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

KVM: selftests: Convert s390's "resets" test away from VCPU_ID 



Pass around a 'struct kvm_vcpu' object in the "resets" test instead of
referencing the vCPU by the global VCPU_ID.  Rename the #define for the
vCPU's ID to ARBITRARY_NON_ZERO_VCPU_ID to make it more obvious that (a)
the value matters but (b) is otherwise arbitrary.

Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent e5b77cde

tools/testing/selftests/kvm/s390x/resets.c

+77 −60
Original line number Diff line number Diff line
@@ -14,14 +14,12 @@ 
#include "kvm_util.h"

#include "kselftest.h"



#define VCPU_ID 3

#define LOCAL_IRQS 32



struct kvm_s390_irq buf[VCPU_ID + LOCAL_IRQS];

#define ARBITRARY_NON_ZERO_VCPU_ID 3



struct kvm_s390_irq buf[ARBITRARY_NON_ZERO_VCPU_ID + LOCAL_IRQS];



struct kvm_vm *vm;

struct kvm_run *run;

struct kvm_sync_regs *sync_regs;

static uint8_t regs_null[512];



static void guest_code_initial(void)
@@ -59,22 +57,22 @@ static void guest_code_initial(void) 
		);

}



static void test_one_reg(uint64_t id, uint64_t value)

static void test_one_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t value)

{

	uint64_t eval_reg;



	vcpu_get_reg(vm, VCPU_ID, id, &eval_reg);

	vcpu_get_reg(vcpu->vm, vcpu->id, id, &eval_reg);

	TEST_ASSERT(eval_reg == value, "value == 0x%lx", value);

}



static void assert_noirq(void)

static void assert_noirq(struct kvm_vcpu *vcpu)

{

	struct kvm_s390_irq_state irq_state;

	int irqs;



	irq_state.len = sizeof(buf);

	irq_state.buf = (unsigned long)buf;

	irqs = __vcpu_ioctl(vm, VCPU_ID, KVM_S390_GET_IRQ_STATE, &irq_state);

	irqs = __vcpu_ioctl(vcpu->vm, vcpu->id, KVM_S390_GET_IRQ_STATE, &irq_state);

	/*

	 * irqs contains the number of retrieved interrupts. Any interrupt

	 * (notably, the emergency call interrupt we have injected) should
@@ -84,19 +82,20 @@ static void assert_noirq(void) 
	TEST_ASSERT(!irqs, "IRQ pending");

}



static void assert_clear(void)

static void assert_clear(struct kvm_vcpu *vcpu)

{

	struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

	struct kvm_sregs sregs;

	struct kvm_regs regs;

	struct kvm_fpu fpu;



	vcpu_regs_get(vm, VCPU_ID, &regs);

	vcpu_regs_get(vcpu->vm, vcpu->id, &regs);

	TEST_ASSERT(!memcmp(&regs.gprs, regs_null, sizeof(regs.gprs)), "grs == 0");



	vcpu_sregs_get(vm, VCPU_ID, &sregs);

	vcpu_sregs_get(vcpu->vm, vcpu->id, &sregs);

	TEST_ASSERT(!memcmp(&sregs.acrs, regs_null, sizeof(sregs.acrs)), "acrs == 0");



	vcpu_fpu_get(vm, VCPU_ID, &fpu);

	vcpu_fpu_get(vcpu->vm, vcpu->id, &fpu);

	TEST_ASSERT(!memcmp(&fpu.fprs, regs_null, sizeof(fpu.fprs)), "fprs == 0");



	/* sync regs */
@@ -110,8 +109,10 @@ static void assert_clear(void) 
		    "vrs0-15 == 0 (sync_regs)");

}



static void assert_initial_noclear(void)

static void assert_initial_noclear(struct kvm_vcpu *vcpu)

{

	struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;



	TEST_ASSERT(sync_regs->gprs[0] == 0xffff000000000000UL,

		    "gpr0 == 0xffff000000000000 (sync_regs)");

	TEST_ASSERT(sync_regs->gprs[1] == 0x0000555500000000UL,
@@ -125,13 +126,14 @@ static void assert_initial_noclear(void) 
	TEST_ASSERT(sync_regs->acrs[9] == 1, "ar9 == 1 (sync_regs)");

}



static void assert_initial(void)

static void assert_initial(struct kvm_vcpu *vcpu)

{

	struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

	struct kvm_sregs sregs;

	struct kvm_fpu fpu;



	/* KVM_GET_SREGS */

	vcpu_sregs_get(vm, VCPU_ID, &sregs);

	vcpu_sregs_get(vcpu->vm, vcpu->id, &sregs);

	TEST_ASSERT(sregs.crs[0] == 0xE0UL, "cr0 == 0xE0 (KVM_GET_SREGS)");

	TEST_ASSERT(sregs.crs[14] == 0xC2000000UL,

		    "cr14 == 0xC2000000 (KVM_GET_SREGS)");
@@ -154,36 +156,38 @@ static void assert_initial(void) 
	TEST_ASSERT(sync_regs->gbea == 1, "gbea == 1 (sync_regs)");



	/* kvm_run */

	TEST_ASSERT(run->psw_addr == 0, "psw_addr == 0 (kvm_run)");

	TEST_ASSERT(run->psw_mask == 0, "psw_mask == 0 (kvm_run)");

	TEST_ASSERT(vcpu->run->psw_addr == 0, "psw_addr == 0 (kvm_run)");

	TEST_ASSERT(vcpu->run->psw_mask == 0, "psw_mask == 0 (kvm_run)");



	vcpu_fpu_get(vm, VCPU_ID, &fpu);

	vcpu_fpu_get(vcpu->vm, vcpu->id, &fpu);

	TEST_ASSERT(!fpu.fpc, "fpc == 0");



	test_one_reg(KVM_REG_S390_GBEA, 1);

	test_one_reg(KVM_REG_S390_PP, 0);

	test_one_reg(KVM_REG_S390_TODPR, 0);

	test_one_reg(KVM_REG_S390_CPU_TIMER, 0);

	test_one_reg(KVM_REG_S390_CLOCK_COMP, 0);

	test_one_reg(vcpu, KVM_REG_S390_GBEA, 1);

	test_one_reg(vcpu, KVM_REG_S390_PP, 0);

	test_one_reg(vcpu, KVM_REG_S390_TODPR, 0);

	test_one_reg(vcpu, KVM_REG_S390_CPU_TIMER, 0);

	test_one_reg(vcpu, KVM_REG_S390_CLOCK_COMP, 0);

}



static void assert_normal_noclear(void)

static void assert_normal_noclear(struct kvm_vcpu *vcpu)

{

	struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;



	TEST_ASSERT(sync_regs->crs[2] == 0x10, "cr2 == 10 (sync_regs)");

	TEST_ASSERT(sync_regs->crs[8] == 1, "cr10 == 1 (sync_regs)");

	TEST_ASSERT(sync_regs->crs[10] == 1, "cr10 == 1 (sync_regs)");

	TEST_ASSERT(sync_regs->crs[11] == -1, "cr11 == -1 (sync_regs)");

}



static void assert_normal(void)

static void assert_normal(struct kvm_vcpu *vcpu)

{

	test_one_reg(KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);

	TEST_ASSERT(sync_regs->pft == KVM_S390_PFAULT_TOKEN_INVALID,

	test_one_reg(vcpu, KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);

	TEST_ASSERT(vcpu->run->s.regs.pft == KVM_S390_PFAULT_TOKEN_INVALID,

			"pft == 0xff.....  (sync_regs)");

	assert_noirq();

	assert_noirq(vcpu);

}



static void inject_irq(int cpu_id)

static void inject_irq(struct kvm_vcpu *vcpu)

{

	struct kvm_s390_irq_state irq_state;

	struct kvm_s390_irq *irq = &buf[0];
@@ -193,73 +197,86 @@ static void inject_irq(int cpu_id) 
	irq_state.len = sizeof(struct kvm_s390_irq);

	irq_state.buf = (unsigned long)buf;

	irq->type = KVM_S390_INT_EMERGENCY;

	irq->u.emerg.code = cpu_id;

	irqs = __vcpu_ioctl(vm, cpu_id, KVM_S390_SET_IRQ_STATE, &irq_state);

	irq->u.emerg.code = vcpu->id;

	irqs = __vcpu_ioctl(vcpu->vm, vcpu->id, KVM_S390_SET_IRQ_STATE, &irq_state);

	TEST_ASSERT(irqs >= 0, "Error injecting EMERGENCY IRQ errno %d\n", errno);

}



static struct kvm_vm *create_vm(struct kvm_vcpu **vcpu)

{

	struct kvm_vm *vm;



	vm = vm_create(DEFAULT_GUEST_PHY_PAGES);



	*vcpu = vm_vcpu_add(vm, ARBITRARY_NON_ZERO_VCPU_ID, guest_code_initial);



	return vm;

}



static void test_normal(void)

{

	struct kvm_vcpu *vcpu;

	struct kvm_vm *vm;



	ksft_print_msg("Testing normal reset\n");

	/* Create VM */

	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);

	run = vcpu_state(vm, VCPU_ID);

	sync_regs = &run->s.regs;

	vm = create_vm(&vcpu);



	vcpu_run(vm, VCPU_ID);

	vcpu_run(vm, vcpu->id);



	inject_irq(VCPU_ID);

	inject_irq(vcpu);



	vcpu_ioctl(vm, VCPU_ID, KVM_S390_NORMAL_RESET, 0);

	vcpu_ioctl(vm, vcpu->id, KVM_S390_NORMAL_RESET, 0);



	/* must clears */

	assert_normal();

	assert_normal(vcpu);

	/* must not clears */

	assert_normal_noclear();

	assert_initial_noclear();

	assert_normal_noclear(vcpu);

	assert_initial_noclear(vcpu);



	kvm_vm_free(vm);

}



static void test_initial(void)

{

	struct kvm_vcpu *vcpu;

	struct kvm_vm *vm;



	ksft_print_msg("Testing initial reset\n");

	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);

	run = vcpu_state(vm, VCPU_ID);

	sync_regs = &run->s.regs;

	vm = create_vm(&vcpu);



	vcpu_run(vm, VCPU_ID);

	vcpu_run(vm, vcpu->id);



	inject_irq(VCPU_ID);

	inject_irq(vcpu);



	vcpu_ioctl(vm, VCPU_ID, KVM_S390_INITIAL_RESET, 0);

	vcpu_ioctl(vm, vcpu->id, KVM_S390_INITIAL_RESET, 0);



	/* must clears */

	assert_normal();

	assert_initial();

	assert_normal(vcpu);

	assert_initial(vcpu);

	/* must not clears */

	assert_initial_noclear();

	assert_initial_noclear(vcpu);



	kvm_vm_free(vm);

}



static void test_clear(void)

{

	struct kvm_vcpu *vcpu;

	struct kvm_vm *vm;



	ksft_print_msg("Testing clear reset\n");

	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);

	run = vcpu_state(vm, VCPU_ID);

	sync_regs = &run->s.regs;

	vm = create_vm(&vcpu);



	vcpu_run(vm, VCPU_ID);

	vcpu_run(vm, vcpu->id);



	inject_irq(VCPU_ID);

	inject_irq(vcpu);



	vcpu_ioctl(vm, VCPU_ID, KVM_S390_CLEAR_RESET, 0);

	vcpu_ioctl(vm, vcpu->id, KVM_S390_CLEAR_RESET, 0);



	/* must clears */

	assert_normal();

	assert_initial();

	assert_clear();

	assert_normal(vcpu);

	assert_initial(vcpu);

	assert_clear(vcpu);



	kvm_vm_free(vm);

}