Commit de10b798 authored by Ben Gardon's avatar Ben Gardon Committed by Sean Christopherson
Browse files

KVM: selftests: Move dirty logging functions to memstress.(c|h) 



Move some helper functions from dirty_log_perf_test.c to the memstress
library so that they can be used in a future commit which tests page
splitting during dirty logging.

Reviewed-by: default avatarVipin Sharma <vipinsh@google.com>
Signed-off-by: default avatarBen Gardon <bgardon@google.com>
Link: https://lore.kernel.org/r/20230131181820.179033-2-bgardon@google.com


Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
parent 07b4b2f4

tools/testing/selftests/kvm/dirty_log_perf_test.c

+7 −77
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);

}

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 */

tools/testing/selftests/kvm/lib/memstress.c

+72 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#define _GNU_SOURCE



#include <inttypes.h>

#include <linux/bitmap.h>



#include "kvm_util.h"

#include "memstress.h"
@@ -323,3 +324,74 @@ void memstress_join_vcpu_threads(int nr_vcpus) 
	for (i = 0; i < nr_vcpus; i++)

		pthread_join(vcpu_threads[i].thread, NULL);

}



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

	}

}



void memstress_enable_dirty_logging(struct kvm_vm *vm, int slots)

{

	toggle_dirty_logging(vm, slots, true);

}



void memstress_disable_dirty_logging(struct kvm_vm *vm, int slots)

{

	toggle_dirty_logging(vm, slots, false);

}



void memstress_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]);

	}

}



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

	}

}



unsigned long **memstress_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;

}



void memstress_free_bitmaps(unsigned long *bitmaps[], int slots)

{

	int i;



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

		free(bitmaps[i]);



	free(bitmaps);

}