Re: [PATCH v2 5/7] KVM: selftests: Check if pmu_event_filter meets expectations on fixed ctrs

Sean Christopherson
2023-05-25T18:11:35Z

On Thu, Apr 20, 2023, Jinrong Liang wrote:
> From: Jinrong Liang <cloudliang@tencent.com>
>
> From: Jinrong Liang <cloudliang@tencent.com>
>
> Add tests to cover that pmu_event_filter works as expected when
> it's applied to fixed performance counters, even if there is none
> fixed counter exists (e.g. Intel guest pmu version=1 or AMD guest).
>
> Signed-off-by: Jinrong Liang <cloudliang@tencent.com>
> ---
> .../kvm/x86_64/pmu_event_filter_test.c | 109 ++++++++++++++++++
> 1 file changed, 109 insertions(+)
>
> diff --git a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
> index a3d5c30ce914..0f54c53d7fff 100644
> --- a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
> +++ b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
> @@ -31,6 +31,7 @@
> #define PMU_EVENT_FILTER_INVALID_ACTION (KVM_PMU_EVENT_DENY + 1)
> #define PMU_EVENT_FILTER_INVALID_FLAGS (KVM_PMU_EVENT_FLAG_MASKED_EVENTS + 1)
> #define PMU_EVENT_FILTER_INVALID_NEVENTS (MAX_FILTER_EVENTS + 1)
> +#define INTEL_PMC_IDX_FIXED 32
>
> /*
> * This is how the event selector and unit mask are stored in an AMD
> @@ -817,6 +818,113 @@ static void test_filter_ioctl(struct kvm_vcpu *vcpu)
> }
> }
>
> +static void intel_guest_run_fixed_counters(uint8_t fixed_ctr_idx)
> +{
> + for (;;) {
> + wrmsr(MSR_CORE_PERF_GLOBAL_CTRL, 0);
> + wrmsr(MSR_CORE_PERF_FIXED_CTR0 + fixed_ctr_idx, 0);
> +
> + /* Only OS_EN bit is enabled for fixed counter[idx]. */
> + wrmsr(MSR_CORE_PERF_FIXED_CTR_CTRL, BIT_ULL(4 * fixed_ctr_idx));
> + wrmsr(MSR_CORE_PERF_GLOBAL_CTRL,
> + BIT_ULL(INTEL_PMC_IDX_FIXED + fixed_ctr_idx));
> + __asm__ __volatile__("loop ." : "+c"((int){NUM_BRANCHES}));
> + wrmsr(MSR_CORE_PERF_GLOBAL_CTRL, 0);
> +
> + GUEST_SYNC(rdmsr(MSR_CORE_PERF_FIXED_CTR0 + fixed_ctr_idx));
> + }
> +}
> +
> +static struct kvm_vcpu *new_vcpu(void *guest_code)
> +{
> + struct kvm_vm *vm;
> + struct kvm_vcpu *vcpu;
> +
> + vm = vm_create_with_one_vcpu(&vcpu, guest_code);
> + vm_init_descriptor_tables(vm);
> + vcpu_init_descriptor_tables(vcpu);

Unnecessary copy+paste, this test doesn't setup a #GP handler.

> +
> + return vcpu;
> +}
> +
> +static void free_vcpu(struct kvm_vcpu *vcpu)
> +{
> + kvm_vm_free(vcpu->vm);
> +}
> +
> +static uint64_t test_fixed_ctr_without_filter(struct kvm_vcpu *vcpu)
> +{
> + return run_vcpu_to_sync(vcpu);
> +}

Please don't add a wrappers that are single line passthroughs.

> +static const uint32_t actions[] = {
> + KVM_PMU_EVENT_ALLOW,
> + KVM_PMU_EVENT_DENY,
> +};

(a) don't define global variables with super common names (this test sets a bad
precedent). (b) this array is used in *one* function, i.e. it can be a local
variable. (c) using an array doesn't save you code and just obfuscates what's
happening.

