KVM: selftests: Make vCPU exit reason test assertion common

Make TEST_ASSERT_KVM_EXIT_REASON() macro and replace all exit reason
test assert statements with it.

No functional changes intended.

Signed-off-by: Vipin Sharma <vipinsh@google.com>
Reviewed-by: David Matlack <dmatlack@google.com>
Message-Id: <20230204014547.583711-2-vipinsh@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/aarch64/psci_test.c b/tools/testing/selftests/kvm/aarch64/psci_test.c
index cfa36f38794844078b8f429f845b427831b326c4..9b004905d1d3141c19051055c51a7900cbbdbea1 100644 (file)
--- a/tools/testing/selftests/kvm/aarch64/psci_test.c
+++ b/tools/testing/selftests/kvm/aarch64/psci_test.c
@@ -180,9 +180,7 @@ static void host_test_system_suspend(void)
 
        enter_guest(source);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_SYSTEM_EVENT,
-                   "Unhandled exit reason: %u (%s)",
-                   run->exit_reason, exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(source, KVM_EXIT_SYSTEM_EVENT);
        TEST_ASSERT(run->system_event.type == KVM_SYSTEM_EVENT_SUSPEND,
                    "Unhandled system event: %u (expected: %u)",
                    run->system_event.type, KVM_SYSTEM_EVENT_SUSPEND);

diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testing/selftests/kvm/include/test_util.h
index 80d6416f3012e6c8605b1e5fb07a21085a0f7cd7..a13663557e2b0159d01bb368e2bc2ebe5d7b58a1 100644 (file)
--- a/tools/testing/selftests/kvm/include/test_util.h
+++ b/tools/testing/selftests/kvm/include/test_util.h
@@ -63,6 +63,14 @@ void test_assert(bool exp, const char *exp_str,
                    #a, #b, #a, (unsigned long) __a, #b, (unsigned long) __b); \
 } while (0)
 
+#define TEST_ASSERT_KVM_EXIT_REASON(vcpu, expected) do {               \
+       __u32 exit_reason = (vcpu)->run->exit_reason;                   \
+                                                                       \
+       TEST_ASSERT(exit_reason == (expected),                          \
+                   "Unexpected exit reason: %u (%s)",                  \
+                   exit_reason, exit_reason_str(exit_reason));         \
+} while (0)
+
 #define TEST_FAIL(fmt, ...) do { \
        TEST_ASSERT(false, fmt, ##__VA_ARGS__); \
        __builtin_unreachable(); \

diff --git a/tools/testing/selftests/kvm/lib/s390x/diag318_test_handler.c b/tools/testing/selftests/kvm/lib/s390x/diag318_test_handler.c
index cdb7daeed5fd956a1076c39d35bad166d09ac788..2c432fa164f194ade8a3d51a79f27c8dbb0e32ee 100644 (file)
--- a/tools/testing/selftests/kvm/lib/s390x/diag318_test_handler.c
+++ b/tools/testing/selftests/kvm/lib/s390x/diag318_test_handler.c
@@ -35,8 +35,7 @@ static uint64_t diag318_handler(void)
        vcpu_run(vcpu);
        run = vcpu->run;
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
-                   "DIAGNOSE 0x0318 instruction was not intercepted");
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_S390_SIEIC);
        TEST_ASSERT(run->s390_sieic.icptcode == ICPT_INSTRUCTION,
                    "Unexpected intercept code: 0x%x", run->s390_sieic.icptcode);
        TEST_ASSERT((run->s390_sieic.ipa & 0xff00) == IPA0_DIAG,

diff --git a/tools/testing/selftests/kvm/s390x/sync_regs_test.c b/tools/testing/selftests/kvm/s390x/sync_regs_test.c
index 2ddde41c44ba994904c1e73228528da2182c49a8..636a70ddac1ea36151cb57a0dfd74ddcca33de14 100644 (file)
--- a/tools/testing/selftests/kvm/s390x/sync_regs_test.c
+++ b/tools/testing/selftests/kvm/s390x/sync_regs_test.c
@@ -126,10 +126,7 @@ void test_req_and_verify_all_valid_regs(struct kvm_vcpu *vcpu)
        run->kvm_valid_regs = TEST_SYNC_FIELDS;
        rv = _vcpu_run(vcpu);
        TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
-                   "Unexpected exit reason: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_S390_SIEIC);
        TEST_ASSERT(run->s390_sieic.icptcode == 4 &&
                    (run->s390_sieic.ipa >> 8) == 0x83 &&
                    (run->s390_sieic.ipb >> 16) == 0x501,
@@ -165,10 +162,7 @@ void test_set_and_verify_various_reg_values(struct kvm_vcpu *vcpu)
 
        rv = _vcpu_run(vcpu);
        TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
-                   "Unexpected exit reason: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_S390_SIEIC);
        TEST_ASSERT(run->s.regs.gprs[11] == 0xBAD1DEA + 1,
                    "r11 sync regs value incorrect 0x%llx.",
                    run->s.regs.gprs[11]);
@@ -200,10 +194,7 @@ void test_clear_kvm_dirty_regs_bits(struct kvm_vcpu *vcpu)
        run->s.regs.diag318 = 0x4B1D;
        rv = _vcpu_run(vcpu);
        TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
-                   "Unexpected exit reason: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_S390_SIEIC);
        TEST_ASSERT(run->s.regs.gprs[11] != 0xDEADBEEF,
                    "r11 sync regs value incorrect 0x%llx.",
                    run->s.regs.gprs[11]);

diff --git a/tools/testing/selftests/kvm/set_memory_region_test.c b/tools/testing/selftests/kvm/set_memory_region_test.c
index 2ef1d1b72ce43194894386df947b0a2def9b2f49..a849ce23ca97560eed95b3ba44b0492a2bc17902 100644 (file)
--- a/tools/testing/selftests/kvm/set_memory_region_test.c
+++ b/tools/testing/selftests/kvm/set_memory_region_test.c
@@ -308,7 +308,6 @@ static void test_delete_memory_region(void)
 static void test_zero_memory_regions(void)
 {
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        struct kvm_vm *vm;
 
        pr_info("Testing KVM_RUN with zero added memory regions\n");
@@ -318,10 +317,7 @@ static void test_zero_memory_regions(void)
 
        vm_ioctl(vm, KVM_SET_NR_MMU_PAGES, (void *)64ul);
        vcpu_run(vcpu);
-
-       run = vcpu->run;
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_INTERNAL_ERROR,
-                   "Unexpected exit_reason = %u\n", run->exit_reason);
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR);
 
        kvm_vm_free(vm);
 }

