Commit 79904c9d authored by Vitaly Kuznetsov's avatar Vitaly Kuznetsov Committed by Paolo Bonzini
Browse files

selftests: kvm: add a selftest for SMM 



Add a simple test for SMM, based on VMX.  The test implements its own
sync between the guest and the host as using our ucall library seems to
be too cumbersome: SMI handler is happening in real-address mode.

This patch also fixes KVM_SET_NESTED_STATE to happen after
KVM_SET_VCPU_EVENTS, in fact it places it last.  This is because
KVM needs to know whether the processor is in SMM or not.

Signed-off-by: default avatarVitaly Kuznetsov <vkuznets@redhat.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent c2390f16

tools/testing/selftests/kvm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/state_test 
TEST_GEN_PROGS_x86_64 += x86_64/evmcs_test

TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid

TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test

TEST_GEN_PROGS_x86_64 += x86_64/smm_test

TEST_GEN_PROGS_x86_64 += dirty_log_test

TEST_GEN_PROGS_x86_64 += clear_dirty_log_test

tools/testing/selftests/kvm/include/x86_64/processor.h

+27 −0
Original line number Diff line number Diff line
@@ -778,6 +778,33 @@ void vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index, 
#define MSR_IA32_APICBASE_ENABLE	(1<<11)

#define MSR_IA32_APICBASE_BASE		(0xfffff<<12)



#define APIC_BASE_MSR	0x800

#define X2APIC_ENABLE	(1UL << 10)

#define	APIC_ICR	0x300

#define		APIC_DEST_SELF		0x40000

#define		APIC_DEST_ALLINC	0x80000

#define		APIC_DEST_ALLBUT	0xC0000

#define		APIC_ICR_RR_MASK	0x30000

#define		APIC_ICR_RR_INVALID	0x00000

#define		APIC_ICR_RR_INPROG	0x10000

#define		APIC_ICR_RR_VALID	0x20000

#define		APIC_INT_LEVELTRIG	0x08000

#define		APIC_INT_ASSERT		0x04000

#define		APIC_ICR_BUSY		0x01000

#define		APIC_DEST_LOGICAL	0x00800

#define		APIC_DEST_PHYSICAL	0x00000

#define		APIC_DM_FIXED		0x00000

#define		APIC_DM_FIXED_MASK	0x00700

#define		APIC_DM_LOWEST		0x00100

#define		APIC_DM_SMI		0x00200

#define		APIC_DM_REMRD		0x00300

#define		APIC_DM_NMI		0x00400

#define		APIC_DM_INIT		0x00500

#define		APIC_DM_STARTUP		0x00600

#define		APIC_DM_EXTINT		0x00700

#define		APIC_VECTOR_MASK	0x000FF

#define	APIC_ICR2	0x310



#define MSR_IA32_TSCDEADLINE		0x000006e0



#define MSR_IA32_UCODE_WRITE		0x00000079

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

+6 −6
Original line number Diff line number Diff line
@@ -1101,12 +1101,6 @@ void vcpu_load_state(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_x86_state *s 
	struct vcpu *vcpu = vcpu_find(vm, vcpuid);

	int r;



	if (state->nested.size) {

		r = ioctl(vcpu->fd, KVM_SET_NESTED_STATE, &state->nested);

		TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_NESTED_STATE, r: %i",

			r);

	}



	r = ioctl(vcpu->fd, KVM_SET_XSAVE, &state->xsave);

        TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_XSAVE, r: %i",

                r);
@@ -1138,4 +1132,10 @@ void vcpu_load_state(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_x86_state *s 
	r = ioctl(vcpu->fd, KVM_SET_REGS, &state->regs);

        TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_REGS, r: %i",

                r);



	if (state->nested.size) {

		r = ioctl(vcpu->fd, KVM_SET_NESTED_STATE, &state->nested);

		TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_NESTED_STATE, r: %i",

			r);

	}

}

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

0 → 100644
+157 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2018, Red Hat, Inc.

 *

 * Tests for SMM.

 */

#define _GNU_SOURCE /* for program_invocation_short_name */

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#include <sys/ioctl.h>



#include "test_util.h"



