Commit fbba7e69 authored by Marc Zyngier's avatar Marc Zyngier
Browse files

Merge branch kvm-arm64/selftest/debug into kvmarm-master/next 

Guest self-hosted debug tests from Ricardo Koller

* kvm-arm64/selftest/debug:
  KVM: selftests: Add aarch64/debug-exceptions test
  KVM: selftests: Add exception handling support for aarch64
  KVM: selftests: Move GUEST_ASSERT_EQ to utils header
  KVM: selftests: Introduce UCALL_UNHANDLED for unhandled vector reporting
  KVM: selftests: Complete x86_64/sync_regs_test ucall
  KVM: selftests: Rename vm_handle_exception
parents 46c88622 4f05223a

tools/testing/selftests/kvm/.gitignore

+1 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

/aarch64/debug-exceptions

/aarch64/get-reg-list

/aarch64/get-reg-list-sve

/aarch64/vgic_init

tools/testing/selftests/kvm/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ endif 


LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/rbtree.c lib/sparsebit.c lib/test_util.c lib/guest_modes.c lib/perf_test_util.c

LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S

LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c

LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c lib/aarch64/handlers.S

LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318_test_handler.c



TEST_GEN_PROGS_x86_64 = x86_64/cr4_cpuid_sync_test
@@ -78,6 +78,7 @@ TEST_GEN_PROGS_x86_64 += memslot_perf_test 
TEST_GEN_PROGS_x86_64 += set_memory_region_test

TEST_GEN_PROGS_x86_64 += steal_time



TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions

TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list

TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list-sve

TEST_GEN_PROGS_aarch64 += aarch64/vgic_init

tools/testing/selftests/kvm/aarch64/debug-exceptions.c

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

#include <test_util.h>

#include <kvm_util.h>

#include <processor.h>



#define VCPU_ID 0



#define MDSCR_KDE	(1 << 13)

#define MDSCR_MDE	(1 << 15)

#define MDSCR_SS	(1 << 0)



#define DBGBCR_LEN8	(0xff << 5)

#define DBGBCR_EXEC	(0x0 << 3)

#define DBGBCR_EL1	(0x1 << 1)

#define DBGBCR_E	(0x1 << 0)



#define DBGWCR_LEN8	(0xff << 5)

#define DBGWCR_RD	(0x1 << 3)

#define DBGWCR_WR	(0x2 << 3)

#define DBGWCR_EL1	(0x1 << 1)

#define DBGWCR_E	(0x1 << 0)



#define SPSR_D		(1 << 9)

#define SPSR_SS		(1 << 21)



extern unsigned char sw_bp, hw_bp, bp_svc, bp_brk, hw_wp, ss_start;

static volatile uint64_t sw_bp_addr, hw_bp_addr;

static volatile uint64_t wp_addr, wp_data_addr;

static volatile uint64_t svc_addr;

static volatile uint64_t ss_addr[4], ss_idx;

#define  PC(v)  ((uint64_t)&(v))



static void reset_debug_state(void)

{

	asm volatile("msr daifset, #8");



	write_sysreg(osdlr_el1, 0);

	write_sysreg(oslar_el1, 0);

	isb();



	write_sysreg(mdscr_el1, 0);

	/* This test only uses the first bp and wp slot. */

	write_sysreg(dbgbvr0_el1, 0);

	write_sysreg(dbgbcr0_el1, 0);

	write_sysreg(dbgwcr0_el1, 0);

	write_sysreg(dbgwvr0_el1, 0);

	isb();

}



static void install_wp(uint64_t addr)

{

	uint32_t wcr;

	uint32_t mdscr;



	wcr = DBGWCR_LEN8 | DBGWCR_RD | DBGWCR_WR | DBGWCR_EL1 | DBGWCR_E;

	write_sysreg(dbgwcr0_el1, wcr);

	write_sysreg(dbgwvr0_el1, addr);

	isb();



	asm volatile("msr daifclr, #8");



	mdscr = read_sysreg(mdscr_el1) | MDSCR_KDE | MDSCR_MDE;

	write_sysreg(mdscr_el1, mdscr);

	isb();

}



