Skip to contentSkip to conversation

x86/apic: Cleanups and new tests

PATCH New Sean Christopherson 1 participant 10 messages Oct 1, 2022 KVM

lore
Share & tools
lore

Sean Christopherson

author reviewer
#0 lore raw

cover x86/apic: Cleanups and new tests

Clean up the APIC test, add a new config to target AVIC, and add new sub-tests to verify IPI delivery when using logical mode, and when two vCPUs share the same xAPIC ID. In other words, add tests for edge cases that no real world user cares about.

Sean Christopherson (9):
x86/apic: Add test config to allow running apic tests against SVM's
AVIC
x86/apic: Replaces spaces with tabs to fix indentation in apic.c x86/apic: Add helpers to query current APIC state, e.g. xAPIC vs.
x2APIC
x86/apic: Assert that vCPU0's APIC is enabled at the start of the test x86/apic: Restore APIC to original state after every sub-test x86/apic: Enable IRQs on vCPU0 for all tests
x86/apic: Run tests that modify APIC ID and/or APIC_BASE after other
tests
x86/apic: Add test for logical mode IPI delivery (cluster and flat) x86/apic: Add test to verify aliased xAPIC IDs both receive IPI

 lib/x86/processor.h |   1 +
 x86/apic.c          | 940 ++++++++++++++++++++++++++++----------------
 x86/unittests.cfg   |  15 +-
 3 files changed, 615 insertions(+), 341 deletions(-)

base-commit: d8a4f9e5e8d69d4ef257b40d6cd666bd2f63494e

Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#1 lore raw

PATCH 1/9 x86/apic: Add test config to allow running apic tests against SVM's AVIC

Add a curated "xapic" test configuration that hides x2APIC from the guest and does not expose a PIT/8254 timer to the guest so that KVM won't disable AVIC due to incompatibilities.

Set the timeout to '60' as the test is painfully slow when AVIC is enabled.

---
 x86/unittests.cfg | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)
x86/unittests.cfg +14 -1
index ed65185..7600935 100644
@@ -30,18 +30,31 @@ file = apic.flat
 smp = 2
 extra_params = -cpu qemu64,+x2apic,+tsc-deadline -machine kernel_irqchip=split
 arch = x86_64
+groups = apic
 
 [ioapic-split]
 file = ioapic.flat
 extra_params = -cpu qemu64 -machine kernel_irqchip=split
 arch = x86_64
+groups = apic
 
-[apic]
+[x2apic]
 file = apic.flat
 smp = 2
 extra_params = -cpu qemu64,+x2apic,+tsc-deadline
 arch = x86_64
 timeout = 30
+groups = apic
+
+# Hide x2APIC and don't create a Programmable Interval Timer (PIT, a.k.a 8254)
+# to allow testing SVM's AVIC, which is disabled if either is exposed to the guest.
+[xapic]
+file = apic.flat
+smp = 2
+extra_params = -cpu qemu64,-x2apic,+tsc-deadline -machine pit=off
+arch = x86_64
+timeout = 60
+groups = apic
 
 [ioapic]
 file = ioapic.flat
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#2 lore raw

PATCH 2/9 x86/apic: Replaces spaces with tabs to fix indentation in apic.c

In reply to Sean Christopherson

Fix spaces vs. tabs indentation in apic.c to make enhancing the test slightly less painful.

No functional change intended.

---
 x86/apic.c | 661 ++++++++++++++++++++++++++---------------------------
 1 file changed, 327 insertions(+), 334 deletions(-)
x86/apic.c +327 -334
index 23508ad..f038198 100644
@@ -12,11 +12,11 @@
 
 static void test_lapic_existence(void)
 {
-    u8 version;
+	u8 version;
 
-    version = (u8)apic_read(APIC_LVR);
-    printf("apic version: %x\n", version);
-    report(version >= 0x10 && version <= 0x15, "apic existence");
+	version = (u8)apic_read(APIC_LVR);
+	printf("apic version: %x\n", version);
+	report(version >= 0x10 && version <= 0x15, "apic existence");
 }
 
 #define TSC_DEADLINE_TIMER_VECTOR 0xef
@@ -26,313 +26,311 @@ static int tdt_count;
 
 static void tsc_deadline_timer_isr(isr_regs_t *regs)
 {
-    ++tdt_count;
-    eoi();
+	++tdt_count;
+	eoi();
 }
 
 static void __test_tsc_deadline_timer(void)
 {
-    handle_irq(TSC_DEADLINE_TIMER_VECTOR, tsc_deadline_timer_isr);
-    irq_enable();
+	handle_irq(TSC_DEADLINE_TIMER_VECTOR, tsc_deadline_timer_isr);
+	irq_enable();
 
-    wrmsr(MSR_IA32_TSCDEADLINE, rdmsr(MSR_IA32_TSC));
-    asm volatile ("nop");
-    report(tdt_count == 1, "tsc deadline timer");
-    report(rdmsr(MSR_IA32_TSCDEADLINE) == 0, "tsc deadline timer clearing");
+	wrmsr(MSR_IA32_TSCDEADLINE, rdmsr(MSR_IA32_TSC));
+	asm volatile ("nop");
+	report(tdt_count == 1, "tsc deadline timer");
+	report(rdmsr(MSR_IA32_TSCDEADLINE) == 0, "tsc deadline timer clearing");
 }
 
 static int enable_tsc_deadline_timer(void)
 {
-    uint32_t lvtt;
+	uint32_t lvtt;
 
-    if (this_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER)) {
-        lvtt = APIC_LVT_TIMER_TSCDEADLINE | TSC_DEADLINE_TIMER_VECTOR;
-        apic_write(APIC_LVTT, lvtt);
-        return 1;
-    } else {
-        return 0;
-    }
+	if (this_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER)) {
+		lvtt = APIC_LVT_TIMER_TSCDEADLINE | TSC_DEADLINE_TIMER_VECTOR;
+		apic_write(APIC_LVTT, lvtt);
+		return 1;
+	} else {
+		return 0;
+	}
 }
 
 static void test_tsc_deadline_timer(void)
 {
-    if(enable_tsc_deadline_timer()) {
-        __test_tsc_deadline_timer();
-    } else {
-        report_skip("tsc deadline timer not detected");
-    }
+	if(enable_tsc_deadline_timer())
+		__test_tsc_deadline_timer();
+	else
+		report_skip("tsc deadline timer not detected");
 }
 
 static void do_write_apicbase(void *data)
 {
-    wrmsr(MSR_IA32_APICBASE, *(u64 *)data);
+	wrmsr(MSR_IA32_APICBASE, *(u64 *)data);
 }
 
 static bool test_write_apicbase_exception(u64 data)
 {
-    return test_for_exception(GP_VECTOR, do_write_apicbase, &data);
+	return test_for_exception(GP_VECTOR, do_write_apicbase, &data);
 }
 
 static void test_enable_x2apic(void)
 {
-    u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
-    u64 apicbase;
+	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u64 apicbase;
 
-    if (enable_x2apic()) {
-        printf("x2apic enabled\n");
+	if (enable_x2apic()) {
+		printf("x2apic enabled\n");
 
-        apicbase = orig_apicbase & ~(APIC_EN | APIC_EXTD);
-        report(test_write_apicbase_exception(apicbase | APIC_EXTD),
-               "x2apic enabled to invalid state");
-        report(test_write_apicbase_exception(apicbase | APIC_EN),
-               "x2apic enabled to apic enabled");
+		apicbase = orig_apicbase & ~(APIC_EN | APIC_EXTD);
+		report(test_write_apicbase_exception(apicbase | APIC_EXTD),
+			"x2apic enabled to invalid state");
+		report(test_write_apicbase_exception(apicbase | APIC_EN),
+			"x2apic enabled to apic enabled");
 
-        report(!test_write_apicbase_exception(apicbase | 0),
-               "x2apic enabled to disabled state");
-        report(test_write_apicbase_exception(apicbase | APIC_EXTD),
-               "disabled to invalid state");
-        report(test_write_apicbase_exception(apicbase | APIC_EN | APIC_EXTD),
-               "disabled to x2apic enabled");
+		report(!test_write_apicbase_exception(apicbase | 0),
+			"x2apic enabled to disabled state");
+		report(test_write_apicbase_exception(apicbase | APIC_EXTD),
+			"disabled to invalid state");
+		report(test_write_apicbase_exception(apicbase | APIC_EN | APIC_EXTD),
+			"disabled to x2apic enabled");
 
-        report(!test_write_apicbase_exception(apicbase | APIC_EN),
-               "apic disabled to apic enabled");
-        report(test_write_apicbase_exception(apicbase | APIC_EXTD),
-               "apic enabled to invalid state");
+		report(!test_write_apicbase_exception(apicbase | APIC_EN),
+			"apic disabled to apic enabled");
+		report(test_write_apicbase_exception(apicbase | APIC_EXTD),
+			"apic enabled to invalid state");
 
-        if (orig_apicbase & APIC_EXTD)
-            enable_x2apic();
-        else
-            reset_apic();
+		if (orig_apicbase & APIC_EXTD)
+			enable_x2apic();
+		else
+			reset_apic();
 
-        /*
-         * Disabling the APIC resets various APIC registers, restore them to
-         * their desired values.
-         */
-        apic_write(APIC_SPIV, 0x1ff);
-    } else {
-        printf("x2apic not detected\n");
+		/*
+		 * Disabling the APIC resets various APIC registers, restore
+		 * them to their desired values.
+		 */
+		apic_write(APIC_SPIV, 0x1ff);
+	} else {
+		printf("x2apic not detected\n");
 
-        report(test_write_apicbase_exception(APIC_EN | APIC_EXTD),
-               "enable unsupported x2apic");
-    }
+		report(test_write_apicbase_exception(APIC_EN | APIC_EXTD),
+		       "enable unsupported x2apic");
+	}
 }
 
 static void verify_disabled_apic_mmio(void)
 {
-    volatile u32 *lvr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_LVR);
-    volatile u32 *tpr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_TASKPRI);
-    u32 cr8 = read_cr8();
+	volatile u32 *lvr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_LVR);
+	volatile u32 *tpr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_TASKPRI);
+	u32 cr8 = read_cr8();
 
