* [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters
@ 2019-02-18 13:47 Andrew Murray
2019-02-18 13:47 ` [PATCH v3 1/6] KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions Andrew Murray
` (5 more replies)
0 siblings, 6 replies; 9+ messages in thread
From: Andrew Murray @ 2019-02-18 13:47 UTC (permalink / raw)
To: Christoffer Dall, Marc Zyngier
Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry
ARMv8 provides support for chained PMU counters, where an event type
of 0x001E is set for odd-numbered counters, the event counter will
increment by one for each overflow of the preceding even-numbered
counter. Let's emulate this in KVM by creating a 64 bit perf counter
when a user chains two emulated counters together.
Testing has been performed by hard-coding hwc->sample_period in
__hw_perf_event_init (arm_pmu.c) to a small value, this results in
regular overflows (for non sampling events). The following command
was then used to measure chained and non-chained instruction cycles:
perf stat -e armv8_pmuv3/long=1,inst_retired/u \
-e armv8_pmuv3/long=0,inst_retired/u dd if=/dev/zero bs=1M \
count=10 | gzip > /dev/null
The reported values were identical (and for non-chained was in the
same ballpark when running on a kernel without this patchset). Debug
was added to verify that the guest received overflow interrupts for
the chain counter.
Changes since v2:
- Rebased onto v5.0-rc7
- Add check for cycle counter in correct patch
- Minor style, naming and comment changes
- Extract armv8pmu_evtype_is_chain from arch/arm64/kernel/perf_event.c
into a common header that KVM can use
Changes since v1:
- Rename kvm_pmu_{enable,disable}_counter to reflect that they can
operate on multiple counters at once and use these functions where
possible
- Fix bugs with overflow handing, kvm_pmu_get_counter_value did not
take into consideration the perf counter value overflowing the low
counter
- Ensure PMCCFILTR_EL0 is used when operating on the cycle counter
- Rename kvm_pmu_reenable_enabled_{pair, single} and similar
- Always create perf event disabled to simplify logic elsewhere
- Move PMCNTENSET_EL0 test to kvm_pmu_enable_counter_mask
Andrew Murray (6):
KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions
KVM: arm/arm64: extract duplicated code to own function
KVM: arm/arm64: re-create event when setting counter value
KVM: arm/arm64: lazily create perf events on enable
arm64: perf: extract chain helper into header
KVM: arm/arm64: support chained PMU counters
arch/arm64/include/asm/perf_event.h | 5 +
arch/arm64/kernel/perf_event.c | 2 +-
arch/arm64/kvm/sys_regs.c | 4 +-
include/kvm/arm_pmu.h | 9 +-
virt/kvm/arm/pmu.c | 410 ++++++++++++++++++++++++++++++------
5 files changed, 360 insertions(+), 70 deletions(-)
--
2.7.4
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH v3 1/6] KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray @ 2019-02-18 13:47 ` Andrew Murray 2019-02-18 13:48 ` [PATCH v3 2/6] KVM: arm/arm64: extract duplicated code to own function Andrew Murray ` (4 subsequent siblings) 5 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:47 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry The kvm_pmu_{enable/disable}_counter functions can enabled/disable multiple counters at once as they operate on a bitmask. Let's make this clearer by renaming the function. Suggested-by: Suzuki K Poulose <suzuki.poulose@arm.com> Signed-off-by: Andrew Murray <andrew.murray@arm.com> Reviewed-by: Julien Thierry <julien.thierry@arm.com> Reviewed-by: Suzuki K Poulose <suzuki.poulose@arm.com> --- arch/arm64/kvm/sys_regs.c | 4 ++-- include/kvm/arm_pmu.h | 8 ++++---- virt/kvm/arm/pmu.c | 12 ++++++------ 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c index c936aa4..8891020 100644 --- a/arch/arm64/kvm/sys_regs.c +++ b/arch/arm64/kvm/sys_regs.c @@ -874,11 +874,11 @@ static bool access_pmcnten(struct kvm_vcpu *vcpu, struct sys_reg_params *p, if (r->Op2 & 0x1) { /* accessing PMCNTENSET_EL0 */ __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) |= val; - kvm_pmu_enable_counter(vcpu, val); + kvm_pmu_enable_counter_mask(vcpu, val); } else { /* accessing PMCNTENCLR_EL0 */ __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) &= ~val; - kvm_pmu_disable_counter(vcpu, val); + kvm_pmu_disable_counter_mask(vcpu, val); } } else { p->regval = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask; diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h index f87fe20..b73f31b 100644 --- a/include/kvm/arm_pmu.h +++ b/include/kvm/arm_pmu.h @@ -46,8 +46,8 @@ void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val); u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu); void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu); void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu); -void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 val); -void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 val); +void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val); +void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val); void kvm_pmu_flush_hwstate(struct kvm_vcpu *vcpu); void kvm_pmu_sync_hwstate(struct kvm_vcpu *vcpu); bool kvm_pmu_should_notify_user(struct kvm_vcpu *vcpu); @@ -83,8 +83,8 @@ static inline u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) } static inline void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu) {} static inline void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) {} -static inline void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 val) {} -static inline void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 val) {} +static inline void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) {} +static inline void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) {} static inline void kvm_pmu_flush_hwstate(struct kvm_vcpu *vcpu) {} static inline void kvm_pmu_sync_hwstate(struct kvm_vcpu *vcpu) {} static inline bool kvm_pmu_should_notify_user(struct kvm_vcpu *vcpu) diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c index 1c5b76c..c5a722a 100644 --- a/virt/kvm/arm/pmu.c +++ b/virt/kvm/arm/pmu.c @@ -135,13 +135,13 @@ u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) } /** - * kvm_pmu_enable_counter - enable selected PMU counter + * kvm_pmu_enable_counter_mask - enable selected PMU counters * @vcpu: The vcpu pointer * @val: the value guest writes to PMCNTENSET register * * Call perf_event_enable to start counting the perf event */ -void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 val) +void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) { int i; struct kvm_pmu *pmu = &vcpu->arch.pmu; @@ -164,13 +164,13 @@ void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 val) } /** - * kvm_pmu_disable_counter - disable selected PMU counter + * kvm_pmu_disable_counter_mask - disable selected PMU counters * @vcpu: The vcpu pointer * @val: the value guest writes to PMCNTENCLR register * * Call perf_event_disable to stop counting the perf event */ -void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 val) +void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) { int i; struct kvm_pmu *pmu = &vcpu->arch.pmu; @@ -347,10 +347,10 @@ void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val) mask = kvm_pmu_valid_counter_mask(vcpu); if (val & ARMV8_PMU_PMCR_E) { - kvm_pmu_enable_counter(vcpu, + kvm_pmu_enable_counter_mask(vcpu, __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask); } else { - kvm_pmu_disable_counter(vcpu, mask); + kvm_pmu_disable_counter_mask(vcpu, mask); } if (val & ARMV8_PMU_PMCR_C) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v3 2/6] KVM: arm/arm64: extract duplicated code to own function 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray 2019-02-18 13:47 ` [PATCH v3 1/6] KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions Andrew Murray @ 2019-02-18 13:48 ` Andrew Murray 2019-02-18 13:48 ` [PATCH v3 3/6] KVM: arm/arm64: re-create event when setting counter value Andrew Murray ` (3 subsequent siblings) 5 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:48 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry Let's reduce code duplication by extracting common code to its own function. Signed-off-by: Andrew Murray <andrew.murray@arm.com> Reviewed-by: Suzuki K Poulose <suzuki.poulose@arm.com> --- virt/kvm/arm/pmu.c | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c index c5a722a..6e7c179 100644 --- a/virt/kvm/arm/pmu.c +++ b/virt/kvm/arm/pmu.c @@ -65,6 +65,19 @@ void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) } /** + * kvm_pmu_release_perf_event - remove the perf event + * @pmc: The PMU counter pointer + */ +static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) +{ + if (pmc->perf_event) { + perf_event_disable(pmc->perf_event); + perf_event_release_kernel(pmc->perf_event); + pmc->perf_event = NULL; + } +} + +/** * kvm_pmu_stop_counter - stop PMU counter * @pmc: The PMU counter pointer * @@ -79,9 +92,7 @@ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc) reg = (pmc->idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + pmc->idx; __vcpu_sys_reg(vcpu, reg) = counter; - perf_event_disable(pmc->perf_event); - perf_event_release_kernel(pmc->perf_event); - pmc->perf_event = NULL; + kvm_pmu_release_perf_event(pmc); } } @@ -112,15 +123,8 @@ void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) int i; struct kvm_pmu *pmu = &vcpu->arch.pmu; - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { - struct kvm_pmc *pmc = &pmu->pmc[i]; - - if (pmc->perf_event) { - perf_event_disable(pmc->perf_event); - perf_event_release_kernel(pmc->perf_event); - pmc->perf_event = NULL; - } - } + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) + kvm_pmu_release_perf_event(&pmu->pmc[i]); } u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v3 3/6] KVM: arm/arm64: re-create event when setting counter value 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray 2019-02-18 13:47 ` [PATCH v3 1/6] KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions Andrew Murray 2019-02-18 13:48 ` [PATCH v3 2/6] KVM: arm/arm64: extract duplicated code to own function Andrew Murray @ 2019-02-18 13:48 ` Andrew Murray 2019-02-18 13:48 ` [PATCH v3 4/6] KVM: arm/arm64: lazily create perf events on enable Andrew Murray ` (2 subsequent siblings) 5 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:48 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry The perf event sample_period is currently set based upon the current counter value, when PMXEVTYPER is written to and the perf event is created. However the user may choose to write the type before the counter value in which case sample_period will be set incorrectly. Let's instead decouple event creation from PMXEVTYPER and (re)create the event in either suitation. Signed-off-by: Andrew Murray <andrew.murray@arm.com> Reviewed-by: Julien Thierry <julien.thierry@arm.com> Reviewed-by: Suzuki K Poulose <suzuki.poulse@arm.com> --- virt/kvm/arm/pmu.c | 42 +++++++++++++++++++++++++++++++++--------- 1 file changed, 33 insertions(+), 9 deletions(-) diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c index 6e7c179..ae1e886 100644 --- a/virt/kvm/arm/pmu.c +++ b/virt/kvm/arm/pmu.c @@ -24,6 +24,7 @@ #include <kvm/arm_pmu.h> #include <kvm/arm_vgic.h> +static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx); /** * kvm_pmu_get_counter_value - get PMU counter value * @vcpu: The vcpu pointer @@ -62,6 +63,9 @@ void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; __vcpu_sys_reg(vcpu, reg) += (s64)val - kvm_pmu_get_counter_value(vcpu, select_idx); + + /* Recreate the perf event to reflect the updated sample_period */ + kvm_pmu_create_perf_event(vcpu, select_idx); } /** @@ -378,23 +382,21 @@ static bool kvm_pmu_counter_is_enabled(struct kvm_vcpu *vcpu, u64 select_idx) } /** - * kvm_pmu_set_counter_event_type - set selected counter to monitor some event + * kvm_pmu_create_perf_event - create a perf event for a counter * @vcpu: The vcpu pointer - * @data: The data guest writes to PMXEVTYPER_EL0 * @select_idx: The number of selected counter - * - * When OS accesses PMXEVTYPER_EL0, that means it wants to set a PMC to count an - * event with given hardware event number. Here we call perf_event API to - * emulate this action and create a kernel perf event for it. */ -void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, - u64 select_idx) +static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) { struct kvm_pmu *pmu = &vcpu->arch.pmu; struct kvm_pmc *pmc = &pmu->pmc[select_idx]; struct perf_event *event; struct perf_event_attr attr; - u64 eventsel, counter; + u64 eventsel, counter, reg, data; + + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) + ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; + data = __vcpu_sys_reg(vcpu, reg); kvm_pmu_stop_counter(vcpu, pmc); eventsel = data & ARMV8_PMU_EVTYPE_EVENT; @@ -431,6 +433,28 @@ void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, pmc->perf_event = event; } +/** + * kvm_pmu_set_counter_event_type - set selected counter to monitor some event + * @vcpu: The vcpu pointer + * @data: The data guest writes to PMXEVTYPER_EL0 + * @select_idx: The number of selected counter + * + * When OS accesses PMXEVTYPER_EL0, that means it wants to set a PMC to count an + * event with given hardware event number. Here we call perf_event API to + * emulate this action and create a kernel perf event for it. + */ +void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, + u64 select_idx) +{ + u64 reg, event_type = data & ARMV8_PMU_EVTYPE_MASK; + + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) + ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; + + __vcpu_sys_reg(vcpu, reg) = event_type; + kvm_pmu_create_perf_event(vcpu, select_idx); +} + bool kvm_arm_support_pmu_v3(void) { /* -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v3 4/6] KVM: arm/arm64: lazily create perf events on enable 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray ` (2 preceding siblings ...) 2019-02-18 13:48 ` [PATCH v3 3/6] KVM: arm/arm64: re-create event when setting counter value Andrew Murray @ 2019-02-18 13:48 ` Andrew Murray 2019-02-18 13:48 ` [PATCH v3 5/6] arm64: perf: extract chain helper into header Andrew Murray 2019-02-18 13:48 ` [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters Andrew Murray 5 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:48 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry To prevent re-creating perf events everytime the counter registers are changed, let's instead lazily create the event when the event is first enabled and destroy it when it changes. Signed-off-by: Andrew Murray <andrew.murray@arm.com> --- virt/kvm/arm/pmu.c | 90 +++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 65 insertions(+), 25 deletions(-) diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c index ae1e886..524b27f 100644 --- a/virt/kvm/arm/pmu.c +++ b/virt/kvm/arm/pmu.c @@ -24,7 +24,10 @@ #include <kvm/arm_pmu.h> #include <kvm/arm_vgic.h> +static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, u64 select_idx); static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx); +static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); + /** * kvm_pmu_get_counter_value - get PMU counter value * @vcpu: The vcpu pointer @@ -59,13 +62,15 @@ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) { u64 reg; + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; __vcpu_sys_reg(vcpu, reg) += (s64)val - kvm_pmu_get_counter_value(vcpu, select_idx); - /* Recreate the perf event to reflect the updated sample_period */ - kvm_pmu_create_perf_event(vcpu, select_idx); + kvm_pmu_stop_counter(vcpu, pmc); + kvm_pmu_sync_counter_enable(vcpu, select_idx); } /** @@ -83,6 +88,7 @@ static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) /** * kvm_pmu_stop_counter - stop PMU counter + * @vcpu: The vcpu pointer * @pmc: The PMU counter pointer * * If this counter has been configured to monitor some event, release it here. @@ -143,6 +149,24 @@ u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) } /** + * kvm_pmu_enable_counter - create/enable a counter + * @vcpu: The vcpu pointer + * @select_idx: The counter index + */ +static void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 select_idx) +{ + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; + + if (!pmc->perf_event) + kvm_pmu_create_perf_event(vcpu, select_idx); + + perf_event_enable(pmc->perf_event); + if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE) + kvm_debug("failed to enable perf event\n"); +} + +/** * kvm_pmu_enable_counter_mask - enable selected PMU counters * @vcpu: The vcpu pointer * @val: the value guest writes to PMCNTENSET register @@ -152,8 +176,6 @@ u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) { int i; - struct kvm_pmu *pmu = &vcpu->arch.pmu; - struct kvm_pmc *pmc; if (!(__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) || !val) return; @@ -162,16 +184,39 @@ void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) if (!(val & BIT(i))) continue; - pmc = &pmu->pmc[i]; - if (pmc->perf_event) { - perf_event_enable(pmc->perf_event); - if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE) - kvm_debug("fail to enable perf event\n"); - } + kvm_pmu_enable_counter(vcpu, i); } } /** + * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled + * @vcpu: The vcpu pointer + * @select_idx: The counter index + */ +static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, + u64 select_idx) +{ + u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0); + + if (set & BIT(select_idx)) + kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); +} + +/** + * kvm_pmu_disable_counter - disable selected PMU counter + * @vcpu: The vcpu pointer + * @pmc: The counter to disable + */ +static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) +{ + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; + + if (pmc->perf_event) + perf_event_disable(pmc->perf_event); +} + +/** * kvm_pmu_disable_counter_mask - disable selected PMU counters * @vcpu: The vcpu pointer * @val: the value guest writes to PMCNTENCLR register @@ -181,8 +226,6 @@ void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) { int i; - struct kvm_pmu *pmu = &vcpu->arch.pmu; - struct kvm_pmc *pmc; if (!val) return; @@ -191,9 +234,7 @@ void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) if (!(val & BIT(i))) continue; - pmc = &pmu->pmc[i]; - if (pmc->perf_event) - perf_event_disable(pmc->perf_event); + kvm_pmu_disable_counter(vcpu, i); } } @@ -375,16 +416,12 @@ void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val) } } -static bool kvm_pmu_counter_is_enabled(struct kvm_vcpu *vcpu, u64 select_idx) -{ - return (__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) && - (__vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & BIT(select_idx)); -} - /** - * kvm_pmu_create_perf_event - create a perf event for a counter + * kvm_pmu_counter_create_perf_event - create a perf event for a counter * @vcpu: The vcpu pointer * @select_idx: The number of selected counter + * + * Events are always created disabled and they are only enabled lazily. */ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) { @@ -398,7 +435,6 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; data = __vcpu_sys_reg(vcpu, reg); - kvm_pmu_stop_counter(vcpu, pmc); eventsel = data & ARMV8_PMU_EVTYPE_EVENT; /* Software increment event does't need to be backed by a perf event */ @@ -410,7 +446,7 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) attr.type = PERF_TYPE_RAW; attr.size = sizeof(attr); attr.pinned = 1; - attr.disabled = !kvm_pmu_counter_is_enabled(vcpu, select_idx); + attr.disabled = 1; attr.exclude_user = data & ARMV8_PMU_EXCLUDE_EL0 ? 1 : 0; attr.exclude_kernel = data & ARMV8_PMU_EXCLUDE_EL1 ? 1 : 0; attr.exclude_hv = 1; /* Don't count EL2 events */ @@ -446,13 +482,17 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, u64 select_idx) { + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; u64 reg, event_type = data & ARMV8_PMU_EVTYPE_MASK; + kvm_pmu_stop_counter(vcpu, pmc); + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; __vcpu_sys_reg(vcpu, reg) = event_type; - kvm_pmu_create_perf_event(vcpu, select_idx); + kvm_pmu_sync_counter_enable(vcpu, select_idx); } bool kvm_arm_support_pmu_v3(void) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v3 5/6] arm64: perf: extract chain helper into header 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray ` (3 preceding siblings ...) 2019-02-18 13:48 ` [PATCH v3 4/6] KVM: arm/arm64: lazily create perf events on enable Andrew Murray @ 2019-02-18 13:48 ` Andrew Murray 2019-02-18 13:48 ` [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters Andrew Murray 5 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:48 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry The ARMv8 Performance Monitors Extension includes an architectural event type named CHAIN which allows for chaining counters together. Let's extract the test for this event into a header file such that other users, such as KVM (for PMU emulation) can make use of. Signed-off-by: Andrew Murray <andrew.murray@arm.com> --- arch/arm64/include/asm/perf_event.h | 5 +++++ arch/arm64/kernel/perf_event.c | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/arch/arm64/include/asm/perf_event.h b/arch/arm64/include/asm/perf_event.h index c593761..cd13f3f 100644 --- a/arch/arm64/include/asm/perf_event.h +++ b/arch/arm64/include/asm/perf_event.h @@ -219,6 +219,11 @@ #define ARMV8_PMU_USERENR_CR (1 << 2) /* Cycle counter can be read at EL0 */ #define ARMV8_PMU_USERENR_ER (1 << 3) /* Event counter can be read at EL0 */ +static inline bool armv8pmu_evtype_is_chain(u64 evtype) +{ + return (evtype == ARMV8_PMUV3_PERFCTR_CHAIN); +} + #ifdef CONFIG_PERF_EVENTS struct pt_regs; extern unsigned long perf_instruction_pointer(struct pt_regs *regs); diff --git a/arch/arm64/kernel/perf_event.c b/arch/arm64/kernel/perf_event.c index 1620a37..4cd1f7a 100644 --- a/arch/arm64/kernel/perf_event.c +++ b/arch/arm64/kernel/perf_event.c @@ -850,7 +850,7 @@ static int armv8pmu_set_event_filter(struct hw_perf_event *event, static int armv8pmu_filter_match(struct perf_event *event) { unsigned long evtype = event->hw.config_base & ARMV8_PMU_EVTYPE_EVENT; - return evtype != ARMV8_PMUV3_PERFCTR_CHAIN; + return !armv8pmu_evtype_is_chain(evtype); } static void armv8pmu_reset(void *info) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters 2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray ` (4 preceding siblings ...) 2019-02-18 13:48 ` [PATCH v3 5/6] arm64: perf: extract chain helper into header Andrew Murray @ 2019-02-18 13:48 ` Andrew Murray 2019-02-20 13:36 ` Marc Zyngier 5 siblings, 1 reply; 9+ messages in thread From: Andrew Murray @ 2019-02-18 13:48 UTC (permalink / raw) To: Christoffer Dall, Marc Zyngier Cc: Suzuki K Poulose, kvmarm, linux-arm-kernel, Julien Thierry Emulate chained PMU counters by creating a single 64 bit event counter for a pair of chained KVM counters. Signed-off-by: Andrew Murray <andrew.murray@arm.com> --- include/kvm/arm_pmu.h | 1 + virt/kvm/arm/pmu.c | 322 +++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 270 insertions(+), 53 deletions(-) diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h index b73f31b..8e691ee 100644 --- a/include/kvm/arm_pmu.h +++ b/include/kvm/arm_pmu.h @@ -29,6 +29,7 @@ struct kvm_pmc { u8 idx; /* index into the pmu->pmc array */ struct perf_event *perf_event; u64 bitmask; + u64 overflow_count; }; struct kvm_pmu { diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c index 524b27f..2852dc4 100644 --- a/virt/kvm/arm/pmu.c +++ b/virt/kvm/arm/pmu.c @@ -24,9 +24,26 @@ #include <kvm/arm_pmu.h> #include <kvm/arm_vgic.h> +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, + u64 pair_low); +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, + u64 select_idx); +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low); static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, u64 select_idx); static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx); -static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); + +#define PERF_ATTR_CFG1_KVM_PMU_CHAINED 0x1 + +/** + * kvm_pmu_counter_is_high_word - is select_idx high counter of 64bit event + * @pmc: The PMU counter pointer + * @select_idx: The counter index + */ +static inline bool kvm_pmu_counter_is_high_word(struct kvm_pmc *pmc) +{ + return ((pmc->perf_event->attr.config1 & PERF_ATTR_CFG1_KVM_PMU_CHAINED) + && (pmc->idx % 2)); +} /** * kvm_pmu_get_counter_value - get PMU counter value @@ -35,22 +52,70 @@ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); */ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) { - u64 counter, reg, enabled, running; + u64 counter_idx, reg, enabled, running, incr; struct kvm_pmu *pmu = &vcpu->arch.pmu; struct kvm_pmc *pmc = &pmu->pmc[select_idx]; reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; - counter = __vcpu_sys_reg(vcpu, reg); + counter_idx = __vcpu_sys_reg(vcpu, reg); /* The real counter value is equal to the value of counter register plus * the value perf event counts. */ - if (pmc->perf_event) - counter += perf_event_read_value(pmc->perf_event, &enabled, + if (pmc->perf_event) { + incr = perf_event_read_value(pmc->perf_event, &enabled, &running); - return counter & pmc->bitmask; + if (kvm_pmu_counter_is_high_word(pmc)) { + u64 counter_low, counter; + + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) + ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx - 1; + counter_low = __vcpu_sys_reg(vcpu, reg); + counter = lower_32_bits(counter_low) | (counter_idx << 32); + counter_idx = upper_32_bits(counter + incr); + } else { + counter_idx += incr; + } + } + + return counter_idx & pmc->bitmask; +} + +/** + * kvm_pmu_counter_is_enabled - is a counter active + * @vcpu: The vcpu pointer + * @select_idx: The counter index + */ +static bool kvm_pmu_counter_is_enabled(struct kvm_vcpu *vcpu, u64 select_idx) +{ + u64 mask = kvm_pmu_valid_counter_mask(vcpu); + + return (__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) && + (__vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask & BIT(select_idx)); +} + +/** + * kvnm_pmu_event_is_chained - is a pair of counters chained and enabled + * @vcpu: The vcpu pointer + * @select_idx: The low counter index + */ +static bool kvm_pmu_event_is_chained(struct kvm_vcpu *vcpu, u64 pair_low) +{ + u64 eventsel, reg; + + reg = (pair_low + 1 == ARMV8_PMU_CYCLE_IDX) + ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + pair_low + 1; + eventsel = __vcpu_sys_reg(vcpu, reg) & ARMV8_PMU_EVTYPE_EVENT; + if (!armv8pmu_evtype_is_chain(eventsel)) + return false; + + if (kvm_pmu_counter_is_enabled(vcpu, pair_low) != + kvm_pmu_counter_is_enabled(vcpu, pair_low + 1)) + return false; + + return true; } /** @@ -61,29 +126,45 @@ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) */ void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) { - u64 reg; - struct kvm_pmu *pmu = &vcpu->arch.pmu; - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; + u64 reg, pair_low; reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; __vcpu_sys_reg(vcpu, reg) += (s64)val - kvm_pmu_get_counter_value(vcpu, select_idx); - kvm_pmu_stop_counter(vcpu, pmc); - kvm_pmu_sync_counter_enable(vcpu, select_idx); + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; + + /* Recreate the perf event to reflect the updated sample_period */ + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); + } else { + kvm_pmu_stop_release_perf_event(vcpu, select_idx); + kvm_pmu_sync_counter_enable(vcpu, select_idx); + } } /** * kvm_pmu_release_perf_event - remove the perf event * @pmc: The PMU counter pointer */ -static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) +static void kvm_pmu_release_perf_event(struct kvm_vcpu *vcpu, + struct kvm_pmc *pmc) { - if (pmc->perf_event) { - perf_event_disable(pmc->perf_event); + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc_alt; + u64 pair_alt; + + pair_alt = (pmc->idx % 2) ? pmc->idx - 1 : pmc->idx + 1; + pmc_alt = &pmu->pmc[pair_alt]; + + if (pmc->perf_event) perf_event_release_kernel(pmc->perf_event); - pmc->perf_event = NULL; - } + + if (pmc->perf_event == pmc_alt->perf_event) + pmc_alt->perf_event = NULL; + + pmc->perf_event = NULL; } /** @@ -91,22 +172,65 @@ static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) * @vcpu: The vcpu pointer * @pmc: The PMU counter pointer * - * If this counter has been configured to monitor some event, release it here. + * If this counter has been configured to monitor some event, stop it here. */ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc) { u64 counter, reg; if (pmc->perf_event) { + perf_event_disable(pmc->perf_event); counter = kvm_pmu_get_counter_value(vcpu, pmc->idx); reg = (pmc->idx == ARMV8_PMU_CYCLE_IDX) ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + pmc->idx; __vcpu_sys_reg(vcpu, reg) = counter; - kvm_pmu_release_perf_event(pmc); } } /** + * kvm_pmu_stop_release_perf_event_pair - stop and release a pair of counters + * @vcpu: The vcpu pointer + * @pmc_low: The PMU counter pointer for lower word + * @pmc_high: The PMU counter pointer for higher word + * + * As chained counters share the underlying perf event, we stop them + * both first before discarding the underlying perf event + */ +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, + u64 idx_low) +{ + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc_low = &pmu->pmc[idx_low]; + struct kvm_pmc *pmc_high = &pmu->pmc[idx_low + 1]; + + /* Stopping a counter involves adding the perf event value to the + * vcpu sys register value prior to releasing the perf event. As + * kvm_pmu_get_counter_value may depend on the low counter value we + * must always stop the high counter first + */ + kvm_pmu_stop_counter(vcpu, pmc_high); + kvm_pmu_stop_counter(vcpu, pmc_low); + + kvm_pmu_release_perf_event(vcpu, pmc_high); + kvm_pmu_release_perf_event(vcpu, pmc_low); +} + +/** + * kvm_pmu_stop_release_perf_event - stop and release a counter + * @vcpu: The vcpu pointer + * @select_idx: The counter index + */ +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, + u64 select_idx) +{ + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; + + kvm_pmu_stop_counter(vcpu, pmc); + kvm_pmu_release_perf_event(vcpu, pmc); +} + +/** * kvm_pmu_vcpu_reset - reset pmu state for cpu * @vcpu: The vcpu pointer * @@ -117,7 +241,7 @@ void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu) struct kvm_pmu *pmu = &vcpu->arch.pmu; for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { - kvm_pmu_stop_counter(vcpu, &pmu->pmc[i]); + kvm_pmu_stop_release_perf_event(vcpu, i); pmu->pmc[i].idx = i; pmu->pmc[i].bitmask = 0xffffffffUL; } @@ -134,7 +258,7 @@ void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) struct kvm_pmu *pmu = &vcpu->arch.pmu; for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) - kvm_pmu_release_perf_event(&pmu->pmc[i]); + kvm_pmu_release_perf_event(vcpu, &pmu->pmc[i]); } u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) @@ -167,53 +291,115 @@ static void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 select_idx) } /** + * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled + * @vcpu: The vcpu pointer + * @select_idx: The counter index + */ +static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, + u64 select_idx) +{ + kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); +} + +/** + * kvm_pmu_sync_counter_enable_pair - reenable a pair if they should be enabled + * @vcpu: The vcpu pointer + * @pair_low: The low counter index + */ +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low) +{ + kvm_pmu_enable_counter_mask(vcpu, BIT(pair_low) | BIT(pair_low + 1)); +} + +/** + * kvm_pmu_enable_counter_pair - enable counters pair at a time + * @vcpu: The vcpu pointer + * @val: counters to enable + * @pair_low: The low counter index + */ +static void kvm_pmu_enable_counter_pair(struct kvm_vcpu *vcpu, u64 val, + u64 pair_low) +{ + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; + + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { + if (pmc_low->perf_event != pmc_high->perf_event) + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); + } + + if (val & BIT(pair_low)) + kvm_pmu_enable_counter(vcpu, pair_low); + + if (val & BIT(pair_low + 1)) + kvm_pmu_enable_counter(vcpu, pair_low + 1); +} + +/** * kvm_pmu_enable_counter_mask - enable selected PMU counters * @vcpu: The vcpu pointer - * @val: the value guest writes to PMCNTENSET register + * @val: the value guest writes to PMCNTENSET register or a subset * * Call perf_event_enable to start counting the perf event */ void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) { int i; + u64 mask = kvm_pmu_valid_counter_mask(vcpu); + u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask; if (!(__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) || !val) return; - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { - if (!(val & BIT(i))) - continue; - - kvm_pmu_enable_counter(vcpu, i); - } + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) + kvm_pmu_enable_counter_pair(vcpu, val & set, i); } /** - * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled + * kvm_pmu_disable_counter - disable selected PMU counter * @vcpu: The vcpu pointer * @select_idx: The counter index */ -static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, - u64 select_idx) +static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) { - u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0); + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; - if (set & BIT(select_idx)) - kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); + if (pmc->perf_event) { + perf_event_disable(pmc->perf_event); + if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE) + kvm_debug("fail to enable perf event\n"); + } } /** - * kvm_pmu_disable_counter - disable selected PMU counter - * @vcpu: The vcpu pointer - * @pmc: The counter to disable + * kvm_pmu_disable_counter_pair - disable counters pair at a time + * @val: counters to disable + * @pair_low: The low counter index */ -static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) +static void kvm_pmu_disable_counter_pair(struct kvm_vcpu *vcpu, u64 val, + u64 pair_low) { struct kvm_pmu *pmu = &vcpu->arch.pmu; - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; + + if (!kvm_pmu_event_is_chained(vcpu, pair_low)) { + if (pmc_low->perf_event == pmc_high->perf_event) { + if (pmc_low->perf_event) { + kvm_pmu_stop_release_perf_event_pair(vcpu, + pair_low); + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); + } + } + } - if (pmc->perf_event) - perf_event_disable(pmc->perf_event); + if (val & BIT(pair_low)) + kvm_pmu_disable_counter(vcpu, pair_low); + + if (val & BIT(pair_low + 1)) + kvm_pmu_disable_counter(vcpu, pair_low + 1); } /** @@ -230,12 +416,8 @@ void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) if (!val) return; - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { - if (!(val & BIT(i))) - continue; - - kvm_pmu_disable_counter(vcpu, i); - } + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) + kvm_pmu_disable_counter_pair(vcpu, val, i); } static u64 kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) @@ -346,6 +528,17 @@ static void kvm_pmu_perf_overflow(struct perf_event *perf_event, __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx); + if (kvm_pmu_event_is_chained(vcpu, idx)) { + struct kvm_pmu *pmu = &vcpu->arch.pmu; + struct kvm_pmc *pmc_high = &pmu->pmc[idx + 1]; + + if (!(--pmc_high->overflow_count)) { + __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx + 1); + pmc_high->overflow_count = U32_MAX + 1UL; + } + + } + if (kvm_pmu_overflow_status(vcpu)) { kvm_make_request(KVM_REQ_IRQ_PENDING, vcpu); kvm_vcpu_kick(vcpu); @@ -442,6 +635,10 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) select_idx != ARMV8_PMU_CYCLE_IDX) return; + /* Handled by even event */ + if (armv8pmu_evtype_is_chain(eventsel)) + return; + memset(&attr, 0, sizeof(struct perf_event_attr)); attr.type = PERF_TYPE_RAW; attr.size = sizeof(attr); @@ -454,6 +651,9 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) attr.config = (select_idx == ARMV8_PMU_CYCLE_IDX) ? ARMV8_PMUV3_PERFCTR_CPU_CYCLES : eventsel; + if (kvm_pmu_event_is_chained(vcpu, select_idx)) + attr.config1 |= PERF_ATTR_CFG1_KVM_PMU_CHAINED; + counter = kvm_pmu_get_counter_value(vcpu, select_idx); /* The initial sample period (overflow count) of an event. */ attr.sample_period = (-counter) & pmc->bitmask; @@ -466,6 +666,14 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) return; } + if (kvm_pmu_event_is_chained(vcpu, select_idx)) { + struct kvm_pmc *pmc_next = &pmu->pmc[select_idx + 1]; + + pmc_next->perf_event = event; + counter = kvm_pmu_get_counter_value(vcpu, select_idx + 1); + pmc_next->overflow_count = (-counter) & pmc->bitmask; + } + pmc->perf_event = event; } @@ -482,17 +690,25 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, u64 select_idx) { - struct kvm_pmu *pmu = &vcpu->arch.pmu; - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; - u64 reg, event_type = data & ARMV8_PMU_EVTYPE_MASK; - - kvm_pmu_stop_counter(vcpu, pmc); + u64 eventsel, event_type, pair_low, reg; reg = (select_idx == ARMV8_PMU_CYCLE_IDX) ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; - __vcpu_sys_reg(vcpu, reg) = event_type; - kvm_pmu_sync_counter_enable(vcpu, select_idx); + eventsel = data & ARMV8_PMU_EVTYPE_EVENT; + event_type = data & ARMV8_PMU_EVTYPE_MASK; + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; + + if (kvm_pmu_event_is_chained(vcpu, pair_low) || + armv8pmu_evtype_is_chain(eventsel)) { + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); + __vcpu_sys_reg(vcpu, reg) = event_type; + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); + } else { + kvm_pmu_stop_release_perf_event(vcpu, pair_low); + __vcpu_sys_reg(vcpu, reg) = event_type; + kvm_pmu_sync_counter_enable(vcpu, pair_low); + } } bool kvm_arm_support_pmu_v3(void) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters 2019-02-18 13:48 ` [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters Andrew Murray @ 2019-02-20 13:36 ` Marc Zyngier 2019-02-20 19:34 ` Andrew Murray 0 siblings, 1 reply; 9+ messages in thread From: Marc Zyngier @ 2019-02-20 13:36 UTC (permalink / raw) To: Andrew Murray Cc: Julien Thierry, Suzuki K Poulose, Christoffer Dall, linux-arm-kernel, kvmarm On Mon, 18 Feb 2019 13:48:04 +0000 Andrew Murray <andrew.murray@arm.com> wrote: > Emulate chained PMU counters by creating a single 64 bit event counter > for a pair of chained KVM counters. > > Signed-off-by: Andrew Murray <andrew.murray@arm.com> > --- > include/kvm/arm_pmu.h | 1 + > virt/kvm/arm/pmu.c | 322 +++++++++++++++++++++++++++++++++++++++++--------- > 2 files changed, 270 insertions(+), 53 deletions(-) > > diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h > index b73f31b..8e691ee 100644 > --- a/include/kvm/arm_pmu.h > +++ b/include/kvm/arm_pmu.h > @@ -29,6 +29,7 @@ struct kvm_pmc { > u8 idx; /* index into the pmu->pmc array */ > struct perf_event *perf_event; > u64 bitmask; > + u64 overflow_count; > }; > > struct kvm_pmu { > diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c > index 524b27f..2852dc4 100644 > --- a/virt/kvm/arm/pmu.c > +++ b/virt/kvm/arm/pmu.c > @@ -24,9 +24,26 @@ > #include <kvm/arm_pmu.h> > #include <kvm/arm_vgic.h> > > +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, > + u64 pair_low); > +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, > + u64 select_idx); > +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low); > static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, u64 select_idx); > static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx); > -static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); > + > +#define PERF_ATTR_CFG1_KVM_PMU_CHAINED 0x1 > + > +/** > + * kvm_pmu_counter_is_high_word - is select_idx high counter of 64bit event > + * @pmc: The PMU counter pointer > + * @select_idx: The counter index What is select_idx here? > + */ > +static inline bool kvm_pmu_counter_is_high_word(struct kvm_pmc *pmc) > +{ > + return ((pmc->perf_event->attr.config1 & PERF_ATTR_CFG1_KVM_PMU_CHAINED) > + && (pmc->idx % 2)); nit: This is usually expressed as 'idx & 1', but that's not a big deal. > +} > > /** > * kvm_pmu_get_counter_value - get PMU counter value > @@ -35,22 +52,70 @@ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); > */ > u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) > { > - u64 counter, reg, enabled, running; > + u64 counter_idx, reg, enabled, running, incr; > struct kvm_pmu *pmu = &vcpu->arch.pmu; > struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; > - counter = __vcpu_sys_reg(vcpu, reg); > + counter_idx = __vcpu_sys_reg(vcpu, reg); Sorry, but the _idx suffix is baffling. What you seem to have here is a counter value, not an index. 'counter' was the right name. > > /* The real counter value is equal to the value of counter register plus > * the value perf event counts. > */ > - if (pmc->perf_event) > - counter += perf_event_read_value(pmc->perf_event, &enabled, > + if (pmc->perf_event) { > + incr = perf_event_read_value(pmc->perf_event, &enabled, > &running); nit: please align the function arguments. > > - return counter & pmc->bitmask; > + if (kvm_pmu_counter_is_high_word(pmc)) { > + u64 counter_low, counter; > + > + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > + ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx - 1; Why do you cater for the cycle counter here? It would feel wrong if we could reach this code with the cycle counter, given that it is 64bit and doesn't need any of this. > + counter_low = __vcpu_sys_reg(vcpu, reg); > + counter = lower_32_bits(counter_low) | (counter_idx << 32); > + counter_idx = upper_32_bits(counter + incr); > + } else { > + counter_idx += incr; > + } > + } > + > + return counter_idx & pmc->bitmask; > +} > + > +/** > + * kvm_pmu_counter_is_enabled - is a counter active > + * @vcpu: The vcpu pointer > + * @select_idx: The counter index > + */ > +static bool kvm_pmu_counter_is_enabled(struct kvm_vcpu *vcpu, u64 select_idx) > +{ > + u64 mask = kvm_pmu_valid_counter_mask(vcpu); > + > + return (__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) && > + (__vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask & BIT(select_idx)); > +} > + > +/** > + * kvnm_pmu_event_is_chained - is a pair of counters chained and enabled > + * @vcpu: The vcpu pointer > + * @select_idx: The low counter index > + */ > +static bool kvm_pmu_event_is_chained(struct kvm_vcpu *vcpu, u64 pair_low) > +{ > + u64 eventsel, reg; > + > + reg = (pair_low + 1 == ARMV8_PMU_CYCLE_IDX) > + ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + pair_low + 1; Again, what does chaining with the cycle counter mean? You shouldn't be able to get here if pair_low >= 30. > + eventsel = __vcpu_sys_reg(vcpu, reg) & ARMV8_PMU_EVTYPE_EVENT; > + if (!armv8pmu_evtype_is_chain(eventsel)) > + return false; OK, so this works with the cycle counter only because PMCCFILTR_EL0[15:0] are RES0. I'd expect something a bit more robust. > + > + if (kvm_pmu_counter_is_enabled(vcpu, pair_low) != > + kvm_pmu_counter_is_enabled(vcpu, pair_low + 1)) > + return false; > + > + return true; > } > > /** > @@ -61,29 +126,45 @@ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) > */ > void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) > { > - u64 reg; > - struct kvm_pmu *pmu = &vcpu->arch.pmu; > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > + u64 reg, pair_low; > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; > __vcpu_sys_reg(vcpu, reg) += (s64)val - kvm_pmu_get_counter_value(vcpu, select_idx); > > - kvm_pmu_stop_counter(vcpu, pmc); > - kvm_pmu_sync_counter_enable(vcpu, select_idx); > + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; Let's get real: pair_low = select_idx & ~1UL; > + > + /* Recreate the perf event to reflect the updated sample_period */ > + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > + } else { > + kvm_pmu_stop_release_perf_event(vcpu, select_idx); > + kvm_pmu_sync_counter_enable(vcpu, select_idx); > + } > } > > /** > * kvm_pmu_release_perf_event - remove the perf event > * @pmc: The PMU counter pointer Missing documentation update. > */ > -static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) > +static void kvm_pmu_release_perf_event(struct kvm_vcpu *vcpu, > + struct kvm_pmc *pmc) > { > - if (pmc->perf_event) { > - perf_event_disable(pmc->perf_event); > + struct kvm_pmu *pmu = &vcpu->arch.pmu; The PMU structure is only a container_of away. See kvm_pmc_to_vcpu. > + struct kvm_pmc *pmc_alt; > + u64 pair_alt; > + > + pair_alt = (pmc->idx % 2) ? pmc->idx - 1 : pmc->idx + 1; pair_alt = pmc->idx ^ 1; > + pmc_alt = &pmu->pmc[pair_alt]; > + > + if (pmc->perf_event) > perf_event_release_kernel(pmc->perf_event); > - pmc->perf_event = NULL; > - } > + > + if (pmc->perf_event == pmc_alt->perf_event) > + pmc_alt->perf_event = NULL; Some people say that you shouldn't use pointers to memory that has already been freed. I don't really care, but this code strikes be a pretty fragile. I'd rather see something like: if (pmc->perf_event) { if (pmc->perf_event == pmc_alt->perf_event) pmc_alt->perf_event = NULL; perf_event_release_kernel(pmc->perf_event); pmc->perf_event = NULL; } which follows the current model, and doesn't mess with pointers post release. I also wonder why you don't rely on the primitives you've defined already (kvm_pmu_event_is_chained), and start reinventing it. Another thing that strikes me as odd is that all of a sudden, you start, dealing with this as full 64bit counter. Up to this point, you've been looking at it as a two separate counters. Here, you deal with both of them at once. I think this is a better approach, but consistency is key. > + > + pmc->perf_event = NULL; > } > > /** > @@ -91,22 +172,65 @@ static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) > * @vcpu: The vcpu pointer > * @pmc: The PMU counter pointer > * > - * If this counter has been configured to monitor some event, release it here. > + * If this counter has been configured to monitor some event, stop it here. > */ > static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc) > { > u64 counter, reg; > > if (pmc->perf_event) { > + perf_event_disable(pmc->perf_event); > counter = kvm_pmu_get_counter_value(vcpu, pmc->idx); > reg = (pmc->idx == ARMV8_PMU_CYCLE_IDX) > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + pmc->idx; > __vcpu_sys_reg(vcpu, reg) = counter; > - kvm_pmu_release_perf_event(pmc); The ever changing semantics of these functions are becoming pretty tedious to follow. I suggest you define the semantic of your choosing early, and stick to it. This patch is only supposed to add 64bit counter support, and seems to contain all kind of infrastructure bits that should be better located in a separate patch. > } > } > > /** > + * kvm_pmu_stop_release_perf_event_pair - stop and release a pair of counters > + * @vcpu: The vcpu pointer > + * @pmc_low: The PMU counter pointer for lower word > + * @pmc_high: The PMU counter pointer for higher word > + * > + * As chained counters share the underlying perf event, we stop them > + * both first before discarding the underlying perf event > + */ > +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, > + u64 idx_low) > +{ > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > + struct kvm_pmc *pmc_low = &pmu->pmc[idx_low]; > + struct kvm_pmc *pmc_high = &pmu->pmc[idx_low + 1]; > + > + /* Stopping a counter involves adding the perf event value to the > + * vcpu sys register value prior to releasing the perf event. As > + * kvm_pmu_get_counter_value may depend on the low counter value we > + * must always stop the high counter first > + */ Comment style (I think Christoffer mentioned this already). > + kvm_pmu_stop_counter(vcpu, pmc_high); > + kvm_pmu_stop_counter(vcpu, pmc_low); > + > + kvm_pmu_release_perf_event(vcpu, pmc_high); > + kvm_pmu_release_perf_event(vcpu, pmc_low); > +} > + > +/** > + * kvm_pmu_stop_release_perf_event - stop and release a counter > + * @vcpu: The vcpu pointer > + * @select_idx: The counter index > + */ > +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, > + u64 select_idx) > +{ > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > + > + kvm_pmu_stop_counter(vcpu, pmc); > + kvm_pmu_release_perf_event(vcpu, pmc); > +} OK, I definitely dislike this kind of construct. Why don't we have a single 'stop_release' function that has deals with everything? You already have the infrastructure. Use it to introduce some abstraction. > + > +/** > * kvm_pmu_vcpu_reset - reset pmu state for cpu > * @vcpu: The vcpu pointer > * > @@ -117,7 +241,7 @@ void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu) > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > - kvm_pmu_stop_counter(vcpu, &pmu->pmc[i]); > + kvm_pmu_stop_release_perf_event(vcpu, i); > pmu->pmc[i].idx = i; > pmu->pmc[i].bitmask = 0xffffffffUL; > } > @@ -134,7 +258,7 @@ void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) > - kvm_pmu_release_perf_event(&pmu->pmc[i]); > + kvm_pmu_release_perf_event(vcpu, &pmu->pmc[i]); > } > > u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) > @@ -167,53 +291,115 @@ static void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > } > > /** > + * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled Why the 'if it should be enabled'? Shouldn't it be 'just do it'? > + * @vcpu: The vcpu pointer > + * @select_idx: The counter index > + */ > +static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, > + u64 select_idx) > +{ > + kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); > +} > + > +/** > + * kvm_pmu_sync_counter_enable_pair - reenable a pair if they should be enabled > + * @vcpu: The vcpu pointer > + * @pair_low: The low counter index > + */ > +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low) > +{ > + kvm_pmu_enable_counter_mask(vcpu, BIT(pair_low) | BIT(pair_low + 1)); > +} > + > +/** > + * kvm_pmu_enable_counter_pair - enable counters pair at a time > + * @vcpu: The vcpu pointer > + * @val: counters to enable > + * @pair_low: The low counter index > + */ > +static void kvm_pmu_enable_counter_pair(struct kvm_vcpu *vcpu, u64 val, > + u64 pair_low) > +{ > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; > + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; > + > + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { > + if (pmc_low->perf_event != pmc_high->perf_event) > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); I find this double condition very odd. How can the second be false if the first is true? Or rather, why does the first condition matter at all? > + } > + > + if (val & BIT(pair_low)) > + kvm_pmu_enable_counter(vcpu, pair_low); > + > + if (val & BIT(pair_low + 1)) > + kvm_pmu_enable_counter(vcpu, pair_low + 1); > +} > + > +/** > * kvm_pmu_enable_counter_mask - enable selected PMU counters > * @vcpu: The vcpu pointer > - * @val: the value guest writes to PMCNTENSET register > + * @val: the value guest writes to PMCNTENSET register or a subset A subset? of what? from where? > * > * Call perf_event_enable to start counting the perf event > */ > void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) > { > int i; > + u64 mask = kvm_pmu_valid_counter_mask(vcpu); > + u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask; > > if (!(__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) || !val) > return; > > - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > - if (!(val & BIT(i))) > - continue; > - > - kvm_pmu_enable_counter(vcpu, i); > - } > + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) > + kvm_pmu_enable_counter_pair(vcpu, val & set, i); > } > > /** > - * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled > + * kvm_pmu_disable_counter - disable selected PMU counter > * @vcpu: The vcpu pointer > * @select_idx: The counter index > */ > -static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, > - u64 select_idx) > +static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > { > - u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0); > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > - if (set & BIT(select_idx)) > - kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); > + if (pmc->perf_event) { > + perf_event_disable(pmc->perf_event); > + if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE) > + kvm_debug("fail to enable perf event\n"); > + } > } > > /** > - * kvm_pmu_disable_counter - disable selected PMU counter > - * @vcpu: The vcpu pointer > - * @pmc: The counter to disable > + * kvm_pmu_disable_counter_pair - disable counters pair at a time > + * @val: counters to disable > + * @pair_low: The low counter index > */ > -static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > +static void kvm_pmu_disable_counter_pair(struct kvm_vcpu *vcpu, u64 val, > + u64 pair_low) > { > struct kvm_pmu *pmu = &vcpu->arch.pmu; > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; > + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; > + > + if (!kvm_pmu_event_is_chained(vcpu, pair_low)) { > + if (pmc_low->perf_event == pmc_high->perf_event) { Again, I find this construct troubling. > + if (pmc_low->perf_event) { > + kvm_pmu_stop_release_perf_event_pair(vcpu, > + pair_low); > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > + } > + } > + } > > - if (pmc->perf_event) > - perf_event_disable(pmc->perf_event); > + if (val & BIT(pair_low)) > + kvm_pmu_disable_counter(vcpu, pair_low); > + > + if (val & BIT(pair_low + 1)) > + kvm_pmu_disable_counter(vcpu, pair_low + 1); > } > > /** > @@ -230,12 +416,8 @@ void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) > if (!val) > return; > > - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > - if (!(val & BIT(i))) > - continue; > - > - kvm_pmu_disable_counter(vcpu, i); > - } > + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) > + kvm_pmu_disable_counter_pair(vcpu, val, i); If disable_counter() was 64bit aware, we shouldn't need any of this. > } > > static u64 kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) > @@ -346,6 +528,17 @@ static void kvm_pmu_perf_overflow(struct perf_event *perf_event, > > __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx); > > + if (kvm_pmu_event_is_chained(vcpu, idx)) { > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > + struct kvm_pmc *pmc_high = &pmu->pmc[idx + 1]; > + > + if (!(--pmc_high->overflow_count)) { > + __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx + 1); > + pmc_high->overflow_count = U32_MAX + 1UL; > + } > + > + } > + > if (kvm_pmu_overflow_status(vcpu)) { > kvm_make_request(KVM_REQ_IRQ_PENDING, vcpu); > kvm_vcpu_kick(vcpu); > @@ -442,6 +635,10 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > select_idx != ARMV8_PMU_CYCLE_IDX) > return; > > + /* Handled by even event */ > + if (armv8pmu_evtype_is_chain(eventsel)) > + return; > + > memset(&attr, 0, sizeof(struct perf_event_attr)); > attr.type = PERF_TYPE_RAW; > attr.size = sizeof(attr); > @@ -454,6 +651,9 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > attr.config = (select_idx == ARMV8_PMU_CYCLE_IDX) ? > ARMV8_PMUV3_PERFCTR_CPU_CYCLES : eventsel; > > + if (kvm_pmu_event_is_chained(vcpu, select_idx)) > + attr.config1 |= PERF_ATTR_CFG1_KVM_PMU_CHAINED; > + > counter = kvm_pmu_get_counter_value(vcpu, select_idx); > /* The initial sample period (overflow count) of an event. */ > attr.sample_period = (-counter) & pmc->bitmask; > @@ -466,6 +666,14 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > return; > } > > + if (kvm_pmu_event_is_chained(vcpu, select_idx)) { > + struct kvm_pmc *pmc_next = &pmu->pmc[select_idx + 1]; > + > + pmc_next->perf_event = event; > + counter = kvm_pmu_get_counter_value(vcpu, select_idx + 1); > + pmc_next->overflow_count = (-counter) & pmc->bitmask; > + } > + > pmc->perf_event = event; > } > > @@ -482,17 +690,25 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, > u64 select_idx) > { > - struct kvm_pmu *pmu = &vcpu->arch.pmu; > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > - u64 reg, event_type = data & ARMV8_PMU_EVTYPE_MASK; > - > - kvm_pmu_stop_counter(vcpu, pmc); > + u64 eventsel, event_type, pair_low, reg; > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; > > - __vcpu_sys_reg(vcpu, reg) = event_type; > - kvm_pmu_sync_counter_enable(vcpu, select_idx); > + eventsel = data & ARMV8_PMU_EVTYPE_EVENT; > + event_type = data & ARMV8_PMU_EVTYPE_MASK; > + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; > + > + if (kvm_pmu_event_is_chained(vcpu, pair_low) || > + armv8pmu_evtype_is_chain(eventsel)) { > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); > + __vcpu_sys_reg(vcpu, reg) = event_type; > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > + } else { > + kvm_pmu_stop_release_perf_event(vcpu, pair_low); > + __vcpu_sys_reg(vcpu, reg) = event_type; > + kvm_pmu_sync_counter_enable(vcpu, pair_low); > + } > } > > bool kvm_arm_support_pmu_v3(void) I've stopped early, as I think the way you handle pairs of register is not completely right. There is a distinct lack of abstraction which doesn't fill me with confidence, and the edge case of counter 30 requires some care. I think you should rework this patch to work with a more generic view of a counter, rather than trying to cram the single/dual counter in every single place. As it stands, I'm not planning to take this into 5.1. Hopefully you'll have the time to rework it for 5.2. Thanks, M. -- Without deviation from the norm, progress is not possible. _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters 2019-02-20 13:36 ` Marc Zyngier @ 2019-02-20 19:34 ` Andrew Murray 0 siblings, 0 replies; 9+ messages in thread From: Andrew Murray @ 2019-02-20 19:34 UTC (permalink / raw) To: Marc Zyngier Cc: Julien Thierry, Suzuki K Poulose, Christoffer Dall, linux-arm-kernel, kvmarm Hi Marc, Thanks for the review... On Wed, Feb 20, 2019 at 01:36:59PM +0000, Marc Zyngier wrote: > On Mon, 18 Feb 2019 13:48:04 +0000 > Andrew Murray <andrew.murray@arm.com> wrote: > > > Emulate chained PMU counters by creating a single 64 bit event counter > > for a pair of chained KVM counters. > > > > Signed-off-by: Andrew Murray <andrew.murray@arm.com> > > --- > > include/kvm/arm_pmu.h | 1 + > > virt/kvm/arm/pmu.c | 322 +++++++++++++++++++++++++++++++++++++++++--------- > > 2 files changed, 270 insertions(+), 53 deletions(-) > > > > diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h > > index b73f31b..8e691ee 100644 > > --- a/include/kvm/arm_pmu.h > > +++ b/include/kvm/arm_pmu.h > > @@ -29,6 +29,7 @@ struct kvm_pmc { > > u8 idx; /* index into the pmu->pmc array */ > > struct perf_event *perf_event; > > u64 bitmask; > > + u64 overflow_count; > > }; > > > > struct kvm_pmu { > > diff --git a/virt/kvm/arm/pmu.c b/virt/kvm/arm/pmu.c > > index 524b27f..2852dc4 100644 > > --- a/virt/kvm/arm/pmu.c > > +++ b/virt/kvm/arm/pmu.c > > @@ -24,9 +24,26 @@ > > #include <kvm/arm_pmu.h> > > #include <kvm/arm_vgic.h> > > > > +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, > > + u64 pair_low); > > +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, > > + u64 select_idx); > > +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low); > > static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, u64 select_idx); > > static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx); > > -static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); > > + > > +#define PERF_ATTR_CFG1_KVM_PMU_CHAINED 0x1 > > + > > +/** > > + * kvm_pmu_counter_is_high_word - is select_idx high counter of 64bit event > > + * @pmc: The PMU counter pointer > > + * @select_idx: The counter index > > What is select_idx here? That should be removed. > > > + */ > > +static inline bool kvm_pmu_counter_is_high_word(struct kvm_pmc *pmc) > > +{ > > + return ((pmc->perf_event->attr.config1 & PERF_ATTR_CFG1_KVM_PMU_CHAINED) > > + && (pmc->idx % 2)); > > nit: This is usually expressed as 'idx & 1', but that's not a big deal. Noted, likewise for the others you point out later on. > > > +} > > > > /** > > * kvm_pmu_get_counter_value - get PMU counter value > > @@ -35,22 +52,70 @@ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc); > > */ > > u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) > > { > > - u64 counter, reg, enabled, running; > > + u64 counter_idx, reg, enabled, running, incr; > > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; > > - counter = __vcpu_sys_reg(vcpu, reg); > > + counter_idx = __vcpu_sys_reg(vcpu, reg); > > Sorry, but the _idx suffix is baffling. What you seem to have here is a > counter value, not an index. 'counter' was the right name. Gah - this was picked up in the previous review, I made the change, it's in my Git tree but somehow it didn't end up here - sorry about that. > > > > > /* The real counter value is equal to the value of counter register plus > > * the value perf event counts. > > */ > > - if (pmc->perf_event) > > - counter += perf_event_read_value(pmc->perf_event, &enabled, > > + if (pmc->perf_event) { > > + incr = perf_event_read_value(pmc->perf_event, &enabled, > > &running); > > nit: please align the function arguments. > > > > > - return counter & pmc->bitmask; > > + if (kvm_pmu_counter_is_high_word(pmc)) { > > + u64 counter_low, counter; > > + > > + reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > > + ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx - 1; > > Why do you cater for the cycle counter here? It would feel wrong if we > could reach this code with the cycle counter, given that it is 64bit > and doesn't need any of this. Yes this isn't needed. > > > + counter_low = __vcpu_sys_reg(vcpu, reg); > > + counter = lower_32_bits(counter_low) | (counter_idx << 32); > > + counter_idx = upper_32_bits(counter + incr); > > + } else { > > + counter_idx += incr; > > + } > > + } > > + > > + return counter_idx & pmc->bitmask; > > +} > > + > > +/** > > + * kvm_pmu_counter_is_enabled - is a counter active > > + * @vcpu: The vcpu pointer > > + * @select_idx: The counter index > > + */ > > +static bool kvm_pmu_counter_is_enabled(struct kvm_vcpu *vcpu, u64 select_idx) > > +{ > > + u64 mask = kvm_pmu_valid_counter_mask(vcpu); > > + > > + return (__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) && > > + (__vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask & BIT(select_idx)); > > +} > > + > > +/** > > + * kvnm_pmu_event_is_chained - is a pair of counters chained and enabled > > + * @vcpu: The vcpu pointer > > + * @select_idx: The low counter index > > + */ > > +static bool kvm_pmu_event_is_chained(struct kvm_vcpu *vcpu, u64 pair_low) > > +{ > > + u64 eventsel, reg; > > + > > + reg = (pair_low + 1 == ARMV8_PMU_CYCLE_IDX) > > + ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + pair_low + 1; > > Again, what does chaining with the cycle counter mean? You shouldn't be > able to get here if pair_low >= 30. > > > + eventsel = __vcpu_sys_reg(vcpu, reg) & ARMV8_PMU_EVTYPE_EVENT; > > + if (!armv8pmu_evtype_is_chain(eventsel)) > > + return false; > > OK, so this works with the cycle counter only because > PMCCFILTR_EL0[15:0] are RES0. I'd expect something a bit more robust. I can update this to bail out based on the value of pair_low for better clarity. > > > + > > + if (kvm_pmu_counter_is_enabled(vcpu, pair_low) != > > + kvm_pmu_counter_is_enabled(vcpu, pair_low + 1)) > > + return false; > > + > > + return true; > > } > > > > /** > > @@ -61,29 +126,45 @@ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) > > */ > > void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) > > { > > - u64 reg; > > - struct kvm_pmu *pmu = &vcpu->arch.pmu; > > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > + u64 reg, pair_low; > > > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + select_idx; > > __vcpu_sys_reg(vcpu, reg) += (s64)val - kvm_pmu_get_counter_value(vcpu, select_idx); > > > > - kvm_pmu_stop_counter(vcpu, pmc); > > - kvm_pmu_sync_counter_enable(vcpu, select_idx); > > + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; > > Let's get real: > > pair_low = select_idx & ~1UL; > > > + > > + /* Recreate the perf event to reflect the updated sample_period */ > > + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { > > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); > > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > > + } else { > > + kvm_pmu_stop_release_perf_event(vcpu, select_idx); > > + kvm_pmu_sync_counter_enable(vcpu, select_idx); > > + } > > } > > > > /** > > * kvm_pmu_release_perf_event - remove the perf event > > * @pmc: The PMU counter pointer > > Missing documentation update. > > > */ > > -static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) > > +static void kvm_pmu_release_perf_event(struct kvm_vcpu *vcpu, > > + struct kvm_pmc *pmc) > > { > > - if (pmc->perf_event) { > > - perf_event_disable(pmc->perf_event); > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > The PMU structure is only a container_of away. See kvm_pmc_to_vcpu. > > > + struct kvm_pmc *pmc_alt; > > + u64 pair_alt; > > + > > + pair_alt = (pmc->idx % 2) ? pmc->idx - 1 : pmc->idx + 1; > > pair_alt = pmc->idx ^ 1; > > > + pmc_alt = &pmu->pmc[pair_alt]; > > + > > + if (pmc->perf_event) > > perf_event_release_kernel(pmc->perf_event); > > - pmc->perf_event = NULL; > > - } > > + > > + if (pmc->perf_event == pmc_alt->perf_event) > > + pmc_alt->perf_event = NULL; > > Some people say that you shouldn't use pointers to memory that has > already been freed. I don't really care, but this code strikes be a > pretty fragile. > > I'd rather see something like: > > if (pmc->perf_event) { > if (pmc->perf_event == pmc_alt->perf_event) > pmc_alt->perf_event = NULL; > > perf_event_release_kernel(pmc->perf_event); > pmc->perf_event = NULL; > } > > which follows the current model, and doesn't mess with pointers post > release. Thanks this makes sense. > I also wonder why you don't rely on the primitives you've > defined already (kvm_pmu_event_is_chained), and start reinventing it. Consider the scenario where you have two counters that form a chained counter. If the user initially enables just the low counter then despite the event types indicating its a chained counter, its actually a normal counter which we must back in perf with a 32 bit event. We reflect this in kvm_pmu_event_is_chained by considering if both counters are enabled. At this point low->perf_event will be something, high->perf_event will be NULL. If the user then additionally enables the high counter, then it becomes a chained counter backed by a 64 bit perf event. Despite it being a chained counter low->perf_event doesn't equal high->perf_event. There are other scenarios... For these reasons we can't reuse kvm_pmu_event_is_chained above. > > Another thing that strikes me as odd is that all of a sudden, you > start, dealing with this as full 64bit counter. Up to this point, > you've been looking at it as a two separate counters. Here, you deal > with both of them at once. I think this is a better approach, but > consistency is key. > > > + > > + pmc->perf_event = NULL; > > } > > > > /** > > @@ -91,22 +172,65 @@ static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc) > > * @vcpu: The vcpu pointer > > * @pmc: The PMU counter pointer > > * > > - * If this counter has been configured to monitor some event, release it here. > > + * If this counter has been configured to monitor some event, stop it here. > > */ > > static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc) > > { > > u64 counter, reg; > > > > if (pmc->perf_event) { > > + perf_event_disable(pmc->perf_event); > > counter = kvm_pmu_get_counter_value(vcpu, pmc->idx); > > reg = (pmc->idx == ARMV8_PMU_CYCLE_IDX) > > ? PMCCNTR_EL0 : PMEVCNTR0_EL0 + pmc->idx; > > __vcpu_sys_reg(vcpu, reg) = counter; > > - kvm_pmu_release_perf_event(pmc); > > The ever changing semantics of these functions are becoming pretty > tedious to follow. I suggest you define the semantic of your choosing > early, and stick to it. This patch is only supposed to add 64bit > counter support, and seems to contain all kind of infrastructure bits > that should be better located in a separate patch. This is relevant. We don't release the event when we stop a single counter because the underlying perf event is shared between both pmc's (if its chained). If we kill it here, then we can't read the counter value when we stop the pair'd pmc. This is why, if a counter is chained we release them as a pair in kvm_pmu_stop_release_perf_event_pair. > > > } > > } > > > > /** > > + * kvm_pmu_stop_release_perf_event_pair - stop and release a pair of counters > > + * @vcpu: The vcpu pointer > > + * @pmc_low: The PMU counter pointer for lower word > > + * @pmc_high: The PMU counter pointer for higher word > > + * > > + * As chained counters share the underlying perf event, we stop them > > + * both first before discarding the underlying perf event > > + */ > > +static void kvm_pmu_stop_release_perf_event_pair(struct kvm_vcpu *vcpu, > > + u64 idx_low) > > +{ > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > + struct kvm_pmc *pmc_low = &pmu->pmc[idx_low]; > > + struct kvm_pmc *pmc_high = &pmu->pmc[idx_low + 1]; > > + > > + /* Stopping a counter involves adding the perf event value to the > > + * vcpu sys register value prior to releasing the perf event. As > > + * kvm_pmu_get_counter_value may depend on the low counter value we > > + * must always stop the high counter first > > + */ > > Comment style (I think Christoffer mentioned this already). I missed that. > > > + kvm_pmu_stop_counter(vcpu, pmc_high); > > + kvm_pmu_stop_counter(vcpu, pmc_low); > > + > > + kvm_pmu_release_perf_event(vcpu, pmc_high); > > + kvm_pmu_release_perf_event(vcpu, pmc_low); > > +} > > + > > +/** > > + * kvm_pmu_stop_release_perf_event - stop and release a counter > > + * @vcpu: The vcpu pointer > > + * @select_idx: The counter index > > + */ > > +static void kvm_pmu_stop_release_perf_event(struct kvm_vcpu *vcpu, > > + u64 select_idx) > > +{ > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > + > > + kvm_pmu_stop_counter(vcpu, pmc); > > + kvm_pmu_release_perf_event(vcpu, pmc); > > +} > > OK, I definitely dislike this kind of construct. Why don't we have a > single 'stop_release' function that has deals with everything? You > already have the infrastructure. Use it to introduce some abstraction. It's possible to improve on this. Though I felt this was the simplest approach. Such a 'stop_release' function would have to determine if it's a chained counter or not and in many cases the caller of the kvm_pmu_stop_release_perf_event{,_pair} functions already knows - so it seemed to just add more code. > > > + > > +/** > > * kvm_pmu_vcpu_reset - reset pmu state for cpu > > * @vcpu: The vcpu pointer > > * > > @@ -117,7 +241,7 @@ void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu) > > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > > > for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > > - kvm_pmu_stop_counter(vcpu, &pmu->pmc[i]); > > + kvm_pmu_stop_release_perf_event(vcpu, i); > > pmu->pmc[i].idx = i; > > pmu->pmc[i].bitmask = 0xffffffffUL; > > } > > @@ -134,7 +258,7 @@ void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) > > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > > > for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) > > - kvm_pmu_release_perf_event(&pmu->pmc[i]); > > + kvm_pmu_release_perf_event(vcpu, &pmu->pmc[i]); > > } > > > > u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu) > > @@ -167,53 +291,115 @@ static void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > > } > > > > /** > > + * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled > > Why the 'if it should be enabled'? Shouldn't it be 'just do it'? If the user changes the counter value, type or enable of a counter within a chained pair then we must destroy and recreate the underlying perf event. It's far easier to simply destroy the event upon these changes and then call kvm_pmu_sync_counter_enable to re-create the relevant events. Therefore we have the suitation where the PMCNTENSET bits are set but the perf backing events are not present, so we recreate the ones that should be enabled. > > > + * @vcpu: The vcpu pointer > > + * @select_idx: The counter index > > + */ > > +static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, > > + u64 select_idx) > > +{ > > + kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); > > +} > > + > > +/** > > + * kvm_pmu_sync_counter_enable_pair - reenable a pair if they should be enabled > > + * @vcpu: The vcpu pointer > > + * @pair_low: The low counter index > > + */ > > +static void kvm_pmu_sync_counter_enable_pair(struct kvm_vcpu *vcpu, u64 pair_low) > > +{ > > + kvm_pmu_enable_counter_mask(vcpu, BIT(pair_low) | BIT(pair_low + 1)); > > +} > > + > > +/** > > + * kvm_pmu_enable_counter_pair - enable counters pair at a time > > + * @vcpu: The vcpu pointer > > + * @val: counters to enable > > + * @pair_low: The low counter index > > + */ > > +static void kvm_pmu_enable_counter_pair(struct kvm_vcpu *vcpu, u64 val, > > + u64 pair_low) > > +{ > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; > > + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; > > + > > + if (kvm_pmu_event_is_chained(vcpu, pair_low)) { > > + if (pmc_low->perf_event != pmc_high->perf_event) > > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); > > I find this double condition very odd. How can the second be false if > the first is true? Or rather, why does the first condition matter at > all? I believe I've explained this above. I.e. if the event types indicate that two counters should make a pair, yet the perf events are different - then we need to destroy them and recreate them. This may happen if a user enables both counters from a pair whereas previously only one was enabled. > > > + } > > + > > + if (val & BIT(pair_low)) > > + kvm_pmu_enable_counter(vcpu, pair_low); > > + > > + if (val & BIT(pair_low + 1)) > > + kvm_pmu_enable_counter(vcpu, pair_low + 1); > > +} > > + > > +/** > > * kvm_pmu_enable_counter_mask - enable selected PMU counters > > * @vcpu: The vcpu pointer > > - * @val: the value guest writes to PMCNTENSET register > > + * @val: the value guest writes to PMCNTENSET register or a subset > > A subset? of what? from where? A subset (val) from PMCTENSET_EL0. Perhaps I can make this clearer. This comment was added to reflect the change of function name to append _mask. > > > * > > * Call perf_event_enable to start counting the perf event > > */ > > void kvm_pmu_enable_counter_mask(struct kvm_vcpu *vcpu, u64 val) > > { > > int i; > > + u64 mask = kvm_pmu_valid_counter_mask(vcpu); > > + u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & mask; > > > > if (!(__vcpu_sys_reg(vcpu, PMCR_EL0) & ARMV8_PMU_PMCR_E) || !val) > > return; > > > > - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > > - if (!(val & BIT(i))) > > - continue; > > - > > - kvm_pmu_enable_counter(vcpu, i); > > - } > > + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) > > + kvm_pmu_enable_counter_pair(vcpu, val & set, i); > > } > > > > /** > > - * kvm_pmu_sync_counter_enable - reenable a counter if it should be enabled > > + * kvm_pmu_disable_counter - disable selected PMU counter > > * @vcpu: The vcpu pointer > > * @select_idx: The counter index > > */ > > -static void kvm_pmu_sync_counter_enable(struct kvm_vcpu *vcpu, > > - u64 select_idx) > > +static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > > { > > - u64 set = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0); > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > + struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > > > - if (set & BIT(select_idx)) > > - kvm_pmu_enable_counter_mask(vcpu, BIT(select_idx)); > > + if (pmc->perf_event) { > > + perf_event_disable(pmc->perf_event); > > + if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE) > > + kvm_debug("fail to enable perf event\n"); > > + } > > } > > > > /** > > - * kvm_pmu_disable_counter - disable selected PMU counter > > - * @vcpu: The vcpu pointer > > - * @pmc: The counter to disable > > + * kvm_pmu_disable_counter_pair - disable counters pair at a time > > + * @val: counters to disable > > + * @pair_low: The low counter index > > */ > > -static void kvm_pmu_disable_counter(struct kvm_vcpu *vcpu, u64 select_idx) > > +static void kvm_pmu_disable_counter_pair(struct kvm_vcpu *vcpu, u64 val, > > + u64 pair_low) > > { > > struct kvm_pmu *pmu = &vcpu->arch.pmu; > > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > + struct kvm_pmc *pmc_low = &pmu->pmc[pair_low]; > > + struct kvm_pmc *pmc_high = &pmu->pmc[pair_low + 1]; > > + > > + if (!kvm_pmu_event_is_chained(vcpu, pair_low)) { > > + if (pmc_low->perf_event == pmc_high->perf_event) { > > Again, I find this construct troubling. The use-case here is when you have two counters in a pair enabled (second condition), and now you've disabled one of them (first condition). We need to destroy the shared perf event. > > > + if (pmc_low->perf_event) { > > + kvm_pmu_stop_release_perf_event_pair(vcpu, > > + pair_low); > > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > > + } > > + } > > + } > > > > - if (pmc->perf_event) > > - perf_event_disable(pmc->perf_event); > > + if (val & BIT(pair_low)) > > + kvm_pmu_disable_counter(vcpu, pair_low); > > + > > + if (val & BIT(pair_low + 1)) > > + kvm_pmu_disable_counter(vcpu, pair_low + 1); > > } > > > > /** > > @@ -230,12 +416,8 @@ void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) > > if (!val) > > return; > > > > - for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) { > > - if (!(val & BIT(i))) > > - continue; > > - > > - kvm_pmu_disable_counter(vcpu, i); > > - } > > + for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i += 2) > > + kvm_pmu_disable_counter_pair(vcpu, val, i); > > If disable_counter() was 64bit aware, we shouldn't need any of this. It's likely the OS will use a mix of chained and non-chained counters - and so we can't treat eveything as chained counters. If we were to combine the logic of kvm_pmu_disable_counter and kvm_pmu_disable_counter_pair we end up duplicating code - we can't disable a counter without considering the impact on its adjacent counter. Unless I'm not understanding what your point here? > > > } > > > > static u64 kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) > > @@ -346,6 +528,17 @@ static void kvm_pmu_perf_overflow(struct perf_event *perf_event, > > > > __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx); > > > > + if (kvm_pmu_event_is_chained(vcpu, idx)) { > > + struct kvm_pmu *pmu = &vcpu->arch.pmu; > > + struct kvm_pmc *pmc_high = &pmu->pmc[idx + 1]; > > + > > + if (!(--pmc_high->overflow_count)) { > > + __vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(idx + 1); > > + pmc_high->overflow_count = U32_MAX + 1UL; > > + } > > + > > + } > > + > > if (kvm_pmu_overflow_status(vcpu)) { > > kvm_make_request(KVM_REQ_IRQ_PENDING, vcpu); > > kvm_vcpu_kick(vcpu); > > @@ -442,6 +635,10 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > > select_idx != ARMV8_PMU_CYCLE_IDX) > > return; > > > > + /* Handled by even event */ > > + if (armv8pmu_evtype_is_chain(eventsel)) > > + return; > > + > > memset(&attr, 0, sizeof(struct perf_event_attr)); > > attr.type = PERF_TYPE_RAW; > > attr.size = sizeof(attr); > > @@ -454,6 +651,9 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > > attr.config = (select_idx == ARMV8_PMU_CYCLE_IDX) ? > > ARMV8_PMUV3_PERFCTR_CPU_CYCLES : eventsel; > > > > + if (kvm_pmu_event_is_chained(vcpu, select_idx)) > > + attr.config1 |= PERF_ATTR_CFG1_KVM_PMU_CHAINED; > > + > > counter = kvm_pmu_get_counter_value(vcpu, select_idx); > > /* The initial sample period (overflow count) of an event. */ > > attr.sample_period = (-counter) & pmc->bitmask; > > @@ -466,6 +666,14 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > > return; > > } > > > > + if (kvm_pmu_event_is_chained(vcpu, select_idx)) { > > + struct kvm_pmc *pmc_next = &pmu->pmc[select_idx + 1]; > > + > > + pmc_next->perf_event = event; > > + counter = kvm_pmu_get_counter_value(vcpu, select_idx + 1); > > + pmc_next->overflow_count = (-counter) & pmc->bitmask; > > + } > > + > > pmc->perf_event = event; > > } > > > > @@ -482,17 +690,25 @@ static void kvm_pmu_create_perf_event(struct kvm_vcpu *vcpu, u64 select_idx) > > void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data, > > u64 select_idx) > > { > > - struct kvm_pmu *pmu = &vcpu->arch.pmu; > > - struct kvm_pmc *pmc = &pmu->pmc[select_idx]; > > - u64 reg, event_type = data & ARMV8_PMU_EVTYPE_MASK; > > - > > - kvm_pmu_stop_counter(vcpu, pmc); > > + u64 eventsel, event_type, pair_low, reg; > > > > reg = (select_idx == ARMV8_PMU_CYCLE_IDX) > > ? PMCCFILTR_EL0 : PMEVTYPER0_EL0 + select_idx; > > > > - __vcpu_sys_reg(vcpu, reg) = event_type; > > - kvm_pmu_sync_counter_enable(vcpu, select_idx); > > + eventsel = data & ARMV8_PMU_EVTYPE_EVENT; > > + event_type = data & ARMV8_PMU_EVTYPE_MASK; > > + pair_low = (select_idx % 2) ? select_idx - 1 : select_idx; > > + > > + if (kvm_pmu_event_is_chained(vcpu, pair_low) || > > + armv8pmu_evtype_is_chain(eventsel)) { > > + kvm_pmu_stop_release_perf_event_pair(vcpu, pair_low); > > + __vcpu_sys_reg(vcpu, reg) = event_type; > > + kvm_pmu_sync_counter_enable_pair(vcpu, pair_low); > > + } else { > > + kvm_pmu_stop_release_perf_event(vcpu, pair_low); > > + __vcpu_sys_reg(vcpu, reg) = event_type; > > + kvm_pmu_sync_counter_enable(vcpu, pair_low); > > + } > > } > > > > bool kvm_arm_support_pmu_v3(void) > > I've stopped early, as I think the way you handle pairs of register is > not completely right. There is a distinct lack of abstraction which > doesn't fill me with confidence, and the edge case of counter 30 > requires some care. > > I think you should rework this patch to work with a more generic view > of a counter, rather than trying to cram the single/dual counter in > every single place. I'm struggling to find a better way to do this. It's made so much more complex due to the fact that we have one perf event backing two counters and that this event needs to be recreated whenever the user does anything with the PMU registers. This dependency is a challenge when the KVM guest can treat the counters as 32bit non-chained. The only way I can see to improve this is to emulate the behavior of chained counters by counting overflows, but then we don't take advantage of the host OS's 64 bit perf events (I'm not even sure how much of a benefit this is). With this approach we reduce the complexity to the kvm_pmu_perf_overflow handler which would be the only place where a dependency between two counters is considered. Everywhere else we treat the counters as non-chained 32 bit. This would so much simpler. Or is there another way? > > As it stands, I'm not planning to take this into 5.1. Hopefully you'll > have the time to rework it for 5.2. That's no problem, it's ready when it's ready. And this seems to be a complicated beast for what it is :|. Thanks, Andrew Murray > > Thanks, > > M. > -- > Without deviation from the norm, progress is not possible. _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2019-02-20 19:35 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-02-18 13:47 [PATCH v3 0/6] KVM: arm/arm64: add support for chained counters Andrew Murray
2019-02-18 13:47 ` [PATCH v3 1/6] KVM: arm/arm64: rename kvm_pmu_{enable/disable}_counter functions Andrew Murray
2019-02-18 13:48 ` [PATCH v3 2/6] KVM: arm/arm64: extract duplicated code to own function Andrew Murray
2019-02-18 13:48 ` [PATCH v3 3/6] KVM: arm/arm64: re-create event when setting counter value Andrew Murray
2019-02-18 13:48 ` [PATCH v3 4/6] KVM: arm/arm64: lazily create perf events on enable Andrew Murray
2019-02-18 13:48 ` [PATCH v3 5/6] arm64: perf: extract chain helper into header Andrew Murray
2019-02-18 13:48 ` [PATCH v3 6/6] KVM: arm/arm64: support chained PMU counters Andrew Murray
2019-02-20 13:36 ` Marc Zyngier
2019-02-20 19:34 ` Andrew Murray
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).