static void install_hw_bp(uint64_t addr)

{

	uint32_t bcr;

	uint32_t mdscr;



	bcr = DBGBCR_LEN8 | DBGBCR_EXEC | DBGBCR_EL1 | DBGBCR_E;

	write_sysreg(dbgbcr0_el1, bcr);

	write_sysreg(dbgbvr0_el1, addr);

	isb();



	asm volatile("msr daifclr, #8");



	mdscr = read_sysreg(mdscr_el1) | MDSCR_KDE | MDSCR_MDE;

	write_sysreg(mdscr_el1, mdscr);

	isb();

}



static void install_ss(void)

{

	uint32_t mdscr;



	asm volatile("msr daifclr, #8");



	mdscr = read_sysreg(mdscr_el1) | MDSCR_KDE | MDSCR_SS;

	write_sysreg(mdscr_el1, mdscr);

	isb();

}



static volatile char write_data;



static void guest_code(void)

{

	GUEST_SYNC(0);



	/* Software-breakpoint */

	asm volatile("sw_bp: brk #0");

	GUEST_ASSERT_EQ(sw_bp_addr, PC(sw_bp));



	GUEST_SYNC(1);



	/* Hardware-breakpoint */

	reset_debug_state();

	install_hw_bp(PC(hw_bp));

	asm volatile("hw_bp: nop");

	GUEST_ASSERT_EQ(hw_bp_addr, PC(hw_bp));



	GUEST_SYNC(2);



	/* Hardware-breakpoint + svc */

	reset_debug_state();

	install_hw_bp(PC(bp_svc));

	asm volatile("bp_svc: svc #0");

	GUEST_ASSERT_EQ(hw_bp_addr, PC(bp_svc));

	GUEST_ASSERT_EQ(svc_addr, PC(bp_svc) + 4);



	GUEST_SYNC(3);



	/* Hardware-breakpoint + software-breakpoint */

	reset_debug_state();

	install_hw_bp(PC(bp_brk));

	asm volatile("bp_brk: brk #0");

	GUEST_ASSERT_EQ(sw_bp_addr, PC(bp_brk));

	GUEST_ASSERT_EQ(hw_bp_addr, PC(bp_brk));



	GUEST_SYNC(4);



	/* Watchpoint */

	reset_debug_state();

	install_wp(PC(write_data));

	write_data = 'x';

	GUEST_ASSERT_EQ(write_data, 'x');

	GUEST_ASSERT_EQ(wp_data_addr, PC(write_data));



	GUEST_SYNC(5);



	/* Single-step */

	reset_debug_state();

	install_ss();

	ss_idx = 0;

	asm volatile("ss_start:\n"

		     "mrs x0, esr_el1\n"

		     "add x0, x0, #1\n"

		     "msr daifset, #8\n"

		     : : : "x0");

	GUEST_ASSERT_EQ(ss_addr[0], PC(ss_start));

	GUEST_ASSERT_EQ(ss_addr[1], PC(ss_start) + 4);

	GUEST_ASSERT_EQ(ss_addr[2], PC(ss_start) + 8);



	GUEST_DONE();

}



static void guest_sw_bp_handler(struct ex_regs *regs)

{

	sw_bp_addr = regs->pc;

	regs->pc += 4;

}



static void guest_hw_bp_handler(struct ex_regs *regs)

{

	hw_bp_addr = regs->pc;

	regs->pstate |= SPSR_D;

}



static void guest_wp_handler(struct ex_regs *regs)

{

	wp_data_addr = read_sysreg(far_el1);

	wp_addr = regs->pc;

	regs->pstate |= SPSR_D;

}



static void guest_ss_handler(struct ex_regs *regs)

{

	GUEST_ASSERT_1(ss_idx < 4, ss_idx);

	ss_addr[ss_idx++] = regs->pc;

	regs->pstate |= SPSR_SS;

}



static void guest_svc_handler(struct ex_regs *regs)

{

	svc_addr = regs->pc;

}



static int debug_version(struct kvm_vm *vm)

