KVM: s390: Improve floating IRQ injection behavior
Janosch Frank
maintainerv5 cover KVM: s390: Improve floating IRQ injection behavior
Multiple fixes for the floating IRQ handling triggered by the firq kvm-unit-test sometimes failing for pv vms.
Only waking up cpus which are enabled, re-kicking after the instruction notification for pv cpus and a general redistribution of IRQs on entry (pending guidance from performance measurements).
The floating part of floating IRQs can make it difficult to make absolutely sure that an IRQ is actually delivered, especially if the OS doesn't regularly have the masks open. We might miss mask enablements if the intervention bits don't get set properly and the kicks might end up nowhere.
v5:
- Rebased on rc5
- Adjusted commit messages for first two patches (Christian)
- Moved opportunistic delivery into wait state handling (Christian)
v4:
- Replaced pv check with mask check which does not need locks
- Fixed bitnum to bitmask translations that Sashiko rightfully complained about
v3:
- Separated code into two patches
- Added a patch that fixes service injections for PV vms
- Added IRQ filtering and kick all if no cpu is enabled
- Fixed the IO pend type translation
v2:
- Rebase onto master
- Added IRQ type check before delivering
Janosch Frank (3):
KVM: s390: Improve floating IRQ injection behavior
KVM: s390: Kick PV cpus at the right time for service irqs
KVM: s390: Add opportunistic floating IRQ injection
arch/s390/include/asm/kvm_host_s390.h | 1 + arch/s390/kvm/s390/intercept.c | 9 ++ arch/s390/kvm/s390/interrupt.c | 156 ++++++++++++++++++++++---- arch/s390/kvm/s390/s390.c | 1 + arch/s390/kvm/s390/s390.h | 1 + 5 files changed, 147 insertions(+), 21 deletions(-)
Signature · 1 line
2.53.0
Janosch Frank
maintainerPATCH v5 1/3 KVM: s390: Improve floating IRQ injection behavior
Floating IRQs can be handled by any VCPU that opened its masks. The current design does not check if the mask is open when a floating IRQ is injected via the FLIC. It will wakeup the last VCPU that went sleeping hoping it's the correct one.
Improve this by checking if the VCPU can deliver that partiqular IRQ and if not try to find another VCPU which can take the IRQ.
This is not the final fix around this topic but we'll eventually inject a pending IRQ. The current code can easily deadlock a VM and with this fix we work around that.
--- arch/s390/kvm/s390/interrupt.c | 86 ++++++++++++++++++++++++++-------- 1 file changed, 66 insertions(+), 20 deletions(-)
arch/s390/kvm/s390/interrupt.c +66 -20
@@ -1918,49 +1918,93 @@ static int __inject_io(struct kvm *kvm, struct kvm_s390_interrupt_info *inti)return 0 ; } +static u64 inti_to_irq_pend_mask (u64 type,int isc) +{ +switch (type) { +case KVM_S390_MCHK : +/* Only repressible machine checks are floating */ +return BIT (IRQ_PEND_MCHK_REP ); +case KVM_S390_INT_VIRTIO : +return BIT (IRQ_PEND_VIRTIO ); +case KVM_S390_INT_SERVICE : +return BIT (IRQ_PEND_EXT_SERVICE ) | +BIT (IRQ_PEND_EXT_SERVICE_EV ); +case KVM_S390_INT_PFAULT_DONE : +return BIT (IRQ_PEND_PFAULT_DONE ); + case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX: +return BIT (isc_to_irq_type (isc)); +default : +return 0 ; + } +} + +/* +* Setup intervention masks to catch running vcpus that hopefully open +* their masks soonish and kick sleeping vcpus to motivate them to +* take IRQs. +*/ +static void vcpu_intervention_kick (struct kvm_vcpu *vcpu,u64 type) +{ +/* make the VCPU drop out of the SIE, or wake it up if sleeping */ +switch (type) { +case KVM_S390_MCHK : +kvm_s390_set_cpuflags (vcpu,CPUSTAT_STOP_INT ); +break ; + case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX: +if (!(type &KVM_S390_INT_IO_AI_MASK && + vcpu->kvm->arch.gisa_int.origin) || +kvm_s390_pv_cpu_get_handle (vcpu)) +kvm_s390_set_cpuflags (vcpu,CPUSTAT_IO_INT ); +break ; +default : +kvm_s390_set_cpuflags (vcpu,CPUSTAT_EXT_INT ); +break ; + } +kvm_s390_vcpu_wakeup (vcpu); +} +/* * Find a destination VCPU for a floating irq and kick it. */ -static void __floating_irq_kick (struct kvm *kvm,u64 type) +static void __floating_irq_kick (struct kvm *kvm,u64 type,int isc) {struct kvm_vcpu *dst_vcpu;int sigcpu, online_vcpus, nr_tries =0 ; +u64 irq_pend_mask; +unsigned long i; online_vcpus =atomic_read (&kvm->online_vcpus);if (!online_vcpus)return ; + irq_pend_mask =inti_to_irq_pend_mask (type, isc);for (sigcpu = kvm->arch.float_int.last_sleep_cpu; ; sigcpu++) { sigcpu %= online_vcpus; dst_vcpu =kvm_get_vcpu (kvm, sigcpu); -if (!is_vcpu_stopped (dst_vcpu)) +if (!is_vcpu_stopped (dst_vcpu) && +deliverable_irqs (dst_vcpu) & irq_pend_mask)break ;/* avoid endless loops if all vcpus are stopped */ -if (nr_tries++ >= online_vcpus) -return ; +if (nr_tries++ >= online_vcpus) { + dst_vcpu =NULL ; +break ; + } } -/* make the VCPU drop out of the SIE, or wake it up if sleeping */ -switch (type) { -case KVM_S390_MCHK : -kvm_s390_set_cpuflags (dst_vcpu,CPUSTAT_STOP_INT ); -break ; - case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX: -if (!(type &KVM_S390_INT_IO_AI_MASK && - kvm->arch.gisa_int.origin) || -kvm_s390_pv_cpu_get_handle (dst_vcpu)) -kvm_s390_set_cpuflags (dst_vcpu,CPUSTAT_IO_INT ); -break ; -default : -kvm_s390_set_cpuflags (dst_vcpu,CPUSTAT_EXT_INT ); -break ; +/* Nobody was enabled, time to wake all of them */ +if (!dst_vcpu) { +kvm_for_each_vcpu (i, dst_vcpu, kvm) +vcpu_intervention_kick (dst_vcpu, type); +return ; } -kvm_s390_vcpu_wakeup (dst_vcpu); + +vcpu_intervention_kick (dst_vcpu, type); }static int __inject_vm (struct kvm *kvm,struct kvm_s390_interrupt_info *inti) {u64 type =READ_ONCE (inti->type); +int isc =-1 ;int rc;switch (type) {
@@ -1977,6 +2021,8 @@ static int __inject_vm(struct kvm *kvm, struct kvm_s390_interrupt_info *inti) rc =__inject_pfault_done (kvm, inti);break ; case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX: +/* Grab isc here since __inject_io() might free inti */ + isc =int_word_to_isc (inti->io.io_int_word); rc =__inject_io (kvm, inti);break ;default :
@@ -1985,7 +2031,7 @@ static int __inject_vm(struct kvm *kvm, struct kvm_s390_interrupt_info *inti)if (rc)return rc; -__floating_irq_kick (kvm, type); +__floating_irq_kick (kvm, type, isc);return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewSashiko has reviewed this patch and found no issues. It looks great!
Quoted 5 lines
Floating IRQs can be handled by any VCPU that opened its masks. The current design does not check if the mask is open when a floating IRQ is injected via the FLIC. It will wakeup the last VCPU that went sleeping hoping it's the correct one.
Quoted 8 lines
Improve this by checking if the VCPU can deliver that partiqular IRQ and if not try to find another VCPU which can take the IRQ.
This is not the final fix around this topic but we'll eventually inject a pending IRQ. The current code can easily deadlock a VM and with this fix we work around that.
Signed-off-by Janosch Frank <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Janosch Frank
maintainerPATCH v5 2/3 KVM: s390: Kick PV cpus at the right time for service irqs
In reply to Janosch FrankService call handling is a two stage process for PV vms. First we receive the secure instruction intercept and then the secure instruction notification intercept.
The secure instruction intercept (104) is analogous to the non-pv instruction intercept (4) with the difference that we're not allowed to inject an IRQ when re-entering SIE. We have to wait for the notification intercept (108) which tells us that we're allowed to inject.
Unfortunately we never considered this difference and hence the IRQ injection code will try to kick on the secure instruction intercept where service IRQs are masked.
It's time to move the kick to the instruction notification and skip kicking on the instruction interception path.
--- arch/s390/kvm/s390/intercept.c | 9 ++++++ arch/s390/kvm/s390/interrupt.c | 50 ++++++++++++++++++++++++++++------ arch/s390/kvm/s390/s390.h | 1 + 3 files changed, 52 insertions(+), 8 deletions(-)
arch/s390/kvm/s390/intercept.c +9 -0
@@ -536,6 +536,15 @@ static int handle_pv_sclp(struct kvm_vcpu *vcpu)set_bit (IRQ_PEND_EXT_SERVICE , &fi->pending_irqs);clear_bit (IRQ_PEND_EXT_SERVICE , &fi->masked_irqs);spin_unlock_irqrestore (&fi->lock, flags); + +/* +* We missed the floating IRQ kick since we can only inject +* when we end up here and not when the irq was injected via +* the FLIC. +* +* Now that we have cleared the masking we can kick cpus. +*/ +kvm_s390_pv_sclp_kick (vcpu);return 0 ; }
arch/s390/kvm/s390/interrupt.c +42 -8
89 lines not on this page · raw message
arch/s390/kvm/s390/s390.h +1 -0
@@ -375,6 +375,7 @@ enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer);int __must_check kvm_s390_deliver_pending_interrupts (struct kvm_vcpu *vcpu);void kvm_s390_clear_local_irqs (struct kvm_vcpu *vcpu);void kvm_s390_clear_float_irqs (struct kvm *kvm); +void kvm_s390_pv_sclp_kick (struct kvm_vcpu *vcpu);int __must_check kvm_s390_inject_vm (struct kvm *kvm,struct kvm_s390_interrupt *s390int,struct kvm_s390_interrupt_info *inti);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v5 2/3] KVM: s390: Kick PV cpus at the right time for service irqs
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 10 lines
Service call handling is a two stage process for PV vms. First we receive the secure instruction intercept and then the secure instruction notification intercept.
The secure instruction intercept (104) is analogous to the non-pv instruction intercept (4) with the difference that we're not allowed to inject an IRQ when re-entering SIE. We have to wait for the notification intercept (108) which tells us that we're allowed to inject.
Quoted 8 lines
Unfortunately we never considered this difference and hence the IRQ injection code will try to kick on the secure instruction intercept where service IRQs are masked.
It's time to move the kick to the instruction notification and skip kicking on the instruction interception path.
Signed-off-by Janosch Frank <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Janosch Frank
maintainerPATCH v5 3/3 KVM: s390: Add opportunistic floating IRQ delivery
In reply to Janosch FrankTry to distribute floating IRQs which haven't been taken by a VCPU yet to sleeping VCPUs. This lowers the risk of floating IRQs not being delivered.
--- arch/s390/include/asm/kvm_host_s390.h | 1 + arch/s390/kvm/s390/interrupt.c | 34 +++++++++++++++++++++++++++ arch/s390/kvm/s390/s390.c | 1 + 3 files changed, 36 insertions(+)
arch/s390/include/asm/kvm_host_s390.h +1 -0
@@ -412,6 +412,7 @@ struct kvm_vm_stat {u64 gmap_shadow_r3_entry;u64 gmap_shadow_sg_entry;u64 gmap_shadow_pg_entry; +u64 inject_redist; };struct kvm_arch_memory_slot {
arch/s390/kvm/s390/interrupt.c +34 -0
@@ -372,6 +372,38 @@ static unsigned long deliverable_irqs(struct kvm_vcpu *vcpu)return active_mask; } +static void distribute_float_irqs (struct kvm *kvm) +{ +struct kvm_vcpu *dst_vcpu; +int sigcpu, online_vcpus; + +if (!READ_ONCE (kvm->arch.float_int.pending_irqs)) +return ; + + online_vcpus =atomic_read (&kvm->online_vcpus); + +/* +* Not too worried about synchronization for idle_mask. We +* might burn too many cycles but apart from that waking a +* vcpu is not harmful. +*/ + sigcpu =find_first_bit (kvm->arch.idle_mask, online_vcpus); + +/* Well nobody's sleeping so someone will likely take the IRQ soon */ +if (sigcpu == online_vcpus) +return ; + +do { + dst_vcpu =kvm_get_vcpu (kvm, sigcpu); +if (deliverable_irqs (dst_vcpu)) { + kvm->stat.inject_redist++; +kvm_s390_vcpu_wakeup (dst_vcpu); +break ; + } + sigcpu =find_next_bit (kvm->arch.idle_mask, online_vcpus, ++sigcpu); + }while (sigcpu < online_vcpus); +} +static void __set_cpu_idle (struct kvm_vcpu *vcpu) {kvm_s390_set_cpuflags (vcpu,CPUSTAT_WAIT );
@@ -1294,6 +1326,8 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)if (!sltime)return 0 ; +distribute_float_irqs (vcpu->kvm); +__set_cpu_idle (vcpu);hrtimer_start (&vcpu->arch.ckc_timer, sltime,HRTIMER_MODE_REL );VCPU_EVENT (vcpu,4 ,"enabled wait: %llu ns" , sltime);
arch/s390/kvm/s390/s390.c +1 -0
@@ -87,6 +87,7 @@ const struct kvm_stats_desc kvm_vm_stats_desc[] = {STATS_DESC_COUNTER (VM , gmap_shadow_r3_entry),STATS_DESC_COUNTER (VM , gmap_shadow_sg_entry),STATS_DESC_COUNTER (VM , gmap_shadow_pg_entry), + STATS_DESC_COUNTER(VM, inject_redist), }; const struct kvm_stats_header kvm_vm_stats_header = {
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v5 3/3] KVM: s390: Add opportunistic floating IRQ delivery
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] kvm: s390: timer-less wait bypasses floating IRQ distribution --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] kvm: s390: timer-less wait bypasses floating IRQ distribution
--
commit f14594a6a744fbc4a4f3602b18d73cbd397d4076
Author: Janosch Frank <[email protected]>
KVM: s390: Add opportunistic floating IRQ delivery
This commit attempts to distribute floating IRQs which haven't been taken by a vCPU yet to sleeping vCPUs. This lowers the risk of floating IRQs not being delivered.
Quoted 4 lines
arch/s390/kvm/s390/interrupt.c +0
-0
[ ... ]
arch/s390/kvm/s390/interrupt.c int kvm_s390_handle_wait(struct kvm_vcpu *vcpu) · line 1333
Quoted 9 lines
arch/s390/kvm/s390/interrupt.c +2
-0@@ -1294,6 +1326,8 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)if (!sltime)return 0 ; +distribute_float_irqs (vcpu->kvm); +__set_cpu_idle (vcpu);hrtimer_start (&vcpu->arch.ckc_timer, sltime,HRTIMER_MODE_REL );VCPU_EVENT (vcpu,4 ,"enabled wait: %llu ns" , sltime);
[Severity: High]
Does this bypass distribute_float_irqs() when a guest enters an enabled wait state with clock comparator and CPU timer interrupts disabled?
If a guest disables timer interrupts and enters a wait state, it appears kvm_s390_handle_wait() jumps directly to the no_timer label:
arch/s390/kvm/s390/interrupt.c:kvm_s390_handle_wait() {
...
if (!ckc_interrupts_enabled(vcpu) &&
!cpu_timer_interrupts_enabled(vcpu)) {
VCPU_EVENT(vcpu, 3, "%s", "enabled wait w/o timer");
__set_cpu_idle(vcpu);
goto no_timer;
}
sltime = __calculate_sltime(vcpu);
if (!sltime)
return 0;
distribute_float_irqs(vcpu->kvm);
__set_cpu_idle(vcpu);
hrtimer_start(&vcpu->arch.ckc_timer, sltime, HRTIMER_MODE_REL);
VCPU_EVENT(vcpu, 4, "enabled wait: %llu ns", sltime);
no_timer:
...
}Because the goto completely bypasses the newly added distribute_float_irqs() call, any pending floating IRQs that this vCPU cannot deliver might remain undelivered when the current vCPU goes to sleep. Could this lead to guest stalls or deadlocks?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3