KVM: arm64: Simplify userspace notification of interrupt state

The userspace notification of interrupts is has a few problems:

- it is utterly pointless

- it is annoyingly split between detecting the need for notification
  and the population of the interrupts in the run structure

We can't do anything about the former (yet), but the latter can be
addressed. If we detect that we must notify userspace, we know that
we are going to exit, as we populate the exit status. Which means
we can also populate the interrupt state at this stage and be done
with it.

This simplifies the structure of the code.

Reviewed-by: Oliver Upton <oupton@kernel.org>
Link: https://patch.msgid.link/20260520100200.543845-3-maz@kernel.org
Signed-off-by: Marc Zyngier <maz@kernel.org>

diff --git a/arch/arm64/kvm/arch_timer.c b/arch/arm64/kvm/arch_timer.c
index d8add34717f07191afd3b1b2f8f1f3978bdc51b0..7236dd6a99e67b50e6e5c73fb07e3d1e8ce2f2c1 100644 (file)
--- a/arch/arm64/kvm/arch_timer.c
+++ b/arch/arm64/kvm/arch_timer.c
@@ -404,22 +404,30 @@ int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
        return vcpu_has_wfit_active(vcpu) && wfit_delay_ns(vcpu) == 0;
 }
 
+static u64 kvm_timer_needs_notify(struct kvm_vcpu *vcpu)
+{
+       u64 v = vcpu->run->s.regs.device_irq_level;
+
+       v ^= kvm_timer_pending(vcpu_vtimer(vcpu)) ? KVM_ARM_DEV_EL1_VTIMER : 0;
+       v ^= kvm_timer_pending(vcpu_ptimer(vcpu)) ? KVM_ARM_DEV_EL1_PTIMER : 0;
+
+       return v & (KVM_ARM_DEV_EL1_VTIMER | KVM_ARM_DEV_EL1_PTIMER);
+}
+
+bool kvm_timer_should_notify_user(struct kvm_vcpu *vcpu)
+{
+       return !!kvm_timer_needs_notify(vcpu);
+}
+
 /*
  * Reflect the timer output level into the kvm_run structure
  */
-void kvm_timer_update_run(struct kvm_vcpu *vcpu)
+bool kvm_timer_update_run(struct kvm_vcpu *vcpu)
 {
-       struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
-       struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
-       struct kvm_sync_regs *regs = &vcpu->run->s.regs;
-
-       /* Populate the device bitmap with the timer states */
-       regs->device_irq_level &= ~(KVM_ARM_DEV_EL1_VTIMER |
-                                   KVM_ARM_DEV_EL1_PTIMER);
-       if (kvm_timer_pending(vtimer))
-               regs->device_irq_level |= KVM_ARM_DEV_EL1_VTIMER;
-       if (kvm_timer_pending(ptimer))
-               regs->device_irq_level |= KVM_ARM_DEV_EL1_PTIMER;
+       u64 mask = kvm_timer_needs_notify(vcpu);
+       if (mask)
+               vcpu->run->s.regs.device_irq_level ^= mask;
+       return !!mask;
 }
 
 static void kvm_timer_update_status(struct arch_timer_context *ctx, bool level)
@@ -903,23 +911,6 @@ void kvm_timer_vcpu_load(struct kvm_vcpu *vcpu)
        timer_set_traps(vcpu, &map);
 }
 
-bool kvm_timer_should_notify_user(struct kvm_vcpu *vcpu)
-{
-       struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
-       struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
-       struct kvm_sync_regs *sregs = &vcpu->run->s.regs;
-       bool vlevel, plevel;
-
-       if (likely(irqchip_in_kernel(vcpu->kvm)))
-               return false;
-
-       vlevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_VTIMER;
-       plevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_PTIMER;
-
-       return kvm_timer_pending(vtimer) != vlevel ||
-              kvm_timer_pending(ptimer) != plevel;
-}
-
 void kvm_timer_vcpu_put(struct kvm_vcpu *vcpu)
 {
        struct arch_timer_cpu *timer = vcpu_timer(vcpu);

diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index 8bb2c7422cc8b0ad1c6952047cbb878af57fcaca..6e6dc17f8b606af22086c11ee8d16c86b097f245 100644 (file)
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -1163,6 +1163,15 @@ static bool vcpu_mode_is_bad_32bit(struct kvm_vcpu *vcpu)
        return !kvm_supports_32bit_el0();
 }
 
