Improve /proc/interrupts further and add a binary interface

From: Dmitry Ilvokhin <[email protected]>

Monitoring tools periodically scan /proc/interrupts to export metrics as a timeseries for future analysis and investigation.

In large fleets, /proc/interrupts is polled (often every few seconds) on every machine. The cumulative overhead adds up quickly across thousands of nodes, so reducing the cost of generating these stats does have a measurable operational impact. With the ongoing trend toward higher core counts per machine, this cost becomes even more noticeable over time, since interrupt counters are per-CPU. In Meta's fleet, we have observed this overhead at scale.

Although a binary /proc interface would be a better long-term solution due to lower formatting (kernel side) and parsing (userspace side) overhead, the text interface will remain in use for some time, even if better solutions will be available. Optimizing the /proc/interrupts printing code is therefore still beneficial.

Function seq_printf() supports rich format string for decimals printing, but it doesn't required for printing /proc/interrupts per CPU counters, seq_put_decimal_ull_width() function can be used instead to print per CPU counters, because very limited formatting is required for this case. Similar optimization idea is already used in show_interrupts().

Performance counter stats (truncated) for 'sh -c cat /proc/interrupts

Before:

      3.42 msec task-clock        #    0.802 CPUs utilized   ( +-  0.05% ) 1      context-switches  #  291.991 /sec            ( +-  0.74% ) 0      cpu-migrations    #    0.000 /sec
       343      page-faults       #  100.153 K/sec           ( +-  0.01% ) 8,932,242      instructions      #    1.66  insn per cycle  ( +-  0.34% ) 5,374,427      cycles            #    1.569 GHz             ( +-  0.04% ) 1,483,154      branches          #  433.068 M/sec           ( +-  0.22% ) 28,768      branch-misses     #    1.94% of all branches ( +-  0.31% )

0.00427182 +- 0.00000215 seconds time elapsed  ( +-  0.05% )

After:

      2.39 msec task-clock        #    0.796 CPUs utilized   ( +-  0.06% ) 1      context-switches  #  418.541 /sec            ( +-  0.70% ) 0      cpu-migrations    #    0.000 /sec
       343      page-faults       #  143.560 K/sec           ( +-  0.01% ) 7,020,982      instructions      #    1.30  insn per cycle  ( +-  0.52% ) 5,397,266      cycles            #    2.259 GHz             ( +-  0.06% ) 1,569,648      branches          #  656.962 M/sec           ( +-  0.08% ) 25,419      branch-misses     #    1.62% of all branches ( +-  0.72% )

0.00299996 +- 0.00000206 seconds time elapsed  ( +-  0.07% )

Relative speed up in time elapsed is around 29%.

[ tglx: Fixed it up so it applies to current mainline ]

Signed-off-by Dmitry Ilvokhin <[email protected]>

Signed-off-by Thomas Gleixner <[email protected]>

Link https://patch.msgid.link/[email protected] open here

---
Changes v2:
- Expanded commit message: add more rationale for the proposed change.
- Renamed helper put_spaced_decimal() -> put_decimal() primarely to make checkpatch.pl --strict pass.

 arch/x86/kernel/irq.c |  112 ++++++++++++++++++++++++++------------------------

 1 file changed, 59 insertions(+), 53 deletions(-)

arch/x86/kernel/irq.c +0 -0

@@ -62,6 +62,18 @@ void ack_bad_irq(unsigned int irq)
  	apic_eoi();
  }

arch/x86/kernel/irq.c +12 -0

