Commit de527b1d authored by Jinrong Liang's avatar Jinrong Liang Committed by Sean Christopherson
Browse files

KVM: selftests: Introduce "struct __kvm_pmu_event_filter" to manipulate filter 



Add custom "__kvm_pmu_event_filter" structure to improve pmu event
filter settings. Simplifies event filter setup by organizing event
filter parameters in a cleaner, more organized way.

Alternatively, selftests could use a struct overlay ala vcpu_set_msr()
to avoid dynamically allocating the array:

        struct {
                struct kvm_msrs header;
                struct kvm_msr_entry entry;
        } buffer = {};

        memset(&buffer, 0, sizeof(buffer));
        buffer.header.nmsrs = 1;
        buffer.entry.index = msr_index;
        buffer.entry.data = msr_value;

but the extra layer added by the nested structs is counterproductive
to writing efficient, clean code.

Suggested-by: default avatarSean Christopherson <seanjc@google.com>
Signed-off-by: default avatarJinrong Liang <cloudliang@tencent.com>
Link: https://lore.kernel.org/r/20230810090945.16053-4-cloudliang@tencent.com


[sean: massage changelog to explain alternative]
Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
parent c853be22

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

+90 −92
Original line number Diff line number Diff line
@@ -28,6 +28,10 @@ 


#define NUM_BRANCHES 42



/* Matches KVM_PMU_EVENT_FILTER_MAX_EVENTS in pmu.c */

#define MAX_FILTER_EVENTS		300

#define MAX_TEST_EVENTS		10



/*

 * This is how the event selector and unit mask are stored in an AMD

 * core performance event-select register. Intel's format is similar,
@@ -69,12 +73,23 @@ 


#define INST_RETIRED EVENT(0xc0, 0)



struct __kvm_pmu_event_filter {

	__u32 action;

	__u32 nevents;

	__u32 fixed_counter_bitmap;

	__u32 flags;

	__u32 pad[4];

	__u64 events[MAX_FILTER_EVENTS];

};



/*

 * This event list comprises Intel's eight architectural events plus

 * AMD's "retired branch instructions" for Zen[123] (and possibly

 * other AMD CPUs).

 */

static const uint64_t event_list[] = {

static const struct __kvm_pmu_event_filter base_event_filter = {

	.nevents = ARRAY_SIZE(base_event_filter.events),

	.events = {

		EVENT(0x3c, 0),

		INST_RETIRED,

		EVENT(0x3c, 1),
@@ -84,6 +99,7 @@ static const uint64_t event_list[] = { 
		EVENT(0xc5, 0),

		EVENT(0xa4, 1),

		AMD_ZEN_BR_RETIRED,

	},

};



struct {
@@ -225,47 +241,11 @@ static bool sanity_check_pmu(struct kvm_vcpu *vcpu) 
	return !r;

}



static struct kvm_pmu_event_filter *alloc_pmu_event_filter(uint32_t nevents)

{

	struct kvm_pmu_event_filter *f;

	int size = sizeof(*f) + nevents * sizeof(f->events[0]);



	f = malloc(size);

	TEST_ASSERT(f, "Out of memory");

	memset(f, 0, size);

	f->nevents = nevents;

	return f;

}





static struct kvm_pmu_event_filter *

create_pmu_event_filter(const uint64_t event_list[], int nevents,

			uint32_t action, uint32_t flags)

{

	struct kvm_pmu_event_filter *f;

	int i;



	f = alloc_pmu_event_filter(nevents);

	f->action = action;

	f->flags = flags;

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

		f->events[i] = event_list[i];



	return f;

}



static struct kvm_pmu_event_filter *event_filter(uint32_t action)

{

	return create_pmu_event_filter(event_list,

				       ARRAY_SIZE(event_list),

				       action, 0);

}



/*

 * Remove the first occurrence of 'event' (if any) from the filter's

 * event list.

 */

static void remove_event(struct kvm_pmu_event_filter *f, uint64_t event)

static void remove_event(struct __kvm_pmu_event_filter *f, uint64_t event)

{

	bool found = false;

	int i;
@@ -313,66 +293,73 @@ static void test_without_filter(struct kvm_vcpu *vcpu) 
}



static void test_with_filter(struct kvm_vcpu *vcpu,

			     struct kvm_pmu_event_filter *f)

			     struct __kvm_pmu_event_filter *__f)

{

	struct kvm_pmu_event_filter *f = (void *)__f;



	vm_ioctl(vcpu->vm, KVM_SET_PMU_EVENT_FILTER, f);

	run_vcpu_and_sync_pmc_results(vcpu);

}



static void test_amd_deny_list(struct kvm_vcpu *vcpu)

{

	uint64_t event = EVENT(0x1C2, 0);

	struct kvm_pmu_event_filter *f;

	struct __kvm_pmu_event_filter f = {

		.action = KVM_PMU_EVENT_DENY,

		.nevents = 1,

		.events = {

			EVENT(0x1C2, 0),

		},

	};



	f = create_pmu_event_filter(&event, 1, KVM_PMU_EVENT_DENY, 0);

	test_with_filter(vcpu, f);

	free(f);

	test_with_filter(vcpu, &f);



	ASSERT_PMC_COUNTING_INSTRUCTIONS();

}



static void test_member_deny_list(struct kvm_vcpu *vcpu)

{

	struct kvm_pmu_event_filter *f = event_filter(KVM_PMU_EVENT_DENY);

	struct __kvm_pmu_event_filter f = base_event_filter;



	test_with_filter(vcpu, f);

	free(f);

	f.action = KVM_PMU_EVENT_DENY;

	test_with_filter(vcpu, &f);



	ASSERT_PMC_NOT_COUNTING_INSTRUCTIONS();

}



static void test_member_allow_list(struct kvm_vcpu *vcpu)

{

	struct kvm_pmu_event_filter *f = event_filter(KVM_PMU_EVENT_ALLOW);

	struct __kvm_pmu_event_filter f = base_event_filter;



	test_with_filter(vcpu, f);

	free(f);

	f.action = KVM_PMU_EVENT_ALLOW;

	test_with_filter(vcpu, &f);



	ASSERT_PMC_COUNTING_INSTRUCTIONS();

}



static void test_not_member_deny_list(struct kvm_vcpu *vcpu)

{

	struct kvm_pmu_event_filter *f = event_filter(KVM_PMU_EVENT_DENY);

	struct __kvm_pmu_event_filter f = base_event_filter;



	remove_event(f, INST_RETIRED);

	remove_event(f, INTEL_BR_RETIRED);

	remove_event(f, AMD_ZEN_BR_RETIRED);

	test_with_filter(vcpu, f);

	free(f);

	f.action = KVM_PMU_EVENT_DENY;



	remove_event(&f, INST_RETIRED);

	remove_event(&f, INTEL_BR_RETIRED);

	remove_event(&f, AMD_ZEN_BR_RETIRED);

	test_with_filter(vcpu, &f);



	ASSERT_PMC_COUNTING_INSTRUCTIONS();

}



static void test_not_member_allow_list(struct kvm_vcpu *vcpu)

{

	struct kvm_pmu_event_filter *f = event_filter(KVM_PMU_EVENT_ALLOW);

	struct __kvm_pmu_event_filter f = base_event_filter;



	f.action = KVM_PMU_EVENT_ALLOW;



	remove_event(f, INST_RETIRED);

	remove_event(f, INTEL_BR_RETIRED);

	remove_event(f, AMD_ZEN_BR_RETIRED);

	test_with_filter(vcpu, f);

	free(f);

	remove_event(&f, INST_RETIRED);

	remove_event(&f, INTEL_BR_RETIRED);

	remove_event(&f, AMD_ZEN_BR_RETIRED);

	test_with_filter(vcpu, &f);



	ASSERT_PMC_NOT_COUNTING_INSTRUCTIONS();

}
@@ -567,19 +554,16 @@ static void run_masked_events_test(struct kvm_vcpu *vcpu, 
				   const uint64_t masked_events[],

				   const int nmasked_events)

{

	struct kvm_pmu_event_filter *f;

	struct __kvm_pmu_event_filter f = {

		.nevents = nmasked_events,

		.action = KVM_PMU_EVENT_ALLOW,

		.flags = KVM_PMU_EVENT_FLAG_MASKED_EVENTS,

	};



	f = create_pmu_event_filter(masked_events, nmasked_events,

				    KVM_PMU_EVENT_ALLOW,

				    KVM_PMU_EVENT_FLAG_MASKED_EVENTS);

	test_with_filter(vcpu, f);

	free(f);

	memcpy(f.events, masked_events, sizeof(uint64_t) * nmasked_events);

	test_with_filter(vcpu, &f);

}



/* Matches KVM_PMU_EVENT_FILTER_MAX_EVENTS in pmu.c */

#define MAX_FILTER_EVENTS	300

#define MAX_TEST_EVENTS		10



#define ALLOW_LOADS		BIT(0)

#define ALLOW_STORES		BIT(1)

#define ALLOW_LOADS_STORES	BIT(2)
@@ -751,17 +735,27 @@ static void test_masked_events(struct kvm_vcpu *vcpu) 
	run_masked_events_tests(vcpu, events, nevents);

}



