KVM: arm64: selftests: Add basic SError injection test

Add tests for SError injection considering KVM is more directly involved
in delivery:

 - Pending SErrors are taken at the first CSE after SErrors are unmasked

 - Pending SErrors aren't taken and remain pending if SErrors are masked

 - Unmasked SErrors are taken immediately when injected (implementation
   detail)

Reviewed-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20250708172532.1699409-25-oliver.upton@linux.dev
Signed-off-by: Oliver Upton <oliver.upton@linux.dev>

diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selftests/kvm/Makefile.kvm
index 38b95998e1e6b5d3ebda841c40a6164546de2185..ce817a975e50a039acb94c4b314932bde6e7430b 100644 (file)
--- a/tools/testing/selftests/kvm/Makefile.kvm
+++ b/tools/testing/selftests/kvm/Makefile.kvm
@@ -156,7 +156,7 @@ TEST_GEN_PROGS_arm64 += arm64/arch_timer_edge_cases
 TEST_GEN_PROGS_arm64 += arm64/debug-exceptions
 TEST_GEN_PROGS_arm64 += arm64/host_sve
 TEST_GEN_PROGS_arm64 += arm64/hypercalls
-TEST_GEN_PROGS_arm64 += arm64/mmio_abort
+TEST_GEN_PROGS_arm64 += arm64/external_aborts
 TEST_GEN_PROGS_arm64 += arm64/page_fault_test
 TEST_GEN_PROGS_arm64 += arm64/psci_test
 TEST_GEN_PROGS_arm64 += arm64/set_id_regs

