KVM: selftests: Consolidate KVM_ENABLE_CAP usage

Add __vm_enable_cap() and use it for negative tests that expect
KVM_ENABLE_CAP to fail.  Opportunistically clean up the MAX_VCPU_ID test
error messages.

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

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h
index 2e1453c..f0afc1d 100644 (file)
--- a/tools/testing/selftests/kvm/include/kvm_util_base.h
+++ b/tools/testing/selftests/kvm/include/kvm_util_base.h
@@ -231,6 +231,10 @@ static inline int vm_check_cap(struct kvm_vm *vm, long cap)
        return ret;
 }
 
+static inline int __vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap)
+{
+       return __vm_ioctl(vm, KVM_ENABLE_CAP, cap);
+}
 static inline void vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap)
 {
        vm_ioctl(vm, KVM_ENABLE_CAP, cap);

diff --git a/tools/testing/selftests/kvm/lib/x86_64/vmx.c b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
index fdca123..dbfca8e 100644 (file)
--- a/tools/testing/selftests/kvm/lib/x86_64/vmx.c
+++ b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
@@ -51,7 +51,7 @@ int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id)
                 .args[0] = (unsigned long)&evmcs_ver
        };
 
-       vcpu_ioctl(vm, vcpu_id, KVM_ENABLE_CAP, &enable_evmcs_cap);
+       vcpu_enable_cap(vm, vcpu_id, &enable_evmcs_cap);
 
        /* KVM should return supported EVMCS version range */
        TEST_ASSERT(((evmcs_ver >> 8) >= (evmcs_ver & 0xff)) &&

diff --git a/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c b/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
index 419fbdc..c6fd36a 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
+++ b/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
@@ -25,28 +25,25 @@ int main(int argc, char *argv[])
        /* Try to set KVM_CAP_MAX_VCPU_ID beyond KVM cap */
        cap.cap = KVM_CAP_MAX_VCPU_ID;
        cap.args[0] = ret + 1;
-       ret = ioctl(vm->fd, KVM_ENABLE_CAP, &cap);
+       ret = __vm_enable_cap(vm, &cap);
        TEST_ASSERT(ret < 0,
-                   "Unexpected success to enable KVM_CAP_MAX_VCPU_ID"
-                   "beyond KVM cap!\n");
+                   "Setting KVM_CAP_MAX_VCPU_ID beyond KVM cap should fail");
 
        /* Set KVM_CAP_MAX_VCPU_ID */
        cap.cap = KVM_CAP_MAX_VCPU_ID;
        cap.args[0] = MAX_VCPU_ID;
-       ret = ioctl(vm->fd, KVM_ENABLE_CAP, &cap);
-       TEST_ASSERT(ret == 0,
-                   "Unexpected failure to enable KVM_CAP_MAX_VCPU_ID!\n");
+       vm_enable_cap(vm, &cap);
+
 
        /* Try to set KVM_CAP_MAX_VCPU_ID again */
        cap.args[0] = MAX_VCPU_ID + 1;
-       ret = ioctl(vm->fd, KVM_ENABLE_CAP, &cap);
+       ret = __vm_enable_cap(vm, &cap);
        TEST_ASSERT(ret < 0,
-                   "Unexpected success to enable KVM_CAP_MAX_VCPU_ID again\n");
+                   "Setting KVM_CAP_MAX_VCPU_ID multiple times should fail");
 
        /* Create vCPU with id beyond KVM_CAP_MAX_VCPU_ID cap*/
-       ret = ioctl(vm->fd, KVM_CREATE_VCPU, MAX_VCPU_ID);
-       TEST_ASSERT(ret < 0,
-                   "Unexpected success in creating a vCPU with VCPU ID out of range\n");
+       ret = __vm_ioctl(vm, KVM_CREATE_VCPU, (void *)MAX_VCPU_ID);
+       TEST_ASSERT(ret < 0, "Creating vCPU with ID > MAX_VCPU_ID should fail");
 
        kvm_vm_free(vm);
        return 0;

diff --git a/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c b/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
index 5b565aa..f127f2f 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
+++ b/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
@@ -80,22 +80,22 @@ static struct kvm_vm *aux_vm_create(bool with_vcpus)
        return vm;
 }
 
-static int __sev_migrate_from(int dst_fd, int src_fd)
+static int __sev_migrate_from(struct kvm_vm *dst, struct kvm_vm *src)
 {
        struct kvm_enable_cap cap = {
                .cap = KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM,
-               .args = { src_fd }
+               .args = { src->fd }
        };
 
-       return ioctl(dst_fd, KVM_ENABLE_CAP, &cap);
+       return __vm_enable_cap(dst, &cap);
 }
 
 
-static void sev_migrate_from(int dst_fd, int src_fd)
+static void sev_migrate_from(struct kvm_vm *dst, struct kvm_vm *src)
 {
        int ret;
 
-       ret = __sev_migrate_from(dst_fd, src_fd);
+       ret = __sev_migrate_from(dst, src);
        TEST_ASSERT(!ret, "Migration failed, ret: %d, errno: %d\n", ret, errno);
 }
 