+/*
+ * A helper routine for putting space and decimal number without overhead
+ * from rich format of printf().
+ */
+static void put_decimal(struct seq_file *p, unsigned long long num)
+{
+	const char *delimiter = " ";
+	unsigned int width = 10;
+
+	seq_put_decimal_ull_width(p, delimiter, num, width);
+}
+

 #define irq_stats(x) (&per_cpu(irq_stat, x))
 /*
  * /proc/interrupts printing for arch specific interrupts

arch/x86/kernel/irq.c +0 -0

@@ -70,103 +82,101 @@ int arch_show_interrupts(struct seq_file
  {
  	int j;

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "NMI");
+	seq_printf(p, "%*s:", prec, "NMI");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->__nmi_count);
+		put_decimal(p, irq_stats(j)->__nmi_count);

  seq_puts(p, "  Non-maskable interrupts\n"); #ifdef CONFIG_X86_LOCAL_APIC

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "LOC");
+	seq_printf(p, "%*s:", prec, "LOC");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->apic_timer_irqs);
+		put_decimal(p, irq_stats(j)->apic_timer_irqs);

  seq_puts(p, "  Local timer interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "SPU");
+	seq_printf(p, "%*s:", prec, "SPU");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_spurious_count);
+		put_decimal(p, irq_stats(j)->irq_spurious_count);

  seq_puts(p, "  Spurious interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "PMI");
+	seq_printf(p, "%*s:", prec, "PMI");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->apic_perf_irqs);
+		put_decimal(p, irq_stats(j)->apic_perf_irqs);

  seq_puts(p, "  Performance monitoring interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "IWI");
+	seq_printf(p, "%*s:", prec, "IWI");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->apic_irq_work_irqs);
+		put_decimal(p, irq_stats(j)->apic_irq_work_irqs);

  seq_puts(p, "  IRQ work interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "RTR");
+	seq_printf(p, "%*s:", prec, "RTR");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->icr_read_retry_count);
+		put_decimal(p, irq_stats(j)->icr_read_retry_count);

  seq_puts(p, "  APIC ICR read retries\n");
  if (x86_platform_ipi_callback) {

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%*s: ", prec, "PLT");
+		seq_printf(p, "%*s:", prec, "PLT");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-			seq_printf(p, "%10u ", irq_stats(j)->x86_platform_ipis);
+			put_decimal(p, irq_stats(j)->x86_platform_ipis);

  seq_puts(p, "  Platform interrupts\n"); }
 #endif
 #ifdef CONFIG_SMP

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "RES");
+	seq_printf(p, "%*s:", prec, "RES");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_resched_count);
+		put_decimal(p, irq_stats(j)->irq_resched_count);

  seq_puts(p, "  Rescheduling interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "CAL");
+	seq_printf(p, "%*s:", prec, "CAL");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_call_count);
+		put_decimal(p, irq_stats(j)->irq_call_count);

  seq_puts(p, "  Function call interrupts\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "TLB");
+	seq_printf(p, "%*s:", prec, "TLB");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_tlb_count);
+		put_decimal(p, irq_stats(j)->irq_tlb_count);

  seq_puts(p, "  TLB shootdowns\n");
 #endif
 #ifdef CONFIG_X86_THERMAL_VECTOR

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "TRM");
+	seq_printf(p, "%*s:", prec, "TRM");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_thermal_count);
+		put_decimal(p, irq_stats(j)->irq_thermal_count);

  seq_puts(p, "  Thermal event interrupts\n"); #endif
 #ifdef CONFIG_X86_MCE_THRESHOLD

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "THR");
+	seq_printf(p, "%*s:", prec, "THR");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_threshold_count);
+		put_decimal(p, irq_stats(j)->irq_threshold_count);

  seq_puts(p, "  Threshold APIC interrupts\n"); #endif
 #ifdef CONFIG_X86_MCE_AMD

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "DFR");
+	seq_printf(p, "%*s:", prec, "DFR");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", irq_stats(j)->irq_deferred_error_count);
+		put_decimal(p, irq_stats(j)->irq_deferred_error_count);

  seq_puts(p, "  Deferred Error APIC interrupts\n"); #endif
 #ifdef CONFIG_X86_MCE

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "MCE");
+	seq_printf(p, "%*s:", prec, "MCE");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", per_cpu(mce_exception_count, j));
+		put_decimal(p, per_cpu(mce_exception_count, j));

  seq_puts(p, "  Machine check exceptions\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "MCP");
+	seq_printf(p, "%*s:", prec, "MCP");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%10u ", per_cpu(mce_poll_count, j));
+		put_decimal(p, per_cpu(mce_poll_count, j));

  seq_puts(p, "  Machine check polls\n");
 #endif
 #ifdef CONFIG_X86_HV_CALLBACK_VECTOR
  if (test_bit(HYPERVISOR_CALLBACK_VECTOR, system_vectors)) {

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%*s: ", prec, "HYP");
+		seq_printf(p, "%*s:", prec, "HYP");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-			seq_printf(p, "%10u ",
-				   irq_stats(j)->irq_hv_callback_count);
+			put_decimal(p, irq_stats(j)->irq_hv_callback_count);

  seq_puts(p, "  Hypervisor callback interrupts\n"); }
 #endif
 #if IS_ENABLED(CONFIG_HYPERV)
  if (test_bit(HYPERV_REENLIGHTENMENT_VECTOR, system_vectors)) {

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%*s: ", prec, "HRE");
+		seq_printf(p, "%*s:", prec, "HRE");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +2 -2

-			seq_printf(p, "%10u ",
-				   irq_stats(j)->irq_hv_reenlightenment_count);
+			put_decimal(p,
+				    irq_stats(j)->irq_hv_reenlightenment_count);

  seq_puts(p, "  Hyper-V reenlightenment interrupts\n"); }
  if (test_bit(HYPERV_STIMER0_VECTOR, system_vectors)) {

arch/x86/kernel/irq.c +1 -1

-		seq_printf(p, "%*s: ", prec, "HVS");
+		seq_printf(p, "%*s:", prec, "HVS");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-			seq_printf(p, "%10u ",
-				   irq_stats(j)->hyperv_stimer0_count);
+			put_decimal(p, irq_stats(j)->hyperv_stimer0_count);

  seq_puts(p, "  Hyper-V stimer0 interrupts\n"); }
 #endif

arch/x86/kernel/irq.c +2 -2

@@ -175,35 +185,31 @@ int arch_show_interrupts(struct seq_file
  	seq_printf(p, "%*s: %10u\n", prec, "MIS", atomic_read(&irq_mis_count));
  #endif
  #if IS_ENABLED(CONFIG_KVM)
-	seq_printf(p, "%*s: ", prec, "PIN");
+	seq_printf(p, "%*s:", prec, "PIN");
  	for_each_online_cpu(j)
-		seq_printf(p, "%10u ", irq_stats(j)->kvm_posted_intr_ipis);
+		put_decimal(p, irq_stats(j)->kvm_posted_intr_ipis);
  	seq_puts(p, "  Posted-interrupt notification event\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "NPI");
+	seq_printf(p, "%*s:", prec, "NPI");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-		seq_printf(p, "%10u ",
-			   irq_stats(j)->kvm_posted_intr_nested_ipis);
+		put_decimal(p, irq_stats(j)->kvm_posted_intr_nested_ipis);

  seq_puts(p, "  Nested posted-interrupt event\n");

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "PIW");
+	seq_printf(p, "%*s:", prec, "PIW");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-		seq_printf(p, "%10u ",
-			   irq_stats(j)->kvm_posted_intr_wakeup_ipis);
+		put_decimal(p, irq_stats(j)->kvm_posted_intr_wakeup_ipis);

  seq_puts(p, "  Posted-interrupt wakeup event\n"); #endif
 #ifdef CONFIG_GUEST_PERF_EVENTS

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "VPMI");
+	seq_printf(p, "%*s:", prec, "VPMI");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-		seq_printf(p, "%10u ",
-			   irq_stats(j)->perf_guest_mediated_pmis);
+		put_decimal(p, irq_stats(j)->perf_guest_mediated_pmis);

  seq_puts(p, " Perf Guest Mediated PMI\n"); #endif
 #ifdef CONFIG_X86_POSTED_MSI

arch/x86/kernel/irq.c +1 -1

-	seq_printf(p, "%*s: ", prec, "PMN");
+	seq_printf(p, "%*s:", prec, "PMN");

  for_each_online_cpu(j)

arch/x86/kernel/irq.c +1 -2

-		seq_printf(p, "%10u ",
-			   irq_stats(j)->posted_msi_notification_count);
+		put_decimal(p, irq_stats(j)->posted_msi_notification_count);

  seq_puts(p, "  Posted MSI notification event\n"); #endif
  return 0;

A large portion of interrupt count entries are zero. There is no point in formatting the zero value as it is way cheeper to just emit a constant string.

Collect the number of consecutive zero counts and emit them in one go before a non-zero count and at the end of the line.

Signed-off-by Thomas Gleixner <[email protected]>

Reviewed-by Dmitry Ilvokhin <[email protected]>

---
V2: Use sizeof() for ZSTR1_LEN - Dmitry
---
 include/linux/interrupt.h |    1 +
 kernel/irq/proc.c         |   42 +++++++++++++++++++++++++++++++++++++-----

 2 files changed, 38 insertions(+), 5 deletions(-)

include/linux/interrupt.h +1 -0

@@ -864,6 +864,7 @@ static inline void init_irq_proc(void)
  struct seq_file;
  int show_interrupts(struct seq_file *p, void *v);
  int arch_show_interrupts(struct seq_file *p, int prec);
+void irq_proc_emit_counts(struct seq_file *p, unsigned int __percpu *cnts);

 extern int early_irq_init(void);
 extern int arch_probe_nr_irqs(void);

kernel/irq/proc.c +0 -0

@@ -450,6 +450,42 @@ int __weak arch_show_interrupts(struct s
  # define ACTUAL_NR_IRQS irq_get_nr_irqs()
  #endif

kernel/irq/proc.c +36 -0

+#define ZSTR1 "          0"
+#define ZSTR1_LEN	(sizeof(ZSTR1) - 1)
+#define ZSTR16		ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 \
+			ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1
+#define ZSTR256		ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 \
+			ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16 ZSTR16
+
+static inline void irq_proc_emit_zero_counts(struct seq_file *p, unsigned int zeros)
+{
+	if (!zeros)
+		return;
+
+	for (unsigned int n = min(zeros, 256); n; zeros -= n, n = min(zeros, 256))
+		seq_write(p, ZSTR256, n * ZSTR1_LEN);
+}
+
+static inline unsigned int irq_proc_emit_count(struct seq_file *p, unsigned int cnt,
+					       unsigned int zeros)
+{
+	if (!cnt)
+		return zeros + 1;
+
+	irq_proc_emit_zero_counts(p, zeros);
+	seq_put_decimal_ull_width(p, " ", cnt, 10);
+	return 0;
+}
+
+void irq_proc_emit_counts(struct seq_file *p, unsigned int __percpu *cnts)
+{
+	unsigned int cpu, zeros = 0;
+
+	for_each_online_cpu(cpu)
+		zeros = irq_proc_emit_count(p, per_cpu(*cnts, cpu), zeros);
+	irq_proc_emit_zero_counts(p, zeros);
+}
+

 int show_interrupts(struct seq_file *p, void *v) {
  const unsigned int nr_irqs = irq_get_nr_irqs();

kernel/irq/proc.c +0 -0

@@ -485,11 +521,7 @@ int show_interrupts(struct seq_file *p,
  		return 0;

  seq_printf(p, "%*d:", prec, i);

kernel/irq/proc.c +1 -5

-	for_each_online_cpu(j) {
-		unsigned int cnt = desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, j) : 0;
-
-		seq_put_decimal_ull_width(p, " ", cnt, 10);
-	}
+	irq_proc_emit_counts(p, &desc->kstat_irqs->cnt);

  seq_putc(p, ' ');

  guard(raw_spinlock_irq)(&desc->lock);

Interrupts which are not marked per CPU increment not only the per CPU statistics, but also the accumulation counter irq_desc::tot_count.

Change the counter to type unsigned long so it does not produce sporadic zeros due to wrap arounds on 64-bit machines and do a quick check for non per CPU interrupts. If the counter is zero, then simply emit a full set of zero strings. That spares the evaluation of the per CPU counters completely for interrupts with zero events.

Signed-off-by Thomas Gleixner <[email protected]>

Reviewed-by Dmitry Ilvokhin <[email protected]>

---
 include/linux/irqdesc.h |    6 +++---
 kernel/irq/proc.c       |   11 ++++++++++-

 2 files changed, 13 insertions(+), 4 deletions(-)

include/linux/irqdesc.h +1 -1

@@ -52,8 +52,8 @@ struct irq_redirect {
   * @depth:		disable-depth, for nested irq_disable() calls
   * @wake_depth:		enable depth, for multiple irq_set_irq_wake() callers
   * @tot_count:		stats field for non-percpu irqs
- * @irq_count:		stats field to detect stalled irqs
   * @last_unhandled:	aging timer for unhandled count
+ * @irq_count:		stats field to detect stalled irqs
   * @irqs_unhandled:	stats field for spurious unhandled interrupts
   * @threads_handled:	stats field for deferred spurious detection of threaded handlers
   * @threads_handled_last: comparator field for deferred spurious detection of threaded handlers

@@ -87,9 +87,9 @@ struct irq_desc {
  	unsigned int		core_internal_state__do_not_mess_with_it;

  unsigned int depth; /* nested irq disables */
  unsigned int wake_depth; /* nested wake enables */

include/linux/irqdesc.h +1 -2

-	unsigned int		tot_count;
-	unsigned int		irq_count;	/* For detecting broken IRQs */
+	unsigned long		tot_count;

  unsigned long last_unhandled; /* Aging timer for unhandled count */

include/linux/irqdesc.h +1 -0

