Skip to contentSkip to conversation

KVM: selftests: Stress save+restore and #PF (ft. nested)

PATCH Superseded Yosry Ahmed 1 participant 12 messages May 18 – May 28

Subsystems (3)

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

cover KVM: selftests: Stress save+restore and #PF (ft. nested)

Add a stress test for save+restore while the guest is triggering and handling #PFs, in both L1 and L2. The goal was to create a generic selftest that would catch bugs like the one fixed by 5c247d08bc81 ("KVM:
nSVM: Use vcpu->arch.cr2 when updating vmcb12 on nested #VMEXIT"), instead of relying on high-level testing (e.g. building GCC in L2) to catch it.

The test tries to be as generic as possible by triggering #PFs in a guest and installing a proper #PF handler, while the host is continuously doing save+restore cycles. Exiting to userspace is randomly triggered by a second thread that constantly signals the vCPU thread.

Patches (1-4) are prep patches, fixing GPR switching for nSVM and generalizing it to cover nVMX, which is needed for the test to run properly with nVMX. Patch 4 removes HORRIFIC_L2_UCALL_CLOBBER_HACK, as it is no longer needed. While this series does not have the "complete" fix added by commit 6783ca4105a7 ("KVM: selftests: Add a shameful hack to preserve/clobber GPRs across ucall"), it's a good step in the right direction.

Patches (5-8) add the actual test. The test is first introduced as a simple (read: dummy) stress test that just explicitly syncs to userspace after each #PF handling to do save+restore, then gradually evolves to add the random signaling and nested support. After the last patch, the test reliably reproduces the CR2 bug.

This series conflicts with reworking L2 stack allocation in [1], but the conflict should be trivial to fix regardless of which series lands first.

[1]https://lore.kernel.org/kvm/[email protected]/

Yosry Ahmed (8):
KVM: selftests: Fix offsets in GPR switching for nSVM
KVM: selftests: Move GPR load/save definitions outside of nSVM code
KVM: selftests: Reuse GPR switching logic for nVMX
KVM: selftests: Drop HORRIFIC_L2_UCALL_CLOBBER_HACK
KVM: selftests: Add basic stress test for save+restore and #PF
handling
KVM: selftests: Trigger save+restore randomly in the #PF stress test
KVM: selftests: Support running stress save+restore and #PF test in L2
KVM: selftests: Trigger L2->L1 exits stress save+restore and #PF test

 tools/testing/selftests/kvm/Makefile.kvm      |   1 +
 .../selftests/kvm/include/x86/processor.h     |  65 +++-
 tools/testing/selftests/kvm/include/x86/vmx.h |  46 +--
 .../testing/selftests/kvm/lib/x86/processor.c |  13 +
 tools/testing/selftests/kvm/lib/x86/svm.c     |  29 +-
 tools/testing/selftests/kvm/lib/x86/ucall.c   |  32 +-
 .../kvm/x86/stress_save_restore_pf_test.c     | 320 ++++++++++++++++++
 7 files changed, 414 insertions(+), 92 deletions(-)
 create mode 100644 tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c

base-commit: a9512a611bd030088f13477258d1f8103cceaa40

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#1 lore raw

PATCH 1/8 KVM: selftests: Fix offsets in GPR switching for nSVM

The GPRs switching code uses hardcoded offsets and gets them wrong. For example, the offset of RBX should actually be 0x18. It also uses an offset outside the struct for the last register.

Instead of hardcoded offsets, define ASM variables that hold the member offsets using offsetof(), and define a macro that uses those offsets to switch one GPR. Opportunistically drop the separate SAVE/LOAD macros in favor of a single SWITCH macro, and rename it to reflect that it doesn't switch RAX.

Also, re-order the registers in the struct alphabetically since the ordering does not matter anymore, and drop RSP as it's not used anyway.

---
 .../selftests/kvm/include/x86/processor.h     |  3 +-
 tools/testing/selftests/kvm/lib/x86/svm.c     | 58 ++++++++++++-------
 2 files changed, 39 insertions(+), 22 deletions(-)