-    memset((void *)APIC_DEFAULT_PHYS_BASE, 0xff, PAGE_SIZE);
-    report(*lvr == ~0, "*0xfee00030: %x", *lvr);
-    report(read_cr8() == cr8, "CR8: %lx", read_cr8());
-    write_cr8(cr8 ^ MAX_TPR);
-    report(read_cr8() == (cr8 ^ MAX_TPR), "CR8: %lx", read_cr8());
-    report(*tpr == ~0, "*0xfee00080: %x", *tpr);
-    write_cr8(cr8);
+	memset((void *)APIC_DEFAULT_PHYS_BASE, 0xff, PAGE_SIZE);
+	report(*lvr == ~0, "*0xfee00030: %x", *lvr);
+	report(read_cr8() == cr8, "CR8: %lx", read_cr8());
+	write_cr8(cr8 ^ MAX_TPR);
+	report(read_cr8() == (cr8 ^ MAX_TPR), "CR8: %lx", read_cr8());
+	report(*tpr == ~0, "*0xfee00080: %x", *tpr);
+	write_cr8(cr8);
 }
 
 static void test_apic_disable(void)
 {
-    volatile u32 *lvr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_LVR);
-    volatile u32 *tpr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_TASKPRI);
-    u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
-    u32 apic_version = apic_read(APIC_LVR);
-    u32 cr8 = read_cr8();
-
-    report_prefix_push("apic_disable");
-    assert_msg(orig_apicbase & APIC_EN, "APIC not enabled.");
-
-    disable_apic();
-    report(!(rdmsr(MSR_IA32_APICBASE) & APIC_EN), "Local apic disabled");
-    report(!this_cpu_has(X86_FEATURE_APIC),
-           "CPUID.1H:EDX.APIC[bit 9] is clear");
-    verify_disabled_apic_mmio();
-
-    reset_apic();
-    report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
-           "Local apic enabled in xAPIC mode");
-    report(this_cpu_has(X86_FEATURE_APIC), "CPUID.1H:EDX.APIC[bit 9] is set");
-    report(*lvr == apic_version, "*0xfee00030: %x", *lvr);
-    report(*tpr == cr8, "*0xfee00080: %x", *tpr);
-    write_cr8(cr8 ^ MAX_TPR);
-    report(*tpr == (cr8 ^ MAX_TPR) << 4, "*0xfee00080: %x", *tpr);
-    write_cr8(cr8);
-
-    if (enable_x2apic()) {
-	apic_write(APIC_SPIV, 0x1ff);
-	report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD),
-               "Local apic enabled in x2APIC mode");
-	report(this_cpu_has(X86_FEATURE_APIC),
-               "CPUID.1H:EDX.APIC[bit 9] is set");
+	volatile u32 *lvr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_LVR);
+	volatile u32 *tpr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_TASKPRI);
+	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u32 apic_version = apic_read(APIC_LVR);
+	u32 cr8 = read_cr8();
+
+	report_prefix_push("apic_disable");
+	assert_msg(orig_apicbase & APIC_EN, "APIC not enabled.");
+
+	disable_apic();
+	report(!(rdmsr(MSR_IA32_APICBASE) & APIC_EN), "Local apic disabled");
+	report(!this_cpu_has(X86_FEATURE_APIC),
+	       "CPUID.1H:EDX.APIC[bit 9] is clear");
 	verify_disabled_apic_mmio();
