*** Detect interrupt storm in softlockup ***
v3 cover *** Detect interrupt storm in softlockup ***
Hi, guys.
I have implemented a low-overhead method for detecting interrupt storm in softlockup. Please review it, all comments are welcome.
Changes from v2 to v3:
- From Liu Song, using enum instead of macro for cpu_stats, shortening the name 'idx_to_stat' to 'stats', adding 'get_16bit_precesion' instead of using right shift operations, and using 'struct irq_counts'.
- From kernel robot test, using '__this_cpu_read' and '__this_cpu_write' instead of accessing to an per-cpu array directly, in order to avoid this warning.
'sparse: incorrect type in initializer (different modifiers)'
Changes from v1 to v2:
- From Douglas, optimize the memory of cpustats. With the maximum number of CPUs, that's now this.
2 * 8192 * 4 + 1 * 8192 * 5 * 4 + 1 * 8192 = 237,568 bytes.
- From Liu Song, refactor the code format and add necessary comments.
- From Douglas, use interrupt counts instead of interrupt time to determine the cause of softlockup.
- Remove the cmdline parameter added in PATCHv1.
Bitao Hu (2):
watchdog/softlockup: low-overhead detection of interrupt storm watchdog/softlockup: report the most frequent interrupts
kernel/watchdog.c | 240 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 240 insertions(+)
Signature · 1 line
2.37.1 (Apple Git-137.1)
PATCH v3 1/2 watchdog/softlockup: low-overhead detection of interrupt storm
The following softlockup is caused by interrupt storm, but it cannot be identified from the call tree. Because the call tree is just a snapshot and doesn't fully capture the behavior of the CPU during the soft lockup.
watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921]
...
Call trace:
__do_softirq+0xa0/0x37c
__irq_exit_rcu+0x108/0x140
irq_exit+0x14/0x20
__handle_domain_irq+0x84/0xe0
gic_handle_irq+0x80/0x108
el0_irq_naked+0x50/0x58Therefore,I think it is necessary to report CPU utilization during the softlockup_thresh period (report once every sample_period, for a total of 5 reportings), like this:
watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921]
CPU#28 Utilization every 4s during lockup:
#1: 0% system, 0% softirq, 100% hardirq, 0% idle
#2: 0% system, 0% softirq, 100% hardirq, 0% idle
#3: 0% system, 0% softirq, 100% hardirq, 0% idle
#4: 0% system, 0% softirq, 100% hardirq, 0% idle
#5: 0% system, 0% softirq, 100% hardirq, 0% idle
...This would be helpful in determining whether an interrupt storm has occurred or in identifying the cause of the softlockup. The criteria for determination are as follows:
a. If the hardirq utilization is high, then interrupt storm should be considered and the root cause cannot be determined from the call tree. b. If the softirq utilization is high, then we could analyze the call tree but it may cannot reflect the root cause.
c. If the system utilization is high, then we could analyze the root cause from the call tree.
--- kernel/watchdog.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+)
kernel/watchdog.c +84 -0
@@ -23,6 +23,8 @@#include <linux/sched/debug.h> #include <linux/sched/isolation.h> #include <linux/stop_machine.h> +#include <linux/kernel_stat.h> +#include <linux/math64.h> #include <asm/irq_regs.h> #include <linux/kvm_para.h>
@@ -441,6 +443,85 @@ static int is_softlockup(unsigned long touch_ts,return 0 ; } +#ifdef CONFIG_IRQ_TIME_ACCOUNTING +#define NUM_STATS_GROUPS 5 +enum stats_per_group { +STATS_SYSTEM , +STATS_SOFTIRQ , +STATS_HARDIRQ , +STATS_IDLE , +NUM_STATS_PER_GROUP , +}; +static enum cpu_usage_stat stats[NUM_STATS_PER_GROUP ] = { +CPUTIME_SYSTEM , +CPUTIME_SOFTIRQ , +CPUTIME_IRQ , +CPUTIME_IDLE , +}; +static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); +static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); +static DEFINE_PER_CPU(u8, cpustat_tail); + +/* +* We don't need nanosecond resolution. A granularity of 16ms is +* sufficient for our precision, allowing us to use u16 to store +* cpustats, which will roll over roughly every ~1000 seconds. +* 2^24 ~= 16 * 10^6 +*/ +static u16 get_16bit_precision (u64 data) +{ +return data >>24LL ;/* 2^24ns ~= 16.8ms */ +} + +static void update_cpustat (void ) +{ +u8 i; +u16 old; +u8 utilization; +u8 tail =__this_cpu_read (cpustat_tail); +struct kernel_cpustat kcpustat; +u64 *cpustat = kcpustat.cpustat; +u16 sample_period_ms =get_16bit_precision (sample_period); + +kcpustat_cpu_fetch (&kcpustat,smp_processor_id ()); +for (i =STATS_SYSTEM ; i <NUM_STATS_PER_GROUP ; i++) { + old =__this_cpu_read (cpustat_old[i]); + cpustat[stats[i]] =get_16bit_precision (cpustat[stats[i]]); + utilization =100 * (u16)(cpustat[stats[i]] - old) / sample_period_ms; +__this_cpu_write (cpustat_utilization[tail][i], utilization); +__this_cpu_write (cpustat_old[i], cpustat[stats[i]]); + } +__this_cpu_write (cpustat_tail, (tail +1 ) %NUM_STATS_GROUPS ); +} + +static void print_cpustat (void ) +{ +u8 i, j; +u8 tail =__this_cpu_read (cpustat_tail); +u64 sample_period_second = sample_period; + +do_div (sample_period_second,NSEC_PER_SEC ); +/* +* We do not want the "watchdog: " prefix on every line, +* hence we use "printk" instead of "pr_crit". +*/ +printk (KERN_CRIT "CPU#%d Utilization every %llus during lockup:\n" , +smp_processor_id (), sample_period_second); +for (j =STATS_SYSTEM , i = tail; j <NUM_STATS_GROUPS ; + j++, i = (i +1 ) %NUM_STATS_GROUPS ) { +printk (KERN_CRIT "\t#%d: %3u%% system,\t%3u%% softirq,\t" +"%3u%% hardirq,\t%3u%% idle\n" , j+1 , +__this_cpu_read (cpustat_utilization[i][STATS_SYSTEM ]), +__this_cpu_read (cpustat_utilization[i][STATS_SOFTIRQ ]), +__this_cpu_read (cpustat_utilization[i][STATS_HARDIRQ ]), +__this_cpu_read (cpustat_utilization[i][STATS_IDLE ])); + } +} +#else +static inline void update_cpustat (void ) { } +static inline void print_cpustat (void ) { } +#endif +/* watchdog detector functions */ static DEFINE_PER_CPU(struct completion, softlockup_completion); static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work);
@@ -504,6 +585,8 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)*/ period_ts =READ_ONCE (*this_cpu_ptr (&watchdog_report_ts)); +update_cpustat (); +/* Reset the interval when touched by known problematic code. */ if (period_ts ==SOFTLOCKUP_DELAY_REPORT ) {if (unlikely (__this_cpu_read (softlockup_touch_sync))) {
@@ -539,6 +622,7 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)pr_emerg ("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n" ,smp_processor_id (), duration, current->comm,task_pid_nr (current)); +print_cpustat ();print_modules ();print_irqtrace_events (current);if (regs)
Signature · 1 line
2.37.1 (Apple Git-137.1)
Re: [PATCHv3 1/2] watchdog/softlockup: low-overhead detection of interrupt storm
Hi,
Quoted 36 lines · Bitao Hu
The following softlockup is caused by interrupt storm, but it cannot be identified from the call tree. Because the call tree is just a snapshot and doesn't fully capture the behavior of the CPU during the soft lockup.
watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921] ... Call trace: __do_softirq+0xa0/0x37c __irq_exit_rcu+0x108/0x140 irq_exit+0x14/0x20 __handle_domain_irq+0x84/0xe0 gic_handle_irq+0x80/0x108 el0_irq_naked+0x50/0x58Therefore,I think it is necessary to report CPU utilization during the
softlockup_threshperiod (report once everysample_period, for a total of 5 reportings), like this:watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921] CPU#28 Utilization every 4s during lockup: #1: 0% system, 0% softirq, 100% hardirq, 0% idle #2: 0% system, 0% softirq, 100% hardirq, 0% idle #3: 0% system, 0% softirq, 100% hardirq, 0% idle #4: 0% system, 0% softirq, 100% hardirq, 0% idle #5: 0% system, 0% softirq, 100% hardirq, 0% idle ...This would be helpful in determining whether an interrupt storm has occurred or in identifying the cause of the softlockup. The criteria for determination are as follows:
a. If the hardirq utilization is high, then interrupt storm should be considered and the root cause cannot be determined from the call tree. b. If the softirq utilization is high, then we could analyze the call tree but it may cannot reflect the root cause.
c. If the system utilization is high, then we could analyze the root cause from the call tree.
Quoted 4 lines
Signed-off-by Bitao Hu <[email protected]>--- kernel/watchdog.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+)
Random high-level question: I'm trying to figure out exactly when your code will trigger. The only way it will trigger is if the timer interrupt is a higher priority than the storming interrupt. By this I don't mean that the timer will interrupt the storming one (it's not a nested interrupt), but that if both interrupts are currently asserted we'll service the timer first.
If the storming interrupt is always serviced before the timer interrupt then the softlockup code won't trigger at all. In that case we should detect a hard lockup and hopefully you've got the buddy detector enabled and pseudo-NMI turned on. Then hopefully we'll have actually interrupted the storming interrupt and it'll be on the callstack.
I just wanted to make sure I was understanding correctly. This is why you don't print the stats from watchdog_hardlockup_check() because they're not useful there, right?
kernel/watchdog.c line 27
Quoted 10 lines
kernel/watchdog.c +2
-0@@ -23,6 +23,8 @@#include <linux/sched/debug.h> #include <linux/sched/isolation.h> #include <linux/stop_machine.h> +#include <linux/kernel_stat.h> +#include <linux/math64.h>
nit: instead of adding to the end, add these in sorted order. The includes we have now are _almost_ in sorted order. I'd add these between "init.h" and "module.h"
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 446
Quoted 7 lines
kernel/watchdog.c +1
-0#include <asm/irq_regs.h> #include <linux/kvm_para.h> @@ -441,6 +443,85 @@ static int is_softlockup(unsigned long touch_ts,return 0 ; } +#ifdef CONFIG_IRQ_TIME_ACCOUNTING
In v1 I think I suggested adding a new config. Even with your optimizations you've quoted this as taking up "237,568 bytes" of global storage when things are configured for the max number of CPUs. It feels like someone might not want that. Adding a new Kconfig knob shouldn't be a huge problem. Maybe you can have it default to "yes" if the max number of CPUs is <= 64 or 128 or something?
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 455
Quoted 9 lines
kernel/watchdog.c +9
-0+#define NUM_STATS_GROUPS 5 +enum stats_per_group { +STATS_SYSTEM , +STATS_SOFTIRQ , +STATS_HARDIRQ , +STATS_IDLE , +NUM_STATS_PER_GROUP , +}; +static enum cpu_usage_stat stats[NUM_STATS_PER_GROUP ] = {
"static const", not just "static"
nit: maybe call this "tracked_stats" since "stats" is a bit of a generic name for a global.
Quoted 6 lines
kernel/watchdog.c +6
-0+CPUTIME_SYSTEM , +CPUTIME_SOFTIRQ , +CPUTIME_IRQ , + CPUTIME_IDLE, +}; +static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]);
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 471
Quoted 10 lines
kernel/watchdog.c +10
-0+static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); +static DEFINE_PER_CPU(u8, cpustat_tail); + +/* +* We don't need nanosecond resolution. A granularity of 16ms is +* sufficient for our precision, allowing us to use u16 to store +* cpustats, which will roll over roughly every ~1000 seconds. +* 2^24 ~= 16 * 10^6 +*/ +static u16 get_16bit_precision (u64 data)
nit: instead of "data", call it "data_ns"
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 478
Quoted 7 lines
kernel/watchdog.c +7
-0+{ +return data >>24LL ;/* 2^24ns ~= 16.8ms */ +} + +static void update_cpustat (void ) +{ +u8 i;
FWIW, Andrew Morton (who will likely be the one landing this patch) was quoted in LWN [1] the other week saying that "i" should be an integer. :-P Making it an "int" won't make the code any less efficient.
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 484
Quoted 6 lines
kernel/watchdog.c +6
-0+u16 old; +u8 utilization; +u8 tail =__this_cpu_read (cpustat_tail); +struct kernel_cpustat kcpustat; +u64 *cpustat = kcpustat.cpustat; +u16 sample_period_ms =get_16bit_precision (sample_period);
It's not really milliseconds, right? Maybe "sample_period_16"?
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 487
Quoted 2 lines
kernel/watchdog.c +2
-0+kcpustat_cpu_fetch (&kcpustat,smp_processor_id ()); +for (i =STATS_SYSTEM ; i <NUM_STATS_PER_GROUP ; i++) {
nit: start i as 0 instead of assuming that STATS_SYSTEM is 0.
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 489
Quoted 2 lines
kernel/watchdog.c +2
-0+ old =__this_cpu_read (cpustat_old[i]); + cpustat[stats[i]] =get_16bit_precision (cpustat[stats[i]]);
IMO make a local called "new" and store the 16-bit precision there. That's easier to read, gets rid of the cast below, and is probably more efficient (the compiler doesn't need to upcast the 16-bit value and store it in a 64-bit memory location). ...oh, or maybe "new" is a reserved keyword? You could call them "old_stat_16" and "new_stat_16".
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 490
Quoted 1 line
kernel/watchdog.c +1
-0+ utilization =100 * (u16)(cpustat[stats[i]] - old) / sample_period_ms;
Maybe slightly better to round, with:
utilization = DIV_ROUND_UP(100 * (new - old), sample_period_ms);
What do you think?
Quoted 10 lines
kernel/watchdog.c +10
-0+__this_cpu_write (cpustat_utilization[tail][i], utilization); +__this_cpu_write (cpustat_old[i], cpustat[stats[i]]); + } +__this_cpu_write (cpustat_tail, (tail +1 ) %NUM_STATS_GROUPS ); +} + +static void print_cpustat (void ) +{ +u8 i, j; +u8 tail =__this_cpu_read (cpustat_tail);
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 510
Quoted 10 lines
kernel/watchdog.c +10
-0+u64 sample_period_second = sample_period; + +do_div (sample_period_second,NSEC_PER_SEC ); +/* +* We do not want the "watchdog: " prefix on every line, +* hence we use "printk" instead of "pr_crit". +*/ +printk (KERN_CRIT "CPU#%d Utilization every %llus during lockup:\n" , +smp_processor_id (), sample_period_second); + for (j = STATS_SYSTEM, i = tail; j < NUM_STATS_GROUPS;
Here initting "j" to STATS_SYSTEM definitely doesn't make sense. Init to 0.
You could also make your loop easier to understand with just:
for (i = 0; i < NUM_STATS_GROUPS; i++) {
unsigned int group = (tail + i) % NUM_STATS_GROUPS;
-Doug
Re: [PATCHv3 1/2] watchdog/softlockup: low-overhead detection of interrupt storm
Quoted 58 lines · Doug Anderson
Hi,
Quoted 36 lines · Bitao Hu
The following softlockup is caused by interrupt storm, but it cannot be identified from the call tree. Because the call tree is just a snapshot and doesn't fully capture the behavior of the CPU during the soft lockup.
watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921] ... Call trace: __do_softirq+0xa0/0x37c __irq_exit_rcu+0x108/0x140 irq_exit+0x14/0x20 __handle_domain_irq+0x84/0xe0 gic_handle_irq+0x80/0x108 el0_irq_naked+0x50/0x58Therefore,I think it is necessary to report CPU utilization during the
softlockup_threshperiod (report once everysample_period, for a total of 5 reportings), like this:watchdog: BUG: soft lockup - CPU#28 stuck for 23s! [fio:83921] CPU#28 Utilization every 4s during lockup: #1: 0% system, 0% softirq, 100% hardirq, 0% idle #2: 0% system, 0% softirq, 100% hardirq, 0% idle #3: 0% system, 0% softirq, 100% hardirq, 0% idle #4: 0% system, 0% softirq, 100% hardirq, 0% idle #5: 0% system, 0% softirq, 100% hardirq, 0% idle ...This would be helpful in determining whether an interrupt storm has occurred or in identifying the cause of the softlockup. The criteria for determination are as follows:
a. If the hardirq utilization is high, then interrupt storm should be considered and the root cause cannot be determined from the call tree. b. If the softirq utilization is high, then we could analyze the call tree but it may cannot reflect the root cause.
c. If the system utilization is high, then we could analyze the root cause from the call tree.Quoted 4 lines
Signed-off-by Bitao Hu <[email protected]>--- kernel/watchdog.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+)Random high-level question: I'm trying to figure out exactly when your code will trigger. The only way it will trigger is if the timer interrupt is a higher priority than the storming interrupt. By this I don't mean that the timer will interrupt the storming one (it's not a nested interrupt), but that if both interrupts are currently asserted we'll service the timer first.
If the storming interrupt is always serviced before the timer interrupt then the softlockup code won't trigger at all. In that case we should detect a hard lockup and hopefully you've got the buddy detector enabled and pseudo-NMI turned on. Then hopefully we'll have actually interrupted the storming interrupt and it'll be on the callstack.
Quoted 3 lines
I just wanted to make sure I was understanding correctly. This is why you don't print the stats from
watchdog_hardlockup_check()because they're not useful there, right?
Yes, you are right. The scenario I'm considering matches your description. If the storming interrupt lead to a soft lockup, then it will not be on the callstack. In this case, we need the stats.
Quoted 16 lines
kernel/watchdog.c line 27
Quoted 12 lines
kernel/watchdog.c +2
-0@@ -23,6 +23,8 @@#include <linux/sched/debug.h> #include <linux/sched/isolation.h> #include <linux/stop_machine.h> +#include <linux/kernel_stat.h> +#include <linux/math64.h> nit: instead of adding to the end, add these in sorted order. The includes we have now are _almost_ in sorted order. I'd add these between "
init.h" and "module.h"
Sure, I will standardize the code.
Quoted 8 lines
Quoted 8 lines
kernel/watchdog.c +0
-0#include <asm/irq_regs.h> #include <linux/kvm_para.h> @@ -441,6 +443,85 @@ static int is_softlockup(unsigned long touch_ts,return 0 ; }
Quoted 8 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 446
Quoted 1 line
kernel/watchdog.c +1
-0+#ifdef CONFIG_IRQ_TIME_ACCOUNTING In v1 I think I suggested adding a new config. Even with your optimizations you've quoted this as taking up "237,568 bytes" of global storage when things are configured for the max number of CPUs. It feels like someone might not want that. Adding a new
Kconfigknob shouldn't be a huge problem. Maybe you can have it default to "yes" if the max number of CPUs is <= 64 or 128 or something?
Sure, I will add a new config.
Quoted 13 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 455
Quoted 11 lines
kernel/watchdog.c +9
-0+#define NUM_STATS_GROUPS 5 +enum stats_per_group { +STATS_SYSTEM , +STATS_SOFTIRQ , +STATS_HARDIRQ , +STATS_IDLE , +NUM_STATS_PER_GROUP , +}; +static enum cpu_usage_stat stats[NUM_STATS_PER_GROUP ] = {"static const", not just "static"
OK.
Quoted 3 lines
nit: maybe call this "
tracked_stats" since "stats" is a bit of a generic name for a global.
Agree, it is clearer.
Quoted 12 lines
Quoted 12 lines
kernel/watchdog.c +10
-0+CPUTIME_SYSTEM , +CPUTIME_SOFTIRQ , +CPUTIME_IRQ , + CPUTIME_IDLE, +}; +static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); +static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); +static DEFINE_PER_CPU(u8, cpustat_tail); + +/*
Quoted 8 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 471
Quoted 6 lines
kernel/watchdog.c +6
-0+* We don't need nanosecond resolution. A granularity of 16ms is +* sufficient for our precision, allowing us to use u16 to store +* cpustats, which will roll over roughly every ~1000 seconds. +* 2^24 ~= 16 * 10^6 +*/ +static u16 get_16bit_precision (u64 data)nit: instead of "data", call it "
data_ns"
OK.
Quoted 15 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 478
Quoted 9 lines
kernel/watchdog.c +7
-0+{ +return data >>24LL ;/* 2^24ns ~= 16.8ms */ +} + +static void update_cpustat (void ) +{ +u8 i;FWIW, Andrew Morton (who will likely be the one landing this patch) was quoted in LWN [1] the other week saying that "i" should be an integer. :-P Making it an "int" won't make the code any less efficient.
Quoted 1 line
OK, I will use "int" here.
Quoted 10 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 484
Quoted 8 lines
kernel/watchdog.c +6
-0+u16 old; +u8 utilization; +u8 tail =__this_cpu_read (cpustat_tail); +struct kernel_cpustat kcpustat; +u64 *cpustat = kcpustat.cpustat; +u16 sample_period_ms =get_16bit_precision (sample_period);It's not really milliseconds, right? Maybe "
sample_period_16"?
Agree, it is clearer.
Quoted 6 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 487
Quoted 4 lines
kernel/watchdog.c +2
-0+kcpustat_cpu_fetch (&kcpustat,smp_processor_id ()); +for (i =STATS_SYSTEM ; i <NUM_STATS_PER_GROUP ; i++) {nit: start i as 0 instead of assuming that
STATS_SYSTEMis 0.
OK.
Quoted 9 lines
kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 489
Quoted 4 lines
kernel/watchdog.c +2
-0+ old =__this_cpu_read (cpustat_old[i]); + cpustat[stats[i]] =get_16bit_precision (cpustat[stats[i]]);IMO make a local called "new" and store the 16-bit precision there. That's easier to read, gets rid of the cast below, and is probably more efficient (the compiler doesn't need to upcast the 16-bit value and store it in a 64-bit memory location).
Oh, that's interesting, I hadn't thought of that.
...oh, or maybe "new" is a
Quoted 10 lines
reserved keyword? You could call them "
old_stat_16" and "new_stat_16".kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 490
Quoted 1 line
kernel/watchdog.c +1
-0+ utilization =100 * (u16)(cpustat[stats[i]] - old) / sample_period_ms;Maybe slightly better to round, with:
utilization =
DIV_ROUND_UP(100 * (new - old), sample_period_ms);What do you think?
Agree, I will use your method.
Quoted 25 lines
Quoted 12 lines
kernel/watchdog.c +10
-0+__this_cpu_write (cpustat_utilization[tail][i], utilization); +__this_cpu_write (cpustat_old[i], cpustat[stats[i]]); + } +__this_cpu_write (cpustat_tail, (tail +1 ) %NUM_STATS_GROUPS ); +} + +static void print_cpustat (void ) +{ +u8 i, j; +u8 tail =__this_cpu_read (cpustat_tail);kernel/watchdog.c static int is_softlockup(unsigned long touch_ts, · line 510
Quoted 10 lines
kernel/watchdog.c +10
-0+u64 sample_period_second = sample_period; + +do_div (sample_period_second,NSEC_PER_SEC ); +/* +* We do not want the "watchdog: " prefix on every line, +* hence we use "printk" instead of "pr_crit". +*/ +printk (KERN_CRIT "CPU#%d Utilization every %llus during lockup:\n" , +smp_processor_id (), sample_period_second); + for (j = STATS_SYSTEM, i = tail; j < NUM_STATS_GROUPS;Here initting "j" to
STATS_SYSTEMdefinitely doesn't make sense. Init to 0.
Quoted 5 lines
You could also make your loop easier to understand with just:
for (i = 0; i < NUM_STATS_GROUPS; i++) { unsigned int group = (tail + i) % NUM_STATS_GROUPS;
Agree, it is easier to read.
Quoted 2 lines
-Doug
PATCH v3 2/2 watchdog/softlockup: report the most frequent interrupts
In reply to Bitao HuWhen the watchdog determines that the current soft lockup is due to an interrupt storm based on CPU utilization, reporting the most frequent interrupts could be good enough for further troubleshooting.
Below is an example of interrupt storm. The call tree does not provide useful information, but we can analyze which interrupt caused the soft lockup by comparing the counts of interrupts.
[ 2987.488075] watchdog: BUG: soft lockup - CPU#9 stuck for 23s! [kworker/9:1:214] [ 2987.488607] CPU#9 Utilization every 4s during lockup: [ 2987.488941] #1: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489357] #2: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489771] #3: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490186] #4: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490601] #5: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.491034] CPU#9 Detect HardIRQ Time exceeds 50%. Most frequent HardIRQs: [ 2987.491493] #1: 330985 irq#7(IPI) [ 2987.491743] #2: 5000 irq#10(arch_timer) [ 2987.492039] #3: 9 irq#91(nvme0q2) [ 2987.492318] #4: 3 irq#118(virtio1-output.12) ... [ 2987.492728] Call trace: [ 2987.492729] __do_softirq+0xa8/0x364
--- kernel/watchdog.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+)
kernel/watchdog.c +156 -0
@@ -25,6 +25,9 @@#include <linux/stop_machine.h> #include <linux/kernel_stat.h> #include <linux/math64.h> +#include <linux/irq.h> +#include <linux/bitops.h> +#include <linux/irqdesc.h> #include <asm/irq_regs.h> #include <linux/kvm_para.h>
@@ -431,11 +434,15 @@ void touch_softlockup_watchdog_sync(void)__this_cpu_write (watchdog_report_ts,SOFTLOCKUP_DELAY_REPORT ); } +static void set_potential_softlockup (unsigned long now,unsigned long touch_ts); +static int is_softlockup (unsigned long touch_ts,unsigned long period_ts,unsigned long now) {if ((watchdog_enabled &WATCHDOG_SOFTOCKUP_ENABLED ) && watchdog_thresh) { +/* Softlockup may occur in the current period */ +set_potential_softlockup (now, period_ts);/* Warn about unreasonable delays. */ if (time_after (now, period_ts +get_softlockup_thresh ()))return now - touch_ts;
@@ -462,6 +469,8 @@ static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_tail); +static void print_hardirq_counts (void ); +/* * We don't need nanosecond resolution. A granularity of 16ms is * sufficient for our precision, allowing us to use u16 to store
@@ -516,10 +525,156 @@ static void print_cpustat(void)__this_cpu_read (cpustat_utilization[i][STATS_HARDIRQ ]), __this_cpu_read(cpustat_utilization[i][STATS_IDLE])); } +print_hardirq_counts (); +} + +#define HARDIRQ_PERCENT_THRESH 50 +#define NUM_HARDIRQ_REPORT 5 +static DECLARE_BITMAP(softlockup_hardirq_cpus, CONFIG_NR_CPUS); +static DEFINE_PER_CPU(u32 *, hardirq_counts); + +struct irq_counts { +int irq; +u32 counts; +}; + +static void find_counts_top (struct irq_counts *irq_counts,int irq,u32 counts,int range) +{ +unsigned int i, j; + +for (i =0 ; i < range; i++) { +if (counts > irq_counts[i].counts) { +for (j = range -1 ; j > i; j--) { + irq_counts[j].counts = irq_counts[j -1 ].counts; + irq_counts[j].irq = irq_counts[j -1 ].irq; + } + irq_counts[j].counts = counts; + irq_counts[j].irq = irq; +break ; + } + } +} + +/* +* If the proportion of time spent handling irq exceeds HARDIRQ_PERCENT_THRESH% +* during sample_period, then it is necessary to record the counts of each irq. +*/ +static inline bool need_record_irq_counts (int type) +{ +int tail =__this_cpu_read (cpustat_tail); +u8 utilization; + +if (--tail ==-1 ) + tail =4 ; + utilization =__this_cpu_read (cpustat_utilization[tail][type]); +return utilization >HARDIRQ_PERCENT_THRESH ; +} + +/* +* Mark softlockup as potentially caused by hardirq +*/ +static void set_potential_softlockup_hardirq (void ) +{ +u32 i; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_desc *desc; + +if (!need_record_irq_counts (STATS_HARDIRQ )) +return ; + +if (!test_bit (cpu, softlockup_hardirq_cpus)) { + counts =kmalloc_array (nr_irqs,sizeof (u32),GFP_ATOMIC ); +if (!counts) +return ; +for_each_irq_desc (i, desc) { +if (!desc) +continue ; + counts[i] = desc->kstat_irqs ? + *this_cpu_ptr (desc->kstat_irqs) :0 ; + } +__this_cpu_write (hardirq_counts, counts); +set_bit (cpu, softlockup_hardirq_cpus); + } +} + +static void clear_potential_softlockup_hardirq (void ) +{ +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); + +if (test_bit (cpu, softlockup_hardirq_cpus)) { +kfree (counts); + counts =NULL ; +__this_cpu_write (hardirq_counts, counts); +clear_bit (cpu, softlockup_hardirq_cpus); + } } + +/* +* Mark that softlockup may occur +*/ +static void set_potential_softlockup (unsigned long now,unsigned long period_ts) +{ +if (time_after_eq (now, period_ts +get_softlockup_thresh () /5 )) +set_potential_softlockup_hardirq (); +} + +static void clear_potential_softlockup (void ) +{ +clear_potential_softlockup_hardirq (); +} + +static void print_hardirq_counts (void ) +{ +u32 i; +struct irq_desc *desc; +u32 counts_diff; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_counts hardirq_counts_top[NUM_HARDIRQ_REPORT ] = { + {-1 ,0 }, {-1 ,0 }, {-1 ,0 }, {-1 ,0 }, + }; + +if (test_bit (cpu, softlockup_hardirq_cpus)) { +/* Find the top NUM_HARDIRQ_REPORT most frequent interrupts */ +for_each_irq_desc (i, desc) { +if (!desc) +continue ; + counts_diff = desc->kstat_irqs ? + *this_cpu_ptr (desc->kstat_irqs) - counts[i] :0 ; +find_counts_top (hardirq_counts_top, i, counts_diff, +NUM_HARDIRQ_REPORT ); + } +/* +* We do not want the "watchdog: " prefix on every line, +* hence we use "printk" instead of "pr_crit". +*/ +printk (KERN_CRIT "CPU#%d Detect HardIRQ Time exceeds %d%%. Most frequent HardIRQs:\n" , +smp_processor_id (),HARDIRQ_PERCENT_THRESH ); +for (i =0 ; i <NUM_HARDIRQ_REPORT ; i++) { +if (hardirq_counts_top[i].irq ==-1 ) +break ; + desc =irq_to_desc (hardirq_counts_top[i].irq); +if (desc && desc->action) +printk (KERN_CRIT "\t#%u: %-10u\tirq#%d(%s)\n" , + i+1 , hardirq_counts_top[i].counts, + hardirq_counts_top[i].irq, desc->action->name); +else +printk (KERN_CRIT "\t#%u: %-10u\tirq#%d\n" , + i+1 , hardirq_counts_top[i].counts, + hardirq_counts_top[i].irq); + } +if (!need_record_irq_counts (STATS_HARDIRQ )) +clear_potential_softlockup_hardirq (); + } +} +#else static inline void update_cpustat (void ) { }static inline void print_cpustat (void ) { } +static inline void set_potential_softlockup (unsigned long now,unsigned long period_ts) { } +static inline void clear_potential_softlockup (void ) { }#endif /* watchdog detector functions */
@@ -537,6 +692,7 @@ static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work);static int softlockup_fn (void *data) {update_touch_ts (); +clear_potential_softlockup ();complete (this_cpu_ptr (&softlockup_completion));return 0 ;
Signature · 1 line
2.37.1 (Apple Git-137.1)
Re: [PATCHv3 2/2] watchdog/softlockup: report the most frequent interrupts
Quoted 90 lines · Bitao Hu
When the watchdog determines that the current soft lockup is due to an interrupt storm based on CPU utilization, reporting the most frequent interrupts could be good enough for further troubleshooting.
Below is an example of interrupt storm. The call tree does not provide useful information, but we can analyze which interrupt caused the soft lockup by comparing the counts of interrupts.
[ 2987.488075] watchdog: BUG: soft lockup - CPU#9 stuck for 23s! [kworker/9:1:214] [ 2987.488607] CPU#9 Utilization every 4s during lockup: [ 2987.488941] #1: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489357] #2: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489771] #3: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490186] #4: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490601] #5: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.491034] CPU#9 Detect HardIRQ Time exceeds 50%. Most frequent HardIRQs: [ 2987.491493] #1: 330985 irq#7(IPI) [ 2987.491743] #2: 5000 irq#10(arch_timer) [ 2987.492039] #3: 9 irq#91(nvme0q2) [ 2987.492318] #4: 3 irq#118(virtio1-output.12) ... [ 2987.492728] Call trace: [ 2987.492729] __do_softirq+0xa8/0x364Signed-off-by Bitao Hu <[email protected]>--- kernel/watchdog.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+)kernel/watchdog.c +26
-0@@ -25,6 +25,9 @@#include <linux/stop_machine.h> #include <linux/kernel_stat.h> #include <linux/math64.h> +#include <linux/irq.h> +#include <linux/bitops.h> +#include <linux/irqdesc.h> #include <asm/irq_regs.h> #include <linux/kvm_para.h> @@ -431,11 +434,15 @@ void touch_softlockup_watchdog_sync(void)__this_cpu_write (watchdog_report_ts,SOFTLOCKUP_DELAY_REPORT ); } +static void set_potential_softlockup (unsigned long now,unsigned long touch_ts); +static int is_softlockup (unsigned long touch_ts,unsigned long period_ts,unsigned long now) {if ((watchdog_enabled &WATCHDOG_SOFTOCKUP_ENABLED ) && watchdog_thresh) { +/* Softlockup may occur in the current period */ +set_potential_softlockup (now, period_ts);/* Warn about unreasonable delays. */ if (time_after (now, period_ts +get_softlockup_thresh ()))return now - touch_ts;@@ -462,6 +469,8 @@ static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_tail); +static void print_hardirq_counts (void ); +/* * We don't need nanosecond resolution. A granularity of 16ms is * sufficient for our precision, allowing us to use u16 to store @@ -516,10 +525,156 @@ static void print_cpustat(void)__this_cpu_read (cpustat_utilization[i][STATS_HARDIRQ ]), __this_cpu_read(cpustat_utilization[i][STATS_IDLE])); } +print_hardirq_counts (); +} + +#define HARDIRQ_PERCENT_THRESH 50 +#define NUM_HARDIRQ_REPORT 5 +static DECLARE_BITMAP(softlockup_hardirq_cpus, CONFIG_NR_CPUS); +static DEFINE_PER_CPU(u32 *, hardirq_counts); + +struct irq_counts { +int irq; +u32 counts; +}; + +static void find_counts_top (struct irq_counts *irq_counts,int irq,u32 counts,int range) +{ +unsigned int i, j; +
kernel/watchdog.c static void print_cpustat(void) · line 554
Quoted 10 lines
kernel/watchdog.c +10
-0+for (i =0 ; i < range; i++) { +if (counts > irq_counts[i].counts) { +for (j = range -1 ; j > i; j--) { + irq_counts[j].counts = irq_counts[j -1 ].counts; + irq_counts[j].irq = irq_counts[j -1 ].irq; + } + irq_counts[j].counts = counts; + irq_counts[j].irq = irq; +break ; + }
The current implementation can lead to a reordering with each iteration. It is recommended to update in place if the value is larger and perform the reordering just before printing at the end.
Quoted 62 lines
kernel/watchdog.c +61
-0+ } +} + +/* +* If the proportion of time spent handling irq exceeds HARDIRQ_PERCENT_THRESH% +* during sample_period, then it is necessary to record the counts of each irq. +*/ +static inline bool need_record_irq_counts (int type) +{ +int tail =__this_cpu_read (cpustat_tail); +u8 utilization; + +if (--tail ==-1 ) + tail =4 ; + utilization =__this_cpu_read (cpustat_utilization[tail][type]); +return utilization >HARDIRQ_PERCENT_THRESH ; +} + +/* +* Mark softlockup as potentially caused by hardirq +*/ +static void set_potential_softlockup_hardirq (void ) +{ +u32 i; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_desc *desc; + +if (!need_record_irq_counts (STATS_HARDIRQ )) +return ; + +if (!test_bit (cpu, softlockup_hardirq_cpus)) { + counts =kmalloc_array (nr_irqs,sizeof (u32),GFP_ATOMIC ); +if (!counts) +return ; +for_each_irq_desc (i, desc) { +if (!desc) +continue ; + counts[i] = desc->kstat_irqs ? + *this_cpu_ptr (desc->kstat_irqs) :0 ; + } +__this_cpu_write (hardirq_counts, counts); +set_bit (cpu, softlockup_hardirq_cpus); + } +} + +static void clear_potential_softlockup_hardirq (void ) +{ +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); + +if (test_bit (cpu, softlockup_hardirq_cpus)) { +kfree (counts); + counts =NULL ; +__this_cpu_write (hardirq_counts, counts); +clear_bit (cpu, softlockup_hardirq_cpus); + } } + +/* +* Mark that softlockup may occur +*/
kernel/watchdog.c static void print_cpustat(void) · line 626
Quoted 10 lines
kernel/watchdog.c +10
-0+static void set_potential_softlockup (unsigned long now,unsigned long period_ts) +{ +if (time_after_eq (now, period_ts +get_softlockup_thresh () /5 )) +set_potential_softlockup_hardirq (); +} + +static void clear_potential_softlockup (void ) +{ +clear_potential_softlockup_hardirq (); +}
Given that clear_potential_softlockup will only call clear_potential_softlockup_hardirq, then why is there a need to declare clear_potential_softlockup separately?
Quoted 62 lines
kernel/watchdog.c +49
-0+ +static void print_hardirq_counts (void ) +{ +u32 i; +struct irq_desc *desc; +u32 counts_diff; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_counts hardirq_counts_top[NUM_HARDIRQ_REPORT ] = { + {-1 ,0 }, {-1 ,0 }, {-1 ,0 }, {-1 ,0 }, + }; + +if (test_bit (cpu, softlockup_hardirq_cpus)) { +/* Find the top NUM_HARDIRQ_REPORT most frequent interrupts */ +for_each_irq_desc (i, desc) { +if (!desc) +continue ; + counts_diff = desc->kstat_irqs ? + *this_cpu_ptr (desc->kstat_irqs) - counts[i] :0 ; +find_counts_top (hardirq_counts_top, i, counts_diff, +NUM_HARDIRQ_REPORT ); + } +/* +* We do not want the "watchdog: " prefix on every line, +* hence we use "printk" instead of "pr_crit". +*/ +printk (KERN_CRIT "CPU#%d Detect HardIRQ Time exceeds %d%%. Most frequent HardIRQs:\n" , +smp_processor_id (),HARDIRQ_PERCENT_THRESH ); +for (i =0 ; i <NUM_HARDIRQ_REPORT ; i++) { +if (hardirq_counts_top[i].irq ==-1 ) +break ; + desc =irq_to_desc (hardirq_counts_top[i].irq); +if (desc && desc->action) +printk (KERN_CRIT "\t#%u: %-10u\tirq#%d(%s)\n" , + i+1 , hardirq_counts_top[i].counts, + hardirq_counts_top[i].irq, desc->action->name); +else +printk (KERN_CRIT "\t#%u: %-10u\tirq#%d\n" , + i+1 , hardirq_counts_top[i].counts, + hardirq_counts_top[i].irq); + } +if (!need_record_irq_counts (STATS_HARDIRQ )) +clear_potential_softlockup_hardirq (); + } +} +#else static inline void update_cpustat (void ) { }static inline void print_cpustat (void ) { } +static inline void set_potential_softlockup (unsigned long now,unsigned long period_ts) { } +static inline void clear_potential_softlockup (void ) { }#endif /* watchdog detector functions */ @@ -537,6 +692,7 @@ static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work);static int softlockup_fn (void *data) {update_touch_ts (); +clear_potential_softlockup ();complete (this_cpu_ptr (&softlockup_completion));return 0 ;
Re: [PATCHv3 2/2] watchdog/softlockup: report the most frequent interrupts
Quoted 97 lines · Liu Song
Quoted 95 lines · Bitao Hu
When the watchdog determines that the current soft lockup is due to an interrupt storm based on CPU utilization, reporting the most frequent interrupts could be good enough for further troubleshooting.
Below is an example of interrupt storm. The call tree does not provide useful information, but we can analyze which interrupt caused the soft lockup by comparing the counts of interrupts.
[ 2987.488075] watchdog: BUG: soft lockup - CPU#9 stuck for 23s! [kworker/9:1:214] [ 2987.488607] CPU#9 Utilization every 4s during lockup: [ 2987.488941] #1: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489357] #2: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489771] #3: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490186] #4: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490601] #5: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.491034] CPU#9 Detect HardIRQ Time exceeds 50%. Most frequent HardIRQs: [ 2987.491493] #1: 330985 irq#7(IPI) [ 2987.491743] #2: 5000 irq#10(arch_timer) [ 2987.492039] #3: 9 irq#91(nvme0q2) [ 2987.492318] #4: 3 irq#118(virtio1-output.12) ... [ 2987.492728] Call trace: [ 2987.492729] __do_softirq+0xa8/0x364Signed-off-by Bitao Hu <[email protected]>---
kernel/watchdog.c| 156 ++++++++++++++++++++++++++++++++++++++++++++++1 file changed, 156 insertions(+)kernel/watchdog.c +31
-0@@ -25,6 +25,9 @@ #include <linux/stop_machine.h> #include <linux/kernel_stat.h> #include <linux/math64.h> +#include <linux/irq.h> +#include <linux/bitops.h> +#include <linux/irqdesc.h> #include <asm/irq_regs.h> #include <linux/kvm_para.h>@@ -431,11 +434,15 @@ void touch_softlockup_watchdog_sync(void) __this_cpu_write(watchdog_report_ts, SOFTLOCKUP_DELAY_REPORT); } +static void set_potential_softlockup (unsigned long now,unsigned long touch_ts); + static int is_softlockup(unsigned long touch_ts, unsigned long period_ts, unsigned long now) { if ((watchdog_enabled & WATCHDOG_SOFTOCKUP_ENABLED) && watchdog_thresh) { + /* Softlockup may occur in the current period */ + set_potential_softlockup(now, period_ts); /* Warn about unreasonable delays. */ if (time_after(now, period_ts + get_softlockup_thresh())) return now - touch_ts;@@ -462,6 +469,8 @@ static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_tail); +static void print_hardirq_counts (void ); + /** We don't need nanosecond resolution. A granularity of 16ms is * sufficient for our precision, allowing us to use u16 to store @@ -516,10 +525,156 @@ static void print_cpustat(void) __this_cpu_read(cpustat_utilization[i][STATS_HARDIRQ]), __this_cpu_read(cpustat_utilization[i][STATS_IDLE])); } + print_hardirq_counts(); +} + +#define HARDIRQ_PERCENT_THRESH 50 +#define NUM_HARDIRQ_REPORT 5 +static DECLARE_BITMAP(softlockup_hardirq_cpus, CONFIG_NR_CPUS); +static DEFINE_PER_CPU(u32 *, hardirq_counts); + +struct irq_counts { + int irq; + u32 counts; +}; + +static void find_counts_top (struct irq_counts *irq_counts,int irq,u32 counts,int range) +{ + unsigned int i, j; + + for (i = 0; i < range; i++) { + if (counts > irq_counts[i].counts) { + for (j = range - 1; j > i; j--) { + irq_counts[j].counts = irq_counts[j - 1].counts; + irq_counts[j].irq = irq_counts[j - 1].irq;
Quoted 8 lines
kernel/watchdog.c static void print_cpustat(void) · line 554
Quoted 5 lines
kernel/watchdog.c +5
-0+ } + irq_counts[j].counts = counts; + irq_counts[j].irq = irq; + break; + }The current implementation can lead to a reordering with each iteration. It is recommended to update in place if the value is larger and perform the reordering just before printing at the end.
Sure, I will consider optimization.
Quoted 70 lines
Quoted 70 lines
kernel/watchdog.c +5
-0+ } +} + +/* +* If the proportion of time spent handling irq exceeds HARDIRQ_PERCENT_THRESH%
+ * duringsample_period, then it is necessary to record the counts of each irq.
+ */kernel/watchdog.c +50
-0+static inline bool need_record_irq_counts (int type) +{ + int tail = __this_cpu_read(cpustat_tail); + u8 utilization; + + if (--tail == -1) + tail = 4; + utilization = __this_cpu_read(cpustat_utilization[tail][type]); + return utilization > HARDIRQ_PERCENT_THRESH; +} + +/* +* Mark softlockup as potentially caused by hardirq +*/ +static void set_potential_softlockup_hardirq (void ) +{ + u32 i; + u32 *counts = __this_cpu_read(hardirq_counts); + int cpu = smp_processor_id(); + struct irq_desc *desc; + + if (!need_record_irq_counts(STATS_HARDIRQ)) + return; + + if (!test_bit(cpu, softlockup_hardirq_cpus)) { + counts = kmalloc_array(nr_irqs, sizeof(u32), GFP_ATOMIC); + if (!counts) + return; + for_each_irq_desc(i, desc) { + if (!desc) + continue; + counts[i] = desc->kstat_irqs ? + *this_cpu_ptr(desc->kstat_irqs) : 0; + } + __this_cpu_write(hardirq_counts, counts); + set_bit(cpu, softlockup_hardirq_cpus); + } +} + +static void clear_potential_softlockup_hardirq (void ) +{ + u32 *counts = __this_cpu_read(hardirq_counts); + int cpu = smp_processor_id(); + + if (test_bit(cpu, softlockup_hardirq_cpus)) { + kfree(counts); + counts = NULL; + __this_cpu_write(hardirq_counts, counts); + clear_bit(cpu, softlockup_hardirq_cpus); + }}
kernel/watchdog.c +5
-0+ +/* +* Mark that softlockup may occur +*/ +static void set_potential_softlockup(unsigned long now, unsigned long
period_ts)kernel/watchdog.c +4
-0+{ + if (time_after_eq(now, period_ts + get_softlockup_thresh() / 5)) + set_potential_softlockup_hardirq(); +}
Quoted 8 lines
kernel/watchdog.c static void print_cpustat(void) · line 626
Quoted 5 lines
kernel/watchdog.c +5
-0+ +static void clear_potential_softlockup (void ) +{ + clear_potential_softlockup_hardirq(); +}Given that
clear_potential_softlockupwill only callclear_potential_softlockup_hardirq, then why is there a need to declareclear_potential_softlockupseparately?
I had considered adding "clear_potential_softlockup_softirq", but ultimately I removed it. Indeed, it is confusing; I will remove the "clear_potential_softlockup".
Quoted 63 lines
Quoted 63 lines
kernel/watchdog.c +27
-0+ +static void print_hardirq_counts(void) +{ + u32 i; + struct irq_desc *desc; + u32 counts_diff; + u32 *counts = __this_cpu_read(hardirq_counts); + int cpu = smp_processor_id(); + struct irq_counts hardirq_counts_top[NUM_HARDIRQ_REPORT] = { + {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, + }; + + if (test_bit(cpu, softlockup_hardirq_cpus)) { + /* Find the top NUM_HARDIRQ_REPORT most frequent interrupts */ + for_each_irq_desc(i, desc) { + if (!desc) + continue; + counts_diff = desc->kstat_irqs ? + *this_cpu_ptr(desc->kstat_irqs) - counts[i] : 0; + find_counts_top(hardirq_counts_top, i, counts_diff, + NUM_HARDIRQ_REPORT); + } + /* + * We do not want the "watchdog: " prefix on every line, + * hence we use "printk" instead of "pr_crit". + */ + printk(KERN_CRIT "CPU#%d Detect HardIRQ Time exceeds %d%%.Most frequent HardIRQs:\n",
+smp_processor_id(),HARDIRQ_PERCENT_THRESH); + for (i = 0; i <NUM_HARDIRQ_REPORT; i++) {
+ if (hardirq_counts_top[i].irq == -1)
+ break;
+ desc =irq_to_desc(hardirq_counts_top[i].irq); + if (desc &&desc->action)
+ printk(KERN_CRIT "\t#%u: %-10u\tirq#%d(%s)\n", + i+1, hardirq_counts_top[i].counts,
+ hardirq_counts_top[i].irq,desc->action->name); + else
+ printk(KERN_CRIT "\t#%u: %-10u\tirq#%d\n", + i+1, hardirq_counts_top[i].counts,
+ hardirq_counts_top[i].irq);
+ }
+ if (!need_record_irq_counts(STATS_HARDIRQ))
+clear_potential_softlockup_hardirq();
+ }kernel/watchdog.c +2
-0+} +#else
static inline voidupdate_cpustat(void){ }
static inline voidprint_cpustat(void){ }
+static inline voidset_potential_softlockup(unsigned long now, unsigned long period_ts){ }
+static inline voidclear_potential_softlockup(void){ } #endif
/* watchdog detector functions */kernel/watchdog.c +1
-0@@ -537,6 +692,7 @@ static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work); static int softlockup_fn(void *data) { update_touch_ts(); + clear_potential_softlockup(); complete(this_cpu_ptr(&softlockup_completion)); return 0;
Re: [PATCHv3 2/2] watchdog/softlockup: report the most frequent interrupts
In reply to Bitao HuHi,
Quoted 36 lines · Bitao Hu
When the watchdog determines that the current soft lockup is due to an interrupt storm based on CPU utilization, reporting the most frequent interrupts could be good enough for further troubleshooting.
Below is an example of interrupt storm. The call tree does not provide useful information, but we can analyze which interrupt caused the soft lockup by comparing the counts of interrupts.
[ 2987.488075] watchdog: BUG: soft lockup - CPU#9 stuck for 23s! [kworker/9:1:214] [ 2987.488607] CPU#9 Utilization every 4s during lockup: [ 2987.488941] #1: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489357] #2: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489771] #3: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490186] #4: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490601] #5: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.491034] CPU#9 Detect HardIRQ Time exceeds 50%. Most frequent HardIRQs: [ 2987.491493] #1: 330985 irq#7(IPI) [ 2987.491743] #2: 5000 irq#10(arch_timer) [ 2987.492039] #3: 9 irq#91(nvme0q2) [ 2987.492318] #4: 3 irq#118(virtio1-output.12) ... [ 2987.492728] Call trace: [ 2987.492729] __do_softirq+0xa8/0x364Signed-off-by Bitao Hu <[email protected]>--- kernel/watchdog.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+)kernel/watchdog.c +0
-0
kernel/watchdog.c line 30
Quoted 6 lines
kernel/watchdog.c +3
-0@@ -25,6 +25,9 @@#include <linux/stop_machine.h> #include <linux/kernel_stat.h> #include <linux/math64.h> +#include <linux/irq.h> +#include <linux/bitops.h> +#include <linux/irqdesc.h>
Like in patch #1, don't just jam headers at the end. Put them in a sensible order.
Quoted 5 lines
kernel/watchdog.c +0
-0#include <asm/irq_regs.h> #include <linux/kvm_para.h> @@ -431,11 +434,15 @@ void touch_softlockup_watchdog_sync(void)__this_cpu_write (watchdog_report_ts,SOFTLOCKUP_DELAY_REPORT ); }
kernel/watchdog.c void touch_softlockup_watchdog_sync(void) · line 445
Quoted 10 lines
kernel/watchdog.c +4
-0+static void set_potential_softlockup (unsigned long now,unsigned long touch_ts); +static int is_softlockup (unsigned long touch_ts,unsigned long period_ts,unsigned long now) {if ((watchdog_enabled &WATCHDOG_SOFTOCKUP_ENABLED ) && watchdog_thresh) { +/* Softlockup may occur in the current period */ +set_potential_softlockup (now, period_ts);
Something is really confusing to me about the set_potential_softlockup() and set_potential_softlockup_hardirq() functions and the comment above this line doesn't help me. From the comment and the name of the function it sounds like at this point in the code you've already determined that a softlockup is likely. ...but I don't think that's the case. At this point in the code all we know is that the softlockup detector is running, right?
I guess the first thing that would help would be to just get rid of the set_potential_softlockup() wrapper and just inline here:
if (time_after_eq(now, period_ts + get_softlockup_thresh() / 5))
set_potential_softlockup_hardirq();
...but then I'd want a comment explaining what that "if" test means. Maybe something like this (assuming it's correct):
The "sample_period" is set so that we should get called ~5 times between the start of the softlockup and when it is detected / reported. If we've already been called twice and it looks like a softlockup might be occurring, start counting interrupts.
Also: assuming I understand correctly, won't your "time_after_eq()" always be true as you've written it? Shouldn't it be something like:
if (time_after_eq(now, period_ts + 2 * get_softlockup_thresh() / 5))
...or maybe you don't need this "if" test at all since you're using "need_record_irq_counts(STATS_HARDIRQ)" here. IMO that should be pulled out here as well since it makes it more obvious...
kernel/watchdog.c static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); · line 473
Quoted 9 lines
kernel/watchdog.c +2
-0/* Warn about unreasonable delays. */ if (time_after (now, period_ts +get_softlockup_thresh ()))return now - touch_ts;@@ -462,6 +469,8 @@ static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_tail); +static void print_hardirq_counts (void ); +
Rather than predeclaring, can't you just put the functions here?
Quoted 11 lines
kernel/watchdog.c +4
-0/* * We don't need nanosecond resolution. A granularity of 16ms is * sufficient for our precision, allowing us to use u16 to store @@ -516,10 +525,156 @@ static void print_cpustat(void)__this_cpu_read (cpustat_utilization[i][STATS_HARDIRQ ]), __this_cpu_read(cpustat_utilization[i][STATS_IDLE])); } +print_hardirq_counts (); +} + +#define HARDIRQ_PERCENT_THRESH 50
kernel/watchdog.c static void print_cpustat(void) · line 541
Quoted 10 lines
kernel/watchdog.c +10
-0+#define NUM_HARDIRQ_REPORT 5 +static DECLARE_BITMAP(softlockup_hardirq_cpus, CONFIG_NR_CPUS); +static DEFINE_PER_CPU(u32 *, hardirq_counts); + +struct irq_counts { +int irq; +u32 counts; +}; + +static void find_counts_top (struct irq_counts *irq_counts,int irq,u32 counts,int range)
nit: it's not really "finding" anything. Maybe "tabulate_irq_count" or something?
Quoted 4 lines
kernel/watchdog.c +4
-0+{ +unsigned int i, j; + +for (i =0 ; i < range; i++) {
kernel/watchdog.c static void print_cpustat(void) · line 555
Quoted 10 lines
kernel/watchdog.c +10
-0+if (counts > irq_counts[i].counts) { +for (j = range -1 ; j > i; j--) { + irq_counts[j].counts = irq_counts[j -1 ].counts; + irq_counts[j].irq = irq_counts[j -1 ].irq; + } + irq_counts[j].counts = counts; + irq_counts[j].irq = irq; +break ; + } + }
Rather than a double loop, can't you just swap? Untested:
unsigned int i;
struct irq_counts new_count = { irq, counts };
for (i = 0; i < range; i++) {
if (count > irq_counts[i].counts)
swap(new_count, irq_counts[i])
}kernel/watchdog.c static void print_cpustat(void) · line 562
Quoted 7 lines
kernel/watchdog.c +7
-0+} + +/* +* If the proportion of time spent handling irq exceeds HARDIRQ_PERCENT_THRESH% +* during sample_period, then it is necessary to record the counts of each irq. +*/ +static inline bool need_record_irq_counts (int type)
Let the compiler decide if this should be inline. No need for the forced "inline" keyword.
Also: why do you need to pass in the "type". This function only makes sense for "STATS_HARDIRQ"
kernel/watchdog.c static void print_cpustat(void) · line 568
Quoted 6 lines
kernel/watchdog.c +6
-0+{ +int tail =__this_cpu_read (cpustat_tail); +u8 utilization; + +if (--tail ==-1 ) + tail =4 ;
Instead of the above:
tail = (tail + NUM_HARDIRQ_REPORT - 1) % NUM_HARDIRQ_REPORT;
Quoted 9 lines
kernel/watchdog.c +9
-0+ utilization =__this_cpu_read (cpustat_utilization[tail][type]); +return utilization >HARDIRQ_PERCENT_THRESH ; +} + +/* +* Mark softlockup as potentially caused by hardirq +*/ +static void set_potential_softlockup_hardirq (void ) +{
kernel/watchdog.c static void print_cpustat(void) · line 587
Quoted 10 lines
kernel/watchdog.c +10
-0+u32 i; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_desc *desc; + +if (!need_record_irq_counts (STATS_HARDIRQ )) +return ; + +if (!test_bit (cpu, softlockup_hardirq_cpus)) { + counts =kmalloc_array (nr_irqs,sizeof (u32),GFP_ATOMIC );
I think "nr_irqs" has the potential to grow at runtime, right? That means you should read it and store locally how big your array actually is. Otherwise you could allocate enough space for 64 IRQs, someone could grow nr_irqs, and you could try looping over 128. Presumably when you loop over with "for_each_irq_desc" you'd also need to bounds-check in case someone on a different CPU expanded the number after you read it...
-Doug
Re: [PATCHv3 2/2] watchdog/softlockup: report the most frequent interrupts
Quoted 34 lines · Doug Anderson
Hi,
Quoted 31 lines · Bitao Hu
When the watchdog determines that the current soft lockup is due to an interrupt storm based on CPU utilization, reporting the most frequent interrupts could be good enough for further troubleshooting.
Below is an example of interrupt storm. The call tree does not provide useful information, but we can analyze which interrupt caused the soft lockup by comparing the counts of interrupts.
[ 2987.488075] watchdog: BUG: soft lockup - CPU#9 stuck for 23s! [kworker/9:1:214] [ 2987.488607] CPU#9 Utilization every 4s during lockup: [ 2987.488941] #1: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489357] #2: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.489771] #3: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490186] #4: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.490601] #5: 0% system, 0% softirq, 100% hardirq, 0% idle [ 2987.491034] CPU#9 Detect HardIRQ Time exceeds 50%. Most frequent HardIRQs: [ 2987.491493] #1: 330985 irq#7(IPI) [ 2987.491743] #2: 5000 irq#10(arch_timer) [ 2987.492039] #3: 9 irq#91(nvme0q2) [ 2987.492318] #4: 3 irq#118(virtio1-output.12) ... [ 2987.492728] Call trace: [ 2987.492729] __do_softirq+0xa8/0x364Signed-off-by Bitao Hu <[email protected]>--- kernel/watchdog.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+)
Quoted 14 lines
kernel/watchdog.c line 30
Quoted 11 lines
kernel/watchdog.c +3
-0@@ -25,6 +25,9 @@#include <linux/stop_machine.h> #include <linux/kernel_stat.h> #include <linux/math64.h> +#include <linux/irq.h> +#include <linux/bitops.h> +#include <linux/irqdesc.h> Like in patch #1, don't just jam headers at the end. Put them in a sensible order.
Sure, I will standardize the code.
Quoted 41 lines
Quoted 8 lines
kernel/watchdog.c +0
-0#include <asm/irq_regs.h> #include <linux/kvm_para.h> @@ -431,11 +434,15 @@ void touch_softlockup_watchdog_sync(void)__this_cpu_write (watchdog_report_ts,SOFTLOCKUP_DELAY_REPORT ); }kernel/watchdog.c void touch_softlockup_watchdog_sync(void) · line 445
Quoted 10 lines
kernel/watchdog.c +4
-0+static void set_potential_softlockup (unsigned long now,unsigned long touch_ts); +static int is_softlockup (unsigned long touch_ts,unsigned long period_ts,unsigned long now) {if ((watchdog_enabled &WATCHDOG_SOFTOCKUP_ENABLED ) && watchdog_thresh) { +/* Softlockup may occur in the current period */ +set_potential_softlockup (now, period_ts);Something is really confusing to me about the
set_potential_softlockup()andset_potential_softlockup_hardirq()functions and the comment above this line doesn't help me. From the comment and the name of the function it sounds like at this point in the code you've already determined that a softlockup is likely. ...but I don't think that's the case. At this point in the code all we know is that the softlockup detector is running, right?I guess the first thing that would help would be to just get rid of the
set_potential_softlockup()wrapper and just inline here:if (
time_after_eq(now, period_ts + get_softlockup_thresh() / 5))
set_potential_softlockup_hardirq();...but then I'd want a comment explaining what that "if" test means. Maybe something like this (assuming it's correct):
The "
sample_period" is set so that we should get called ~5 times between the start of the softlockup and when it is detected / reported. If we've already been called twice and it looks like a softlockup might be occurring, start counting interrupts.
Quoted 8 lines
Also: assuming I understand correctly, won't your "
time_after_eq()" always be true as you've written it? Shouldn't it be something like:if (
time_after_eq(now, period_ts + 2 * get_softlockup_thresh() / 5))...or maybe you don't need this "if" test at all since you're using "
need_record_irq_counts(STATS_HARDIRQ)" here. IMO that should be pulled out here as well since it makes it more obvious...
I agree with your this suggestion here. It is easier to understand:
if (time_after_eq(now, period_ts + get_softlockup_thresh() / 5))
set_potential_softlockup_hardirq();
Please let me explain the criteria for the judgment here. Under normal
circumstances, "softlockup_fn" will be woken up every "sample_period" to
update "period_ts", and the "time_after_eq" I written will be false. If
"period_ts" has not been updated after a "sample_period" has passed,
then the "time_after_eq" will be true. And I suspect that in the subsequent few "sample_period", "period_ts" might also not be updated, which could indicate a potential softlockup. At this point, I use
"need_record_irq_counts" to determine if this phenomenon is caused by an
interrupt storm.
To summarize, my condition to start counting interrupts is that
"period_ts" has not been updated during "sample_period" AND the proportion of hardirq time during "sample_period" exceeds 50%.
What do you think?
By the way, The reason for having both set_potential_softlockup() and set_potential_softlockup_hardirq() is that I once wrote a set_potential_softlockup_softirq() for starting counting softirqs. However, I found it might not very meaningful and removed it. I will follow your suggestion and make improvements to make this area more understandable.
Quoted 32 lines
kernel/watchdog.c static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); · line 473
Quoted 12 lines
kernel/watchdog.c +2
-0/* Warn about unreasonable delays. */ if (time_after (now, period_ts +get_softlockup_thresh ()))return now - touch_ts;@@ -462,6 +469,8 @@ static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_utilization[NUM_STATS_GROUPS][NUM_STATS_PER_GROUP]); static DEFINE_PER_CPU(u8, cpustat_tail); +static void print_hardirq_counts (void ); +Rather than predeclaring, can't you just put the functions here?
Quoted 16 lines
kernel/watchdog.c +9
-0/* * We don't need nanosecond resolution. A granularity of 16ms is * sufficient for our precision, allowing us to use u16 to store @@ -516,10 +525,156 @@ static void print_cpustat(void)__this_cpu_read (cpustat_utilization[i][STATS_HARDIRQ ]), __this_cpu_read(cpustat_utilization[i][STATS_IDLE])); } +print_hardirq_counts (); +} + +#define HARDIRQ_PERCENT_THRESH 50 +#define NUM_HARDIRQ_REPORT 5 +static DECLARE_BITMAP(softlockup_hardirq_cpus, CONFIG_NR_CPUS); +static DEFINE_PER_CPU(u32 *, hardirq_counts); + +struct irq_counts {
Quoted 8 lines
kernel/watchdog.c static void print_cpustat(void) · line 541
Quoted 5 lines
kernel/watchdog.c +5
-0+int irq; +u32 counts; +}; + +static void find_counts_top (struct irq_counts *irq_counts,int irq,u32 counts,int range)nit: it's not really "finding" anything. Maybe "
tabulate_irq_count" or something?
Agree, I will rename it.
Quoted 19 lines
Quoted 6 lines
kernel/watchdog.c +4
-0+{ +unsigned int i, j; + +for (i =0 ; i < range; i++) {kernel/watchdog.c static void print_cpustat(void) · line 555
Quoted 10 lines
kernel/watchdog.c +10
-0+if (counts > irq_counts[i].counts) { +for (j = range -1 ; j > i; j--) { + irq_counts[j].counts = irq_counts[j -1 ].counts; + irq_counts[j].irq = irq_counts[j -1 ].irq; + } + irq_counts[j].counts = counts; + irq_counts[j].irq = irq; +break ; + } + }Rather than a double loop, can't you just swap? Untested:
Quoted 7 lines
unsigned int i;
struct irq_counts new_count = { irq, counts };
for (i = 0; i < range; i++) {
if (count > irq_counts[i].counts)
swap(new_count, irq_counts[i])
}I will try it.
Quoted 12 lines
kernel/watchdog.c static void print_cpustat(void) · line 562
Quoted 9 lines
kernel/watchdog.c +7
-0+} + +/* +* If the proportion of time spent handling irq exceeds HARDIRQ_PERCENT_THRESH% +* during sample_period, then it is necessary to record the counts of each irq. +*/ +static inline bool need_record_irq_counts (int type)Let the compiler decide if this should be inline. No need for the forced "inline" keyword.
OK.
Quoted 3 lines
Also: why do you need to pass in the "type". This function only makes sense for "
STATS_HARDIRQ
As previously mentioned, I had considered counting softirqs. I will refactor 'need_record_irq_counts'.
Quoted 11 lines
kernel/watchdog.c static void print_cpustat(void) · line 568
Quoted 8 lines
kernel/watchdog.c +6
-0+{ +int tail =__this_cpu_read (cpustat_tail); +u8 utilization; + +if (--tail ==-1 ) + tail =4 ;Instead of the above:
Quoted 1 line
tail = (tail +
NUM_HARDIRQ_REPORT- 1) %NUM_HARDIRQ_REPORT;
Agree, I will follow your suggestion.
Quoted 22 lines
Quoted 11 lines
kernel/watchdog.c +9
-0+ utilization =__this_cpu_read (cpustat_utilization[tail][type]); +return utilization >HARDIRQ_PERCENT_THRESH ; +} + +/* +* Mark softlockup as potentially caused by hardirq +*/ +static void set_potential_softlockup_hardirq (void ) +{kernel/watchdog.c static void print_cpustat(void) · line 587
Quoted 10 lines
kernel/watchdog.c +10
-0+u32 i; +u32 *counts =__this_cpu_read (hardirq_counts); +int cpu =smp_processor_id (); +struct irq_desc *desc; + +if (!need_record_irq_counts (STATS_HARDIRQ )) +return ; + +if (!test_bit (cpu, softlockup_hardirq_cpus)) { + counts =kmalloc_array (nr_irqs,sizeof (u32),GFP_ATOMIC );
Quoted 7 lines
I think "
nr_irqs" has the potential to grow at runtime, right? That means you should read it and store locally how big your array actually is. Otherwise you could allocate enough space for 64 IRQs, someone could grownr_irqs, and you could try looping over 128. Presumably when you loop over with "for_each_irq_desc" you'd also need to bounds-check in case someone on a different CPU expanded the number after you read it...
Oh, I assumed that "nr_irqs" would remain constant at runtime, but I will consider scenarios where it might grow.
Quoted 3 lines
-Doug
Re: [PATCHv3 2/2] watchdog/softlockup: report the most frequent interrupts
Hi,
Quoted 19 lines · Bitao Hu
Quoted 4 lines
...or maybe you don't need this "if" test at all since you're using "
need_record_irq_counts(STATS_HARDIRQ)" here. IMO that should be pulled out here as well since it makes it more obvious...I agree with your this suggestion here. It is easier to understand:
if (
time_after_eq(now, period_ts + get_softlockup_thresh() / 5))
set_potential_softlockup_hardirq();Please let me explain the criteria for the judgment here. Under normal circumstances, "
softlockup_fn" will be woken up every "sample_period" to update "period_ts", and the "time_after_eq" I written will be false. If "period_ts" has not been updated after a "sample_period" has passed, then the "time_after_eq" will be true. And I suspect that in the subsequent few "sample_period", "period_ts" might also not be updated, which could indicate a potential softlockup. At this point, I use "need_record_irq_counts" to determine if this phenomenon is caused by an interrupt storm.
Quoted 5 lines
To summarize, my condition to start counting interrupts is that "
period_ts" has not been updated during "sample_period" AND the proportion of hardirq time during "sample_period" exceeds 50%.What do you think?
OK, sounds reasonable. Given that this is non-obvious, it would be great if your patch included a comment explaining it. :-)