tools/testing/selftests/kvm/include/x86/processor.h +1 -2
index 77f576ee7789d..1482f2b53a9c5 100644
@@ -381,10 +381,9 @@ static inline unsigned int x86_model(unsigned int eax)
 /* General Registers in 64-Bit Mode */
 struct gpr64_regs {
 	u64 rax;
+	u64 rbx;
 	u64 rcx;
 	u64 rdx;
-	u64 rbx;
-	u64 rsp;
 	u64 rbp;
 	u64 rsi;
 	u64 rdi;
tools/testing/selftests/kvm/lib/x86/svm.c +38 -20

78 lines not on this page · raw message

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#2 lore raw

PATCH 2/8 KVM: selftests: Move GPR load/save definitions outside of nSVM code

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

In preparation for reusing the code for nVMX tests, move the definitions for GPRs switching to processor.h.

No functional change intended.

---
 .../selftests/kvm/include/x86/processor.h     | 42 +++++++++++++++++++
 .../testing/selftests/kvm/lib/x86/processor.c |  2 +
 tools/testing/selftests/kvm/lib/x86/svm.c     | 41 ------------------
 3 files changed, 44 insertions(+), 41 deletions(-)
tools/testing/selftests/kvm/include/x86/processor.h +42 -0
index 1482f2b53a9c5..8e4eab84b91bc 100644
@@ -397,6 +397,48 @@ struct gpr64_regs {
 	u64 r15;
 };
 
+extern struct gpr64_regs guest_regs;
+
+#define DEFINE_ASM_GPR64_OFFSET(reg) \
+	asm(".equ GPR64_OFF_" #reg ", %c0" : : "i"(offsetof(struct gpr64_regs, reg)))
+
+DEFINE_ASM_GPR64_OFFSET(rbx);
+DEFINE_ASM_GPR64_OFFSET(rcx);
+DEFINE_ASM_GPR64_OFFSET(rdx);
+DEFINE_ASM_GPR64_OFFSET(rbp);
+DEFINE_ASM_GPR64_OFFSET(rsi);
+DEFINE_ASM_GPR64_OFFSET(rdi);
+DEFINE_ASM_GPR64_OFFSET(r8);
+DEFINE_ASM_GPR64_OFFSET(r9);
+DEFINE_ASM_GPR64_OFFSET(r10);
+DEFINE_ASM_GPR64_OFFSET(r11);
+DEFINE_ASM_GPR64_OFFSET(r12);
+DEFINE_ASM_GPR64_OFFSET(r13);
+DEFINE_ASM_GPR64_OFFSET(r14);
+DEFINE_ASM_GPR64_OFFSET(r15);
+
+#define GUEST_SWITCH_GPR_ASM(reg) \
+	"xchg %%" #reg ", guest_regs + GPR64_OFF_" #reg "\n\t"
+/*
+ * save/restore 64-bit general registers except rax, rip, rsp
+ * which are directly handed through the VMCB guest processor state
+ */
+#define GUEST_SWITCH_GPRS_NORAX_ASM \
+	GUEST_SWITCH_GPR_ASM(rbx) \
+	GUEST_SWITCH_GPR_ASM(rcx) \
+	GUEST_SWITCH_GPR_ASM(rdx) \
+	GUEST_SWITCH_GPR_ASM(rbp) \
+	GUEST_SWITCH_GPR_ASM(rsi) \
+	GUEST_SWITCH_GPR_ASM(rdi) \
+	GUEST_SWITCH_GPR_ASM(r8)  \
+	GUEST_SWITCH_GPR_ASM(r9)  \
+	GUEST_SWITCH_GPR_ASM(r10) \
+	GUEST_SWITCH_GPR_ASM(r11) \
+	GUEST_SWITCH_GPR_ASM(r12) \
+	GUEST_SWITCH_GPR_ASM(r13) \
+	GUEST_SWITCH_GPR_ASM(r14) \
+	GUEST_SWITCH_GPR_ASM(r15)
+
 struct desc64 {
 	u16 limit0;
 	u16 base0;
tools/testing/selftests/kvm/lib/x86/processor.c +2 -0
index b51467d70f6e7..caefcd12df8d2 100644
@@ -29,6 +29,8 @@ bool host_cpu_is_amd_compatible;
 bool is_forced_emulation_enabled;
 u64 guest_tsc_khz;
 
+struct gpr64_regs guest_regs;
+
 const char *ex_str(int vector)
 {
 	switch (vector) {
tools/testing/selftests/kvm/lib/x86/svm.c +0 -41

53 lines not on this page · raw message

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#3 lore raw

PATCH 3/8 KVM: selftests: Reuse GPR switching logic for nVMX

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Reuse the GPR switching logic for nVMX by adding a wrapper that also switches RAX, replacing the push/pop of a subset of the registers.

---
 .../selftests/kvm/include/x86/processor.h     |  5 ++
 tools/testing/selftests/kvm/include/x86/vmx.h | 46 +++++--------------
 2 files changed, 17 insertions(+), 34 deletions(-)
tools/testing/selftests/kvm/include/x86/processor.h +5 -0
index 8e4eab84b91bc..ca2ec92490f7c 100644
@@ -402,6 +402,7 @@ extern struct gpr64_regs guest_regs;
 #define DEFINE_ASM_GPR64_OFFSET(reg) \
 	asm(".equ GPR64_OFF_" #reg ", %c0" : : "i"(offsetof(struct gpr64_regs, reg)))
 
+DEFINE_ASM_GPR64_OFFSET(rax);
 DEFINE_ASM_GPR64_OFFSET(rbx);
 DEFINE_ASM_GPR64_OFFSET(rcx);
 DEFINE_ASM_GPR64_OFFSET(rdx);
@@ -439,6 +440,10 @@ DEFINE_ASM_GPR64_OFFSET(r15);
 	GUEST_SWITCH_GPR_ASM(r14) \
 	GUEST_SWITCH_GPR_ASM(r15)
 
+#define GUEST_SWITCH_GPRS_ASM \
+	GUEST_SWITCH_GPR_ASM(rax) \
+	GUEST_SWITCH_GPRS_NORAX_ASM
+
 struct desc64 {
 	u16 limit0;
 	u16 base0;
tools/testing/selftests/kvm/include/x86/vmx.h +12 -34

83 lines not on this page · raw message

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#4 lore raw

PATCH 4/8 KVM: selftests: Drop HORRIFIC_L2_UCALL_CLOBBER_HACK

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Now that nVMX test codes preserves GPRs across nested VM-Exits (specifically RBP, RDX, and RDI among others), drop the ucall-specific hack to avoid clobbering these registers.

---
 tools/testing/selftests/kvm/lib/x86/ucall.c | 32 ++-------------------
 1 file changed, 2 insertions(+), 30 deletions(-)
tools/testing/selftests/kvm/lib/x86/ucall.c +2 -30
index e7dd5791959ba..38050c60a0670 100644
@@ -10,36 +10,8 @@
 
 void ucall_arch_do_ucall(gva_t uc)
 {
-	/*
-	 * FIXME: Revert this hack (the entire commit that added it) once nVMX
-	 * preserves L2 GPRs across a nested VM-Exit.  If a ucall from L2, e.g.
-	 * to do a GUEST_SYNC(), lands the vCPU in L1, any and all GPRs can be
-	 * clobbered by L1.  Save and restore non-volatile GPRs (clobbering RBP
-	 * in particular is problematic) along with RDX and RDI (which are
-	 * inputs), and clobber volatile GPRs. *sigh*
-	 */
-#define HORRIFIC_L2_UCALL_CLOBBER_HACK	\
-	"rcx", "rsi", "r8", "r9", "r10", "r11"
-
-	asm volatile("push %%rbp\n\t"
-		     "push %%r15\n\t"
-		     "push %%r14\n\t"
-		     "push %%r13\n\t"
-		     "push %%r12\n\t"
-		     "push %%rbx\n\t"
-		     "push %%rdx\n\t"
-		     "push %%rdi\n\t"
-		     "in %[port], %%al\n\t"
-		     "pop %%rdi\n\t"
-		     "pop %%rdx\n\t"
-		     "pop %%rbx\n\t"
-		     "pop %%r12\n\t"
-		     "pop %%r13\n\t"
-		     "pop %%r14\n\t"
-		     "pop %%r15\n\t"
-		     "pop %%rbp\n\t"
-		: : [port] "d" (UCALL_PIO_PORT), "D" (uc) : "rax", "memory",
-		     HORRIFIC_L2_UCALL_CLOBBER_HACK);
+	asm volatile("in %[port], %%al"
+		: : [port] "d" (UCALL_PIO_PORT), "D" (uc) : "rax", "memory");
 }
 
 void *ucall_arch_get_ucall(struct kvm_vcpu *vcpu)
Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#5 lore raw

PATCH 5/8 KVM: selftests: Add basic stress test for save+restore and #PF handling

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Add a basic stress test for handling #PFs in a guest while the host is doing save+restore cycles. The guest periodically accesses non-present memory causing a #PF, and the #PF handler walks the page tables and updates the PTE to be present, like a proper #PF handler.

After every access (and #PF), the guest triggers a sync and the test performs save+restore of the VM. This is not very meaningful as save+restore are performed after the access and #PF handling complete, but following changes will change that.

---
 tools/testing/selftests/kvm/Makefile.kvm      |   1 +
 .../selftests/kvm/include/x86/processor.h     |  15 ++
 .../testing/selftests/kvm/lib/x86/processor.c |  11 ++
 .../kvm/x86/stress_save_restore_pf_test.c     | 171 ++++++++++++++++++
 4 files changed, 198 insertions(+)
 create mode 100644 tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c
tools/testing/selftests/kvm/Makefile.kvm +1 -0
index 82fa943b95038..9327284dd5bbf 100644
@@ -110,6 +110,7 @@ TEST_GEN_PROGS_x86 += x86/set_sregs_test
 TEST_GEN_PROGS_x86 += x86/smaller_maxphyaddr_emulation_test
 TEST_GEN_PROGS_x86 += x86/smm_test
 TEST_GEN_PROGS_x86 += x86/state_test
+TEST_GEN_PROGS_x86 += x86/stress_save_restore_pf_test
 TEST_GEN_PROGS_x86 += x86/vmx_preemption_timer_test
 TEST_GEN_PROGS_x86 += x86/svm_vmcall_test
 TEST_GEN_PROGS_x86 += x86/svm_int_ctl_test
tools/testing/selftests/kvm/include/x86/processor.h +15 -0
index ca2ec92490f7c..41bffe031eb88 100644
@@ -610,6 +610,15 @@ static inline void set_cr0(u64 val)
 	__asm__ __volatile__("mov %0, %%cr0" : : "r" (val) : "memory");
 }
 
+static inline u64 get_cr2(void)
+{
+	u64 cr2;
+
+	__asm__ __volatile__("mov %%cr2, %[cr2]"
+			     : /* output */ [cr2]"=r"(cr2));
+	return cr2;
+}
+
 static inline u64 get_cr3(void)
 {
 	u64 cr3;
@@ -905,6 +914,11 @@ static inline void write_sse_reg(int reg, const sse128_t *data)
 	}
 }
 
+static inline void invlpg(u64 addr)
+{
+	__asm__ __volatile__("invlpg (%0)" : : "r"(addr) : "memory");
+}
+
 static inline void cpu_relax(void)
 {
 	asm volatile("rep; nop" ::: "memory");
@@ -1557,6 +1571,7 @@ void __virt_pg_map(struct kvm_vm *vm, struct kvm_mmu *mmu, gva_t gva,
 		   gpa_t gpa,  int level);
 void virt_map_level(struct kvm_vm *vm, gva_t gva, gpa_t gpa,
 		    u64 nr_bytes, int level);
+void virt_map_page_tables(struct kvm_vm *vm);
 
 void vm_enable_tdp(struct kvm_vm *vm);
 bool kvm_cpu_has_tdp(void);
tools/testing/selftests/kvm/lib/x86/processor.c +11 -0
index caefcd12df8d2..6708fa8b6a304 100644
@@ -343,6 +343,17 @@ void virt_map_level(struct kvm_vm *vm, gva_t gva, gpa_t gpa,
 	}
 }
 
+void virt_map_page_tables(struct kvm_vm *vm)
+{
+	gpa_t gpa = KVM_GUEST_PAGE_TABLE_MIN_PADDR;
+	struct userspace_mem_region *region;
+	u64 pt_size;
+
+	region = memslot2region(vm, vm->memslots[MEM_REGION_PT]);
+	pt_size = region->region.guest_phys_addr + region->region.memory_size - gpa;
+	virt_map(vm, gpa, gpa, pt_size / getpagesize());
+}
+
 static bool vm_is_target_pte(struct kvm_mmu *mmu, u64 *pte,
 			     int *level, int current_level)
 {
tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c new file +171 -0

171 lines not on this page · raw message

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#6 lore raw

Re: [PATCH 5/8] KVM: selftests: Add basic stress test for save+restore and #PF handling

Quoted 8 lines
tools/testing/selftests/kvm/lib/x86/processor.c +0 -0
index caefcd12df8d2..6708fa8b6a304 100644
@@ -343,6 +343,17 @@ void virt_map_level(struct kvm_vm *vm, gva_t gva, gpa_t gpa,
        }
 }
 

tools/testing/selftests/kvm/lib/x86/processor.c void virt_map_level(struct kvm_vm *vm, gva_t gva, gpa_t gpa, · line 355

Quoted 10 lines
tools/testing/selftests/kvm/lib/x86/processor.c +10 -0
+void virt_map_page_tables(struct kvm_vm *vm)
+{
+       gpa_t gpa = KVM_GUEST_PAGE_TABLE_MIN_PADDR;
+       struct userspace_mem_region *region;
+       u64 pt_size;
+
+       region = memslot2region(vm, vm->memslots[MEM_REGION_PT]);
+       pt_size = region->region.guest_phys_addr + region->region.memory_size - gpa;
+       virt_map(vm, gpa, gpa, pt_size / getpagesize());
+}

This is wrong. It tries to map the entire memslot for MEM_REGION_PT, starting at KVM_GUEST_PAGE_TABLE_MIN_PADDR. The problem is, the memslot is shared with other things like ELF. So this tries to map everything from KVM_GUEST_PAGE_TABLE_MIN_PADDR (0x180000) to the end of the memslot (0x291000 in this case) using identity GVA->GPA mappings.

When using clang's LLD, ELF starts at GVA 0x20000, so this tries to remap the ELF GVAs to a different GPAs, and an assertion fires in __virt_pg_map().

Without LLD (when I did my initial testing), ELF starts at GVA 0x40000, so it's outside the range mapped by virt_map_page_tables().

We can fix this by creating a separate memslot for page tables like other archs do, but I think for this case, it's probably simpler if the test just walks the page tables and maps them. It should be one page at each level.

#7 lore raw

PATCH 6/8 KVM: selftests: Trigger save+restore randomly in the #PF stress test

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Instead of an explicit GUEST_SYNC() after each access+#PF, run another thread that keeps sending SIGUSR to the vCPU thread, essentially triggering exits to userspace and save+restore on random points in guest execution. This makes the test a lot more meaningful as it opens the door to exercising race conditions between #PF handling in the guest and save+restore in the host.

The signals are ignored using SIG_IGN outside of __vcpu_run() to avoid interrupting other ioctls/sysctls performed by the test.

---
 .../kvm/x86/stress_save_restore_pf_test.c     | 56 ++++++++++++++++---
 1 file changed, 48 insertions(+), 8 deletions(-)
tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c +48 -8
index 12da74b4f725c..60a013e0f14fb 100644
@@ -5,6 +5,8 @@
 #include <errno.h>
 #include <sys/types.h>
 #include <time.h>
+#include <pthread.h>
+#include <signal.h>
 #include <unistd.h>
 
 #include "test_util.h"
@@ -99,14 +101,40 @@ static void guest_access_memory(void *arg)
 		/* Clear the present bit again so it faults next time */
 		*guest_get_pte(vaddr) &= ~pte_present_mask;
 		invlpg(vaddr);
+	}
+}
+
+static void *sigusr_thread_fn(void *arg)
+{
+	pthread_t vcpu_thread = (pthread_t)arg;
 
-		GUEST_SYNC(guest_accesses);
+	for (;;) {
+		pthread_testcancel();
+		pthread_kill(vcpu_thread, SIGUSR1);
+		usleep(100);
 	}
+	return NULL;
+}
+
+static void dummy_signal_handler(int signo) {}
+static struct sigaction sa;
+
+static void vcpu_sigusr_listen(void)
+{
+	sa.sa_handler = dummy_signal_handler;
+	sigaction(SIGUSR1, &sa, NULL);
+}
+
+static void vcpu_sigusr_ignore(void)
+{
+	sa.sa_handler = SIG_IGN;
+	sigaction(SIGUSR1, &sa, NULL);
 }
 
 int main(int argc, char *argv[])
 {
 	struct kvm_x86_state *state;
+	pthread_t sigusr_thread;
 	struct kvm_vcpu *vcpu;
 	int r, i, count = 0;
 	struct kvm_vm *vm;
@@ -140,18 +168,28 @@ int main(int argc, char *argv[])
 	/* Map the page tables so that the guest #PF handler can walk them */
 	virt_map_page_tables(vm);
 
+	/* Initialize the thread sending SIGUSR and install the handler */
+	pthread_create(&sigusr_thread, NULL, sigusr_thread_fn,
+		       (void *)pthread_self());
+
 	while (count++ < NR_ITERATIONS) {
+		/*
+		 * Only handle SIGUSR while the vCPU is running, otherwise
+		 * ignore it to avoid interrupting other ioctls/syscalls.
+		 */
+		vcpu_sigusr_listen();
 		r = __vcpu_run(vcpu);
-		TEST_ASSERT(!r, "vcpu_run failed");
-		TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
-
-		get_ucall(vcpu, &uc);
-		if (uc.cmd == UCALL_ABORT) {
+		if (r == -1)
+			TEST_ASSERT_EQ(errno, EINTR);
+		vcpu_sigusr_ignore();
+
+		/* The guest only exists due to a signal or failed assertion */
+		if (!r) {
+			TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
+			TEST_ASSERT_EQ(get_ucall(vcpu, &uc), UCALL_ABORT);
 			REPORT_GUEST_ASSERT(uc);
 			break;
 		}
-		TEST_ASSERT_EQ(uc.cmd, UCALL_SYNC);
-		TEST_ASSERT_EQ(uc.args[1], count - 1);
 
 		state = vcpu_save_state(vcpu);
 
@@ -166,6 +204,8 @@ int main(int argc, char *argv[])
 	sync_global_from_guest(vm, guest_accesses);
 	pr_info("Guest page accesses: %lu\n", guest_accesses);
 
+	pthread_cancel(sigusr_thread);
+	pthread_join(sigusr_thread, NULL);
 	kvm_vm_free(vm);
 	return 0;
 }
Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#8 lore raw

PATCH 7/8 KVM: selftests: Support running stress save+restore and #PF test in L2

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Extend the stress test to allow running the access+#PF code in L2 instead of L1 by adding proper L1 guest code to bootstrap L2. The test runs in nested mode if a '-n' flag is added.

---
 .../kvm/x86/stress_save_restore_pf_test.c     | 75 ++++++++++++++++++-
 1 file changed, 73 insertions(+), 2 deletions(-)
tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c +73 -2
index 60a013e0f14fb..ec3d36d6e4846 100644
@@ -8,10 +8,13 @@
 #include <pthread.h>
 #include <signal.h>
 #include <unistd.h>
+#include <getopt.h>
 
 #include "test_util.h"
 #include "kvm_util.h"
 #include "processor.h"
+#include "svm_util.h"
+#include "vmx.h"
 
 #define NR_ITERATIONS		500
 
@@ -26,6 +29,8 @@
 #define NR_TEST_ADDRS		512
 #define PATTERN			0xabcdefabcdefabcdULL
 
+#define L2_GUEST_STACK_SIZE	64
+
 #define PTRS_PER_PTE		512
 #define PXD_INDEX(vaddr, level)	(((vaddr) >> PG_LEVEL_SHIFT(level)) & (PTRS_PER_PTE - 1))
 
@@ -104,6 +109,41 @@ static void guest_access_memory(void *arg)
 	}
 }
 
+static void l1_svm_code(struct svm_test_data *svm)
+{
+	unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
+
+	generic_svm_setup(svm, guest_access_memory, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
+
+	run_guest(svm->vmcb, svm->vmcb_gpa);
+	GUEST_ASSERT(false);
+}
+
+static void l1_vmx_code(struct vmx_pages *vmx)
+{
+	unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
+
+	GUEST_ASSERT(prepare_for_vmx_operation(vmx));
+	GUEST_ASSERT(load_vmcs(vmx));
+	prepare_vmcs(vmx, guest_access_memory, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
+
+	/* Ignore any #PF */
+	GUEST_ASSERT(!vmwrite(EXCEPTION_BITMAP, BIT(PF_VECTOR)));
+	GUEST_ASSERT(!vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0));
+	GUEST_ASSERT(!vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, -1));
+
+	GUEST_ASSERT(!vmlaunch());
+	GUEST_ASSERT(false);
+}
+
+static void l1_guest_code(void *test_data)
+{
+	if (this_cpu_has(X86_FEATURE_SVM))
+		l1_svm_code(test_data);
+	else
+		l1_vmx_code(test_data);
+}
+
 static void *sigusr_thread_fn(void *arg)
 {
 	pthread_t vcpu_thread = (pthread_t)arg;
@@ -131,6 +171,25 @@ static void vcpu_sigusr_ignore(void)
 	sigaction(SIGUSR1, &sa, NULL);
 }
 
+static bool parse_args_nested(int argc, char *argv[])
+{
+	bool nested = false;
+	int opt;
+
+	while ((opt = getopt(argc, argv, "n")) != -1) {
+		switch (opt) {
+		case 'n':
+			nested = true;
+			break;
+		default:
+			printf("Usage: %s [-n]\n", argv[0]);
+			exit(1);
+		}
+	}
+
+	return nested;
+}
+
 int main(int argc, char *argv[])
 {
 	struct kvm_x86_state *state;
@@ -139,12 +198,24 @@ int main(int argc, char *argv[])
 	int r, i, count = 0;
 	struct kvm_vm *vm;
 	struct ucall uc;
+	bool nested;
 	gva_t gva;
 	gpa_t gpa;
 
-	vm = vm_create_with_one_vcpu(&vcpu, guest_access_memory);
+	nested = parse_args_nested(argc, argv);
+
+	vm = vm_create_with_one_vcpu(&vcpu, nested ? l1_guest_code : guest_access_memory);
 	vm_install_exception_handler(vm, PF_VECTOR, guest_pf_handler);
 
+	if (nested) {
+		TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SVM) || kvm_cpu_has(X86_FEATURE_VMX));
+		if (kvm_cpu_has(X86_FEATURE_SVM))
+			vcpu_alloc_svm(vm, &gva);
+		else
+			vcpu_alloc_vmx(vm, &gva);
+		vcpu_args_set(vcpu, 1, gva);
+	}
+
 	pte_present_mask = PTE_PRESENT_MASK(&vm->mmu);
 	pte_huge_mask = PTE_HUGE_MASK(&vm->mmu);
 	sync_global_to_guest(vm, pte_present_mask);
@@ -202,7 +273,7 @@ int main(int argc, char *argv[])
 	}
 
 	sync_global_from_guest(vm, guest_accesses);
-	pr_info("Guest page accesses: %lu\n", guest_accesses);
+	pr_info("Guest page accesses%s: %lu\n", nested ? " (from L2)" : "", guest_accesses);
 
 	pthread_cancel(sigusr_thread);
 	pthread_join(sigusr_thread, NULL);
Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#9 lore raw

PATCH 8/8 KVM: selftests: Trigger L2->L1 exits stress save+restore and #PF test

In reply to Yosry Ahmed

From: Yosry Ahmed <[email protected]>

Extend the testing coverage in L2 by injecting a #UD into the vCPU every other iteration during restore, and intercepting #UD from L1, essentially forcing an L2 -> L1 VM-Exit directly after save+restore.

With this change, the test reliably reproduces the CR2 bug fixed by commit 5c247d08bc81 ("KVM: nSVM: Use vcpu->arch.cr2 when updating vmcb12 on nested #VMEXIT") -- at least on Milan, Genoa, and Turin CPUs.

---
 .../kvm/x86/stress_save_restore_pf_test.c     | 48 +++++++++++++++++--
 1 file changed, 43 insertions(+), 5 deletions(-)
tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c +43 -5
index ec3d36d6e4846..e977d9786e392 100644
@@ -115,8 +115,12 @@ static void l1_svm_code(struct svm_test_data *svm)
 
 	generic_svm_setup(svm, guest_access_memory, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
 
-	run_guest(svm->vmcb, svm->vmcb_gpa);
-	GUEST_ASSERT(false);
+	svm->vmcb->control.intercept_exceptions |= BIT(UD_VECTOR);
+
+	while (1) {
+		run_guest(svm->vmcb, svm->vmcb_gpa);
+		GUEST_ASSERT_EQ(svm->vmcb->control.exit_code, (SVM_EXIT_EXCP_BASE + UD_VECTOR));
+	}
 }
 
 static void l1_vmx_code(struct vmx_pages *vmx)
@@ -127,13 +131,17 @@ static void l1_vmx_code(struct vmx_pages *vmx)
 	GUEST_ASSERT(load_vmcs(vmx));
 	prepare_vmcs(vmx, guest_access_memory, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
 
-	/* Ignore any #PF */
-	GUEST_ASSERT(!vmwrite(EXCEPTION_BITMAP, BIT(PF_VECTOR)));
+	/* Intercept UD, ignore any #PF */
+	GUEST_ASSERT(!vmwrite(EXCEPTION_BITMAP, BIT(UD_VECTOR) | BIT(PF_VECTOR)));
 	GUEST_ASSERT(!vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0));
 	GUEST_ASSERT(!vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, -1));
 
 	GUEST_ASSERT(!vmlaunch());
-	GUEST_ASSERT(false);
+	while (1) {
+		GUEST_ASSERT_EQ(vmreadz(VM_EXIT_REASON), EXIT_REASON_EXCEPTION_NMI);
+		GUEST_ASSERT_EQ(vmreadz(VM_EXIT_INTR_INFO) & 0xff, UD_VECTOR);
+		GUEST_ASSERT(!vmresume());
+	}
 }
 
 static void l1_guest_code(void *test_data)
@@ -171,6 +179,23 @@ static void vcpu_sigusr_ignore(void)
 	sigaction(SIGUSR1, &sa, NULL);
 }
 