static int run_filter_test(struct kvm_vcpu *vcpu, const uint64_t *events,

			   int nevents, uint32_t flags)

static int set_pmu_event_filter(struct kvm_vcpu *vcpu,

				struct __kvm_pmu_event_filter *__f)

{

	struct kvm_pmu_event_filter *f;

	int r;

	struct kvm_pmu_event_filter *f = (void *)__f;



	f = create_pmu_event_filter(events, nevents, KVM_PMU_EVENT_ALLOW, flags);

	r = __vm_ioctl(vcpu->vm, KVM_SET_PMU_EVENT_FILTER, f);

	free(f);

	return __vm_ioctl(vcpu->vm, KVM_SET_PMU_EVENT_FILTER, f);

}



static int set_pmu_single_event_filter(struct kvm_vcpu *vcpu, uint64_t event,

				       uint32_t flags, uint32_t action)

{

	struct __kvm_pmu_event_filter f = {

		.nevents = 1,

		.flags = flags,

		.action = action,

		.events = {

			event,

		},

	};



	return r;

	return set_pmu_event_filter(vcpu, &f);

}



static void test_filter_ioctl(struct kvm_vcpu *vcpu)
@@ -773,14 +767,18 @@ static void test_filter_ioctl(struct kvm_vcpu *vcpu) 
	 * Unfortunately having invalid bits set in event data is expected to

	 * pass when flags == 0 (bits other than eventsel+umask).

	 */

	r = run_filter_test(vcpu, &e, 1, 0);

	r = set_pmu_single_event_filter(vcpu, e, 0, KVM_PMU_EVENT_ALLOW);

	TEST_ASSERT(r == 0, "Valid PMU Event Filter is failing");



	r = run_filter_test(vcpu, &e, 1, KVM_PMU_EVENT_FLAG_MASKED_EVENTS);

	r = set_pmu_single_event_filter(vcpu, e,

					KVM_PMU_EVENT_FLAG_MASKED_EVENTS,

					KVM_PMU_EVENT_ALLOW);

	TEST_ASSERT(r != 0, "Invalid PMU Event Filter is expected to fail");



	e = KVM_PMU_ENCODE_MASKED_ENTRY(0xff, 0xff, 0xff, 0xf);

	r = run_filter_test(vcpu, &e, 1, KVM_PMU_EVENT_FLAG_MASKED_EVENTS);

	r = set_pmu_single_event_filter(vcpu, e,

					KVM_PMU_EVENT_FLAG_MASKED_EVENTS,

					KVM_PMU_EVENT_ALLOW);

	TEST_ASSERT(r == 0, "Valid PMU Event Filter is failing");

}