-	if (!(orig_apicbase & APIC_EXTD))
-	    reset_apic();
-    }
-    report_prefix_pop();
+
+	reset_apic();
+	report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
+	       "Local apic enabled in xAPIC mode");
+	report(this_cpu_has(X86_FEATURE_APIC), "CPUID.1H:EDX.APIC[bit 9] is set");
+	report(*lvr == apic_version, "*0xfee00030: %x", *lvr);
+	report(*tpr == cr8, "*0xfee00080: %x", *tpr);
+	write_cr8(cr8 ^ MAX_TPR);
+	report(*tpr == (cr8 ^ MAX_TPR) << 4, "*0xfee00080: %x", *tpr);
+	write_cr8(cr8);
+
+	if (enable_x2apic()) {
+		apic_write(APIC_SPIV, 0x1ff);
+		report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD),
+		       "Local apic enabled in x2APIC mode");
+		report(this_cpu_has(X86_FEATURE_APIC),
+		       "CPUID.1H:EDX.APIC[bit 9] is set");
+		verify_disabled_apic_mmio();
+		if (!(orig_apicbase & APIC_EXTD))
+			reset_apic();
+	}
+	report_prefix_pop();
 }
 
 #define ALTERNATE_APIC_BASE	0xfed40000
 
 static void test_apicbase(void)
 {
-    u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
-    u32 lvr = apic_read(APIC_LVR);
-    u64 value;
+	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u32 lvr = apic_read(APIC_LVR);
+	u64 value;
 
-    wrmsr(MSR_IA32_APICBASE, orig_apicbase & ~(APIC_EN | APIC_EXTD));
-    wrmsr(MSR_IA32_APICBASE, ALTERNATE_APIC_BASE | APIC_BSP | APIC_EN);
+	wrmsr(MSR_IA32_APICBASE, orig_apicbase & ~(APIC_EN | APIC_EXTD));
+	wrmsr(MSR_IA32_APICBASE, ALTERNATE_APIC_BASE | APIC_BSP | APIC_EN);
 
-    report_prefix_push("apicbase");
+	report_prefix_push("apicbase");
 
-    report(*(volatile u32 *)(ALTERNATE_APIC_BASE + APIC_LVR) == lvr,
-           "relocate apic");
+	report(*(volatile u32 *)(ALTERNATE_APIC_BASE + APIC_LVR) == lvr,
+	       "relocate apic");
 
-    value = orig_apicbase | (1UL << cpuid_maxphyaddr());
-    report(test_for_exception(GP_VECTOR, do_write_apicbase, &value),
-           "reserved physaddr bits");
+	value = orig_apicbase | (1UL << cpuid_maxphyaddr());
+	report(test_for_exception(GP_VECTOR, do_write_apicbase, &value),
+	       "reserved physaddr bits");
 
-    value = orig_apicbase | 1;
-    report(test_for_exception(GP_VECTOR, do_write_apicbase, &value),
-           "reserved low bits");
+	value = orig_apicbase | 1;
+	report(test_for_exception(GP_VECTOR, do_write_apicbase, &value),
+	       "reserved low bits");
 
-    wrmsr(MSR_IA32_APICBASE, orig_apicbase);
-    apic_write(APIC_SPIV, 0x1ff);
+	wrmsr(MSR_IA32_APICBASE, orig_apicbase);
+	apic_write(APIC_SPIV, 0x1ff);
 
-    report_prefix_pop();
+	report_prefix_pop();
 }
 
 static void do_write_apic_id(void *id)
 {
-    apic_write(APIC_ID, *(u32 *)id);
+	apic_write(APIC_ID, *(u32 *)id);
 }
 
 static void __test_apic_id(void * unused)
 {
-    u32 id, newid;
-    u8  initial_xapic_id = cpuid(1).b >> 24;
-    u32 initial_x2apic_id = cpuid(0xb).d;
-    bool x2apic_mode = rdmsr(MSR_IA32_APICBASE) & APIC_EXTD;
+	u32 id, newid;
+	u8  initial_xapic_id = cpuid(1).b >> 24;
+	u32 initial_x2apic_id = cpuid(0xb).d;
+	bool x2apic_mode = rdmsr(MSR_IA32_APICBASE) & APIC_EXTD;
 
-    if (x2apic_mode)
-        reset_apic();
+	if (x2apic_mode)
+		reset_apic();
 
-    id = apic_id();
-    report(initial_xapic_id == id, "xapic id matches cpuid");
+	id = apic_id();
+	report(initial_xapic_id == id, "xapic id matches cpuid");
 
-    newid = (id + 1) << 24;
-    report(!test_for_exception(GP_VECTOR, do_write_apic_id, &newid) &&
-           (id == apic_id() || id + 1 == apic_id()),
-           "writeable xapic id");
+	newid = (id + 1) << 24;
+	report(!test_for_exception(GP_VECTOR, do_write_apic_id, &newid) &&
+	       (id == apic_id() || id + 1 == apic_id()),
+	       "writeable xapic id");
 
-    if (!enable_x2apic())
-        goto out;
+	if (!enable_x2apic())
+		goto out;
 
-    report(test_for_exception(GP_VECTOR, do_write_apic_id, &newid),
-           "non-writeable x2apic id");
-    report(initial_xapic_id == (apic_id() & 0xff), "sane x2apic id");
+	report(test_for_exception(GP_VECTOR, do_write_apic_id, &newid),
+	       "non-writeable x2apic id");
+	report(initial_xapic_id == (apic_id() & 0xff), "sane x2apic id");
 
-    /* old QEMUs do not set initial x2APIC ID */
-    report(initial_xapic_id == (initial_x2apic_id & 0xff) && 
-           initial_x2apic_id == apic_id(),
-           "x2apic id matches cpuid");
+	/* old QEMUs do not set initial x2APIC ID */
+	report(initial_xapic_id == (initial_x2apic_id & 0xff) && 
+	       initial_x2apic_id == apic_id(),
+	       "x2apic id matches cpuid");
 
 out:
-    reset_apic();
+	reset_apic();
 
-    report(initial_xapic_id == apic_id(), "correct xapic id after reset");
+	report(initial_xapic_id == apic_id(), "correct xapic id after reset");
 
-    /* old KVMs do not reset xAPIC ID */
-    if (id != apic_id())
-        apic_write(APIC_ID, id << 24);
+	/* old KVMs do not reset xAPIC ID */
+	if (id != apic_id())
+		apic_write(APIC_ID, id << 24);
 
-    if (x2apic_mode)
-        enable_x2apic();
+	if (x2apic_mode)
+		enable_x2apic();
 }
 
 static void test_apic_id(void)
 {
-    if (cpu_count() < 2)
-        return;
+	if (cpu_count() < 2)
+		return;
 
-    on_cpu(1, __test_apic_id, NULL);
+	on_cpu(1, __test_apic_id, NULL);
 }
 
 static int ipi_count;
 
 static void self_ipi_isr(isr_regs_t *regs)
 {
-    ++ipi_count;
-    eoi();
+	++ipi_count;
+	eoi();
 }
 
 static void __test_self_ipi(void)
 {
-    u64 start = rdtsc();
-    int vec = 0xf1;
+	u64 start = rdtsc();
+	int vec = 0xf1;
 
-    handle_irq(vec, self_ipi_isr);
-    irq_enable();
-    apic_icr_write(APIC_DEST_SELF | APIC_DEST_PHYSICAL | APIC_DM_FIXED | vec,
-                   id_map[0]);
+	handle_irq(vec, self_ipi_isr);
+	irq_enable();
+	apic_icr_write(APIC_DEST_SELF | APIC_DEST_PHYSICAL | APIC_DM_FIXED | vec,
+		       id_map[0]);
 
-    do {
-        pause();
-    } while (rdtsc() - start < 1000000000 && ipi_count == 0);
+	do {
+		pause();
+	} while (rdtsc() - start < 1000000000 && ipi_count == 0);
 }
 
 static void test_self_ipi_xapic(void)
 {
-    u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
 
-    report_prefix_push("self_ipi_xapic");
+	report_prefix_push("self_ipi_xapic");
 
-    /* Reset to xAPIC mode. */
-    reset_apic();
-    report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
-           "Local apic enabled in xAPIC mode");
+	/* Reset to xAPIC mode. */
+	reset_apic();
+	report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
+	       "Local apic enabled in xAPIC mode");
 
-    ipi_count = 0;
-    __test_self_ipi();
-    report(ipi_count == 1, "self ipi");
+	ipi_count = 0;
+	__test_self_ipi();
+	report(ipi_count == 1, "self ipi");
 
-    /* Enable x2APIC mode if it was already enabled. */
-    if (orig_apicbase & APIC_EXTD)
-        enable_x2apic();
+	/* Enable x2APIC mode if it was already enabled. */
+	if (orig_apicbase & APIC_EXTD)
+		enable_x2apic();
 
-    report_prefix_pop();
+	report_prefix_pop();
 }
 
 static void test_self_ipi_x2apic(void)
 {
-    u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
 
-    report_prefix_push("self_ipi_x2apic");
+	report_prefix_push("self_ipi_x2apic");
 
-    if (enable_x2apic()) {
-        report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) ==
-               (APIC_EN | APIC_EXTD),
-               "Local apic enabled in x2APIC mode");
+	if (enable_x2apic()) {
+		report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD),
+			"Local apic enabled in x2APIC mode");
 
-        ipi_count = 0;
-        __test_self_ipi();
-        report(ipi_count == 1, "self ipi");
+		ipi_count = 0;
+		__test_self_ipi();
+		report(ipi_count == 1, "self ipi");
 
-        /* Reset to xAPIC mode unless x2APIC was already enabled. */
-        if (!(orig_apicbase & APIC_EXTD))
-            reset_apic();
-    } else {
-        report_skip("x2apic not detected");
-    }
+		/* Reset to xAPIC mode unless x2APIC was already enabled. */
+		if (!(orig_apicbase & APIC_EXTD))
+			reset_apic();
+	} else {
+		report_skip("x2apic not detected");
+	}
 
-    report_prefix_pop();
+	report_prefix_pop();
 }
 
 volatile int nmi_counter_private, nmi_counter, nmi_hlt_counter, sti_loop_active;
 
 static void sti_nop(char *p)
 {
-    asm volatile (
+	asm volatile (
 		  ".globl post_sti \n\t"
 		  "sti \n"
 		  /*
@@ -344,47 +342,44 @@ static void sti_nop(char *p)
 		  "cli"
 		  : : "m"(*p)
 		  );
-    nmi_counter = nmi_counter_private;
+	nmi_counter = nmi_counter_private;
 }
 
 static void sti_loop(void *ignore)
 {
-    unsigned k = 0;
+	unsigned k = 0;
 
-    while (sti_loop_active) {
-	sti_nop((char *)(ulong)((k++ * 4096) % (128 * 1024 * 1024)));
-    }
+	while (sti_loop_active)
+		sti_nop((char *)(ulong)((k++ * 4096) % (128 * 1024 * 1024)));
 }
 
 static void nmi_handler(isr_regs_t *regs)
 {
-    extern void post_sti(void);
-    ++nmi_counter_private;
-    nmi_hlt_counter += regs->rip == (ulong)post_sti;
+	extern void post_sti(void);
+	++nmi_counter_private;
+	nmi_hlt_counter += regs->rip == (ulong)post_sti;
 }
 
 static void test_sti_nmi(void)
 {
-    unsigned old_counter;
+	unsigned old_counter;
 
-    if (cpu_count() < 2) {
-	return;
-    }
+	if (cpu_count() < 2)
+		return;
 
-    handle_irq(2, nmi_handler);
-    on_cpu(1, update_cr3, (void *)read_cr3());
+	handle_irq(2, nmi_handler);
+	on_cpu(1, update_cr3, (void *)read_cr3());
 
-    sti_loop_active = 1;
-    on_cpu_async(1, sti_loop, 0);
-    while (nmi_counter < 30000) {
-	old_counter = nmi_counter;
-	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[1]);
-	while (nmi_counter == old_counter) {
-	    ;
+	sti_loop_active = 1;
+	on_cpu_async(1, sti_loop, 0);
+	while (nmi_counter < 30000) {
+		old_counter = nmi_counter;
+		apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[1]);
+		while (nmi_counter == old_counter)
+			;
 	}
-    }
-    sti_loop_active = 0;
-    report(nmi_hlt_counter == 0, "nmi-after-sti");
+	sti_loop_active = 0;
+	report(nmi_hlt_counter == 0, "nmi-after-sti");
 }
 
 static volatile bool nmi_done, nmi_flushed;
@@ -394,140 +389,138 @@ static volatile int cpu0_nmi_ctr2, cpu1_nmi_ctr2;
 
 static void multiple_nmi_handler(isr_regs_t *regs)
 {
-    ++nmi_received;
+	++nmi_received;
 }
 
 static void kick_me_nmi(void *blah)
 {
-    while (!nmi_done) {
-	++cpu1_nmi_ctr1;
-	while (cpu1_nmi_ctr1 != cpu0_nmi_ctr1 && !nmi_done) {
-	    pause();
+	while (!nmi_done) {
+		++cpu1_nmi_ctr1;
+		while (cpu1_nmi_ctr1 != cpu0_nmi_ctr1 && !nmi_done)
+			pause();
+
+		if (nmi_done)
+			return;
+
+		apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[0]);
+		/* make sure the NMI has arrived by sending an IPI after it */
+		apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_FIXED | APIC_INT_ASSERT
+				| 0x44, id_map[0]);
+		++cpu1_nmi_ctr2;
+		while (cpu1_nmi_ctr2 != cpu0_nmi_ctr2 && !nmi_done)
+			pause();
 	}
-	if (nmi_done) {
-	    return;
-	}
-	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[0]);
-	/* make sure the NMI has arrived by sending an IPI after it */
-	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_FIXED | APIC_INT_ASSERT
-		       | 0x44, id_map[0]);
-	++cpu1_nmi_ctr2;
-	while (cpu1_nmi_ctr2 != cpu0_nmi_ctr2 && !nmi_done) {
-	    pause();
-	}
-    }
 }
 
 static void flush_nmi(isr_regs_t *regs)
 {
-    nmi_flushed = true;
-    apic_write(APIC_EOI, 0);
+	nmi_flushed = true;
+	apic_write(APIC_EOI, 0);
 }
 
 static void test_multiple_nmi(void)
 {
-    int i;
-    bool ok = true;
+	int i;
+	bool ok = true;
 
-    if (cpu_count() < 2) {
-	return;
-    }
+	if (cpu_count() < 2)
+		return;
 
-    sti();
-    handle_irq(2, multiple_nmi_handler);
-    handle_irq(0x44, flush_nmi);
-    on_cpu_async(1, kick_me_nmi, 0);
-    for (i = 0; i < 100000; ++i) {
-	nmi_flushed = false;
-	nmi_received = 0;
-	++cpu0_nmi_ctr1;
-	while (cpu1_nmi_ctr1 != cpu0_nmi_ctr1) {
-	    pause();
-	}
-	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[0]);
-	while (!nmi_flushed) {
-	    pause();
-	}
-	if (nmi_received != 2) {
-	    ok = false;
-	    break;
-	}
-	++cpu0_nmi_ctr2;
-	while (cpu1_nmi_ctr2 != cpu0_nmi_ctr2) {
-	    pause();
+	sti();
+	handle_irq(2, multiple_nmi_handler);
+	handle_irq(0x44, flush_nmi);
+	on_cpu_async(1, kick_me_nmi, 0);
+	for (i = 0; i < 100000; ++i) {
+		nmi_flushed = false;
+		nmi_received = 0;
+		++cpu0_nmi_ctr1;
+		while (cpu1_nmi_ctr1 != cpu0_nmi_ctr1)
+			pause();
+
+		apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI | APIC_INT_ASSERT, id_map[0]);
+		while (!nmi_flushed)
+			pause();
+
+		if (nmi_received != 2) {
+			ok = false;
+			break;
+		}
+
+		++cpu0_nmi_ctr2;
+		while (cpu1_nmi_ctr2 != cpu0_nmi_ctr2)
+			pause();
 	}
-    }
-    nmi_done = true;
-    report(ok, "multiple nmi");
+	nmi_done = true;
+	report(ok, "multiple nmi");
 }
 
 static void pending_nmi_handler(isr_regs_t *regs)
 {
-    int i;
+	int i;
 
-    if (++nmi_received == 1) {
-        for (i = 0; i < 10; ++i)
-            apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI, 0);
-    }
+	if (++nmi_received == 1) {
+		for (i = 0; i < 10; ++i)
+			apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI, 0);
+	}
 }
 
 static void test_pending_nmi(void)
 {
-    int i;
+	int i;
 
-    handle_irq(2, pending_nmi_handler);
-    for (i = 0; i < 100000; ++i) {
-	    nmi_received = 0;
+	handle_irq(2, pending_nmi_handler);
+	for (i = 0; i < 100000; ++i) {
+		nmi_received = 0;
 
-        apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI, 0);
-        while (nmi_received < 2)
-            pause();
+		apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_NMI, 0);
+		while (nmi_received < 2)
+			pause();
 
-        if (nmi_received != 2)
-            break;
-    }
-    report(nmi_received == 2, "pending nmi");
+		if (nmi_received != 2)
+			break;
+	}
+	report(nmi_received == 2, "pending nmi");
 }
 
 static volatile int lvtt_counter = 0;
 
 static void lvtt_handler(isr_regs_t *regs)
 {
-    lvtt_counter++;
-    eoi();
+	lvtt_counter++;
+	eoi();
 }
 
 static void test_apic_timer_one_shot(void)
 {
-    uint64_t tsc1, tsc2;
-    static const uint32_t interval = 0x10000;
+	uint64_t tsc1, tsc2;
+	static const uint32_t interval = 0x10000;
 
 #define APIC_LVT_TIMER_VECTOR    (0xee)
 
-    handle_irq(APIC_LVT_TIMER_VECTOR, lvtt_handler);
-    irq_enable();
+	handle_irq(APIC_LVT_TIMER_VECTOR, lvtt_handler);
+	irq_enable();
 
-    /* One shot mode */
-    apic_write(APIC_LVTT, APIC_LVT_TIMER_ONESHOT |
-               APIC_LVT_TIMER_VECTOR);
-    /* Divider == 1 */
-    apic_write(APIC_TDCR, 0x0000000b);
+	/* One shot mode */
+	apic_write(APIC_LVTT, APIC_LVT_TIMER_ONESHOT |
+		   APIC_LVT_TIMER_VECTOR);
+	/* Divider == 1 */
+	apic_write(APIC_TDCR, 0x0000000b);
 
-    tsc1 = rdtsc();
-    /* Set "Initial Counter Register", which starts the timer */
-    apic_write(APIC_TMICT, interval);
-    while (!lvtt_counter);
-    tsc2 = rdtsc();
+	tsc1 = rdtsc();
+	/* Set "Initial Counter Register", which starts the timer */
+	apic_write(APIC_TMICT, interval);
+	while (!lvtt_counter);
+	tsc2 = rdtsc();
 
-    /*
-     * For LVT Timer clock, SDM vol 3 10.5.4 says it should be
-     * derived from processor's bus clock (IIUC which is the same
-     * as TSC), however QEMU seems to be using nanosecond. In all
-     * cases, the following should satisfy on all modern
-     * processors.
-     */
-    report((lvtt_counter == 1) && (tsc2 - tsc1 >= interval),
-           "APIC LVT timer one shot");
+	/*
+	 * For LVT Timer clock, SDM vol 3 10.5.4 says it should be
+	 * derived from processor's bus clock (IIUC which is the same
+	 * as TSC), however QEMU seems to be using nanosecond. In all
+	 * cases, the following should satisfy on all modern
+	 * processors.
+	 */
+	report((lvtt_counter == 1) && (tsc2 - tsc1 >= interval),
+	       "APIC LVT timer one shot");
 }
 
 static atomic_t broadcast_counter;