diff --git a/tools/testing/selftests/kvm/arm64/external_aborts.c b/tools/testing/selftests/kvm/arm64/external_aborts.c
new file mode 100644 (file)
index 0000000..f49c98b
--- /dev/null
+++ b/tools/testing/selftests/kvm/arm64/external_aborts.c
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * external_abort - Tests for userspace external abort injection
+ *
+ * Copyright (c) 2024 Google LLC
+ */
+#include "processor.h"
+#include "test_util.h"
+
+#define MMIO_ADDR      0x8000000ULL
+
+static u64 expected_abort_pc;
+
+static void expect_sea_handler(struct ex_regs *regs)
+{
+       u64 esr = read_sysreg(esr_el1);
+
+       GUEST_ASSERT_EQ(regs->pc, expected_abort_pc);
+       GUEST_ASSERT_EQ(ESR_ELx_EC(esr), ESR_ELx_EC_DABT_CUR);
+       GUEST_ASSERT_EQ(esr & ESR_ELx_FSC_TYPE, ESR_ELx_FSC_EXTABT);
+
+       GUEST_DONE();
+}
+
+static void unexpected_dabt_handler(struct ex_regs *regs)
+{
+       GUEST_FAIL("Unexpected data abort at PC: %lx\n", regs->pc);
+}
+
+static struct kvm_vm *vm_create_with_dabt_handler(struct kvm_vcpu **vcpu, void *guest_code,
+                                                 handler_fn dabt_handler)
+{
+       struct kvm_vm *vm = vm_create_with_one_vcpu(vcpu, guest_code);
+
+       vm_init_descriptor_tables(vm);
+       vcpu_init_descriptor_tables(*vcpu);
+       vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, ESR_ELx_EC_DABT_CUR, dabt_handler);
+
+       virt_map(vm, MMIO_ADDR, MMIO_ADDR, 1);
+
+       return vm;
+}
+
+static void vcpu_inject_sea(struct kvm_vcpu *vcpu)
+{
+       struct kvm_vcpu_events events = {};
+
+       events.exception.ext_dabt_pending = true;
+       vcpu_events_set(vcpu, &events);
+}
+
+static void vcpu_inject_serror(struct kvm_vcpu *vcpu)
+{
+       struct kvm_vcpu_events events = {};
+
+       events.exception.serror_pending = true;
+       vcpu_events_set(vcpu, &events);
+}
+
+static void __vcpu_run_expect(struct kvm_vcpu *vcpu, unsigned int cmd)
+{
+       struct ucall uc;
+
+       vcpu_run(vcpu);
+       switch (get_ucall(vcpu, &uc)) {
+       case UCALL_ABORT:
+               REPORT_GUEST_ASSERT(uc);
+               break;
+       default:
+               if (uc.cmd == cmd)
+                       return;
+
+               TEST_FAIL("Unexpected ucall: %lu", uc.cmd);
+       }
+}
+
+static void vcpu_run_expect_done(struct kvm_vcpu *vcpu)
+{
+       __vcpu_run_expect(vcpu, UCALL_DONE);
+}
+
+static void vcpu_run_expect_sync(struct kvm_vcpu *vcpu)
+{
+       __vcpu_run_expect(vcpu, UCALL_SYNC);
+}
+
+extern char test_mmio_abort_insn;
+
+static void test_mmio_abort_guest(void)
+{
+       WRITE_ONCE(expected_abort_pc, (u64)&test_mmio_abort_insn);
+
+       asm volatile("test_mmio_abort_insn:\n\t"
+                    "ldr x0, [%0]\n\t"
+                    : : "r" (MMIO_ADDR) : "x0", "memory");
+
+       GUEST_FAIL("MMIO instruction should not retire");
+}
+
+/*
+ * Test that KVM doesn't complete MMIO emulation when userspace has made an
+ * external abort pending for the instruction.
+ */
+static void test_mmio_abort(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_abort_guest,
+                                                       expect_sea_handler);
+       struct kvm_run *run = vcpu->run;
+
+       vcpu_run(vcpu);
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_MMIO);
+       TEST_ASSERT_EQ(run->mmio.phys_addr, MMIO_ADDR);
+       TEST_ASSERT_EQ(run->mmio.len, sizeof(unsigned long));
+       TEST_ASSERT(!run->mmio.is_write, "Expected MMIO read");
+
+       vcpu_inject_sea(vcpu);
+       vcpu_run_expect_done(vcpu);
+       kvm_vm_free(vm);
+}
+
+extern char test_mmio_nisv_insn;
+
+static void test_mmio_nisv_guest(void)
+{
+       WRITE_ONCE(expected_abort_pc, (u64)&test_mmio_nisv_insn);
+
+       asm volatile("test_mmio_nisv_insn:\n\t"
+                    "ldr x0, [%0], #8\n\t"
+                    : : "r" (MMIO_ADDR) : "x0", "memory");
+
+       GUEST_FAIL("MMIO instruction should not retire");
+}
+
+/*
+ * Test that the KVM_RUN ioctl fails for ESR_EL2.ISV=0 MMIO aborts if userspace
+ * hasn't enabled KVM_CAP_ARM_NISV_TO_USER.
+ */
+static void test_mmio_nisv(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_nisv_guest,
+                                                       unexpected_dabt_handler);
+
+       TEST_ASSERT(_vcpu_run(vcpu), "Expected nonzero return code from KVM_RUN");
+       TEST_ASSERT_EQ(errno, ENOSYS);
+
+       kvm_vm_free(vm);
+}
+
+/*
+ * Test that ESR_EL2.ISV=0 MMIO aborts reach userspace and that an injected SEA
+ * reaches the guest.
+ */
+static void test_mmio_nisv_abort(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_nisv_guest,
+                                                       expect_sea_handler);
+       struct kvm_run *run = vcpu->run;
+
+       vm_enable_cap(vm, KVM_CAP_ARM_NISV_TO_USER, 1);
+
+       vcpu_run(vcpu);
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_ARM_NISV);
+       TEST_ASSERT_EQ(run->arm_nisv.fault_ipa, MMIO_ADDR);
+
+       vcpu_inject_sea(vcpu);
+       vcpu_run_expect_done(vcpu);
+       kvm_vm_free(vm);
+}
+
+static void unexpected_serror_handler(struct ex_regs *regs)
+{
+       GUEST_FAIL("Took unexpected SError exception");
+}
+
+static void test_serror_masked_guest(void)
+{
+       GUEST_ASSERT(read_sysreg(isr_el1) & ISR_EL1_A);
+
+       isb();
+
+       GUEST_DONE();
+}
+
+static void test_serror_masked(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_serror_masked_guest,
+                                                       unexpected_dabt_handler);
+
+       vm_install_exception_handler(vm, VECTOR_ERROR_CURRENT, unexpected_serror_handler);
+
+       vcpu_inject_serror(vcpu);
+       vcpu_run_expect_done(vcpu);
+       kvm_vm_free(vm);
+}
+
+static void expect_serror_handler(struct ex_regs *regs)
+{
+       GUEST_DONE();
+}
+
+static void test_serror_guest(void)
+{
+       GUEST_ASSERT(read_sysreg(isr_el1) & ISR_EL1_A);
+
+       local_serror_enable();
+       isb();
+       local_serror_disable();
+
+       GUEST_FAIL("Should've taken pending SError exception");
+}
+
+static void test_serror(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_serror_guest,
+                                                       unexpected_dabt_handler);
+
+       vm_install_exception_handler(vm, VECTOR_ERROR_CURRENT, expect_serror_handler);
+
+       vcpu_inject_serror(vcpu);
+       vcpu_run_expect_done(vcpu);
+       kvm_vm_free(vm);
+}
+
+static void test_serror_emulated_guest(void)
+{
+       GUEST_ASSERT(!(read_sysreg(isr_el1) & ISR_EL1_A));
+
+       local_serror_enable();
+       GUEST_SYNC(0);
+       local_serror_disable();
+
+       GUEST_FAIL("Should've taken unmasked SError exception");
+}
+
+static void test_serror_emulated(void)
+{
+       struct kvm_vcpu *vcpu;
+       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_serror_emulated_guest,
+                                                       unexpected_dabt_handler);
+
+       vm_install_exception_handler(vm, VECTOR_ERROR_CURRENT, expect_serror_handler);
+
+       vcpu_run_expect_sync(vcpu);
+       vcpu_inject_serror(vcpu);
+       vcpu_run_expect_done(vcpu);
+       kvm_vm_free(vm);
+}
+
+int main(void)
+{
+       test_mmio_abort();
+       test_mmio_nisv();
+       test_mmio_nisv_abort();
+       test_serror();
+       test_serror_masked();
+       test_serror_emulated();
+}