@@ -110,13 +110,13 @@ static void test_sev_migrate_from(bool es)
                dst_vms[i] = aux_vm_create(true);
 
        /* Initial migration from the src to the first dst. */
-       sev_migrate_from(dst_vms[0]->fd, src_vm->fd);
+       sev_migrate_from(dst_vms[0], src_vm);
 
        for (i = 1; i < NR_MIGRATE_TEST_VMS; i++)
-               sev_migrate_from(dst_vms[i]->fd, dst_vms[i - 1]->fd);
+               sev_migrate_from(dst_vms[i], dst_vms[i - 1]);
 
        /* Migrate the guest back to the original VM. */
-       ret = __sev_migrate_from(src_vm->fd, dst_vms[NR_MIGRATE_TEST_VMS - 1]->fd);
+       ret = __sev_migrate_from(src_vm, dst_vms[NR_MIGRATE_TEST_VMS - 1]);
        TEST_ASSERT(ret == -1 && errno == EIO,
                    "VM that was migrated from should be dead. ret %d, errno: %d\n", ret,
                    errno);
@@ -128,7 +128,7 @@ static void test_sev_migrate_from(bool es)
 
 struct locking_thread_input {
        struct kvm_vm *vm;
-       int source_fds[NR_LOCK_TESTING_THREADS];
+       struct kvm_vm *source_vms[NR_LOCK_TESTING_THREADS];
 };
 
 static void *locking_test_thread(void *arg)
@@ -138,7 +138,7 @@ static void *locking_test_thread(void *arg)
 
        for (i = 0; i < NR_LOCK_TESTING_ITERATIONS; ++i) {
                j = i % NR_LOCK_TESTING_THREADS;
-               __sev_migrate_from(input->vm->fd, input->source_fds[j]);
+               __sev_migrate_from(input->vm, input->source_vms[j]);
        }
 
        return NULL;
@@ -152,11 +152,11 @@ static void test_sev_migrate_locking(void)
 
        for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i) {
                input[i].vm = sev_vm_create(/* es= */ false);
-               input[0].source_fds[i] = input[i].vm->fd;
+               input[0].source_vms[i] = input[i].vm;
        }
        for (i = 1; i < NR_LOCK_TESTING_THREADS; ++i)
-               memcpy(input[i].source_fds, input[0].source_fds,
-                      sizeof(input[i].source_fds));
+               memcpy(input[i].source_vms, input[0].source_vms,
+                      sizeof(input[i].source_vms));
 
        for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i)
                pthread_create(&pt[i], NULL, locking_test_thread, &input[i]);
@@ -175,7 +175,7 @@ static void test_sev_migrate_parameters(void)
 
        vm_no_vcpu = vm_create(0);
        vm_no_sev = aux_vm_create(true);
-       ret = __sev_migrate_from(vm_no_vcpu->fd, vm_no_sev->fd);
+       ret = __sev_migrate_from(vm_no_vcpu, vm_no_sev);
        TEST_ASSERT(ret == -1 && errno == EINVAL,
                    "Migrations require SEV enabled. ret %d, errno: %d\n", ret,
                    errno);
@@ -189,25 +189,25 @@ static void test_sev_migrate_parameters(void)
        sev_ioctl(sev_es_vm_no_vmsa->fd, KVM_SEV_ES_INIT, NULL);
        vm_vcpu_add(sev_es_vm_no_vmsa, 1);
 
-       ret = __sev_migrate_from(sev_vm->fd, sev_es_vm->fd);
+       ret = __sev_migrate_from(sev_vm, sev_es_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "Should not be able migrate to SEV enabled VM. ret: %d, errno: %d\n",
                ret, errno);
 
-       ret = __sev_migrate_from(sev_es_vm->fd, sev_vm->fd);
+       ret = __sev_migrate_from(sev_es_vm, sev_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "Should not be able migrate to SEV-ES enabled VM. ret: %d, errno: %d\n",
                ret, errno);
 
-       ret = __sev_migrate_from(vm_no_vcpu->fd, sev_es_vm->fd);
+       ret = __sev_migrate_from(vm_no_vcpu, sev_es_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "SEV-ES migrations require same number of vCPUS. ret: %d, errno: %d\n",
                ret, errno);
 
-       ret = __sev_migrate_from(vm_no_vcpu->fd, sev_es_vm_no_vmsa->fd);
+       ret = __sev_migrate_from(vm_no_vcpu, sev_es_vm_no_vmsa);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "SEV-ES migrations require UPDATE_VMSA. ret %d, errno: %d\n",
@@ -221,22 +221,22 @@ out:
        kvm_vm_free(vm_no_sev);
 }
 
-static int __sev_mirror_create(int dst_fd, int src_fd)
+static int __sev_mirror_create(struct kvm_vm *dst, struct kvm_vm *src)
 {
        struct kvm_enable_cap cap = {
                .cap = KVM_CAP_VM_COPY_ENC_CONTEXT_FROM,
-               .args = { src_fd }
+               .args = { src->fd }
        };
 
-       return ioctl(dst_fd, KVM_ENABLE_CAP, &cap);
+       return __vm_enable_cap(dst, &cap);
 }
 
 
