The KVM PMU event filter uAPI requires disallowed events not to count. Because userspace can install or update the event filter independently of guest register writes, re-apply the filter on every vCPU load as well as on trapped PMEVTYPER_EL0 and PMCCFILTR_EL0 writes, excluding all exception levels in hardware whenever the selected event is blocked. When running in a nested hypervisor context (is_hyp_ctxt(vcpu)), L1 vEL2 executes at physical NS-EL1: remap guest ARMV8_PMU_INCLUDE_EL2 onto physical EL1 (clearing ARMV8_PMU_EXCLUDE_NS_EL1 so P == NSK) and honor guest MDCR_EL2.HPMD for event counters 0..HPMN-1 and MDCR_EL2.HCCD for PMCCNTR_EL0. Signed-off-by: Colton Lewis --- arch/arm64/kvm/pmu-direct.c | 78 +++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/arch/arm64/kvm/pmu-direct.c b/arch/arm64/kvm/pmu-direct.c index 5c8a8c42e353d..ace3e8e781538 100644 --- a/arch/arm64/kvm/pmu-direct.c +++ b/arch/arm64/kvm/pmu-direct.c @@ -242,6 +242,67 @@ u64 kvm_pmu_direct_reg_read(struct kvm_vcpu *vcpu, unsigned int reg) } } +static void kvm_pmu_apply_single_event_filter(struct kvm_vcpu *vcpu, u8 idx) +{ + u64 guest_counters; + u64 evtyper_set = ARMV8_PMU_EXCLUDE_EL0 | + ARMV8_PMU_EXCLUDE_EL1; + u64 evtyper_clr = ARMV8_PMU_INCLUDE_EL2; + bool guest_include_el2; + u64 val; + u64 evsel; + + guard(preempt)(); + + if (!kvm_pmu_part_on_cpu(vcpu)) + return; + + guest_counters = kvm_vcpu_pmu_guest_counter_mask(vcpu); + if (!test_bit(idx, (unsigned long *)&guest_counters)) + return; + + if (idx == ARMV8_PMU_CYCLE_IDX) { + val = __vcpu_sys_reg(vcpu, PMCCFILTR_EL0); + val &= kvm_pmu_evtyper_mask(vcpu->kvm) & + ~kvm_pmu_event_mask(vcpu->kvm); + evsel = ARMV8_PMUV3_PERFCTR_CPU_CYCLES; + } else { + val = __vcpu_sys_reg(vcpu, PMEVTYPER0_EL0 + idx); + val &= kvm_pmu_evtyper_mask(vcpu->kvm); + evsel = val & kvm_pmu_event_mask(vcpu->kvm); + } + + guest_include_el2 = (val & ARMV8_PMU_INCLUDE_EL2); + val &= ~evtyper_clr; + + if (unlikely(is_hyp_ctxt(vcpu))) { + u64 mdcr = __vcpu_sys_reg(vcpu, MDCR_EL2); + bool hpmd = (idx == ARMV8_PMU_CYCLE_IDX) ? + (mdcr & MDCR_EL2_HCCD) : + (!kvm_pmu_counter_is_hyp(vcpu, idx) && + (mdcr & MDCR_EL2_HPMD)); + + val &= ~ARMV8_PMU_EXCLUDE_NS_EL1; + if (guest_include_el2 && !hpmd) + val &= ~ARMV8_PMU_EXCLUDE_EL1; + else + val |= ARMV8_PMU_EXCLUDE_EL1; + } + + if (vcpu->kvm->arch.pmu_filter && + evsel != ARMV8_PMUV3_PERFCTR_SW_INCR && + evsel != ARMV8_PMUV3_PERFCTR_CHAIN && + !test_bit(evsel, vcpu->kvm->arch.pmu_filter)) { + val |= evtyper_set; + val &= ~(ARMV8_PMU_EXCLUDE_NS_EL0 | ARMV8_PMU_EXCLUDE_NS_EL1); + } + + if (idx == ARMV8_PMU_CYCLE_IDX) + write_pmccfiltr(val); + else + write_pmevtypern(idx, val); +} + /** * kvm_pmu_direct_reg_write() - Write a guest PMU register for Partitioned PMU * @vcpu: Pointer to vcpu struct @@ -281,6 +342,7 @@ void kvm_pmu_direct_reg_write(struct kvm_vcpu *vcpu, unsigned int reg, if (reg == PMCCFILTR_EL0) mask &= ~kvm_pmu_event_mask(vcpu->kvm); __vcpu_assign_sys_reg(vcpu, reg, val & mask); + kvm_pmu_apply_single_event_filter(vcpu, reg - PMEVTYPER0_EL0); break; case PMCNTENSET_EL0: val &= kvm_vcpu_pmu_guest_counter_mask(vcpu); @@ -345,6 +407,21 @@ u64 kvm_pmu_guest_counter_mask(void) return kvm_vcpu_pmu_guest_counter_mask(kvm_get_running_vcpu()); } +static void kvm_pmu_apply_event_filter(struct kvm_vcpu *vcpu) +{ + struct arm_pmu *pmu = vcpu->kvm->arch.arm_pmu; + unsigned long guest_counters; + u8 i; + + if (!pmu) + return; + + guest_counters = kvm_vcpu_pmu_guest_counter_mask(vcpu); + + for_each_set_bit(i, &guest_counters, ARMPMU_MAX_HWEVENTS) + kvm_pmu_apply_single_event_filter(vcpu, i); +} + /** * kvm_pmu_load() - Load untrapped PMU registers * @vcpu: Pointer to struct kvm_vcpu @@ -376,6 +453,7 @@ void kvm_pmu_load(struct kvm_vcpu *vcpu) } guest_counters = kvm_vcpu_pmu_guest_counter_mask(vcpu); + kvm_pmu_apply_event_filter(vcpu); for_each_set_bit(i, &guest_counters, ARMPMU_MAX_HWEVENTS) { val = __vcpu_sys_reg(vcpu, PMEVCNTR0_EL0 + i); -- 2.56.1.708.g77570a6a1d-goog