Evaluate whether any enabled and unmasked guest counter has overflowed in kvm_pmu_part_overflow_status() so KVM updates the virtual PMU interrupt level in the vGIC (or userspace IRQ state) across VM entries and host PMU overflow interrupts: - Harvest any live guest overflow bits from physical pmovsset_el0 into shadow PMOVSSET_EL0 and clear them in hardware when the partitioned PMU is loaded on the local CPU. - Check (PMOVSSET_EL0 & PMINTENSET_EL1) against PMCR_EL0.E for guest counters 0..HPMN-1 and PMCCNTR_EL0, and against MDCR_EL2.HPME for nested hypervisor counters HPMN..N-1. - In kvm_pmu_handle_guest_irq(), raise KVM_REQ_IRQ_PENDING and kick the vCPU (or queue overflow_work when running in NMI context) when an unmasked guest overflow occurs. Signed-off-by: Colton Lewis --- arch/arm64/kvm/pmu-direct.c | 65 +++++++++++++++++++++++++++++++++++++ arch/arm64/kvm/pmu-emul.c | 4 +-- arch/arm64/kvm/pmu.c | 8 +++++ include/kvm/arm_pmu.h | 2 ++ 4 files changed, 77 insertions(+), 2 deletions(-) diff --git a/arch/arm64/kvm/pmu-direct.c b/arch/arm64/kvm/pmu-direct.c index 21357decce214..b0491d32b5d7b 100644 --- a/arch/arm64/kvm/pmu-direct.c +++ b/arch/arm64/kvm/pmu-direct.c @@ -823,6 +823,71 @@ void kvm_pmu_handle_guest_irq(u64 pmovsr) return; __vcpu_rmw_sys_reg(vcpu, PMOVSSET_EL0, |=, govf); + + if (kvm_pmu_part_overflow_status(vcpu)) { + kvm_make_request(KVM_REQ_IRQ_PENDING, vcpu); + + if (!in_nmi()) + kvm_vcpu_kick(vcpu); + else + irq_work_queue(&vcpu->arch.pmu.overflow_work); + } +} + +/** + * kvm_pmu_part_overflow_status() - Determine if any guest counters have overflowed + * @vcpu: Pointer to struct kvm_vcpu + * + * Determine if any guest counters have overflowed and therefore an + * IRQ needs to be injected into the guest. If an overflow is detected + * while access is VCPU_PMU_ACCESS_FREE (for example, after state + * restoration via KVM_SET_ONE_REG), transition the vCPU to + * VCPU_PMU_ACCESS_GUEST_OWNED. + * + * Return: True if there was an overflow, false otherwise + */ +bool kvm_pmu_part_overflow_status(struct kvm_vcpu *vcpu) +{ + u64 mask = kvm_vcpu_pmu_guest_counter_mask(vcpu); + u64 hyp_mask = kvm_pmu_hyp_counter_mask(vcpu); + u64 pmovs, pmint, pmcr, reg; + unsigned long flags; + bool overflow; + + local_irq_save(flags); + if (vcpu->arch.pmu.loaded_on_cpu && + vcpu == kvm_get_running_vcpu()) { + u64 hw_ovf = read_sysreg(pmovsset_el0) & mask; + + if (hw_ovf) { + __vcpu_rmw_sys_reg(vcpu, PMOVSSET_EL0, |=, hw_ovf); + write_sysreg(hw_ovf, pmovsclr_el0); + } + pmint = read_pmintenset(); + pmcr = read_pmcr(); + } else { + pmint = __vcpu_sys_reg(vcpu, PMINTENSET_EL1); + pmcr = __vcpu_sys_reg(vcpu, PMCR_EL0); + } + + pmovs = __vcpu_sys_reg(vcpu, PMOVSSET_EL0); + local_irq_restore(flags); + + reg = pmovs & pmint & mask; + if (!(pmcr & ARMV8_PMU_PMCR_E)) + reg &= hyp_mask; + if (hyp_mask && !(__vcpu_sys_reg(vcpu, MDCR_EL2) & MDCR_EL2_HPME)) + reg &= ~hyp_mask; + + overflow = !!reg; + + if (overflow && !in_interrupt() && + kvm_pmu_get_access(vcpu) == VCPU_PMU_ACCESS_FREE) { + scoped_guard(preempt) + kvm_pmu_set_guest_owned(vcpu); + } + + return overflow; } /** diff --git a/arch/arm64/kvm/pmu-emul.c b/arch/arm64/kvm/pmu-emul.c index da66162c68042..a72bdc5a0b3ea 100644 --- a/arch/arm64/kvm/pmu-emul.c +++ b/arch/arm64/kvm/pmu-emul.c @@ -268,7 +268,7 @@ void kvm_pmu_reprogram_counter_mask(struct kvm_vcpu *vcpu, u64 val) * counter where the values of the global enable control, PMOVSSET_EL0[n], and * PMINTENSET_EL1[n] are all 1. */ -bool kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) +bool kvm_pmu_emul_overflow_status(struct kvm_vcpu *vcpu) { u64 reg = __vcpu_sys_reg(vcpu, PMOVSSET_EL0); @@ -400,7 +400,7 @@ static void kvm_pmu_perf_overflow(struct perf_event *perf_event, kvm_pmu_counter_increment(vcpu, BIT(idx + 1), ARMV8_PMUV3_PERFCTR_CHAIN); - if (kvm_pmu_overflow_status(vcpu)) { + if (kvm_pmu_emul_overflow_status(vcpu)) { kvm_make_request(KVM_REQ_IRQ_PENDING, vcpu); if (!in_nmi()) diff --git a/arch/arm64/kvm/pmu.c b/arch/arm64/kvm/pmu.c index 7389d61957fa9..9d4ad4b7bd8d5 100644 --- a/arch/arm64/kvm/pmu.c +++ b/arch/arm64/kvm/pmu.c @@ -409,6 +409,14 @@ u64 kvm_pmu_evtyper_mask(struct kvm *kvm) return mask; } +bool kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) +{ + if (kvm_pmu_is_partitioned(vcpu->kvm)) + return kvm_pmu_part_overflow_status(vcpu); + + return kvm_pmu_emul_overflow_status(vcpu); +} + static void kvm_pmu_update_state(struct kvm_vcpu *vcpu) { struct kvm_pmu *pmu = &vcpu->arch.pmu; diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h index 9800514019630..fcd8e6331943e 100644 --- a/include/kvm/arm_pmu.h +++ b/include/kvm/arm_pmu.h @@ -91,6 +91,8 @@ bool kvm_set_pmuserenr(u64 val); void kvm_vcpu_pmu_restore_guest(struct kvm_vcpu *vcpu); void kvm_vcpu_pmu_restore_host(struct kvm_vcpu *vcpu); void kvm_vcpu_pmu_resync_el0(void); +bool kvm_pmu_emul_overflow_status(struct kvm_vcpu *vcpu); +bool kvm_pmu_part_overflow_status(struct kvm_vcpu *vcpu); #define kvm_vcpu_has_pmu(vcpu) \ (vcpu_has_feature(vcpu, KVM_ARM_VCPU_PMU_V3)) -- 2.56.1.708.g77570a6a1d-goog