KVM: selftests: Add test to verify KVM_CAP_X86_BUS_LOCK_EXIT

Add a test case to verify x86's bus lock exit functionality, which is now
supported on both Intel and AMD.  Trigger bus lock exits by performing a
split-lock access, i.e. an atomic access that splits two cache lines.

Verify that the correct number of bus lock exits are generated, and that
the counter is incremented correctly and at the appropriate time based on
the underlying architecture.

Generate bus locks in both L1 and L2 (if nested virtualization is enabled),
as SVM's functionality in particular requires non-trivial logic to do the
right thing when running nested VMs.

Signed-off-by: Nikunj A Dadhania <nikunj@amd.com>
Co-developed-by: Manali Shukla <manali.shukla@amd.com>
Signed-off-by: Manali Shukla <manali.shukla@amd.com>
Link: https://lore.kernel.org/r/20250502050346.14274-6-manali.shukla@amd.com
Co-developed-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Sean Christopherson <seanjc@google.com>

diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selftests/kvm/Makefile.kvm
index f62b0a5aba35a06a1845e9dfc49064431791853d..fa65b82c1f5304d656a036c08f051cd6baae96e9 100644 (file)
--- a/tools/testing/selftests/kvm/Makefile.kvm
+++ b/tools/testing/selftests/kvm/Makefile.kvm
@@ -78,6 +78,7 @@ TEST_GEN_PROGS_x86 += x86/hyperv_svm_test
 TEST_GEN_PROGS_x86 += x86/hyperv_tlb_flush
 TEST_GEN_PROGS_x86 += x86/kvm_clock_test
 TEST_GEN_PROGS_x86 += x86/kvm_pv_test
+TEST_GEN_PROGS_x86 += x86/kvm_buslock_test
 TEST_GEN_PROGS_x86 += x86/monitor_mwait_test
 TEST_GEN_PROGS_x86 += x86/nested_emulation_test
 TEST_GEN_PROGS_x86 += x86/nested_exceptions_test

diff --git a/tools/testing/selftests/kvm/x86/kvm_buslock_test.c b/tools/testing/selftests/kvm/x86/kvm_buslock_test.c
new file mode 100644 (file)
index 0000000..d88500c
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86/kvm_buslock_test.c
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2024 Advanced Micro Devices, Inc.
+ */
+#include <linux/atomic.h>
+
+#include "kvm_util.h"
+#include "processor.h"
+#include "svm_util.h"
+#include "vmx.h"
+#include "test_util.h"
+
+#define NR_BUS_LOCKS_PER_LEVEL 100
+#define CACHE_LINE_SIZE                64
+
+/*
+ * To generate a bus lock, carve out a buffer that precisely occupies two cache
+ * lines and perform an atomic access that splits the two lines.
+ */
+static u8 buffer[CACHE_LINE_SIZE * 2] __aligned(CACHE_LINE_SIZE);
+static atomic_t *val = (void *)&buffer[CACHE_LINE_SIZE - (sizeof(*val) / 2)];
+
+static void guest_generate_buslocks(void)
+{
+       for (int i = 0; i < NR_BUS_LOCKS_PER_LEVEL; i++)
+               atomic_inc(val);
+}
+
+#define L2_GUEST_STACK_SIZE    64
+
+static void l2_guest_code(void)
+{
+       guest_generate_buslocks();
+       GUEST_DONE();
+}
+
+static void l1_svm_code(struct svm_test_data *svm)
+{
+       unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
+       struct vmcb *vmcb = svm->vmcb;
+
+       generic_svm_setup(svm, l2_guest_code, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
+       run_guest(vmcb, svm->vmcb_gpa);
+}
+
+static void l1_vmx_code(struct vmx_pages *vmx)
+{
+       unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
+
+       GUEST_ASSERT_EQ(prepare_for_vmx_operation(vmx), true);
+       GUEST_ASSERT_EQ(load_vmcs(vmx), true);
+
+       prepare_vmcs(vmx, NULL, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
+
+       GUEST_ASSERT(!vmwrite(GUEST_RIP, (u64)l2_guest_code));
+       GUEST_ASSERT(!vmlaunch());
+}
+
+static void guest_code(void *test_data)
+{
+       guest_generate_buslocks();
+
+       if (this_cpu_has(X86_FEATURE_SVM))
+               l1_svm_code(test_data);
+       else if (this_cpu_has(X86_FEATURE_VMX))
+               l1_vmx_code(test_data);
+       else
+               GUEST_DONE();
+
+       TEST_FAIL("L2 should have signaled 'done'");
+}
+
+int main(int argc, char *argv[])
+{
+       const bool has_nested = kvm_cpu_has(X86_FEATURE_SVM) || kvm_cpu_has(X86_FEATURE_VMX);
+       vm_vaddr_t nested_test_data_gva;
+       struct kvm_vcpu *vcpu;
+       struct kvm_run *run;
+       struct kvm_vm *vm;
+       int i, bus_locks = 0;
+
+       TEST_REQUIRE(kvm_has_cap(KVM_CAP_X86_BUS_LOCK_EXIT));
+
+       vm = vm_create(1);
+       vm_enable_cap(vm, KVM_CAP_X86_BUS_LOCK_EXIT, KVM_BUS_LOCK_DETECTION_EXIT);
+       vcpu = vm_vcpu_add(vm, 0, guest_code);
+
+       if (kvm_cpu_has(X86_FEATURE_SVM))
+               vcpu_alloc_svm(vm, &nested_test_data_gva);
+       else
+               vcpu_alloc_vmx(vm, &nested_test_data_gva);
+
+       vcpu_args_set(vcpu, 1, nested_test_data_gva);
+
+       run = vcpu->run;
+
+       for (i = 0; i <= NR_BUS_LOCKS_PER_LEVEL * (1 + has_nested); i++) {
+               struct ucall uc;
+
+               vcpu_run(vcpu);
+
+               if (run->exit_reason == KVM_EXIT_IO) {
+                       switch (get_ucall(vcpu, &uc)) {
+                       case UCALL_ABORT:
+                               REPORT_GUEST_ASSERT(uc);
+                               goto done;
+                       case UCALL_SYNC:
+                               continue;
+                       case UCALL_DONE:
+                               goto done;
+                       default:
+                               TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd);
+                       }
+               }
+
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_X86_BUS_LOCK);
+
+               /*
+                * Verify the counter is actually getting incremented, e.g. that
+                * KVM isn't skipping the instruction.  On Intel, the exit is
+                * trap-like, i.e. the counter should already have been
+                * incremented.  On AMD, it's fault-like, i.e. the counter will
+                * be incremented when the guest re-executes the instruction.
+                */
+               sync_global_from_guest(vm, *val);
+               TEST_ASSERT_EQ(atomic_read(val), bus_locks + host_cpu_is_intel);
+
+               bus_locks++;
+       }
+       TEST_FAIL("Didn't receive UCALL_DONE, took %u bus lock exits\n", bus_locks);
+done:
+       TEST_ASSERT_EQ(i, bus_locks);
+       kvm_vm_free(vm);
+       return 0;
+}