{

	uint64_t id_aa64dfr0;



	get_reg(vm, VCPU_ID, ARM64_SYS_REG(ID_AA64DFR0_EL1), &id_aa64dfr0);

	return id_aa64dfr0 & 0xf;

}



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

{

	struct kvm_vm *vm;

	struct ucall uc;

	int stage;



	vm = vm_create_default(VCPU_ID, 0, guest_code);

	ucall_init(vm, NULL);



	vm_init_descriptor_tables(vm);

	vcpu_init_descriptor_tables(vm, VCPU_ID);



	if (debug_version(vm) < 6) {

		print_skip("Armv8 debug architecture not supported.");

		kvm_vm_free(vm);

		exit(KSFT_SKIP);

	}



	vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT,

				ESR_EC_BRK_INS, guest_sw_bp_handler);

	vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT,

				ESR_EC_HW_BP_CURRENT, guest_hw_bp_handler);

	vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT,

				ESR_EC_WP_CURRENT, guest_wp_handler);

	vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT,

				ESR_EC_SSTEP_CURRENT, guest_ss_handler);

	vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT,

				ESR_EC_SVC64, guest_svc_handler);



	for (stage = 0; stage < 7; stage++) {

		vcpu_run(vm, VCPU_ID);



		switch (get_ucall(vm, VCPU_ID, &uc)) {

		case UCALL_SYNC:

			TEST_ASSERT(uc.args[1] == stage,

				"Stage %d: Unexpected sync ucall, got %lx",

				stage, (ulong)uc.args[1]);

			break;

		case UCALL_ABORT:

			TEST_FAIL("%s at %s:%ld\n\tvalues: %#lx, %#lx",

				(const char *)uc.args[0],

				__FILE__, uc.args[1], uc.args[2], uc.args[3]);

			break;

		case UCALL_DONE:

			goto done;

		default:

			TEST_FAIL("Unknown ucall %lu", uc.cmd);

		}

	}



done:

	kvm_vm_free(vm);

	return 0;

}

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

+78 −5
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#define SELFTEST_KVM_PROCESSOR_H



#include "kvm_util.h"

#include <linux/stringify.h>





#define ARM64_CORE_REG(x) (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \
@@ -18,6 +19,9 @@ 
#define MAIR_EL1                3, 0, 10, 2, 0

#define TTBR0_EL1               3, 0,  2, 0, 0

#define SCTLR_EL1               3, 0,  1, 0, 0

#define VBAR_EL1                3, 0, 12, 0, 0



#define ID_AA64DFR0_EL1         3, 0,  0, 5, 0



/*

 * Default MAIR
@@ -56,4 +60,73 @@ void aarch64_vcpu_setup(struct kvm_vm *vm, int vcpuid, struct kvm_vcpu_init *ini 
void aarch64_vcpu_add_default(struct kvm_vm *vm, uint32_t vcpuid,

			      struct kvm_vcpu_init *init, void *guest_code);



struct ex_regs {

	u64 regs[31];

	u64 sp;

	u64 pc;

	u64 pstate;

};



#define VECTOR_NUM	16



enum {

	VECTOR_SYNC_CURRENT_SP0,

	VECTOR_IRQ_CURRENT_SP0,

	VECTOR_FIQ_CURRENT_SP0,

	VECTOR_ERROR_CURRENT_SP0,



	VECTOR_SYNC_CURRENT,

	VECTOR_IRQ_CURRENT,

	VECTOR_FIQ_CURRENT,

	VECTOR_ERROR_CURRENT,



	VECTOR_SYNC_LOWER_64,

	VECTOR_IRQ_LOWER_64,

	VECTOR_FIQ_LOWER_64,

	VECTOR_ERROR_LOWER_64,



	VECTOR_SYNC_LOWER_32,

	VECTOR_IRQ_LOWER_32,

	VECTOR_FIQ_LOWER_32,

	VECTOR_ERROR_LOWER_32,

};



#define VECTOR_IS_SYNC(v) ((v) == VECTOR_SYNC_CURRENT_SP0 || \

			   (v) == VECTOR_SYNC_CURRENT     || \

			   (v) == VECTOR_SYNC_LOWER_64    || \

			   (v) == VECTOR_SYNC_LOWER_32)



#define ESR_EC_NUM		64

#define ESR_EC_SHIFT		26

#define ESR_EC_MASK		(ESR_EC_NUM - 1)



#define ESR_EC_SVC64		0x15

#define ESR_EC_HW_BP_CURRENT	0x31

#define ESR_EC_SSTEP_CURRENT	0x33

#define ESR_EC_WP_CURRENT	0x35

#define ESR_EC_BRK_INS		0x3c



void vm_init_descriptor_tables(struct kvm_vm *vm);

void vcpu_init_descriptor_tables(struct kvm_vm *vm, uint32_t vcpuid);



typedef void(*handler_fn)(struct ex_regs *);

void vm_install_exception_handler(struct kvm_vm *vm,

		int vector, handler_fn handler);

void vm_install_sync_handler(struct kvm_vm *vm,

		int vector, int ec, handler_fn handler);



#define write_sysreg(reg, val)						  \

({									  \

	u64 __val = (u64)(val);						  \

	asm volatile("msr " __stringify(reg) ", %x0" : : "rZ" (__val));	  \

})



#define read_sysreg(reg)						  \

({	u64 val;							  \

	asm volatile("mrs %0, "__stringify(reg) : "=r"(val) : : "memory");\

	val;								  \

})



#define isb()	asm volatile("isb" : : : "memory")



#endif /* SELFTEST_KVM_PROCESSOR_H */

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

+13 −10
Original line number Diff line number Diff line
@@ -349,6 +349,7 @@ enum { 
	UCALL_SYNC,

	UCALL_ABORT,

	UCALL_DONE,

	UCALL_UNHANDLED,

};



#define UCALL_MAX_ARGS 6
@@ -367,26 +368,28 @@ uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc); 
				ucall(UCALL_SYNC, 6, "hello", stage, arg1, arg2, arg3, arg4)

#define GUEST_SYNC(stage)	ucall(UCALL_SYNC, 2, "hello", stage)

#define GUEST_DONE()		ucall(UCALL_DONE, 0)

#define __GUEST_ASSERT(_condition, _nargs, _args...) do {	\

#define __GUEST_ASSERT(_condition, _condstr, _nargs, _args...) do {    \

	if (!(_condition))                                              \

		ucall(UCALL_ABORT, 2 + _nargs,                          \

			"Failed guest assert: "                         \

			#_condition, __LINE__, _args);		\

			_condstr, __LINE__, _args);                     \

} while (0)



#define GUEST_ASSERT(_condition) \

	__GUEST_ASSERT((_condition), 0, 0)

	__GUEST_ASSERT(_condition, #_condition, 0, 0)



#define GUEST_ASSERT_1(_condition, arg1) \

	__GUEST_ASSERT((_condition), 1, (arg1))

	__GUEST_ASSERT(_condition, #_condition, 1, (arg1))



#define GUEST_ASSERT_2(_condition, arg1, arg2) \

	__GUEST_ASSERT((_condition), 2, (arg1), (arg2))

	__GUEST_ASSERT(_condition, #_condition, 2, (arg1), (arg2))



#define GUEST_ASSERT_3(_condition, arg1, arg2, arg3) \

	__GUEST_ASSERT((_condition), 3, (arg1), (arg2), (arg3))

	__GUEST_ASSERT(_condition, #_condition, 3, (arg1), (arg2), (arg3))



#define GUEST_ASSERT_4(_condition, arg1, arg2, arg3, arg4) \

	__GUEST_ASSERT((_condition), 4, (arg1), (arg2), (arg3), (arg4))

	__GUEST_ASSERT(_condition, #_condition, 4, (arg1), (arg2), (arg3), (arg4))



#define GUEST_ASSERT_EQ(a, b) __GUEST_ASSERT((a) == (b), #a " == " #b, 2, a, b)



#endif /* SELFTEST_KVM_UTIL_H */