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

Merge branch kvm-arm64/selftest/s2-faults into kvmarm-master/next 



* kvm-arm64/selftest/s2-faults:
  : .
  : New KVM/arm64 selftests exercising various sorts of S2 faults, courtesy
  : of Ricardo Koller. From the cover letter:
  :
  : "This series adds a new aarch64 selftest for testing stage 2 fault handling
  : for various combinations of guest accesses (e.g., write, S1PTW), backing
  : sources (e.g., anon), and types of faults (e.g., read on hugetlbfs with a
  : hole, write on a readonly memslot). Each test tries a different combination
  : and then checks that the access results in the right behavior (e.g., uffd
  : faults with the right address and write/read flag). [...]"
  : .
  KVM: selftests: aarch64: Add mix of tests into page_fault_test
  KVM: selftests: aarch64: Add readonly memslot tests into page_fault_test
  KVM: selftests: aarch64: Add dirty logging tests into page_fault_test
  KVM: selftests: aarch64: Add userfaultfd tests into page_fault_test
  KVM: selftests: aarch64: Add aarch64/page_fault_test
  KVM: selftests: Use the right memslot for code, page-tables, and data allocations
  KVM: selftests: Fix alignment in virt_arch_pgd_alloc() and vm_vaddr_alloc()
  KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
  KVM: selftests: Stash backing_src_type in struct userspace_mem_region
  tools: Copy bitfield.h from the kernel sources
  KVM: selftests: aarch64: Construct DEFAULT_MAIR_EL1 using sysreg.h macros
  KVM: selftests: Add missing close and munmap in __vm_mem_region_delete()
  KVM: selftests: aarch64: Add virt_get_pte_hva() library function
  KVM: selftests: Add a userfaultfd library

Signed-off-by: default avatarMarc Zyngier <maz@kernel.org>
parents 02f6fdd4 ff2b5509

tools/include/linux/bitfield.h

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

/*

 * Copyright (C) 2014 Felix Fietkau <nbd@nbd.name>

 * Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>

 */



#ifndef _LINUX_BITFIELD_H

#define _LINUX_BITFIELD_H



#include <linux/build_bug.h>

#include <asm/byteorder.h>



/*

 * Bitfield access macros

 *

 * FIELD_{GET,PREP} macros take as first parameter shifted mask

 * from which they extract the base mask and shift amount.

 * Mask must be a compilation time constant.

 *

 * Example:

 *

 *  #define REG_FIELD_A  GENMASK(6, 0)

 *  #define REG_FIELD_B  BIT(7)

 *  #define REG_FIELD_C  GENMASK(15, 8)

 *  #define REG_FIELD_D  GENMASK(31, 16)

 *

 * Get:

 *  a = FIELD_GET(REG_FIELD_A, reg);

 *  b = FIELD_GET(REG_FIELD_B, reg);

 *

 * Set:

 *  reg = FIELD_PREP(REG_FIELD_A, 1) |

 *	  FIELD_PREP(REG_FIELD_B, 0) |

 *	  FIELD_PREP(REG_FIELD_C, c) |

 *	  FIELD_PREP(REG_FIELD_D, 0x40);

 *

 * Modify:

 *  reg &= ~REG_FIELD_C;

 *  reg |= FIELD_PREP(REG_FIELD_C, c);

 */



#define __bf_shf(x) (__builtin_ffsll(x) - 1)



#define __scalar_type_to_unsigned_cases(type)				\

		unsigned type:	(unsigned type)0,			\

		signed type:	(unsigned type)0



#define __unsigned_scalar_typeof(x) typeof(				\

		_Generic((x),						\

			char:	(unsigned char)0,			\

			__scalar_type_to_unsigned_cases(char),		\

			__scalar_type_to_unsigned_cases(short),		\

			__scalar_type_to_unsigned_cases(int),		\

			__scalar_type_to_unsigned_cases(long),		\

			__scalar_type_to_unsigned_cases(long long),	\

			default: (x)))



#define __bf_cast_unsigned(type, x)	((__unsigned_scalar_typeof(type))(x))



#define __BF_FIELD_CHECK(_mask, _reg, _val, _pfx)			\

	({								\

		BUILD_BUG_ON_MSG(!__builtin_constant_p(_mask),		\

				 _pfx "mask is not constant");		\

		BUILD_BUG_ON_MSG((_mask) == 0, _pfx "mask is zero");	\

		BUILD_BUG_ON_MSG(__builtin_constant_p(_val) ?		\

				 ~((_mask) >> __bf_shf(_mask)) & (_val) : 0, \

				 _pfx "value too large for the field"); \

		BUILD_BUG_ON_MSG(__bf_cast_unsigned(_mask, _mask) >	\

				 __bf_cast_unsigned(_reg, ~0ull),	\

				 _pfx "type of reg too small for mask"); \

		__BUILD_BUG_ON_NOT_POWER_OF_2((_mask) +			\

					      (1ULL << __bf_shf(_mask))); \

	})



/**

 * FIELD_MAX() - produce the maximum value representable by a field

 * @_mask: shifted mask defining the field's length and position

 *

 * FIELD_MAX() returns the maximum value that can be held in the field

 * specified by @_mask.

 */

#define FIELD_MAX(_mask)						\

	({								\

		__BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_MAX: ");	\

		(typeof(_mask))((_mask) >> __bf_shf(_mask));		\

	})



/**

 * FIELD_FIT() - check if value fits in the field

 * @_mask: shifted mask defining the field's length and position

 * @_val:  value to test against the field

 *

 * Return: true if @_val can fit inside @_mask, false if @_val is too big.

 */

#define FIELD_FIT(_mask, _val)						\

	({								\

		__BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_FIT: ");	\

		!((((typeof(_mask))_val) << __bf_shf(_mask)) & ~(_mask)); \

	})



/**

 * FIELD_PREP() - prepare a bitfield element

 * @_mask: shifted mask defining the field's length and position

 * @_val:  value to put in the field

 *

 * FIELD_PREP() masks and shifts up the value.  The result should

 * be combined with other fields of the bitfield using logical OR.

 */

#define FIELD_PREP(_mask, _val)						\

	({								\

		__BF_FIELD_CHECK(_mask, 0ULL, _val, "FIELD_PREP: ");	\

		((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask);	\

	})



/**

 * FIELD_GET() - extract a bitfield element

 * @_mask: shifted mask defining the field's length and position

 * @_reg:  value of entire bitfield

 *

 * FIELD_GET() extracts the field specified by @_mask from the

 * bitfield passed in as @_reg by masking and shifting it down.

 */

#define FIELD_GET(_mask, _reg)						\

	({								\

		__BF_FIELD_CHECK(_mask, _reg, 0U, "FIELD_GET: ");	\

		(typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask));	\

	})



extern void __compiletime_error("value doesn't fit into mask")

__field_overflow(void);

extern void __compiletime_error("bad bitfield mask")

__bad_mask(void);

static __always_inline u64 field_multiplier(u64 field)

{

	if ((field | (field - 1)) & ((field | (field - 1)) + 1))

		__bad_mask();

	return field & -field;

}

static __always_inline u64 field_mask(u64 field)

{

	return field / field_multiplier(field);

}

#define field_max(field)	((typeof(field))field_mask(field))

#define ____MAKE_OP(type,base,to,from)					\

static __always_inline __##type type##_encode_bits(base v, base field)	\

{									\

	if (__builtin_constant_p(v) && (v & ~field_mask(field)))	\

		__field_overflow();					\

	return to((v & field_mask(field)) * field_multiplier(field));	\

}									\

static __always_inline __##type type##_replace_bits(__##type old,	\

					base val, base field)		\

{									\

	return (old & ~to(field)) | type##_encode_bits(val, field);	\

}									\

static __always_inline void type##p_replace_bits(__##type *p,		\

					base val, base field)		\

{									\

	*p = (*p & ~to(field)) | type##_encode_bits(val, field);	\

}									\

static __always_inline base type##_get_bits(__##type v, base field)	\

{									\

	return (from(v) & field)/field_multiplier(field);		\

}

#define __MAKE_OP(size)							\

	____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu)	\

	____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu)	\

	____MAKE_OP(u##size,u##size,,)

____MAKE_OP(u8,u8,,)

__MAKE_OP(16)

__MAKE_OP(32)

__MAKE_OP(64)

#undef __MAKE_OP

#undef ____MAKE_OP



#endif

tools/testing/selftests/kvm/.gitignore

+1 −0
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ 
/aarch64/debug-exceptions

/aarch64/get-reg-list

/aarch64/hypercalls

/aarch64/page_fault_test

/aarch64/psci_test

/aarch64/vcpu_width_config

/aarch64/vgic_init

tools/testing/selftests/kvm/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ LIBKVM += lib/perf_test_util.c 
LIBKVM += lib/rbtree.c

LIBKVM += lib/sparsebit.c

LIBKVM += lib/test_util.c

LIBKVM += lib/userfaultfd_util.c



LIBKVM_STRING += lib/string_override.c
@@ -152,6 +153,7 @@ TEST_GEN_PROGS_aarch64 += aarch64/arch_timer 
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions

TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list

TEST_GEN_PROGS_aarch64 += aarch64/hypercalls

TEST_GEN_PROGS_aarch64 += aarch64/page_fault_test

TEST_GEN_PROGS_aarch64 += aarch64/psci_test

TEST_GEN_PROGS_aarch64 += aarch64/vcpu_width_config

TEST_GEN_PROGS_aarch64 += aarch64/vgic_init

tools/testing/selftests/kvm/aarch64/page_fault_test.c

0 → 100644
+1112 −0

File added.

Preview size limit exceeded, changes collapsed.

tools/testing/selftests/kvm/demand_paging_test.c

+30 −198
Original line number Diff line number Diff line
@@ -22,23 +22,13 @@ 
#include "test_util.h"

#include "perf_test_util.h"

#include "guest_modes.h"

#include "userfaultfd_util.h"



#ifdef __NR_userfaultfd



#ifdef PRINT_PER_PAGE_UPDATES

#define PER_PAGE_DEBUG(...) printf(__VA_ARGS__)

#else

#define PER_PAGE_DEBUG(...) _no_printf(__VA_ARGS__)

#endif



#ifdef PRINT_PER_VCPU_UPDATES

#define PER_VCPU_DEBUG(...) printf(__VA_ARGS__)

#else

#define PER_VCPU_DEBUG(...) _no_printf(__VA_ARGS__)

#endif



static int nr_vcpus = 1;

static uint64_t guest_percpu_mem_size = DEFAULT_PER_VCPU_MEM_SIZE;



static size_t demand_paging_size;

static char *guest_data_prototype;
@@ -67,9 +57,11 @@ static void vcpu_worker(struct perf_test_vcpu_args *vcpu_args) 
		       ts_diff.tv_sec, ts_diff.tv_nsec);

}



static int handle_uffd_page_request(int uffd_mode, int uffd, uint64_t addr)

static int handle_uffd_page_request(int uffd_mode, int uffd,

		struct uffd_msg *msg)

{

	pid_t tid = syscall(__NR_gettid);

	uint64_t addr = msg->arg.pagefault.address;

	struct timespec start;

	struct timespec ts_diff;

	int r;
@@ -116,123 +108,17 @@ static int handle_uffd_page_request(int uffd_mode, int uffd, uint64_t addr) 
	return 0;

}



bool quit_uffd_thread;



struct uffd_handler_args {

struct test_params {

	int uffd_mode;

	int uffd;

	int pipefd;

	useconds_t delay;

	useconds_t uffd_delay;

	enum vm_mem_backing_src_type src_type;