+static bool kvm_irq_update_run(struct kvm_vcpu *vcpu)
+{
+       bool r;
+
+       r  = kvm_timer_update_run(vcpu);
+       r |= kvm_pmu_update_run(vcpu);
+       return r;
+}
+
 /**
  * kvm_vcpu_exit_request - returns true if the VCPU should *not* enter the guest
  * @vcpu:      The VCPU pointer
@@ -1184,13 +1193,11 @@ static bool kvm_vcpu_exit_request(struct kvm_vcpu *vcpu, int *ret)
        /*
         * If we're using a userspace irqchip, then check if we need
         * to tell a userspace irqchip about timer or PMU level
-        * changes and if so, exit to userspace (the actual level
-        * state gets updated in kvm_timer_update_run and
-        * kvm_pmu_update_run below).
+        * changes and if so, exit to userspace while updating the run
+        * state.
         */
        if (unlikely(!irqchip_in_kernel(vcpu->kvm))) {
-               if (kvm_timer_should_notify_user(vcpu) ||
-                   kvm_pmu_should_notify_user(vcpu)) {
+               if (unlikely(kvm_irq_update_run(vcpu))) {
                        *ret = -EINTR;
                        run->exit_reason = KVM_EXIT_INTR;
                        return true;
@@ -1405,11 +1412,8 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
                ret = handle_exit(vcpu, ret);
        }
 
-       /* Tell userspace about in-kernel device output levels */
-       if (unlikely(!irqchip_in_kernel(vcpu->kvm))) {
-               kvm_timer_update_run(vcpu);
-               kvm_pmu_update_run(vcpu);
-       }
+       if (unlikely(!irqchip_in_kernel(vcpu->kvm)))
+               kvm_irq_update_run(vcpu);
 
        kvm_sigset_deactivate(vcpu);
 

diff --git a/arch/arm64/kvm/pmu-emul.c b/arch/arm64/kvm/pmu-emul.c
index e1860acae641fa2f6da711898355a6be1e0a7c36..31a472a2c4881eff8a852c429e27259e6e2cc223 100644 (file)
--- a/arch/arm64/kvm/pmu-emul.c
+++ b/arch/arm64/kvm/pmu-emul.c
@@ -413,27 +413,21 @@ static void kvm_pmu_update_state(struct kvm_vcpu *vcpu)
 
 bool kvm_pmu_should_notify_user(struct kvm_vcpu *vcpu)
 {
-       struct kvm_pmu *pmu = &vcpu->arch.pmu;
        struct kvm_sync_regs *sregs = &vcpu->run->s.regs;
        bool run_level = sregs->device_irq_level & KVM_ARM_DEV_PMU;
 
-       if (likely(irqchip_in_kernel(vcpu->kvm)))
-               return false;
-
-       return pmu->irq_level != run_level;
+       return kvm_pmu_overflow_status(vcpu) != run_level;
 }
 
 /*
  * Reflect the PMU overflow interrupt output level into the kvm_run structure
  */
-void kvm_pmu_update_run(struct kvm_vcpu *vcpu)
+bool kvm_pmu_update_run(struct kvm_vcpu *vcpu)
 {
-       struct kvm_sync_regs *regs = &vcpu->run->s.regs;
-
-       /* Populate the timer bitmap for user space */
-       regs->device_irq_level &= ~KVM_ARM_DEV_PMU;
-       if (vcpu->arch.pmu.irq_level)
-               regs->device_irq_level |= KVM_ARM_DEV_PMU;
+       bool update = kvm_pmu_should_notify_user(vcpu);
+       if (update)
+               vcpu->run->s.regs.device_irq_level ^= KVM_ARM_DEV_PMU;
+       return update;
 }
 
 /**

diff --git a/include/kvm/arm_arch_timer.h b/include/kvm/arm_arch_timer.h
index bf8cc9589bd095ae89186f66007a7b5a7be9e058..9e4076eebd29fcc02d1507d0161878a6b90b2fac 100644 (file)
--- a/include/kvm/arm_arch_timer.h
+++ b/include/kvm/arm_arch_timer.h
@@ -104,7 +104,7 @@ void kvm_timer_vcpu_init(struct kvm_vcpu *vcpu);
 void kvm_timer_sync_nested(struct kvm_vcpu *vcpu);
 void kvm_timer_sync_user(struct kvm_vcpu *vcpu);
 bool kvm_timer_should_notify_user(struct kvm_vcpu *vcpu);
-void kvm_timer_update_run(struct kvm_vcpu *vcpu);
+bool kvm_timer_update_run(struct kvm_vcpu *vcpu);
 void kvm_timer_vcpu_terminate(struct kvm_vcpu *vcpu);
 
 void kvm_timer_init_vm(struct kvm *kvm);

diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h
index 0a36a3d5c8944df15b09e4633c61e36db739bda8..3e844c5ee91747b059c19fbe2b1442001e7d9aff 100644 (file)
--- a/include/kvm/arm_pmu.h
+++ b/include/kvm/arm_pmu.h
@@ -54,7 +54,7 @@ void kvm_pmu_reprogram_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);
-void kvm_pmu_update_run(struct kvm_vcpu *vcpu);
+bool kvm_pmu_update_run(struct kvm_vcpu *vcpu);
 void kvm_pmu_software_increment(struct kvm_vcpu *vcpu, u64 val);
 void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val);
 void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu, u64 data,
@@ -131,7 +131,7 @@ static inline bool kvm_pmu_should_notify_user(struct kvm_vcpu *vcpu)
 {
        return false;
 }
-static inline void kvm_pmu_update_run(struct kvm_vcpu *vcpu) {}
+static inline bool kvm_pmu_update_run(struct kvm_vcpu *vcpu) { return false; }
 static inline void kvm_pmu_software_increment(struct kvm_vcpu *vcpu, u64 val) {}
 static inline void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val) {}
 static inline void kvm_pmu_set_counter_event_type(struct kvm_vcpu *vcpu,