> +static uint64_t test_fixed_ctr_with_filter(struct kvm_vcpu *vcpu,

Don't abbreviate "counter", there's really no need and "ctr" versus "ctrl" is
already confusing enough.

> + uint32_t action,
> + uint32_t bitmap)
> +{
> + struct kvm_pmu_event_filter *f;
> + uint64_t r;
> +
> + f = create_pmu_event_filter(0, 0, action, 0, bitmap);
> + r = test_with_filter(vcpu, f);
> + free(f);
> + return r;
> +}
> +
> +static bool fixed_ctr_is_allowed(uint8_t idx, uint32_t action, uint32_t bitmap)
> +{
> + return (action == KVM_PMU_EVENT_ALLOW && (bitmap & BIT_ULL(idx))) ||
> + (action == KVM_PMU_EVENT_DENY && !(bitmap & BIT_ULL(idx)));

This helper shouldn't exist. It's largely a symptom of using an array.
> +}
> +
> +static void test_fixed_ctr_action_and_bitmap(struct kvm_vcpu *vcpu,
> + uint8_t fixed_ctr_idx,
> + uint8_t max_fixed_num)
> +{
> + uint8_t i;
> + uint32_t bitmap;
> + uint64_t count;
> + bool expected;
> +
> + /*
> + * Check the fixed performance counter can count normally works when
> + * KVM userspace doesn't set any pmu filter.
> + */
> + TEST_ASSERT(max_fixed_num && test_fixed_ctr_without_filter(vcpu),
> + "Fixed counter does not exist or does not work as expected.");
> +
> + for (i = 0; i < ARRAY_SIZE(actions); i++) {
> + for (bitmap = 0; bitmap < BIT_ULL(max_fixed_num); bitmap++) {

You're comparing a 32-bit value against a 64-bit value.

> + expected = fixed_ctr_is_allowed(fixed_ctr_idx, actions[i], bitmap);
> + count = test_fixed_ctr_with_filter(vcpu, actions[i], bitmap);
> +
> + TEST_ASSERT(expected == !!count,
> + "Fixed event filter does not work as expected.");
> + }
> + }

static uint64_t test_with_fixed_counter_filter(struct kvm_vcpu *vcpu,
uint32_t action, uint32_t bitmap)
{
...

}

static void __test_fixed_counter_bitmap(...)
{
uint32_t bitmap;

TEST_ASSERT(nr_fixed_counters < sizeof(bitmap));

for (i = 0; i < BIT(nr_fixed_counters); i++) {
count = test_with_fixed_counter_filter(vcpu, KVM_PMU_EVENT_ALLOW,
bitmap);
TEST_ASSERT(!!count == !!(bitmap & BIT(idx)));

count = test_with_fixed_counter_filter(vcpu, KVM_PMU_EVENT_DENY,
bitmap);
TEST_ASSERT(!!count == !(bitmap & BIT(idx)));

}
}

> +}
> +
> +static void test_fixed_counter_bitmap(void)
> +{
> + struct kvm_vcpu *vcpu;
> + uint8_t idx, max_fixed_num = get_kvm_supported_fixed_num();
> +
> + /*
> + * Check that pmu_event_filter works as expected when it's applied to
> + * fixed performance counters.
> + */
> + for (idx = 0; idx < max_fixed_num; idx++) {
> + vcpu = new_vcpu(intel_guest_run_fixed_counters);
> + vcpu_args_set(vcpu, 1, idx);
> + test_fixed_ctr_action_and_bitmap(vcpu, idx, max_fixed_num);
> + free_vcpu(vcpu);
> + }
> +}
> +
> int main(int argc, char *argv[])
> {
> void (*guest_code)(void);
> @@ -860,6 +968,7 @@ int main(int argc, char *argv[])
> kvm_vm_free(vm);
>
> test_pmu_config_disable(guest_code);
> + test_fixed_counter_bitmap();
>
> return 0;
> }
> --
> 2.31.1
>