	bool partition_vcpu_memory_access;

};



static void *uffd_handler_thread_fn(void *arg)

static void prefault_mem(void *alias, uint64_t len)

{

	struct uffd_handler_args *uffd_args = (struct uffd_handler_args *)arg;

	int uffd = uffd_args->uffd;

	int pipefd = uffd_args->pipefd;

	useconds_t delay = uffd_args->delay;

	int64_t pages = 0;

	struct timespec start;

	struct timespec ts_diff;



	clock_gettime(CLOCK_MONOTONIC, &start);

	while (!quit_uffd_thread) {

		struct uffd_msg msg;

		struct pollfd pollfd[2];

		char tmp_chr;

		int r;

		uint64_t addr;



		pollfd[0].fd = uffd;

		pollfd[0].events = POLLIN;

		pollfd[1].fd = pipefd;

		pollfd[1].events = POLLIN;



		r = poll(pollfd, 2, -1);

		switch (r) {

		case -1:

			pr_info("poll err");

			continue;

		case 0:

			continue;

		case 1:

			break;

		default:

			pr_info("Polling uffd returned %d", r);

			return NULL;

		}



		if (pollfd[0].revents & POLLERR) {

			pr_info("uffd revents has POLLERR");

			return NULL;

		}



		if (pollfd[1].revents & POLLIN) {

			r = read(pollfd[1].fd, &tmp_chr, 1);

			TEST_ASSERT(r == 1,

				    "Error reading pipefd in UFFD thread\n");

			return NULL;

		}



		if (!(pollfd[0].revents & POLLIN))

			continue;



		r = read(uffd, &msg, sizeof(msg));

		if (r == -1) {

			if (errno == EAGAIN)

				continue;

			pr_info("Read of uffd got errno %d\n", errno);

			return NULL;

		}



		if (r != sizeof(msg)) {

			pr_info("Read on uffd returned unexpected size: %d bytes", r);

			return NULL;

		}



		if (!(msg.event & UFFD_EVENT_PAGEFAULT))

			continue;



		if (delay)

			usleep(delay);

		addr =  msg.arg.pagefault.address;

		r = handle_uffd_page_request(uffd_args->uffd_mode, uffd, addr);

		if (r < 0)

			return NULL;

		pages++;

	}



	ts_diff = timespec_elapsed(start);

	PER_VCPU_DEBUG("userfaulted %ld pages over %ld.%.9lds. (%f/sec)\n",

		       pages, ts_diff.tv_sec, ts_diff.tv_nsec,

		       pages / ((double)ts_diff.tv_sec + (double)ts_diff.tv_nsec / 100000000.0));



	return NULL;

}



static void setup_demand_paging(struct kvm_vm *vm,

				pthread_t *uffd_handler_thread, int pipefd,

				int uffd_mode, useconds_t uffd_delay,

				struct uffd_handler_args *uffd_args,

				void *hva, void *alias, uint64_t len)

{

	bool is_minor = (uffd_mode == UFFDIO_REGISTER_MODE_MINOR);

	int uffd;

	struct uffdio_api uffdio_api;

	struct uffdio_register uffdio_register;

	uint64_t expected_ioctls = ((uint64_t) 1) << _UFFDIO_COPY;

	int ret;



	PER_PAGE_DEBUG("Userfaultfd %s mode, faults resolved with %s\n",

		       is_minor ? "MINOR" : "MISSING",

		       is_minor ? "UFFDIO_CONINUE" : "UFFDIO_COPY");



	/* In order to get minor faults, prefault via the alias. */

	if (is_minor) {

	size_t p;



		expected_ioctls = ((uint64_t) 1) << _UFFDIO_CONTINUE;



	TEST_ASSERT(alias != NULL, "Alias required for minor faults");

	for (p = 0; p < (len / demand_paging_size); ++p) {

		memcpy(alias + (p * demand_paging_size),
@@ -240,50 +126,14 @@ static void setup_demand_paging(struct kvm_vm *vm, 
	}

}



	uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);

	TEST_ASSERT(uffd >= 0, __KVM_SYSCALL_ERROR("userfaultfd()", uffd));



	uffdio_api.api = UFFD_API;

	uffdio_api.features = 0;

	ret = ioctl(uffd, UFFDIO_API, &uffdio_api);

	TEST_ASSERT(ret != -1, __KVM_SYSCALL_ERROR("UFFDIO_API", ret));



	uffdio_register.range.start = (uint64_t)hva;

	uffdio_register.range.len = len;

	uffdio_register.mode = uffd_mode;

	ret = ioctl(uffd, UFFDIO_REGISTER, &uffdio_register);

	TEST_ASSERT(ret != -1, __KVM_SYSCALL_ERROR("UFFDIO_REGISTER", ret));

	TEST_ASSERT((uffdio_register.ioctls & expected_ioctls) ==

		    expected_ioctls, "missing userfaultfd ioctls");



	uffd_args->uffd_mode = uffd_mode;

	uffd_args->uffd = uffd;

	uffd_args->pipefd = pipefd;

	uffd_args->delay = uffd_delay;

	pthread_create(uffd_handler_thread, NULL, uffd_handler_thread_fn,

		       uffd_args);



	PER_VCPU_DEBUG("Created uffd thread for HVA range [%p, %p)\n",

		       hva, hva + len);

}



struct test_params {

	int uffd_mode;

	useconds_t uffd_delay;

	enum vm_mem_backing_src_type src_type;

	bool partition_vcpu_memory_access;

};



static void run_test(enum vm_guest_mode mode, void *arg)

{

	struct test_params *p = arg;

	pthread_t *uffd_handler_threads = NULL;

	struct uffd_handler_args *uffd_args = NULL;

	struct uffd_desc **uffd_descs = NULL;

	struct timespec start;

	struct timespec ts_diff;

	int *pipefds = NULL;

	struct kvm_vm *vm;

	int r, i;

	int i;



	vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size, 1,

				 p->src_type, p->partition_vcpu_memory_access);
@@ -296,15 +146,8 @@ static void run_test(enum vm_guest_mode mode, void *arg) 
	memset(guest_data_prototype, 0xAB, demand_paging_size);



	if (p->uffd_mode) {

		uffd_handler_threads =

			malloc(nr_vcpus * sizeof(*uffd_handler_threads));

		TEST_ASSERT(uffd_handler_threads, "Memory allocation failed");



		uffd_args = malloc(nr_vcpus * sizeof(*uffd_args));

		TEST_ASSERT(uffd_args, "Memory allocation failed");



		pipefds = malloc(sizeof(int) * nr_vcpus * 2);

		TEST_ASSERT(pipefds, "Unable to allocate memory for pipefd");

		uffd_descs = malloc(nr_vcpus * sizeof(struct uffd_desc *));

		TEST_ASSERT(uffd_descs, "Memory allocation failed");



		for (i = 0; i < nr_vcpus; i++) {

			struct perf_test_vcpu_args *vcpu_args;
@@ -317,19 +160,17 @@ static void run_test(enum vm_guest_mode mode, void *arg) 
			vcpu_hva = addr_gpa2hva(vm, vcpu_args->gpa);

			vcpu_alias = addr_gpa2alias(vm, vcpu_args->gpa);



			prefault_mem(vcpu_alias,

				vcpu_args->pages * perf_test_args.guest_page_size);



			/*

			 * Set up user fault fd to handle demand paging

			 * requests.

			 */

			r = pipe2(&pipefds[i * 2],

				  O_CLOEXEC | O_NONBLOCK);

			TEST_ASSERT(!r, "Failed to set up pipefd");



			setup_demand_paging(vm, &uffd_handler_threads[i],

					    pipefds[i * 2], p->uffd_mode,

					    p->uffd_delay, &uffd_args[i],

					    vcpu_hva, vcpu_alias,

					    vcpu_args->pages * perf_test_args.guest_page_size);

			uffd_descs[i] = uffd_setup_demand_paging(

				p->uffd_mode, p->uffd_delay, vcpu_hva,

				vcpu_args->pages * perf_test_args.guest_page_size,

				&handle_uffd_page_request);

		}

	}
@@ -344,15 +185,9 @@ static void run_test(enum vm_guest_mode mode, void *arg) 
	pr_info("All vCPU threads joined\n");



	if (p->uffd_mode) {

		char c;



		/* Tell the user fault fd handler threads to quit */

		for (i = 0; i < nr_vcpus; i++) {

			r = write(pipefds[i * 2 + 1], &c, 1);

			TEST_ASSERT(r == 1, "Unable to write to pipefd");



			pthread_join(uffd_handler_threads[i], NULL);

		}

		for (i = 0; i < nr_vcpus; i++)

			uffd_stop_demand_paging(uffd_descs[i]);

	}



	pr_info("Total guest execution time: %ld.%.9lds\n",
@@ -364,11 +199,8 @@ static void run_test(enum vm_guest_mode mode, void *arg) 
	perf_test_destroy_vm(vm);



	free(guest_data_prototype);

	if (p->uffd_mode) {

		free(uffd_handler_threads);

		free(uffd_args);

		free(pipefds);

	}

	if (p->uffd_mode)

		free(uffd_descs);

}



static void help(char *name)