diff --git a/tools/testing/selftests/kvm/x86_64/amx_test.c b/tools/testing/selftests/kvm/x86_64/amx_test.c
index bd72c6eb3b670a4f49dab41f67d97cadfd3278c3..b646cdb5055adb3ab9f3f03e68381d422ed5e27d 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/amx_test.c
+++ b/tools/testing/selftests/kvm/x86_64/amx_test.c
@@ -241,7 +241,6 @@ int main(int argc, char *argv[])
        struct kvm_regs regs1, regs2;
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct kvm_x86_state *state;
        int xsave_restore_size;
        vm_vaddr_t amx_cfg, tiledata, xsavedata;
@@ -268,7 +267,6 @@ int main(int argc, char *argv[])
                    "KVM should enumerate max XSAVE size when XSAVE is supported");
        xsave_restore_size = kvm_cpu_property(X86_PROPERTY_XSTATE_MAX_SIZE);
 
-       run = vcpu->run;
        vcpu_regs_get(vcpu, &regs1);
 
        /* Register #NM handler */
@@ -291,10 +289,7 @@ int main(int argc, char *argv[])
 
        for (stage = 1; ; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:
@@ -350,7 +345,6 @@ int main(int argc, char *argv[])
                /* Restore state in a new VM.  */
                vcpu = vm_recreate_with_one_vcpu(vm);
                vcpu_load_state(vcpu, state);
-               run = vcpu->run;
                kvm_x86_state_cleanup(state);
 
                memset(&regs2, 0, sizeof(regs2));

diff --git a/tools/testing/selftests/kvm/x86_64/cr4_cpuid_sync_test.c b/tools/testing/selftests/kvm/x86_64/cr4_cpuid_sync_test.c
index 1027a671c7d3aaceb3971ec3b10ca28227cb29d6..624dc725e14dc0d3170b7fbe6414c92907102027 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/cr4_cpuid_sync_test.c
+++ b/tools/testing/selftests/kvm/x86_64/cr4_cpuid_sync_test.c
@@ -50,7 +50,6 @@ static void guest_code(void)
 int main(int argc, char *argv[])
 {
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        struct kvm_vm *vm;
        struct kvm_sregs sregs;
        struct ucall uc;
@@ -58,15 +57,10 @@ int main(int argc, char *argv[])
        TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_XSAVE));
 
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
-       run = vcpu->run;
 
        while (1) {
                vcpu_run(vcpu);
-
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Unexpected exit reason: %u (%s),\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/debug_regs.c b/tools/testing/selftests/kvm/x86_64/debug_regs.c
index 7ef99c3359a0db8eda4bde8026fc831a62f33a93..f6b295e0b2d2bb2ef7d8f3f9359df5125c17069d 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/debug_regs.c
+++ b/tools/testing/selftests/kvm/x86_64/debug_regs.c
@@ -204,7 +204,7 @@ int main(void)
        vcpu_guest_debug_set(vcpu, &debug);
 
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO, "KVM_EXIT_IO");
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        cmd = get_ucall(vcpu, &uc);
        TEST_ASSERT(cmd == UCALL_DONE, "UCALL_DONE");
 

diff --git a/tools/testing/selftests/kvm/x86_64/flds_emulation.h b/tools/testing/selftests/kvm/x86_64/flds_emulation.h
index e43a7df25f2c53321cfdc776de2b7fa87d992276..0a1573d52882b7b127307a829b0d1dc4d1af6560 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/flds_emulation.h
+++ b/tools/testing/selftests/kvm/x86_64/flds_emulation.h
@@ -24,10 +24,7 @@ static inline void handle_flds_emulation_failure_exit(struct kvm_vcpu *vcpu)
        uint8_t *insn_bytes;
        uint64_t flags;
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_INTERNAL_ERROR,
-                   "Unexpected exit reason: %u (%s)",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR);
 
        TEST_ASSERT(run->emulation_failure.suberror == KVM_INTERNAL_ERROR_EMULATION,
                    "Unexpected suberror: %u",

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_clock.c b/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
index 2ee0af0d449efcab6f14b4242f43ce40eeb7995c..f25749eaa6a84bb16f0405fdf8847ace33ce04ce 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
@@ -207,13 +207,11 @@ int main(void)
 {
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct ucall uc;
        vm_vaddr_t tsc_page_gva;
        int stage;
 
        vm = vm_create_with_one_vcpu(&vcpu, guest_main);
-       run = vcpu->run;
 
        vcpu_set_hv_cpuid(vcpu);
 
@@ -227,10 +225,7 @@ int main(void)
 
        for (stage = 1;; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_evmcs.c b/tools/testing/selftests/kvm/x86_64/hyperv_evmcs.c
index af29e5776d4034e90efc6a772596f703ff580ced..7bde0c4dfdbd18b769a2580c68c2e789a7a692a6 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_evmcs.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_evmcs.c
@@ -237,7 +237,6 @@ int main(int argc, char *argv[])
 
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct ucall uc;
        int stage;
 
@@ -266,13 +265,8 @@ int main(int argc, char *argv[])
        pr_info("Running L1 which uses EVMCS to run L2\n");
 
        for (stage = 1;; stage++) {
-               run = vcpu->run;
-
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_features.c b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
index c5e3b39edd0797b71fa3c0b386514b3fcac4ebe6..78606de9385dae2b4ff88fb9ddd69bc83c5a8962 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_features.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
@@ -122,7 +122,6 @@ static void guest_test_msrs_access(void)
 {
        struct kvm_cpuid2 *prev_cpuid = NULL;
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        struct kvm_vm *vm;
        struct ucall uc;
        int stage = 0;
@@ -151,8 +150,6 @@ static void guest_test_msrs_access(void)
                vm_init_descriptor_tables(vm);
                vcpu_init_descriptor_tables(vcpu);
 
-               run = vcpu->run;
-
                /* TODO: Make this entire test easier to maintain. */
                if (stage >= 21)
                        vcpu_enable_cap(vcpu, KVM_CAP_HYPERV_SYNIC2, 0);
@@ -494,9 +491,7 @@ static void guest_test_msrs_access(void)
                         msr->idx, msr->write ? "write" : "read");
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           run->exit_reason, exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:
@@ -518,7 +513,6 @@ static void guest_test_hcalls_access(void)
 {
        struct kvm_cpuid2 *prev_cpuid = NULL;
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        struct kvm_vm *vm;
        struct ucall uc;
        int stage = 0;
@@ -550,8 +544,6 @@ static void guest_test_hcalls_access(void)
                        vcpu_init_cpuid(vcpu, prev_cpuid);
                }
 
-               run = vcpu->run;
-
                switch (stage) {
                case 0:
                        vcpu_set_cpuid_feature(vcpu, HV_MSR_HYPERCALL_AVAILABLE);
@@ -669,9 +661,7 @@ static void guest_test_hcalls_access(void)
                pr_debug("Stage %d: testing hcall: 0x%lx\n", stage, hcall->control);
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           run->exit_reason, exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_ipi.c b/tools/testing/selftests/kvm/x86_64/hyperv_ipi.c
index 0cbb0e646ef8d7e7e804b730c773dcfd497a0658..6feb5ddb031dac66aeabe18b7733f8639f29af63 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_ipi.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_ipi.c
@@ -243,7 +243,6 @@ int main(int argc, char *argv[])
 {
        struct kvm_vm *vm;
        struct kvm_vcpu *vcpu[3];
-       unsigned int exit_reason;
        vm_vaddr_t hcall_page;
        pthread_t threads[2];
        int stage = 1, r;
@@ -283,10 +282,7 @@ int main(int argc, char *argv[])
        while (true) {
                vcpu_run(vcpu[0]);
 
-               exit_reason = vcpu[0]->run->exit_reason;
-               TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           exit_reason, exit_reason_str(exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu[0], KVM_EXIT_IO);
 
                switch (get_ucall(vcpu[0], &uc)) {
                case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_svm_test.c b/tools/testing/selftests/kvm/x86_64/hyperv_svm_test.c
index 68a7d354ea070a290cb818f7877fd712d0e7b1ea..e446d76d1c0c38f7ed41ff0ed3dfc736b6b3693c 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_svm_test.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_svm_test.c
@@ -156,7 +156,6 @@ int main(int argc, char *argv[])
        vm_vaddr_t hcall_page;
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct ucall uc;
        int stage;
 
@@ -165,7 +164,6 @@ int main(int argc, char *argv[])
        /* Create VM */
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
        vcpu_set_hv_cpuid(vcpu);
-       run = vcpu->run;
        vcpu_alloc_svm(vm, &nested_gva);
        vcpu_alloc_hyperv_test_pages(vm, &hv_pages_gva);
 
@@ -177,10 +175,7 @@ int main(int argc, char *argv[])
 
        for (stage = 1;; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_tlb_flush.c b/tools/testing/selftests/kvm/x86_64/hyperv_tlb_flush.c
index 68f97ff720a74f8eeb3c3a4d12daa84d24696954..4758b6ef5618e387d3a838908e78d2e51af79fa7 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_tlb_flush.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_tlb_flush.c
@@ -542,18 +542,13 @@ static void *vcpu_thread(void *arg)
        struct ucall uc;
        int old;
        int r;
-       unsigned int exit_reason;
 
        r = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
        TEST_ASSERT(!r, "pthread_setcanceltype failed on vcpu_id=%u with errno=%d",
                    vcpu->id, r);
 
        vcpu_run(vcpu);
-       exit_reason = vcpu->run->exit_reason;
-
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "vCPU %u exited with unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   vcpu->id, exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        switch (get_ucall(vcpu, &uc)) {
        case UCALL_ABORT:
@@ -587,7 +582,6 @@ int main(int argc, char *argv[])
 {
        struct kvm_vm *vm;
        struct kvm_vcpu *vcpu[3];
-       unsigned int exit_reason;
        pthread_t threads[2];
        vm_vaddr_t test_data_page, gva;
        vm_paddr_t gpa;
@@ -657,11 +651,7 @@ int main(int argc, char *argv[])
 
        while (true) {
                vcpu_run(vcpu[0]);
-               exit_reason = vcpu[0]->run->exit_reason;
-
-               TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           exit_reason, exit_reason_str(exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu[0], KVM_EXIT_IO);
 
                switch (get_ucall(vcpu[0], &uc)) {
                case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
index 813ce282cf5612b72e9909c7f825f94dfb2bc231..1778704360a6634ee7df3dfacd8f63fd3d236cab 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
+++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
@@ -105,7 +105,6 @@ static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
 static void enter_guest(struct kvm_vcpu *vcpu)
 {
        struct kvm_clock_data start, end;
-       struct kvm_run *run = vcpu->run;
        struct kvm_vm *vm = vcpu->vm;
        struct ucall uc;
        int i;
@@ -118,9 +117,7 @@ static void enter_guest(struct kvm_vcpu *vcpu)
                vcpu_run(vcpu);
                vm_ioctl(vm, KVM_GET_CLOCK, &end);
 
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           run->exit_reason, exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
index 619655c1a1f39fbf950149a13d9feec57f8f6ea8..f774a9e62858f3a35736591223db35c4acceacba 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
+++ b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
@@ -111,14 +111,11 @@ static void pr_hcall(struct ucall *uc)
 
 static void enter_guest(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        while (true) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "unexpected exit reason: %u (%s)",
-                           run->exit_reason, exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_PR_MSR:

diff --git a/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c b/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c
index 016070cad36edb59405b4b10d42b7b398911d125..72812644d7f5ea6b212f525376ca7a5a3f74648f 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c
+++ b/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c
@@ -64,7 +64,6 @@ int main(int argc, char *argv[])
 {
        uint64_t disabled_quirks;
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        struct kvm_vm *vm;
        struct ucall uc;
        int testcase;
@@ -74,18 +73,12 @@ int main(int argc, char *argv[])
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
        vcpu_clear_cpuid_feature(vcpu, X86_FEATURE_MWAIT);
 
-       run = vcpu->run;
-
        vm_init_descriptor_tables(vm);
        vcpu_init_descriptor_tables(vcpu);
 
        while (1) {
                vcpu_run(vcpu);
-
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Unexpected exit reason: %u (%s),\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/nested_exceptions_test.c b/tools/testing/selftests/kvm/x86_64/nested_exceptions_test.c
index ac33835f78f45afa2a1bc2d387bf03c18025efc5..6502aa23c2f84b81d4187a42b7ec057b5354311a 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/nested_exceptions_test.c
+++ b/tools/testing/selftests/kvm/x86_64/nested_exceptions_test.c
@@ -166,12 +166,9 @@ static void __attribute__((__flatten__)) l1_guest_code(void *test_data)
 
 static void assert_ucall_vector(struct kvm_vcpu *vcpu, int vector)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason, exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        switch (get_ucall(vcpu, &uc)) {
        case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/platform_info_test.c b/tools/testing/selftests/kvm/x86_64/platform_info_test.c
index 310a104d94f06ab0533ef5fc4cfef0e675a65e07..c9a07963d68aaedcc6b45d4e00e932e5981645b0 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/platform_info_test.c
+++ b/tools/testing/selftests/kvm/x86_64/platform_info_test.c
@@ -36,15 +36,12 @@ static void guest_code(void)
 
 static void test_msr_platform_info_enabled(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        vm_enable_cap(vcpu->vm, KVM_CAP_MSR_PLATFORM_INFO, true);
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                       "Exit_reason other than KVM_EXIT_IO: %u (%s),\n",
-                       run->exit_reason,
-                       exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
+
        get_ucall(vcpu, &uc);
        TEST_ASSERT(uc.cmd == UCALL_SYNC,
                        "Received ucall other than UCALL_SYNC: %lu\n", uc.cmd);
@@ -56,14 +53,9 @@ static void test_msr_platform_info_enabled(struct kvm_vcpu *vcpu)
 
 static void test_msr_platform_info_disabled(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
-
        vm_enable_cap(vcpu->vm, KVM_CAP_MSR_PLATFORM_INFO, false);
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN,
-                       "Exit_reason other than KVM_EXIT_SHUTDOWN: %u (%s)\n",
-                       run->exit_reason,
-                       exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_SHUTDOWN);
 }
 
 int main(int argc, char *argv[])

diff --git a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
index bad7ef8c5b92e991f6e3d689c98c1c9139e31ca0..2feef25ba69134ea132e9fb441e5fca732de67bc 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
+++ b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
@@ -151,14 +151,10 @@ static void amd_guest_code(void)
  */
 static uint64_t run_vcpu_to_sync(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        get_ucall(vcpu, &uc);
        TEST_ASSERT(uc.cmd == UCALL_SYNC,
                    "Received ucall other than UCALL_SYNC: %lu", uc.cmd);

diff --git a/tools/testing/selftests/kvm/x86_64/smm_test.c b/tools/testing/selftests/kvm/x86_64/smm_test.c
index cb38a478e1f62aec9e52ca861baddfaf07b03ee8..e18b86666e1fc2d9814c287f81fae95dc9dadfa4 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/smm_test.c
+++ b/tools/testing/selftests/kvm/x86_64/smm_test.c
@@ -133,7 +133,6 @@ int main(int argc, char *argv[])
        struct kvm_vcpu *vcpu;
        struct kvm_regs regs;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct kvm_x86_state *state;
        int stage, stage_reported;
 
@@ -142,8 +141,6 @@ int main(int argc, char *argv[])
        /* Create VM */
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
 
-       run = vcpu->run;
-
        vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, SMRAM_GPA,
                                    SMRAM_MEMSLOT, SMRAM_PAGES, 0);
        TEST_ASSERT(vm_phy_pages_alloc(vm, SMRAM_PAGES, SMRAM_GPA, SMRAM_MEMSLOT)
@@ -169,10 +166,7 @@ int main(int argc, char *argv[])
 
        for (stage = 1;; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                memset(&regs, 0, sizeof(regs));
                vcpu_regs_get(vcpu, &regs);
@@ -208,7 +202,6 @@ int main(int argc, char *argv[])
 
                vcpu = vm_recreate_with_one_vcpu(vm);
                vcpu_load_state(vcpu, state);
-               run = vcpu->run;
                kvm_x86_state_cleanup(state);
        }
 

diff --git a/tools/testing/selftests/kvm/x86_64/state_test.c b/tools/testing/selftests/kvm/x86_64/state_test.c
index ea578971fb9f9278893ed115a63dbfa417979727..4c4925a8ab4523452326a417634764f85fce19ca 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/state_test.c
+++ b/tools/testing/selftests/kvm/x86_64/state_test.c
@@ -158,14 +158,12 @@ int main(int argc, char *argv[])
        struct kvm_regs regs1, regs2;
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct kvm_x86_state *state;
        struct ucall uc;
        int stage;
 
        /* Create VM */
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
-       run = vcpu->run;
 
        vcpu_regs_get(vcpu, &regs1);
 
@@ -183,10 +181,7 @@ int main(int argc, char *argv[])
 
        for (stage = 1;; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:
@@ -214,7 +209,6 @@ int main(int argc, char *argv[])
                /* Restore state in a new VM.  */
                vcpu = vm_recreate_with_one_vcpu(vm);
                vcpu_load_state(vcpu, state);
-               run = vcpu->run;
                kvm_x86_state_cleanup(state);
 
                memset(&regs2, 0, sizeof(regs2));

diff --git a/tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c b/tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c
index 4a07ba227b9954cbe99dc10b84bea96e78e80f22..32bef39bec2178068238a2de650f87179acc22f6 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c
+++ b/tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c
@@ -85,7 +85,6 @@ static void l1_guest_code(struct svm_test_data *svm)
 int main(int argc, char *argv[])
 {
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        vm_vaddr_t svm_gva;
        struct kvm_vm *vm;
        struct ucall uc;
@@ -103,13 +102,8 @@ int main(int argc, char *argv[])
        vcpu_alloc_svm(vm, &svm_gva);
        vcpu_args_set(vcpu, 1, svm_gva);
 
-       run = vcpu->run;
-
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        switch (get_ucall(vcpu, &uc)) {
        case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/svm_nested_shutdown_test.c b/tools/testing/selftests/kvm/x86_64/svm_nested_shutdown_test.c
index e73fcdef47bbe910a4643a33404c17c28635097d..d6fcdcc3af3144b6805cf3d9530614b03476ac79 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/svm_nested_shutdown_test.c
+++ b/tools/testing/selftests/kvm/x86_64/svm_nested_shutdown_test.c
@@ -42,7 +42,6 @@ static void l1_guest_code(struct svm_test_data *svm, struct idt_entry *idt)
 int main(int argc, char *argv[])
 {
        struct kvm_vcpu *vcpu;
-       struct kvm_run *run;
        vm_vaddr_t svm_gva;
        struct kvm_vm *vm;
 
@@ -55,13 +54,9 @@ int main(int argc, char *argv[])
        vcpu_alloc_svm(vm, &svm_gva);
 
        vcpu_args_set(vcpu, 2, svm_gva, vm->idt);
-       run = vcpu->run;
 
        vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN,
-                   "Got exit_reason other than KVM_EXIT_SHUTDOWN: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_SHUTDOWN);
 
        kvm_vm_free(vm);
 }

diff --git a/tools/testing/selftests/kvm/x86_64/svm_nested_soft_inject_test.c b/tools/testing/selftests/kvm/x86_64/svm_nested_soft_inject_test.c
index b34980d45648a68de61051cd521f49b21e8fa719..4e2479716da6eb5b567151593beac16c419a8220 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/svm_nested_soft_inject_test.c
+++ b/tools/testing/selftests/kvm/x86_64/svm_nested_soft_inject_test.c
@@ -176,16 +176,12 @@ static void run_test(bool is_nmi)
        memset(&debug, 0, sizeof(debug));
        vcpu_guest_debug_set(vcpu, &debug);
 
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        alarm(2);
        vcpu_run(vcpu);
        alarm(0);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        switch (get_ucall(vcpu, &uc)) {
        case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/svm_vmcall_test.c b/tools/testing/selftests/kvm/x86_64/svm_vmcall_test.c
index c3ac45df748325151aae1f7c27e994be924c171c..8a62cca28cfbb377af77b31b985b3e8694430edf 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/svm_vmcall_test.c
+++ b/tools/testing/selftests/kvm/x86_64/svm_vmcall_test.c
@@ -47,14 +47,10 @@ int main(int argc, char *argv[])
        vcpu_args_set(vcpu, 1, svm_gva);
 
        for (;;) {
-               volatile struct kvm_run *run = vcpu->run;
                struct ucall uc;
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/sync_regs_test.c b/tools/testing/selftests/kvm/x86_64/sync_regs_test.c
index d2f9b5bdfab20b6c3eae23afc249049b61af343d..2da89fdc2471a7f95983c66b1c744a5365ad007c 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/sync_regs_test.c
+++ b/tools/testing/selftests/kvm/x86_64/sync_regs_test.c
@@ -132,10 +132,7 @@ int main(int argc, char *argv[])
        /* TODO: BUILD TIME CHECK: TEST_ASSERT(KVM_SYNC_X86_NUM_FIELDS != 3); */
        run->kvm_valid_regs = TEST_SYNC_FIELDS;
        rv = _vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        vcpu_regs_get(vcpu, &regs);
        compare_regs(&regs, &run->s.regs.regs);
@@ -154,10 +151,7 @@ int main(int argc, char *argv[])
        run->kvm_valid_regs = TEST_SYNC_FIELDS;
        run->kvm_dirty_regs = KVM_SYNC_X86_REGS | KVM_SYNC_X86_SREGS;
        rv = _vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(run->s.regs.regs.rbx == 0xBAD1DEA + 1,
                    "rbx sync regs value incorrect 0x%llx.",
                    run->s.regs.regs.rbx);
@@ -181,10 +175,7 @@ int main(int argc, char *argv[])
        run->kvm_dirty_regs = 0;
        run->s.regs.regs.rbx = 0xDEADBEEF;
        rv = _vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(run->s.regs.regs.rbx != 0xDEADBEEF,
                    "rbx sync regs value incorrect 0x%llx.",
                    run->s.regs.regs.rbx);
@@ -199,10 +190,7 @@ int main(int argc, char *argv[])
        regs.rbx = 0xBAC0;
        vcpu_regs_set(vcpu, &regs);
        rv = _vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(run->s.regs.regs.rbx == 0xAAAA,
                    "rbx sync regs value incorrect 0x%llx.",
                    run->s.regs.regs.rbx);
@@ -219,10 +207,7 @@ int main(int argc, char *argv[])
        run->kvm_dirty_regs = TEST_SYNC_FIELDS;
        run->s.regs.regs.rbx = 0xBBBB;
        rv = _vcpu_run(vcpu);
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(run->s.regs.regs.rbx == 0xBBBB,
                    "rbx sync regs value incorrect 0x%llx.",
                    run->s.regs.regs.rbx);

diff --git a/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c b/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
index ead5d878a71c458348d9e86100016bc8bd2a72b4..56306a19144a7db90a7f0906aede46e75ee346a1 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
+++ b/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
@@ -89,9 +89,7 @@ int main(void)
        run = vcpu->run;
        vcpu_run(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Expected KVM_EXIT_IO, got: %u (%s)\n",
-                   run->exit_reason, exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(run->io.port == ARBITRARY_IO_PORT,
                    "Expected IN from port %d from L2, got port %d",
                    ARBITRARY_IO_PORT, run->io.port);
@@ -111,10 +109,7 @@ int main(void)
 
 
        if (has_svm) {
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN,
-                           "Got exit_reason other than KVM_EXIT_SHUTDOWN: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_SHUTDOWN);
        } else {
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_DONE:

diff --git a/tools/testing/selftests/kvm/x86_64/tsc_scaling_sync.c b/tools/testing/selftests/kvm/x86_64/tsc_scaling_sync.c
index 47139aab74084b29ba356dd9ddd4d76edb0105eb..5b669818e39aaa2313d0887c0324aca4b628ed3c 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/tsc_scaling_sync.c
+++ b/tools/testing/selftests/kvm/x86_64/tsc_scaling_sync.c
@@ -64,14 +64,10 @@ static void *run_vcpu(void *_cpu_nr)
        pthread_spin_unlock(&create_lock);
 
        for (;;) {
-               volatile struct kvm_run *run = vcpu->run;
                 struct ucall uc;
 
                vcpu_run(vcpu);
-                TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                            "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                            run->exit_reason,
-                            exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                 case UCALL_DONE:

diff --git a/tools/testing/selftests/kvm/x86_64/ucna_injection_test.c b/tools/testing/selftests/kvm/x86_64/ucna_injection_test.c
index a897c7fd8abe464d57a2927f5526b3f6f7044d62..85f34ca7e49e531c11e09f700738d0eec2a0e0fa 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/ucna_injection_test.c
+++ b/tools/testing/selftests/kvm/x86_64/ucna_injection_test.c
@@ -137,15 +137,11 @@ static void guest_gp_handler(struct ex_regs *regs)
 
 static void run_vcpu_expect_gp(struct kvm_vcpu *vcpu)
 {
-       unsigned int exit_reason;
        struct ucall uc;
 
        vcpu_run(vcpu);
 
-       exit_reason = vcpu->run->exit_reason;
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "exited with unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
        TEST_ASSERT(get_ucall(vcpu, &uc) == UCALL_SYNC,
                    "Expect UCALL_SYNC\n");
        TEST_ASSERT(uc.args[1] == SYNC_GP, "#GP is expected.");
@@ -182,7 +178,6 @@ static void *run_ucna_injection(void *arg)
        struct ucall uc;
        int old;
        int r;
-       unsigned int exit_reason;
 
        r = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
        TEST_ASSERT(r == 0,
@@ -191,10 +186,7 @@ static void *run_ucna_injection(void *arg)
 
        vcpu_run(params->vcpu);
 
-       exit_reason = params->vcpu->run->exit_reason;
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(params->vcpu, KVM_EXIT_IO);
        TEST_ASSERT(get_ucall(params->vcpu, &uc) == UCALL_SYNC,
                    "Expect UCALL_SYNC\n");
        TEST_ASSERT(uc.args[1] == SYNC_FIRST_UCNA, "Injecting first UCNA.");
@@ -204,10 +196,7 @@ static void *run_ucna_injection(void *arg)
        inject_ucna(params->vcpu, FIRST_UCNA_ADDR);
        vcpu_run(params->vcpu);
 
-       exit_reason = params->vcpu->run->exit_reason;
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(params->vcpu, KVM_EXIT_IO);
        TEST_ASSERT(get_ucall(params->vcpu, &uc) == UCALL_SYNC,
                    "Expect UCALL_SYNC\n");
        TEST_ASSERT(uc.args[1] == SYNC_SECOND_UCNA, "Injecting second UCNA.");
@@ -217,10 +206,7 @@ static void *run_ucna_injection(void *arg)
        inject_ucna(params->vcpu, SECOND_UCNA_ADDR);
        vcpu_run(params->vcpu);
 
-       exit_reason = params->vcpu->run->exit_reason;
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(params->vcpu, KVM_EXIT_IO);
        if (get_ucall(params->vcpu, &uc) == UCALL_ABORT) {
                TEST_ASSERT(false, "vCPU assertion failure: %s.\n",
                            (const char *)uc.args[0]);

diff --git a/tools/testing/selftests/kvm/x86_64/userspace_io_test.c b/tools/testing/selftests/kvm/x86_64/userspace_io_test.c
index 91076c9787b41e322a1b3c3de2c35b066295d710..0cb51fa42773b23278448b66174f05052a407465 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/userspace_io_test.c
+++ b/tools/testing/selftests/kvm/x86_64/userspace_io_test.c
@@ -63,11 +63,7 @@ int main(int argc, char *argv[])
 
        while (1) {
                vcpu_run(vcpu);
-
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Unexpected exit reason: %u (%s),\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                if (get_ucall(vcpu, &uc))
                        break;

diff --git a/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c b/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
index 25fa55344a10efb23b972e41d1f62262ee928e70..3533dc2fbfeeb136b217eb79e819e2e374e2b0cd 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
+++ b/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
@@ -410,10 +410,7 @@ static void process_rdmsr(struct kvm_vcpu *vcpu, uint32_t msr_index)
 
        check_for_guest_assert(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_X86_RDMSR,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_X86_RDMSR);
        TEST_ASSERT(run->msr.index == msr_index,
                        "Unexpected msr (0x%04x), expected 0x%04x",
                        run->msr.index, msr_index);
@@ -445,10 +442,7 @@ static void process_wrmsr(struct kvm_vcpu *vcpu, uint32_t msr_index)
 
        check_for_guest_assert(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_X86_WRMSR,
-                   "Unexpected exit reason: %u (%s),\n",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_X86_WRMSR);
        TEST_ASSERT(run->msr.index == msr_index,
                        "Unexpected msr (0x%04x), expected 0x%04x",
                        run->msr.index, msr_index);
@@ -472,15 +466,11 @@ static void process_wrmsr(struct kvm_vcpu *vcpu, uint32_t msr_index)
 
 static void process_ucall_done(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        check_for_guest_assert(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s)",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        TEST_ASSERT(get_ucall(vcpu, &uc) == UCALL_DONE,
                    "Unexpected ucall command: %lu, expected UCALL_DONE (%d)",
@@ -489,15 +479,11 @@ static void process_ucall_done(struct kvm_vcpu *vcpu)
 
 static uint64_t process_ucall(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu->run;
        struct ucall uc = {};
 
        check_for_guest_assert(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Unexpected exit reason: %u (%s)",
-                   run->exit_reason,
-                   exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        switch (get_ucall(vcpu, &uc)) {
        case UCALL_SYNC:

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_apic_access_test.c b/tools/testing/selftests/kvm/x86_64/vmx_apic_access_test.c
index 5abecf06329eaccd2ac85e0fb6b57075d5628f15..2bed5fb3a0d6e51aa63f9732d77dac330378d2c8 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_apic_access_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_apic_access_test.c
@@ -96,21 +96,14 @@ int main(int argc, char *argv[])
 
                vcpu_run(vcpu);
                if (apic_access_addr == high_gpa) {
-                       TEST_ASSERT(run->exit_reason ==
-                                   KVM_EXIT_INTERNAL_ERROR,
-                                   "Got exit reason other than KVM_EXIT_INTERNAL_ERROR: %u (%s)\n",
-                                   run->exit_reason,
-                                   exit_reason_str(run->exit_reason));
+                       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR);
                        TEST_ASSERT(run->internal.suberror ==
                                    KVM_INTERNAL_ERROR_EMULATION,
                                    "Got internal suberror other than KVM_INTERNAL_ERROR_EMULATION: %u\n",
                                    run->internal.suberror);
                        break;
                }
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_close_while_nested_test.c b/tools/testing/selftests/kvm/x86_64/vmx_close_while_nested_test.c
index d79651b027402d6f349eb594a03fdc425ce3843a..dad988351493e089bf0f9b62d7604d89b65137a7 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_close_while_nested_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_close_while_nested_test.c
@@ -64,10 +64,7 @@ int main(int argc, char *argv[])
                struct ucall uc;
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                if (run->io.port == PORT_L0_EXIT)
                        break;

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c b/tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c
index f0456fb031b1ef465c9f6177af630599e5d92daf..e4ad5fef52ffc5b08ec8d3f445b518b52229e672 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c
@@ -73,7 +73,6 @@ int main(int argc, char *argv[])
 
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct ucall uc;
        bool done = false;
 
@@ -84,7 +83,6 @@ int main(int argc, char *argv[])
        vm = vm_create_with_one_vcpu(&vcpu, l1_guest_code);
        vmx = vcpu_alloc_vmx(vm, &vmx_pages_gva);
        vcpu_args_set(vcpu, 1, vmx_pages_gva);
-       run = vcpu->run;
 
        /* Add an extra memory slot for testing dirty logging */
        vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
@@ -117,10 +115,7 @@ int main(int argc, char *argv[])
        while (!done) {
                memset(host_test_mem, 0xaa, TEST_MEM_PAGES * 4096);
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Unexpected exit reason: %u (%s),\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_exception_with_invalid_guest_state.c b/tools/testing/selftests/kvm/x86_64/vmx_exception_with_invalid_guest_state.c
index ccdfa5dc1a4dc6fdc5876575dfb6240c3beff536..be0bdb8c6f78c27a3fa573ea87f66ddc58bf79c8 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_exception_with_invalid_guest_state.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_exception_with_invalid_guest_state.c
@@ -26,9 +26,7 @@ static void __run_vcpu_with_invalid_state(struct kvm_vcpu *vcpu)
 
        vcpu_run(vcpu);
 
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_INTERNAL_ERROR,
-                   "Expected KVM_EXIT_INTERNAL_ERROR, got %d (%s)\n",
-                   run->exit_reason, exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR);
        TEST_ASSERT(run->emulation_failure.suberror == KVM_INTERNAL_ERROR_EMULATION,
                    "Expected emulation failure, got %d\n",
                    run->emulation_failure.suberror);

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_invalid_nested_guest_state.c b/tools/testing/selftests/kvm/x86_64/vmx_invalid_nested_guest_state.c
index 6bfb4bb471ca2b68f7cdaeeece7b93ba4d6d33db..a100ee5f000936e8e397d2112071b19f18192ff5 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_invalid_nested_guest_state.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_invalid_nested_guest_state.c
@@ -74,9 +74,7 @@ int main(int argc, char *argv[])
         * The first exit to L0 userspace should be an I/O access from L2.
         * Running L1 should launch L2 without triggering an exit to userspace.
         */
-       TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                   "Expected KVM_EXIT_IO, got: %u (%s)\n",
-                   run->exit_reason, exit_reason_str(run->exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        TEST_ASSERT(run->io.port == ARBITRARY_IO_PORT,
                    "Expected IN from port %d from L2, got port %d",

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_nested_tsc_scaling_test.c b/tools/testing/selftests/kvm/x86_64/vmx_nested_tsc_scaling_test.c
index 465a9434d61c2b9d7cc3611d719e32598365f00b..d427eb146bc5818e8d96a93da7c00a1b485bcf81 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_nested_tsc_scaling_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_nested_tsc_scaling_test.c
@@ -183,14 +183,10 @@ int main(int argc, char *argv[])
        vcpu_ioctl(vcpu, KVM_SET_TSC_KHZ, (void *) (tsc_khz / l1_scale_factor));
 
        for (;;) {
-               volatile struct kvm_run *run = vcpu->run;
                struct ucall uc;
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_preemption_timer_test.c b/tools/testing/selftests/kvm/x86_64/vmx_preemption_timer_test.c
index 0efdc05969a56395db7774821c9023fb93928d9c..affc32800158415225e2a5c0cd2d75ce0f727e30 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_preemption_timer_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_preemption_timer_test.c
@@ -157,7 +157,6 @@ int main(int argc, char *argv[])
 
        struct kvm_regs regs1, regs2;
        struct kvm_vm *vm;
-       struct kvm_run *run;
        struct kvm_vcpu *vcpu;
        struct kvm_x86_state *state;
        struct ucall uc;
@@ -173,7 +172,6 @@ int main(int argc, char *argv[])
 
        /* Create VM */
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
-       run = vcpu->run;
 
        vcpu_regs_get(vcpu, &regs1);
 
@@ -182,10 +180,7 @@ int main(int argc, char *argv[])
 
        for (stage = 1;; stage++) {
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Stage %d: unexpected exit reason: %u (%s),\n",
-                           stage, run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:
@@ -237,7 +232,6 @@ int main(int argc, char *argv[])
                /* Restore state in a new VM.  */
                vcpu = vm_recreate_with_one_vcpu(vm);
                vcpu_load_state(vcpu, state);
-               run = vcpu->run;
                kvm_x86_state_cleanup(state);
 
                memset(&regs2, 0, sizeof(regs2));

diff --git a/tools/testing/selftests/kvm/x86_64/vmx_tsc_adjust_test.c b/tools/testing/selftests/kvm/x86_64/vmx_tsc_adjust_test.c
index ff8ecdf32ae07d9e448e32af6839943a1ed3d51b..2ceb5c78c442710166c2ecc1243d812cb1839793 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/vmx_tsc_adjust_test.c
+++ b/tools/testing/selftests/kvm/x86_64/vmx_tsc_adjust_test.c
@@ -131,14 +131,10 @@ int main(int argc, char *argv[])
        vcpu_args_set(vcpu, 1, vmx_pages_gva);
 
        for (;;) {
-               volatile struct kvm_run *run = vcpu->run;
                struct ucall uc;
 
                vcpu_run(vcpu);
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/xapic_ipi_test.c b/tools/testing/selftests/kvm/x86_64/xapic_ipi_test.c
index 3d272d7f961ef1948e65e588f0d6cad30e7ebe70..67ac2a3292efd4e5a4ff24073af25849ce375dd9 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/xapic_ipi_test.c
+++ b/tools/testing/selftests/kvm/x86_64/xapic_ipi_test.c
@@ -198,7 +198,6 @@ static void *vcpu_thread(void *arg)
        struct ucall uc;
        int old;
        int r;
-       unsigned int exit_reason;
 
        r = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
        TEST_ASSERT(r == 0,
@@ -207,11 +206,8 @@ static void *vcpu_thread(void *arg)
 
        fprintf(stderr, "vCPU thread running vCPU %u\n", vcpu->id);
        vcpu_run(vcpu);
-       exit_reason = vcpu->run->exit_reason;
 
-       TEST_ASSERT(exit_reason == KVM_EXIT_IO,
-                   "vCPU %u exited with unexpected exit reason %u-%s, expected KVM_EXIT_IO",
-                   vcpu->id, exit_reason, exit_reason_str(exit_reason));
+       TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
        if (get_ucall(vcpu, &uc) == UCALL_ABORT) {
                TEST_ASSERT(false,

diff --git a/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c b/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
index d42701dfbd83acfd655ddca780e05eb81b6ec7cb..05898ad9f4d992b3c7eba0a9ec677b21315689e6 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
+++ b/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
@@ -622,15 +622,10 @@ int main(int argc, char *argv[])
        bool evtchn_irq_expected = false;
 
        for (;;) {
-               volatile struct kvm_run *run = vcpu->run;
                struct ucall uc;
 
                vcpu_run(vcpu);
-
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT:

diff --git a/tools/testing/selftests/kvm/x86_64/xen_vmcall_test.c b/tools/testing/selftests/kvm/x86_64/xen_vmcall_test.c
index 88914d48c65ed8fb5270c5d96ae45c9c55faee5d..c94cde3b523f2b14a4f61986c835ad5503a95337 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/xen_vmcall_test.c
+++ b/tools/testing/selftests/kvm/x86_64/xen_vmcall_test.c
@@ -122,10 +122,7 @@ int main(int argc, char *argv[])
                        continue;
                }
 
-               TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
-                           "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
-                           run->exit_reason,
-                           exit_reason_str(run->exit_reason));
+               TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 
                switch (get_ucall(vcpu, &uc)) {
                case UCALL_ABORT: