Merge tag 'kvm-x86-selftests-6.5' of https://github.com/kvm-x86/linux into HEAD (bb05b0ef) · Commits · EulixOS / Software / Kernel

tools/testing/selftests/kvm/Makefile

+16 −2

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ TEST_PROGS_x86_64 += x86_64/nx_huge_pages_test.sh
		# Compiled test targets
		TEST_GEN_PROGS_x86_64 = x86_64/cpuid_test
		TEST_GEN_PROGS_x86_64 += x86_64/cr4_cpuid_sync_test
		TEST_GEN_PROGS_x86_64 += x86_64/dirty_log_page_splitting_test
		TEST_GEN_PROGS_x86_64 += x86_64/get_msr_index_features
		TEST_GEN_PROGS_x86_64 += x86_64/exit_on_emulation_failure_test
		TEST_GEN_PROGS_x86_64 += x86_64/fix_hypercall_test
		@@ -185,6 +186,8 @@ TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(ARCH_DIR))
		TEST_GEN_PROGS_EXTENDED += $(TEST_GEN_PROGS_EXTENDED_$(ARCH_DIR))
		LIBKVM += $(LIBKVM_$(ARCH_DIR))

		OVERRIDE_TARGETS = 1

		# lib.mak defines $(OUTPUT), prepends $(OUTPUT)/ to $(TEST_GEN_PROGS), and most
		# importantly defines, i.e. overwrites, $(CC) (unless `make -e` or `make CC=`,
		# which causes the environment variable to override the makefile).
		@@ -199,7 +202,7 @@ else
		LINUX_TOOL_ARCH_INCLUDE = $(top_srcdir)/tools/arch/$(ARCH)/include
		endif
		CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \
		-Wno-gnu-variable-sized-type-not-at-end \
		-Wno-gnu-variable-sized-type-not-at-end -MD\
		-fno-builtin-memcmp -fno-builtin-memcpy -fno-builtin-memset \
		-fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) \
		-I$(LINUX_TOOL_ARCH_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude \
		@@ -226,7 +229,18 @@ LIBKVM_S_OBJ := $(patsubst %.S, $(OUTPUT)/%.o, $(LIBKVM_S))
		LIBKVM_STRING_OBJ := $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_STRING))
		LIBKVM_OBJS = $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(LIBKVM_STRING_OBJ)

		EXTRA_CLEAN += $(LIBKVM_OBJS) cscope.*
		TEST_GEN_OBJ = $(patsubst %, %.o, $(TEST_GEN_PROGS))
		TEST_GEN_OBJ += $(patsubst %, %.o, $(TEST_GEN_PROGS_EXTENDED))
		TEST_DEP_FILES = $(patsubst %.o, %.d, $(TEST_GEN_OBJ))
		TEST_DEP_FILES += $(patsubst %.o, %.d, $(LIBKVM_OBJS))
		-include $(TEST_DEP_FILES)

		$(TEST_GEN_PROGS) $(TEST_GEN_PROGS_EXTENDED): %: %.o
		$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH) $< $(LIBKVM_OBJS) $(LDLIBS) -o $@
		$(TEST_GEN_OBJ): $(OUTPUT)/%.o: %.c
		$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@

		EXTRA_CLEAN += $(LIBKVM_OBJS) $(TEST_DEP_FILES) $(TEST_GEN_OBJ) cscope.*

		x := $(shell mkdir -p $(sort $(dir $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ))))
		$(LIBKVM_C_OBJ): $(OUTPUT)/%.o: %.c

tools/testing/selftests/kvm/demand_paging_test.c

+22 −10

Original line number	Diff line number	Diff line
		@@ -128,6 +128,7 @@ static void prefault_mem(void *alias, uint64_t len)

		static void run_test(enum vm_guest_mode mode, void *arg)
		{
		struct memstress_vcpu_args *vcpu_args;
		struct test_params *p = arg;
		struct uffd_desc **uffd_descs = NULL;
		struct timespec start;
		@@ -145,24 +146,24 @@ static void run_test(enum vm_guest_mode mode, void *arg)
		"Failed to allocate buffer for guest data pattern");
		memset(guest_data_prototype, 0xAB, demand_paging_size);

		if (p->uffd_mode == UFFDIO_REGISTER_MODE_MINOR) {
		for (i = 0; i < nr_vcpus; i++) {
		vcpu_args = &memstress_args.vcpu_args[i];
		prefault_mem(addr_gpa2alias(vm, vcpu_args->gpa),
		vcpu_args->pages * memstress_args.guest_page_size);
		}
		}

		if (p->uffd_mode) {
		uffd_descs = malloc(nr_vcpus * sizeof(struct uffd_desc *));
		TEST_ASSERT(uffd_descs, "Memory allocation failed");

		for (i = 0; i < nr_vcpus; i++) {
		struct memstress_vcpu_args *vcpu_args;
		void *vcpu_hva;
		void *vcpu_alias;

		vcpu_args = &memstress_args.vcpu_args[i];

		/* Cache the host addresses of the region */
		vcpu_hva = addr_gpa2hva(vm, vcpu_args->gpa);
		vcpu_alias = addr_gpa2alias(vm, vcpu_args->gpa);

		prefault_mem(vcpu_alias,
		vcpu_args->pages * memstress_args.guest_page_size);

		/*
		* Set up user fault fd to handle demand paging
		* requests.
		@@ -207,10 +208,11 @@ static void help(char *name)
		{
		puts("");
		printf("usage: %s [-h] [-m vm_mode] [-u uffd_mode] [-d uffd_delay_usec]\n"
		" [-b memory] [-s type] [-v vcpus] [-o]\n", name);
		" [-b memory] [-s type] [-v vcpus] [-c cpu_list] [-o]\n", name);
		guest_modes_help();
		printf(" -u: use userfaultfd to handle vCPU page faults. Mode is a\n"
		" UFFD registration mode: 'MISSING' or 'MINOR'.\n");
		kvm_print_vcpu_pinning_help();
		printf(" -d: add a delay in usec to the User Fault\n"
		" FD handler to simulate demand paging\n"
		" overheads. Ignored without -u.\n");
		@@ -228,6 +230,7 @@ static void help(char *name)
		int main(int argc, char *argv[])
		{
		int max_vcpus = kvm_check_cap(KVM_CAP_MAX_VCPUS);
		const char *cpulist = NULL;
		struct test_params p = {
		.src_type = DEFAULT_VM_MEM_SRC,
		.partition_vcpu_memory_access = true,
		@@ -236,7 +239,7 @@ int main(int argc, char *argv[])

		guest_modes_append_default();

		while ((opt = getopt(argc, argv, "hm:u:d:b:s:v:o")) != -1) {
		while ((opt = getopt(argc, argv, "hm:u:d:b:s:v:c:o")) != -1) {
		switch (opt) {
		case 'm':
		guest_modes_cmdline(optarg);
		@@ -263,6 +266,9 @@ int main(int argc, char *argv[])
		TEST_ASSERT(nr_vcpus <= max_vcpus,
		"Invalid number of vcpus, must be between 1 and %d", max_vcpus);
		break;
		case 'c':
		cpulist = optarg;
		break;
		case 'o':
		p.partition_vcpu_memory_access = false;
		break;
		@@ -278,6 +284,12 @@ int main(int argc, char *argv[])
		TEST_FAIL("userfaultfd MINOR mode requires shared memory; pick a different -s");
		}

		if (cpulist) {
		kvm_parse_vcpu_pinning(cpulist, memstress_args.vcpu_to_pcpu,
		nr_vcpus);
		memstress_args.pin_vcpus = true;
		}

		for_each_guest_mode(run_test, &p);

		return 0;

tools/testing/selftests/kvm/dirty_log_perf_test.c

+8 −88

Original line number	Diff line number	Diff line
		@@ -136,77 +136,6 @@ struct test_params {
		bool random_access;
		};

		static void toggle_dirty_logging(struct kvm_vm *vm, int slots, bool enable)
		{
		int i;

		for (i = 0; i < slots; i++) {
		int slot = MEMSTRESS_MEM_SLOT_INDEX + i;
		int flags = enable ? KVM_MEM_LOG_DIRTY_PAGES : 0;

		vm_mem_region_set_flags(vm, slot, flags);
		}
		}

		static inline void enable_dirty_logging(struct kvm_vm *vm, int slots)
		{
		toggle_dirty_logging(vm, slots, true);
		}

		static inline void disable_dirty_logging(struct kvm_vm *vm, int slots)
		{
		toggle_dirty_logging(vm, slots, false);
		}

		static void get_dirty_log(struct kvm_vm vm, unsigned long bitmaps[], int slots)
		{
		int i;

		for (i = 0; i < slots; i++) {
		int slot = MEMSTRESS_MEM_SLOT_INDEX + i;

		kvm_vm_get_dirty_log(vm, slot, bitmaps[i]);
		}
		}

		static void clear_dirty_log(struct kvm_vm vm, unsigned long bitmaps[],
		int slots, uint64_t pages_per_slot)
		{
		int i;

		for (i = 0; i < slots; i++) {
		int slot = MEMSTRESS_MEM_SLOT_INDEX + i;

		kvm_vm_clear_dirty_log(vm, slot, bitmaps[i], 0, pages_per_slot);
		}
		}

		static unsigned long **alloc_bitmaps(int slots, uint64_t pages_per_slot)
		{
		unsigned long **bitmaps;
		int i;

		bitmaps = malloc(slots * sizeof(bitmaps[0]));
		TEST_ASSERT(bitmaps, "Failed to allocate bitmaps array.");

		for (i = 0; i < slots; i++) {
		bitmaps[i] = bitmap_zalloc(pages_per_slot);
		TEST_ASSERT(bitmaps[i], "Failed to allocate slot bitmap.");
		}

		return bitmaps;
		}

		static void free_bitmaps(unsigned long *bitmaps[], int slots)
		{
		int i;

		for (i = 0; i < slots; i++)
		free(bitmaps[i]);

		free(bitmaps);
		}

		static void run_test(enum vm_guest_mode mode, void *arg)
		{
		struct test_params *p = arg;
		@@ -236,7 +165,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)
		host_num_pages = vm_num_host_pages(mode, guest_num_pages);
		pages_per_slot = host_num_pages / p->slots;

		bitmaps = alloc_bitmaps(p->slots, pages_per_slot);
		bitmaps = memstress_alloc_bitmaps(p->slots, pages_per_slot);

		if (dirty_log_manual_caps)
		vm_enable_cap(vm, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2,
		@@ -277,7 +206,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)

		/* Enable dirty logging */
		clock_gettime(CLOCK_MONOTONIC, &start);
		enable_dirty_logging(vm, p->slots);
		memstress_enable_dirty_logging(vm, p->slots);
		ts_diff = timespec_elapsed(start);
		pr_info("Enabling dirty logging time: %ld.%.9lds\n\n",
		ts_diff.tv_sec, ts_diff.tv_nsec);
		@@ -306,7 +235,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)
		iteration, ts_diff.tv_sec, ts_diff.tv_nsec);

		clock_gettime(CLOCK_MONOTONIC, &start);
		get_dirty_log(vm, bitmaps, p->slots);
		memstress_get_dirty_log(vm, bitmaps, p->slots);
		ts_diff = timespec_elapsed(start);
		get_dirty_log_total = timespec_add(get_dirty_log_total,
		ts_diff);
		@@ -315,7 +244,8 @@ static void run_test(enum vm_guest_mode mode, void *arg)

		if (dirty_log_manual_caps) {
		clock_gettime(CLOCK_MONOTONIC, &start);
		clear_dirty_log(vm, bitmaps, p->slots, pages_per_slot);
		memstress_clear_dirty_log(vm, bitmaps, p->slots,
		pages_per_slot);
		ts_diff = timespec_elapsed(start);
		clear_dirty_log_total = timespec_add(clear_dirty_log_total,
		ts_diff);
		@@ -334,7 +264,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)

		/* Disable dirty logging */
		clock_gettime(CLOCK_MONOTONIC, &start);
		disable_dirty_logging(vm, p->slots);
		memstress_disable_dirty_logging(vm, p->slots);
		ts_diff = timespec_elapsed(start);
		pr_info("Disabling dirty logging time: %ld.%.9lds\n",
		ts_diff.tv_sec, ts_diff.tv_nsec);
		@@ -359,7 +289,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)
		clear_dirty_log_total.tv_nsec, avg.tv_sec, avg.tv_nsec);
		}

		free_bitmaps(bitmaps, p->slots);
		memstress_free_bitmaps(bitmaps, p->slots);
		arch_cleanup_vm(vm);
		memstress_destroy_vm(vm);
		}
		@@ -402,17 +332,7 @@ static void help(char *name)
		" so -w X means each page has an X%% chance of writing\n"
		" and a (100-X)%% chance of reading.\n"
		" (default: 100 i.e. all pages are written to.)\n");
		printf(" -c: Pin tasks to physical CPUs. Takes a list of comma separated\n"
		" values (target pCPU), one for each vCPU, plus an optional\n"
		" entry for the main application task (specified via entry\n"
		" <nr_vcpus + 1>). If used, entries must be provided for all\n"
		" vCPUs, i.e. pinning vCPUs is all or nothing.\n\n"
		" E.g. to create 3 vCPUs, pin vCPU0=>pCPU22, vCPU1=>pCPU23,\n"
		" vCPU2=>pCPU24, and pin the application task to pCPU50:\n\n"
		" ./dirty_log_perf_test -v 3 -c 22,23,24,50\n\n"
		" To leave the application task unpinned, drop the final entry:\n\n"
		" ./dirty_log_perf_test -v 3 -c 22,23,24\n\n"
		" (default: no pinning)\n");
		kvm_print_vcpu_pinning_help();
		puts("");
		exit(0);
		}

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