-static void sev_mirror_create(int dst_fd, int src_fd)
+static void sev_mirror_create(struct kvm_vm *dst, struct kvm_vm *src)
 {
        int ret;
 
-       ret = __sev_mirror_create(dst_fd, src_fd);
+       ret = __sev_mirror_create(dst, src);
        TEST_ASSERT(!ret, "Copying context failed, ret: %d, errno: %d\n", ret, errno);
 }
 
@@ -284,7 +284,7 @@ static void test_sev_mirror(bool es)
        src_vm = sev_vm_create(es);
        dst_vm = aux_vm_create(false);
 
-       sev_mirror_create(dst_vm->fd, src_vm->fd);
+       sev_mirror_create(dst_vm, src_vm);
 
        /* Check that we can complete creation of the mirror VM.  */
        for (i = 0; i < NR_MIGRATE_TEST_VCPUS; ++i)
@@ -308,18 +308,18 @@ static void test_sev_mirror_parameters(void)
        vm_with_vcpu = aux_vm_create(true);
        vm_no_vcpu = aux_vm_create(false);
 
-       ret = __sev_mirror_create(sev_vm->fd, sev_vm->fd);
+       ret = __sev_mirror_create(sev_vm, sev_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "Should not be able copy context to self. ret: %d, errno: %d\n",
                ret, errno);
 
-       ret = __sev_mirror_create(vm_no_vcpu->fd, vm_with_vcpu->fd);
+       ret = __sev_mirror_create(vm_no_vcpu, vm_with_vcpu);
        TEST_ASSERT(ret == -1 && errno == EINVAL,
                    "Copy context requires SEV enabled. ret %d, errno: %d\n", ret,
                    errno);
 
-       ret = __sev_mirror_create(vm_with_vcpu->fd, sev_vm->fd);
+       ret = __sev_mirror_create(vm_with_vcpu, sev_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "SEV copy context requires no vCPUS on the destination. ret: %d, errno: %d\n",
@@ -329,13 +329,13 @@ static void test_sev_mirror_parameters(void)
                goto out;
 
        sev_es_vm = sev_vm_create(/* es= */ true);
-       ret = __sev_mirror_create(sev_vm->fd, sev_es_vm->fd);
+       ret = __sev_mirror_create(sev_vm, sev_es_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "Should not be able copy context to SEV enabled VM. ret: %d, errno: %d\n",
                ret, errno);
 
-       ret = __sev_mirror_create(sev_es_vm->fd, sev_vm->fd);
+       ret = __sev_mirror_create(sev_es_vm, sev_vm);
        TEST_ASSERT(
                ret == -1 && errno == EINVAL,
                "Should not be able copy context to SEV-ES enabled VM. ret: %d, errno: %d\n",
@@ -363,16 +363,16 @@ static void test_sev_move_copy(void)
        dst2_mirror_vm = aux_vm_create(false);
        dst3_mirror_vm = aux_vm_create(false);
 
-       sev_mirror_create(mirror_vm->fd, sev_vm->fd);
+       sev_mirror_create(mirror_vm, sev_vm);
 
-       sev_migrate_from(dst_mirror_vm->fd, mirror_vm->fd);
-       sev_migrate_from(dst_vm->fd, sev_vm->fd);
+       sev_migrate_from(dst_mirror_vm, mirror_vm);
+       sev_migrate_from(dst_vm, sev_vm);
 
-       sev_migrate_from(dst2_vm->fd, dst_vm->fd);
-       sev_migrate_from(dst2_mirror_vm->fd, dst_mirror_vm->fd);
+       sev_migrate_from(dst2_vm, dst_vm);
+       sev_migrate_from(dst2_mirror_vm, dst_mirror_vm);
 
-       sev_migrate_from(dst3_mirror_vm->fd, dst2_mirror_vm->fd);
-       sev_migrate_from(dst3_vm->fd, dst2_vm->fd);
+       sev_migrate_from(dst3_mirror_vm, dst2_mirror_vm);
+       sev_migrate_from(dst3_vm, dst2_vm);
 
        kvm_vm_free(dst_vm);
        kvm_vm_free(sev_vm);
@@ -392,10 +392,10 @@ static void test_sev_move_copy(void)
        mirror_vm = aux_vm_create(false);
        dst_mirror_vm = aux_vm_create(false);
 
-       sev_mirror_create(mirror_vm->fd, sev_vm->fd);
+       sev_mirror_create(mirror_vm, sev_vm);
 
-       sev_migrate_from(dst_mirror_vm->fd, mirror_vm->fd);
-       sev_migrate_from(dst_vm->fd, sev_vm->fd);
+       sev_migrate_from(dst_mirror_vm, mirror_vm);
+       sev_migrate_from(dst_vm, sev_vm);
 
        kvm_vm_free(mirror_vm);
        kvm_vm_free(dst_mirror_vm);