| Message ID | 20240228072216.95130-3-yaoma@linux.alibaba.com (mailing list archive) |
|---|---|
| State | Not Applicable |
| Headers | show |
| Series | *** Detect interrupt storm in softlockup *** | expand |
Hi, On Tue, Feb 27, 2024 at 11:22 PM Bitao Hu <yaoma@linux.alibaba.com> wrote: > > The soft lockup detector lacks a mechanism to identify interrupt storms > as root cause of a lockup. To enable this the detector needs a > mechanism to snapshot the interrupt count statistics on a CPU when the > detector observes a potential lockup scenario and compare that against > the interrupt count when it warns about the lockup later on. The number > of interrupts in that period give a hint whether the lockup might be > caused by an interrupt storm. > > Instead of having extra storage in the lockup detector and accessing > the internals of the interrupt descriptor directly, convert the per CPU > irq_desc::kstat_irq member to a data structure which contains the > counter plus a snapshot member and provide interfaces to take a > snapshot of all interrupts on the current CPU and to retrieve the delta > of a specific interrupt later on. > > Originally-by: Thomas Gleixner <tglx@linutronix.de> > Signed-off-by: Bitao Hu <yaoma@linux.alibaba.com> > Reviewed-by: Liu Song <liusong@linux.alibaba.com> > --- > arch/mips/dec/setup.c | 2 +- > arch/parisc/kernel/smp.c | 2 +- > arch/powerpc/kvm/book3s_hv_rm_xics.c | 2 +- > include/linux/irqdesc.h | 14 ++++++++++-- > include/linux/kernel_stat.h | 3 +++ > kernel/irq/internals.h | 2 +- > kernel/irq/irqdesc.c | 34 ++++++++++++++++++++++------ > kernel/irq/proc.c | 5 ++-- > scripts/gdb/linux/interrupts.py | 6 ++--- > 9 files changed, 51 insertions(+), 19 deletions(-) I won't insist on it, but I continue to worry about memory implications with large numbers of CPUs. With a 4-byte int, 8192 max CPUs, and 100 IRQs the extra "ref" value takes up over 3MB of memory (8192 * 4 bytes * 100). Technically, you could add a new symbol like "config NEED_IRQ_SNAPSHOTS". This wouldn't be a symbol selectable by the end user but would automatically be selected by "config SOFTLOCKUP_DETECTOR_INTR_STORM". If the config wasn't defined then the struct wouldn't contain "ref" and the snapshot routines would just be static inline stubs. Maybe Thomas has an opinion about whether this is something to worry about. Worst case it wouldn't be hard to do in a follow-up patch. Everything else looks good to me. Given that I'm not insisting on adding the extra CONFIG, I'm OK w/: Reviewed-by: Douglas Anderson <dianders@chromium.org>
Doug! On Wed, Feb 28 2024 at 14:44, Doug Anderson wrote: > I won't insist on it, but I continue to worry about memory > implications with large numbers of CPUs. With a 4-byte int, 8192 max > CPUs, and 100 IRQs the extra "ref" value takes up over 3MB of memory > (8192 * 4 bytes * 100). > > Technically, you could add a new symbol like "config > NEED_IRQ_SNAPSHOTS". This wouldn't be a symbol selectable by the end > user but would automatically be selected by "config > SOFTLOCKUP_DETECTOR_INTR_STORM". If the config wasn't defined then the > struct wouldn't contain "ref" and the snapshot routines would just be > static inline stubs. > > Maybe Thomas has an opinion about whether this is something to worry > about. Worst case it wouldn't be hard to do in a follow-up patch. I'd say it makes sense to give people a choice to save memory especially when the softlock detector code is not enabled. It's rather straight forward to do. Thanks, tglx --- --- a/include/linux/irqdesc.h +++ b/include/linux/irqdesc.h @@ -24,7 +24,9 @@ struct pt_regs; */ struct irqstat { unsigned int cnt; +#ifdef CONFIG_GENIRQ_STAT_SNAPSHOT unsigned int ref; +#endif }; /** --- a/kernel/irq/irqdesc.c +++ b/kernel/irq/irqdesc.c @@ -978,6 +978,7 @@ static unsigned int kstat_irqs(unsigned return sum; } +#ifdef CONFIG_GENIRQ_STAT_SNAPSHOT void kstat_snapshot_irqs(void) { struct irq_desc *desc; @@ -998,6 +999,7 @@ unsigned int kstat_get_irq_since_snapsho return 0; return this_cpu_read(desc->kstat_irqs->cnt) - this_cpu_read(desc->kstat_irqs->ref); } +#endif /** * kstat_irqs_usr - Get the statistics for an interrupt from thread context --- a/kernel/irq/Kconfig +++ b/kernel/irq/Kconfig @@ -108,6 +108,10 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR config GENERIC_IRQ_RESERVATION_MODE bool +# Snapshot for interrupt statistics +config GENERIC_IRQ_STAT_SNAPSHOT + bool + # Support forced irq threading config IRQ_FORCED_THREADING bool
Hi, On 2024/3/2 03:22, Thomas Gleixner wrote: > Doug! > > On Wed, Feb 28 2024 at 14:44, Doug Anderson wrote: >> I won't insist on it, but I continue to worry about memory >> implications with large numbers of CPUs. With a 4-byte int, 8192 max >> CPUs, and 100 IRQs the extra "ref" value takes up over 3MB of memory >> (8192 * 4 bytes * 100). >> >> Technically, you could add a new symbol like "config >> NEED_IRQ_SNAPSHOTS". This wouldn't be a symbol selectable by the end >> user but would automatically be selected by "config >> SOFTLOCKUP_DETECTOR_INTR_STORM". If the config wasn't defined then the >> struct wouldn't contain "ref" and the snapshot routines would just be >> static inline stubs. >> >> Maybe Thomas has an opinion about whether this is something to worry >> about. Worst case it wouldn't be hard to do in a follow-up patch. > > I'd say it makes sense to give people a choice to save memory especially > when the softlock detector code is not enabled. > > It's rather straight forward to do. > > Thanks, > > tglx > --- > --- a/include/linux/irqdesc.h > +++ b/include/linux/irqdesc.h > @@ -24,7 +24,9 @@ struct pt_regs; > */ > struct irqstat { > unsigned int cnt; > +#ifdef CONFIG_GENIRQ_STAT_SNAPSHOT > unsigned int ref; > +#endif > }; > > /** > --- a/kernel/irq/irqdesc.c > +++ b/kernel/irq/irqdesc.c > @@ -978,6 +978,7 @@ static unsigned int kstat_irqs(unsigned > return sum; > } > > +#ifdef CONFIG_GENIRQ_STAT_SNAPSHOT > void kstat_snapshot_irqs(void) > { > struct irq_desc *desc; > @@ -998,6 +999,7 @@ unsigned int kstat_get_irq_since_snapsho > return 0; > return this_cpu_read(desc->kstat_irqs->cnt) - this_cpu_read(desc->kstat_irqs->ref); > } > +#endif > > /** > * kstat_irqs_usr - Get the statistics for an interrupt from thread context > --- a/kernel/irq/Kconfig > +++ b/kernel/irq/Kconfig > @@ -108,6 +108,10 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR > config GENERIC_IRQ_RESERVATION_MODE > bool > > +# Snapshot for interrupt statistics > +config GENERIC_IRQ_STAT_SNAPSHOT > + bool > + > # Support forced irq threading > config IRQ_FORCED_THREADING > bool I think we should follow Douglas's suggestion by making "config GENERIC_IRQ_STAT_SNAPSHOT" automatically selectable by "config SOFTLOCKUP_DETECTOR_INTR_STORM". This can prevent users from inadvertently disabling "config GENERIC_IRQ_STAT_SNAPSHOT" while enabling "config SOFTLOCKUP_DETECTOR_INTR_STORM". Best Regards, Bitao Hu diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig index 2531f3496ab6..9cf3b2d4c2a8 100644 --- a/kernel/irq/Kconfig +++ b/kernel/irq/Kconfig @@ -108,6 +108,15 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR config GENERIC_IRQ_RESERVATION_MODE bool +# Snapshot for interrupt statistics +config GENERIC_IRQ_STAT_SNAPSHOT + bool + help + + Say Y here to enable the kernel to provide a snapshot mechanism + for interrupt statistics. + + # Support forced irq threading config IRQ_FORCED_THREADING bool diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 49f652674bd8..899b69fcb598 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1032,6 +1032,7 @@ config SOFTLOCKUP_DETECTOR config SOFTLOCKUP_DETECTOR_INTR_STORM bool "Detect Interrupt Storm in Soft Lockups" depends on SOFTLOCKUP_DETECTOR && IRQ_TIME_ACCOUNTING + select GENERIC_IRQ_STAT_SNAPSHOT default y if NR_CPUS <= 128 help Say Y here to enable the kernel to detect interrupt storm
On Mon, Mar 04 2024 at 20:00, Bitao Hu wrote: >> +# Snapshot for interrupt statistics >> +config GENERIC_IRQ_STAT_SNAPSHOT >> + bool >> + >> # Support forced irq threading >> config IRQ_FORCED_THREADING >> bool > > I think we should follow Douglas's suggestion by making > "config GENERIC_IRQ_STAT_SNAPSHOT" automatically selectable by > "config SOFTLOCKUP_DETECTOR_INTR_STORM". This can prevent users > from inadvertently disabling "config GENERIC_IRQ_STAT_SNAPSHOT" > while enabling "config SOFTLOCKUP_DETECTOR_INTR_STORM". The above is not even configurable by the user. It's only selectable by some other config option. > +# Snapshot for interrupt statistics > +config GENERIC_IRQ_STAT_SNAPSHOT > + bool > + help > + > + Say Y here to enable the kernel to provide a snapshot mechanism > + for interrupt statistics. That makes is visible which is pointless because it's only relevant when there is an actual user. Thanks, tglx
Hi, On 2024/3/4 22:24, Thomas Gleixner wrote: > The above is not even configurable by the user. It's only selectable by > some other config option. > >> +# Snapshot for interrupt statistics >> +config GENERIC_IRQ_STAT_SNAPSHOT >> + bool >> + help >> + >> + Say Y here to enable the kernel to provide a snapshot mechanism >> + for interrupt statistics. > > That makes is visible which is pointless because it's only relevant when > there is an actual user. I guess I may have misunderstood your intentions earlier. Initially, I thought you were suggesting that when "SOFTLOCKUP_DETECTOR_INTR_STORM" is not enabled, people should be able to choose "GENERIC_IRQ_STAT_SNAPSHOT" through menuconfig, so I attempted to make "GENERIC_IRQ_STAT_SNAPSHOT" visible to the user. However, after analyzing the previous emails, it seems that what you were actually proposing was to directly disable "GENERIC_IRQ_STAT_SNAPSHOT" when "SOFTLOCKUP_DETECTOR_INTR_STORM" is not enabled, as a way to save memory. If my current understanding is correct, then the code for that part would look something like the following. Does this align with your expectations? Best Regards, Bitao Hu diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig index 2531f3496ab6..a28e5ac5fc79 100644 --- a/kernel/irq/Kconfig +++ b/kernel/irq/Kconfig @@ -108,6 +108,10 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR config GENERIC_IRQ_RESERVATION_MODE bool +# Snapshot for interrupt statistics +config GENERIC_IRQ_STAT_SNAPSHOT + bool + # Support forced irq threading config IRQ_FORCED_THREADING bool diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 49f652674bd8..899b69fcb598 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1032,6 +1032,7 @@ config SOFTLOCKUP_DETECTOR config SOFTLOCKUP_DETECTOR_INTR_STORM bool "Detect Interrupt Storm in Soft Lockups" depends on SOFTLOCKUP_DETECTOR && IRQ_TIME_ACCOUNTING + select GENERIC_IRQ_STAT_SNAPSHOT default y if NR_CPUS <= 128 help Say Y here to enable the kernel to detect interrupt storm
On Tue, Mar 05 2024 at 18:57, Bitao Hu wrote: > On 2024/3/4 22:24, Thomas Gleixner wrote: > "GENERIC_IRQ_STAT_SNAPSHOT" visible to the user. However, after > analyzing the previous emails, it seems that what you were actually > proposing was to directly disable "GENERIC_IRQ_STAT_SNAPSHOT" when > "SOFTLOCKUP_DETECTOR_INTR_STORM" is not enabled, as a way to save > memory. If my current understanding is correct, then the code for that > part would look something like the following. Correct. > diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig > index 2531f3496ab6..a28e5ac5fc79 100644 > --- a/kernel/irq/Kconfig > +++ b/kernel/irq/Kconfig > @@ -108,6 +108,10 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR > config GENERIC_IRQ_RESERVATION_MODE > bool > > +# Snapshot for interrupt statistics > +config GENERIC_IRQ_STAT_SNAPSHOT > + bool > + > # Support forced irq threading > config IRQ_FORCED_THREADING > bool > diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug > index 49f652674bd8..899b69fcb598 100644 > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -1032,6 +1032,7 @@ config SOFTLOCKUP_DETECTOR > config SOFTLOCKUP_DETECTOR_INTR_STORM > bool "Detect Interrupt Storm in Soft Lockups" > depends on SOFTLOCKUP_DETECTOR && IRQ_TIME_ACCOUNTING > + select GENERIC_IRQ_STAT_SNAPSHOT This goes into the patch which adds the lockup detector parts. Thanks, tglx
Hi, On 2024/3/6 00:57, Thomas Gleixner wrote: > >> diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig >> index 2531f3496ab6..a28e5ac5fc79 100644 >> --- a/kernel/irq/Kconfig >> +++ b/kernel/irq/Kconfig >> @@ -108,6 +108,10 @@ config GENERIC_IRQ_MATRIX_ALLOCATOR >> config GENERIC_IRQ_RESERVATION_MODE >> bool >> >> +# Snapshot for interrupt statistics >> +config GENERIC_IRQ_STAT_SNAPSHOT >> + bool >> + >> # Support forced irq threading >> config IRQ_FORCED_THREADING >> bool >> diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug >> index 49f652674bd8..899b69fcb598 100644 >> --- a/lib/Kconfig.debug >> +++ b/lib/Kconfig.debug >> @@ -1032,6 +1032,7 @@ config SOFTLOCKUP_DETECTOR >> config SOFTLOCKUP_DETECTOR_INTR_STORM >> bool "Detect Interrupt Storm in Soft Lockups" >> depends on SOFTLOCKUP_DETECTOR && IRQ_TIME_ACCOUNTING >> + select GENERIC_IRQ_STAT_SNAPSHOT > > This goes into the patch which adds the lockup detector parts. > OK, I will implement this in the next version. Best Regards, Bitao Hu
diff --git a/arch/mips/dec/setup.c b/arch/mips/dec/setup.c index 6c3704f51d0d..87f0a1436bf9 100644 --- a/arch/mips/dec/setup.c +++ b/arch/mips/dec/setup.c @@ -756,7 +756,7 @@ void __init arch_init_irq(void) NULL)) pr_err("Failed to register fpu interrupt\n"); desc_fpu = irq_to_desc(irq_fpu); - fpu_kstat_irq = this_cpu_ptr(desc_fpu->kstat_irqs); + fpu_kstat_irq = this_cpu_ptr(&desc_fpu->kstat_irqs->cnt); } if (dec_interrupt[DEC_IRQ_CASCADE] >= 0) { if (request_irq(dec_interrupt[DEC_IRQ_CASCADE], no_action, diff --git a/arch/parisc/kernel/smp.c b/arch/parisc/kernel/smp.c index 444154271f23..800eb64e91ad 100644 --- a/arch/parisc/kernel/smp.c +++ b/arch/parisc/kernel/smp.c @@ -344,7 +344,7 @@ static int smp_boot_one_cpu(int cpuid, struct task_struct *idle) struct irq_desc *desc = irq_to_desc(i); if (desc && desc->kstat_irqs) - *per_cpu_ptr(desc->kstat_irqs, cpuid) = 0; + *per_cpu_ptr(desc->kstat_irqs, cpuid) = (struct irqstat) { }; } #endif diff --git a/arch/powerpc/kvm/book3s_hv_rm_xics.c b/arch/powerpc/kvm/book3s_hv_rm_xics.c index e42984878503..f2636414d82a 100644 --- a/arch/powerpc/kvm/book3s_hv_rm_xics.c +++ b/arch/powerpc/kvm/book3s_hv_rm_xics.c @@ -837,7 +837,7 @@ static inline void this_cpu_inc_rm(unsigned int __percpu *addr) */ static void kvmppc_rm_handle_irq_desc(struct irq_desc *desc) { - this_cpu_inc_rm(desc->kstat_irqs); + this_cpu_inc_rm(&desc->kstat_irqs->cnt); __this_cpu_inc(kstat.irqs_sum); } diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h index d9451d456a73..95d8def84471 100644 --- a/include/linux/irqdesc.h +++ b/include/linux/irqdesc.h @@ -17,6 +17,16 @@ struct irq_desc; struct irq_domain; struct pt_regs; +/** + * struct irqstat - interrupt statistics + * @cnt: real-time interrupt count + * @ref: snapshot of interrupt count + */ +struct irqstat { + unsigned int cnt; + unsigned int ref; +}; + /** * struct irq_desc - interrupt descriptor * @irq_common_data: per irq and chip data passed down to chip functions @@ -55,7 +65,7 @@ struct pt_regs; struct irq_desc { struct irq_common_data irq_common_data; struct irq_data irq_data; - unsigned int __percpu *kstat_irqs; + struct irqstat __percpu *kstat_irqs; irq_flow_handler_t handle_irq; struct irqaction *action; /* IRQ action list */ unsigned int status_use_accessors; @@ -119,7 +129,7 @@ extern struct irq_desc irq_desc[NR_IRQS]; static inline unsigned int irq_desc_kstat_cpu(struct irq_desc *desc, unsigned int cpu) { - return desc->kstat_irqs ? *per_cpu_ptr(desc->kstat_irqs, cpu) : 0; + return desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, cpu) : 0; } static inline struct irq_desc *irq_data_to_desc(struct irq_data *data) diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h index 9935f7ecbfb9..98b3043ea5e6 100644 --- a/include/linux/kernel_stat.h +++ b/include/linux/kernel_stat.h @@ -79,6 +79,9 @@ static inline unsigned int kstat_cpu_softirqs_sum(int cpu) return sum; } +extern void kstat_snapshot_irqs(void); +extern unsigned int kstat_get_irq_since_snapshot(unsigned int irq); + /* * Number of interrupts per specific IRQ source, since bootup */ diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h index bcc7f21db9ee..1d92532c2aae 100644 --- a/kernel/irq/internals.h +++ b/kernel/irq/internals.h @@ -258,7 +258,7 @@ static inline void irq_state_set_masked(struct irq_desc *desc) static inline void __kstat_incr_irqs_this_cpu(struct irq_desc *desc) { - __this_cpu_inc(*desc->kstat_irqs); + __this_cpu_inc(desc->kstat_irqs->cnt); __this_cpu_inc(kstat.irqs_sum); } diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c index 27ca1c866f29..9cd17080b2d8 100644 --- a/kernel/irq/irqdesc.c +++ b/kernel/irq/irqdesc.c @@ -122,7 +122,7 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node, desc->name = NULL; desc->owner = owner; for_each_possible_cpu(cpu) - *per_cpu_ptr(desc->kstat_irqs, cpu) = 0; + *per_cpu_ptr(desc->kstat_irqs, cpu) = (struct irqstat) { }; desc_smp_init(desc, node, affinity); } @@ -418,8 +418,8 @@ static struct irq_desc *alloc_desc(int irq, int node, unsigned int flags, desc = kzalloc_node(sizeof(*desc), GFP_KERNEL, node); if (!desc) return NULL; - /* allocate based on nr_cpu_ids */ - desc->kstat_irqs = alloc_percpu(unsigned int); + + desc->kstat_irqs = alloc_percpu(struct irqstat); if (!desc->kstat_irqs) goto err_desc; @@ -593,7 +593,7 @@ int __init early_irq_init(void) count = ARRAY_SIZE(irq_desc); for (i = 0; i < count; i++) { - desc[i].kstat_irqs = alloc_percpu(unsigned int); + desc[i].kstat_irqs = alloc_percpu(struct irqstat); alloc_masks(&desc[i], node); raw_spin_lock_init(&desc[i].lock); lockdep_set_class(&desc[i].lock, &irq_desc_lock_class); @@ -952,8 +952,7 @@ unsigned int kstat_irqs_cpu(unsigned int irq, int cpu) { struct irq_desc *desc = irq_to_desc(irq); - return desc && desc->kstat_irqs ? - *per_cpu_ptr(desc->kstat_irqs, cpu) : 0; + return desc && desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, cpu) : 0; } static bool irq_is_nmi(struct irq_desc *desc) @@ -975,10 +974,31 @@ static unsigned int kstat_irqs(unsigned int irq) return data_race(desc->tot_count); for_each_possible_cpu(cpu) - sum += data_race(*per_cpu_ptr(desc->kstat_irqs, cpu)); + sum += data_race(per_cpu(desc->kstat_irqs->cnt, cpu)); return sum; } +void kstat_snapshot_irqs(void) +{ + struct irq_desc *desc; + unsigned int irq; + + for_each_irq_desc(irq, desc) { + if (!desc->kstat_irqs) + continue; + this_cpu_write(desc->kstat_irqs->ref, this_cpu_read(desc->kstat_irqs->cnt)); + } +} + +unsigned int kstat_get_irq_since_snapshot(unsigned int irq) +{ + struct irq_desc *desc = irq_to_desc(irq); + + if (!desc || !desc->kstat_irqs) + return 0; + return this_cpu_read(desc->kstat_irqs->cnt) - this_cpu_read(desc->kstat_irqs->ref); +} + /** * kstat_irqs_usr - Get the statistics for an interrupt from thread context * @irq: The interrupt number diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c index 623b8136e9af..6954e0a02047 100644 --- a/kernel/irq/proc.c +++ b/kernel/irq/proc.c @@ -490,7 +490,7 @@ int show_interrupts(struct seq_file *p, void *v) if (desc->kstat_irqs) { for_each_online_cpu(j) - any_count |= data_race(*per_cpu_ptr(desc->kstat_irqs, j)); + any_count |= data_race(per_cpu(desc->kstat_irqs->cnt, j)); } if ((!desc->action || irq_desc_is_chained(desc)) && !any_count) @@ -498,8 +498,7 @@ int show_interrupts(struct seq_file *p, void *v) seq_printf(p, "%*d: ", prec, i); for_each_online_cpu(j) - seq_printf(p, "%10u ", desc->kstat_irqs ? - *per_cpu_ptr(desc->kstat_irqs, j) : 0); + seq_printf(p, "%10u ", desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, j) : 0); raw_spin_lock_irqsave(&desc->lock, flags); if (desc->irq_data.chip) { diff --git a/scripts/gdb/linux/interrupts.py b/scripts/gdb/linux/interrupts.py index ef478e273791..7e50f3b9dfad 100644 --- a/scripts/gdb/linux/interrupts.py +++ b/scripts/gdb/linux/interrupts.py @@ -37,7 +37,7 @@ def show_irq_desc(prec, irq): any_count = 0 if desc['kstat_irqs']: for cpu in cpus.each_online_cpu(): - any_count += cpus.per_cpu(desc['kstat_irqs'], cpu) + any_count += cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt'] if (desc['action'] == 0 or irq_desc_is_chained(desc)) and any_count == 0: return text; @@ -45,7 +45,7 @@ def show_irq_desc(prec, irq): text += "%*d: " % (prec, irq) for cpu in cpus.each_online_cpu(): if desc['kstat_irqs']: - count = cpus.per_cpu(desc['kstat_irqs'], cpu) + count = cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt'] else: count = 0 text += "%10u" % (count) @@ -177,7 +177,7 @@ def arm_common_show_interrupts(prec): if desc == 0: continue for cpu in cpus.each_online_cpu(): - text += "%10u" % (cpus.per_cpu(desc['kstat_irqs'], cpu)) + text += "%10u" % (cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt']) text += " %s" % (ipi_types[ipi].string()) text += "\n" return text