@@ -567,11 +560,11 @@ static void test_physical_broadcast(void)
 
 	printf("starting broadcast (%s)\n", enable_x2apic() ? "x2apic" : "xapic");
 	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_FIXED | APIC_INT_ASSERT |
-			BROADCAST_VECTOR, broadcast_address);
+		       BROADCAST_VECTOR, broadcast_address);
 	report(broadcast_received(ncpus), "APIC physical broadcast address");
 
 	apic_icr_write(APIC_DEST_PHYSICAL | APIC_DM_FIXED | APIC_INT_ASSERT |
-			BROADCAST_VECTOR | APIC_DEST_ALLINC, 0);
+		       BROADCAST_VECTOR | APIC_DEST_ALLINC, 0);
 	report(broadcast_received(ncpus), "APIC physical broadcast shorthand");
 }
 
@@ -678,38 +671,38 @@ static void test_apic_change_mode(void)
 
 static void test_pv_ipi(void)
 {
-    int ret;
-    unsigned long a0 = 0xFFFFFFFF, a1 = 0, a2 = 0xFFFFFFFF, a3 = 0x0;
+	int ret;
+	unsigned long a0 = 0xFFFFFFFF, a1 = 0, a2 = 0xFFFFFFFF, a3 = 0x0;
 
-    asm volatile("vmcall" : "=a"(ret) :"a"(KVM_HC_SEND_IPI), "b"(a0), "c"(a1), "d"(a2), "S"(a3));
-    report(!ret, "PV IPIs testing");
+	asm volatile("vmcall" : "=a"(ret) :"a"(KVM_HC_SEND_IPI), "b"(a0), "c"(a1), "d"(a2), "S"(a3));
+	report(!ret, "PV IPIs testing");
 }
 
 int main(void)
 {
-    setup_vm();
+	setup_vm();
 
-    test_lapic_existence();
+	test_lapic_existence();
 
-    mask_pic_interrupts();
-    test_apic_id();
-    test_apic_disable();
-    test_enable_x2apic();
-    test_apicbase();
+	mask_pic_interrupts();
+	test_apic_id();
+	test_apic_disable();
+	test_enable_x2apic();
+	test_apicbase();
 
-    test_self_ipi_xapic();
-    test_self_ipi_x2apic();
-    test_physical_broadcast();
-    if (test_device_enabled())
-        test_pv_ipi();
+	test_self_ipi_xapic();
+	test_self_ipi_x2apic();
+	test_physical_broadcast();
+	if (test_device_enabled())
+		test_pv_ipi();
 
-    test_sti_nmi();
-    test_multiple_nmi();
-    test_pending_nmi();
+	test_sti_nmi();
+	test_multiple_nmi();
+	test_pending_nmi();
 
-    test_apic_timer_one_shot();
-    test_apic_change_mode();
-    test_tsc_deadline_timer();
+	test_apic_timer_one_shot();
+	test_apic_change_mode();
+	test_tsc_deadline_timer();
 
-    return report_summary();
+	return report_summary();
 }
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#3 lore raw

PATCH 3/9 x86/apic: Add helpers to query current APIC state, e.g. xAPIC vs. x2APIC

In reply to Sean Christopherson

Add helpers to query APIC state and use them to replace a bunch of open coded instances.

No functional change intended.

---
 x86/apic.c | 39 +++++++++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 14 deletions(-)
x86/apic.c +25 -14
index f038198..650c1d0 100644
@@ -10,6 +10,21 @@
 
 #define MAX_TPR			0xf
 
+static bool is_apic_hw_enabled(void)
+{
+	return rdmsr(MSR_IA32_APICBASE) & APIC_EN;
+}
+
+static bool is_x2apic_enabled(void)
+{
+	return (rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD);
+}
+
+static bool is_xapic_enabled(void)
+{
+	return (rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN;
+}
+
 static void test_lapic_existence(void)
 {
 	u8 version;
@@ -143,14 +158,13 @@ static void test_apic_disable(void)
 	assert_msg(orig_apicbase & APIC_EN, "APIC not enabled.");
 
 	disable_apic();
-	report(!(rdmsr(MSR_IA32_APICBASE) & APIC_EN), "Local apic disabled");
+	report(!is_apic_hw_enabled(), "Local apic disabled");
 	report(!this_cpu_has(X86_FEATURE_APIC),
 	       "CPUID.1H:EDX.APIC[bit 9] is clear");
 	verify_disabled_apic_mmio();
 
 	reset_apic();
-	report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
-	       "Local apic enabled in xAPIC mode");
+	report(is_xapic_enabled(), "Local apic enabled in xAPIC mode");
 	report(this_cpu_has(X86_FEATURE_APIC), "CPUID.1H:EDX.APIC[bit 9] is set");
 	report(*lvr == apic_version, "*0xfee00030: %x", *lvr);
 	report(*tpr == cr8, "*0xfee00080: %x", *tpr);
@@ -160,8 +174,7 @@ static void test_apic_disable(void)
 
 	if (enable_x2apic()) {
 		apic_write(APIC_SPIV, 0x1ff);
-		report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD),
-		       "Local apic enabled in x2APIC mode");
+		report(is_x2apic_enabled(), "Local apic enabled in x2APIC mode");
 		report(this_cpu_has(X86_FEATURE_APIC),
 		       "CPUID.1H:EDX.APIC[bit 9] is set");
 		verify_disabled_apic_mmio();
@@ -211,7 +224,7 @@ static void __test_apic_id(void * unused)
 	u32 id, newid;
 	u8  initial_xapic_id = cpuid(1).b >> 24;
 	u32 initial_x2apic_id = cpuid(0xb).d;
-	bool x2apic_mode = rdmsr(MSR_IA32_APICBASE) & APIC_EXTD;
+	bool x2apic_mode = is_x2apic_enabled();
 
 	if (x2apic_mode)
 		reset_apic();
@@ -282,21 +295,20 @@ static void __test_self_ipi(void)
 
 static void test_self_ipi_xapic(void)
 {
-	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u64 was_x2apic = is_x2apic_enabled();
 
 	report_prefix_push("self_ipi_xapic");
 
 	/* Reset to xAPIC mode. */
 	reset_apic();
-	report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == APIC_EN,
-	       "Local apic enabled in xAPIC mode");
+	report(is_xapic_enabled(), "Local apic enabled in xAPIC mode");
 
 	ipi_count = 0;
 	__test_self_ipi();
 	report(ipi_count == 1, "self ipi");
 
 	/* Enable x2APIC mode if it was already enabled. */