+static bool vcpu_state_is_guest_mode(struct kvm_x86_state *state)
+{
+	return !!(state->nested.flags & KVM_STATE_NESTED_GUEST_MODE);
+}
+
+static void vcpu_state_inject_ud(struct kvm_x86_state *state)
+{
+	if (state->events.exception.pending || state->events.exception.injected)
+		return;
+
+	state->events.flags |= KVM_VCPUEVENT_VALID_PAYLOAD;
+	state->events.exception.pending = true;
+	state->events.exception.injected = false;
+	state->events.exception.nr = UD_VECTOR;
+	state->events.exception.has_error_code = false;
+}
+
 static bool parse_args_nested(int argc, char *argv[])
 {
 	bool nested = false;
@@ -202,10 +227,13 @@ int main(int argc, char *argv[])
 	gva_t gva;
 	gpa_t gpa;
 
+	TEST_REQUIRE(kvm_has_cap(KVM_CAP_EXCEPTION_PAYLOAD));
+
 	nested = parse_args_nested(argc, argv);
 
 	vm = vm_create_with_one_vcpu(&vcpu, nested ? l1_guest_code : guest_access_memory);
 	vm_install_exception_handler(vm, PF_VECTOR, guest_pf_handler);
+	vm_enable_cap(vm, KVM_CAP_EXCEPTION_PAYLOAD, -2ul);
 
 	if (nested) {
 		TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SVM) || kvm_cpu_has(X86_FEATURE_VMX));