+	unsigned int		irq_count;	/* For detecting broken IRQs */

  unsigned int irqs_unhandled;
  atomic_t threads_handled;
  int threads_handled_last;

kernel/irq/proc.c +0 -0

@@ -521,7 +521,16 @@ int show_interrupts(struct seq_file *p,
  		return 0;

  seq_printf(p, "%*d:", prec, i);

kernel/irq/proc.c +10 -1

-	irq_proc_emit_counts(p, &desc->kstat_irqs->cnt);
+
+	/*
+	 * Always output per CPU interrupts. Output device interrupts only when
+	 * desc::tot_count is not zero.
+	 */
+	if (irq_settings_is_per_cpu(desc) || irq_settings_is_per_cpu_devid(desc) ||
+	    data_race(desc->tot_count))
+		irq_proc_emit_counts(p, &desc->kstat_irqs->cnt);
+	else
+		irq_proc_emit_zero_counts(p, num_online_cpus());

  seq_putc(p, ' ');

  guard(raw_spinlock_irq)(&desc->lock);

Having the x86 specific interrupt statistics as a data structure with individual members instead of an array is just stupid as it requires endless copy and paste in arch_show_interrupts() and arch_irq_stat_cpu(), where the latter does not even take the latest interrupt additions into account. The resulting #ifdef orgy is just disgusting.

Convert it to an array of counters, which does not make a difference in the actual interrupt hotpath increment as the array index is constant and therefore not any different than the member based access.

But in arch_show_interrupts() and arch_irq_stat_cpu() this just turns into a loop, which reduces the text size by ~2k (~12%):

   text	   data	    bss	    dec	    hex	filename
  19643	  15250	    904	  35797	   8bd5	../build/arch/x86/kernel/irq.o
  17355	  15250	    904	  33509	   82e5	../build/arch/x86/kernel/irq.o

Adding a new vector or software counter only requires to update the table and everything just works. Using the core provided emit function which speeds up 0 outputs makes it significantly faster.

Signed-off-by Thomas Gleixner <[email protected]>

---
V2: Simplified and extended vector skip mechanism
Fixup the typoes - Micheal, Dmitry
Added the lost precision back for ERR/MIS - Dmitry

#if IS_ENABLED(CONFIG_HYPERV)

arch/x86/kernel/irq.c +0 -8

-	if (test_bit(HYPERV_REENLIGHTENMENT_VECTOR, system_vectors)) {
-		seq_printf(p, "%*s:", prec, "HRE");
-		for_each_online_cpu(j)
-			put_decimal(p,
-				    irq_stats(j)->irq_hv_reenlightenment_count);
-		seq_puts(p, "  Hyper-V reenlightenment interrupts\n");
-	}
-	if (test_bit(HYPERV_STIMER0_VECTOR, system_vectors)) {

arch/x86/kernel/irq.c +1 -0

+	ITS(HYPERV_STIMER0,		"HVS", " Hyper-V stimer0 interrupts\n"),
 #endif

From: Thomas Gleixner <[email protected]> Sent: Friday, March 20, 2026 6:22 AM

arch/x86/kernel/irq.c void ack_bad_irq(unsigned int irq) · line 108

Quoted 4 lines

arch/x86/kernel/irq.c +1 -3

-	seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
-#if defined(CONFIG_X86_IO_APIC)
-	seq_printf(p, "%*s: %10u\n", prec, "MIS", atomic_read(&irq_mis_count));
+	ITS(HYPERV_REENLIGHTENMENT,	"HRE", " Hyper-V reenlightment interrupts\n"),

There's still a typo in the description string:

s/reenlightment/reenlightenment/

Quoted 8 lines

From: Thomas Gleixner <[email protected]> Sent: Friday, March 20, 2026 6:22 AM

arch/x86/kernel/irq.c void ack_bad_irq(unsigned int irq) · line 108

Quoted 4 lines

arch/x86/kernel/irq.c +1 -3

-	seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
-#if defined(CONFIG_X86_IO_APIC)
-	seq_printf(p, "%*s: %10u\n", prec, "MIS", atomic_read(&irq_mis_count));
+	ITS(HYPERV_REENLIGHTENMENT,	"HRE", " Hyper-V reenlightment interrupts\n"),

There's still a typo in the description string:

Quoted 1 line

s/reenlightment/reenlightenment/

I clearly suffer from dyslexia.

Having the x86 specific interrupt statistics as a data structure with individual members instead of an array is just stupid as it requires endless copy and paste in arch_show_interrupts() and arch_irq_stat_cpu(), where the latter does not even take the latest interrupt additions into account. The resulting #ifdef orgy is just disgusting.

Convert it to an array of counters, which does not make a difference in the actual interrupt hotpath increment as the array index is constant and therefore not any different than the member based access.

But in arch_show_interrupts() and arch_irq_stat_cpu() this just turns into a loop, which reduces the text size by ~2k (~12%):

   text    data     bss     dec     hex filename
  19643   15250     904   35797    8bd5 ../build/arch/x86/kernel/irq.o
  17355   15250     904   33509    82e5 ../build/arch/x86/kernel/irq.o

Adding a new vector or software counter only requires to update the table and everything just works. Using the core provided emit function which speeds up 0 outputs makes it significantly faster.

Signed-off-by Thomas Gleixner <[email protected]>

---
V2: Simplified and extended vector skip mechanism Fixup the typoes - Micheal, Dmitry
    Added the lost precision back for ERR/MIS - Dmitry
---

 arch/x86/events/amd/core.c          |    2 arch/x86/events/amd/ibs.c           |    2 arch/x86/events/core.c              |    2 arch/x86/events/intel/core.c        |    2 arch/x86/events/intel/knc.c         |    2 arch/x86/events/intel/p4.c          |    2 arch/x86/events/zhaoxin/core.c      |    2 arch/x86/hyperv/hv_init.c           |    2 arch/x86/include/asm/hardirq.h      |   69 +++++-----

 arch/x86/include/asm/irq.h          |    2 arch/x86/include/asm/mce.h          |    3 arch/x86/kernel/apic/apic.c         |    4 arch/x86/kernel/apic/ipi.c          |    2 arch/x86/kernel/cpu/acrn.c          |    2 arch/x86/kernel/cpu/mce/amd.c       |    2 arch/x86/kernel/cpu/mce/core.c      |    8 - arch/x86/kernel/cpu/mce/threshold.c |    2 arch/x86/kernel/cpu/mshyperv.c      |    4
 arch/x86/kernel/irq.c               |  247 ++++++++++++------------------------

 arch/x86/kernel/irq_work.c          |    2
 arch/x86/kernel/irqinit.c           |    2

 arch/x86/kernel/kvm.c               |    2 
 arch/x86/kernel/nmi.c               |    4 
 arch/x86/kernel/smp.c               |    6 

 arch/x86/mm/tlb.c                   |    2
 arch/x86/xen/enlighten_hvm.c        |    2
 arch/x86/xen/enlighten_pv.c         |    2
 arch/x86/xen/smp.c                  |    6
 arch/x86/xen/smp_pv.c               |    2

 29 files changed, 158 insertions(+), 233 deletions(-)

Quoted 1 line · Thomas Gleixner

 arch/x86/include/asm/hardirq.h      |   69 +++++-----

I believe this breaks scripts/gdb/linux/interrupts.py, particularly the x86_show_irqstat() function, which still expects individual members in struct irq_cpustat_t.

Quoted 1 line

 arch/x86/kernel/irq.c               |  247 ++++++++++++------------------------

Nit: This moves the description text by one more space to the left (in addition to the one in patch 1), and now the description is no longer aligned to the generic interrupts.

Quoted 6 lines · Radu Rendec

Quoted 1 line · Thomas Gleixner

 arch/x86/include/asm/hardirq.h      |   69 +++++-----

I believe this breaks scripts/gdb/linux/interrupts.py, particularly the x86_show_irqstat() function, which still expects individual members in struct irq_cpustat_t.

Uurg. I did not even know this exists. Let me try to polish the snake.

Quoted 4 lines · Thomas Gleixner

Quoted 3 lines · Radu Rendec

Quoted 1 line · Thomas Gleixner

 arch/x86/include/asm/hardirq.h      |   69 +++++-----

Quoted 5 lines

Quoted 3 lines

I believe this breaks scripts/gdb/linux/interrupts.py, particularly the x86_show_irqstat() function, which still expects individual members in struct irq_cpustat_t.

Uurg. I did not even know this exists. Let me try to polish the snake.

Something like the below should work, now I have to figure out how to test it.

----

scripts/gdb/linux/interrupts.py +0 -0

@@ -97,8 +97,8 @@ irq_desc_type = utils.CachedType("struct
          text += "%*s: %10u\n" % (prec, "ERR", cnt['counter'])

     return text

scripts/gdb/linux/interrupts.py +2 -2

-def x86_show_irqstat(prec, pfx, field, desc):
-    irq_stat = gdb.parse_and_eval("&irq_stat")
+def x86_show_irqstat(prec, pfx, idx, desc):
+    irq_stat = gdb.parse_and_eval("&irq_stat.counts[IRQ_COUNT_%s]" %idx)

     text = "%*s: " % (prec, pfx)
     for cpu in cpus.each_online_cpu():
         stat = cpus.per_cpu(irq_stat, cpu)

scripts/gdb/linux/interrupts.py +0 -0

@@ -118,32 +118,51 @@ irq_desc_type = utils.CachedType("struct
      text = x86_show_irqstat(prec, "NMI", '__nmi_count', 'Non-maskable interrupts')

     if constants.LX_CONFIG_X86_LOCAL_APIC:
-        text += x86_show_irqstat(prec, "LOC", 'apic_timer_irqs', "Local timer interrupts") -        text += x86_show_irqstat(prec, "SPU", 'irq_spurious_count', "Spurious interrupts") -        text += x86_show_irqstat(prec, "PMI", 'apic_perf_irqs', "Performance monitoring interrupts") -        text += x86_show_irqstat(prec, "IWI", 'apic_irq_work_irqs', "IRQ work interrupts") -        text += x86_show_irqstat(prec, "RTR", 'icr_read_retry_count', "APIC ICR read retries") +        text += x86_show_irqstat(prec, "LOC", 'APIC_TIMER', "Local timer interrupts")
+        text += x86_show_irqstat(prec, "SPU", 'SPURIOUS', "Spurious interrupts")
+        text += x86_show_irqstat(prec, "PMI", 'APIC_PERF', "Performance monitoring interrupts") +        text += x86_show_irqstat(prec, "IWI", 'IRQ_WORK', "IRQ work interrupts")
+        text += x86_show_irqstat(prec, "RTR", 'ICR_READ_RETRY', "APIC ICR read retries") if utils.gdb_eval_or_none("x86_platform_ipi_callback") is not None:
-            text += x86_show_irqstat(prec, "PLT", 'x86_platform_ipis', "Platform interrupts") +            text += x86_show_irqstat(prec, "PLT", 'X86_PLATFORM_IPI', "Platform interrupts")
     if constants.LX_CONFIG_SMP:
-        text += x86_show_irqstat(prec, "RES", 'irq_resched_count', "Rescheduling interrupts") -        text += x86_show_irqstat(prec, "CAL", 'irq_call_count', "Function call interrupts") -        text += x86_show_irqstat(prec, "TLB", 'irq_tlb_count', "TLB shootdowns")
+        text += x86_show_irqstat(prec, "RES", 'RESCHEDULE', "Rescheduling interrupts")
+        text += x86_show_irqstat(prec, "CAL", 'CALL_FUNCTION', "Function call interrupts") +
+    text += x86_show_irqstat(prec, "TLB", 'TLB', "TLB shootdowns")

     if constants.LX_CONFIG_X86_THERMAL_VECTOR:
-        text += x86_show_irqstat(prec, "TRM", 'irq_thermal_count', "Thermal events interrupts") +        text += x86_show_irqstat(prec, "TRM", 'THERMAL_APIC', "Thermal events interrupts")
     if constants.LX_CONFIG_X86_MCE_THRESHOLD:
-        text += x86_show_irqstat(prec, "THR", 'irq_threshold_count', "Threshold APIC interrupts") +        text += x86_show_irqstat(prec, "THR", 'THRESHOLD_APIC', "Threshold APIC interrupts")
     if constants.LX_CONFIG_X86_MCE_AMD:
-        text += x86_show_irqstat(prec, "DFR", 'irq_deferred_error_count', "Deferred Error APIC interrupts") +        text += x86_show_irqstat(prec, "DFR", 'DEFERRED_ERROR', "Deferred Error APIC interrupts")
     if constants.LX_CONFIG_X86_MCE:
         text += x86_show_mce(prec, "&mce_exception_count", "MCE", "Machine check exceptions") text += x86_show_mce(prec, "&mce_poll_count", "MCP", "Machine check polls")

+    if constants.LX_CONFIG_X86_HV_CALLBACK_VECTOR:
+        text += x86_show_irqstat(prec, 'HYP', 'HYPERVISOR_CALLBACK', 'Hypervisor callback interrupts')

scripts/gdb/linux/interrupts.py +16 -0

+
+    if constants.LX_CONFIG_HYPERV:
+        text += x86_show_irqstat(prec, 'HRE', 'HYPERV_REENLIGHTENMENT', 'Hyper-V reenlightenment interrupts')
+        text += x86_show_irqstat(prec, 'HVS', 'HYPERV_STIMER0', 'Hyper-V stimer0 interrupts')
+
+    if constants.LX_CONFIG_KVM:
+        text += x86_show_irqstat(prec, "PIN", 'POSTED_INTR', 'Posted-interrupt notification event')
+        text += x86_show_irqstat(prec, "NPI", 'POSTED_INTR_NESTED', 'Nested posted-interrupt event')
+        text += x86_show_irqstat(prec, "PIW", 'POSTED_INTR_WAKEUP', 'Posted-interrupt wakeup event')
+
+    if constants.LX_CONFIG_GUEST_PERF_EVENTS:
+        text += x86_show_irqstat(prec, "VPMI", 'PERF_GUEST_MEDIATED_PMI', 'Perf Guest Mediated PMI')
+
+    if constants.LX_CONFIG_X86_POSTED_MSI:
+        text += x86_show_irqstat(prec, "PIN", 'POSTED_MSI_NOTIFICATION', 'Posted MSI notification event')
+

     text += show_irq_err_count(prec)

     if constants.LX_CONFIG_X86_IO_APIC:

scripts/gdb/linux/interrupts.py +0 -0

@@ -151,11 +170,6 @@ irq_desc_type = utils.CachedType("struct

         if cnt is not None:
             text += "%*s: %10u\n" % (prec, "MIS", cnt['counter'])

-    if constants.LX_CONFIG_KVM:
-        text += x86_show_irqstat(prec, "PIN", 'kvm_posted_intr_ipis', 'Posted-interrupt notification event') -        text += x86_show_irqstat(prec, "NPI", 'kvm_posted_intr_nested_ipis', 'Nested posted-interrupt event') -        text += x86_show_irqstat(prec, "PIW", 'kvm_posted_intr_wakeup_ipis', 'Posted-interrupt wakeup event') -
     return text

 def arm_common_show_interrupts(prec):

Quoted 6 lines · Thomas Gleixner

Quoted 4 lines · Thomas Gleixner

Quoted 3 lines · Radu Rendec

Quoted 1 line · Thomas Gleixner

 arch/x86/include/asm/hardirq.h      |   69 +++++-----

Quoted 8 lines

Quoted 5 lines

Quoted 3 lines

I believe this breaks scripts/gdb/linux/interrupts.py, particularly the x86_show_irqstat() function, which still expects individual members in struct irq_cpustat_t.

Uurg. I did not even know this exists. Let me try to polish the snake.

Something like the below should work, now I have to figure out how to test it.

At a glance, it looks about right (although I haven't tested it). The test procedure involves running the kernel in a Qemu VM and attaching with gdb to Qemu's gdb server (apologies if I'm just stating the obvious here). It's briefly described here:
Documentation/dev-tools/gdb-kernel-debugging.rst

The documentation doesn't elaborate on Qemu parameters. I'm using something like this:

qemu-system-x86_64 -nographic -m 1G -accel kvm -machine q35,hpet=off -cpu host -smp 4 \
        -netdev bridge,br=vbr-nat,id=net0 -device virtio-net-pci,mac=52:54:98:aa:bb:cc,netdev=net0 \
        -drive file=root.img,format=raw,if=virtio \
        -kernel bzImage \
        -append "console=ttyS0 root=/dev/vda1 rw nokaslr" \
        -s

Happy to help if something doesn't quite work for you.

Quoted 82 lines

----

scripts/gdb/linux/interrupts.py +0 -0

@@ -97,8 +97,8 @@ irq_desc_type = utils.CachedType("struct
          text += "%*s: %10u\n" % (prec, "ERR", cnt['counter'])

     return text

scripts/gdb/linux/interrupts.py +2 -2

-def x86_show_irqstat(prec, pfx, field, desc):
-    irq_stat = gdb.parse_and_eval("&irq_stat")
+def x86_show_irqstat(prec, pfx, idx, desc):
+    irq_stat = gdb.parse_and_eval("&irq_stat.counts[IRQ_COUNT_%s]" %idx)

     text = "%*s: " % (prec, pfx)
     for cpu in cpus.each_online_cpu():
         stat = cpus.per_cpu(irq_stat, cpu)

scripts/gdb/linux/interrupts.py +0 -0

@@ -118,32 +118,51 @@ irq_desc_type = utils.CachedType("struct
      text = x86_show_irqstat(prec, "NMI", '__nmi_count', 'Non-maskable interrupts')

     if constants.LX_CONFIG_X86_LOCAL_APIC:
-        text += x86_show_irqstat(prec, "LOC", 'apic_timer_irqs', "Local timer interrupts") -        text += x86_show_irqstat(prec, "SPU", 'irq_spurious_count', "Spurious interrupts") -        text += x86_show_irqstat(prec, "PMI", 'apic_perf_irqs', "Performance monitoring interrupts") -        text += x86_show_irqstat(prec, "IWI", 'apic_irq_work_irqs', "IRQ work interrupts") -        text += x86_show_irqstat(prec, "RTR", 'icr_read_retry_count', "APIC ICR read retries") +        text += x86_show_irqstat(prec, "LOC", 'APIC_TIMER', "Local timer interrupts")
+        text += x86_show_irqstat(prec, "SPU", 'SPURIOUS', "Spurious interrupts")
+        text += x86_show_irqstat(prec, "PMI", 'APIC_PERF', "Performance monitoring interrupts") +        text += x86_show_irqstat(prec, "IWI", 'IRQ_WORK', "IRQ work interrupts")
+        text += x86_show_irqstat(prec, "RTR", 'ICR_READ_RETRY', "APIC ICR read retries") if utils.gdb_eval_or_none("x86_platform_ipi_callback") is not None:
-            text += x86_show_irqstat(prec, "PLT", 'x86_platform_ipis', "Platform interrupts") +            text += x86_show_irqstat(prec, "PLT", 'X86_PLATFORM_IPI', "Platform interrupts")
     if constants.LX_CONFIG_SMP:
-        text += x86_show_irqstat(prec, "RES", 'irq_resched_count', "Rescheduling interrupts") -        text += x86_show_irqstat(prec, "CAL", 'irq_call_count', "Function call interrupts") -        text += x86_show_irqstat(prec, "TLB", 'irq_tlb_count', "TLB shootdowns")
+        text += x86_show_irqstat(prec, "RES", 'RESCHEDULE', "Rescheduling interrupts")
+        text += x86_show_irqstat(prec, "CAL", 'CALL_FUNCTION', "Function call interrupts") +
+    text += x86_show_irqstat(prec, "TLB", 'TLB', "TLB shootdowns")

     if constants.LX_CONFIG_X86_THERMAL_VECTOR:
-        text += x86_show_irqstat(prec, "TRM", 'irq_thermal_count', "Thermal events interrupts") +        text += x86_show_irqstat(prec, "TRM", 'THERMAL_APIC', "Thermal events interrupts")
     if constants.LX_CONFIG_X86_MCE_THRESHOLD:
-        text += x86_show_irqstat(prec, "THR", 'irq_threshold_count', "Threshold APIC interrupts") +        text += x86_show_irqstat(prec, "THR", 'THRESHOLD_APIC', "Threshold APIC interrupts")
     if constants.LX_CONFIG_X86_MCE_AMD:
-        text += x86_show_irqstat(prec, "DFR", 'irq_deferred_error_count', "Deferred Error APIC interrupts") +        text += x86_show_irqstat(prec, "DFR", 'DEFERRED_ERROR', "Deferred Error APIC interrupts")
     if constants.LX_CONFIG_X86_MCE:
         text += x86_show_mce(prec, "&mce_exception_count", "MCE", "Machine check exceptions") text += x86_show_mce(prec, "&mce_poll_count", "MCP", "Machine check polls")

+    if constants.LX_CONFIG_X86_HV_CALLBACK_VECTOR:
+        text += x86_show_irqstat(prec, 'HYP', 'HYPERVISOR_CALLBACK', 'Hypervisor callback interrupts')

scripts/gdb/linux/interrupts.py +16 -0

+
+    if constants.LX_CONFIG_HYPERV:
+        text += x86_show_irqstat(prec, 'HRE', 'HYPERV_REENLIGHTENMENT', 'Hyper-V reenlightenment interrupts')
+        text += x86_show_irqstat(prec, 'HVS', 'HYPERV_STIMER0', 'Hyper-V stimer0 interrupts')
+
+    if constants.LX_CONFIG_KVM:
+        text += x86_show_irqstat(prec, "PIN", 'POSTED_INTR', 'Posted-interrupt notification event')
+        text += x86_show_irqstat(prec, "NPI", 'POSTED_INTR_NESTED', 'Nested posted-interrupt event')
+        text += x86_show_irqstat(prec, "PIW", 'POSTED_INTR_WAKEUP', 'Posted-interrupt wakeup event')
+
+    if constants.LX_CONFIG_GUEST_PERF_EVENTS:
+        text += x86_show_irqstat(prec, "VPMI", 'PERF_GUEST_MEDIATED_PMI', 'Perf Guest Mediated PMI')
+
+    if constants.LX_CONFIG_X86_POSTED_MSI:
+        text += x86_show_irqstat(prec, "PIN", 'POSTED_MSI_NOTIFICATION', 'Posted MSI notification event')
+

     text += show_irq_err_count(prec)

     if constants.LX_CONFIG_X86_IO_APIC:

scripts/gdb/linux/interrupts.py +0 -0

@@ -151,11 +170,6 @@ irq_desc_type = utils.CachedType("struct

         if cnt is not None:
             text += "%*s: %10u\n" % (prec, "MIS", cnt['counter'])

Quoted 8 lines

-    if constants.LX_CONFIG_KVM:
-        text += x86_show_irqstat(prec, "PIN", 'kvm_posted_intr_ipis', 'Posted-interrupt notification event') -        text += x86_show_irqstat(prec, "NPI", 'kvm_posted_intr_nested_ipis', 'Nested posted-interrupt event') -        text += x86_show_irqstat(prec, "PIW", 'kvm_posted_intr_wakeup_ipis', 'Posted-interrupt wakeup event') -
     return text

 def arm_common_show_interrupts(prec):

On Tue, 2026-03-24 at 16:32 -0400, Radu Rendec wrote:

I tested it, and it's very close but requires a few extra changes, which I included as a patch at the bottom.

There's one more gotcha: in the next patch (patch 5) you rename nr_irqs to total_nr_irqs, and the change must be applied to interrupts.py as well. It's used at the beginning of the LxInterruptList.invoke() function.

Quoted 4 lines · Radu Rendec

On Tue, 2026-03-24 at 16:32 -0400, Radu Rendec wrote:

I tested it, and it's very close but requires a few extra changes, which I included as a patch at the bottom.

All of this is overly complicated. That can directly use the irq_stat_info array and therefore stays always in sync without ever touching that python nightmare again.

Replacement patch below (works only after 5/14 obviously).

Quoted 4 lines

There's one more gotcha: in the next patch (patch 5) you rename nr_irqs to total_nr_irqs, and the change must be applied to interrupts.py as well. It's used at the beginning of the LxInterruptList.invoke() function.

Sigh, yes. This GDB python insanity is a pain, debugging it even more so.

Quoted 1 line · Thomas Gleixner

Sigh, yes. This GDB python insanity is a pain, debugging it even more so.

All matter of perspective but kudos to you for trying to fix it, that is much appreciated.

Florian!

Quoted 5 lines · Florian Fainelli

Quoted 1 line · Thomas Gleixner

Sigh, yes. This GDB python insanity is a pain, debugging it even more so.

All matter of perspective but kudos to you for trying to fix it, that is much appreciated.

What bothers me most on the kernel side is that there is neither annotation, which tells something is used in a gdb script, nor a compile time check.

So if Radu hadn't noticed and pointed it out, I wouldn't have known about it at all.

The insanity snark was just my annoyance about the python integration into gdb. It's amazing that a debugger provides an extension interface which is undebuggable. But admittedly it's at least consistent with the rest of GDB's usability.

Quoted 2 lines · Thomas Gleixner

So if Radu hadn't noticed and pointed it out, I wouldn't have known about it at all.

Yes that's a fair point and it has been a complaint of mine whenever I had to use the GDB scripts because they get out of sync so easily with the code they are trying to parse, at some point it's not even fun.

This should still apply if you want to take it:

https://lore.kernel.org/all/[email protected]/

As far as ensuring that the C/Rust code stays in sync with GDB at compile time, did not have any bright idea about how to do that.

Quoted 4 lines · Radu Rendec

On Tue, 2026-03-24 at 16:32 -0400, Radu Rendec wrote:

I tested it, and it's very close but requires a few extra changes, which I included as a patch at the bottom.

All of this is overly complicated. That can directly use the irq_stat_info array and therefore stays always in sync without ever touching that python nightmare again.

Replacement patch below (works only after 5/14 obviously).

Quoted 4 lines

There's one more gotcha: in the next patch (patch 5) you rename nr_irqs to total_nr_irqs, and the change must be applied to interrupts.py as well. It's used at the beginning of the LxInterruptList.invoke() function.

Sigh, yes. This GDB python insanity is a pain, debugging it even more so.

---

scripts/gdb/linux/interrupts.py +0 -0

index f4f715a8f0e3..7fde52317e84 100644
@@ -97,13 +97,13 @@ def show_irq_err_count(prec):
          text += "%*s: %10u\n" % (prec, "ERR", cnt['counter'])

     return text

scripts/gdb/linux/interrupts.py +2 -2

-def x86_show_irqstat(prec, pfx, field, desc):
-    irq_stat = gdb.parse_and_eval("&irq_stat")
+def x86_show_irqstat(prec, pfx, idx, desc):
+    irq_stat = gdb.parse_and_eval("&irq_stat.counts[%d]" %idx)

     text = "%*s: " % (prec, pfx)
     for cpu in cpus.each_online_cpu():
         stat = cpus.per_cpu(irq_stat, cpu)
-        text += "%10u " % (stat[field])
-    text += "  %s\n" % (desc)
+        text += "%10u " % (stat.dereference())
+    text += desc
     return text

 def x86_show_mce(prec, var, pfx, desc):

scripts/gdb/linux/interrupts.py +0 -0

@@ -115,34 +115,14 @@ def x86_show_mce(prec, var, pfx, desc):

     return text

 def x86_show_interupts(prec):
-    text = x86_show_irqstat(prec, "NMI", '__nmi_count', 'Non-maskable interrupts')

scripts/gdb/linux/interrupts.py +2 -17

-
-    if constants.LX_CONFIG_X86_LOCAL_APIC:
-        text += x86_show_irqstat(prec, "LOC", 'apic_timer_irqs', "Local timer interrupts")
-        text += x86_show_irqstat(prec, "SPU", 'irq_spurious_count', "Spurious interrupts")
-        text += x86_show_irqstat(prec, "PMI", 'apic_perf_irqs', "Performance monitoring interrupts")
-        text += x86_show_irqstat(prec, "IWI", 'apic_irq_work_irqs', "IRQ work interrupts")
-        text += x86_show_irqstat(prec, "RTR", 'icr_read_retry_count', "APIC ICR read retries")
-        if utils.gdb_eval_or_none("x86_platform_ipi_callback") is not None:
-            text += x86_show_irqstat(prec, "PLT", 'x86_platform_ipis', "Platform interrupts")
-
-    if constants.LX_CONFIG_SMP:
-        text += x86_show_irqstat(prec, "RES", 'irq_resched_count', "Rescheduling interrupts")
-        text += x86_show_irqstat(prec, "CAL", 'irq_call_count', "Function call interrupts")
-        text += x86_show_irqstat(prec, "TLB", 'irq_tlb_count', "TLB shootdowns")
-
-    if constants.LX_CONFIG_X86_THERMAL_VECTOR:
-        text += x86_show_irqstat(prec, "TRM", 'irq_thermal_count', "Thermal events interrupts")
+    info_type = gdb.lookup_type('struct irq_stat_info')
+    info = gdb.parse_and_eval('irq_stat_info')

-    if constants.LX_CONFIG_X86_MCE_THRESHOLD:
-        text += x86_show_irqstat(prec, "THR", 'irq_threshold_count', "Threshold APIC interrupts")

scripts/gdb/linux/interrupts.py +5 -7

-
-    if constants.LX_CONFIG_X86_MCE_AMD:
-        text += x86_show_irqstat(prec, "DFR", 'irq_deferred_error_count', "Deferred Error APIC interrupts")
-
-    if constants.LX_CONFIG_X86_MCE:
-        text += x86_show_mce(prec, "&mce_exception_count", "MCE", "Machine check exceptions")
-        text += x86_show_mce(prec, "&mce_poll_count", "MCP", "Machine check polls")
+    text = ""
+    for idx in range(int(info.type.sizeof / info_type.sizeof)):
+        pfx = info[idx]['symbol'].string()
+        desc = info[idx]['text'].string()
+        text += x86_show_irqstat(prec, pfx, idx, desc)

     text += show_irq_err_count(prec)

scripts/gdb/linux/interrupts.py +0 -0

@@ -151,11 +131,6 @@ def x86_show_interupts(prec):

         if cnt is not None:
             text += "%*s: %10u\n" % (prec, "MIS", cnt['counter'])

-    if constants.LX_CONFIG_KVM:
-        text += x86_show_irqstat(prec, "PIN", 'kvm_posted_intr_ipis', 'Posted-interrupt notification event') -        text += x86_show_irqstat(prec, "NPI", 'kvm_posted_intr_nested_ipis', 'Nested posted-interrupt event') -        text += x86_show_irqstat(prec, "PIW", 'kvm_posted_intr_wakeup_ipis', 'Posted-interrupt wakeup event') -
     return text

 def arm_common_show_interrupts(prec):

scripts/gdb/linux/interrupts.py +0 -0

@@ -209,7 +184,7 @@ class LxInterruptList(gdb.Command):
          super(LxInterruptList, self).__init__("lx-interruptlist", gdb.COMMAND_DATA)

     def invoke(self, arg, from_tty):
-        nr_irqs = gdb.parse_and_eval("nr_irqs") +        nr_irqs = gdb.parse_and_eval("total_nr_irqs") prec = 3
         j = 1000
         while prec < 10 and j <= nr_irqs:

... to avoid function calls in the core code to retrieve the maximum number of interrupts.

Signed-off-by Thomas Gleixner <[email protected]>

Reviewed-by Dmitry Ilvokhin <[email protected]>

---
 kernel/irq/internals.h |    1 + kernel/irq/irqdesc.c   |   28 ++++++++++++++-------------- kernel/irq/proc.c      |    2 +-

 3 files changed, 16 insertions(+), 15 deletions(-)

kernel/irq/internals.h +0 -0

@@ -21,6 +21,7 @@

 extern bool noirqdebug;
 extern int irq_poll_cpu;
+extern unsigned int total_nr_irqs;

 extern struct irqaction chained_action;

kernel/irq/irqdesc.c +0 -0

@@ -140,14 +140,14 @@ static void desc_set_defaults(unsigned i
  	desc_smp_init(desc, node, affinity);
  }

kernel/irq/irqdesc.c +1 -1

-static unsigned int nr_irqs = NR_IRQS;
+unsigned int total_nr_irqs __read_mostly = NR_IRQS;

 /**
  * irq_get_nr_irqs() - Number of interrupts supported by the system. */
 unsigned int irq_get_nr_irqs(void)
 {

kernel/irq/irqdesc.c +1 -1

-	return nr_irqs;
+	return total_nr_irqs;

 }
 EXPORT_SYMBOL_GPL(irq_get_nr_irqs);

kernel/irq/irqdesc.c +1 -1

@@ -159,7 +159,7 @@ EXPORT_SYMBOL_GPL(irq_get_nr_irqs);
   */
  unsigned int irq_set_nr_irqs(unsigned int nr)
  {
-	nr_irqs = nr;
+	total_nr_irqs = nr;

  return nr;
 }

kernel/irq/irqdesc.c +0 -0

@@ -187,9 +187,9 @@ static unsigned int irq_find_at_or_after
  	struct irq_desc *desc;

  guard(rcu)();

kernel/irq/irqdesc.c +1 -1

-	desc = mt_find(&sparse_irqs, &index, nr_irqs);
+	desc = mt_find(&sparse_irqs, &index, total_nr_irqs);

kernel/irq/irqdesc.c +1 -1

-	return desc ? irq_desc_get_irq(desc) : nr_irqs;
+	return desc ? irq_desc_get_irq(desc) : total_nr_irqs;

 }

 static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)

kernel/irq/irqdesc.c +1 -1

@@ -543,7 +543,7 @@ static bool irq_expand_nr_irqs(unsigned
  {
  	if (nr > MAX_SPARSE_IRQS)
  		return false;
-	nr_irqs = nr;
+	total_nr_irqs = nr;
  	return true;
  }

kernel/irq/irqdesc.c +1 -1

@@ -557,16 +557,16 @@ int __init early_irq_init(void)
  	/* Let arch update nr_irqs and return the nr of preallocated irqs */
  	initcnt = arch_probe_nr_irqs();
  	printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
-	       NR_IRQS, nr_irqs, initcnt);
+	       NR_IRQS, total_nr_irqs, initcnt);

kernel/irq/irqdesc.c +2 -2

-	if (WARN_ON(nr_irqs > MAX_SPARSE_IRQS))
-		nr_irqs = MAX_SPARSE_IRQS;
+	if (WARN_ON(total_nr_irqs > MAX_SPARSE_IRQS))
+		total_nr_irqs = MAX_SPARSE_IRQS;

  if (WARN_ON(initcnt > MAX_SPARSE_IRQS))
  initcnt = MAX_SPARSE_IRQS;

kernel/irq/irqdesc.c +2 -2

-	if (initcnt > nr_irqs)
-		nr_irqs = initcnt;
+	if (initcnt > total_nr_irqs)
+		total_nr_irqs = initcnt;

  for (i = 0; i < initcnt; i++) {
  desc = alloc_desc(i, node, 0, NULL, NULL);

kernel/irq/irqdesc.c +0 -0

@@ -862,7 +862,7 @@ void irq_free_descs(unsigned int from, u
  {
  	int i;

kernel/irq/irqdesc.c +1 -1

-	if (from >= nr_irqs || (from + cnt) > nr_irqs)
+	if (from >= total_nr_irqs || (from + cnt) > total_nr_irqs)

  return;

  guard(mutex)(&sparse_irq_lock);

kernel/irq/irqdesc.c +0 -0

@@ -911,7 +911,7 @@ int __ref __irq_alloc_descs(int irq, uns
  	if (irq >=0 && start != irq)
  		return -EEXIST;

kernel/irq/irqdesc.c +1 -1

-	if (start + cnt > nr_irqs) {
+	if (start + cnt > total_nr_irqs) {

  if (!irq_expand_nr_irqs(start + cnt)) return -ENOMEM;
  }

kernel/irq/irqdesc.c +1 -1

@@ -923,7 +923,7 @@ EXPORT_SYMBOL_GPL(__irq_alloc_descs);
   * irq_get_next_irq - get next allocated irq number
   * @offset:	where to start the search
   *
- * Returns next irq number after offset or nr_irqs if none is found.
+ * Returns next irq number after offset or total_nr_irqs if none is found.
   */
  unsigned int irq_get_next_irq(unsigned int offset)
  {

kernel/irq/proc.c +0 -0

@@ -447,7 +447,7 @@ int __weak arch_show_interrupts(struct s
  }

 #ifndef ACTUAL_NR_IRQS

kernel/irq/proc.c +1 -1

-# define ACTUAL_NR_IRQS irq_get_nr_irqs()
+# define ACTUAL_NR_IRQS total_nr_irqs

 #endif

 #define ZSTR1 "          0"

Quoted 6 lines · Thomas Gleixner

 #ifndef ACTUAL_NR_IRQS

kernel/irq/proc.c +1 -1

-# define ACTUAL_NR_IRQS irq_get_nr_irqs()
+# define ACTUAL_NR_IRQS total_nr_irqs

 #endif

 #define ZSTR1 "          0"

Nit: This is modified again in the next patch, so it doesn't matter. But for the purpose of this patch in isolation, looking at where ACTUAL_NR_IRQS is used, in show_interrupts() the nr_irqs variable should also be initialized to total_nr_irqs to avoid the extra function call.

show_interrupts() evaluates a boatload of conditions to establish whether exposing an interrupt in /proc/interrupts or not.

That can be simplified by caching the condition in an internal status flag, which is updated when one of the relevant inputs changes.

As a result the number of instructions and branches for reading /proc/interrupts is reduced significantly.

Signed-off-by Thomas Gleixner <[email protected]>

Reviewed-by Dmitry Ilvokhin <[email protected]>

---
V2: s/IRQF_/IRQ/ and fixup the enum treatment - Dmitry
---
 include/linux/irq.h    |    1 + kernel/irq/chip.c      |    2 ++ kernel/irq/internals.h |    2 ++ kernel/irq/manage.c    |    2 ++ kernel/irq/proc.c      |   16 ++++++++++++---- kernel/irq/settings.h  |   13 +++++++++++++

 6 files changed, 32 insertions(+), 4 deletions(-)

include/linux/irq.h +1 -0

@@ -99,6 +99,7 @@ enum {
  	IRQ_DISABLE_UNLAZY	= (1 << 19),
  	IRQ_HIDDEN		= (1 << 20),
  	IRQ_NO_DEBUG		= (1 << 21),
+	IRQ_RESERVED		= (1 << 22),
  };

 #define IRQF_MODIFY_MASK \

kernel/irq/chip.c +1 -0

@@ -1004,6 +1004,7 @@ static void
  		WARN_ON(irq_chip_pm_get(irq_desc_get_irq_data(desc)));
  		irq_activate_and_startup(desc, IRQ_RESEND);
  	}
+	irq_proc_update_valid(desc);
  }

 void __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,

kernel/irq/chip.c +0 -0

@@ -1064,6 +1065,7 @@ void irq_modify_status(unsigned int irq,
  			trigger = tmp;

  irqd_set(&desc->irq_data, trigger);

kernel/irq/chip.c +1 -0

+		irq_proc_update_valid(desc);

  }
 }
 EXPORT_SYMBOL_GPL(irq_modify_status);

kernel/irq/internals.h +2 -0

@@ -123,6 +123,7 @@ extern void register_irq_proc(unsigned i
  extern void unregister_irq_proc(unsigned int irq, struct irq_desc *desc);
  extern void register_handler_proc(unsigned int irq, struct irqaction *action);
  extern void unregister_handler_proc(unsigned int irq, struct irqaction *action);
+void irq_proc_update_valid(struct irq_desc *desc);
  #else
  static inline void register_irq_proc(unsigned int irq, struct irq_desc *desc) { }
  static inline void unregister_irq_proc(unsigned int irq, struct irq_desc *desc) { }

@@ -130,6 +131,7 @@ static inline void register_handler_proc
  					 struct irqaction *action) { }
  static inline void unregister_handler_proc(unsigned int irq,
  					   struct irqaction *action) { }
+static inline void irq_proc_update_valid(struct irq_desc *desc) { }
  #endif

 extern bool irq_can_set_affinity_usr(unsigned int irq);

kernel/irq/manage.c +0 -0

@@ -1802,6 +1802,7 @@ static int
  		__enable_irq(desc);
  	}

kernel/irq/manage.c +1 -0

+	irq_proc_update_valid(desc);

  raw_spin_unlock_irqrestore(&desc->lock, flags); chip_bus_sync_unlock(desc); mutex_unlock(&desc->request_mutex);

kernel/irq/manage.c +0 -0

@@ -1906,6 +1907,7 @@ static struct irqaction *__free_irq(stru
  		desc->affinity_hint = NULL;
  #endif

kernel/irq/manage.c +1 -0

+	irq_proc_update_valid(desc);

  raw_spin_unlock_irqrestore(&desc->lock, flags);
  /*
  * Drop bus_lock here so the changes which were done in the chip

kernel/irq/proc.c +0 -0

@@ -439,6 +439,17 @@ void init_irq_proc(void)
  		register_irq_proc(irq, desc);
  }

kernel/irq/proc.c +5 -0

+		set = 0;
+
+	irq_settings_update_proc_valid(desc, set);
+}
+

 #ifdef CONFIG_GENERIC_IRQ_SHOW

 int __weak arch_show_interrupts(struct seq_file *p, int prec)

kernel/irq/proc.c +0 -0

@@ -514,10 +525,7 @@ int show_interrupts(struct seq_file *p,

  guard(rcu)();
  desc = irq_to_desc(i);

kernel/irq/proc.c +1 -4

-	if (!desc || irq_settings_is_hidden(desc))
-		return 0;
-
-	if (!desc->action || irq_desc_is_chained(desc) || !desc->kstat_irqs)
+	if (!desc || !irq_settings_proc_valid(desc))

  return 0;

  seq_printf(p, "%*d:", prec, i);

kernel/irq/settings.h +1 -0

@@ -18,6 +18,7 @@ enum {
  	_IRQ_DISABLE_UNLAZY	= IRQ_DISABLE_UNLAZY,
  	_IRQ_HIDDEN		= IRQ_HIDDEN,
  	_IRQ_NO_DEBUG		= IRQ_NO_DEBUG,
+	_IRQ_PROC_VALID		= IRQ_RESERVED,
  	_IRQF_MODIFY_MASK	= IRQF_MODIFY_MASK,
  };

kernel/irq/settings.h +1 -0

@@ -34,6 +35,7 @@ enum {
  #define IRQ_DISABLE_UNLAZY	GOT_YOU_MORON
  #define IRQ_HIDDEN		GOT_YOU_MORON
  #define IRQ_NO_DEBUG		GOT_YOU_MORON
+#define IRQ_RESERVED		GOT_YOU_MORON
  #undef IRQF_MODIFY_MASK
  #define IRQF_MODIFY_MASK	GOT_YOU_MORON

kernel/irq/settings.h +11 -0

@@ -180,3 +182,14 @@ static inline bool irq_settings_no_debug
  {
  	return desc->status_use_accessors & _IRQ_NO_DEBUG;
  }
+
+static inline bool irq_settings_proc_valid(struct irq_desc *desc)
+{
+	return desc->status_use_accessors & _IRQ_PROC_VALID;
+}
+
+static inline void irq_settings_update_proc_valid(struct irq_desc *desc, u32 set)
+{
+	desc->status_use_accessors &= ~_IRQ_PROC_VALID;
+	desc->status_use_accessors |= (set & _IRQ_PROC_VALID);
+}

Quoted 4 lines

kernel/irq/proc.c +4 -0

+void irq_proc_update_valid(struct irq_desc *desc)
+{
+	u32 set = _IRQ_PROC_VALID;
+

kernel/irq/proc.c void init_irq_proc(void) · line 447

Quoted 2 lines

kernel/irq/proc.c +2 -0

+	if (irq_settings_is_hidden(desc) || !desc->action ||
+	    irq_desc_is_chained(desc) || !desc->kstat_irqs)

Can desc->kstat_irqs ever be NULL? Looking at kernel/irq/irqdesc.c, it seems to me that it's allocated always and very early (before every other field in struct irq_desc), and with an explicit check for NULL on allocation. It's also deallocated late, right before struct irq_desc itself is deallocated (in irq_kobj_release()).

Quoted 4 lines · Radu Rendec

Quoted 4 lines

kernel/irq/proc.c +4 -0

+void irq_proc_update_valid(struct irq_desc *desc)
+{
+	u32 set = _IRQ_PROC_VALID;
+

Quoted 8 lines

kernel/irq/proc.c void init_irq_proc(void) · line 447

Quoted 2 lines

kernel/irq/proc.c +2 -0

+	if (irq_settings_is_hidden(desc) || !desc->action ||
+	    irq_desc_is_chained(desc) || !desc->kstat_irqs)

Can desc->kstat_irqs ever be NULL? Looking at kernel/irq/irqdesc.c, it seems to me that it's allocated always and very early (before every other field in struct irq_desc), and with an explicit check for NULL on allocation. It's also deallocated late, right before struct irq_desc itself is deallocated (in irq_kobj_release()).

Well spotted. That's a left over from histerical code.

Calculating the precision of the interrupt number column on every initial show_interrupt() invocation is a pointless exercise as the underlying maximum number of interrupts rarely changes.

Calculate it only when that number is modified and let show_interrupts() use the cached value.

Signed-off-by Thomas Gleixner <[email protected]>

Reviewed-by Dmitry Ilvokhin <[email protected]>

---
 kernel/irq/internals.h |    6 ++++++ kernel/irq/irqdesc.c   |   10 ++++++---- kernel/irq/proc.c      |   28 +++++++++++++++++++---------

 3 files changed, 31 insertions(+), 13 deletions(-)

kernel/irq/internals.h +0 -0

@@ -134,6 +134,12 @@ static inline void unregister_handler_pr
  static inline void irq_proc_update_valid(struct irq_desc *desc) { }
  #endif

kernel/irq/internals.h +6 -0

+#if defined(CONFIG_PROC_FS) && defined(CONFIG_GENERIC_IRQ_SHOW)
+void irq_proc_calc_prec(void);
+#else
+static inline void irq_proc_calc_prec(void) { }
+#endif
+

 extern bool irq_can_set_affinity_usr(unsigned int irq);
 extern int irq_do_set_affinity(struct irq_data *data,

kernel/irq/irqdesc.c +2 -3

@@ -157,13 +157,12 @@ EXPORT_SYMBOL_GPL(irq_get_nr_irqs);
   *
   * Return: @nr.
   */
-unsigned int irq_set_nr_irqs(unsigned int nr)
+unsigned int __init irq_set_nr_irqs(unsigned int nr)
  {
  	total_nr_irqs = nr;
-
+	irq_proc_calc_prec();
  	return nr;
  }
-EXPORT_SYMBOL_GPL(irq_set_nr_irqs);

 static DEFINE_MUTEX(sparse_irq_lock);
 static struct maple_tree sparse_irqs = MTREE_INIT_EXT(sparse_irqs,

kernel/irq/irqdesc.c +1 -0

@@ -544,6 +543,7 @@ static bool irq_expand_nr_irqs(unsigned
  	if (nr > MAX_SPARSE_IRQS)
  		return false;
  	total_nr_irqs = nr;
+	irq_proc_calc_prec();
  	return true;
  }

kernel/irq/irqdesc.c +1 -0

@@ -572,6 +572,7 @@ int __init early_irq_init(void)
  		desc = alloc_desc(i, node, 0, NULL, NULL);
  		irq_insert_desc(i, desc);
  	}
+	irq_proc_calc_prec();
  	return arch_early_irq_init();
  }

kernel/irq/irqdesc.c +0 -0

@@ -592,7 +593,7 @@ int __init early_irq_init(void)

  init_irq_default_affinity();

kernel/irq/irqdesc.c +1 -1

-	printk(KERN_INFO "NR_IRQS: %d\n", NR_IRQS);
+	pr_info("NR_IRQS: %d\n", NR_IRQS);

  count = ARRAY_SIZE(irq_desc);

kernel/irq/irqdesc.c +0 -0

@@ -602,6 +603,7 @@ int __init early_irq_init(void)
  			goto __free_desc_res;
  	}

kernel/irq/irqdesc.c +1 -0

+	irq_proc_calc_prec();

  return arch_early_irq_init();

 __free_desc_res:

kernel/irq/proc.c +0 -0

@@ -457,10 +457,21 @@ int __weak arch_show_interrupts(struct s
  	return 0;
  }

kernel/irq/proc.c +2 -0

+static int irq_num_prec __read_mostly = 3;
+

 #ifndef ACTUAL_NR_IRQS

 # define ACTUAL_NR_IRQS total_nr_irqs
 #endif
 

kernel/irq/proc.c +9 -0

+void irq_proc_calc_prec(void)
+{
+	unsigned int prec, n;
+
+	for (prec = 3, n = 1000; prec < 10 && n <= total_nr_irqs; ++prec)
+		n *= 10;
+	WRITE_ONCE(irq_num_prec, prec);
+}
+

 #define ZSTR1 "          0"
 #define ZSTR1_LEN (sizeof(ZSTR1) - 1)
 #define ZSTR16 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 ZSTR1 \

kernel/irq/proc.c +0 -0

@@ -499,8 +510,7 @@ void irq_proc_emit_counts(struct seq_fil

 int show_interrupts(struct seq_file *p, void *v)
 {

kernel/irq/proc.c +1 -2

-	const unsigned int nr_irqs = irq_get_nr_irqs();
-	static int prec;
+	int prec = READ_ONCE(irq_num_prec);

  int i = *(loff_t *) v, j;
  struct irqaction *action;

kernel/irq/proc.c +0 -0

@@ -514,9 +524,6 @@ int show_interrupts(struct seq_file *p,

  /* print header and calculate the width of the first column */ if (i == 0) {

kernel/irq/proc.c +0 -3

-		for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
-			j *= 10;
-

  seq_printf(p, "%*s", prec + 8, ""); for_each_online_cpu(j) seq_printf(p, "CPU%-8d", j);

kernel/irq/proc.c +3 -1

@@ -552,13 +559,16 @@ int show_interrupts(struct seq_file *p,
  	} else {
  		seq_printf(p, "%8s", "None");
  	}
+
+	seq_putc(p, ' ');
  	if (desc->irq_data.domain)
-		seq_printf(p, " %*lu", prec, desc->irq_data.hwirq);
+		seq_put_decimal_ull_width(p, "", desc->irq_data.hwirq, prec);

  else
  seq_printf(p, " %*s", prec, "");

kernel/irq/proc.c +4 -3

-#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
-	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
-#endif
+
+	if (IS_ENABLED(CONFIG_GENERIC_IRQ_SHOW_LEVEL))
+		seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
+

  if (desc->name)
  seq_printf(p, "-%-8s", desc->name);

Prepare for a smarter iterator for /proc/interrupts so that the next interrupt descriptor can be cached after lookup.

Signed-off-by Thomas Gleixner <[email protected]>

--- in preparation for a smarter iterator for /proc/interrupts.

Signed-off-by Thomas Gleixner <[email protected]>

---
 kernel/irq/internals.h |    2 ++
 kernel/irq/irqdesc.c   |   12 +++++-------
 2 files changed, 7 insertions(+), 7 deletions(-)