SEKE 2012 Proceedings - Knowledge Systems Institute

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static int lapic_suspend(struct sys_device *dev) {
unsigned long flags;
int maxlvt;
if (!apic_pm_state.active)
return 0;
maxlvt = lapic_get_maxlvt();
apic_pm_state.apic_id = apic_read(APIC_ID);
apic_pm_state.apic_taskpri = apic_read(APIC_TASKPRI);
apic_pm_state.apic_ldr = apic_read(APIC_LDR);
apic_pm_state.apic_dfr = apic_read(APIC_DFR);
apic_pm_state.apic_spiv = apic_read(APIC_SPIV);
apic_pm_state.apic_lvtt = apic_read(APIC_LVTT);
if (maxlvt >= 4)
apic_pm_state.apic_lvtpc = apic_read(APIC_LVTPC);
apic_pm_state.apic_lvt0 = apic_read(APIC_LVT0);
apic_pm_state.apic_lvt1 = apic_read(APIC_LVT1);
apic_pm_state.apic_lvterr = apic_read(APIC_LVTERR);
apic_pm_state.apic_tmict = apic_read(APIC_TMICT);
apic_pm_state.apic_tdcr = apic_read(APIC_TDCR);
#ifdef CONFIG_X86_THERMAL_VECTOR
if (maxlvt >= 5)
apic_pm_state.apic_thmr = apic_read(APIC_LVTTHMR);
#endif
local_irq_save(flags);
disable_local_APIC();
if (intr_remapping_enabled)
disable_intr_remapping();
local_irq_restore(flags);
return 0; }
Figure 4. Lapic suspend
void disable_local_APIC(void) {
unsigned int value;
if (!x2apic_mode && !apic_phys)
return;
clear_local_APIC();
value = apic_read(APIC_SPIV);
value &= ~APIC_SPIV_APIC_ENABLED;
apic_write(APIC_SPIV, value);
#ifdef CONFIG_X86_32
if (enabled_via_apicbase) {
unsigned int l, h;
rdmsr(MSR_IA32_APICBASE, l, h);
l &= ~MSR_IA32_APICBASE_ENABLE;
wrmsr(MSR_IA32_APICBASE, l, h); }
#endif }
Figure 5. Disable Local APIC
It is also n ecessary to include a system call between steps
10 and 11 to enable clock interrupts again on the chosen CPU;
otherwise it would become inaccessible to oth er processes
after the execution of the experiment. Figure 6 shows the
necessary code to re-enable clock ticks.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static int lapic_resume(struct sys_device *dev) {
unsigned int l, h;
unsigned long flags;
int maxlvt;
int ret = 0;
struct IO_APIC_route_entry **ioapic_entries = NULL;
if (!apic_pm_state.active)
return 0;
local_irq_save(flags);
if (intr_remapping_enabled) {
ioapic_entries = alloc_ioapic_entries();
if (!ioapic_entries) {
WARN(1, "Alloc ioapiclapic resume failed.");
ret = -ENOMEM;
goto restore; }
ret = save_IO_APIC_setup(ioapic_entries);
if (ret) {
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
WARN(1, "Saving IO-APIC state failed: %d\n", ret);
free_ioapic_entries(ioapic_entries);
goto restore; }
mask_IO_APIC_setup(ioapic_entries);
mask_8259A();
}
if (x2apic_mode)
enable_x2apic();
else {
rdmsr(MSR_IA32_APICBASE, l, h);
l &= ~MSR_IA32_APICBASE_BASE;
l |= MSR_IA32_APICBASE_ENABLE | mp_lapic_addr;
wrmsr(MSR_IA32_APICBASE, l, h); }
maxlvt = lapic_get_maxlvt();
apic_write(APIC_ID, apic_pm_state.apic_id);
apic_write(APIC_DFR, apic_pm_state.apic_dfr);
apic_write(APIC_LDR, apic_pm_state.apic_ldr);
...
apic_write(APIC_TDCR, apic_pm_state.apic_tdcr);
apic_write(APIC_TMICT, apic_pm_state.apic_tmict);
apic_write(APIC_ESR, 0);
apic_read(APIC_ESR);
apic_write(APIC_LVTERR, apic_pm_state.apic_lvterr);
apic_write(APIC_ESR, 0);
apic_read(APIC_ESR);
if (intr_remapping_enabled) {
reenable_intr_remapping(x2apic_mode);
unmask_8259A();
restore_IO_APIC_setup(ioapic_entries);
free_ioapic_entries(ioapic_entries); }
restore:
local_irq_restore(flags);
return ret;
}
Figure 6. Fragment of lapic_resume
The resulted trace af ter running the instrumented system
with clock tick disabling should be compared with the trace
where clock ticks were not disabled, in order to see if the
filtering process th at selected the considered function(s) to
implement clock tick handling was correct. In order to confirm
the correction, that function(s) should not be present in the
new trace.
Another adopted validation step was to verifying the
number of calls to the function(s) that are supposed to be the
one(s) that handle clock ticks using the SystemTap script
shown in Figure 7. A complementary SystemTap script shown
in Figure 8 calculates the duration of the execution of these
respective functions that can indicate some measure of the OS
jitter.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
global var1
probe begin {
var1[0]=0; var1[1]=0; var1[2]=0; var1[3]=0; }
probe kernel.function("").call {
j=cpu();
var1[j]=var1[j]+1;
}
probe end {
printf("ID: %d Count: %d\n",0, var1[0]);
printf("ID: %d Count: %d\n",1, var1[1]);
printf("ID: %d Count: %d\n",2, var1[2]);
printf("ID: %d Count: %d\n",3, var1[3]);
}
Figure 7. Script to verify the number of clock tick handling
177