@@ -264,8 +292,18 @@ int main(int argc, char *argv[])
 
 		state = vcpu_save_state(vcpu);
 
+		/*
+		 * If the vCPU is in guest mode, inject a #UD to trigger an
+		 * L2->L1 VM-Exit every other iteration.
+		 */
+		if (vcpu_state_is_guest_mode(state) && count % 2 == 0) {
+			TEST_ASSERT(nested, "Unexpected guest mode");
+			vcpu_state_inject_ud(state);
+		}
+
 		kvm_vm_release(vm);
 		vcpu = vm_recreate_with_one_vcpu(vm);
+		vm_enable_cap(vm, KVM_CAP_EXCEPTION_PAYLOAD, -2ul);
 		vcpu_load_state(vcpu, state);
 		kvm_x86_state_cleanup(state);
 
Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#10 lore raw
In reply to Yosry Ahmed
Quoted 26 lines · Yosry Ahmed

Add a stress test for save+restore while the guest is triggering and handling #PFs, in both L1 and L2. The goal was to create a generic selftest that would catch bugs like the one fixed by 5c247d08bc81 ("KVM:
nSVM: Use vcpu->arch.cr2 when updating vmcb12 on nested #VMEXIT"), instead of relying on high-level testing (e.g. building GCC in L2) to catch it.

