Skip to contentSkip to conversation

combine nmi_watchdog and softlockup

PATCH In review Don Zickus 6 participants 19 messages Apr 15, 2010 – Apr 19, 2010

Subsystems (4)
lore
Share & tools
lore

Don Zickus

author
#0 lore raw

PATCH v2 1/1 combine nmi_watchdog and softlockup

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

To detect hardlockups, cpus not responding to interrupts, I implemented an hrtimer that runs 5 times for every perf event overflow event. If that stops counting on a cpu, then the cpu is most likely in trouble.

To detect softlockups, tasks not yielding to the scheduler, I used the previous kthread idea that now gets kicked every time the hrtimer fires. If the kthread isn't being scheduled neither is anyone else and the warning is printed to the console.

I tested this on x86_64 and both the softlockup and hardlockup paths work.

V2:
- cleaned up the Kconfig and softlockup combination
- surrounded hardlockup cases with #ifdef CONFIG_PERF_EVENTS_NMI
- seperated out the softlockup case from perf event subsystem
- re-arranged the enabling/disabling nmi watchdog from proc space
- added cpumasks for hardlockup failure cases
- removed fallback to soft events if no PMU exists for hard events

TODO:
- figure out how to make an arch-agnostic clock2cycles call (if possible) to feed into perf events as a sample period
- probably implement some missing procfs stuff

---
 arch/x86/kernel/apic/hw_nmi.c |    2 +-
 include/linux/sched.h         |    6 +
 init/Kconfig                  |    1 +
 kernel/Makefile               |    4 +-
 kernel/sysctl.c               |    9 +
 kernel/watchdog.c             |  570 +++++++++++++++++++++++++++++++++++++++++
 lib/Kconfig.debug             |   21 +-
 7 files changed, 605 insertions(+), 8 deletions(-)
 create mode 100644 kernel/watchdog.c
arch/x86/kernel/apic/hw_nmi.c +1 -1
index e8b78a0..79425f9 100644
@@ -89,7 +89,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
 
 u64 hw_nmi_get_sample_period(void)
 {
-	return cpu_khz * 1000;
+	return (u64)(cpu_khz) * 1000 * 60;
 }
 
 #ifdef ARCH_HAS_NMI_WATCHDOG
include/linux/sched.h +6 -0
index 6f7bba9..83be6d7 100644
@@ -338,6 +338,12 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
 					 size_t *lenp, loff_t *ppos);
 #endif
 
+#ifdef CONFIG_NMI_WATCHDOG
+extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+				  void __user *buffer,
+				  size_t *lenp, loff_t *ppos);
+#endif
+
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched		__attribute__((__section__(".sched.text")))
 
init/Kconfig +1 -0
index 7331a16..0b83612 100644
@@ -948,6 +948,7 @@ config PERF_USE_VMALLOC
 
 config PERF_EVENTS_NMI
 	bool
+	depends on PERF_EVENTS
 	help
 	  Arch has support for nmi_watchdog
 
kernel/Makefile +3 -1
index 8a5abe5..56ba99d 100644
@@ -75,9 +75,11 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += kgdb.o
+ifneq ($(CONFIG_NMI_WATCHDOG),y)
 obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
-obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
+endif
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
+obj-$(CONFIG_NMI_WATCHDOG) += watchdog.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
kernel/sysctl.c +9 -0
index ac72c9e..2165b22 100644
@@ -704,6 +704,15 @@ static struct ctl_table kern_table[] = {
 		.mode           = 0644,
 		.proc_handler   = proc_nmi_enabled,
 	},
+	{
+		.procname	= "watchdog_thresh",
+		.data		= &softlockup_thresh,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= proc_dowatchdog_thresh,
+		.extra1		= &neg_one,
+		.extra2		= &sixty,
+	},
 #endif
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_NMI_WATCHDOG)
 	{
kernel/watchdog.c new file +570 -0

570 lines not on this page · raw message

lib/Kconfig.debug +15 -6
index e2e73cc..280794a 100644
@@ -171,15 +171,24 @@ config DETECT_SOFTLOCKUP
 	   support it.)
 
 config NMI_WATCHDOG
-	bool "Detect Hard Lockups with an NMI Watchdog"
-	depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+	bool "Detect Hard and Soft Lockups"
+	depends on DEBUG_KERNEL
+	default DETECT_SOFTLOCKUP
 	help
 	  Say Y here to enable the kernel to use the NMI as a watchdog
-	  to detect hard lockups.  This is useful when a cpu hangs for no
-	  reason but can still respond to NMIs.  A backtrace is displayed
-	  for reviewing and reporting.
+	  to detect hard and soft lockups.
+
+	  Softlockups are bugs that cause the kernel to loop in kernel
+	  mode for more than 60 seconds, without giving other tasks a
+	  chance to run.  The current stack trace is displayed upon
+	  detection and the system will stay locked up.
+
+	  Hardlockups are bugs that cause the cpu to loop in kernel mode
+	  for more than 60 seconds, without letting other interrupts a
+	  chance to run.  The current stack trace is displayed upon detection
+	  and the system will stay locked up.
 
-	  The overhead should be minimal, just an extra NMI every few
+	  The overhead should me minimal, just an extra NMI every few
 	  seconds.
 
 config BOOTPARAM_SOFTLOCKUP_PANIC
Signature · 1 line
1.6.5.2
#1 lore raw
Quoted 9 lines · On Thu, 15 Apr 2010 17:25:10 -0400 Don Zickus wrote:
 arch/x86/kernel/apic/hw_nmi.c |    2 +-
 include/linux/sched.h         |    6 +
 init/Kconfig                  |    1 +
 kernel/Makefile               |    4 +-
 kernel/sysctl.c               |    9 +
 kernel/watchdog.c             |  570 +++++++++++++++++++++++++++++++++++++++++
 lib/Kconfig.debug             |   21 +-
 7 files changed, 605 insertions(+), 8 deletions(-)
 create mode 100644 kernel/watchdog.c

Updates to Documentation/kernel-parameters.txt ??

kernel/watchdog.c line 79

Quoted 6 lines
kernel/watchdog.c new file +6 -0
+static int __init no_watchdog_setup(char *str)
+{
+	no_watchdog = 1;
+	return 1;
+}
+__setup("no_watchdog", no_watchdog_setup);

New, please document.

kernel/watchdog.c line 86

Quoted 6 lines
kernel/watchdog.c new file +6 -0
+/* deprecated */
+static int __init nosoftlockup_setup(char *str)
+{
+	no_watchdog = 1;
+	return 1;
+}

That's not marked as deprecated anywhere?

kernel/watchdog.c line 93

Quoted 7 lines
kernel/watchdog.c new file +7 -0
+__setup("nosoftlockup", nosoftlockup_setup);
+static int __init nonmi_watchdog_setup(char *str)
+{
+	no_watchdog = 1;
+	return 1;
+}
+__setup("nonmi_watchdog", nonmi_watchdog_setup);

New, please document.

Quoted 6 lines
lib/Kconfig.debug +0 -0
index e2e73cc..280794a 100644
@@ -171,15 +171,24 @@ config DETECT_SOFTLOCKUP
 	   support it.)

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 178

Quoted 10 lines
lib/Kconfig.debug +3 -3
 
 config NMI_WATCHDOG
-	bool "Detect Hard Lockups with an NMI Watchdog"
-	depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+	bool "Detect Hard and Soft Lockups"
+	depends on DEBUG_KERNEL
+	default DETECT_SOFTLOCKUP
 	help
 	  Say Y here to enable the kernel to use the NMI as a watchdog
-	  to detect hard lockups.  This is useful when a cpu hangs for no

preferably: CPU

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 186

Quoted 10 lines
lib/Kconfig.debug +8 -2
-	  reason but can still respond to NMIs.  A backtrace is displayed
-	  for reviewing and reporting.
+	  to detect hard and soft lockups.
+
+	  Softlockups are bugs that cause the kernel to loop in kernel
+	  mode for more than 60 seconds, without giving other tasks a
+	  chance to run.  The current stack trace is displayed upon
+	  detection and the system will stay locked up.
+
+	  Hardlockups are bugs that cause the cpu to loop in kernel mode

ditto

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 187

Quoted 1 line
lib/Kconfig.debug +1 -0
+	  for more than 60 seconds, without letting other interrupts a

have a

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 191

Quoted 5 lines
lib/Kconfig.debug +3 -1
+	  chance to run.  The current stack trace is displayed upon detection
+	  and the system will stay locked up.
 
-	  The overhead should be minimal, just an extra NMI every few
+	  The overhead should me minimal, just an extra NMI every few

be

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 194

Quoted 3 lines
lib/Kconfig.debug +0 -0
 	  seconds.
 
 config BOOTPARAM_SOFTLOCKUP_PANIC

---
~Randy

author
#2 lore raw
Quoted 12 lines · Randy Dunlap
Quoted 9 lines · On Thu, 15 Apr 2010 17:25:10 -0400 Don Zickus wrote:
 arch/x86/kernel/apic/hw_nmi.c |    2 +-
 include/linux/sched.h         |    6 +
 init/Kconfig                  |    1 +
 kernel/Makefile               |    4 +-
 kernel/sysctl.c               |    9 +
 kernel/watchdog.c             |  570 +++++++++++++++++++++++++++++++++++++++++
 lib/Kconfig.debug             |   21 +-
 7 files changed, 605 insertions(+), 8 deletions(-)
 create mode 100644 kernel/watchdog.c
Quoted 1 line

Updates to Documentation/kernel-parameters.txt ??

Thanks for the comments, will try to get them added in the next spin.

Cheers,
Don

#3 lore raw
In reply to Don Zickus
Quoted 27 lines · Don Zickus

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

To detect hardlockups, cpus not responding to interrupts, I implemented an hrtimer that runs 5 times for every perf event overflow event. If that stops counting on a cpu, then the cpu is most likely in trouble.

To detect softlockups, tasks not yielding to the scheduler, I used the previous kthread idea that now gets kicked every time the hrtimer fires. If the kthread isn't being scheduled neither is anyone else and the warning is printed to the console.

I tested this on x86_64 and both the softlockup and hardlockup paths work.

V2:
- cleaned up the Kconfig and softlockup combination
- surrounded hardlockup cases with #ifdef CONFIG_PERF_EVENTS_NMI
- seperated out the softlockup case from perf event subsystem
- re-arranged the enabling/disabling nmi watchdog from proc space
- added cpumasks for hardlockup failure cases
- removed fallback to soft events if no PMU exists for hard events

Quoted 3 lines

TODO:
- figure out how to make an arch-agnostic clock2cycles call (if possible) to feed into perf events as a sample period

In fact we also have the sample_freq thing that let you run against a frequency (events per sec) rather than a sample period.

We do some calculations that recompute the actual sample period on top of this frequency in a regular base as the events come.

It's rather unfortunate we can't have 0.xxxx frequencies but may be we can work that out by adding a freq_unscale field, which would basically produce the frequency like this:

	freq = event->attr.sample_freq * (10 ^ -event->attr.freq_unscale)

This is not trivial though, so let's rather focus on the real matter for now :)

Quoted 35 lines
arch/x86/kernel/apic/hw_nmi.c +1 -1
index e8b78a0..79425f9 100644
@@ -89,7 +89,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
 
 u64 hw_nmi_get_sample_period(void)
 {
-	return cpu_khz * 1000;
+	return (u64)(cpu_khz) * 1000 * 60;
 }
 
 #ifdef ARCH_HAS_NMI_WATCHDOG
include/linux/sched.h +6 -0
index 6f7bba9..83be6d7 100644
@@ -338,6 +338,12 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
 					 size_t *lenp, loff_t *ppos);
 #endif
 
+#ifdef CONFIG_NMI_WATCHDOG
+extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+				  void __user *buffer,
+				  size_t *lenp, loff_t *ppos);
+#endif
+
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched		__attribute__((__section__(".sched.text")))
 
init/Kconfig +0 -0
index 7331a16..0b83612 100644

init/Kconfig config PERF_USE_VMALLOC · line 953

Quoted 6 lines
init/Kconfig +1 -0
@@ -948,6 +948,7 @@ config PERF_USE_VMALLOC
 
 config PERF_EVENTS_NMI
 	bool
+	depends on PERF_EVENTS
 	help
 	  Arch has support for nmi_watchdog

That looks too general. It's more about the fact the arch supports cpu cycle events and generates NMIs on overflow.

kernel/Makefile obj-$(CONFIG_GCOV_KERNEL) += gcov/ · line 80

Quoted 12 lines
kernel/Makefile +2 -1
index 8a5abe5..56ba99d 100644
@@ -75,9 +75,11 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += kgdb.o
+ifneq ($(CONFIG_NMI_WATCHDOG),y)
 obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
-obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
+endif

I'm confused, do we have two versions of the softlockup detector now? You should drop the older one.

Quoted 31 lines
kernel/Makefile +1 -0
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
+obj-$(CONFIG_NMI_WATCHDOG) += watchdog.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
kernel/sysctl.c +9 -0
index ac72c9e..2165b22 100644
@@ -704,6 +704,15 @@ static struct ctl_table kern_table[] = {
 		.mode           = 0644,
 		.proc_handler   = proc_nmi_enabled,
 	},
+	{
+		.procname	= "watchdog_thresh",
+		.data		= &softlockup_thresh,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= proc_dowatchdog_thresh,
+		.extra1		= &neg_one,
+		.extra2		= &sixty,
+	},
 #endif
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_NMI_WATCHDOG)
 	{
kernel/watchdog.c new file +0 -0
new file mode 100644
index 0000000..fad5b1a

kernel/watchdog.c line 2

Quoted 2 lines
kernel/watchdog.c new file +2 -0
@@ -0,0 +1,570 @@
+/*
+ * Detect Hard/Soft Lockups using the NMI

Well, softlockups detection doesn't use NMI.

Quoted 17 lines
kernel/watchdog.c new file +17 -0
+/*
+ * Returns seconds, approximately.  We don't need nanosecond
+ * resolution, and we don't need to waste time with a big divide when
+ * 2^30ns == 1.074s.
+ */
+static unsigned long get_timestamp(int this_cpu)
+{
+	return cpu_clock(this_cpu) >> 30LL;  /* 2^30 ~= 10^9 */
+}
+
+static unsigned long get_sample_period(void)
+{
+	/*
+	 * convert softlockup_thresh from seconds to ns
+	 * the divide by 5 is to give hrtimer 5 chances to
+	 * increment before the hardlockup detector generates
+	 * a warning

kernel/watchdog.c line 123

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	 */
+	return softlockup_thresh / 5 * NSEC_PER_SEC;
+}
+
+/* Commands for resetting the watchdog */
+static void __touch_watchdog(void)
+{
+	int this_cpu = raw_smp_processor_id();
+
+	__raw_get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);

Please use __get_cpu_var() instead so that we keep the preempt disabled check from smp_processor_id()

kernel/watchdog.c line 128

Quoted 5 lines
kernel/watchdog.c new file +5 -0
+}
+
+void touch_watchdog(void)
+{
+	__raw_get_cpu_var(watchdog_touch_ts) = 0;

Same here.

Quoted 27 lines
kernel/watchdog.c new file +27 -0
+}
+EXPORT_SYMBOL(touch_watchdog);
+
+void touch_all_watchdog(void)
+{
+	int cpu;
+
+	for_each_online_cpu(cpu)
+		per_cpu(watchdog_touch_ts, cpu) = 0;
+}
+
+/* deprecated functions */
+void touch_nmi_watchdog(void)
+{
+	touch_watchdog();
+}
+EXPORT_SYMBOL(touch_nmi_watchdog);
+
+void touch_all_nmi_watchdog(void)
+{
+	touch_all_watchdog();
+}
+
+void touch_softlockup_watchdog(void)
+{
+	touch_watchdog();
+}

kernel/watchdog.c line 165

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+
+void touch_all_softlockup_watchdogs(void)
+{
+	touch_all_watchdog();
+}
+
+void softlockup_tick(void)
+{
+}
+/* end of deprecated functions */

You should replace the call sites directly.

Quoted 43 lines
kernel/watchdog.c new file +43 -0
+#ifdef CONFIG_PERF_EVENTS_NMI
+/* watchdog detector functions */
+static int is_hardlockup(int cpu)
+{
+	unsigned long hrint = per_cpu(hrtimer_interrupts, cpu);
+
+	if (per_cpu(hrtimer_interrupts_saved, cpu) == hrint)
+		return 1;
+
+	per_cpu(hrtimer_interrupts_saved, cpu) = hrint;
+	return 0;
+}
+#endif
+
+static int is_softlockup(unsigned long touch_ts, int cpu)
+{
+	unsigned long now = get_timestamp(cpu);
+
+	/* Warn about unreasonable delays: */
+	if (now > (touch_ts + softlockup_thresh))
+		return now - touch_ts;
+
+	return 0;
+}
+
+static int
+watchdog_panic(struct notifier_block *this, unsigned long event, void *ptr)
+{
+	did_panic = 1;
+
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block panic_block = {
+	.notifier_call = watchdog_panic,
+};
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+struct perf_event_attr wd_hw_attr = {
+	.type		= PERF_TYPE_HARDWARE,
+	.config		= PERF_COUNT_HW_CPU_CYCLES,
+	.size		= sizeof(struct perf_event_attr),
+	.pinned		= 1,

kernel/watchdog.c line 219

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	.disabled	= 1,
+};
+
+struct perf_event_attr wd_sw_attr = {
+	.type		= PERF_TYPE_SOFTWARE,
+	.config		= PERF_COUNT_SW_CPU_CLOCK,
+	.size		= sizeof(struct perf_event_attr),
+	.pinned		= 1,
+	.disabled	= 1,
+};

Why do you keep the software clock, I don't see how it can be useful to detect hardlockups. It triggers in a regular irq not an NMI.

Quoted 21 lines
kernel/watchdog.c new file +21 -0
+
+/* Callback function for perf event subsystem */
+void watchdog_overflow_callback(struct perf_event *event, int nmi,
+		 struct perf_sample_data *data,
+		 struct pt_regs *regs)
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return;
+	}
+
+	/* check for a hardlockup
+	 * This is done by making sure our timer interrupt
+	 * is incrementing.  The timer interrupt should have
+	 * fired multiple times before we overflow'd.  If it hasn't
+	 * then this is a good indication the cpu is stuck
+	 */
+	if (is_hardlockup(this_cpu)) {

kernel/watchdog.c line 250

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+		/* only print hardlockups once */
+		if (cpumask_test_cpu(this_cpu, to_cpumask(hardlockup_mask)))
+			return;
+
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

kernel/watchdog.c line 254

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		return;
+	}
+
+	cpumask_clear_cpu(this_cpu, to_cpumask(hardlockup_mask));

Hmm...this is probably not necessary.

Quoted 6 lines
kernel/watchdog.c new file +6 -0
+	return;
+}
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* watchdog kicker functions */
+static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)

kernel/watchdog.c line 270

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+	struct pt_regs *regs = get_irq_regs();
+	int duration;
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+	/* kick the hardlockup detector */
+	__get_cpu_var(hrtimer_interrupts)++;
+#endif

Please avoid such ifdefs in the middle of the code.

It's better to gather hardlockup matters in a single ifdef block:

#ifdef CONFIG_PERF_EVENTS_NMI
define your functions here
#else
define (if needed) your off case functions here (static inline stubs) #endif

Quoted 22 lines
kernel/watchdog.c new file +22 -0
+
+	/* kick the softlockup detector */
+	wake_up_process(__get_cpu_var(softlockup_watchdog));
+
+	/* .. and repeat */
+	hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return HRTIMER_RESTART;
+	}
+
+	/* check for a softlockup
+	 * This is done by making sure a high priority task is
+	 * being scheduled.  The task touches the watchdog to
+	 * indicate it is getting cpu time.  If it hasn't then
+	 * this is a good indication some task is hogging the cpu
+	 */
+	duration = is_softlockup(touch_ts, this_cpu);
+	if (duration) {
+		printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
+			this_cpu, duration,

kernel/watchdog.c line 302

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+			current->comm, task_pid_nr(current));
+		print_modules();
+		print_irqtrace_events(current);
+		if (regs)
+			show_regs(regs);
+		else
+			dump_stack();
+
+		if (softlockup_panic)
+			panic("softlockup: hung tasks");

You probably want a backtrace cpu mask here as well (but better don't use the same than the hardlockup thing)

Quoted 41 lines
kernel/watchdog.c new file +41 -0
+	}
+
+	return HRTIMER_RESTART;
+}
+
+
+/*
+ * The watchdog thread - touches the timestamp.
+ */
+static int watchdog(void *__bind_cpu)
+{
+	struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, (unsigned long)__bind_cpu);
+
+	sched_setscheduler(current, SCHED_FIFO, &param);
+
+	/* initialize timestamp */
+	__touch_watchdog();
+
+	/* kick off the timer for the hardlockup detector */
+	/* done here because hrtimer_start can only pin to smp_processor_id() */
+	hrtimer_start(hrtimer, ns_to_ktime(get_sample_period()),
+		      HRTIMER_MODE_REL_PINNED);
+
+	set_current_state(TASK_INTERRUPTIBLE);
+	/*
+	 * Run briefly once per second to reset the softlockup timestamp.
+	 * If this gets delayed for more than 60 seconds then the
+	 * debug-printout triggers in softlockup_tick().
+	 */
+	while (!kthread_should_stop()) {
+		__touch_watchdog();
+		schedule();
+
+		if (kthread_should_stop())
+			break;
+
+		set_current_state(TASK_INTERRUPTIBLE);
+	}
+	__set_current_state(TASK_RUNNING);
+

kernel/watchdog.c line 353

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	return 0;
+}
+
+
+/* prepare/enable/disable routines */
+static int watchdog_prepare_cpu(int cpu)
+{
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+
+	BUG_ON(per_cpu(softlockup_watchdog, cpu));

Please warn here instead, nothing seriously dangerous is going to happen.

Quoted 30 lines
kernel/watchdog.c new file +30 -0
+	hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	hrtimer->function = watchdog_timer_fn;
+
+	return 0;
+}
+
+static int watchdog_enable(int cpu)
+{
+	struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
+#ifdef CONFIG_PERF_EVENTS_NMI
+	struct perf_event_attr *wd_attr;
+	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+
+	/* is it already setup and enabled? */
+	if (event && event->state > PERF_EVENT_STATE_OFF)
+		goto out;
+
+	/* it is setup but not enabled */
+	if (event != NULL)
+		goto out_enable;
+
+	/* Try to register using hardware perf events */
+	wd_attr = &wd_hw_attr;
+	wd_attr->sample_period = hw_nmi_get_sample_period();
+	event = perf_event_create_kernel_counter(wd_attr, cpu, -1, watchdog_overflow_callback);
+	if (!IS_ERR(event)) {
+		printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
+		goto out_save;
+	}
+

kernel/watchdog.c line 393

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	printk(KERN_ERR "NMI watchdog failed to create perf event on cpu%i: %p\n", cpu, event);
+	return -1;
+
+	/* success path */
+out_save:
+	per_cpu(watchdog_ev, cpu) = event;
+out_enable:
+	perf_event_enable(per_cpu(watchdog_ev, cpu));
+out:
+#endif /* CONFIG_PERF_EVENTS_NMI */

Especially such kind of idef in a function plus goto in the middle, we really want to avoid that.

You want a watchdog_nmi_enable() call instead that does nothing if !CONFIG_PERF_EVENTS_NMI.

Quoted 80 lines
kernel/watchdog.c new file +80 -0
+
+	/* create the watchdog thread */
+	if (!p) {
+		p = kthread_create(watchdog, (void *)(unsigned long)cpu, "watchdog/%d", cpu);
+		if (IS_ERR(p)) {
+			printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu);
+			return -1;
+		}
+		kthread_bind(p, cpu);
+		per_cpu(watchdog_touch_ts, cpu) = 0;
+		per_cpu(softlockup_watchdog, cpu) = p;
+		wake_up_process(p);
+	}
+
+	return 0;
+}
+
+static void watchdog_disable(int cpu)
+{
+	struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+#ifdef CONFIG_PERF_EVENTS_NMI
+	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+#endif
+
+	/*
+	 * cancel the timer first to stop incrementing the stats
+	 * and waking up the kthread
+	 */
+	hrtimer_cancel(hrtimer);
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+	if (event) {
+		perf_event_disable(event);
+		per_cpu(watchdog_ev, cpu) = NULL;
+
+		/* should be in cleanup, but blocks oprofile */
+		perf_event_release_kernel(event);
+	}
+#endif
+
+	if (p) {
+		per_cpu(softlockup_watchdog, cpu) = NULL;
+		kthread_stop(p);
+	}
+
+	/* if any cpu succeeds, watchdog is considered enabled for the system */
+	nmi_watchdog_enabled = 1;
+}
+
+static void watchdog_cleanup(int cpu)
+{
+
+}
+
+static void watchdog_enable_all_cpus(void)
+{
+	int cpu;
+	int result;
+
+	for_each_online_cpu(cpu)
+		result += watchdog_enable(cpu);
+
+	if (result)
+		printk(KERN_ERR "watchdog: failed to be enabled on some cpus\n");
+
+}
+
+static void watchdog_disable_all_cpus(void)
+{
+	int cpu;
+
+	for_each_online_cpu(cpu)
+		watchdog_disable(cpu);
+
+	/* if all watchdogs are disabled, then they are disabled for the system */
+	nmi_watchdog_enabled = 0;
+}
+
+

kernel/watchdog.c line 483

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+/* sysctl functions */
+#ifdef CONFIG_SYSCTL
+/*
+ * proc handler for /proc/sys/kernel/nmi_watchdog
+ */
+
+int proc_nmi_enabled(struct ctl_table *table, int write,
+		     void __user *buffer, size_t *length, loff_t *ppos)
+{
+	touch_all_watchdog();

Why do you need to touch watchdogs here?

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+	proc_dointvec(table, write, buffer, length, ppos);
+
+	if (nmi_watchdog_enabled)
+		watchdog_enable_all_cpus();

kernel/watchdog.c line 497

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	else
+		watchdog_disable_all_cpus();
+	return 0;
+}
+
+int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+			     void __user *buffer,
+			     size_t *lenp, loff_t *ppos)
+{
+	touch_all_watchdog();

Same here?

Quoted 53 lines
kernel/watchdog.c new file +53 -0
+	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+}
+
+/* stub functions */
+int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+			     void __user *buffer,
+			     size_t *lenp, loff_t *ppos)
+{
+	return proc_dowatchdog_thresh(table, write, buffer, lenp, ppos);
+}
+/* end of stub functions */
+#endif /* CONFIG_SYSCTL */
+
+
+/*
+ * Create/destroy watchdog threads as CPUs come and go:
+ */
+static int __cpuinit
+cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
+{
+	int hotcpu = (unsigned long)hcpu;
+
+	switch (action) {
+	case CPU_UP_PREPARE:
+	case CPU_UP_PREPARE_FROZEN:
+		if (watchdog_prepare_cpu(hotcpu))
+			return NOTIFY_BAD;
+		break;
+	case CPU_ONLINE:
+	case CPU_ONLINE_FROZEN:
+		if (watchdog_enable(hotcpu))
+			return NOTIFY_BAD;
+		break;
+#ifdef CONFIG_HOTPLUG_CPU
+	case CPU_UP_CANCELED:
+	case CPU_UP_CANCELED_FROZEN:
+		watchdog_disable(hotcpu);
+		break;
+	case CPU_DEAD:
+	case CPU_DEAD_FROZEN:
+		watchdog_disable(hotcpu);
+		watchdog_cleanup(hotcpu);
+		break;
+#endif /* CONFIG_HOTPLUG_CPU */
+	}
+	return NOTIFY_OK;
+}
+
+static struct notifier_block __cpuinitdata cpu_nfb = {
+	.notifier_call = cpu_callback
+};
+
+static int __init spawn_watchdog_task(void)

kernel/watchdog.c line 560

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+{
+	void *cpu = (void *)(long)smp_processor_id();
+	int err;
+
+	if (no_watchdog)
+		return 0;
+
+	err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
+	if (err == NOTIFY_BAD) {
+		BUG();

Please warn instead, there is nothing fatal here.

Quoted 15 lines
kernel/watchdog.c new file +10 -0
+		return 1;
+	}
+	cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
+	register_cpu_notifier(&cpu_nfb);
+
+	atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
+
+	return 0;
+}
+early_initcall(spawn_watchdog_task);
lib/Kconfig.debug +0 -0
index e2e73cc..280794a 100644

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 176

Quoted 8 lines
lib/Kconfig.debug +3 -2
@@ -171,15 +171,24 @@ config DETECT_SOFTLOCKUP
 	   support it.)
 
 config NMI_WATCHDOG
-	bool "Detect Hard Lockups with an NMI Watchdog"
-	depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+	bool "Detect Hard and Soft Lockups"
+	depends on DEBUG_KERNEL
+	default DETECT_SOFTLOCKUP

I'd suggest to drop the NMI prefix, this is not anymore about detecting hard lockups only.

May be config WATCHDOG or config LOCKUP_DETECTOR if it's taken already.

Also you should half-drop the DETECT_SOFTLOCKUP thing:
keep it's definition but drop the ability to choose it from the prompt:

config DETECT_SOFTLOCKUP

	bool
	depends on DEBUG_KERNEL && !S390
	default y

This way we keep it for compatibility with def_configs, it will enable the WATCHDOG by default if it is "y", we can schedule its removal later.

Thanks.

author
#4 lore raw
Quoted 47 lines · Frederic Weisbecker
Quoted 27 lines · Don Zickus

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

To detect hardlockups, cpus not responding to interrupts, I implemented an hrtimer that runs 5 times for every perf event overflow event. If that stops counting on a cpu, then the cpu is most likely in trouble.

To detect softlockups, tasks not yielding to the scheduler, I used the previous kthread idea that now gets kicked every time the hrtimer fires. If the kthread isn't being scheduled neither is anyone else and the warning is printed to the console.

I tested this on x86_64 and both the softlockup and hardlockup paths work.

V2:
- cleaned up the Kconfig and softlockup combination
- surrounded hardlockup cases with #ifdef CONFIG_PERF_EVENTS_NMI
- seperated out the softlockup case from perf event subsystem
- re-arranged the enabling/disabling nmi watchdog from proc space
- added cpumasks for hardlockup failure cases
- removed fallback to soft events if no PMU exists for hard events

Quoted 3 lines

TODO:
- figure out how to make an arch-agnostic clock2cycles call (if possible) to feed into perf events as a sample period

In fact we also have the sample_freq thing that let you run against a frequency (events per sec) rather than a sample period.

We do some calculations that recompute the actual sample period on top of this frequency in a regular base as the events come.

It's rather unfortunate we can't have 0.xxxx frequencies but may be we can work that out by adding a freq_unscale field, which would basically produce the frequency like this:

Quoted 4 lines
	freq = event->attr.sample_freq * (10 ^ -event->attr.freq_unscale)

This is not trivial though, so let's rather focus on the real matter for now :)

Interesting thanks.

Quoted 38 lines
Quoted 38 lines
arch/x86/kernel/apic/hw_nmi.c +1 -1
index e8b78a0..79425f9 100644
@@ -89,7 +89,7 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
 
 u64 hw_nmi_get_sample_period(void)
 {
-	return cpu_khz * 1000;
+	return (u64)(cpu_khz) * 1000 * 60;
 }
 
 #ifdef ARCH_HAS_NMI_WATCHDOG
include/linux/sched.h +6 -0
index 6f7bba9..83be6d7 100644
@@ -338,6 +338,12 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
 					 size_t *lenp, loff_t *ppos);
 #endif
 
+#ifdef CONFIG_NMI_WATCHDOG
+extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+				  void __user *buffer,
+				  size_t *lenp, loff_t *ppos);
+#endif
+
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched		__attribute__((__section__(".sched.text")))
 
init/Kconfig +0 -0
index 7331a16..0b83612 100644
@@ -948,6 +948,7 @@ config PERF_USE_VMALLOC
 
Quoted 10 lines

init/Kconfig config PERF_USE_VMALLOC · line 953

Quoted 5 lines
init/Kconfig +1 -0
 config PERF_EVENTS_NMI
 	bool
+	depends on PERF_EVENTS
 	help
 	  Arch has support for nmi_watchdog

That looks too general. It's more about the fact the arch supports cpu cycle events and generates NMIs on overflow.

I was trying to figure out a way to add the PERF_EVENTS dependency as I didn't want to impose it on the CONFIG_NMI_WATCHDOG if that config supported softlockup (which doesn't need the PERF_EVENTS).

Quoted 12 lines
Quoted 12 lines
kernel/Makefile +1 -0
index 8a5abe5..56ba99d 100644
@@ -75,9 +75,11 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += kgdb.o
+ifneq ($(CONFIG_NMI_WATCHDOG),y)
Quoted 8 lines

kernel/Makefile obj-$(CONFIG_GCOV_KERNEL) += gcov/ · line 80

Quoted 3 lines
kernel/Makefile +1 -1
 obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
-obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
+endif

I'm confused, do we have two versions of the softlockup detector now? You should drop the older one.

Originally Ingo talked about a migration path, so I was going to support the older one in case the new one was having issues, sort of like what he suggested about moving the nmi code from arch/x86/kernel/apic/nmi.c to kernel/watchdog.c. But I can probably drop the softlockup case as the migration isn't as tricky as the nmi case.

Quoted 32 lines
Quoted 32 lines
kernel/Makefile +1 -0
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
+obj-$(CONFIG_NMI_WATCHDOG) += watchdog.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
kernel/sysctl.c +9 -0
index ac72c9e..2165b22 100644
@@ -704,6 +704,15 @@ static struct ctl_table kern_table[] = {
 		.mode           = 0644,
 		.proc_handler   = proc_nmi_enabled,
 	},
+	{
+		.procname	= "watchdog_thresh",
+		.data		= &softlockup_thresh,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= proc_dowatchdog_thresh,
+		.extra1		= &neg_one,
+		.extra2		= &sixty,
+	},
 #endif
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_NMI_WATCHDOG)
 	{
kernel/watchdog.c new file +0 -1
new file mode 100644
index 0000000..fad5b1a
--- /dev/null
Quoted 8 lines

kernel/watchdog.c line 2

Quoted 4 lines

+++ b/kernel/watchdog.c

kernel/watchdog.c new file +2 -0
@@ -0,0 +1,570 @@
+/*
+ * Detect Hard/Soft Lockups using the NMI

Well, softlockups detection doesn't use NMI.

Yeah, sorry. I dropped part of the code per your suggestion and forget to update the comments.

Quoted 27 lines
Quoted 27 lines
kernel/watchdog.c new file +24 -0
+/*
+ * Returns seconds, approximately.  We don't need nanosecond
+ * resolution, and we don't need to waste time with a big divide when
+ * 2^30ns == 1.074s.
+ */
+static unsigned long get_timestamp(int this_cpu)
+{
+	return cpu_clock(this_cpu) >> 30LL;  /* 2^30 ~= 10^9 */
+}
+
+static unsigned long get_sample_period(void)
+{
+	/*
+	 * convert softlockup_thresh from seconds to ns
+	 * the divide by 5 is to give hrtimer 5 chances to
+	 * increment before the hardlockup detector generates
+	 * a warning
+	 */
+	return softlockup_thresh / 5 * NSEC_PER_SEC;
+}
+
+/* Commands for resetting the watchdog */
+static void __touch_watchdog(void)
+{
Quoted 8 lines

kernel/watchdog.c line 123

Quoted 3 lines
kernel/watchdog.c new file +3 -0
+	int this_cpu = raw_smp_processor_id();
+
+	__raw_get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);

Please use __get_cpu_var() instead so that we keep the preempt disabled check from smp_processor_id()

ok.

Quoted 47 lines

kernel/watchdog.c line 128

Quoted 8 lines
kernel/watchdog.c new file +5 -0
+}
+
+void touch_watchdog(void)
+{
+	__raw_get_cpu_var(watchdog_touch_ts) = 0;

Same here.

Quoted 33 lines
kernel/watchdog.c new file +33 -0
+}
+EXPORT_SYMBOL(touch_watchdog);
+
+void touch_all_watchdog(void)
+{
+	int cpu;
+
+	for_each_online_cpu(cpu)
+		per_cpu(watchdog_touch_ts, cpu) = 0;
+}
+
+/* deprecated functions */
+void touch_nmi_watchdog(void)
+{
+	touch_watchdog();
+}
+EXPORT_SYMBOL(touch_nmi_watchdog);
+
+void touch_all_nmi_watchdog(void)
+{
+	touch_all_watchdog();
+}
+
+void touch_softlockup_watchdog(void)
+{
+	touch_watchdog();
+}
+
+void touch_all_softlockup_watchdogs(void)
+{
+	touch_all_watchdog();
+}
+
Quoted 8 lines

kernel/watchdog.c line 165

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+void softlockup_tick(void)
+{
+}
+/* end of deprecated functions */

You should replace the call sites directly.

ok.

Quoted 55 lines
Quoted 55 lines
kernel/watchdog.c new file +52 -0
+#ifdef CONFIG_PERF_EVENTS_NMI
+/* watchdog detector functions */
+static int is_hardlockup(int cpu)
+{
+	unsigned long hrint = per_cpu(hrtimer_interrupts, cpu);
+
+	if (per_cpu(hrtimer_interrupts_saved, cpu) == hrint)
+		return 1;
+
+	per_cpu(hrtimer_interrupts_saved, cpu) = hrint;
+	return 0;
+}
+#endif
+
+static int is_softlockup(unsigned long touch_ts, int cpu)
+{
+	unsigned long now = get_timestamp(cpu);
+
+	/* Warn about unreasonable delays: */
+	if (now > (touch_ts + softlockup_thresh))
+		return now - touch_ts;
+
+	return 0;
+}
+
+static int
+watchdog_panic(struct notifier_block *this, unsigned long event, void *ptr)
+{
+	did_panic = 1;
+
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block panic_block = {
+	.notifier_call = watchdog_panic,
+};
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+struct perf_event_attr wd_hw_attr = {
+	.type		= PERF_TYPE_HARDWARE,
+	.config		= PERF_COUNT_HW_CPU_CYCLES,
+	.size		= sizeof(struct perf_event_attr),
+	.pinned		= 1,
+	.disabled	= 1,
+};
+
+struct perf_event_attr wd_sw_attr = {
+	.type		= PERF_TYPE_SOFTWARE,
+	.config		= PERF_COUNT_SW_CPU_CLOCK,
+	.size		= sizeof(struct perf_event_attr),
+	.pinned		= 1,
+	.disabled	= 1,
Quoted 8 lines

kernel/watchdog.c line 124

Quoted 1 line
kernel/watchdog.c new file +1 -0
+};

Why do you keep the software clock, I don't see how it can be useful to detect hardlockups. It triggers in a regular irq not an NMI.

sorry, I dropped part of the code and forgot to drop this too.

Quoted 30 lines
Quoted 30 lines
kernel/watchdog.c new file +27 -0
+
+/* Callback function for perf event subsystem */
+void watchdog_overflow_callback(struct perf_event *event, int nmi,
+		 struct perf_sample_data *data,
+		 struct pt_regs *regs)
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return;
+	}
+
+	/* check for a hardlockup
+	 * This is done by making sure our timer interrupt
+	 * is incrementing.  The timer interrupt should have
+	 * fired multiple times before we overflow'd.  If it hasn't
+	 * then this is a good indication the cpu is stuck
+	 */
+	if (is_hardlockup(this_cpu)) {
+		/* only print hardlockups once */
+		if (cpumask_test_cpu(this_cpu, to_cpumask(hardlockup_mask)))
+			return;
+
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
Quoted 8 lines

kernel/watchdog.c line 250

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

ok.

Quoted 11 lines

kernel/watchdog.c line 254

Quoted 7 lines
kernel/watchdog.c new file +4 -0
+		return;
+	}
+
+	cpumask_clear_cpu(this_cpu, to_cpumask(hardlockup_mask));

Hmm...this is probably not necessary.

I was just thinking of the case where dispite the WARN above, the cpu actually recovered and then failed again separately. But I probably won't spend anymore time defending it. :-)

Quoted 24 lines
Quoted 9 lines
kernel/watchdog.c new file +6 -0
+	return;
+}
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* watchdog kicker functions */
+static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)

kernel/watchdog.c line 270

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+	struct pt_regs *regs = get_irq_regs();
+	int duration;
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+	/* kick the hardlockup detector */
+	__get_cpu_var(hrtimer_interrupts)++;
+#endif

Please avoid such ifdefs in the middle of the code.

Quoted 7 lines

It's better to gather hardlockup matters in a single ifdef block:

#ifdef CONFIG_PERF_EVENTS_NMI
define your functions here
#else
define (if needed) your off case functions here (static inline stubs) #endif

ok.

Quoted 32 lines
Quoted 32 lines
kernel/watchdog.c new file +29 -0
+
+	/* kick the softlockup detector */
+	wake_up_process(__get_cpu_var(softlockup_watchdog));
+
+	/* .. and repeat */
+	hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return HRTIMER_RESTART;
+	}
+
+	/* check for a softlockup
+	 * This is done by making sure a high priority task is
+	 * being scheduled.  The task touches the watchdog to
+	 * indicate it is getting cpu time.  If it hasn't then
+	 * this is a good indication some task is hogging the cpu
+	 */
+	duration = is_softlockup(touch_ts, this_cpu);
+	if (duration) {
+		printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
+			this_cpu, duration,
+			current->comm, task_pid_nr(current));
+		print_modules();
+		print_irqtrace_events(current);
+		if (regs)
+			show_regs(regs);
+		else
+			dump_stack();
Quoted 8 lines

kernel/watchdog.c line 302

Quoted 3 lines
kernel/watchdog.c new file +3 -0
+
+		if (softlockup_panic)
+			panic("softlockup: hung tasks");

You probably want a backtrace cpu mask here as well (but better don't use the same than the hardlockup thing)

yup.

Quoted 108 lines
Quoted 44 lines
kernel/watchdog.c new file +41 -0
+	}
+
+	return HRTIMER_RESTART;
+}
+
+
+/*
+ * The watchdog thread - touches the timestamp.
+ */
+static int watchdog(void *__bind_cpu)
+{
+	struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, (unsigned long)__bind_cpu);
+
+	sched_setscheduler(current, SCHED_FIFO, &param);
+
+	/* initialize timestamp */
+	__touch_watchdog();
+
+	/* kick off the timer for the hardlockup detector */
+	/* done here because hrtimer_start can only pin to smp_processor_id() */
+	hrtimer_start(hrtimer, ns_to_ktime(get_sample_period()),
+		      HRTIMER_MODE_REL_PINNED);
+
+	set_current_state(TASK_INTERRUPTIBLE);
+	/*
+	 * Run briefly once per second to reset the softlockup timestamp.
+	 * If this gets delayed for more than 60 seconds then the
+	 * debug-printout triggers in softlockup_tick().
+	 */
+	while (!kthread_should_stop()) {
+		__touch_watchdog();
+		schedule();
+
+		if (kthread_should_stop())
+			break;
+
+		set_current_state(TASK_INTERRUPTIBLE);
+	}
+	__set_current_state(TASK_RUNNING);
+

