Commit ac712209 authored by Sean Christopherson's avatar Sean Christopherson Committed by Paolo Bonzini
Browse files

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: default avatarSean Christopherson <seanjc@google.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent c472df1a

tools/testing/selftests/kvm/include/kvm_util_base.h

+4 −0
Original line number Diff line number Diff line
@@ -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);

tools/testing/selftests/kvm/lib/x86_64/vmx.c

+1 −1
Original line number Diff line number Diff line
@@ -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)) &&

tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c

+8 −11
Original line number Diff line number Diff line
@@ -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;

tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c

+39 −39
Original line number Diff line number Diff line
@@ -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 @@ static void test_sev_migrate_parameters(void) 
	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);