The test tries to be as generic as possible by triggering #PFs in a guest and installing a proper #PF handler, while the host is continuously doing save+restore cycles. Exiting to userspace is randomly triggered by a second thread that constantly signals the vCPU thread.

Patches (1-4) are prep patches, fixing GPR switching for nSVM and generalizing it to cover nVMX, which is needed for the test to run properly with nVMX. Patch 4 removes HORRIFIC_L2_UCALL_CLOBBER_HACK, as it is no longer needed. While this series does not have the "complete" fix added by commit 6783ca4105a7 ("KVM: selftests: Add a shameful hack to preserve/clobber GPRs across ucall"), it's a good step in the right direction.

Patches (5-8) add the actual test. The test is first introduced as a simple (read: dummy) stress test that just explicitly syncs to userspace after each #PF handling to do save+restore, then gradually evolves to add the random signaling and nested support. After the last patch, the test reliably reproduces the CR2 bug.

Quoted 5 lines

This series conflicts with reworking L2 stack allocation in [1], but the conflict should be trivial to fix regardless of which series lands first.

[1]https://lore.kernel.org/kvm/[email protected]/

Oh I forgot, all the patches should have:

Assisted-by gemini/gemini-3.1-pro
Quoted 28 lines

Yosry Ahmed (8):
KVM: selftests: Fix offsets in GPR switching for nSVM
KVM: selftests: Move GPR load/save definitions outside of nSVM code
KVM: selftests: Reuse GPR switching logic for nVMX
KVM: selftests: Drop HORRIFIC_L2_UCALL_CLOBBER_HACK
KVM: selftests: Add basic stress test for save+restore and #PF
handling
KVM: selftests: Trigger save+restore randomly in the #PF stress test
KVM: selftests: Support running stress save+restore and #PF test in L2
KVM: selftests: Trigger L2->L1 exits stress save+restore and #PF test

 tools/testing/selftests/kvm/Makefile.kvm      |   1 +
 .../selftests/kvm/include/x86/processor.h     |  65 +++-
 tools/testing/selftests/kvm/include/x86/vmx.h |  46 +--
 .../testing/selftests/kvm/lib/x86/processor.c |  13 +
 tools/testing/selftests/kvm/lib/x86/svm.c     |  29 +-
 tools/testing/selftests/kvm/lib/x86/ucall.c   |  32 +-
 .../kvm/x86/stress_save_restore_pf_test.c     | 320 ++++++++++++++++++
 7 files changed, 414 insertions(+), 92 deletions(-)
 create mode 100644 tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c

