* [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier
2010-04-23 16:13 [PATCH 0/8] lockup detector changes Don Zickus
@ 2010-04-23 16:13 ` Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: Don Zickus @ 2010-04-23 16:13 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
As part of the transition of the nmi watchdog to something more generic,
the trigger_all_cpu_backtrace code is getting left behind. Put it in its
own die_notifier so it can still be used.
V2:
- use arch_spin_locks
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
arch/x86/kernel/apic/hw_nmi.c | 65 ++++++++++++++++++++++++++++++++---------
1 files changed, 51 insertions(+), 14 deletions(-)
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index 79425f9..8c3edfb 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -17,6 +17,10 @@
#include <linux/cpumask.h>
#include <linux/kernel_stat.h>
#include <asm/mce.h>
+#include <linux/kdebug.h>
+#include <linux/notifier.h>
+#include <linux/kprobes.h>
+
#include <linux/nmi.h>
#include <linux/module.h>
@@ -54,20 +58,6 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
unsigned int sum;
int cpu = smp_processor_id();
- /* FIXME: cheap hack for this check, probably should get its own
- * die_notifier handler
- */
- if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
- static DEFINE_SPINLOCK(lock); /* Serialise the printks */
-
- spin_lock(&lock);
- printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
- show_regs(regs);
- dump_stack();
- spin_unlock(&lock);
- cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
- }
-
/* if we are doing an mce, just assume the cpu is not stuck */
/* Could check oops_in_progress here too, but it's safer not to */
if (mce_in_progress())
@@ -109,6 +99,53 @@ void arch_trigger_all_cpu_backtrace(void)
mdelay(1);
}
}
+
+static int __kprobes
+arch_trigger_all_cpu_backtrace_handler(struct notifier_block *self,
+ unsigned long cmd, void *__args)
+{
+ struct die_args *args = __args;
+ struct pt_regs *regs;
+ int cpu = smp_processor_id();
+
+ switch (cmd) {
+ case DIE_NMI:
+ case DIE_NMI_IPI:
+ break;
+
+ default:
+ return NOTIFY_DONE;
+ }
+
+ regs = args->regs;
+
+ if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
+ static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED;
+
+ arch_spin_lock(&lock);
+ printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
+ show_regs(regs);
+ dump_stack();
+ arch_spin_unlock(&lock);
+ cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
+ return NOTIFY_STOP;
+ }
+
+ return NOTIFY_DONE;
+}
+
+static __read_mostly struct notifier_block backtrace_notifier = {
+ .notifier_call = arch_trigger_all_cpu_backtrace_handler,
+ .next = NULL,
+ .priority = 1
+};
+
+static int __init register_trigger_all_cpu_backtrace(void)
+{
+ register_die_notifier(&backtrace_notifier);
+ return 0;
+}
+early_initcall(register_trigger_all_cpu_backtrace);
#endif
/* STUB calls to mimic old nmi_watchdog behaviour */
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 0/8] lockup detector changes
@ 2010-05-07 21:11 Don Zickus
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
` (7 more replies)
0 siblings, 8 replies; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
This patch series covers mostly the changes necessary for combining the
nmi_watchdog and softlockup code. Also added are the cleanups associated
with the change, like removing the old files.
The changelogs in each patch are more specific to what the changes are.
V2:
reworked patch 2 to not change the touch_softlockup_watchdog api but instead
do some cleanups here and there. This caused patches 7 and 8 to be changed a
bit to handle the new differences.
Don Zickus (8):
[watchdog] combine nmi_watchdog and softlockup
[nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
[watchdog] remove old softlockup code
[watchdog] remove nmi_watchdog.c file
[x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier
[x86] watchdog: cleanup hw_nmi.c cruft
[watchdog] resolve softlockup.c conflicts
[watchdog] separate touch_nmi_watchdog code path from touch_watchdog
Documentation/kernel-parameters.txt | 2 +
arch/x86/include/asm/nmi.h | 2 +-
arch/x86/kernel/apic/Makefile | 4 +-
arch/x86/kernel/apic/hw_nmi.c | 119 +++-----
arch/x86/kernel/traps.c | 4 +-
include/linux/nmi.h | 8 +-
include/linux/sched.h | 14 +-
init/Kconfig | 5 +-
kernel/Makefile | 3 +-
kernel/kgdb.c | 6 +-
kernel/nmi_watchdog.c | 259 ----------------
kernel/softlockup.c | 278 -----------------
kernel/sysctl.c | 52 ++--
kernel/timer.c | 1 -
kernel/watchdog.c | 564 +++++++++++++++++++++++++++++++++++
lib/Kconfig.debug | 30 ++-
16 files changed, 684 insertions(+), 667 deletions(-)
delete mode 100644 kernel/nmi_watchdog.c
delete mode 100644 kernel/softlockup.c
create mode 100644 kernel/watchdog.c
^ permalink raw reply [flat|nested] 27+ messages in thread
* [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-12 19:55 ` Frederic Weisbecker
2010-05-13 6:51 ` [tip:perf/nmi] lockup_detector: Combine nmi_watchdog and softlockup detector tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal Don Zickus
` (6 subsequent siblings)
7 siblings, 2 replies; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
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
V3:
- comment cleanups
- drop support for older softlockup code
- per_cpu cleanups
- completely remove software clock base hardlockup detector
- use per_cpu masking on hard/soft lockup detection
- #ifdef cleanups
- rename config option NMI_WATCHDOG to LOCKUP_DETECTOR
- documentation additions
V4:
- documentation fixes
- convert per_cpu to __get_cpu_var
- powerpc compile fixes
V5:
- split apart warn flags for hard and soft lockups
TODO:
- figure out how to make an arch-agnostic clock2cycles call (if possible)
to feed into perf events as a sample period
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
Documentation/kernel-parameters.txt | 2 +
arch/x86/include/asm/nmi.h | 2 +-
arch/x86/kernel/apic/Makefile | 4 +-
arch/x86/kernel/apic/hw_nmi.c | 2 +-
arch/x86/kernel/traps.c | 4 +-
include/linux/nmi.h | 8 +-
include/linux/sched.h | 6 +
init/Kconfig | 5 +-
kernel/Makefile | 3 +-
kernel/sysctl.c | 21 +-
kernel/watchdog.c | 577 +++++++++++++++++++++++++++++++++++
lib/Kconfig.debug | 30 ++-
12 files changed, 635 insertions(+), 29 deletions(-)
create mode 100644 kernel/watchdog.c
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 736d456..705f16f 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1764,6 +1764,8 @@ and is between 256 and 4096 characters. It is defined in the file
nousb [USB] Disable the USB subsystem
+ nowatchdog [KNL] Disable the lockup detector.
+
nowb [ARM]
nox2apic [X86-64,APIC] Do not enable x2APIC mode.
diff --git a/arch/x86/include/asm/nmi.h b/arch/x86/include/asm/nmi.h
index 5b41b0f..932f0f8 100644
--- a/arch/x86/include/asm/nmi.h
+++ b/arch/x86/include/asm/nmi.h
@@ -17,7 +17,7 @@ int do_nmi_callback(struct pt_regs *regs, int cpu);
extern void die_nmi(char *str, struct pt_regs *regs, int do_panic);
extern int check_nmi_watchdog(void);
-#if !defined(CONFIG_NMI_WATCHDOG)
+#if !defined(CONFIG_LOCKUP_DETECTOR)
extern int nmi_watchdog_enabled;
#endif
extern int avail_to_resrv_perfctr_nmi_bit(unsigned int);
diff --git a/arch/x86/kernel/apic/Makefile b/arch/x86/kernel/apic/Makefile
index 1a4512e..52f32e0 100644
--- a/arch/x86/kernel/apic/Makefile
+++ b/arch/x86/kernel/apic/Makefile
@@ -3,10 +3,10 @@
#
obj-$(CONFIG_X86_LOCAL_APIC) += apic.o apic_noop.o probe_$(BITS).o ipi.o
-ifneq ($(CONFIG_NMI_WATCHDOG),y)
+ifneq ($(CONFIG_LOCKUP_DETECTOR),y)
obj-$(CONFIG_X86_LOCAL_APIC) += nmi.o
endif
-obj-$(CONFIG_NMI_WATCHDOG) += hw_nmi.o
+obj-$(CONFIG_LOCKUP_DETECTOR) += hw_nmi.o
obj-$(CONFIG_X86_IO_APIC) += io_apic.o
obj-$(CONFIG_SMP) += ipi.o
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index e8b78a0..79425f9 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -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
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
index bdc7fab..bd347c2 100644
--- a/arch/x86/kernel/traps.c
+++ b/arch/x86/kernel/traps.c
@@ -406,7 +406,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
== NOTIFY_STOP)
return;
-#ifndef CONFIG_NMI_WATCHDOG
+#ifndef CONFIG_LOCKUP_DETECTOR
/*
* Ok, so this is none of the documented NMI sources,
* so it must be the NMI watchdog.
@@ -414,7 +414,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
if (nmi_watchdog_tick(regs, reason))
return;
if (!do_nmi_callback(regs, cpu))
-#endif /* !CONFIG_NMI_WATCHDOG */
+#endif /* !CONFIG_LOCKUP_DETECTOR */
unknown_nmi_error(reason, regs);
#else
unknown_nmi_error(reason, regs);
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 22cc796..abd48aa 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -20,7 +20,7 @@ extern void touch_nmi_watchdog(void);
extern void acpi_nmi_disable(void);
extern void acpi_nmi_enable(void);
#else
-#ifndef CONFIG_NMI_WATCHDOG
+#ifndef CONFIG_LOCKUP_DETECTOR
static inline void touch_nmi_watchdog(void)
{
touch_softlockup_watchdog();
@@ -51,12 +51,12 @@ static inline bool trigger_all_cpu_backtrace(void)
}
#endif
-#ifdef CONFIG_NMI_WATCHDOG
+#ifdef CONFIG_LOCKUP_DETECTOR
int hw_nmi_is_cpu_stuck(struct pt_regs *);
u64 hw_nmi_get_sample_period(void);
-extern int nmi_watchdog_enabled;
+extern int watchdog_enabled;
struct ctl_table;
-extern int proc_nmi_enabled(struct ctl_table *, int ,
+extern int proc_dowatchdog_enabled(struct ctl_table *, int ,
void __user *, size_t *, loff_t *);
#endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6f7bba9..2455ff5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -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_LOCKUP_DETECTOR
+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")))
diff --git a/init/Kconfig b/init/Kconfig
index 7331a16..c5ce8b7 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -948,8 +948,11 @@ config PERF_USE_VMALLOC
config PERF_EVENTS_NMI
bool
+ depends on PERF_EVENTS
help
- Arch has support for nmi_watchdog
+ System hardware can generate an NMI using the perf event
+ subsystem. Also has support for calculating CPU cycle events
+ to determine how many clock cycles in a given period.
menu "Kernel Performance Events And Counters"
diff --git a/kernel/Makefile b/kernel/Makefile
index 8a5abe5..cc3acb3 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -75,9 +75,8 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
obj-$(CONFIG_KPROBES) += kprobes.o
obj-$(CONFIG_KGDB) += kgdb.o
-obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
-obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
+obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
obj-$(CONFIG_SECCOMP) += seccomp.o
obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index ac72c9e..1083897 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -60,7 +60,7 @@
#include <asm/io.h>
#endif
-#ifdef CONFIG_NMI_WATCHDOG
+#ifdef CONFIG_LOCKUP_DETECTOR
#include <linux/nmi.h>
#endif
@@ -696,16 +696,25 @@ static struct ctl_table kern_table[] = {
.mode = 0444,
.proc_handler = proc_dointvec,
},
-#if defined(CONFIG_NMI_WATCHDOG)
+#if defined(CONFIG_LOCKUP_DETECTOR)
{
- .procname = "nmi_watchdog",
- .data = &nmi_watchdog_enabled,
+ .procname = "watchdog",
+ .data = &watchdog_enabled,
.maxlen = sizeof (int),
.mode = 0644,
- .proc_handler = proc_nmi_enabled,
+ .proc_handler = proc_dowatchdog_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)
+#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
{
.procname = "unknown_nmi_panic",
.data = &unknown_nmi_panic,
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
new file mode 100644
index 0000000..2684e95
--- /dev/null
+++ b/kernel/watchdog.c
@@ -0,0 +1,577 @@
+/*
+ * Detect hard and soft lockups on a system
+ *
+ * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
+ *
+ * this code detects hard lockups: incidents in where on a CPU
+ * the kernel does not respond to anything except NMI.
+ *
+ * Note: Most of this code is borrowed heavily from softlockup.c,
+ * so thanks to Ingo for the initial implementation.
+ * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
+ * to those contributors as well.
+ */
+
+#include <linux/mm.h>
+#include <linux/cpu.h>
+#include <linux/nmi.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/freezer.h>
+#include <linux/kthread.h>
+#include <linux/lockdep.h>
+#include <linux/notifier.h>
+#include <linux/module.h>
+#include <linux/sysctl.h>
+
+#include <asm/irq_regs.h>
+#include <linux/perf_event.h>
+
+int watchdog_enabled;
+int __read_mostly softlockup_thresh = 60;
+
+static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
+static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
+static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
+static DEFINE_PER_CPU(bool, hard_watchdog_warn);
+static DEFINE_PER_CPU(bool, soft_watchdog_warn);
+#ifdef CONFIG_PERF_EVENTS_NMI
+static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
+static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
+static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
+#endif
+
+static int __read_mostly did_panic;
+static int __initdata no_watchdog;
+
+
+/* boot commands */
+/*
+ * Should we panic when a soft-lockup or hard-lockup occurs:
+ */
+#ifdef CONFIG_PERF_EVENTS_NMI
+static int hardlockup_panic;
+
+static int __init hardlockup_panic_setup(char *str)
+{
+ if (!strncmp(str, "panic", 5))
+ hardlockup_panic = 1;
+ return 1;
+}
+__setup("nmi_watchdog=", hardlockup_panic_setup);
+#endif
+
+unsigned int __read_mostly softlockup_panic =
+ CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
+
+static int __init softlockup_panic_setup(char *str)
+{
+ softlockup_panic = simple_strtoul(str, NULL, 0);
+
+ return 1;
+}
+__setup("softlockup_panic=", softlockup_panic_setup);
+
+static int __init nowatchdog_setup(char *str)
+{
+ no_watchdog = 1;
+ return 1;
+}
+__setup("nowatchdog", nowatchdog_setup);
+
+/* deprecated */
+static int __init nosoftlockup_setup(char *str)
+{
+ no_watchdog = 1;
+ return 1;
+}
+__setup("nosoftlockup", nosoftlockup_setup);
+/* */
+
+
+/*
+ * 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)
+{
+ int this_cpu = raw_smp_processor_id();
+
+ __get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);
+}
+
+void touch_watchdog(void)
+{
+ __get_cpu_var(watchdog_touch_ts) = 0;
+}
+EXPORT_SYMBOL(touch_watchdog);
+
+void touch_all_watchdog(void)
+{
+ int cpu;
+
+ /*
+ * this is done lockless
+ * do we care if a 0 races with a timestamp?
+ * all it means is the softlock check starts one cycle later
+ */
+ for_each_online_cpu(cpu)
+ per_cpu(watchdog_touch_ts, cpu) = 0;
+}
+
+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();
+}
+
+void softlockup_tick(void)
+{
+}
+
+#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
+static 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,
+};
+
+/* 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 (__get_cpu_var(hard_watchdog_warn) == true)
+ 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);
+
+ __get_cpu_var(hard_watchdog_warn) = true;
+ return;
+ }
+
+ __get_cpu_var(hard_watchdog_warn) = false;
+ return;
+}
+static void watchdog_interrupt_count(void)
+{
+ __get_cpu_var(hrtimer_interrupts)++;
+}
+#else
+static inline void watchdog_interrupt_count(void) { return; }
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* watchdog kicker functions */
+static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
+{
+ int this_cpu = smp_processor_id();
+ unsigned long touch_ts = __get_cpu_var(watchdog_touch_ts);
+ struct pt_regs *regs = get_irq_regs();
+ int duration;
+
+ /* kick the hardlockup detector */
+ watchdog_interrupt_count();
+
+ /* 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 (unlikely(duration)) {
+ /* only warn once */
+ if (__get_cpu_var(soft_watchdog_warn) == true)
+ return HRTIMER_RESTART;
+
+ 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();
+
+ if (softlockup_panic)
+ panic("softlockup: hung tasks");
+ __get_cpu_var(soft_watchdog_warn) = true;
+ } else
+ __get_cpu_var(soft_watchdog_warn) = false;
+
+ 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, ¶m);
+
+ /* 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);
+
+ return 0;
+}
+
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+static int watchdog_nmi_enable(int cpu)
+{
+ 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;
+ }
+
+ 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:
+ return 0;
+}
+
+static void watchdog_nmi_disable(int cpu)
+{
+ struct perf_event *event = per_cpu(watchdog_ev, cpu);
+
+ if (event) {
+ perf_event_disable(event);
+ per_cpu(watchdog_ev, cpu) = NULL;
+
+ /* should be in cleanup, but blocks oprofile */
+ perf_event_release_kernel(event);
+ }
+ return;
+}
+#else
+static int watchdog_nmi_enable(int cpu) { return 0; }
+static void watchdog_nmi_disable(int cpu) { return; }
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* prepare/enable/disable routines */
+static int watchdog_prepare_cpu(int cpu)
+{
+ struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+
+ WARN_ON(per_cpu(softlockup_watchdog, cpu));
+ 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);
+
+ /* enable the perf event */
+ if (watchdog_nmi_enable(cpu) != 0)
+ return -1;
+
+ /* 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);
+
+ /*
+ * cancel the timer first to stop incrementing the stats
+ * and waking up the kthread
+ */
+ hrtimer_cancel(hrtimer);
+
+ /* disable the perf event */
+ watchdog_nmi_disable(cpu);
+
+ /* stop the watchdog thread */
+ if (p) {
+ per_cpu(softlockup_watchdog, cpu) = NULL;
+ kthread_stop(p);
+ }
+
+ /* if any cpu succeeds, watchdog is considered enabled for the system */
+ watchdog_enabled = 1;
+}
+
+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 */
+ watchdog_enabled = 0;
+}
+
+
+/* sysctl functions */
+#ifdef CONFIG_SYSCTL
+/*
+ * proc handler for /proc/sys/kernel/nmi_watchdog
+ */
+
+int proc_dowatchdog_enabled(struct ctl_table *table, int write,
+ void __user *buffer, size_t *length, loff_t *ppos)
+{
+ proc_dointvec(table, write, buffer, length, ppos);
+
+ if (watchdog_enabled)
+ watchdog_enable_all_cpus();
+ 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)
+{
+ 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);
+ 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)
+{
+ void *cpu = (void *)(long)smp_processor_id();
+ int err;
+
+ if (no_watchdog)
+ return 0;
+
+ err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
+ WARN_ON(err == NOTIFY_BAD);
+
+ 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);
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index e2e73cc..97a29e6 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -152,7 +152,7 @@ config DEBUG_SHIRQ
points; some don't and need to be caught.
config DETECT_SOFTLOCKUP
- bool "Detect Soft Lockups"
+ bool
depends on DEBUG_KERNEL && !S390
default y
help
@@ -170,17 +170,27 @@ config DETECT_SOFTLOCKUP
can be detected via the NMI-watchdog, on platforms that
support it.)
-config NMI_WATCHDOG
- bool "Detect Hard Lockups with an NMI Watchdog"
- depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+config LOCKUP_DETECTOR
+ 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.
+ Say Y here to enable the kernel to act as a watchdog 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 have 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
- seconds.
+ The overhead should be minimal. A periodic hrtimer runs to
+ generate interrupts and kick the watchdog task every 10-12 seconds.
+ An NMI is generated every 60 seconds or so to check for hardlockups.
config BOOTPARAM_SOFTLOCKUP_PANIC
bool "Panic (Reboot) On Soft Lockups"
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-12 20:06 ` Frederic Weisbecker
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Touch_softlockup " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 3/8] [watchdog] remove old softlockup code Don Zickus
` (5 subsequent siblings)
7 siblings, 2 replies; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
Just some code cleanup to make touch_softlockup clearer and remove the
softlockup_tick function as it is no longer needed.
Also remove the /proc softlockup_thres call as it has been changed to
watchdog_thres.
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
include/linux/sched.h | 16 +++-------------
kernel/sysctl.c | 9 ---------
kernel/timer.c | 1 -
kernel/watchdog.c | 35 +++--------------------------------
4 files changed, 6 insertions(+), 55 deletions(-)
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2455ff5..e9c6c1d 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -308,18 +308,14 @@ extern void scheduler_tick(void);
extern void sched_show_task(struct task_struct *p);
#ifdef CONFIG_DETECT_SOFTLOCKUP
-extern void softlockup_tick(void);
extern void touch_softlockup_watchdog(void);
extern void touch_all_softlockup_watchdogs(void);
-extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos);
extern unsigned int softlockup_panic;
extern int softlockup_thresh;
+extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+ void __user *buffer,
+ size_t *lenp, loff_t *ppos);
#else
-static inline void softlockup_tick(void)
-{
-}
static inline void touch_softlockup_watchdog(void)
{
}
@@ -338,12 +334,6 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
size_t *lenp, loff_t *ppos);
#endif
-#ifdef CONFIG_LOCKUP_DETECTOR
-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")))
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 1083897..1fec781 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
.extra1 = &zero,
.extra2 = &one,
},
- {
- .procname = "softlockup_thresh",
- .data = &softlockup_thresh,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = proc_dosoftlockup_thresh,
- .extra1 = &neg_one,
- .extra2 = &sixty,
- },
#endif
#ifdef CONFIG_DETECT_HUNG_TASK
{
diff --git a/kernel/timer.c b/kernel/timer.c
index c61a794..80c8da5 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1223,7 +1223,6 @@ void run_local_timers(void)
{
hrtimer_run_queues();
raise_softirq(TIMER_SOFTIRQ);
- softlockup_tick();
}
/*
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 2684e95..03671b7 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -118,13 +118,12 @@ static void __touch_watchdog(void)
__get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);
}
-void touch_watchdog(void)
+void touch_softlockup_watchdog(void)
{
__get_cpu_var(watchdog_touch_ts) = 0;
}
-EXPORT_SYMBOL(touch_watchdog);
-void touch_all_watchdog(void)
+void touch_all_softlockup_watchdogs(void)
{
int cpu;
@@ -139,29 +138,10 @@ void touch_all_watchdog(void)
void touch_nmi_watchdog(void)
{
- touch_watchdog();
+ touch_softlockup_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();
-}
-
-void softlockup_tick(void)
-{
-}
-
#ifdef CONFIG_PERF_EVENTS_NMI
/* watchdog detector functions */
static int is_hardlockup(int cpu)
@@ -507,15 +487,6 @@ int proc_dowatchdog_thresh(struct ctl_table *table, int write,
{
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 */
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 3/8] [watchdog] remove old softlockup code
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
2010-05-07 21:11 ` [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Remove " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 4/8] [watchdog] remove nmi_watchdog.c file Don Zickus
` (4 subsequent siblings)
7 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
Now that is no longer compiled or used, just remove it.
Also moves some of the code wrapped with DETECT_SOFTLOCKUP to the
LOCKUP_DETECTOR wrappers because that is the code that uses it now.
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
kernel/softlockup.c | 278 ---------------------------------------------------
kernel/sysctl.c | 22 ++--
2 files changed, 10 insertions(+), 290 deletions(-)
delete mode 100644 kernel/softlockup.c
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
deleted file mode 100644
index d225790..0000000
--- a/kernel/softlockup.c
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * Detect Soft Lockups
- *
- * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
- *
- * this code detects soft lockups: incidents in where on a CPU
- * the kernel does not reschedule for 10 seconds or more.
- */
-#include <linux/mm.h>
-#include <linux/cpu.h>
-#include <linux/nmi.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/freezer.h>
-#include <linux/kthread.h>
-#include <linux/lockdep.h>
-#include <linux/notifier.h>
-#include <linux/module.h>
-#include <linux/sysctl.h>
-
-#include <asm/irq_regs.h>
-
-static DEFINE_SPINLOCK(print_lock);
-
-static DEFINE_PER_CPU(unsigned long, softlockup_touch_ts); /* touch timestamp */
-static DEFINE_PER_CPU(unsigned long, softlockup_print_ts); /* print timestamp */
-static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
-
-static int __read_mostly did_panic;
-int __read_mostly softlockup_thresh = 60;
-
-/*
- * Should we panic (and reboot, if panic_timeout= is set) when a
- * soft-lockup occurs:
- */
-unsigned int __read_mostly softlockup_panic =
- CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
-
-static int __init softlockup_panic_setup(char *str)
-{
- softlockup_panic = simple_strtoul(str, NULL, 0);
-
- return 1;
-}
-__setup("softlockup_panic=", softlockup_panic_setup);
-
-static int
-softlock_panic(struct notifier_block *this, unsigned long event, void *ptr)
-{
- did_panic = 1;
-
- return NOTIFY_DONE;
-}
-
-static struct notifier_block panic_block = {
- .notifier_call = softlock_panic,
-};
-
-/*
- * 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 void __touch_softlockup_watchdog(void)
-{
- int this_cpu = raw_smp_processor_id();
-
- __raw_get_cpu_var(softlockup_touch_ts) = get_timestamp(this_cpu);
-}
-
-void touch_softlockup_watchdog(void)
-{
- __raw_get_cpu_var(softlockup_touch_ts) = 0;
-}
-EXPORT_SYMBOL(touch_softlockup_watchdog);
-
-void touch_all_softlockup_watchdogs(void)
-{
- int cpu;
-
- /* Cause each CPU to re-update its timestamp rather than complain */
- for_each_online_cpu(cpu)
- per_cpu(softlockup_touch_ts, cpu) = 0;
-}
-EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
-
-int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
-{
- touch_all_softlockup_watchdogs();
- return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
-}
-
-/*
- * This callback runs from the timer interrupt, and checks
- * whether the watchdog thread has hung or not:
- */
-void softlockup_tick(void)
-{
- int this_cpu = smp_processor_id();
- unsigned long touch_ts = per_cpu(softlockup_touch_ts, this_cpu);
- unsigned long print_ts;
- struct pt_regs *regs = get_irq_regs();
- unsigned long now;
-
- /* Is detection switched off? */
- if (!per_cpu(softlockup_watchdog, this_cpu) || softlockup_thresh <= 0) {
- /* Be sure we don't false trigger if switched back on */
- if (touch_ts)
- per_cpu(softlockup_touch_ts, this_cpu) = 0;
- return;
- }
-
- if (touch_ts == 0) {
- __touch_softlockup_watchdog();
- return;
- }
-
- print_ts = per_cpu(softlockup_print_ts, this_cpu);
-
- /* report at most once a second */
- if (print_ts == touch_ts || did_panic)
- return;
-
- /* do not print during early bootup: */
- if (unlikely(system_state != SYSTEM_RUNNING)) {
- __touch_softlockup_watchdog();
- return;
- }
-
- now = get_timestamp(this_cpu);
-
- /*
- * Wake up the high-prio watchdog task twice per
- * threshold timespan.
- */
- if (now > touch_ts + softlockup_thresh/2)
- wake_up_process(per_cpu(softlockup_watchdog, this_cpu));
-
- /* Warn about unreasonable delays: */
- if (now <= (touch_ts + softlockup_thresh))
- return;
-
- per_cpu(softlockup_print_ts, this_cpu) = touch_ts;
-
- spin_lock(&print_lock);
- printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
- this_cpu, now - touch_ts,
- current->comm, task_pid_nr(current));
- print_modules();
- print_irqtrace_events(current);
- if (regs)
- show_regs(regs);
- else
- dump_stack();
- spin_unlock(&print_lock);
-
- if (softlockup_panic)
- panic("softlockup: hung tasks");
-}
-
-/*
- * The watchdog thread - runs every second and touches the timestamp.
- */
-static int watchdog(void *__bind_cpu)
-{
- struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
-
- sched_setscheduler(current, SCHED_FIFO, ¶m);
-
- /* initialize timestamp */
- __touch_softlockup_watchdog();
-
- 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_softlockup_watchdog();
- schedule();
-
- if (kthread_should_stop())
- break;
-
- set_current_state(TASK_INTERRUPTIBLE);
- }
- __set_current_state(TASK_RUNNING);
-
- return 0;
-}
-
-/*
- * 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;
- struct task_struct *p;
-
- switch (action) {
- case CPU_UP_PREPARE:
- case CPU_UP_PREPARE_FROZEN:
- BUG_ON(per_cpu(softlockup_watchdog, hotcpu));
- p = kthread_create(watchdog, hcpu, "watchdog/%d", hotcpu);
- if (IS_ERR(p)) {
- printk(KERN_ERR "watchdog for %i failed\n", hotcpu);
- return NOTIFY_BAD;
- }
- per_cpu(softlockup_touch_ts, hotcpu) = 0;
- per_cpu(softlockup_watchdog, hotcpu) = p;
- kthread_bind(p, hotcpu);
- break;
- case CPU_ONLINE:
- case CPU_ONLINE_FROZEN:
- wake_up_process(per_cpu(softlockup_watchdog, hotcpu));
- break;
-#ifdef CONFIG_HOTPLUG_CPU
- case CPU_UP_CANCELED:
- case CPU_UP_CANCELED_FROZEN:
- if (!per_cpu(softlockup_watchdog, hotcpu))
- break;
- /* Unbind so it can run. Fall thru. */
- kthread_bind(per_cpu(softlockup_watchdog, hotcpu),
- cpumask_any(cpu_online_mask));
- case CPU_DEAD:
- case CPU_DEAD_FROZEN:
- p = per_cpu(softlockup_watchdog, hotcpu);
- per_cpu(softlockup_watchdog, hotcpu) = NULL;
- kthread_stop(p);
- break;
-#endif /* CONFIG_HOTPLUG_CPU */
- }
- return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata cpu_nfb = {
- .notifier_call = cpu_callback
-};
-
-static int __initdata nosoftlockup;
-
-static int __init nosoftlockup_setup(char *str)
-{
- nosoftlockup = 1;
- return 1;
-}
-__setup("nosoftlockup", nosoftlockup_setup);
-
-static int __init spawn_softlockup_task(void)
-{
- void *cpu = (void *)(long)smp_processor_id();
- int err;
-
- if (nosoftlockup)
- return 0;
-
- err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
- if (err == NOTIFY_BAD) {
- BUG();
- 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_softlockup_task);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 1fec781..494e9a2 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -99,7 +99,7 @@ extern int blk_iopoll_enabled;
#endif
/* Constants used for minimum and maximum */
-#ifdef CONFIG_DETECT_SOFTLOCKUP
+#ifdef CONFIG_LOCKUP_DETECTOR
static int sixty = 60;
static int neg_one = -1;
#endif
@@ -713,6 +713,15 @@ static struct ctl_table kern_table[] = {
.extra1 = &neg_one,
.extra2 = &sixty,
},
+ {
+ .procname = "softlockup_panic",
+ .data = &softlockup_panic,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &zero,
+ .extra2 = &one,
+ },
#endif
#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
{
@@ -817,17 +826,6 @@ static struct ctl_table kern_table[] = {
.proc_handler = proc_dointvec,
},
#endif
-#ifdef CONFIG_DETECT_SOFTLOCKUP
- {
- .procname = "softlockup_panic",
- .data = &softlockup_panic,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = proc_dointvec_minmax,
- .extra1 = &zero,
- .extra2 = &one,
- },
-#endif
#ifdef CONFIG_DETECT_HUNG_TASK
{
.procname = "hung_task_panic",
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 4/8] [watchdog] remove nmi_watchdog.c file
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
` (2 preceding siblings ...)
2010-05-07 21:11 ` [PATCH 3/8] [watchdog] remove old softlockup code Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Remove " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier Don Zickus
` (3 subsequent siblings)
7 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
This file migrated to kernel/watchdog.c and then combined with
kernel/softlockup.c. As a result kernel/nmi_watchdog.c is no longer
needed. Just remove it.
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
kernel/nmi_watchdog.c | 259 -------------------------------------------------
1 files changed, 0 insertions(+), 259 deletions(-)
delete mode 100644 kernel/nmi_watchdog.c
diff --git a/kernel/nmi_watchdog.c b/kernel/nmi_watchdog.c
deleted file mode 100644
index a79d211..0000000
--- a/kernel/nmi_watchdog.c
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Detect Hard Lockups using the NMI
- *
- * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
- *
- * this code detects hard lockups: incidents in where on a CPU
- * the kernel does not respond to anything except NMI.
- *
- * Note: Most of this code is borrowed heavily from softlockup.c,
- * so thanks to Ingo for the initial implementation.
- * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
- * to those contributors as well.
- */
-
-#include <linux/mm.h>
-#include <linux/cpu.h>
-#include <linux/nmi.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/freezer.h>
-#include <linux/lockdep.h>
-#include <linux/notifier.h>
-#include <linux/module.h>
-#include <linux/sysctl.h>
-
-#include <asm/irq_regs.h>
-#include <linux/perf_event.h>
-
-static DEFINE_PER_CPU(struct perf_event *, nmi_watchdog_ev);
-static DEFINE_PER_CPU(int, nmi_watchdog_touch);
-static DEFINE_PER_CPU(long, alert_counter);
-
-static int panic_on_timeout;
-
-void touch_nmi_watchdog(void)
-{
- __raw_get_cpu_var(nmi_watchdog_touch) = 1;
- touch_softlockup_watchdog();
-}
-EXPORT_SYMBOL(touch_nmi_watchdog);
-
-void touch_all_nmi_watchdog(void)
-{
- int cpu;
-
- for_each_online_cpu(cpu)
- per_cpu(nmi_watchdog_touch, cpu) = 1;
- touch_softlockup_watchdog();
-}
-
-static int __init setup_nmi_watchdog(char *str)
-{
- if (!strncmp(str, "panic", 5)) {
- panic_on_timeout = 1;
- str = strchr(str, ',');
- if (!str)
- return 1;
- ++str;
- }
- return 1;
-}
-__setup("nmi_watchdog=", setup_nmi_watchdog);
-
-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,
-};
-
-void wd_overflow(struct perf_event *event, int nmi,
- struct perf_sample_data *data,
- struct pt_regs *regs)
-{
- int cpu = smp_processor_id();
- int touched = 0;
-
- if (__get_cpu_var(nmi_watchdog_touch)) {
- per_cpu(nmi_watchdog_touch, cpu) = 0;
- touched = 1;
- }
-
- /* check to see if the cpu is doing anything */
- if (!touched && hw_nmi_is_cpu_stuck(regs)) {
- /*
- * Ayiee, looks like this CPU is stuck ...
- * wait a few IRQs (5 seconds) before doing the oops ...
- */
- per_cpu(alert_counter, cpu) += 1;
- if (per_cpu(alert_counter, cpu) == 5) {
- if (panic_on_timeout)
- panic("NMI Watchdog detected LOCKUP on cpu %d", cpu);
- else
- WARN(1, "NMI Watchdog detected LOCKUP on cpu %d", cpu);
- }
- } else {
- per_cpu(alert_counter, cpu) = 0;
- }
-
- return;
-}
-
-static int enable_nmi_watchdog(int cpu)
-{
- struct perf_event *event;
- struct perf_event_attr *wd_attr;
-
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event && event->state > PERF_EVENT_STATE_OFF)
- return 0;
-
- if (event == NULL) {
- /* Try to register using hardware perf events first */
- wd_attr = &wd_hw_attr;
- wd_attr->sample_period = hw_nmi_get_sample_period();
- event = perf_event_create_kernel_counter(wd_attr, cpu, -1, wd_overflow);
- if (IS_ERR(event)) {
- /* hardware doesn't exist or not supported, fallback to software events */
- printk(KERN_INFO "nmi_watchdog: hardware not available, trying software events\n");
- wd_attr = &wd_sw_attr;
- wd_attr->sample_period = NSEC_PER_SEC;
- event = perf_event_create_kernel_counter(wd_attr, cpu, -1, wd_overflow);
- if (IS_ERR(event)) {
- printk(KERN_ERR "nmi watchdog failed to create perf event on %i: %p\n", cpu, event);
- return -1;
- }
- }
- per_cpu(nmi_watchdog_ev, cpu) = event;
- }
- perf_event_enable(per_cpu(nmi_watchdog_ev, cpu));
- return 0;
-}
-
-static void disable_nmi_watchdog(int cpu)
-{
- struct perf_event *event;
-
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event) {
- perf_event_disable(per_cpu(nmi_watchdog_ev, cpu));
- per_cpu(nmi_watchdog_ev, cpu) = NULL;
- perf_event_release_kernel(event);
- }
-}
-
-#ifdef CONFIG_SYSCTL
-/*
- * proc handler for /proc/sys/kernel/nmi_watchdog
- */
-int nmi_watchdog_enabled;
-
-int proc_nmi_enabled(struct ctl_table *table, int write,
- void __user *buffer, size_t *length, loff_t *ppos)
-{
- int cpu;
-
- if (!write) {
- struct perf_event *event;
- for_each_online_cpu(cpu) {
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event && event->state > PERF_EVENT_STATE_OFF) {
- nmi_watchdog_enabled = 1;
- break;
- }
- }
- proc_dointvec(table, write, buffer, length, ppos);
- return 0;
- }
-
- touch_all_nmi_watchdog();
- proc_dointvec(table, write, buffer, length, ppos);
- if (nmi_watchdog_enabled) {
- for_each_online_cpu(cpu)
- if (enable_nmi_watchdog(cpu)) {
- printk(KERN_ERR "NMI watchdog failed configuration, "
- " can not be enabled\n");
- }
- } else {
- for_each_online_cpu(cpu)
- disable_nmi_watchdog(cpu);
- }
- return 0;
-}
-
-#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:
- per_cpu(nmi_watchdog_touch, hotcpu) = 0;
- break;
- case CPU_ONLINE:
- case CPU_ONLINE_FROZEN:
- if (enable_nmi_watchdog(hotcpu))
- return NOTIFY_BAD;
- break;
-#ifdef CONFIG_HOTPLUG_CPU
- case CPU_UP_CANCELED:
- case CPU_UP_CANCELED_FROZEN:
- disable_nmi_watchdog(hotcpu);
- case CPU_DEAD:
- case CPU_DEAD_FROZEN:
- break;
-#endif /* CONFIG_HOTPLUG_CPU */
- }
- return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata cpu_nfb = {
- .notifier_call = cpu_callback
-};
-
-static int __initdata nonmi_watchdog;
-
-static int __init nonmi_watchdog_setup(char *str)
-{
- nonmi_watchdog = 1;
- return 1;
-}
-__setup("nonmi_watchdog", nonmi_watchdog_setup);
-
-static int __init spawn_nmi_watchdog_task(void)
-{
- void *cpu = (void *)(long)smp_processor_id();
- int err;
-
- if (nonmi_watchdog)
- return 0;
-
- printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
-
- err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
- if (err == NOTIFY_BAD) {
- BUG();
- return 1;
- }
- cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
- register_cpu_notifier(&cpu_nfb);
-
- return 0;
-}
-early_initcall(spawn_nmi_watchdog_task);
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
` (3 preceding siblings ...)
2010-05-07 21:11 ` [PATCH 4/8] [watchdog] remove nmi_watchdog.c file Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] x86: Move " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 6/8] [x86] watchdog: cleanup hw_nmi.c cruft Don Zickus
` (2 subsequent siblings)
7 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
As part of the transition of the nmi watchdog to something more generic,
the trigger_all_cpu_backtrace code is getting left behind. Put it in its
own die_notifier so it can still be used.
V2:
- use arch_spin_locks
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
arch/x86/kernel/apic/hw_nmi.c | 65 ++++++++++++++++++++++++++++++++---------
1 files changed, 51 insertions(+), 14 deletions(-)
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index 79425f9..8c3edfb 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -17,6 +17,10 @@
#include <linux/cpumask.h>
#include <linux/kernel_stat.h>
#include <asm/mce.h>
+#include <linux/kdebug.h>
+#include <linux/notifier.h>
+#include <linux/kprobes.h>
+
#include <linux/nmi.h>
#include <linux/module.h>
@@ -54,20 +58,6 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
unsigned int sum;
int cpu = smp_processor_id();
- /* FIXME: cheap hack for this check, probably should get its own
- * die_notifier handler
- */
- if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
- static DEFINE_SPINLOCK(lock); /* Serialise the printks */
-
- spin_lock(&lock);
- printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
- show_regs(regs);
- dump_stack();
- spin_unlock(&lock);
- cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
- }
-
/* if we are doing an mce, just assume the cpu is not stuck */
/* Could check oops_in_progress here too, but it's safer not to */
if (mce_in_progress())
@@ -109,6 +99,53 @@ void arch_trigger_all_cpu_backtrace(void)
mdelay(1);
}
}
+
+static int __kprobes
+arch_trigger_all_cpu_backtrace_handler(struct notifier_block *self,
+ unsigned long cmd, void *__args)
+{
+ struct die_args *args = __args;
+ struct pt_regs *regs;
+ int cpu = smp_processor_id();
+
+ switch (cmd) {
+ case DIE_NMI:
+ case DIE_NMI_IPI:
+ break;
+
+ default:
+ return NOTIFY_DONE;
+ }
+
+ regs = args->regs;
+
+ if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
+ static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED;
+
+ arch_spin_lock(&lock);
+ printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
+ show_regs(regs);
+ dump_stack();
+ arch_spin_unlock(&lock);
+ cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
+ return NOTIFY_STOP;
+ }
+
+ return NOTIFY_DONE;
+}
+
+static __read_mostly struct notifier_block backtrace_notifier = {
+ .notifier_call = arch_trigger_all_cpu_backtrace_handler,
+ .next = NULL,
+ .priority = 1
+};
+
+static int __init register_trigger_all_cpu_backtrace(void)
+{
+ register_die_notifier(&backtrace_notifier);
+ return 0;
+}
+early_initcall(register_trigger_all_cpu_backtrace);
#endif
/* STUB calls to mimic old nmi_watchdog behaviour */
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 6/8] [x86] watchdog: cleanup hw_nmi.c cruft
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
` (4 preceding siblings ...)
2010-05-07 21:11 ` [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] x86: Cleanup " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 7/8] [watchdog] resolve softlockup.c conflicts Don Zickus
2010-05-07 21:11 ` [PATCH 8/8] [watchdog] separate touch_nmi_watchdog code path from touch_watchdog Don Zickus
7 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
The design of the hardlockup watchdog has changed and cruft was left
behind in the hw_nmi.c file. Just remove the code that isn't used
anymore.
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
arch/x86/kernel/apic/hw_nmi.c | 58 -----------------------------------------
1 files changed, 0 insertions(+), 58 deletions(-)
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index 8c3edfb..3b40082 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -9,74 +9,16 @@
*
*/
-#include <asm/apic.h>
-#include <linux/smp.h>
#include <linux/cpumask.h>
-#include <linux/sched.h>
-#include <linux/percpu.h>
-#include <linux/cpumask.h>
-#include <linux/kernel_stat.h>
-#include <asm/mce.h>
#include <linux/kdebug.h>
#include <linux/notifier.h>
#include <linux/kprobes.h>
-
-
#include <linux/nmi.h>
#include <linux/module.h>
/* For reliability, we're prepared to waste bits here. */
static DECLARE_BITMAP(backtrace_mask, NR_CPUS) __read_mostly;
-static DEFINE_PER_CPU(unsigned, last_irq_sum);
-
-/*
- * Take the local apic timer and PIT/HPET into account. We don't
- * know which one is active, when we have highres/dyntick on
- */
-static inline unsigned int get_timer_irqs(int cpu)
-{
- unsigned int irqs = per_cpu(irq_stat, cpu).irq0_irqs;
-
-#if defined(CONFIG_X86_LOCAL_APIC)
- irqs += per_cpu(irq_stat, cpu).apic_timer_irqs;
-#endif
-
- return irqs;
-}
-
-static inline int mce_in_progress(void)
-{
-#if defined(CONFIG_X86_MCE)
- return atomic_read(&mce_entry) > 0;
-#endif
- return 0;
-}
-
-int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
-{
- unsigned int sum;
- int cpu = smp_processor_id();
-
- /* if we are doing an mce, just assume the cpu is not stuck */
- /* Could check oops_in_progress here too, but it's safer not to */
- if (mce_in_progress())
- return 0;
-
- /* We determine if the cpu is stuck by checking whether any
- * interrupts have happened since we last checked. Of course
- * an nmi storm could create false positives, but the higher
- * level logic should account for that
- */
- sum = get_timer_irqs(cpu);
- if (__get_cpu_var(last_irq_sum) == sum) {
- return 1;
- } else {
- __get_cpu_var(last_irq_sum) = sum;
- return 0;
- }
-}
-
u64 hw_nmi_get_sample_period(void)
{
return (u64)(cpu_khz) * 1000 * 60;
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 7/8] [watchdog] resolve softlockup.c conflicts
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
` (5 preceding siblings ...)
2010-05-07 21:11 ` [PATCH 6/8] [x86] watchdog: cleanup hw_nmi.c cruft Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-07 21:11 ` [PATCH 8/8] [watchdog] separate touch_nmi_watchdog code path from touch_watchdog Don Zickus
7 siblings, 0 replies; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
My changes with the softlockup code uses an older version of softlockup.c.
A couple of commits have been committed that were not on the branch I am
using. This patch resolves those conflicts.
Commit 8c2eb4 softlockup: Stop spurious softlockup messages due to overflow
d6ad3e softlockup: Add sched_clock_tick() to avoid kernel warning on kgdb resume
Conflicts:
include/linux/sched.h
kernel/kgdb.c
kernel/softlockup.c
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
include/linux/sched.h | 4 ++++
kernel/kgdb.c | 6 +++---
kernel/watchdog.c | 17 ++++++++++++++++-
3 files changed, 23 insertions(+), 4 deletions(-)
diff --git a/include/linux/sched.h b/include/linux/sched.h
index e9c6c1d..720e7e9 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -310,6 +310,7 @@ extern void sched_show_task(struct task_struct *p);
#ifdef CONFIG_DETECT_SOFTLOCKUP
extern void touch_softlockup_watchdog(void);
extern void touch_all_softlockup_watchdogs(void);
+extern void touch_softlockup_watchdog_sync(void);
extern unsigned int softlockup_panic;
extern int softlockup_thresh;
extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
@@ -322,6 +323,9 @@ static inline void touch_softlockup_watchdog(void)
static inline void touch_all_softlockup_watchdogs(void)
{
}
+static inline void touch_softlockup_watchdog_sync(void)
+{
+}
#endif
#ifdef CONFIG_DETECT_HUNG_TASK
diff --git a/kernel/kgdb.c b/kernel/kgdb.c
index 2eb517e..87f2cc5 100644
--- a/kernel/kgdb.c
+++ b/kernel/kgdb.c
@@ -596,7 +596,7 @@ static void kgdb_wait(struct pt_regs *regs)
/* Signal the primary CPU that we are done: */
atomic_set(&cpu_in_kgdb[cpu], 0);
- touch_softlockup_watchdog();
+ touch_softlockup_watchdog_sync();
clocksource_touch_watchdog();
local_irq_restore(flags);
}
@@ -1450,7 +1450,7 @@ acquirelock:
(kgdb_info[cpu].task &&
kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
atomic_set(&kgdb_active, -1);
- touch_softlockup_watchdog();
+ touch_softlockup_watchdog_sync();
clocksource_touch_watchdog();
local_irq_restore(flags);
@@ -1550,7 +1550,7 @@ kgdb_restore:
}
/* Free kgdb_active */
atomic_set(&kgdb_active, -1);
- touch_softlockup_watchdog();
+ touch_softlockup_watchdog_sync();
clocksource_touch_watchdog();
local_irq_restore(flags);
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 03671b7..80a282c 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -33,6 +33,7 @@ int __read_mostly softlockup_thresh = 60;
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
+static DEFINE_PER_CPU(bool, softlockup_touch_sync);
static DEFINE_PER_CPU(bool, hard_watchdog_warn);
static DEFINE_PER_CPU(bool, soft_watchdog_warn);
#ifdef CONFIG_PERF_EVENTS_NMI
@@ -136,6 +137,12 @@ void touch_all_softlockup_watchdogs(void)
per_cpu(watchdog_touch_ts, cpu) = 0;
}
+void touch_softlockup_watchdog_sync(void)
+{
+ __raw_get_cpu_var(softlockup_touch_sync) = true;
+ __raw_get_cpu_var(watchdog_touch_ts) = 0;
+}
+
void touch_nmi_watchdog(void)
{
touch_softlockup_watchdog();
@@ -161,7 +168,7 @@ 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))
+ if (time_after(now, touch_ts + softlockup_thresh))
return now - touch_ts;
return 0;
@@ -250,6 +257,14 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
if (touch_ts == 0) {
+ if (unlikely(per_cpu(softlockup_touch_sync, this_cpu))) {
+ /*
+ * If the time stamp was touched atomically
+ * make sure the scheduler tick is up to date.
+ */
+ per_cpu(softlockup_touch_sync, this_cpu) = false;
+ sched_clock_tick();
+ }
__touch_watchdog();
return HRTIMER_RESTART;
}
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 8/8] [watchdog] separate touch_nmi_watchdog code path from touch_watchdog
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
` (6 preceding siblings ...)
2010-05-07 21:11 ` [PATCH 7/8] [watchdog] resolve softlockup.c conflicts Don Zickus
@ 2010-05-07 21:11 ` Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] lockup_detector: Separate " tip-bot for Don Zickus
7 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-07 21:11 UTC (permalink / raw
To: mingo, fweisbec
Cc: peterz, gorcunov, aris, linux-kernel, randy.dunlap, dzickus
When I combined the nmi_watchdog (hardlockup) and softlockup code, I
also combined the paths the touch_watchdog and touch_nmi_watchdog took.
This may not be the best idea as pointed out by Frederic W., that the
touch_watchdog case probably should not reset the hardlockup count.
Therefore the patch belows falls back to the previous idea of keeping
the touch_nmi_watchdog a superset of the touch_watchdog case.
Signed-off-by: Don Zickus <dzickus@redhat.com>
---
kernel/watchdog.c | 7 ++++---
1 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 80a282c..09fb804 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -31,6 +31,7 @@ int watchdog_enabled;
int __read_mostly softlockup_thresh = 60;
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
+static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
static DEFINE_PER_CPU(bool, softlockup_touch_sync);
@@ -145,6 +146,7 @@ void touch_softlockup_watchdog_sync(void)
void touch_nmi_watchdog(void)
{
+ __get_cpu_var(watchdog_nmi_touch) = true;
touch_softlockup_watchdog();
}
EXPORT_SYMBOL(touch_nmi_watchdog);
@@ -201,10 +203,9 @@ void watchdog_overflow_callback(struct perf_event *event, int nmi,
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();
+ if (__get_cpu_var(watchdog_nmi_touch) == true) {
+ __get_cpu_var(watchdog_nmi_touch) = false;
return;
}
--
1.7.0.1
^ permalink raw reply related [flat|nested] 27+ messages in thread
* Re: [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
@ 2010-05-12 19:55 ` Frederic Weisbecker
2010-05-13 6:51 ` [tip:perf/nmi] lockup_detector: Combine nmi_watchdog and softlockup detector tip-bot for Don Zickus
1 sibling, 0 replies; 27+ messages in thread
From: Frederic Weisbecker @ 2010-05-12 19:55 UTC (permalink / raw
To: Don Zickus; +Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Fri, May 07, 2010 at 05:11:44PM -0400, Don Zickus wrote:
> 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
>
> V3:
> - comment cleanups
> - drop support for older softlockup code
> - per_cpu cleanups
> - completely remove software clock base hardlockup detector
> - use per_cpu masking on hard/soft lockup detection
> - #ifdef cleanups
> - rename config option NMI_WATCHDOG to LOCKUP_DETECTOR
> - documentation additions
>
> V4:
> - documentation fixes
> - convert per_cpu to __get_cpu_var
> - powerpc compile fixes
>
> V5:
> - split apart warn flags for hard and soft lockups
>
> TODO:
> - figure out how to make an arch-agnostic clock2cycles call (if possible)
> to feed into perf events as a sample period
>
> Signed-off-by: Don Zickus <dzickus@redhat.com>
> ---
> Documentation/kernel-parameters.txt | 2 +
> arch/x86/include/asm/nmi.h | 2 +-
> arch/x86/kernel/apic/Makefile | 4 +-
> arch/x86/kernel/apic/hw_nmi.c | 2 +-
> arch/x86/kernel/traps.c | 4 +-
> include/linux/nmi.h | 8 +-
> include/linux/sched.h | 6 +
> init/Kconfig | 5 +-
> kernel/Makefile | 3 +-
> kernel/sysctl.c | 21 +-
> kernel/watchdog.c | 577 +++++++++++++++++++++++++++++++++++
> lib/Kconfig.debug | 30 ++-
> 12 files changed, 635 insertions(+), 29 deletions(-)
> create mode 100644 kernel/watchdog.c
>
> diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
> index 736d456..705f16f 100644
> --- a/Documentation/kernel-parameters.txt
> +++ b/Documentation/kernel-parameters.txt
> @@ -1764,6 +1764,8 @@ and is between 256 and 4096 characters. It is defined in the file
>
> nousb [USB] Disable the USB subsystem
>
> + nowatchdog [KNL] Disable the lockup detector.
> +
> nowb [ARM]
>
> nox2apic [X86-64,APIC] Do not enable x2APIC mode.
> diff --git a/arch/x86/include/asm/nmi.h b/arch/x86/include/asm/nmi.h
> index 5b41b0f..932f0f8 100644
> --- a/arch/x86/include/asm/nmi.h
> +++ b/arch/x86/include/asm/nmi.h
> @@ -17,7 +17,7 @@ int do_nmi_callback(struct pt_regs *regs, int cpu);
>
> extern void die_nmi(char *str, struct pt_regs *regs, int do_panic);
> extern int check_nmi_watchdog(void);
> -#if !defined(CONFIG_NMI_WATCHDOG)
> +#if !defined(CONFIG_LOCKUP_DETECTOR)
> extern int nmi_watchdog_enabled;
> #endif
> extern int avail_to_resrv_perfctr_nmi_bit(unsigned int);
> diff --git a/arch/x86/kernel/apic/Makefile b/arch/x86/kernel/apic/Makefile
> index 1a4512e..52f32e0 100644
> --- a/arch/x86/kernel/apic/Makefile
> +++ b/arch/x86/kernel/apic/Makefile
> @@ -3,10 +3,10 @@
> #
>
> obj-$(CONFIG_X86_LOCAL_APIC) += apic.o apic_noop.o probe_$(BITS).o ipi.o
> -ifneq ($(CONFIG_NMI_WATCHDOG),y)
> +ifneq ($(CONFIG_LOCKUP_DETECTOR),y)
> obj-$(CONFIG_X86_LOCAL_APIC) += nmi.o
> endif
> -obj-$(CONFIG_NMI_WATCHDOG) += hw_nmi.o
> +obj-$(CONFIG_LOCKUP_DETECTOR) += hw_nmi.o
>
> obj-$(CONFIG_X86_IO_APIC) += io_apic.o
> obj-$(CONFIG_SMP) += ipi.o
> diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
> index e8b78a0..79425f9 100644
> --- a/arch/x86/kernel/apic/hw_nmi.c
> +++ b/arch/x86/kernel/apic/hw_nmi.c
> @@ -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
> diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
> index bdc7fab..bd347c2 100644
> --- a/arch/x86/kernel/traps.c
> +++ b/arch/x86/kernel/traps.c
> @@ -406,7 +406,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
> == NOTIFY_STOP)
> return;
>
> -#ifndef CONFIG_NMI_WATCHDOG
> +#ifndef CONFIG_LOCKUP_DETECTOR
> /*
> * Ok, so this is none of the documented NMI sources,
> * so it must be the NMI watchdog.
> @@ -414,7 +414,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
> if (nmi_watchdog_tick(regs, reason))
> return;
> if (!do_nmi_callback(regs, cpu))
> -#endif /* !CONFIG_NMI_WATCHDOG */
> +#endif /* !CONFIG_LOCKUP_DETECTOR */
> unknown_nmi_error(reason, regs);
> #else
> unknown_nmi_error(reason, regs);
> diff --git a/include/linux/nmi.h b/include/linux/nmi.h
> index 22cc796..abd48aa 100644
> --- a/include/linux/nmi.h
> +++ b/include/linux/nmi.h
> @@ -20,7 +20,7 @@ extern void touch_nmi_watchdog(void);
> extern void acpi_nmi_disable(void);
> extern void acpi_nmi_enable(void);
> #else
> -#ifndef CONFIG_NMI_WATCHDOG
> +#ifndef CONFIG_LOCKUP_DETECTOR
> static inline void touch_nmi_watchdog(void)
> {
> touch_softlockup_watchdog();
> @@ -51,12 +51,12 @@ static inline bool trigger_all_cpu_backtrace(void)
> }
> #endif
>
> -#ifdef CONFIG_NMI_WATCHDOG
> +#ifdef CONFIG_LOCKUP_DETECTOR
> int hw_nmi_is_cpu_stuck(struct pt_regs *);
> u64 hw_nmi_get_sample_period(void);
> -extern int nmi_watchdog_enabled;
> +extern int watchdog_enabled;
> struct ctl_table;
> -extern int proc_nmi_enabled(struct ctl_table *, int ,
> +extern int proc_dowatchdog_enabled(struct ctl_table *, int ,
> void __user *, size_t *, loff_t *);
> #endif
>
> diff --git a/include/linux/sched.h b/include/linux/sched.h
> index 6f7bba9..2455ff5 100644
> --- a/include/linux/sched.h
> +++ b/include/linux/sched.h
> @@ -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_LOCKUP_DETECTOR
> +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")))
>
> diff --git a/init/Kconfig b/init/Kconfig
> index 7331a16..c5ce8b7 100644
> --- a/init/Kconfig
> +++ b/init/Kconfig
> @@ -948,8 +948,11 @@ config PERF_USE_VMALLOC
>
> config PERF_EVENTS_NMI
> bool
> + depends on PERF_EVENTS
> help
> - Arch has support for nmi_watchdog
> + System hardware can generate an NMI using the perf event
> + subsystem. Also has support for calculating CPU cycle events
> + to determine how many clock cycles in a given period.
>
> menu "Kernel Performance Events And Counters"
>
> diff --git a/kernel/Makefile b/kernel/Makefile
> index 8a5abe5..cc3acb3 100644
> --- a/kernel/Makefile
> +++ b/kernel/Makefile
> @@ -75,9 +75,8 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
> obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
> obj-$(CONFIG_KPROBES) += kprobes.o
> obj-$(CONFIG_KGDB) += kgdb.o
> -obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
> -obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
> obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
> +obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
> obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
> obj-$(CONFIG_SECCOMP) += seccomp.o
> obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
> diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> index ac72c9e..1083897 100644
> --- a/kernel/sysctl.c
> +++ b/kernel/sysctl.c
> @@ -60,7 +60,7 @@
> #include <asm/io.h>
> #endif
>
> -#ifdef CONFIG_NMI_WATCHDOG
> +#ifdef CONFIG_LOCKUP_DETECTOR
> #include <linux/nmi.h>
> #endif
>
> @@ -696,16 +696,25 @@ static struct ctl_table kern_table[] = {
> .mode = 0444,
> .proc_handler = proc_dointvec,
> },
> -#if defined(CONFIG_NMI_WATCHDOG)
> +#if defined(CONFIG_LOCKUP_DETECTOR)
> {
> - .procname = "nmi_watchdog",
> - .data = &nmi_watchdog_enabled,
> + .procname = "watchdog",
> + .data = &watchdog_enabled,
I suspect this could break some userspace apps that rely on
this sysctl option.
May be you should keep the nmi_watchdog around and schedule its
removal for later in the feature_removal_schedule.txt file.
> .maxlen = sizeof (int),
> .mode = 0644,
> - .proc_handler = proc_nmi_enabled,
> + .proc_handler = proc_dowatchdog_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)
> +#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
> {
> .procname = "unknown_nmi_panic",
> .data = &unknown_nmi_panic,
> diff --git a/kernel/watchdog.c b/kernel/watchdog.c
> new file mode 100644
> index 0000000..2684e95
> --- /dev/null
> +++ b/kernel/watchdog.c
> @@ -0,0 +1,577 @@
> +/*
> + * Detect hard and soft lockups on a system
> + *
> + * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
> + *
> + * this code detects hard lockups: incidents in where on a CPU
> + * the kernel does not respond to anything except NMI.
> + *
> + * Note: Most of this code is borrowed heavily from softlockup.c,
> + * so thanks to Ingo for the initial implementation.
> + * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
> + * to those contributors as well.
> + */
> +
> +#include <linux/mm.h>
> +#include <linux/cpu.h>
> +#include <linux/nmi.h>
> +#include <linux/init.h>
> +#include <linux/delay.h>
> +#include <linux/freezer.h>
> +#include <linux/kthread.h>
> +#include <linux/lockdep.h>
> +#include <linux/notifier.h>
> +#include <linux/module.h>
> +#include <linux/sysctl.h>
> +
> +#include <asm/irq_regs.h>
> +#include <linux/perf_event.h>
> +
> +int watchdog_enabled;
> +int __read_mostly softlockup_thresh = 60;
> +
> +static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
> +static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
> +static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
> +static DEFINE_PER_CPU(bool, hard_watchdog_warn);
This one should be under CONFIG_PERF_EVENTS_NMI
> +static DEFINE_PER_CPU(bool, soft_watchdog_warn);
> +#ifdef CONFIG_PERF_EVENTS_NMI
> +static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
> +static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
> +static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
> +#endif
> +
> +static int __read_mostly did_panic;
> +static int __initdata no_watchdog;
> +
> +
> +/* boot commands */
> +/*
> + * Should we panic when a soft-lockup or hard-lockup occurs:
> + */
> +#ifdef CONFIG_PERF_EVENTS_NMI
> +static int hardlockup_panic;
> +
> +static int __init hardlockup_panic_setup(char *str)
> +{
> + if (!strncmp(str, "panic", 5))
> + hardlockup_panic = 1;
> + return 1;
> +}
> +__setup("nmi_watchdog=", hardlockup_panic_setup);
If nmi_watchdog=0, this won't deactivate anymore the hardlockup
detector.
> +#endif
> +
> +unsigned int __read_mostly softlockup_panic =
> + CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
> +
> +static int __init softlockup_panic_setup(char *str)
> +{
> + softlockup_panic = simple_strtoul(str, NULL, 0);
> +
> + return 1;
> +}
> +__setup("softlockup_panic=", softlockup_panic_setup);
> +
> +static int __init nowatchdog_setup(char *str)
> +{
> + no_watchdog = 1;
> + return 1;
> +}
> +__setup("nowatchdog", nowatchdog_setup);
> +
> +/* deprecated */
> +static int __init nosoftlockup_setup(char *str)
> +{
> + no_watchdog = 1;
> + return 1;
> +}
> +__setup("nosoftlockup", nosoftlockup_setup);
> +/* */
> +
> +
> +/*
> + * 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)
> +{
> + int this_cpu = raw_smp_processor_id();
This must use smp_processor_id() for preemption disabled
checks.
> +
> + __get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);
> +}
> +
> +void touch_watchdog(void)
> +{
> + __get_cpu_var(watchdog_touch_ts) = 0;
> +}
> +EXPORT_SYMBOL(touch_watchdog);
> +
> +void touch_all_watchdog(void)
> +{
> + int cpu;
> +
> + /*
> + * this is done lockless
> + * do we care if a 0 races with a timestamp?
> + * all it means is the softlock check starts one cycle later
> + */
> + for_each_online_cpu(cpu)
> + per_cpu(watchdog_touch_ts, cpu) = 0;
> +}
> +
> +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();
> +}
> +
> +void softlockup_tick(void)
> +{
> +}
> +
> +#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;
All these per_cpu() should be __this_cpu_var() for readability,
for the preemption disabled safety check, and may be even
for optimization reasons: if an arch defines its own __my_cpu_offset,
it may get it faster.
> +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
> +static 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,
> +};
> +
> +/* 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);
same here
> +
> + 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 (__get_cpu_var(hard_watchdog_warn) == true)
> + 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);
> +
> + __get_cpu_var(hard_watchdog_warn) = true;
> + return;
> + }
> +
> + __get_cpu_var(hard_watchdog_warn) = false;
> + return;
> +}
> +static void watchdog_interrupt_count(void)
> +{
> + __get_cpu_var(hrtimer_interrupts)++;
> +}
> +#else
> +static inline void watchdog_interrupt_count(void) { return; }
> +#endif /* CONFIG_PERF_EVENTS_NMI */
> +
> +/* watchdog kicker functions */
> +static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
> +{
> + int this_cpu = smp_processor_id();
> + unsigned long touch_ts = __get_cpu_var(watchdog_touch_ts);
> + struct pt_regs *regs = get_irq_regs();
> + int duration;
> +
> + /* kick the hardlockup detector */
> + watchdog_interrupt_count();
> +
> + /* 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 (unlikely(duration)) {
> + /* only warn once */
> + if (__get_cpu_var(soft_watchdog_warn) == true)
> + return HRTIMER_RESTART;
> +
> + 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();
> +
> + if (softlockup_panic)
> + panic("softlockup: hung tasks");
> + __get_cpu_var(soft_watchdog_warn) = true;
> + } else
> + __get_cpu_var(soft_watchdog_warn) = false;
> +
> + 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);
This is bound to a single cpu already: __raw_get_cpu_var() (because we don't
need the preempt disabled check here).
Thanks.
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-07 21:11 ` [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal Don Zickus
@ 2010-05-12 20:06 ` Frederic Weisbecker
2010-05-12 20:26 ` Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Touch_softlockup " tip-bot for Don Zickus
1 sibling, 1 reply; 27+ messages in thread
From: Frederic Weisbecker @ 2010-05-12 20:06 UTC (permalink / raw
To: Don Zickus; +Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Fri, May 07, 2010 at 05:11:45PM -0400, Don Zickus wrote:
> Just some code cleanup to make touch_softlockup clearer and remove the
> softlockup_tick function as it is no longer needed.
>
> Also remove the /proc softlockup_thres call as it has been changed to
> watchdog_thres.
>
> Signed-off-by: Don Zickus <dzickus@redhat.com>
> ---
> include/linux/sched.h | 16 +++-------------
> kernel/sysctl.c | 9 ---------
> kernel/timer.c | 1 -
> kernel/watchdog.c | 35 +++--------------------------------
> 4 files changed, 6 insertions(+), 55 deletions(-)
>
> diff --git a/include/linux/sched.h b/include/linux/sched.h
> index 2455ff5..e9c6c1d 100644
> --- a/include/linux/sched.h
> +++ b/include/linux/sched.h
> @@ -308,18 +308,14 @@ extern void scheduler_tick(void);
> extern void sched_show_task(struct task_struct *p);
>
> #ifdef CONFIG_DETECT_SOFTLOCKUP
> -extern void softlockup_tick(void);
> extern void touch_softlockup_watchdog(void);
> extern void touch_all_softlockup_watchdogs(void);
> -extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
> - void __user *buffer,
> - size_t *lenp, loff_t *ppos);
> extern unsigned int softlockup_panic;
> extern int softlockup_thresh;
> +extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
> + void __user *buffer,
> + size_t *lenp, loff_t *ppos);
> #else
> -static inline void softlockup_tick(void)
> -{
> -}
> static inline void touch_softlockup_watchdog(void)
> {
> }
> @@ -338,12 +334,6 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
> size_t *lenp, loff_t *ppos);
> #endif
>
> -#ifdef CONFIG_LOCKUP_DETECTOR
> -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")))
>
> diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> index 1083897..1fec781 100644
> --- a/kernel/sysctl.c
> +++ b/kernel/sysctl.c
> @@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
> .extra1 = &zero,
> .extra2 = &one,
> },
> - {
> - .procname = "softlockup_thresh",
> - .data = &softlockup_thresh,
> - .maxlen = sizeof(int),
> - .mode = 0644,
> - .proc_handler = proc_dosoftlockup_thresh,
> - .extra1 = &neg_one,
> - .extra2 = &sixty,
> - },
I wonder about the ABI breakage.
But I suspect few userspace tools use it though, since this is
mostly for kernel dev.
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 20:06 ` Frederic Weisbecker
@ 2010-05-12 20:26 ` Don Zickus
2010-05-12 20:28 ` Frederic Weisbecker
0 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-12 20:26 UTC (permalink / raw
To: Frederic Weisbecker
Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Wed, May 12, 2010 at 10:06:54PM +0200, Frederic Weisbecker wrote:
> > diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> > index 1083897..1fec781 100644
> > --- a/kernel/sysctl.c
> > +++ b/kernel/sysctl.c
> > @@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
> > .extra1 = &zero,
> > .extra2 = &one,
> > },
> > - {
> > - .procname = "softlockup_thresh",
> > - .data = &softlockup_thresh,
> > - .maxlen = sizeof(int),
> > - .mode = 0644,
> > - .proc_handler = proc_dosoftlockup_thresh,
> > - .extra1 = &neg_one,
> > - .extra2 = &sixty,
> > - },
>
>
>
> I wonder about the ABI breakage.
>
> But I suspect few userspace tools use it though, since this is
> mostly for kernel dev.
There is no breakage, this chunk of code was duplicated later in the file.
I am just removing the duplicated bits to simplify the SOFTLOCKUP Kconfig
stuff.
Cheers,
Don
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 20:26 ` Don Zickus
@ 2010-05-12 20:28 ` Frederic Weisbecker
2010-05-12 20:56 ` Don Zickus
0 siblings, 1 reply; 27+ messages in thread
From: Frederic Weisbecker @ 2010-05-12 20:28 UTC (permalink / raw
To: Don Zickus; +Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Wed, May 12, 2010 at 04:26:28PM -0400, Don Zickus wrote:
> On Wed, May 12, 2010 at 10:06:54PM +0200, Frederic Weisbecker wrote:
> > > diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> > > index 1083897..1fec781 100644
> > > --- a/kernel/sysctl.c
> > > +++ b/kernel/sysctl.c
> > > @@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
> > > .extra1 = &zero,
> > > .extra2 = &one,
> > > },
> > > - {
> > > - .procname = "softlockup_thresh",
> > > - .data = &softlockup_thresh,
> > > - .maxlen = sizeof(int),
> > > - .mode = 0644,
> > > - .proc_handler = proc_dosoftlockup_thresh,
> > > - .extra1 = &neg_one,
> > > - .extra2 = &sixty,
> > > - },
> >
> >
> >
> > I wonder about the ABI breakage.
> >
> > But I suspect few userspace tools use it though, since this is
> > mostly for kernel dev.
>
> There is no breakage, this chunk of code was duplicated later in the file.
> I am just removing the duplicated bits to simplify the SOFTLOCKUP Kconfig
> stuff.
>
> Cheers,
> Don
Ah right.
BTW, if you address my reviews, please do it incrementally, I'm going
to apply this set and push it to Ingo.
Thanks.
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 20:28 ` Frederic Weisbecker
@ 2010-05-12 20:56 ` Don Zickus
2010-05-12 21:00 ` Frederic Weisbecker
0 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-12 20:56 UTC (permalink / raw
To: Frederic Weisbecker
Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Wed, May 12, 2010 at 10:28:35PM +0200, Frederic Weisbecker wrote:
> On Wed, May 12, 2010 at 04:26:28PM -0400, Don Zickus wrote:
> > On Wed, May 12, 2010 at 10:06:54PM +0200, Frederic Weisbecker wrote:
> > > > diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> > > > index 1083897..1fec781 100644
> > > > --- a/kernel/sysctl.c
> > > > +++ b/kernel/sysctl.c
> > > > @@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
> > > > .extra1 = &zero,
> > > > .extra2 = &one,
> > > > },
> > > > - {
> > > > - .procname = "softlockup_thresh",
> > > > - .data = &softlockup_thresh,
> > > > - .maxlen = sizeof(int),
> > > > - .mode = 0644,
> > > > - .proc_handler = proc_dosoftlockup_thresh,
> > > > - .extra1 = &neg_one,
> > > > - .extra2 = &sixty,
> > > > - },
> > >
> > >
> > >
> > > I wonder about the ABI breakage.
> > >
> > > But I suspect few userspace tools use it though, since this is
> > > mostly for kernel dev.
> >
> > There is no breakage, this chunk of code was duplicated later in the file.
> > I am just removing the duplicated bits to simplify the SOFTLOCKUP Kconfig
> > stuff.
> >
> > Cheers,
> > Don
>
>
> Ah right.
>
> BTW, if you address my reviews, please do it incrementally, I'm going
> to apply this set and push it to Ingo.
Ok, probably easier to review too. :-)
Cheers,
Don
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 20:56 ` Don Zickus
@ 2010-05-12 21:00 ` Frederic Weisbecker
2010-05-12 21:38 ` Cyrill Gorcunov
0 siblings, 1 reply; 27+ messages in thread
From: Frederic Weisbecker @ 2010-05-12 21:00 UTC (permalink / raw
To: Don Zickus; +Cc: mingo, peterz, gorcunov, aris, linux-kernel, randy.dunlap
On Wed, May 12, 2010 at 04:56:16PM -0400, Don Zickus wrote:
> On Wed, May 12, 2010 at 10:28:35PM +0200, Frederic Weisbecker wrote:
> > On Wed, May 12, 2010 at 04:26:28PM -0400, Don Zickus wrote:
> > > On Wed, May 12, 2010 at 10:06:54PM +0200, Frederic Weisbecker wrote:
> > > > > diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> > > > > index 1083897..1fec781 100644
> > > > > --- a/kernel/sysctl.c
> > > > > +++ b/kernel/sysctl.c
> > > > > @@ -827,15 +827,6 @@ static struct ctl_table kern_table[] = {
> > > > > .extra1 = &zero,
> > > > > .extra2 = &one,
> > > > > },
> > > > > - {
> > > > > - .procname = "softlockup_thresh",
> > > > > - .data = &softlockup_thresh,
> > > > > - .maxlen = sizeof(int),
> > > > > - .mode = 0644,
> > > > > - .proc_handler = proc_dosoftlockup_thresh,
> > > > > - .extra1 = &neg_one,
> > > > > - .extra2 = &sixty,
> > > > > - },
> > > >
> > > >
> > > >
> > > > I wonder about the ABI breakage.
> > > >
> > > > But I suspect few userspace tools use it though, since this is
> > > > mostly for kernel dev.
> > >
> > > There is no breakage, this chunk of code was duplicated later in the file.
> > > I am just removing the duplicated bits to simplify the SOFTLOCKUP Kconfig
> > > stuff.
> > >
> > > Cheers,
> > > Don
> >
> >
> > Ah right.
> >
> > BTW, if you address my reviews, please do it incrementally, I'm going
> > to apply this set and push it to Ingo.
>
> Ok, probably easier to review too. :-)
Yeah, and it's time to flush this code as it's good globally.
Plus it would be nice to get this for .35
Ah and forget about the sysctl ABI breakages. Since this is only
used for kernel development, this is not going to break much things.
If somebody complains, we can still reintegrate what we had.
Thanks.
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 21:00 ` Frederic Weisbecker
@ 2010-05-12 21:38 ` Cyrill Gorcunov
2010-05-12 21:50 ` Don Zickus
0 siblings, 1 reply; 27+ messages in thread
From: Cyrill Gorcunov @ 2010-05-12 21:38 UTC (permalink / raw
To: Frederic Weisbecker, mingo
Cc: Don Zickus, peterz, aris, linux-kernel, randy.dunlap
On Wed, May 12, 2010 at 11:00:36PM +0200, Frederic Weisbecker wrote:
...
> > >
> > > Ah right.
> > >
> > > BTW, if you address my reviews, please do it incrementally, I'm going
> > > to apply this set and push it to Ingo.
> >
> > Ok, probably easier to review too. :-)
>
>
> Yeah, and it's time to flush this code as it's good globally.
>
> Plus it would be nice to get this for .35
>
> Ah and forget about the sysctl ABI breakages. Since this is only
> used for kernel development, this is not going to break much things.
> If somebody complains, we can still reintegrate what we had.
>
> Thanks.
>
...
Guys, could you please spend a few minutes and enlighten me a bit?
Does all this series mean that we eventually will drop nmi-watchdog
via io-apic (read via pic) as only the transition to perf complete?
I recall someone said about to stop using io-apic, but just to be sure.
-- Cyrill
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 21:38 ` Cyrill Gorcunov
@ 2010-05-12 21:50 ` Don Zickus
2010-05-13 15:53 ` Cyrill Gorcunov
0 siblings, 1 reply; 27+ messages in thread
From: Don Zickus @ 2010-05-12 21:50 UTC (permalink / raw
To: Cyrill Gorcunov
Cc: Frederic Weisbecker, mingo, peterz, aris, linux-kernel,
randy.dunlap
On Thu, May 13, 2010 at 01:38:14AM +0400, Cyrill Gorcunov wrote:
> On Wed, May 12, 2010 at 11:00:36PM +0200, Frederic Weisbecker wrote:
> ...
> > > >
> > > > Ah right.
> > > >
> > > > BTW, if you address my reviews, please do it incrementally, I'm going
> > > > to apply this set and push it to Ingo.
> > >
> > > Ok, probably easier to review too. :-)
> >
> >
> > Yeah, and it's time to flush this code as it's good globally.
> >
> > Plus it would be nice to get this for .35
> >
> > Ah and forget about the sysctl ABI breakages. Since this is only
> > used for kernel development, this is not going to break much things.
> > If somebody complains, we can still reintegrate what we had.
> >
> > Thanks.
> >
> ...
> Guys, could you please spend a few minutes and enlighten me a bit?
> Does all this series mean that we eventually will drop nmi-watchdog
> via io-apic (read via pic) as only the transition to perf complete?
>
> I recall someone said about to stop using io-apic, but just to be sure.
Right, this code sits on top of the perf subsystem which uses lapic.
Eventually, the old nmi watchdog code will disappear along with the
support for io-apic.
Cheers,
Don
^ permalink raw reply [flat|nested] 27+ messages in thread
* [tip:perf/nmi] lockup_detector: Combine nmi_watchdog and softlockup detector
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
2010-05-12 19:55 ` Frederic Weisbecker
@ 2010-05-13 6:51 ` tip-bot for Don Zickus
1 sibling, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:51 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: 58687acba59266735adb8ccd9b5b9aa2c7cd205b
Gitweb: http://git.kernel.org/tip/58687acba59266735adb8ccd9b5b9aa2c7cd205b
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:44 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:33 +0200
lockup_detector: Combine nmi_watchdog and softlockup detector
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
V3:
- comment cleanups
- drop support for older softlockup code
- per_cpu cleanups
- completely remove software clock base hardlockup detector
- use per_cpu masking on hard/soft lockup detection
- #ifdef cleanups
- rename config option NMI_WATCHDOG to LOCKUP_DETECTOR
- documentation additions
V4:
- documentation fixes
- convert per_cpu to __get_cpu_var
- powerpc compile fixes
V5:
- split apart warn flags for hard and soft lockups
TODO:
- figure out how to make an arch-agnostic clock2cycles call
(if possible) to feed into perf events as a sample period
[fweisbec: merged conflict patch]
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-2-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
Documentation/kernel-parameters.txt | 2 +
arch/x86/include/asm/nmi.h | 2 +-
arch/x86/kernel/apic/Makefile | 4 +-
arch/x86/kernel/apic/hw_nmi.c | 2 +-
arch/x86/kernel/traps.c | 4 +-
include/linux/nmi.h | 8 +-
include/linux/sched.h | 6 +
init/Kconfig | 5 +-
kernel/Makefile | 3 +-
kernel/sysctl.c | 21 +-
kernel/watchdog.c | 592 +++++++++++++++++++++++++++++++++++
lib/Kconfig.debug | 30 ++-
12 files changed, 650 insertions(+), 29 deletions(-)
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 839b21b..dfe8d1c 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1777,6 +1777,8 @@ and is between 256 and 4096 characters. It is defined in the file
nousb [USB] Disable the USB subsystem
+ nowatchdog [KNL] Disable the lockup detector.
+
nowb [ARM]
nox2apic [X86-64,APIC] Do not enable x2APIC mode.
diff --git a/arch/x86/include/asm/nmi.h b/arch/x86/include/asm/nmi.h
index 5b41b0f..932f0f8 100644
--- a/arch/x86/include/asm/nmi.h
+++ b/arch/x86/include/asm/nmi.h
@@ -17,7 +17,7 @@ int do_nmi_callback(struct pt_regs *regs, int cpu);
extern void die_nmi(char *str, struct pt_regs *regs, int do_panic);
extern int check_nmi_watchdog(void);
-#if !defined(CONFIG_NMI_WATCHDOG)
+#if !defined(CONFIG_LOCKUP_DETECTOR)
extern int nmi_watchdog_enabled;
#endif
extern int avail_to_resrv_perfctr_nmi_bit(unsigned int);
diff --git a/arch/x86/kernel/apic/Makefile b/arch/x86/kernel/apic/Makefile
index 1a4512e..52f32e0 100644
--- a/arch/x86/kernel/apic/Makefile
+++ b/arch/x86/kernel/apic/Makefile
@@ -3,10 +3,10 @@
#
obj-$(CONFIG_X86_LOCAL_APIC) += apic.o apic_noop.o probe_$(BITS).o ipi.o
-ifneq ($(CONFIG_NMI_WATCHDOG),y)
+ifneq ($(CONFIG_LOCKUP_DETECTOR),y)
obj-$(CONFIG_X86_LOCAL_APIC) += nmi.o
endif
-obj-$(CONFIG_NMI_WATCHDOG) += hw_nmi.o
+obj-$(CONFIG_LOCKUP_DETECTOR) += hw_nmi.o
obj-$(CONFIG_X86_IO_APIC) += io_apic.o
obj-$(CONFIG_SMP) += ipi.o
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index e8b78a0..79425f9 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -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
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
index bdc7fab..bd347c2 100644
--- a/arch/x86/kernel/traps.c
+++ b/arch/x86/kernel/traps.c
@@ -406,7 +406,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
== NOTIFY_STOP)
return;
-#ifndef CONFIG_NMI_WATCHDOG
+#ifndef CONFIG_LOCKUP_DETECTOR
/*
* Ok, so this is none of the documented NMI sources,
* so it must be the NMI watchdog.
@@ -414,7 +414,7 @@ static notrace __kprobes void default_do_nmi(struct pt_regs *regs)
if (nmi_watchdog_tick(regs, reason))
return;
if (!do_nmi_callback(regs, cpu))
-#endif /* !CONFIG_NMI_WATCHDOG */
+#endif /* !CONFIG_LOCKUP_DETECTOR */
unknown_nmi_error(reason, regs);
#else
unknown_nmi_error(reason, regs);
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 22cc796..abd48aa 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -20,7 +20,7 @@ extern void touch_nmi_watchdog(void);
extern void acpi_nmi_disable(void);
extern void acpi_nmi_enable(void);
#else
-#ifndef CONFIG_NMI_WATCHDOG
+#ifndef CONFIG_LOCKUP_DETECTOR
static inline void touch_nmi_watchdog(void)
{
touch_softlockup_watchdog();
@@ -51,12 +51,12 @@ static inline bool trigger_all_cpu_backtrace(void)
}
#endif
-#ifdef CONFIG_NMI_WATCHDOG
+#ifdef CONFIG_LOCKUP_DETECTOR
int hw_nmi_is_cpu_stuck(struct pt_regs *);
u64 hw_nmi_get_sample_period(void);
-extern int nmi_watchdog_enabled;
+extern int watchdog_enabled;
struct ctl_table;
-extern int proc_nmi_enabled(struct ctl_table *, int ,
+extern int proc_dowatchdog_enabled(struct ctl_table *, int ,
void __user *, size_t *, loff_t *);
#endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index dad7f66..37efe8f 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -346,6 +346,12 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
size_t *lenp, loff_t *ppos);
#endif
+#ifdef CONFIG_LOCKUP_DETECTOR
+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")))
diff --git a/init/Kconfig b/init/Kconfig
index c6c8903..e44e254 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -944,8 +944,11 @@ config PERF_USE_VMALLOC
config PERF_EVENTS_NMI
bool
+ depends on PERF_EVENTS
help
- Arch has support for nmi_watchdog
+ System hardware can generate an NMI using the perf event
+ subsystem. Also has support for calculating CPU cycle events
+ to determine how many clock cycles in a given period.
menu "Kernel Performance Events And Counters"
diff --git a/kernel/Makefile b/kernel/Makefile
index d5c3006..6adeafc 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -76,9 +76,8 @@ obj-$(CONFIG_GCOV_KERNEL) += gcov/
obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
obj-$(CONFIG_KPROBES) += kprobes.o
obj-$(CONFIG_KGDB) += kgdb.o
-obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
-obj-$(CONFIG_NMI_WATCHDOG) += nmi_watchdog.o
obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
+obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
obj-$(CONFIG_SECCOMP) += seccomp.o
obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index a38af43..0f9adda 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -74,7 +74,7 @@
#include <scsi/sg.h>
#endif
-#ifdef CONFIG_NMI_WATCHDOG
+#ifdef CONFIG_LOCKUP_DETECTOR
#include <linux/nmi.h>
#endif
@@ -686,16 +686,25 @@ static struct ctl_table kern_table[] = {
.mode = 0444,
.proc_handler = proc_dointvec,
},
-#if defined(CONFIG_NMI_WATCHDOG)
+#if defined(CONFIG_LOCKUP_DETECTOR)
{
- .procname = "nmi_watchdog",
- .data = &nmi_watchdog_enabled,
+ .procname = "watchdog",
+ .data = &watchdog_enabled,
.maxlen = sizeof (int),
.mode = 0644,
- .proc_handler = proc_nmi_enabled,
+ .proc_handler = proc_dowatchdog_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)
+#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
{
.procname = "unknown_nmi_panic",
.data = &unknown_nmi_panic,
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
new file mode 100644
index 0000000..6b7fad8
--- /dev/null
+++ b/kernel/watchdog.c
@@ -0,0 +1,592 @@
+/*
+ * Detect hard and soft lockups on a system
+ *
+ * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
+ *
+ * this code detects hard lockups: incidents in where on a CPU
+ * the kernel does not respond to anything except NMI.
+ *
+ * Note: Most of this code is borrowed heavily from softlockup.c,
+ * so thanks to Ingo for the initial implementation.
+ * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
+ * to those contributors as well.
+ */
+
+#include <linux/mm.h>
+#include <linux/cpu.h>
+#include <linux/nmi.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/freezer.h>
+#include <linux/kthread.h>
+#include <linux/lockdep.h>
+#include <linux/notifier.h>
+#include <linux/module.h>
+#include <linux/sysctl.h>
+
+#include <asm/irq_regs.h>
+#include <linux/perf_event.h>
+
+int watchdog_enabled;
+int __read_mostly softlockup_thresh = 60;
+
+static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
+static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
+static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
+static DEFINE_PER_CPU(bool, softlockup_touch_sync);
+static DEFINE_PER_CPU(bool, hard_watchdog_warn);
+static DEFINE_PER_CPU(bool, soft_watchdog_warn);
+#ifdef CONFIG_PERF_EVENTS_NMI
+static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
+static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
+static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
+#endif
+
+static int __read_mostly did_panic;
+static int __initdata no_watchdog;
+
+
+/* boot commands */
+/*
+ * Should we panic when a soft-lockup or hard-lockup occurs:
+ */
+#ifdef CONFIG_PERF_EVENTS_NMI
+static int hardlockup_panic;
+
+static int __init hardlockup_panic_setup(char *str)
+{
+ if (!strncmp(str, "panic", 5))
+ hardlockup_panic = 1;
+ return 1;
+}
+__setup("nmi_watchdog=", hardlockup_panic_setup);
+#endif
+
+unsigned int __read_mostly softlockup_panic =
+ CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
+
+static int __init softlockup_panic_setup(char *str)
+{
+ softlockup_panic = simple_strtoul(str, NULL, 0);
+
+ return 1;
+}
+__setup("softlockup_panic=", softlockup_panic_setup);
+
+static int __init nowatchdog_setup(char *str)
+{
+ no_watchdog = 1;
+ return 1;
+}
+__setup("nowatchdog", nowatchdog_setup);
+
+/* deprecated */
+static int __init nosoftlockup_setup(char *str)
+{
+ no_watchdog = 1;
+ return 1;
+}
+__setup("nosoftlockup", nosoftlockup_setup);
+/* */
+
+
+/*
+ * 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)
+{
+ int this_cpu = raw_smp_processor_id();
+
+ __get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);
+}
+
+void touch_watchdog(void)
+{
+ __get_cpu_var(watchdog_touch_ts) = 0;
+}
+EXPORT_SYMBOL(touch_watchdog);
+
+void touch_all_watchdog(void)
+{
+ int cpu;
+
+ /*
+ * this is done lockless
+ * do we care if a 0 races with a timestamp?
+ * all it means is the softlock check starts one cycle later
+ */
+ for_each_online_cpu(cpu)
+ per_cpu(watchdog_touch_ts, cpu) = 0;
+}
+
+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();
+}
+
+void touch_softlockup_watchdog_sync(void)
+{
+ __raw_get_cpu_var(softlockup_touch_sync) = true;
+ __raw_get_cpu_var(watchdog_touch_ts) = 0;
+}
+
+void softlockup_tick(void)
+{
+}
+
+#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 (time_after(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
+static 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,
+};
+
+/* 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 (__get_cpu_var(hard_watchdog_warn) == true)
+ 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);
+
+ __get_cpu_var(hard_watchdog_warn) = true;
+ return;
+ }
+
+ __get_cpu_var(hard_watchdog_warn) = false;
+ return;
+}
+static void watchdog_interrupt_count(void)
+{
+ __get_cpu_var(hrtimer_interrupts)++;
+}
+#else
+static inline void watchdog_interrupt_count(void) { return; }
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* watchdog kicker functions */
+static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
+{
+ int this_cpu = smp_processor_id();
+ unsigned long touch_ts = __get_cpu_var(watchdog_touch_ts);
+ struct pt_regs *regs = get_irq_regs();
+ int duration;
+
+ /* kick the hardlockup detector */
+ watchdog_interrupt_count();
+
+ /* 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) {
+ if (unlikely(per_cpu(softlockup_touch_sync, this_cpu))) {
+ /*
+ * If the time stamp was touched atomically
+ * make sure the scheduler tick is up to date.
+ */
+ per_cpu(softlockup_touch_sync, this_cpu) = false;
+ sched_clock_tick();
+ }
+ __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 (unlikely(duration)) {
+ /* only warn once */
+ if (__get_cpu_var(soft_watchdog_warn) == true)
+ return HRTIMER_RESTART;
+
+ 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();
+
+ if (softlockup_panic)
+ panic("softlockup: hung tasks");
+ __get_cpu_var(soft_watchdog_warn) = true;
+ } else
+ __get_cpu_var(soft_watchdog_warn) = false;
+
+ 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, ¶m);
+
+ /* 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);
+
+ return 0;
+}
+
+
+#ifdef CONFIG_PERF_EVENTS_NMI
+static int watchdog_nmi_enable(int cpu)
+{
+ 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;
+ }
+
+ 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:
+ return 0;
+}
+
+static void watchdog_nmi_disable(int cpu)
+{
+ struct perf_event *event = per_cpu(watchdog_ev, cpu);
+
+ if (event) {
+ perf_event_disable(event);
+ per_cpu(watchdog_ev, cpu) = NULL;
+
+ /* should be in cleanup, but blocks oprofile */
+ perf_event_release_kernel(event);
+ }
+ return;
+}
+#else
+static int watchdog_nmi_enable(int cpu) { return 0; }
+static void watchdog_nmi_disable(int cpu) { return; }
+#endif /* CONFIG_PERF_EVENTS_NMI */
+
+/* prepare/enable/disable routines */
+static int watchdog_prepare_cpu(int cpu)
+{
+ struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
+
+ WARN_ON(per_cpu(softlockup_watchdog, cpu));
+ 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);
+
+ /* enable the perf event */
+ if (watchdog_nmi_enable(cpu) != 0)
+ return -1;
+
+ /* 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);
+
+ /*
+ * cancel the timer first to stop incrementing the stats
+ * and waking up the kthread
+ */
+ hrtimer_cancel(hrtimer);
+
+ /* disable the perf event */
+ watchdog_nmi_disable(cpu);
+
+ /* stop the watchdog thread */
+ if (p) {
+ per_cpu(softlockup_watchdog, cpu) = NULL;
+ kthread_stop(p);
+ }
+
+ /* if any cpu succeeds, watchdog is considered enabled for the system */
+ watchdog_enabled = 1;
+}
+
+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 */
+ watchdog_enabled = 0;
+}
+
+
+/* sysctl functions */
+#ifdef CONFIG_SYSCTL
+/*
+ * proc handler for /proc/sys/kernel/nmi_watchdog
+ */
+
+int proc_dowatchdog_enabled(struct ctl_table *table, int write,
+ void __user *buffer, size_t *length, loff_t *ppos)
+{
+ proc_dointvec(table, write, buffer, length, ppos);
+
+ if (watchdog_enabled)
+ watchdog_enable_all_cpus();
+ 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)
+{
+ 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);
+ 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)
+{
+ void *cpu = (void *)(long)smp_processor_id();
+ int err;
+
+ if (no_watchdog)
+ return 0;
+
+ err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
+ WARN_ON(err == NOTIFY_BAD);
+
+ 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);
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 220ae60..49e285d 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -153,7 +153,7 @@ config DEBUG_SHIRQ
points; some don't and need to be caught.
config DETECT_SOFTLOCKUP
- bool "Detect Soft Lockups"
+ bool
depends on DEBUG_KERNEL && !S390
default y
help
@@ -171,17 +171,27 @@ config DETECT_SOFTLOCKUP
can be detected via the NMI-watchdog, on platforms that
support it.)
-config NMI_WATCHDOG
- bool "Detect Hard Lockups with an NMI Watchdog"
- depends on DEBUG_KERNEL && PERF_EVENTS && PERF_EVENTS_NMI
+config LOCKUP_DETECTOR
+ 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.
+ Say Y here to enable the kernel to act as a watchdog 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 have 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
- seconds.
+ The overhead should be minimal. A periodic hrtimer runs to
+ generate interrupts and kick the watchdog task every 10-12 seconds.
+ An NMI is generated every 60 seconds or so to check for hardlockups.
config BOOTPARAM_SOFTLOCKUP_PANIC
bool "Panic (Reboot) On Soft Lockups"
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] lockup_detector: Touch_softlockup cleanups and softlockup_tick removal
2010-05-07 21:11 ` [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal Don Zickus
2010-05-12 20:06 ` Frederic Weisbecker
@ 2010-05-13 6:52 ` tip-bot for Don Zickus
1 sibling, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:52 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: 332fbdbca3f7716c5620970755ae054d213bcc4e
Gitweb: http://git.kernel.org/tip/332fbdbca3f7716c5620970755ae054d213bcc4e
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:45 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:43 +0200
lockup_detector: Touch_softlockup cleanups and softlockup_tick removal
Just some code cleanup to make touch_softlockup clearer and remove the
softlockup_tick function as it is no longer needed.
Also remove the /proc softlockup_thres call as it has been changed to
watchdog_thres.
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-3-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
include/linux/sched.h | 16 +++-------------
kernel/sysctl.c | 9 ---------
kernel/timer.c | 1 -
kernel/watchdog.c | 35 +++--------------------------------
4 files changed, 6 insertions(+), 55 deletions(-)
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 37efe8f..33f9b2a 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -312,19 +312,15 @@ extern void scheduler_tick(void);
extern void sched_show_task(struct task_struct *p);
#ifdef CONFIG_DETECT_SOFTLOCKUP
-extern void softlockup_tick(void);
extern void touch_softlockup_watchdog(void);
extern void touch_softlockup_watchdog_sync(void);
extern void touch_all_softlockup_watchdogs(void);
-extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos);
+extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
+ void __user *buffer,
+ size_t *lenp, loff_t *ppos);
extern unsigned int softlockup_panic;
extern int softlockup_thresh;
#else
-static inline void softlockup_tick(void)
-{
-}
static inline void touch_softlockup_watchdog(void)
{
}
@@ -346,12 +342,6 @@ extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
size_t *lenp, loff_t *ppos);
#endif
-#ifdef CONFIG_LOCKUP_DETECTOR
-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")))
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 0f9adda..999bc3f 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -817,15 +817,6 @@ static struct ctl_table kern_table[] = {
.extra1 = &zero,
.extra2 = &one,
},
- {
- .procname = "softlockup_thresh",
- .data = &softlockup_thresh,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = proc_dosoftlockup_thresh,
- .extra1 = &neg_one,
- .extra2 = &sixty,
- },
#endif
#ifdef CONFIG_DETECT_HUNG_TASK
{
diff --git a/kernel/timer.c b/kernel/timer.c
index aeb6a54..e8de5eb 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1225,7 +1225,6 @@ void run_local_timers(void)
{
hrtimer_run_queues();
raise_softirq(TIMER_SOFTIRQ);
- softlockup_tick();
}
/*
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 6b7fad8..f1541b7 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -119,13 +119,12 @@ static void __touch_watchdog(void)
__get_cpu_var(watchdog_touch_ts) = get_timestamp(this_cpu);
}
-void touch_watchdog(void)
+void touch_softlockup_watchdog(void)
{
__get_cpu_var(watchdog_touch_ts) = 0;
}
-EXPORT_SYMBOL(touch_watchdog);
-void touch_all_watchdog(void)
+void touch_all_softlockup_watchdogs(void)
{
int cpu;
@@ -140,35 +139,16 @@ void touch_all_watchdog(void)
void touch_nmi_watchdog(void)
{
- touch_watchdog();
+ touch_softlockup_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();
-}
-
void touch_softlockup_watchdog_sync(void)
{
__raw_get_cpu_var(softlockup_touch_sync) = true;
__raw_get_cpu_var(watchdog_touch_ts) = 0;
}
-void softlockup_tick(void)
-{
-}
-
#ifdef CONFIG_PERF_EVENTS_NMI
/* watchdog detector functions */
static int is_hardlockup(int cpu)
@@ -522,15 +502,6 @@ int proc_dowatchdog_thresh(struct ctl_table *table, int write,
{
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 */
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] lockup_detector: Remove old softlockup code
2010-05-07 21:11 ` [PATCH 3/8] [watchdog] remove old softlockup code Don Zickus
@ 2010-05-13 6:52 ` tip-bot for Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:52 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: 2508ce1845a3b256798532b2c6b7997c2dc6533b
Gitweb: http://git.kernel.org/tip/2508ce1845a3b256798532b2c6b7997c2dc6533b
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:46 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:45 +0200
lockup_detector: Remove old softlockup code
Now that is no longer compiled or used, just remove it.
Also move some of the code wrapped with DETECT_SOFTLOCKUP to the
LOCKUP_DETECTOR wrappers because that is the code that uses it now.
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-4-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
kernel/softlockup.c | 293 ---------------------------------------------------
kernel/sysctl.c | 22 ++--
2 files changed, 10 insertions(+), 305 deletions(-)
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
deleted file mode 100644
index 4b493f6..0000000
--- a/kernel/softlockup.c
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Detect Soft Lockups
- *
- * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
- *
- * this code detects soft lockups: incidents in where on a CPU
- * the kernel does not reschedule for 10 seconds or more.
- */
-#include <linux/mm.h>
-#include <linux/cpu.h>
-#include <linux/nmi.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/freezer.h>
-#include <linux/kthread.h>
-#include <linux/lockdep.h>
-#include <linux/notifier.h>
-#include <linux/module.h>
-#include <linux/sysctl.h>
-
-#include <asm/irq_regs.h>
-
-static DEFINE_SPINLOCK(print_lock);
-
-static DEFINE_PER_CPU(unsigned long, softlockup_touch_ts); /* touch timestamp */
-static DEFINE_PER_CPU(unsigned long, softlockup_print_ts); /* print timestamp */
-static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
-static DEFINE_PER_CPU(bool, softlock_touch_sync);
-
-static int __read_mostly did_panic;
-int __read_mostly softlockup_thresh = 60;
-
-/*
- * Should we panic (and reboot, if panic_timeout= is set) when a
- * soft-lockup occurs:
- */
-unsigned int __read_mostly softlockup_panic =
- CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
-
-static int __init softlockup_panic_setup(char *str)
-{
- softlockup_panic = simple_strtoul(str, NULL, 0);
-
- return 1;
-}
-__setup("softlockup_panic=", softlockup_panic_setup);
-
-static int
-softlock_panic(struct notifier_block *this, unsigned long event, void *ptr)
-{
- did_panic = 1;
-
- return NOTIFY_DONE;
-}
-
-static struct notifier_block panic_block = {
- .notifier_call = softlock_panic,
-};
-
-/*
- * 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 void __touch_softlockup_watchdog(void)
-{
- int this_cpu = raw_smp_processor_id();
-
- __raw_get_cpu_var(softlockup_touch_ts) = get_timestamp(this_cpu);
-}
-
-void touch_softlockup_watchdog(void)
-{
- __raw_get_cpu_var(softlockup_touch_ts) = 0;
-}
-EXPORT_SYMBOL(touch_softlockup_watchdog);
-
-void touch_softlockup_watchdog_sync(void)
-{
- __raw_get_cpu_var(softlock_touch_sync) = true;
- __raw_get_cpu_var(softlockup_touch_ts) = 0;
-}
-
-void touch_all_softlockup_watchdogs(void)
-{
- int cpu;
-
- /* Cause each CPU to re-update its timestamp rather than complain */
- for_each_online_cpu(cpu)
- per_cpu(softlockup_touch_ts, cpu) = 0;
-}
-EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
-
-int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
-{
- touch_all_softlockup_watchdogs();
- return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
-}
-
-/*
- * This callback runs from the timer interrupt, and checks
- * whether the watchdog thread has hung or not:
- */
-void softlockup_tick(void)
-{
- int this_cpu = smp_processor_id();
- unsigned long touch_ts = per_cpu(softlockup_touch_ts, this_cpu);
- unsigned long print_ts;
- struct pt_regs *regs = get_irq_regs();
- unsigned long now;
-
- /* Is detection switched off? */
- if (!per_cpu(softlockup_watchdog, this_cpu) || softlockup_thresh <= 0) {
- /* Be sure we don't false trigger if switched back on */
- if (touch_ts)
- per_cpu(softlockup_touch_ts, this_cpu) = 0;
- return;
- }
-
- if (touch_ts == 0) {
- if (unlikely(per_cpu(softlock_touch_sync, this_cpu))) {
- /*
- * If the time stamp was touched atomically
- * make sure the scheduler tick is up to date.
- */
- per_cpu(softlock_touch_sync, this_cpu) = false;
- sched_clock_tick();
- }
- __touch_softlockup_watchdog();
- return;
- }
-
- print_ts = per_cpu(softlockup_print_ts, this_cpu);
-
- /* report at most once a second */
- if (print_ts == touch_ts || did_panic)
- return;
-
- /* do not print during early bootup: */
- if (unlikely(system_state != SYSTEM_RUNNING)) {
- __touch_softlockup_watchdog();
- return;
- }
-
- now = get_timestamp(this_cpu);
-
- /*
- * Wake up the high-prio watchdog task twice per
- * threshold timespan.
- */
- if (time_after(now - softlockup_thresh/2, touch_ts))
- wake_up_process(per_cpu(softlockup_watchdog, this_cpu));
-
- /* Warn about unreasonable delays: */
- if (time_before_eq(now - softlockup_thresh, touch_ts))
- return;
-
- per_cpu(softlockup_print_ts, this_cpu) = touch_ts;
-
- spin_lock(&print_lock);
- printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
- this_cpu, now - touch_ts,
- current->comm, task_pid_nr(current));
- print_modules();
- print_irqtrace_events(current);
- if (regs)
- show_regs(regs);
- else
- dump_stack();
- spin_unlock(&print_lock);
-
- if (softlockup_panic)
- panic("softlockup: hung tasks");
-}
-
-/*
- * The watchdog thread - runs every second and touches the timestamp.
- */
-static int watchdog(void *__bind_cpu)
-{
- struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
-
- sched_setscheduler(current, SCHED_FIFO, ¶m);
-
- /* initialize timestamp */
- __touch_softlockup_watchdog();
-
- 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_softlockup_watchdog();
- schedule();
-
- if (kthread_should_stop())
- break;
-
- set_current_state(TASK_INTERRUPTIBLE);
- }
- __set_current_state(TASK_RUNNING);
-
- return 0;
-}
-
-/*
- * 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;
- struct task_struct *p;
-
- switch (action) {
- case CPU_UP_PREPARE:
- case CPU_UP_PREPARE_FROZEN:
- BUG_ON(per_cpu(softlockup_watchdog, hotcpu));
- p = kthread_create(watchdog, hcpu, "watchdog/%d", hotcpu);
- if (IS_ERR(p)) {
- printk(KERN_ERR "watchdog for %i failed\n", hotcpu);
- return NOTIFY_BAD;
- }
- per_cpu(softlockup_touch_ts, hotcpu) = 0;
- per_cpu(softlockup_watchdog, hotcpu) = p;
- kthread_bind(p, hotcpu);
- break;
- case CPU_ONLINE:
- case CPU_ONLINE_FROZEN:
- wake_up_process(per_cpu(softlockup_watchdog, hotcpu));
- break;
-#ifdef CONFIG_HOTPLUG_CPU
- case CPU_UP_CANCELED:
- case CPU_UP_CANCELED_FROZEN:
- if (!per_cpu(softlockup_watchdog, hotcpu))
- break;
- /* Unbind so it can run. Fall thru. */
- kthread_bind(per_cpu(softlockup_watchdog, hotcpu),
- cpumask_any(cpu_online_mask));
- case CPU_DEAD:
- case CPU_DEAD_FROZEN:
- p = per_cpu(softlockup_watchdog, hotcpu);
- per_cpu(softlockup_watchdog, hotcpu) = NULL;
- kthread_stop(p);
- break;
-#endif /* CONFIG_HOTPLUG_CPU */
- }
- return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata cpu_nfb = {
- .notifier_call = cpu_callback
-};
-
-static int __initdata nosoftlockup;
-
-static int __init nosoftlockup_setup(char *str)
-{
- nosoftlockup = 1;
- return 1;
-}
-__setup("nosoftlockup", nosoftlockup_setup);
-
-static int __init spawn_softlockup_task(void)
-{
- void *cpu = (void *)(long)smp_processor_id();
- int err;
-
- if (nosoftlockup)
- return 0;
-
- err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
- if (err == NOTIFY_BAD) {
- BUG();
- 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_softlockup_task);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 999bc3f..04bcd8a 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -108,7 +108,7 @@ extern int blk_iopoll_enabled;
#endif
/* Constants used for minimum and maximum */
-#ifdef CONFIG_DETECT_SOFTLOCKUP
+#ifdef CONFIG_LOCKUP_DETECTOR
static int sixty = 60;
static int neg_one = -1;
#endif
@@ -703,6 +703,15 @@ static struct ctl_table kern_table[] = {
.extra1 = &neg_one,
.extra2 = &sixty,
},
+ {
+ .procname = "softlockup_panic",
+ .data = &softlockup_panic,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &zero,
+ .extra2 = &one,
+ },
#endif
#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
{
@@ -807,17 +816,6 @@ static struct ctl_table kern_table[] = {
.proc_handler = proc_dointvec,
},
#endif
-#ifdef CONFIG_DETECT_SOFTLOCKUP
- {
- .procname = "softlockup_panic",
- .data = &softlockup_panic,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = proc_dointvec_minmax,
- .extra1 = &zero,
- .extra2 = &one,
- },
-#endif
#ifdef CONFIG_DETECT_HUNG_TASK
{
.procname = "hung_task_panic",
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] lockup_detector: Remove nmi_watchdog.c file
2010-05-07 21:11 ` [PATCH 4/8] [watchdog] remove nmi_watchdog.c file Don Zickus
@ 2010-05-13 6:52 ` tip-bot for Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:52 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: f69bcf60c3f17aa367e16eef7bc6ab001ea6d58a
Gitweb: http://git.kernel.org/tip/f69bcf60c3f17aa367e16eef7bc6ab001ea6d58a
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:47 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:46 +0200
lockup_detector: Remove nmi_watchdog.c file
This file migrated to kernel/watchdog.c and then combined with
kernel/softlockup.c. As a result kernel/nmi_watchdog.c is no longer
needed. Just remove it.
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-5-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
kernel/nmi_watchdog.c | 259 -------------------------------------------------
1 files changed, 0 insertions(+), 259 deletions(-)
diff --git a/kernel/nmi_watchdog.c b/kernel/nmi_watchdog.c
deleted file mode 100644
index a79d211..0000000
--- a/kernel/nmi_watchdog.c
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Detect Hard Lockups using the NMI
- *
- * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
- *
- * this code detects hard lockups: incidents in where on a CPU
- * the kernel does not respond to anything except NMI.
- *
- * Note: Most of this code is borrowed heavily from softlockup.c,
- * so thanks to Ingo for the initial implementation.
- * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
- * to those contributors as well.
- */
-
-#include <linux/mm.h>
-#include <linux/cpu.h>
-#include <linux/nmi.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/freezer.h>
-#include <linux/lockdep.h>
-#include <linux/notifier.h>
-#include <linux/module.h>
-#include <linux/sysctl.h>
-
-#include <asm/irq_regs.h>
-#include <linux/perf_event.h>
-
-static DEFINE_PER_CPU(struct perf_event *, nmi_watchdog_ev);
-static DEFINE_PER_CPU(int, nmi_watchdog_touch);
-static DEFINE_PER_CPU(long, alert_counter);
-
-static int panic_on_timeout;
-
-void touch_nmi_watchdog(void)
-{
- __raw_get_cpu_var(nmi_watchdog_touch) = 1;
- touch_softlockup_watchdog();
-}
-EXPORT_SYMBOL(touch_nmi_watchdog);
-
-void touch_all_nmi_watchdog(void)
-{
- int cpu;
-
- for_each_online_cpu(cpu)
- per_cpu(nmi_watchdog_touch, cpu) = 1;
- touch_softlockup_watchdog();
-}
-
-static int __init setup_nmi_watchdog(char *str)
-{
- if (!strncmp(str, "panic", 5)) {
- panic_on_timeout = 1;
- str = strchr(str, ',');
- if (!str)
- return 1;
- ++str;
- }
- return 1;
-}
-__setup("nmi_watchdog=", setup_nmi_watchdog);
-
-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,
-};
-
-void wd_overflow(struct perf_event *event, int nmi,
- struct perf_sample_data *data,
- struct pt_regs *regs)
-{
- int cpu = smp_processor_id();
- int touched = 0;
-
- if (__get_cpu_var(nmi_watchdog_touch)) {
- per_cpu(nmi_watchdog_touch, cpu) = 0;
- touched = 1;
- }
-
- /* check to see if the cpu is doing anything */
- if (!touched && hw_nmi_is_cpu_stuck(regs)) {
- /*
- * Ayiee, looks like this CPU is stuck ...
- * wait a few IRQs (5 seconds) before doing the oops ...
- */
- per_cpu(alert_counter, cpu) += 1;
- if (per_cpu(alert_counter, cpu) == 5) {
- if (panic_on_timeout)
- panic("NMI Watchdog detected LOCKUP on cpu %d", cpu);
- else
- WARN(1, "NMI Watchdog detected LOCKUP on cpu %d", cpu);
- }
- } else {
- per_cpu(alert_counter, cpu) = 0;
- }
-
- return;
-}
-
-static int enable_nmi_watchdog(int cpu)
-{
- struct perf_event *event;
- struct perf_event_attr *wd_attr;
-
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event && event->state > PERF_EVENT_STATE_OFF)
- return 0;
-
- if (event == NULL) {
- /* Try to register using hardware perf events first */
- wd_attr = &wd_hw_attr;
- wd_attr->sample_period = hw_nmi_get_sample_period();
- event = perf_event_create_kernel_counter(wd_attr, cpu, -1, wd_overflow);
- if (IS_ERR(event)) {
- /* hardware doesn't exist or not supported, fallback to software events */
- printk(KERN_INFO "nmi_watchdog: hardware not available, trying software events\n");
- wd_attr = &wd_sw_attr;
- wd_attr->sample_period = NSEC_PER_SEC;
- event = perf_event_create_kernel_counter(wd_attr, cpu, -1, wd_overflow);
- if (IS_ERR(event)) {
- printk(KERN_ERR "nmi watchdog failed to create perf event on %i: %p\n", cpu, event);
- return -1;
- }
- }
- per_cpu(nmi_watchdog_ev, cpu) = event;
- }
- perf_event_enable(per_cpu(nmi_watchdog_ev, cpu));
- return 0;
-}
-
-static void disable_nmi_watchdog(int cpu)
-{
- struct perf_event *event;
-
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event) {
- perf_event_disable(per_cpu(nmi_watchdog_ev, cpu));
- per_cpu(nmi_watchdog_ev, cpu) = NULL;
- perf_event_release_kernel(event);
- }
-}
-
-#ifdef CONFIG_SYSCTL
-/*
- * proc handler for /proc/sys/kernel/nmi_watchdog
- */
-int nmi_watchdog_enabled;
-
-int proc_nmi_enabled(struct ctl_table *table, int write,
- void __user *buffer, size_t *length, loff_t *ppos)
-{
- int cpu;
-
- if (!write) {
- struct perf_event *event;
- for_each_online_cpu(cpu) {
- event = per_cpu(nmi_watchdog_ev, cpu);
- if (event && event->state > PERF_EVENT_STATE_OFF) {
- nmi_watchdog_enabled = 1;
- break;
- }
- }
- proc_dointvec(table, write, buffer, length, ppos);
- return 0;
- }
-
- touch_all_nmi_watchdog();
- proc_dointvec(table, write, buffer, length, ppos);
- if (nmi_watchdog_enabled) {
- for_each_online_cpu(cpu)
- if (enable_nmi_watchdog(cpu)) {
- printk(KERN_ERR "NMI watchdog failed configuration, "
- " can not be enabled\n");
- }
- } else {
- for_each_online_cpu(cpu)
- disable_nmi_watchdog(cpu);
- }
- return 0;
-}
-
-#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:
- per_cpu(nmi_watchdog_touch, hotcpu) = 0;
- break;
- case CPU_ONLINE:
- case CPU_ONLINE_FROZEN:
- if (enable_nmi_watchdog(hotcpu))
- return NOTIFY_BAD;
- break;
-#ifdef CONFIG_HOTPLUG_CPU
- case CPU_UP_CANCELED:
- case CPU_UP_CANCELED_FROZEN:
- disable_nmi_watchdog(hotcpu);
- case CPU_DEAD:
- case CPU_DEAD_FROZEN:
- break;
-#endif /* CONFIG_HOTPLUG_CPU */
- }
- return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata cpu_nfb = {
- .notifier_call = cpu_callback
-};
-
-static int __initdata nonmi_watchdog;
-
-static int __init nonmi_watchdog_setup(char *str)
-{
- nonmi_watchdog = 1;
- return 1;
-}
-__setup("nonmi_watchdog", nonmi_watchdog_setup);
-
-static int __init spawn_nmi_watchdog_task(void)
-{
- void *cpu = (void *)(long)smp_processor_id();
- int err;
-
- if (nonmi_watchdog)
- return 0;
-
- printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
-
- err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
- if (err == NOTIFY_BAD) {
- BUG();
- return 1;
- }
- cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
- register_cpu_notifier(&cpu_nfb);
-
- return 0;
-}
-early_initcall(spawn_nmi_watchdog_task);
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] x86: Move trigger_all_cpu_backtrace to its own die_notifier
2010-05-07 21:11 ` [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier Don Zickus
@ 2010-05-13 6:53 ` tip-bot for Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:53 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: 7cbb7e7fa46f6e5229438ac9e4a5c72ec0d53e0b
Gitweb: http://git.kernel.org/tip/7cbb7e7fa46f6e5229438ac9e4a5c72ec0d53e0b
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:48 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:47 +0200
x86: Move trigger_all_cpu_backtrace to its own die_notifier
As part of the transition of the nmi watchdog to something more
generic, the trigger_all_cpu_backtrace code is getting left behind.
Put it in its own die_notifier so it can still be used.
V2:
- use arch_spin_locks
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-6-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
arch/x86/kernel/apic/hw_nmi.c | 65 ++++++++++++++++++++++++++++++++---------
1 files changed, 51 insertions(+), 14 deletions(-)
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index 79425f9..8c3edfb 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -17,6 +17,10 @@
#include <linux/cpumask.h>
#include <linux/kernel_stat.h>
#include <asm/mce.h>
+#include <linux/kdebug.h>
+#include <linux/notifier.h>
+#include <linux/kprobes.h>
+
#include <linux/nmi.h>
#include <linux/module.h>
@@ -54,20 +58,6 @@ int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
unsigned int sum;
int cpu = smp_processor_id();
- /* FIXME: cheap hack for this check, probably should get its own
- * die_notifier handler
- */
- if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
- static DEFINE_SPINLOCK(lock); /* Serialise the printks */
-
- spin_lock(&lock);
- printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
- show_regs(regs);
- dump_stack();
- spin_unlock(&lock);
- cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
- }
-
/* if we are doing an mce, just assume the cpu is not stuck */
/* Could check oops_in_progress here too, but it's safer not to */
if (mce_in_progress())
@@ -109,6 +99,53 @@ void arch_trigger_all_cpu_backtrace(void)
mdelay(1);
}
}
+
+static int __kprobes
+arch_trigger_all_cpu_backtrace_handler(struct notifier_block *self,
+ unsigned long cmd, void *__args)
+{
+ struct die_args *args = __args;
+ struct pt_regs *regs;
+ int cpu = smp_processor_id();
+
+ switch (cmd) {
+ case DIE_NMI:
+ case DIE_NMI_IPI:
+ break;
+
+ default:
+ return NOTIFY_DONE;
+ }
+
+ regs = args->regs;
+
+ if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
+ static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED;
+
+ arch_spin_lock(&lock);
+ printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
+ show_regs(regs);
+ dump_stack();
+ arch_spin_unlock(&lock);
+ cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
+ return NOTIFY_STOP;
+ }
+
+ return NOTIFY_DONE;
+}
+
+static __read_mostly struct notifier_block backtrace_notifier = {
+ .notifier_call = arch_trigger_all_cpu_backtrace_handler,
+ .next = NULL,
+ .priority = 1
+};
+
+static int __init register_trigger_all_cpu_backtrace(void)
+{
+ register_die_notifier(&backtrace_notifier);
+ return 0;
+}
+early_initcall(register_trigger_all_cpu_backtrace);
#endif
/* STUB calls to mimic old nmi_watchdog behaviour */
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] x86: Cleanup hw_nmi.c cruft
2010-05-07 21:11 ` [PATCH 6/8] [x86] watchdog: cleanup hw_nmi.c cruft Don Zickus
@ 2010-05-13 6:53 ` tip-bot for Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:53 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: 10f9014912a2b1cb59c39cdea777e6d9afa8f17e
Gitweb: http://git.kernel.org/tip/10f9014912a2b1cb59c39cdea777e6d9afa8f17e
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:49 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:48 +0200
x86: Cleanup hw_nmi.c cruft
The design of the hardlockup watchdog has changed and cruft was left
behind in the hw_nmi.c file. Just remove the code that isn't used
anymore.
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-7-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
arch/x86/kernel/apic/hw_nmi.c | 58 -----------------------------------------
1 files changed, 0 insertions(+), 58 deletions(-)
diff --git a/arch/x86/kernel/apic/hw_nmi.c b/arch/x86/kernel/apic/hw_nmi.c
index 8c3edfb..3b40082 100644
--- a/arch/x86/kernel/apic/hw_nmi.c
+++ b/arch/x86/kernel/apic/hw_nmi.c
@@ -9,74 +9,16 @@
*
*/
-#include <asm/apic.h>
-#include <linux/smp.h>
#include <linux/cpumask.h>
-#include <linux/sched.h>
-#include <linux/percpu.h>
-#include <linux/cpumask.h>
-#include <linux/kernel_stat.h>
-#include <asm/mce.h>
#include <linux/kdebug.h>
#include <linux/notifier.h>
#include <linux/kprobes.h>
-
-
#include <linux/nmi.h>
#include <linux/module.h>
/* For reliability, we're prepared to waste bits here. */
static DECLARE_BITMAP(backtrace_mask, NR_CPUS) __read_mostly;
-static DEFINE_PER_CPU(unsigned, last_irq_sum);
-
-/*
- * Take the local apic timer and PIT/HPET into account. We don't
- * know which one is active, when we have highres/dyntick on
- */
-static inline unsigned int get_timer_irqs(int cpu)
-{
- unsigned int irqs = per_cpu(irq_stat, cpu).irq0_irqs;
-
-#if defined(CONFIG_X86_LOCAL_APIC)
- irqs += per_cpu(irq_stat, cpu).apic_timer_irqs;
-#endif
-
- return irqs;
-}
-
-static inline int mce_in_progress(void)
-{
-#if defined(CONFIG_X86_MCE)
- return atomic_read(&mce_entry) > 0;
-#endif
- return 0;
-}
-
-int hw_nmi_is_cpu_stuck(struct pt_regs *regs)
-{
- unsigned int sum;
- int cpu = smp_processor_id();
-
- /* if we are doing an mce, just assume the cpu is not stuck */
- /* Could check oops_in_progress here too, but it's safer not to */
- if (mce_in_progress())
- return 0;
-
- /* We determine if the cpu is stuck by checking whether any
- * interrupts have happened since we last checked. Of course
- * an nmi storm could create false positives, but the higher
- * level logic should account for that
- */
- sum = get_timer_irqs(cpu);
- if (__get_cpu_var(last_irq_sum) == sum) {
- return 1;
- } else {
- __get_cpu_var(last_irq_sum) = sum;
- return 0;
- }
-}
-
u64 hw_nmi_get_sample_period(void)
{
return (u64)(cpu_khz) * 1000 * 60;
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [tip:perf/nmi] lockup_detector: Separate touch_nmi_watchdog code path from touch_watchdog
2010-05-07 21:11 ` [PATCH 8/8] [watchdog] separate touch_nmi_watchdog code path from touch_watchdog Don Zickus
@ 2010-05-13 6:53 ` tip-bot for Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: tip-bot for Don Zickus @ 2010-05-13 6:53 UTC (permalink / raw
To: linux-tip-commits
Cc: linux-kernel, hpa, mingo, eparis, peterz, randy.dunlap, gorcunov,
fweisbec, tglx, dzickus, mingo
Commit-ID: d7c547335fa6b0090fa09c46ea0e965ac273a27e
Gitweb: http://git.kernel.org/tip/d7c547335fa6b0090fa09c46ea0e965ac273a27e
Author: Don Zickus <dzickus@redhat.com>
AuthorDate: Fri, 7 May 2010 17:11:51 -0400
Committer: Frederic Weisbecker <fweisbec@gmail.com>
CommitDate: Wed, 12 May 2010 23:55:55 +0200
lockup_detector: Separate touch_nmi_watchdog code path from touch_watchdog
When I combined the nmi_watchdog (hardlockup) and softlockup code, I
also combined the paths the touch_watchdog and touch_nmi_watchdog took.
This may not be the best idea as pointed out by Frederic W., that the
touch_watchdog case probably should not reset the hardlockup count.
Therefore the patch below falls back to the previous idea of keeping
the touch_nmi_watchdog a superset of the touch_watchdog case.
Signed-off-by: Don Zickus <dzickus@redhat.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Eric Paris <eparis@redhat.com>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
LKML-Reference: <1273266711-18706-9-git-send-email-dzickus@redhat.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
---
kernel/watchdog.c | 7 ++++---
1 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index f1541b7..57b8e2c 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -31,6 +31,7 @@ int watchdog_enabled;
int __read_mostly softlockup_thresh = 60;
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
+static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
static DEFINE_PER_CPU(bool, softlockup_touch_sync);
@@ -139,6 +140,7 @@ void touch_all_softlockup_watchdogs(void)
void touch_nmi_watchdog(void)
{
+ __get_cpu_var(watchdog_nmi_touch) = true;
touch_softlockup_watchdog();
}
EXPORT_SYMBOL(touch_nmi_watchdog);
@@ -201,10 +203,9 @@ void watchdog_overflow_callback(struct perf_event *event, int nmi,
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();
+ if (__get_cpu_var(watchdog_nmi_touch) == true) {
+ __get_cpu_var(watchdog_nmi_touch) = false;
return;
}
^ permalink raw reply related [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-12 21:50 ` Don Zickus
@ 2010-05-13 15:53 ` Cyrill Gorcunov
2010-05-13 16:04 ` Don Zickus
0 siblings, 1 reply; 27+ messages in thread
From: Cyrill Gorcunov @ 2010-05-13 15:53 UTC (permalink / raw
To: Don Zickus
Cc: Frederic Weisbecker, mingo, peterz, aris, linux-kernel,
randy.dunlap
On Wed, May 12, 2010 at 05:50:15PM -0400, Don Zickus wrote:
...
> > Guys, could you please spend a few minutes and enlighten me a bit?
> > Does all this series mean that we eventually will drop nmi-watchdog
> > via io-apic (read via pic) as only the transition to perf complete?
> >
> > I recall someone said about to stop using io-apic, but just to be sure.
>
> Right, this code sits on top of the perf subsystem which uses lapic.
> Eventually, the old nmi watchdog code will disappear along with the
> support for io-apic.
>
> Cheers,
> Don
>
Thanks for explanation, Don! So I assume (?) that io-apic
nmi-watchdog is going to be dropped due to obsolescense of
this mode, right?
-- Cyrill
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal
2010-05-13 15:53 ` Cyrill Gorcunov
@ 2010-05-13 16:04 ` Don Zickus
0 siblings, 0 replies; 27+ messages in thread
From: Don Zickus @ 2010-05-13 16:04 UTC (permalink / raw
To: Cyrill Gorcunov
Cc: Frederic Weisbecker, mingo, peterz, aris, linux-kernel,
randy.dunlap
On Thu, May 13, 2010 at 07:53:13PM +0400, Cyrill Gorcunov wrote:
> On Wed, May 12, 2010 at 05:50:15PM -0400, Don Zickus wrote:
> ...
> > > Guys, could you please spend a few minutes and enlighten me a bit?
> > > Does all this series mean that we eventually will drop nmi-watchdog
> > > via io-apic (read via pic) as only the transition to perf complete?
> > >
> > > I recall someone said about to stop using io-apic, but just to be sure.
> >
> > Right, this code sits on top of the perf subsystem which uses lapic.
> > Eventually, the old nmi watchdog code will disappear along with the
> > support for io-apic.
> >
> > Cheers,
> > Don
> >
>
> Thanks for explanation, Don! So I assume (?) that io-apic
> nmi-watchdog is going to be dropped due to obsolescense of
> this mode, right?
Well partly. The other part is you can't really confirm an NMI came from
the io-apic or not unlike the lapic (where you can see if it crossed
zero). Therefore under io-apic, all unknown nmis were wrongly being
filtered as nmi watchdog interrupts.
Cheers,
Don
^ permalink raw reply [flat|nested] 27+ messages in thread
end of thread, other threads:[~2010-05-13 16:04 UTC | newest]
Thread overview: 27+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2010-05-07 21:11 [PATCH 0/8] lockup detector changes Don Zickus
2010-05-07 21:11 ` [PATCH 1/8] [watchdog] combine nmi_watchdog and softlockup Don Zickus
2010-05-12 19:55 ` Frederic Weisbecker
2010-05-13 6:51 ` [tip:perf/nmi] lockup_detector: Combine nmi_watchdog and softlockup detector tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 2/8] [nmi watchdog] touch_softlockup cleanups and softlockup_tick removal Don Zickus
2010-05-12 20:06 ` Frederic Weisbecker
2010-05-12 20:26 ` Don Zickus
2010-05-12 20:28 ` Frederic Weisbecker
2010-05-12 20:56 ` Don Zickus
2010-05-12 21:00 ` Frederic Weisbecker
2010-05-12 21:38 ` Cyrill Gorcunov
2010-05-12 21:50 ` Don Zickus
2010-05-13 15:53 ` Cyrill Gorcunov
2010-05-13 16:04 ` Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Touch_softlockup " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 3/8] [watchdog] remove old softlockup code Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Remove " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 4/8] [watchdog] remove nmi_watchdog.c file Don Zickus
2010-05-13 6:52 ` [tip:perf/nmi] lockup_detector: Remove " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] x86: Move " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 6/8] [x86] watchdog: cleanup hw_nmi.c cruft Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] x86: Cleanup " tip-bot for Don Zickus
2010-05-07 21:11 ` [PATCH 7/8] [watchdog] resolve softlockup.c conflicts Don Zickus
2010-05-07 21:11 ` [PATCH 8/8] [watchdog] separate touch_nmi_watchdog code path from touch_watchdog Don Zickus
2010-05-13 6:53 ` [tip:perf/nmi] lockup_detector: Separate " tip-bot for Don Zickus
-- strict thread matches above, loose matches on Subject: below --
2010-04-23 16:13 [PATCH 0/8] lockup detector changes Don Zickus
2010-04-23 16:13 ` [PATCH 5/8] [x86] watchdog: move trigger_all_cpu_backtrace to its own die_notifier Don Zickus
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).