-	if (orig_apicbase & APIC_EXTD)
+	if (was_x2apic)
 		enable_x2apic();
 
 	report_prefix_pop();
@@ -304,20 +316,19 @@ static void test_self_ipi_xapic(void)
 
 static void test_self_ipi_x2apic(void)
 {
-	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
+	u64 was_xapic = is_xapic_enabled();
 
 	report_prefix_push("self_ipi_x2apic");
 
 	if (enable_x2apic()) {
-		report((rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD),
-			"Local apic enabled in x2APIC mode");
+		report(is_x2apic_enabled(), "Local apic enabled in x2APIC mode");
 
 		ipi_count = 0;
 		__test_self_ipi();
 		report(ipi_count == 1, "self ipi");
 
 		/* Reset to xAPIC mode unless x2APIC was already enabled. */
-		if (!(orig_apicbase & APIC_EXTD))
+		if (was_xapic)
 			reset_apic();
 	} else {
 		report_skip("x2apic not detected");
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#4 lore raw

PATCH 4/9 x86/apic: Assert that vCPU0's APIC is enabled at the start of the test

In reply to Sean Christopherson

Assert that vCPU's APIC is fully enabled at the start of the apic test. The boot code is supposed to do that, but nothing ever actually verifies the APIC got setup correctly.

---
 x86/apic.c | 8 ++++++++
 1 file changed, 8 insertions(+)
x86/apic.c +8 -0
index 650c1d0..6c555ce 100644
@@ -15,6 +15,11 @@ static bool is_apic_hw_enabled(void)
 	return rdmsr(MSR_IA32_APICBASE) & APIC_EN;
 }
 
+static bool is_apic_sw_enabled(void)
+{
+	return apic_read(APIC_SPIV) & APIC_SPIV_APIC_ENABLED;
+}
+
 static bool is_x2apic_enabled(void)
 {
 	return (rdmsr(MSR_IA32_APICBASE) & (APIC_EN | APIC_EXTD)) == (APIC_EN | APIC_EXTD);
@@ -691,6 +696,9 @@ static void test_pv_ipi(void)
 
 int main(void)
 {
+	assert_msg(is_apic_hw_enabled() && is_apic_sw_enabled(),
+		   "APIC should be fully enabled by startup code.");
+
 	setup_vm();
 
 	test_lapic_existence();
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#5 lore raw

PATCH 5/9 x86/apic: Restore APIC to original state after every sub-test

In reply to Sean Christopherson

Restore the APIC to its original state after every APIC sub-test. Many of the tests already do (parts of) this manually, while others do not. Always restore to dedup code and to avoid cross-test dependencies.

---
 x86/apic.c | 92 +++++++++++++++++++++++++-----------------------------
 1 file changed, 43 insertions(+), 49 deletions(-)
x86/apic.c +43 -49
index 6c555ce..e466a57 100644
@@ -94,13 +94,12 @@ static bool test_write_apicbase_exception(u64 data)
 
 static void test_enable_x2apic(void)
 {
-	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
-	u64 apicbase;
+	u64 apicbase = rdmsr(MSR_IA32_APICBASE);
 
 	if (enable_x2apic()) {
 		printf("x2apic enabled\n");
 
-		apicbase = orig_apicbase & ~(APIC_EN | APIC_EXTD);
+		apicbase &= ~(APIC_EN | APIC_EXTD);
 		report(test_write_apicbase_exception(apicbase | APIC_EXTD),
 			"x2apic enabled to invalid state");
 		report(test_write_apicbase_exception(apicbase | APIC_EN),
@@ -117,17 +116,6 @@ static void test_enable_x2apic(void)
 			"apic disabled to apic enabled");
 		report(test_write_apicbase_exception(apicbase | APIC_EXTD),
 			"apic enabled to invalid state");
-
-		if (orig_apicbase & APIC_EXTD)
-			enable_x2apic();
-		else
-			reset_apic();
-
-		/*
-		 * Disabling the APIC resets various APIC registers, restore
-		 * them to their desired values.
-		 */
-		apic_write(APIC_SPIV, 0x1ff);
 	} else {
 		printf("x2apic not detected\n");
 
@@ -155,12 +143,10 @@ static void test_apic_disable(void)
 {
 	volatile u32 *lvr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_LVR);
 	volatile u32 *tpr = (volatile u32 *)(APIC_DEFAULT_PHYS_BASE + APIC_TASKPRI);
-	u64 orig_apicbase = rdmsr(MSR_IA32_APICBASE);
 	u32 apic_version = apic_read(APIC_LVR);
 	u32 cr8 = read_cr8();
 
 	report_prefix_push("apic_disable");
-	assert_msg(orig_apicbase & APIC_EN, "APIC not enabled.");
 
 	disable_apic();
 	report(!is_apic_hw_enabled(), "Local apic disabled");
@@ -178,13 +164,10 @@ static void test_apic_disable(void)
 	write_cr8(cr8);
 
 	if (enable_x2apic()) {
-		apic_write(APIC_SPIV, 0x1ff);
 		report(is_x2apic_enabled(), "Local apic enabled in x2APIC mode");
 		report(this_cpu_has(X86_FEATURE_APIC),
 		       "CPUID.1H:EDX.APIC[bit 9] is set");
 		verify_disabled_apic_mmio();
-		if (!(orig_apicbase & APIC_EXTD))
-			reset_apic();
 	}
 	report_prefix_pop();
 }
@@ -213,8 +196,8 @@ static void test_apicbase(void)
 	report(test_for_exception(GP_VECTOR, do_write_apicbase, &value),
 	       "reserved low bits");
 
+	/* Restore the APIC address, the "reset" helpers leave it as is. */
 	wrmsr(MSR_IA32_APICBASE, orig_apicbase);
-	apic_write(APIC_SPIV, 0x1ff);
 
 	report_prefix_pop();
 }
@@ -300,8 +283,6 @@ static void __test_self_ipi(void)
 
 static void test_self_ipi_xapic(void)
 {
-	u64 was_x2apic = is_x2apic_enabled();
-
 	report_prefix_push("self_ipi_xapic");
 
 	/* Reset to xAPIC mode. */
@@ -312,17 +293,11 @@ static void test_self_ipi_xapic(void)
 	__test_self_ipi();
 	report(ipi_count == 1, "self ipi");
 
-	/* Enable x2APIC mode if it was already enabled. */
-	if (was_x2apic)
-		enable_x2apic();
-
 	report_prefix_pop();
 }
 
 static void test_self_ipi_x2apic(void)
 {
-	u64 was_xapic = is_xapic_enabled();
-
 	report_prefix_push("self_ipi_x2apic");
 
 	if (enable_x2apic()) {
@@ -331,10 +306,6 @@ static void test_self_ipi_x2apic(void)
 		ipi_count = 0;
 		__test_self_ipi();
 		report(ipi_count == 1, "self ipi");
-
-		/* Reset to xAPIC mode unless x2APIC was already enabled. */
-		if (was_xapic)
-			reset_apic();
 	} else {
 		report_skip("x2apic not detected");
 	}
@@ -690,38 +661,61 @@ static void test_pv_ipi(void)
 	int ret;
 	unsigned long a0 = 0xFFFFFFFF, a1 = 0, a2 = 0xFFFFFFFF, a3 = 0x0;
 
+	if (!test_device_enabled())
+		return;
+
 	asm volatile("vmcall" : "=a"(ret) :"a"(KVM_HC_SEND_IPI), "b"(a0), "c"(a1), "d"(a2), "S"(a3));
 	report(!ret, "PV IPIs testing");
 }
 
+typedef void (*apic_test_fn)(void);
+
 int main(void)
 {
+	bool is_x2apic = is_x2apic_enabled();
+	u32 spiv = apic_read(APIC_SPIV);
+	int i;
+
+	const apic_test_fn tests[] = {
+		test_lapic_existence,
+
+		test_apic_id,
+		test_apic_disable,
+		test_enable_x2apic,
+		test_apicbase,
+
+		test_self_ipi_xapic,
+		test_self_ipi_x2apic,
+		test_physical_broadcast,
+
+		test_pv_ipi,
+
+		test_sti_nmi,
+		test_multiple_nmi,
+		test_pending_nmi,
+
+		test_apic_timer_one_shot,
+		test_apic_change_mode,
+		test_tsc_deadline_timer,
+	};
+
 	assert_msg(is_apic_hw_enabled() && is_apic_sw_enabled(),
 		   "APIC should be fully enabled by startup code.");
 
 	setup_vm();
 
-	test_lapic_existence();
-
 	mask_pic_interrupts();
-	test_apic_id();
-	test_apic_disable();
-	test_enable_x2apic();
-	test_apicbase();
 
-	test_self_ipi_xapic();
-	test_self_ipi_x2apic();
-	test_physical_broadcast();
-	if (test_device_enabled())
-		test_pv_ipi();
+	for (i = 0; i < ARRAY_SIZE(tests); i++) {
+		tests[i]();
 
-	test_sti_nmi();
-	test_multiple_nmi();
-	test_pending_nmi();
+		if (is_x2apic)
+			enable_x2apic();
+		else
+			reset_apic();
 
-	test_apic_timer_one_shot();
-	test_apic_change_mode();
-	test_tsc_deadline_timer();
+		apic_write(APIC_SPIV, spiv);
+	}
 
 	return report_summary();
 }
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#6 lore raw

PATCH 6/9 x86/apic: Enable IRQs on vCPU0 for all tests

In reply to Sean Christopherson

Enable IRQs on vCPU0 for all APIC sub-tests. Many sub-tests want to generate interrupts, and leaving IRQs disabled makes writing a new test unnecessarily frustrating (guess who forgot to enable IRQs...).

---
 x86/apic.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
x86/apic.c +1 -3
index e466a57..3c00137 100644
@@ -53,7 +53,6 @@ static void tsc_deadline_timer_isr(isr_regs_t *regs)
 static void __test_tsc_deadline_timer(void)
 {
 	handle_irq(TSC_DEADLINE_TIMER_VECTOR, tsc_deadline_timer_isr);
-	irq_enable();
 
 	wrmsr(MSR_IA32_TSCDEADLINE, rdmsr(MSR_IA32_TSC));
 	asm volatile ("nop");
@@ -272,7 +271,6 @@ static void __test_self_ipi(void)
 	int vec = 0xf1;
 
 	handle_irq(vec, self_ipi_isr);
-	irq_enable();
 	apic_icr_write(APIC_DEST_SELF | APIC_DEST_PHYSICAL | APIC_DM_FIXED | vec,
 		       id_map[0]);
 
@@ -485,7 +483,6 @@ static void test_apic_timer_one_shot(void)
 #define APIC_LVT_TIMER_VECTOR    (0xee)
 
 	handle_irq(APIC_LVT_TIMER_VECTOR, lvtt_handler);
-	irq_enable();
 
 	/* One shot mode */
 	apic_write(APIC_LVTT, APIC_LVT_TIMER_ONESHOT |
@@ -705,6 +702,7 @@ int main(void)
 	setup_vm();
 
 	mask_pic_interrupts();
+	irq_enable();
 
 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
 		tests[i]();
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#7 lore raw

PATCH 7/9 x86/apic: Run tests that modify APIC ID and/or APIC_BASE after other tests

In reply to Sean Christopherson

Run the sub-tests that modify the APIC ID and/or APIC base address after all other sub-tests. KVM disables APICv/AVIC if the ID or base is changed, and keeps APICv/AVIC disabled even if the original value is restored. I.e. run as many tests as possible with an APICv/AVIC friendly setup.

---
 x86/apic.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)
x86/apic.c +8 -2
index 3c00137..5be44b8 100644
@@ -676,10 +676,8 @@ int main(void)
 	const apic_test_fn tests[] = {
 		test_lapic_existence,
 
-		test_apic_id,
 		test_apic_disable,
 		test_enable_x2apic,
-		test_apicbase,
 
 		test_self_ipi_xapic,
 		test_self_ipi_x2apic,
@@ -694,6 +692,14 @@ int main(void)
 		test_apic_timer_one_shot,
 		test_apic_change_mode,
 		test_tsc_deadline_timer,
+
+		/*
+		 * KVM may disable APICv if the APIC ID and/or APIC_BASE is
+		 * modified, keep these tests at the end so that the test as a
+		 * whole provides coverage for APICv (when it's enabled).
+		 */
+		test_apic_id,
+		test_apicbase,
 	};
 
 	assert_msg(is_apic_hw_enabled() && is_apic_sw_enabled(),
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#8 lore raw

PATCH 8/9 x86/apic: Add test for logical mode IPI delivery (cluster and flat)

In reply to Sean Christopherson

Add an APIC sub-test to verify the darker corners of logical mode IPI delivery. Logical mode is rather bizarre, in that each "ID" is treated as a bitmask, e.g. an ID with multiple bits set can match multiple destinations. Verify that overlapping and/or superfluous destinations and IDs with multiple target vCPUs are handled correctly for both flat and cluster modes.

---
 x86/apic.c | 201 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 192 insertions(+), 9 deletions(-)
x86/apic.c +192 -9
index 5be44b8..1cc61d3 100644
@@ -257,11 +257,11 @@ static void test_apic_id(void)
 	on_cpu(1, __test_apic_id, NULL);
 }
 
-static int ipi_count;
+static atomic_t ipi_count;
 
-static void self_ipi_isr(isr_regs_t *regs)
+static void handle_ipi(isr_regs_t *regs)
 {
-	++ipi_count;
+	atomic_inc(&ipi_count);
 	eoi();
 }
 
@@ -270,13 +270,13 @@ static void __test_self_ipi(void)
 	u64 start = rdtsc();
 	int vec = 0xf1;
 
-	handle_irq(vec, self_ipi_isr);
+	handle_irq(vec, handle_ipi);
 	apic_icr_write(APIC_DEST_SELF | APIC_DEST_PHYSICAL | APIC_DM_FIXED | vec,
 		       id_map[0]);
 
 	do {
 		pause();
-	} while (rdtsc() - start < 1000000000 && ipi_count == 0);
+	} while (rdtsc() - start < 1000000000 && atomic_read(&ipi_count) == 0);
 }
 
 static void test_self_ipi_xapic(void)
@@ -287,9 +287,9 @@ static void test_self_ipi_xapic(void)
 	reset_apic();
 	report(is_xapic_enabled(), "Local apic enabled in xAPIC mode");
 
-	ipi_count = 0;
+	atomic_set(&ipi_count, 0);
 	__test_self_ipi();
-	report(ipi_count == 1, "self ipi");
+	report(atomic_read(&ipi_count) == 1, "self ipi");
 
 	report_prefix_pop();
 }
@@ -301,9 +301,9 @@ static void test_self_ipi_x2apic(void)
 	if (enable_x2apic()) {
 		report(is_x2apic_enabled(), "Local apic enabled in x2APIC mode");
 
-		ipi_count = 0;
+		atomic_set(&ipi_count, 0);
 		__test_self_ipi();
-		report(ipi_count == 1, "self ipi");
+		report(atomic_read(&ipi_count) == 1, "self ipi");
 	} else {
 		report_skip("x2apic not detected");
 	}
@@ -665,6 +665,188 @@ static void test_pv_ipi(void)
 	report(!ret, "PV IPIs testing");
 }
 