#include "kvm_util.h"



#include "vmx.h"



#define VCPU_ID	      1



#define PAGE_SIZE  4096



#define SMRAM_SIZE 65536

#define SMRAM_MEMSLOT ((1 << 16) | 1)

#define SMRAM_PAGES (SMRAM_SIZE / PAGE_SIZE)

#define SMRAM_GPA 0x1000000

#define SMRAM_STAGE 0xfe



#define STR(x) #x

#define XSTR(s) STR(s)



#define SYNC_PORT 0xe

#define DONE 0xff



/*

 * This is compiled as normal 64-bit code, however, SMI handler is executed

 * in real-address mode. To stay simple we're limiting ourselves to a mode

 * independent subset of asm here.

 * SMI handler always report back fixed stage SMRAM_STAGE.

 */

uint8_t smi_handler[] = {

	0xb0, SMRAM_STAGE,    /* mov $SMRAM_STAGE, %al */

	0xe4, SYNC_PORT,      /* in $SYNC_PORT, %al */

	0x0f, 0xaa,           /* rsm */

};



void sync_with_host(uint64_t phase)

{

	asm volatile("in $" XSTR(SYNC_PORT)", %%al \n"

		     : : "a" (phase));

}



void self_smi(void)

{

	wrmsr(APIC_BASE_MSR + (APIC_ICR >> 4),

	      APIC_DEST_SELF | APIC_INT_ASSERT | APIC_DM_SMI);

}



void guest_code(struct vmx_pages *vmx_pages)

{

	uint64_t apicbase = rdmsr(MSR_IA32_APICBASE);



	sync_with_host(1);



	wrmsr(MSR_IA32_APICBASE, apicbase | X2APIC_ENABLE);



	sync_with_host(2);



	self_smi();



	sync_with_host(4);



	if (vmx_pages) {

		GUEST_ASSERT(prepare_for_vmx_operation(vmx_pages));



		sync_with_host(5);



		self_smi();



		sync_with_host(7);

	}



	sync_with_host(DONE);

}



int main(int argc, char *argv[])

{

	struct vmx_pages *vmx_pages = NULL;

	vm_vaddr_t vmx_pages_gva = 0;



	struct kvm_regs regs;

	struct kvm_vm *vm;

	struct kvm_run *run;

	struct kvm_x86_state *state;

	int stage, stage_reported;



	/* Create VM */

	vm = vm_create_default(VCPU_ID, 0, guest_code);



	vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());



	run = vcpu_state(vm, VCPU_ID);



	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)

		    == SMRAM_GPA, "could not allocate guest physical addresses?");



	memset(addr_gpa2hva(vm, SMRAM_GPA), 0x0, SMRAM_SIZE);

	memcpy(addr_gpa2hva(vm, SMRAM_GPA) + 0x8000, smi_handler,

	       sizeof(smi_handler));



	vcpu_set_msr(vm, VCPU_ID, MSR_IA32_SMBASE, SMRAM_GPA);



	if (kvm_check_cap(KVM_CAP_NESTED_STATE)) {

		vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);

		vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);

	} else {

		printf("will skip SMM test with VMX enabled\n");

		vcpu_args_set(vm, VCPU_ID, 1, 0);

	}



	for (stage = 1;; stage++) {

		_vcpu_run(vm, VCPU_ID);

		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));



		memset(&regs, 0, sizeof(regs));

		vcpu_regs_get(vm, VCPU_ID, &regs);



		stage_reported = regs.rax & 0xff;



		if (stage_reported == DONE)

			goto done;



		TEST_ASSERT(stage_reported == stage ||

			    stage_reported == SMRAM_STAGE,

			    "Unexpected stage: #%x, got %x",

			    stage, stage_reported);



		state = vcpu_save_state(vm, VCPU_ID);

		kvm_vm_release(vm);

		kvm_vm_restart(vm, O_RDWR);

		vm_vcpu_add(vm, VCPU_ID, 0, 0);

		vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());

		vcpu_load_state(vm, VCPU_ID, state);

		run = vcpu_state(vm, VCPU_ID);

		free(state);

	}



done:

	kvm_vm_free(vm);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE