Print traces on softlockup
Subsystems (4)
v4 cover Print traces on softlockup
Added more patches to handle the 'uniprocessor' panic case by sending NMIs to every cpu but self. Only affects x86, sparc.
V4: roll x86 and sparc patches into patch1
add CONFIG_SMP in various places based on Andrew's suggestion
V3: wrap x86 code with get/put_cpu based on Oleg's suggestions
V2: expand from one patch to 4
Aaron Tomlin (4):
nmi: Provide the option to issue an NMI back trace to every cpu but
current
x86, nmi: Add more flexible NMI back trace support sparc64, nmi: Add more flexible NMI back trace support
watchdog: Printing traces for all cpus on lockup detection
Documentation/kernel-parameters.txt | 5 +++++ Documentation/sysctl/kernel.txt | 17 +++++++++++++++++ arch/sparc/include/asm/irq_64.h | 2 +- arch/sparc/kernel/process_64.c | 14 +++++++++----- arch/x86/include/asm/irq.h | 2 +- arch/x86/kernel/apic/hw_nmi.c | 17 +++++++++++++---- include/linux/nmi.h | 12 +++++++++++- kernel/sysctl.c | 9 +++++++++ kernel/watchdog.c | 32 ++++++++++++++++++++++++++++++++ 9 files changed, 98 insertions(+), 12 deletions(-)
Aaron Tomlin (2):
nmi: Provide the option to issue an NMI back trace to every cpu but
current
watchdog: Printing traces for all cpus on lockup detection
Documentation/kernel-parameters.txt | 5 +++++ Documentation/sysctl/kernel.txt | 17 +++++++++++++++++ arch/sparc/include/asm/irq_64.h | 2 +- arch/sparc/kernel/process_64.c | 14 +++++++++----- arch/x86/include/asm/irq.h | 2 +- arch/x86/kernel/apic/hw_nmi.c | 17 +++++++++++++---- include/linux/nmi.h | 14 +++++++++++++- kernel/sysctl.c | 11 +++++++++++ kernel/watchdog.c | 34 ++++++++++++++++++++++++++++++++++ 9 files changed, 104 insertions(+), 12 deletions(-)
PATCH v4 1/2 nmi: Provide the option to issue an NMI back trace to every cpu but current
From: Aaron Tomlin <[email protected]>
Some times it is preferred not to use the trigger_all_cpu_backtrace() routine when one wants to avoid capturing a back trace for current. For instance if one was previously captured recently.
This patch provides a new routine namely trigger_allbutself_cpu_backtrace() which offers the flexibility to issue an NMI to every cpu but current and capture a back trace accordingly.
Patched x86 and sparc to support new routine.
[Don't print message in single processor case,
wrap with get/put_cpu based on Oleg's suggestion]
--- arch/sparc/include/asm/irq_64.h | 2 +- arch/sparc/kernel/process_64.c | 14 +++++++++----- arch/x86/include/asm/irq.h | 2 +- arch/x86/kernel/apic/hw_nmi.c | 17 +++++++++++++---- include/linux/nmi.h | 11 ++++++++++- 5 files changed, 34 insertions(+), 12 deletions(-)
arch/sparc/include/asm/irq_64.h +1 -1
@@ -89,7 +89,7 @@ static inline unsigned long get_softint(void)return retval; } -void arch_trigger_all_cpu_backtrace (void ); +void arch_trigger_all_cpu_backtrace (bool );#define arch_trigger_all_cpu_backtrace arch_trigger_all_cpu_backtraceextern void *hardirq_stack[NR_CPUS ];
arch/sparc/kernel/process_64.c +9 -5
@@ -237,7 +237,7 @@ static void __global_reg_poll(struct global_reg_snapshot *gp) } } -void arch_trigger_all_cpu_backtrace (void ) +void arch_trigger_all_cpu_backtrace (bool include_self) {struct thread_info *tp =current_thread_info ();struct pt_regs *regs =get_irq_regs ();
@@ -249,15 +249,19 @@ void arch_trigger_all_cpu_backtrace(void)spin_lock_irqsave (&global_cpu_snapshot_lock, flags); -memset (global_cpu_snapshot,0 ,sizeof (global_cpu_snapshot)); - this_cpu =raw_smp_processor_id (); -__global_reg_self (tp, regs, this_cpu); +memset (global_cpu_snapshot,0 ,sizeof (global_cpu_snapshot)); + +if (include_self) +__global_reg_self (tp, regs, this_cpu);smp_fetch_global_regs ();for_each_online_cpu (cpu) { +if (!include_self && cpu = this_cpu) +continue ; +struct global_reg_snapshot *gp = &global_cpu_snapshot[cpu].reg;__global_reg_poll (gp);
@@ -290,7 +294,7 @@ void arch_trigger_all_cpu_backtrace(void)static void sysrq_handle_globreg (int key) { -arch_trigger_all_cpu_backtrace (); +arch_trigger_all_cpu_backtrace (true); }static struct sysrq_key_op sparc_globalreg_op = {
arch/x86/include/asm/irq.h +1 -1
@@ -43,7 +43,7 @@ extern int vector_used_by_percpu_irq(unsigned int vector);extern void init_ISA_irqs (void );#ifdef CONFIG_X86_LOCAL_APIC -void arch_trigger_all_cpu_backtrace (void ); +void arch_trigger_all_cpu_backtrace (bool );#define arch_trigger_all_cpu_backtrace arch_trigger_all_cpu_backtrace#endif
arch/x86/kernel/apic/hw_nmi.c +13 -4
@@ -33,31 +33,40 @@ static DECLARE_BITMAP(backtrace_mask, NR_CPUS) __read_mostly;/* "in progress" flag of arch_trigger_all_cpu_backtrace */ static unsigned long backtrace_flag; -void arch_trigger_all_cpu_backtrace (void ) +void arch_trigger_all_cpu_backtrace (bool include_self) {int i; +int cpu =get_cpu (); -if (test_and_set_bit (0 , &backtrace_flag)) +if (test_and_set_bit (0 , &backtrace_flag)) {/* * If there is already a trigger_all_cpu_backtrace() in progress * (backtrace_flag = 1), don't output double cpu dump infos. */ +put_cpu ();return ; + }cpumask_copy (to_cpumask (backtrace_mask), cpu_online_mask); +if (!include_self) +cpumask_clear_cpu (cpu,to_cpumask (backtrace_mask)); -printk (KERN_INFO "sending NMI to all CPUs:\n" ); - apic->send_IPI_all (NMI_VECTOR ); +if (!cpumask_empty (to_cpumask (backtrace_mask))) { +pr_info ("sending NMI to %s CPUs:\n" , (include_self ?"all" :"other" )); + apic->send_IPI_mask (to_cpumask (backtrace_mask),NMI_VECTOR ); + }/* Wait for up to 10 seconds for all CPUs to do the backtrace */ for (i =0 ; i <10 *1000 ; i++) {if (cpumask_empty (to_cpumask (backtrace_mask)))break ;mdelay (1 ); +touch_softlockup_watchdog (); }clear_bit (0 , &backtrace_flag);smp_mb__after_clear_bit (); +put_cpu (); } static int __kprobes
include/linux/nmi.h +10 -1
@@ -32,15 +32,24 @@ static inline void touch_nmi_watchdog(void)#ifdef arch_trigger_all_cpu_backtracestatic inline bool trigger_all_cpu_backtrace (void ) { -arch_trigger_all_cpu_backtrace (); +arch_trigger_all_cpu_backtrace (true);return true; } +static inline bool trigger_allbutself_cpu_backtrace (void ) +{ +arch_trigger_all_cpu_backtrace (false); +return true; +}#else static inline bool trigger_all_cpu_backtrace (void ) {return false; } +static inline bool trigger_allbutself_cpu_backtrace (void ) +{ +return false; +}#endif #ifdef CONFIG_LOCKUP_DETECTOR
Signature · 1 line
1.7.1
PATCH v4 2/2 watchdog: Printing traces for all cpus on lockup detection
In reply to Don ZickusFrom: Aaron Tomlin <[email protected]>
A 'softlockup' is defined as a bug that causes the kernel to loop in kernel mode for more than a predefined period to time, without giving other tasks a chance to run.
Currently, upon detection of this condition by the per-cpu watchdog task, debug information (including a stack trace) is sent to the system log.
On some occasions, we have observed that the "victim" rather than the actual "culprit" (i.e. the owner/holder of the contended resource) is reported to the user.
Often this information has proven to be insufficient to assist debugging efforts.
To avoid loss of useful debug information, for architectures which support NMI, this patch makes it possible to improve soft lockup reporting. This is accomplished by issuing an NMI to each cpu to obtain a stack trace.
If NMI is not supported we just revert back to the old method. A sysctl and boot-time parameter is available to toggle this feature.
--- Documentation/kernel-parameters.txt | 5 +++++ Documentation/sysctl/kernel.txt | 17 +++++++++++++++++ include/linux/nmi.h | 3 +++ kernel/sysctl.c | 11 +++++++++++ kernel/watchdog.c | 34 ++++++++++++++++++++++++++++++++++ 5 files changed, 70 insertions(+), 0 deletions(-)
Documentation/kernel-parameters.txt +4 -0
@@ -3047,6 +3047,11 @@ bytes respectively. Such letter suffixes can also be entirely omitted. [KNL] Should the soft-lockup detector generate panics. Format: <integer> + softlockup_all_cpu_backtrace+ [KNL] Should the soft-lockup detector generate + backtraces on all cpus. + Format: <integer> + sonypi.*= [HW] Sony Programmable I/O Control Device driver See Documentation/laptops/sonypi.txt
Documentation/sysctl/kernel.txt +17 -0
@@ -75,6 +75,7 @@ show up in /proc/sys/kernel: - shmall - shmmax [ sysv ipc ] - shmmni +- softlockup_all_cpu_backtrace - stop-a [ SPARC only ] - sysrq => Documentation/sysrq.txt - tainted
@@ -768,6 +769,22 @@ without users and with a dead originative process will be destroyed. =============================== +softlockup_all_cpu_backtrace: + +This value controls the soft lockup detector thread's behavior +when a soft lockup condition is detected as to whether or not +to gather further debug information. If enabled, each cpu will +be issued an NMI and instructed to capture stack trace. + +This feature is only applicable for architectures which support +NMI. + +0: do nothing. This is the default behavior. + +1: on detection capture more debug information. + +=============================== + tainted: Non-zero if the kernel has been tainted. Numeric values, which
include/linux/nmi.h +3 -0
@@ -57,6 +57,9 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *);u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; +#ifdef CONFIG_SMP +extern int sysctl_softlockup_all_cpu_backtrace; +#endif struct ctl_table ;extern int proc_dowatchdog (struct ctl_table *,int ,void __user *,size_t *,loff_t *);
kernel/sysctl.c +11 -0
@@ -854,6 +854,17 @@ static struct ctl_table kern_table[] = { .extra1 = &zero, .extra2 = &one, }, +#ifdef CONFIG_SMP + { + .procname = "softlockup_all_cpu_backtrace", + .data = &sysctl_softlockup_all_cpu_backtrace, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = proc_dointvec_minmax, + .extra1 = &zero, + .extra2 = &one, + }, +#endif /* CONFIG_SMP */ { .procname = "nmi_watchdog", .data = &watchdog_user_enabled,
kernel/watchdog.c +33 -0
@@ -31,6 +31,7 @@int watchdog_user_enabled =1 ;int __read_mostly watchdog_thresh =10 ; +int __read_mostly sysctl_softlockup_all_cpu_backtrace;static int __read_mostly watchdog_running;static u64 __read_mostly sample_period;
@@ -47,6 +48,7 @@ static DEFINE_PER_CPU(bool, watchdog_nmi_touch); static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved); static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);#endif +static unsigned long soft_lockup_nmi_warn;/* boot commands */ /*
@@ -95,6 +97,15 @@ static int __init nosoftlockup_setup(char *str) }__setup ("nosoftlockup" , nosoftlockup_setup);/* */ +#ifdef CONFIG_SMP +static int __init softlockup_all_cpu_backtrace_setup (char *str) +{ + sysctl_softlockup_all_cpu_backtrace + !!simple_strtol (str,NULL ,0 ); +return 1 ; +} +__setup ("softlockup_all_cpu_backtrace=" , softlockup_all_cpu_backtrace_setup); +#endif /* * Hard-lockup warnings should be triggered after just a few seconds. Soft-
@@ -267,6 +278,7 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)unsigned long touch_ts =__this_cpu_read (watchdog_touch_ts);struct pt_regs *regs =get_irq_regs ();int duration; +int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;/* kick the hardlockup detector */ watchdog_interrupt_count ();
@@ -313,6 +325,17 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)if (__this_cpu_read (soft_watchdog_warn) = true)return HRTIMER_RESTART ; +if (softlockup_all_cpu_backtrace) { +/* Prevent multiple soft-lockup reports if one cpu is already +* engaged in dumping cpu back traces +*/ +if (test_and_set_bit (0 , &soft_lockup_nmi_warn)) { +/* Someone else will report us. Let's give up */ +__this_cpu_write (soft_watchdog_warn, true); +return HRTIMER_RESTART ; + } + } +printk (KERN_EMERG "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n" ,smp_processor_id (), duration, current->comm,task_pid_nr (current));
@@ -323,6 +346,17 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)else dump_stack (); +if (softlockup_all_cpu_backtrace) { +/* Avoid generating two back traces for current +* given that one is already made above +*/ +trigger_allbutself_cpu_backtrace (); + +clear_bit (0 , &soft_lockup_nmi_warn); +/* Barrier to sync with other cpus */ +smp_mb__after_clear_bit (); + } +if (softlockup_panic)panic ("softlockup: hung tasks" );__this_cpu_write (soft_watchdog_warn, true);
Signature · 1 line
1.7.1
Re: [PATCH 2/2 v4] watchdog: Printing traces for all cpus on lockup detection
Quoted 28 lines · On Wed, 23 Apr 2014 16:40:05 -0400 Don Zickus <[email protected]> wrote:
From: Aaron Tomlin <[email protected]>
A 'softlockup' is defined as a bug that causes the kernel to loop in kernel mode for more than a predefined period to time, without giving other tasks a chance to run.
Currently, upon detection of this condition by the per-cpu watchdog task, debug information (including a stack trace) is sent to the system log.
On some occasions, we have observed that the "victim" rather than the actual "culprit" (i.e. the owner/holder of the contended resource) is reported to the user.
Often this information has proven to be insufficient to assist debugging efforts.To avoid loss of useful debug information, for architectures which support NMI, this patch makes it possible to improve soft lockup reporting. This is accomplished by issuing an NMI to each cpu to obtain a stack trace.
If NMI is not supported we just revert back to the old method. A sysctl and boot-time parameter is available to toggle this feature.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *); · line 62
Quoted 6 lines
include/linux/nmi.h +3
-0@@ -57,6 +57,9 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *);u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; +#ifdef CONFIG_SMP +extern int sysctl_softlockup_all_cpu_backtrace; +#endif
The ifdefs aren't really needed here. If we omit them then error reporting happens at link time rather than at compile time, but that's a small price to pay for cleaning up the code.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *);
Quoted 10 lines
include/linux/nmi.h +10
-0+if (softlockup_all_cpu_backtrace) { +/* Prevent multiple soft-lockup reports if one cpu is already +* engaged in dumping cpu back traces +*/ +if (test_and_set_bit (0 , &soft_lockup_nmi_warn)) { +/* Someone else will report us. Let's give up */ +__this_cpu_write (soft_watchdog_warn, true); +return HRTIMER_RESTART ; + } + }
You missed my suggestion here.
text data bss dec hex filename 1519 524 24 2067 813 kernel/watchdog.o-before 1471 520 16 2007 7d7 kernel/watchdog.o-after
include/linux/nmi.h renamed from include/linux/nmi.h~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +0 -2
@@ -57,9 +57,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; -#ifdef CONFIG_SMP extern int sysctl_softlockup_all_cpu_backtrace; -#endif struct ctl_table ;extern int proc_dowatchdog (struct ctl_table *,int ,void __user *,size_t *,loff_t *);
kernel/watchdog.c renamed from kernel/watchdog.c~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +5 -0
@@ -31,7 +31,12 @@int watchdog_user_enabled =1 ;int __read_mostly watchdog_thresh =10 ; +#ifdef CONFIG_SMP int __read_mostly sysctl_softlockup_all_cpu_backtrace; +#else +#define sysctl_softlockup_all_cpu_backtrace 0 +#endif +static int __read_mostly watchdog_running;static u64 __read_mostly sample_period;
_
Re: [PATCH 2/2 v4] watchdog: Printing traces for all cpus on lockup detection
Quoted 86 lines · Andrew Morton
Quoted 28 lines · On Wed, 23 Apr 2014 16:40:05 -0400 Don Zickus <[email protected]> wrote:
From: Aaron Tomlin <[email protected]>
A 'softlockup' is defined as a bug that causes the kernel to loop in kernel mode for more than a predefined period to time, without giving other tasks a chance to run.
Currently, upon detection of this condition by the per-cpu watchdog task, debug information (including a stack trace) is sent to the system log.
On some occasions, we have observed that the "victim" rather than the actual "culprit" (i.e. the owner/holder of the contended resource) is reported to the user.
Often this information has proven to be insufficient to assist debugging efforts.To avoid loss of useful debug information, for architectures which support NMI, this patch makes it possible to improve soft lockup reporting. This is accomplished by issuing an NMI to each cpu to obtain a stack trace.
If NMI is not supported we just revert back to the old method. A sysctl and boot-time parameter is available to toggle this feature.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *); · line 62
Quoted 6 lines
include/linux/nmi.h +3
-0@@ -57,6 +57,9 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *);u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; +#ifdef CONFIG_SMP +extern int sysctl_softlockup_all_cpu_backtrace; +#endif The ifdefs aren't really needed here. If we omit them then error reporting happens at link time rather than at compile time, but that's a small price to pay for cleaning up the code.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *);
Quoted 10 lines
include/linux/nmi.h +10
-0+if (softlockup_all_cpu_backtrace) { +/* Prevent multiple soft-lockup reports if one cpu is already +* engaged in dumping cpu back traces +*/ +if (test_and_set_bit (0 , &soft_lockup_nmi_warn)) { +/* Someone else will report us. Let's give up */ +__this_cpu_write (soft_watchdog_warn, true); +return HRTIMER_RESTART ; + } + }You missed my suggestion here.
text data bss dec hex filename 1519 524 24 2067 813 kernel/watchdog.o-before 1471 520 16 2007 7d7 kernel/watchdog.o-afterinclude/linux/nmi.h renamed from include/linux/nmi.h~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +0
-2@@ -57,9 +57,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; -#ifdef CONFIG_SMP extern int sysctl_softlockup_all_cpu_backtrace; -#endif struct ctl_table ;extern int proc_dowatchdog (struct ctl_table *,int ,void __user *,size_t *,loff_t *);kernel/watchdog.c renamed from kernel/watchdog.c~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +5
-0@@ -31,7 +31,12 @@int watchdog_user_enabled =1 ;int __read_mostly watchdog_thresh =10 ; +#ifdef CONFIG_SMP int __read_mostly sysctl_softlockup_all_cpu_backtrace; +#else +#define sysctl_softlockup_all_cpu_backtrace 0 +#endif +static int __read_mostly watchdog_running;static u64 __read_mostly sample_period;
Quoted 1 line
_
Ah ok. I will respin the patch with that cleanup. Thanks!
Cheers,
Don
Quoted 1 line
Re: [PATCH 2/2 v4] watchdog: Printing traces for all cpus on lockup detection
Quoted 87 lines · Don Zickus
Quoted 86 lines · Andrew Morton
Quoted 28 lines · On Wed, 23 Apr 2014 16:40:05 -0400 Don Zickus <[email protected]> wrote:
From: Aaron Tomlin <[email protected]>
A 'softlockup' is defined as a bug that causes the kernel to loop in kernel mode for more than a predefined period to time, without giving other tasks a chance to run.
Currently, upon detection of this condition by the per-cpu watchdog task, debug information (including a stack trace) is sent to the system log.
On some occasions, we have observed that the "victim" rather than the actual "culprit" (i.e. the owner/holder of the contended resource) is reported to the user.
Often this information has proven to be insufficient to assist debugging efforts.To avoid loss of useful debug information, for architectures which support NMI, this patch makes it possible to improve soft lockup reporting. This is accomplished by issuing an NMI to each cpu to obtain a stack trace.
If NMI is not supported we just revert back to the old method. A sysctl and boot-time parameter is available to toggle this feature.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *); · line 62
Quoted 6 lines
include/linux/nmi.h +3
-0@@ -57,6 +57,9 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *);u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; +#ifdef CONFIG_SMP +extern int sysctl_softlockup_all_cpu_backtrace; +#endif The ifdefs aren't really needed here. If we omit them then error reporting happens at link time rather than at compile time, but that's a small price to pay for cleaning up the code.
include/linux/nmi.h int hw_nmi_is_cpu_stuck(struct pt_regs *);
Quoted 10 lines
include/linux/nmi.h +10
-0+if (softlockup_all_cpu_backtrace) { +/* Prevent multiple soft-lockup reports if one cpu is already +* engaged in dumping cpu back traces +*/ +if (test_and_set_bit (0 , &soft_lockup_nmi_warn)) { +/* Someone else will report us. Let's give up */ +__this_cpu_write (soft_watchdog_warn, true); +return HRTIMER_RESTART ; + } + }You missed my suggestion here.
text data bss dec hex filename 1519 524 24 2067 813 kernel/watchdog.o-before 1471 520 16 2007 7d7 kernel/watchdog.o-afterinclude/linux/nmi.h renamed from include/linux/nmi.h~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +0
-2@@ -57,9 +57,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *u64 hw_nmi_get_sample_period (int watchdog_thresh);extern int watchdog_user_enabled;extern int watchdog_thresh; -#ifdef CONFIG_SMP extern int sysctl_softlockup_all_cpu_backtrace; -#endif struct ctl_table ;extern int proc_dowatchdog (struct ctl_table *,int ,void __user *,size_t *,loff_t *);kernel/watchdog.c renamed from kernel/watchdog.c~watchdog-printing-traces-for-all-cpus-on-lockup-detection-fix +5
-0@@ -31,7 +31,12 @@int watchdog_user_enabled =1 ;int __read_mostly watchdog_thresh =10 ; +#ifdef CONFIG_SMP int __read_mostly sysctl_softlockup_all_cpu_backtrace; +#else +#define sysctl_softlockup_all_cpu_backtrace 0 +#endif +static int __read_mostly watchdog_running;static u64 __read_mostly sample_period;
Quoted 3 lines
Quoted 1 line
_
Ah ok. I will respin the patch with that cleanup. Thanks!
Or I can just be happy you took care of that for me. :-)
/me should read all his email first...
Thanks,
Don