+#define APIC_LDR_CLUSTER_FLAG	BIT(31)
+
+static void set_ldr(void *__ldr)
+{
+	u32 ldr = (unsigned long)__ldr;
+
+	if (ldr & APIC_LDR_CLUSTER_FLAG)
+		apic_write(APIC_DFR, APIC_DFR_CLUSTER);
+	else
+		apic_write(APIC_DFR, APIC_DFR_FLAT);
+
+	apic_write(APIC_LDR, ldr << 24);
+}
+
+static int test_fixed_ipi(u32 dest_mode, u8 dest, u8 vector,
+			  int nr_ipis_expected, const char *mode_name)
+{
+	u64 start = rdtsc();
+	int got;
+
+	atomic_set(&ipi_count, 0);
+
+	/*
+	 * Wait for vCPU1 to get back into HLT, i.e. into the host so that
+	 * KVM must handle incomplete AVIC IPIs.
+	 */
+	do {
+		pause();
+	} while (rdtsc() - start < 1000000);
+
+	start = rdtsc();
+
+	apic_icr_write(dest_mode | APIC_DM_FIXED | vector, dest);
+
+	do {
+		pause();
+	} while (rdtsc() - start < 1000000000 &&
+		 atomic_read(&ipi_count) != nr_ipis_expected);
+
+	/* Only report failures to cut down on the spam. */
+	got = atomic_read(&ipi_count);
+	if (got != nr_ipis_expected)
+		report_fail("Want %d IPI(s) using %s mode, dest = %x, got %d IPI(s)",
+			    nr_ipis_expected, mode_name, dest, got);
+	atomic_set(&ipi_count, 0);
+
+	return got == nr_ipis_expected ? 0 : 1;
+}
+
+static int test_logical_ipi_single_target(u8 logical_id, bool cluster, u8 dest,
+					  u8 vector)
+{
+	/* Disallow broadcast, there are at least 2 vCPUs. */
+	if (dest == 0xff)
+		return 0;
+
+	set_ldr((void *)0);
+	on_cpu(1, set_ldr,
+	       (void *)((u32)logical_id | (cluster ? APIC_LDR_CLUSTER_FLAG : 0)));
+	return test_fixed_ipi(APIC_DEST_LOGICAL, dest, vector, 1,
+			      cluster ? "logical cluster" : "logical flat");
+}
+
+static int test_logical_ipi_multi_target(u8 vcpu0_logical_id, u8 vcpu1_logical_id,
+					 bool cluster, u8 dest, u8 vector)
+{
+	/* Allow broadcast unless there are more than 2 vCPUs. */
+	if (dest == 0xff && cpu_count() > 2)
+		return 0;
+
+	set_ldr((void *)((u32)vcpu0_logical_id | (cluster ? APIC_LDR_CLUSTER_FLAG : 0)));
+	on_cpu(1, set_ldr,
+	       (void *)((u32)vcpu1_logical_id | (cluster ? APIC_LDR_CLUSTER_FLAG : 0)));
+	return test_fixed_ipi(APIC_DEST_LOGICAL, dest, vector, 2,
+			      cluster ? "logical cluster" : "logical flat");
+}
+
+static void test_logical_ipi_xapic(void)
+{
+	int c, i, j, k, f;
+	u8 vector = 0xf1;
+
+	if (cpu_count() < 2)
+		return;
+
+	/*
+	 * All vCPUs must be in xAPIC mode, i.e. simply resetting this vCPUs
+	 * APIC is not sufficient.
+	 */
+	if (is_x2apic_enabled())
+		return;
+
+	handle_irq(vector, handle_ipi);
+
+	/* Flat mode.  8 bits for logical IDs (one per bit). */
+	f = 0;
+	for (i = 0; i < 8; i++) {
+		/*
+		 * Test all possible destination values.  Non-existent targets
+		 * should be ignored.  vCPU is always targeted, i.e. should get
+		 * an IPI.
+		 */
+		for (k = 0; k < 0xff; k++) {
+			/*
+			 * Skip values that overlap the actual target the
+			 * resulting combination will be covered by other
+			 * numbers in the sequence.
+			 */
+			if (BIT(i) & k)
+				continue;
+
+			f += test_logical_ipi_single_target(BIT(i), false,
+							    BIT(i) | k, vector);
+		}
+	}
+	report(!f, "IPI to single target using logical flat mode");
+
+	/* Cluster mode.  4 bits for the cluster, 4 bits for logical IDs. */
+	f = 0;
+	for (c = 0; c < 0xf; c++) {
+		for (i = 0; i < 4; i++) {
+			/* Same as above, just fewer bits... */
+			for (k = 0; k < 0x10; k++) {
+				if (BIT(i) & k)
+					continue;
+
+				test_logical_ipi_single_target(c << 4 | BIT(i), true,
+							       c << 4 | BIT(i) | k, vector);
+			}
+		}
+	}
+	report(!f, "IPI to single target using logical cluster mode");
+
+	/* And now do it all over again targeting both vCPU0 and vCPU1. */
+	f = 0;
+	for (i = 0; i < 8 && !f; i++) {
+		for (j = 0; j < 8 && !f; j++) {
+			if (i == j)
+				continue;
+
+			for (k = 0; k < 0x100 && !f; k++) {
+				if ((BIT(i) | BIT(j)) & k)
+					continue;
+
+				f += test_logical_ipi_multi_target(BIT(i), BIT(j), false,
+								   BIT(i) | BIT(j) | k, vector);
+				if (f)
+					break;
+				f += test_logical_ipi_multi_target(BIT(i) | BIT(j),
+								   BIT(i) | BIT(j), false,
+								   BIT(i) | BIT(j) | k, vector);
+			}
+		}
+	}
+	report(!f, "IPI to multiple targets using logical flat mode");
+
+	f = 0;
+	for (c = 0; c < 0xf && !f; c++) {
+		for (i = 0; i < 4 && !f; i++) {
+			for (j = 0; j < 4 && !f; j++) {
+				if (i == j)
+					continue;
+
+				for (k = 0; k < 0x10 && !f; k++) {
+					if ((BIT(i) | BIT(j)) & k)
+						continue;
+
+					f += test_logical_ipi_multi_target(c << 4 | BIT(i),
+									   c << 4 | BIT(j), true,
+									   c << 4 | BIT(i) | BIT(j) | k, vector);
+					if (f)
+						break;
+					f += test_logical_ipi_multi_target(c << 4 | BIT(i) | BIT(j),
+									   c << 4 | BIT(i) | BIT(j), true,
+									   c << 4 | BIT(i) | BIT(j) | k, vector);
+				}
+			}
+		}
+	}
+	report(!f, "IPI to multiple targets using logical cluster mode");
+}
+
 typedef void (*apic_test_fn)(void);
 
 int main(void)
@@ -682,6 +864,7 @@ int main(void)
 		test_self_ipi_xapic,
 		test_self_ipi_x2apic,
 		test_physical_broadcast,
+		test_logical_ipi_xapic,
 
 		test_pv_ipi,
 
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
author reviewer
#9 lore raw

PATCH 9/9 x86/apic: Add test to verify aliased xAPIC IDs both receive IPI

In reply to Sean Christopherson

Verify that multiple vCPUs with the same physical xAPIC ID receive an IPI sent to said ID. Note, on_cpu() maintains its own CPU=>ID map and is effectively unusuable after changing the xAPIC ID. Update each vCPU's xAPIC ID from within the IRQ handler so as to avoid having to send yet another IPI from vCPU0 to tell vCPU1 to update its ID.

---
 lib/x86/processor.h |  1 +
 x86/apic.c          | 67 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)
lib/x86/processor.h +1 -0
index 0324220..280821e 100644
@@ -219,6 +219,7 @@ static inline bool is_intel(void)
 #define	X86_FEATURE_VMX			(CPUID(0x1, 0, ECX, 5))
 #define	X86_FEATURE_PDCM		(CPUID(0x1, 0, ECX, 15))
 #define	X86_FEATURE_PCID		(CPUID(0x1, 0, ECX, 17))
+#define X86_FEATURE_X2APIC		(CPUID(0x1, 0, ECX, 21))
 #define	X86_FEATURE_MOVBE		(CPUID(0x1, 0, ECX, 22))
 #define	X86_FEATURE_TSC_DEADLINE_TIMER	(CPUID(0x1, 0, ECX, 24))
 #define	X86_FEATURE_XSAVE		(CPUID(0x1, 0, ECX, 26))
x86/apic.c +67 -0

79 lines not on this page · raw message

Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog