KVM: selftests: Convert emulator_error_test away from VCPU_ID

Convert emulator_error_test to use vm_create_with_one_vcpu() and pass
around a 'struct kvm_vcpu' object instead of using a global VCPU_ID.  Note,
this is a "functional" change in the sense that the test now creates a vCPU
with vcpu_id==0 instead of vcpu_id==5.  The non-zero VCPU_ID was 100%
arbitrary and added little to no validation coverage.  If testing non-zero
vCPU IDs is desirable for generic tests, that can be done in the future by
tweaking the VM creation helpers.

Opportunistically use vcpu_run() instead of _vcpu_run() with an open
coded assert that KVM_RUN succeeded.

Signed-off-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/x86_64/emulator_error_test.c b/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
index 9c156f9cfa15401bbd944f8ef52ad4e19b354be9..08a95dab3a6b1f7f615a910773f690c39b5dffc9 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
+++ b/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
@@ -11,7 +11,6 @@
 #include "kvm_util.h"
 #include "vmx.h"
 
-#define VCPU_ID           1
 #define MAXPHYADDR 36
 
 #define MEM_REGION_GVA 0x0000123456789000
@@ -27,14 +26,6 @@ static void guest_code(void)
        GUEST_DONE();
 }
 
-static void run_guest(struct kvm_vm *vm)
-{
-       int rc;
-
-       rc = _vcpu_run(vm, VCPU_ID);
-       TEST_ASSERT(rc == 0, "vcpu_run failed: %d\n", rc);
-}
-
 /*
  * Accessors to get R/M, REG, and Mod bits described in the SDM vol 2,
  * figure 2-2 "Table Interpretation of ModR/M Byte (C8H)".
@@ -56,9 +47,9 @@ static bool is_flds(uint8_t *insn_bytes, uint8_t insn_size)
               GET_RM(insn_bytes[1]) != 0x5;
 }
 
-static void process_exit_on_emulation_error(struct kvm_vm *vm)
+static void process_exit_on_emulation_error(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu_state(vm, VCPU_ID);
+       struct kvm_run *run = vcpu->run;
        struct kvm_regs regs;
        uint8_t *insn_bytes;
        uint8_t insn_size;
@@ -92,50 +83,49 @@ static void process_exit_on_emulation_error(struct kvm_vm *vm)
                         * contained an flds instruction that is 2-bytes in
                         * length (ie: no prefix, no SIB, no displacement).
                         */
-                       vcpu_regs_get(vm, VCPU_ID, &regs);
+                       vcpu_regs_get(vcpu->vm, vcpu->id, &regs);
                        regs.rip += 2;
-                       vcpu_regs_set(vm, VCPU_ID, &regs);
+                       vcpu_regs_set(vcpu->vm, vcpu->id, &regs);
                }
        }
 }
 
-static void do_guest_assert(struct kvm_vm *vm, struct ucall *uc)
+static void do_guest_assert(struct ucall *uc)
 {
        TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0], __FILE__,
                  uc->args[1]);
 }
 
-static void check_for_guest_assert(struct kvm_vm *vm)
+static void check_for_guest_assert(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu_state(vm, VCPU_ID);
        struct ucall uc;
 
-       if (run->exit_reason == KVM_EXIT_IO &&
-           get_ucall(vm, VCPU_ID, &uc) == UCALL_ABORT) {
-               do_guest_assert(vm, &uc);
+       if (vcpu->run->exit_reason == KVM_EXIT_IO &&
+           get_ucall(vcpu->vm, vcpu->id, &uc) == UCALL_ABORT) {
+               do_guest_assert(&uc);
        }
 }
 
-static void process_ucall_done(struct kvm_vm *vm)
+static void process_ucall_done(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu_state(vm, VCPU_ID);
+       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
-       check_for_guest_assert(vm);
+       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(get_ucall(vm, VCPU_ID, &uc) == UCALL_DONE,
+       TEST_ASSERT(get_ucall(vcpu->vm, vcpu->id, &uc) == UCALL_DONE,
                    "Unexpected ucall command: %lu, expected UCALL_DONE (%d)",
                    uc.cmd, UCALL_DONE);
 }
 
-static uint64_t process_ucall(struct kvm_vm *vm)
+static uint64_t process_ucall(struct kvm_vcpu *vcpu)
 {
-       struct kvm_run *run = vcpu_state(vm, VCPU_ID);
+       struct kvm_run *run = vcpu->run;
        struct ucall uc;
 
        TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
@@ -143,14 +133,14 @@ static uint64_t process_ucall(struct kvm_vm *vm)
                    run->exit_reason,
                    exit_reason_str(run->exit_reason));
 
-       switch (get_ucall(vm, VCPU_ID, &uc)) {
+       switch (get_ucall(vcpu->vm, vcpu->id, &uc)) {
        case UCALL_SYNC:
                break;
        case UCALL_ABORT:
-               do_guest_assert(vm, &uc);
+               do_guest_assert(&uc);
                break;
        case UCALL_DONE:
-               process_ucall_done(vm);
+               process_ucall_done(vcpu);
                break;
        default:
                TEST_ASSERT(false, "Unexpected ucall");
@@ -163,6 +153,7 @@ int main(int argc, char *argv[])
 {
        struct kvm_cpuid_entry2 *entry;
        struct kvm_cpuid2 *cpuid;
+       struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
        uint64_t gpa, pte;
        uint64_t *hva;
@@ -171,20 +162,20 @@ int main(int argc, char *argv[])
        /* Tell stdout not to buffer its content */
        setbuf(stdout, NULL);
 
-       vm = vm_create_default(VCPU_ID, 0, guest_code);
-
        if (!kvm_check_cap(KVM_CAP_SMALLER_MAXPHYADDR)) {
                printf("module parameter 'allow_smaller_maxphyaddr' is not set.  Skipping test.\n");
                return 0;
        }
 
+       vm = vm_create_with_one_vcpu(&vcpu, guest_code);
+
        cpuid = kvm_get_supported_cpuid();
 
        entry = kvm_get_supported_cpuid_index(0x80000008, 0);
        entry->eax = (entry->eax & 0xffffff00) | MAXPHYADDR;
        set_cpuid(cpuid, entry);
 
-       vcpu_set_cpuid(vm, VCPU_ID, cpuid);
+       vcpu_set_cpuid(vm, vcpu->id, cpuid);
 
        rc = kvm_check_cap(KVM_CAP_EXIT_ON_EMULATION_FAILURE);
        TEST_ASSERT(rc, "KVM_CAP_EXIT_ON_EMULATION_FAILURE is unavailable");
@@ -199,14 +190,14 @@ int main(int argc, char *argv[])
        virt_map(vm, MEM_REGION_GVA, MEM_REGION_GPA, 1);
        hva = addr_gpa2hva(vm, MEM_REGION_GPA);
        memset(hva, 0, PAGE_SIZE);
-       pte = vm_get_page_table_entry(vm, VCPU_ID, MEM_REGION_GVA);
-       vm_set_page_table_entry(vm, VCPU_ID, MEM_REGION_GVA, pte | (1ull << 36));
+       pte = vm_get_page_table_entry(vm, vcpu->id, MEM_REGION_GVA);
+       vm_set_page_table_entry(vm, vcpu->id, MEM_REGION_GVA, pte | (1ull << 36));
 
-       run_guest(vm);
-       process_exit_on_emulation_error(vm);
-       run_guest(vm);
+       vcpu_run(vm, vcpu->id);
+       process_exit_on_emulation_error(vcpu);
+       vcpu_run(vm, vcpu->id);
 
-       TEST_ASSERT(process_ucall(vm) == UCALL_DONE, "Expected UCALL_DONE");
+       TEST_ASSERT(process_ucall(vcpu) == UCALL_DONE, "Expected UCALL_DONE");
 
        kvm_vm_free(vm);