kernel/watchdog.c line 353

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	return 0;
+}
+
+
+/* prepare/enable/disable routines */
+static int watchdog_prepare_cpu(int cpu)
+{
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+
+	BUG_ON(per_cpu(softlockup_watchdog, cpu));

Please warn here instead, nothing seriously dangerous is going to happen.

Quoted 30 lines
kernel/watchdog.c new file +30 -0
+	hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	hrtimer->function = watchdog_timer_fn;
+
+	return 0;
+}
+
+static int watchdog_enable(int cpu)
+{
+	struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
+#ifdef CONFIG_PERF_EVENTS_NMI
+	struct perf_event_attr *wd_attr;
+	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+
+	/* is it already setup and enabled? */
+	if (event && event->state > PERF_EVENT_STATE_OFF)
+		goto out;
+
+	/* it is setup but not enabled */
+	if (event != NULL)
+		goto out_enable;
+
+	/* Try to register using hardware perf events */
+	wd_attr = &wd_hw_attr;
+	wd_attr->sample_period = hw_nmi_get_sample_period();
+	event = perf_event_create_kernel_counter(wd_attr, cpu, -1, watchdog_overflow_callback);
+	if (!IS_ERR(event)) {
+		printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
+		goto out_save;
+	}
+

kernel/watchdog.c line 393

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	printk(KERN_ERR "NMI watchdog failed to create perf event on cpu%i: %p\n", cpu, event);
+	return -1;
+
+	/* success path */
+out_save:
+	per_cpu(watchdog_ev, cpu) = event;
+out_enable:
+	perf_event_enable(per_cpu(watchdog_ev, cpu));
+out:
+#endif /* CONFIG_PERF_EVENTS_NMI */

Especially such kind of idef in a function plus goto in the middle, we really want to avoid that.

Quoted 2 lines

You want a watchdog_nmi_enable() call instead that does nothing if !CONFIG_PERF_EVENTS_NMI.

ok.

Quoted 89 lines
Quoted 89 lines
kernel/watchdog.c new file +86 -0
+
+	/* create the watchdog thread */
+	if (!p) {
+		p = kthread_create(watchdog, (void *)(unsigned long)cpu, "watchdog/%d", cpu);
+		if (IS_ERR(p)) {
+			printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu);
+			return -1;
+		}
+		kthread_bind(p, cpu);
+		per_cpu(watchdog_touch_ts, cpu) = 0;
+		per_cpu(softlockup_watchdog, cpu) = p;
+		wake_up_process(p);
+	}
+
+	return 0;
+}
+
+static void watchdog_disable(int cpu)
+{
+	struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
+	struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+#ifdef CONFIG_PERF_EVENTS_NMI
+	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+#endif
+
+	/*
+	 * cancel the timer first to stop incrementing the stats
+	 * and waking up the kthread
+	 */
+	hrtimer_cancel(hrtimer);
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+	if (event) {
+		perf_event_disable(event);
+		per_cpu(watchdog_ev, cpu) = NULL;
+
+		/* should be in cleanup, but blocks oprofile */
+		perf_event_release_kernel(event);
+	}
+#endif
+
+	if (p) {
+		per_cpu(softlockup_watchdog, cpu) = NULL;
+		kthread_stop(p);
+	}
+
+	/* if any cpu succeeds, watchdog is considered enabled for the system */
+	nmi_watchdog_enabled = 1;
+}
+
+static void watchdog_cleanup(int cpu)
+{
+
+}
+
+static void watchdog_enable_all_cpus(void)
+{
+	int cpu;
+	int result;
+
+	for_each_online_cpu(cpu)
+		result += watchdog_enable(cpu);
+
+	if (result)
+		printk(KERN_ERR "watchdog: failed to be enabled on some cpus\n");
+
+}
+
+static void watchdog_disable_all_cpus(void)
+{
+	int cpu;
+
+	for_each_online_cpu(cpu)
+		watchdog_disable(cpu);
+
+	/* if all watchdogs are disabled, then they are disabled for the system */
+	nmi_watchdog_enabled = 0;
+}
+
+
+/* sysctl functions */
+#ifdef CONFIG_SYSCTL
+/*
+ * proc handler for /proc/sys/kernel/nmi_watchdog
+ */
+
Quoted 8 lines

kernel/watchdog.c line 483

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+int proc_nmi_enabled(struct ctl_table *table, int write,
+		     void __user *buffer, size_t *length, loff_t *ppos)
+{
+	touch_all_watchdog();

Why do you need to touch watchdogs here?

just legacy stuff I copied over. I can remove.

Quoted 122 lines
Quoted 7 lines
kernel/watchdog.c new file +4 -0
+	proc_dointvec(table, write, buffer, length, ppos);
+
+	if (nmi_watchdog_enabled)
+		watchdog_enable_all_cpus();

kernel/watchdog.c line 497

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+	else
+		watchdog_disable_all_cpus();
+	return 0;
+}
+
+int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+			     void __user *buffer,
+			     size_t *lenp, loff_t *ppos)
+{
+	touch_all_watchdog();

Same here?

Quoted 53 lines
kernel/watchdog.c new file +53 -0
+	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+}
+
+/* stub functions */
+int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+			     void __user *buffer,
+			     size_t *lenp, loff_t *ppos)
+{
+	return proc_dowatchdog_thresh(table, write, buffer, lenp, ppos);
+}
+/* end of stub functions */
+#endif /* CONFIG_SYSCTL */
+
+
+/*
+ * Create/destroy watchdog threads as CPUs come and go:
+ */
+static int __cpuinit
+cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
+{
+	int hotcpu = (unsigned long)hcpu;
+
+	switch (action) {
+	case CPU_UP_PREPARE:
+	case CPU_UP_PREPARE_FROZEN:
+		if (watchdog_prepare_cpu(hotcpu))
+			return NOTIFY_BAD;
+		break;
+	case CPU_ONLINE:
+	case CPU_ONLINE_FROZEN:
+		if (watchdog_enable(hotcpu))
+			return NOTIFY_BAD;
+		break;
+#ifdef CONFIG_HOTPLUG_CPU
+	case CPU_UP_CANCELED:
+	case CPU_UP_CANCELED_FROZEN:
+		watchdog_disable(hotcpu);
+		break;
+	case CPU_DEAD:
+	case CPU_DEAD_FROZEN:
+		watchdog_disable(hotcpu);
+		watchdog_cleanup(hotcpu);
+		break;
+#endif /* CONFIG_HOTPLUG_CPU */
+	}
+	return NOTIFY_OK;
+}
+
+static struct notifier_block __cpuinitdata cpu_nfb = {
+	.notifier_call = cpu_callback
+};
+
+static int __init spawn_watchdog_task(void)

kernel/watchdog.c line 560

Quoted 10 lines
kernel/watchdog.c new file +10 -0
+{
+	void *cpu = (void *)(long)smp_processor_id();
+	int err;
+
+	if (no_watchdog)
+		return 0;
+
+	err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
+	if (err == NOTIFY_BAD) {
+		BUG();

Please warn instead, there is nothing fatal here.

Quoted 15 lines
kernel/watchdog.c new file +10 -0
+		return 1;
+	}
+	cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
+	register_cpu_notifier(&cpu_nfb);
+
+	atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
+
+	return 0;
+}
+early_initcall(spawn_watchdog_task);
lib/Kconfig.debug +0 -0
index e2e73cc..280794a 100644

lib/Kconfig.debug config DETECT_SOFTLOCKUP · line 176

Quoted 8 lines
lib/Kconfig.debug +3 -2
@@ -171,15 +171,24 @@ config DETECT_SOFTLOCKUP
 	   support it.)
 
 config NMI_WATCHDOG
-	bool "Detect Hard Lockups with an NMI Watchdog"
-	depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+	bool "Detect Hard and Soft Lockups"
+	depends on DEBUG_KERNEL
+	default DETECT_SOFTLOCKUP

I'd suggest to drop the NMI prefix, this is not anymore about detecting hard lockups only.

Quoted 2 lines

May be config WATCHDOG or config LOCKUP_DETECTOR if it's taken already.

yeah, I thought about that too. Will work on it.

Quoted 6 lines

Also you should half-drop the DETECT_SOFTLOCKUP thing:
keep it's definition but drop the ability to choose it from the prompt:

Quoted 8 lines

config DETECT_SOFTLOCKUP

	bool
	depends on DEBUG_KERNEL && !S390
	default y

This way we keep it for compatibility with def_configs, it will enable the WATCHDOG by default if it is "y", we can schedule its removal later.

I understand the general idea but not quite the implementation idea. I will work on it and see what I come up with.

Thanks for the review!

Cheers,
Don

#5 lore raw
Quoted 12 lines · Don Zickus
Quoted 10 lines · Frederic Weisbecker

init/Kconfig config PERF_USE_VMALLOC · line 953

Quoted 5 lines

config PERF_EVENTS_NMI

init/Kconfig +1 -0
 	bool
+	depends on PERF_EVENTS
 	help
 	  Arch has support for nmi_watchdog

That looks too general. It's more about the fact the arch supports cpu cycle events and generates NMIs on overflow.

Quoted 3 lines

I was trying to figure out a way to add the PERF_EVENTS dependency as I didn't want to impose it on the CONFIG_NMI_WATCHDOG if that config supported softlockup (which doesn't need the PERF_EVENTS).

Yeah and this is fine. I was talking about the help description.

Quoted 8 lines
Quoted 2 lines

I'm confused, do we have two versions of the softlockup detector now? You should drop the older one.

Originally Ingo talked about a migration path, so I was going to support the older one in case the new one was having issues, sort of like what he suggested about moving the nmi code from arch/x86/kernel/apic/nmi.c to kernel/watchdog.c. But I can probably drop the softlockup case as the migration isn't as tricky as the nmi case.

Ok.

Quoted 9 lines
Quoted 8 lines

kernel/watchdog.c line 254

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		return;
+	}
+
+	cpumask_clear_cpu(this_cpu, to_cpumask(hardlockup_mask));

Hmm...this is probably not necessary.

Quoted 3 lines

I was just thinking of the case where dispite the WARN above, the cpu actually recovered and then failed again separately. But I probably won't spend anymore time defending it. :-)

This is really just a corner case, I guess you don't need to bother with that. It is actually racy against other cpus and adding a spinlock here (in the everything is fine path) would be an overkill.

In fact, having two per cpu vars named hardlockup_warned and softlockup_warned would be better than cpumasks. I'm sorry I suggested you the cpumask, but such per cpu vars will avoid you dealing with these synchonization issues. And one of the primary rules is usually to never take a lock from NMIs if we can :)

Quoted 4 lines
Quoted 2 lines

You probably want a backtrace cpu mask here as well (but better don't use the same than the hardlockup thing)

yup.

So actually, per_cpu softlockup_warned would be better :)

Quoted 9 lines
Quoted 9 lines

Also you should half-drop the DETECT_SOFTLOCKUP thing:
keep it's definition but drop the ability to choose it from the prompt:

config DETECT_SOFTLOCKUP

	bool
	depends on DEBUG_KERNEL && !S390
	default y
Quoted 6 lines
Quoted 3 lines

This way we keep it for compatibility with def_configs, it will enable the WATCHDOG by default if it is "y", we can schedule its removal later.

I understand the general idea but not quite the implementation idea. I will work on it and see what I come up with.

We current have:

config DETECT_SOFTLOCKUP

     bool "Blah"
     depends on DEBUG_KERNEL && !S390
     default y
     help
       .......

The idea is to remove the "Blah" so that the user can't select it anymore from make menuconfig, and to remove the help too as it's useless too.

So that config WATCHDOG can be default y if DETECT_SOFTLOCKUP. Then if someone comes with a config that has DETECT_SOFTLOCKUP, it's new implementation (WATCHDOG) will enabled by default.

author
#6 lore raw
Quoted 13 lines · Frederic Weisbecker
Quoted 12 lines · Don Zickus
Quoted 10 lines · Frederic Weisbecker

init/Kconfig config PERF_USE_VMALLOC · line 953

Quoted 5 lines

config PERF_EVENTS_NMI

init/Kconfig +1 -0
 	bool
+	depends on PERF_EVENTS
 	help
 	  Arch has support for nmi_watchdog

That looks too general. It's more about the fact the arch supports cpu cycle events and generates NMIs on overflow.

Quoted 7 lines
Quoted 3 lines

I was trying to figure out a way to add the PERF_EVENTS dependency as I didn't want to impose it on the CONFIG_NMI_WATCHDOG if that config supported softlockup (which doesn't need the PERF_EVENTS).

Yeah and this is fine. I was talking about the help description.

Oh. heh. ok, will expand that.

Quoted 35 lines
Quoted 11 lines
Quoted 5 lines

I'm confused, do we have two versions of the softlockup detector now? You should drop the older one.

Originally Ingo talked about a migration path, so I was going to support the older one in case the new one was having issues, sort of like what he suggested about moving the nmi code from arch/x86/kernel/apic/nmi.c to kernel/watchdog.c. But I can probably drop the softlockup case as the migration isn't as tricky as the nmi case.

Ok.

Quoted 9 lines
Quoted 8 lines

kernel/watchdog.c line 254

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		return;
+	}
+
+	cpumask_clear_cpu(this_cpu, to_cpumask(hardlockup_mask));

Hmm...this is probably not necessary.

Quoted 3 lines

I was just thinking of the case where dispite the WARN above, the cpu actually recovered and then failed again separately. But I probably won't spend anymore time defending it. :-)

This is really just a corner case, I guess you don't need to bother with that. It is actually racy against other cpus and adding a spinlock here (in the everything is fine path) would be an overkill.

Quoted 5 lines

In fact, having two per cpu vars named hardlockup_warned and softlockup_warned would be better than cpumasks. I'm sorry I suggested you the cpumask, but such per cpu vars will avoid you dealing with these synchonization issues. And one of the primary rules is usually to never take a lock from NMIs if we can :)

Yeah, I guess per cpu is better. I agree that locks in NMI are frowned upon but I wasn't sure of it was dealt with.

I'll try to implement this. Any objections if I combined hardlockup and softlockup with per cpu watchdog_warn and have bit masks for HARDLOCKUP and SOFTLOCKUP? I hate to just waste per cpu space for this.

Quoted 38 lines
Quoted 7 lines
Quoted 5 lines

You probably want a backtrace cpu mask here as well (but better don't use the same than the hardlockup thing)

yup.

So actually, per_cpu softlockup_warned would be better :)

Quoted 9 lines
Quoted 9 lines

Also you should half-drop the DETECT_SOFTLOCKUP thing:
keep it's definition but drop the ability to choose it from the prompt:

config DETECT_SOFTLOCKUP

	bool
	depends on DEBUG_KERNEL && !S390
	default y
Quoted 6 lines
Quoted 3 lines

This way we keep it for compatibility with def_configs, it will enable the WATCHDOG by default if it is "y", we can schedule its removal later.

I understand the general idea but not quite the implementation idea. I will work on it and see what I come up with.

We current have:

config DETECT_SOFTLOCKUP

     bool "Blah"
     depends on DEBUG_KERNEL && !S390
     default y
     help
       .......
Quoted 7 lines

The idea is to remove the "Blah" so that the user can't select it anymore from make menuconfig, and to remove the help too as it's useless too.

So that config WATCHDOG can be default y if DETECT_SOFTLOCKUP. Then if someone comes with a config that has DETECT_SOFTLOCKUP, it's new implementation (WATCHDOG) will enabled by default.

Ah, I missed the bool part. I got it. Thanks for the clarification.

Cheers,
Don

Quoted 1 line
#7 lore raw
Quoted 4 lines · Don Zickus
Quoted 4 lines

This is really just a corner case, I guess you don't need to bother with that. It is actually racy against other cpus and adding a spinlock here (in the everything is fine path) would be an overkill.

Quoted 8 lines
Quoted 5 lines

In fact, having two per cpu vars named hardlockup_warned and softlockup_warned would be better than cpumasks. I'm sorry I suggested you the cpumask, but such per cpu vars will avoid you dealing with these synchonization issues. And one of the primary rules is usually to never take a lock from NMIs if we can :)

Yeah, I guess per cpu is better. I agree that locks in NMI are frowned upon but I wasn't sure of it was dealt with.

They work in fact. They are just not checked by lockdep. And mostly they are very dangerous: if something else can take it (from interrupt, from context) then this is a deadlock. And even though we ensure this is only taken from NMI, we tend to avoid that.

Quoted 3 lines

I'll try to implement this. Any objections if I combined hardlockup and softlockup with per cpu watchdog_warn and have bit masks for HARDLOCKUP and SOFTLOCKUP? I hate to just waste per cpu space for this.

Hmm, a hardlockup can come in after a softlockup.
Don't worry too much about memory: usually the more you have cpu, the more you have memory :)
Plus this is debugging code, not something supposed to be enabled in production.

author
#8 lore raw
Quoted 7 lines · Frederic Weisbecker
Quoted 3 lines

I'll try to implement this. Any objections if I combined hardlockup and softlockup with per cpu watchdog_warn and have bit masks for HARDLOCKUP and SOFTLOCKUP? I hate to just waste per cpu space for this.

Hmm, a hardlockup can come in after a softlockup.

Let me re-explain what I meant. It was meant to do double duty. The softlockup code only checks the SOFTLOCKUP bit and the hardlockup only ever checks the HARDLOCKUP bit.

ie if get_cpu_var(watchdog_warn) && HARDLOCKUP { return; }

Quoted 4 lines

Don't worry too much about memory: usually the more you have cpu, the more you have memory :)
Plus this is debugging code, not something supposed to be enabled in production.

Well depends on your POV. In RHEL we enable both NMI_WATCHDOG and SOFTLOCKUP on production systems (and we have customers that are thankful for that :-) ).

Cheers,
Don

#9 lore raw
Quoted 7 lines · Don Zickus
Quoted 6 lines · Frederic Weisbecker
Quoted 3 lines

I'll try to implement this. Any objections if I combined hardlockup and softlockup with per cpu watchdog_warn and have bit masks for HARDLOCKUP and SOFTLOCKUP? I hate to just waste per cpu space for this.

Quoted 7 lines
Quoted 1 line

Hmm, a hardlockup can come in after a softlockup.

Let me re-explain what I meant. It was meant to do double duty. The softlockup code only checks the SOFTLOCKUP bit and the hardlockup only ever checks the HARDLOCKUP bit.

ie if get_cpu_var(watchdog_warn) && HARDLOCKUP { return; }

Ah right.

Quoted 9 lines
Quoted 5 lines

Don't worry too much about memory: usually the more you have cpu, the more you have memory :)
Plus this is debugging code, not something supposed to be enabled in production.

Well depends on your POV. In RHEL we enable both NMI_WATCHDOG and SOFTLOCKUP on production systems (and we have customers that are thankful for that :-) ).

Ok :)

#10 lore raw
In reply to Frederic Weisbecker

On Fri, Apr 16, 2010 at 03:47:14AM +0200, Frederic Weisbecker wrote:
[...]

Quoted 27 lines
Quoted 27 lines
kernel/watchdog.c new file +27 -0
+
+/* Callback function for perf event subsystem */
+void watchdog_overflow_callback(struct perf_event *event, int nmi,
+		 struct perf_sample_data *data,
+		 struct pt_regs *regs)
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return;
+	}
+
+	/* check for a hardlockup
+	 * This is done by making sure our timer interrupt
+	 * is incrementing.  The timer interrupt should have
+	 * fired multiple times before we overflow'd.  If it hasn't
+	 * then this is a good indication the cpu is stuck
+	 */
+	if (is_hardlockup(this_cpu)) {
+		/* only print hardlockups once */
+		if (cpumask_test_cpu(this_cpu, to_cpumask(hardlockup_mask)))
+			return;
+
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
Quoted 9 lines

kernel/watchdog.c line 250

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

-- Cyrill

#11 lore raw
Quoted 39 lines · Cyrill Gorcunov

On Fri, Apr 16, 2010 at 03:47:14AM +0200, Frederic Weisbecker wrote:
[...]

Quoted 27 lines
Quoted 27 lines
kernel/watchdog.c new file +27 -0
+
+/* Callback function for perf event subsystem */
+void watchdog_overflow_callback(struct perf_event *event, int nmi,
+		 struct perf_sample_data *data,
+		 struct pt_regs *regs)
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return;
+	}
+
+	/* check for a hardlockup
+	 * This is done by making sure our timer interrupt
+	 * is incrementing.  The timer interrupt should have
+	 * fired multiple times before we overflow'd.  If it hasn't
+	 * then this is a good indication the cpu is stuck
+	 */
+	if (is_hardlockup(this_cpu)) {
+		/* only print hardlockups once */
+		if (cpumask_test_cpu(this_cpu, to_cpumask(hardlockup_mask)))
+			return;
+
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
Quoted 9 lines

kernel/watchdog.c line 250

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

Quoted 2 lines

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

The cpu mask is not per cpu here, this is a shared bitmap, so you can race against other cpus NMIs.

That said, as I suggested, having a per cpu var that we set when we warned would be much better than a spinlock here.

maintainer
#12 lore raw
Quoted 7 lines · Frederic Weisbecker
Quoted 5 lines
Quoted 2 lines

May be have an arch spin lock there to update your cpu mask safely.

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

Quoted 5 lines

The cpu mask is not per cpu here, this is a shared bitmap, so you can race against other cpus NMIs.

That said, as I suggested, having a per cpu var that we set when we warned would be much better than a spinlock here.

Every time you think NMI and spinlock think FAIL.

#13 lore raw
Quoted 8 lines · Peter Zijlstra
Quoted 7 lines · Frederic Weisbecker
Quoted 5 lines
Quoted 2 lines

May be have an arch spin lock there to update your cpu mask safely.

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

Quoted 7 lines
Quoted 5 lines

The cpu mask is not per cpu here, this is a shared bitmap, so you can race against other cpus NMIs.

That said, as I suggested, having a per cpu var that we set when we warned would be much better than a spinlock here.

Every time you think NMI and spinlock think FAIL.

In fact I was first inspired by the x86 nmi watchdog handler that does this spinlock to protect cpumask, but realize just after my FAIL ;-)

#14 lore raw
In reply to Frederic Weisbecker

On Fri, Apr 16, 2010 at 04:46:17PM +0200, Frederic Weisbecker wrote:
...

Quoted 16 lines
Quoted 12 lines
Quoted 11 lines

kernel/watchdog.c line 250

Quoted 6 lines
kernel/watchdog.c new file +6 -0
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

Quoted 2 lines

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

Quoted 6 lines

The cpu mask is not per cpu here, this is a shared bitmap, so you can race against other cpus NMIs.

That said, as I suggested, having a per cpu var that we set when we warned would be much better than a spinlock here.

yeah, saw DECLARE_BITMAP but read it as DEFINE_PER_CPU for some reason. having any spinlock in irq handler is really under suspicious.

-- Cyrill

author
#15 lore raw
In reply to Cyrill Gorcunov
Quoted 39 lines · Cyrill Gorcunov

On Fri, Apr 16, 2010 at 03:47:14AM +0200, Frederic Weisbecker wrote:
[...]

Quoted 27 lines
Quoted 27 lines
kernel/watchdog.c new file +27 -0
+
+/* Callback function for perf event subsystem */
+void watchdog_overflow_callback(struct perf_event *event, int nmi,
+		 struct perf_sample_data *data,
+		 struct pt_regs *regs)
+{
+	int this_cpu = smp_processor_id();
+	unsigned long touch_ts = per_cpu(watchdog_touch_ts, this_cpu);
+
+	if (touch_ts == 0) {
+		__touch_watchdog();
+		return;
+	}
+
+	/* check for a hardlockup
+	 * This is done by making sure our timer interrupt
+	 * is incrementing.  The timer interrupt should have
+	 * fired multiple times before we overflow'd.  If it hasn't
+	 * then this is a good indication the cpu is stuck
+	 */
+	if (is_hardlockup(this_cpu)) {
+		/* only print hardlockups once */
+		if (cpumask_test_cpu(this_cpu, to_cpumask(hardlockup_mask)))
+			return;
+
+		if (hardlockup_panic)
+			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
Quoted 9 lines

kernel/watchdog.c line 250

Quoted 4 lines
kernel/watchdog.c new file +4 -0
+		else
+			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
+
+		cpumask_set_cpu(this_cpu, to_cpumask(hardlockup_mask));

May be have an arch spin lock there to update your cpu mask safely.

Quoted 2 lines

Hmm, this is NMI handler path so from what we protect this per-cpu data? Do I miss something? /me confused

It's not per-cpu which is the problem I believe. If you have multiple cpus dealing with hardlockups than they can overwrite each other's data.

Cheers,
Don

author
#16 lore raw
In reply to Frederic Weisbecker
Quoted 8 lines · Frederic Weisbecker
Quoted 7 lines · Don Zickus

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

Hello all,

After making a bunch of cleanups, I am stuck debating whether to continue updating this patch on the stale branch perf/nmi on Ingo's tree or just repost the whole patch again (which isn't much bigger just adds the arch/x86/kernel/apic/hw_nmi.c piece).

Part of the new patch series includes removing kernel/nmi_watchdog.c, which seemed kinda silly because it was only an intermediate file until things got shifted to kernel/watchdog.c

Thoughts?

Cheers,
Don

#17 lore raw
Quoted 17 lines · Don Zickus
Quoted 8 lines · Frederic Weisbecker
Quoted 7 lines · Don Zickus

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

Hello all,

After making a bunch of cleanups, I am stuck debating whether to continue updating this patch on the stale branch perf/nmi on Ingo's tree or just repost the whole patch again (which isn't much bigger just adds the arch/x86/kernel/apic/hw_nmi.c piece).

Quoted 5 lines

Part of the new patch series includes removing kernel/nmi_watchdog.c, which seemed kinda silly because it was only an intermediate file until things got shifted to kernel/watchdog.c

Thoughts?

I'd prefer relative patches as the current perf/nmi bits are tested quite well.

Intermediate stages are not a problem: 90% of the code in the kernel's Git history is 'intermediate' as well, in hindsight. What matters is that the workflow that resulted was clean and that the patches were (and are) clean.

Ingo

author
#18 lore raw
Quoted 24 lines · Ingo Molnar
Quoted 21 lines · Don Zickus
Quoted 8 lines · Frederic Weisbecker
Quoted 7 lines · Don Zickus

The new nmi_watchdog (which uses the perf event subsystem) is very similar in structure to the softlockup detector. Using Ingo's suggestion, I combined the two functionalities into one file, kernel/watchdog.c.

Now both the nmi_watchdog (or hardlockup detector) and softlockup detector sit on top of the perf event subsystem, which is run every 60 seconds or so to see if there are any lockups.

Hello all,

After making a bunch of cleanups, I am stuck debating whether to continue updating this patch on the stale branch perf/nmi on Ingo's tree or just repost the whole patch again (which isn't much bigger just adds the arch/x86/kernel/apic/hw_nmi.c piece).

Part of the new patch series includes removing kernel/nmi_watchdog.c, which seemed kinda silly because it was only an intermediate file until things got shifted to kernel/watchdog.c

Quoted 8 lines
Quoted 1 line

Thoughts?

I'd prefer relative patches as the current perf/nmi bits are tested quite well.

Intermediate stages are not a problem: 90% of the code in the kernel's Git history is 'intermediate' as well, in hindsight. What matters is that the workflow that resulted was clean and that the patches were (and are) clean.

Ok, I'll continue that then. Thanks.

Cheers,
Don