+1 −0

Original line number	Diff line number	Diff line
		@@ -733,6 +733,7 @@ static inline struct kvm_vm vm_create_with_one_vcpu(struct kvm_vcpu *vcpu,
		struct kvm_vcpu vm_recreate_with_one_vcpu(struct kvm_vm vm);

		void kvm_pin_this_task_to_pcpu(uint32_t pcpu);
		void kvm_print_vcpu_pinning_help(void);
		void kvm_parse_vcpu_pinning(const char *pcpus_string, uint32_t vcpu_to_pcpu[],
		int nr_vcpus);

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

+8 −0

Original line number	Diff line number	Diff line
		@@ -72,4 +72,12 @@ void memstress_guest_code(uint32_t vcpu_id);
		uint64_t memstress_nested_pages(int nr_vcpus);
		void memstress_setup_nested(struct kvm_vm vm, int nr_vcpus, struct kvm_vcpu vcpus[]);

		void memstress_enable_dirty_logging(struct kvm_vm *vm, int slots);
		void memstress_disable_dirty_logging(struct kvm_vm *vm, int slots);
		void memstress_get_dirty_log(struct kvm_vm vm, unsigned long bitmaps[], int slots);
		void memstress_clear_dirty_log(struct kvm_vm vm, unsigned long bitmaps[],
		int slots, uint64_t pages_per_slot);
		unsigned long **memstress_alloc_bitmaps(int slots, uint64_t pages_per_slot);
		void memstress_free_bitmaps(unsigned long *bitmaps[], int slots);

		#endif /* SELFTEST_KVM_MEMSTRESS_H */