diff --git a/tools/testing/selftests/kvm/arm64/mmio_abort.c b/tools/testing/selftests/kvm/arm64/mmio_abort.c
deleted file mode 100644 (file)
index 8b7a80a..0000000
--- a/tools/testing/selftests/kvm/arm64/mmio_abort.c
+++ /dev/null
@@ -1,159 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * mmio_abort - Tests for userspace MMIO abort injection
- *
- * Copyright (c) 2024 Google LLC
- */
-#include "processor.h"
-#include "test_util.h"
-
-#define MMIO_ADDR      0x8000000ULL
-
-static u64 expected_abort_pc;
-
-static void expect_sea_handler(struct ex_regs *regs)
-{
-       u64 esr = read_sysreg(esr_el1);
-
-       GUEST_ASSERT_EQ(regs->pc, expected_abort_pc);
-       GUEST_ASSERT_EQ(ESR_ELx_EC(esr), ESR_ELx_EC_DABT_CUR);
-       GUEST_ASSERT_EQ(esr & ESR_ELx_FSC_TYPE, ESR_ELx_FSC_EXTABT);
-
-       GUEST_DONE();
-}
-
-static void unexpected_dabt_handler(struct ex_regs *regs)
-{
-       GUEST_FAIL("Unexpected data abort at PC: %lx\n", regs->pc);
-}
-
-static struct kvm_vm *vm_create_with_dabt_handler(struct kvm_vcpu **vcpu, void *guest_code,
-                                                 handler_fn dabt_handler)
-{
-       struct kvm_vm *vm = vm_create_with_one_vcpu(vcpu, guest_code);
-
-       vm_init_descriptor_tables(vm);
-       vcpu_init_descriptor_tables(*vcpu);
-       vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, ESR_ELx_EC_DABT_CUR, dabt_handler);
-
-       virt_map(vm, MMIO_ADDR, MMIO_ADDR, 1);
-
-       return vm;
-}
-
-static void vcpu_inject_extabt(struct kvm_vcpu *vcpu)
-{
-       struct kvm_vcpu_events events = {};
-
-       events.exception.ext_dabt_pending = true;
-       vcpu_events_set(vcpu, &events);
-}
-
-static void vcpu_run_expect_done(struct kvm_vcpu *vcpu)
-{
-       struct ucall uc;
-
-       vcpu_run(vcpu);
-       switch (get_ucall(vcpu, &uc)) {
-       case UCALL_ABORT:
-               REPORT_GUEST_ASSERT(uc);
-               break;
-       case UCALL_DONE:
-               break;
-       default:
-               TEST_FAIL("Unexpected ucall: %lu", uc.cmd);
-       }
-}
-
-extern char test_mmio_abort_insn;
-
-static void test_mmio_abort_guest(void)
-{
-       WRITE_ONCE(expected_abort_pc, (u64)&test_mmio_abort_insn);
-
-       asm volatile("test_mmio_abort_insn:\n\t"
-                    "ldr x0, [%0]\n\t"
-                    : : "r" (MMIO_ADDR) : "x0", "memory");
-
-       GUEST_FAIL("MMIO instruction should not retire");
-}
-
-/*
- * Test that KVM doesn't complete MMIO emulation when userspace has made an
- * external abort pending for the instruction.
- */
-static void test_mmio_abort(void)
-{
-       struct kvm_vcpu *vcpu;
-       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_abort_guest,
-                                                       expect_sea_handler);
-       struct kvm_run *run = vcpu->run;
-
-       vcpu_run(vcpu);
-       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_MMIO);
-       TEST_ASSERT_EQ(run->mmio.phys_addr, MMIO_ADDR);
-       TEST_ASSERT_EQ(run->mmio.len, sizeof(unsigned long));
-       TEST_ASSERT(!run->mmio.is_write, "Expected MMIO read");
-
-       vcpu_inject_extabt(vcpu);
-       vcpu_run_expect_done(vcpu);
-       kvm_vm_free(vm);
-}
-
-extern char test_mmio_nisv_insn;
-
-static void test_mmio_nisv_guest(void)
-{
-       WRITE_ONCE(expected_abort_pc, (u64)&test_mmio_nisv_insn);
-
-       asm volatile("test_mmio_nisv_insn:\n\t"
-                    "ldr x0, [%0], #8\n\t"
-                    : : "r" (MMIO_ADDR) : "x0", "memory");
-
-       GUEST_FAIL("MMIO instruction should not retire");
-}
-
-/*
- * Test that the KVM_RUN ioctl fails for ESR_EL2.ISV=0 MMIO aborts if userspace
- * hasn't enabled KVM_CAP_ARM_NISV_TO_USER.
- */
-static void test_mmio_nisv(void)
-{
-       struct kvm_vcpu *vcpu;
-       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_nisv_guest,
-                                                       unexpected_dabt_handler);
-
-       TEST_ASSERT(_vcpu_run(vcpu), "Expected nonzero return code from KVM_RUN");
-       TEST_ASSERT_EQ(errno, ENOSYS);
-
-       kvm_vm_free(vm);
-}
-
-/*
- * Test that ESR_EL2.ISV=0 MMIO aborts reach userspace and that an injected SEA
- * reaches the guest.
- */
-static void test_mmio_nisv_abort(void)
-{
-       struct kvm_vcpu *vcpu;
-       struct kvm_vm *vm = vm_create_with_dabt_handler(&vcpu, test_mmio_nisv_guest,
-                                                       expect_sea_handler);
-       struct kvm_run *run = vcpu->run;
-
-       vm_enable_cap(vm, KVM_CAP_ARM_NISV_TO_USER, 1);
-
-       vcpu_run(vcpu);
-       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_ARM_NISV);
-       TEST_ASSERT_EQ(run->arm_nisv.fault_ipa, MMIO_ADDR);
-
-       vcpu_inject_extabt(vcpu);
-       vcpu_run_expect_done(vcpu);
-       kvm_vm_free(vm);
-}
-
-int main(void)
-{
-       test_mmio_abort();
-       test_mmio_nisv();
-       test_mmio_nisv_abort();
-}

diff --git a/tools/testing/selftests/kvm/include/arm64/processor.h b/tools/testing/selftests/kvm/include/arm64/processor.h
index b0fc0f945766fe82db70bbab693990c0609282f9..255fed769a8a54ece6876e2106d42f9184dafbc4 100644 (file)
--- a/tools/testing/selftests/kvm/include/arm64/processor.h
+++ b/tools/testing/selftests/kvm/include/arm64/processor.h
@@ -254,6 +254,16 @@ static inline void local_irq_disable(void)
        asm volatile("msr daifset, #3" : : : "memory");
 }
 
+static inline void local_serror_enable(void)
+{
+       asm volatile("msr daifclr, #4" : : : "memory");
+}
+
+static inline void local_serror_disable(void)
+{
+       asm volatile("msr daifset, #4" : : : "memory");
+}
+
 /**
  * struct arm_smccc_res - Result from SMC/HVC call
  * @a0-a3 result values from registers 0 to 3