base-commit: a9512a611bd030088f13477258d1f8103cceaa40

Signature · 1 line
2.54.0.563.g4f69b47b94-goog
#11 lore raw
In reply to Yosry Ahmed
Quoted 26 lines · Yosry Ahmed

Add a stress test for save+restore while the guest is triggering and handling #PFs, in both L1 and L2. The goal was to create a generic selftest that would catch bugs like the one fixed by 5c247d08bc81 ("KVM:
nSVM: Use vcpu->arch.cr2 when updating vmcb12 on nested #VMEXIT"), instead of relying on high-level testing (e.g. building GCC in L2) to catch it.

The test tries to be as generic as possible by triggering #PFs in a guest and installing a proper #PF handler, while the host is continuously doing save+restore cycles. Exiting to userspace is randomly triggered by a second thread that constantly signals the vCPU thread.

Patches (1-4) are prep patches, fixing GPR switching for nSVM and generalizing it to cover nVMX, which is needed for the test to run properly with nVMX. Patch 4 removes HORRIFIC_L2_UCALL_CLOBBER_HACK, as it is no longer needed. While this series does not have the "complete" fix added by commit 6783ca4105a7 ("KVM: selftests: Add a shameful hack to preserve/clobber GPRs across ucall"), it's a good step in the right direction.

Patches (5-8) add the actual test. The test is first introduced as a simple (read: dummy) stress test that just explicitly syncs to userspace after each #PF handling to do save+restore, then gradually evolves to add the random signaling and nested support. After the last patch, the test reliably reproduces the CR2 bug.

Quoted 8 lines

This series conflicts with reworking L2 stack allocation in [1], but the conflict should be trivial to fix regardless of which series lands first.

[1]https://lore.kernel.org/kvm/[email protected]/

Yosry Ahmed (8):
KVM: selftests: Fix offsets in GPR switching for nSVM

This series will need a new version with a reworked patch 1, potentially after some TDX selftests infrastructure lands. The .equ approach to define offsets doesn't always work. See details here:

https://lore.kernel.org/kvm/[email protected]/

Quoted 25 lines

KVM: selftests: Move GPR load/save definitions outside of nSVM code
KVM: selftests: Reuse GPR switching logic for nVMX
KVM: selftests: Drop HORRIFIC_L2_UCALL_CLOBBER_HACK
KVM: selftests: Add basic stress test for save+restore and #PF
handling
KVM: selftests: Trigger save+restore randomly in the #PF stress test
KVM: selftests: Support running stress save+restore and #PF test in L2
KVM: selftests: Trigger L2->L1 exits stress save+restore and #PF test

 tools/testing/selftests/kvm/Makefile.kvm      |   1 +
 .../selftests/kvm/include/x86/processor.h     |  65 +++-
 tools/testing/selftests/kvm/include/x86/vmx.h |  46 +--
 .../testing/selftests/kvm/lib/x86/processor.c |  13 +
 tools/testing/selftests/kvm/lib/x86/svm.c     |  29 +-
 tools/testing/selftests/kvm/lib/x86/ucall.c   |  32 +-
 .../kvm/x86/stress_save_restore_pf_test.c     | 320 ++++++++++++++++++
 7 files changed, 414 insertions(+), 92 deletions(-)
 create mode 100644 tools/testing/selftests/kvm/x86/stress_save_restore_pf_test.c

base-commit: a9512a611bd030088f13477258d1f8103cceaa40

Signature · 1 line
2.54.0.563.g4f69b47b94-goog