blob: d7ebdf4cea98aa3829ba1ec6a57a67359d6a0c98 [file] [log] [blame]
Don Zickus58687ac2010-05-07 17:11:44 -04001/*
2 * Detect hard and soft lockups on a system
3 *
4 * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
5 *
6 * this code detects hard lockups: incidents in where on a CPU
7 * the kernel does not respond to anything except NMI.
8 *
9 * Note: Most of this code is borrowed heavily from softlockup.c,
10 * so thanks to Ingo for the initial implementation.
11 * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
12 * to those contributors as well.
13 */
14
15#include <linux/mm.h>
16#include <linux/cpu.h>
17#include <linux/nmi.h>
18#include <linux/init.h>
19#include <linux/delay.h>
20#include <linux/freezer.h>
21#include <linux/kthread.h>
22#include <linux/lockdep.h>
23#include <linux/notifier.h>
24#include <linux/module.h>
25#include <linux/sysctl.h>
26
27#include <asm/irq_regs.h>
28#include <linux/perf_event.h>
29
30int watchdog_enabled;
31int __read_mostly softlockup_thresh = 60;
32
33static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
34static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
35static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
36static DEFINE_PER_CPU(bool, softlockup_touch_sync);
Don Zickus58687ac2010-05-07 17:11:44 -040037static DEFINE_PER_CPU(bool, soft_watchdog_warn);
Frederic Weisbecker23637d42010-05-15 23:15:20 +020038#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickuscafcd802010-05-14 11:11:21 -040039static DEFINE_PER_CPU(bool, hard_watchdog_warn);
40static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
Don Zickus58687ac2010-05-07 17:11:44 -040041static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
42static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
43static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
44#endif
45
David Daney433039e2010-11-05 16:17:39 -070046static int no_watchdog;
Don Zickus58687ac2010-05-07 17:11:44 -040047
48
49/* boot commands */
50/*
51 * Should we panic when a soft-lockup or hard-lockup occurs:
52 */
Frederic Weisbecker23637d42010-05-15 23:15:20 +020053#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickus58687ac2010-05-07 17:11:44 -040054static int hardlockup_panic;
55
56static int __init hardlockup_panic_setup(char *str)
57{
58 if (!strncmp(str, "panic", 5))
59 hardlockup_panic = 1;
Don Zickus5dc30552010-11-29 17:07:17 -050060 else if (!strncmp(str, "0", 1))
61 no_watchdog = 1;
Don Zickus58687ac2010-05-07 17:11:44 -040062 return 1;
63}
64__setup("nmi_watchdog=", hardlockup_panic_setup);
65#endif
66
67unsigned int __read_mostly softlockup_panic =
68 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
69
70static int __init softlockup_panic_setup(char *str)
71{
72 softlockup_panic = simple_strtoul(str, NULL, 0);
73
74 return 1;
75}
76__setup("softlockup_panic=", softlockup_panic_setup);
77
78static int __init nowatchdog_setup(char *str)
79{
80 no_watchdog = 1;
81 return 1;
82}
83__setup("nowatchdog", nowatchdog_setup);
84
85/* deprecated */
86static int __init nosoftlockup_setup(char *str)
87{
88 no_watchdog = 1;
89 return 1;
90}
91__setup("nosoftlockup", nosoftlockup_setup);
92/* */
93
94
95/*
96 * Returns seconds, approximately. We don't need nanosecond
97 * resolution, and we don't need to waste time with a big divide when
98 * 2^30ns == 1.074s.
99 */
100static unsigned long get_timestamp(int this_cpu)
101{
102 return cpu_clock(this_cpu) >> 30LL; /* 2^30 ~= 10^9 */
103}
104
105static unsigned long get_sample_period(void)
106{
107 /*
108 * convert softlockup_thresh from seconds to ns
109 * the divide by 5 is to give hrtimer 5 chances to
110 * increment before the hardlockup detector generates
111 * a warning
112 */
113 return softlockup_thresh / 5 * NSEC_PER_SEC;
114}
115
116/* Commands for resetting the watchdog */
117static void __touch_watchdog(void)
118{
Don Zickus26e09c62010-05-17 18:06:04 -0400119 int this_cpu = smp_processor_id();
Don Zickus58687ac2010-05-07 17:11:44 -0400120
Christoph Lameter909ea962010-12-08 16:22:55 +0100121 __this_cpu_write(watchdog_touch_ts, get_timestamp(this_cpu));
Don Zickus58687ac2010-05-07 17:11:44 -0400122}
123
Don Zickus332fbdb2010-05-07 17:11:45 -0400124void touch_softlockup_watchdog(void)
Don Zickus58687ac2010-05-07 17:11:44 -0400125{
Christoph Lameter909ea962010-12-08 16:22:55 +0100126 __this_cpu_write(watchdog_touch_ts, 0);
Don Zickus58687ac2010-05-07 17:11:44 -0400127}
Ingo Molnar0167c782010-05-13 08:53:33 +0200128EXPORT_SYMBOL(touch_softlockup_watchdog);
Don Zickus58687ac2010-05-07 17:11:44 -0400129
Don Zickus332fbdb2010-05-07 17:11:45 -0400130void touch_all_softlockup_watchdogs(void)
Don Zickus58687ac2010-05-07 17:11:44 -0400131{
132 int cpu;
133
134 /*
135 * this is done lockless
136 * do we care if a 0 races with a timestamp?
137 * all it means is the softlock check starts one cycle later
138 */
139 for_each_online_cpu(cpu)
140 per_cpu(watchdog_touch_ts, cpu) = 0;
141}
142
Don Zickuscafcd802010-05-14 11:11:21 -0400143#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickus58687ac2010-05-07 17:11:44 -0400144void touch_nmi_watchdog(void)
145{
Don Zickus68d3f1d2010-08-31 23:00:07 -0400146 if (watchdog_enabled) {
147 unsigned cpu;
148
149 for_each_present_cpu(cpu) {
150 if (per_cpu(watchdog_nmi_touch, cpu) != true)
151 per_cpu(watchdog_nmi_touch, cpu) = true;
152 }
153 }
Don Zickus332fbdb2010-05-07 17:11:45 -0400154 touch_softlockup_watchdog();
Don Zickus58687ac2010-05-07 17:11:44 -0400155}
156EXPORT_SYMBOL(touch_nmi_watchdog);
157
Don Zickuscafcd802010-05-14 11:11:21 -0400158#endif
159
Don Zickus58687ac2010-05-07 17:11:44 -0400160void touch_softlockup_watchdog_sync(void)
161{
162 __raw_get_cpu_var(softlockup_touch_sync) = true;
163 __raw_get_cpu_var(watchdog_touch_ts) = 0;
164}
165
Frederic Weisbecker23637d42010-05-15 23:15:20 +0200166#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickus58687ac2010-05-07 17:11:44 -0400167/* watchdog detector functions */
Don Zickus26e09c62010-05-17 18:06:04 -0400168static int is_hardlockup(void)
Don Zickus58687ac2010-05-07 17:11:44 -0400169{
Christoph Lameter909ea962010-12-08 16:22:55 +0100170 unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
Don Zickus58687ac2010-05-07 17:11:44 -0400171
Christoph Lameter909ea962010-12-08 16:22:55 +0100172 if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
Don Zickus58687ac2010-05-07 17:11:44 -0400173 return 1;
174
Christoph Lameter909ea962010-12-08 16:22:55 +0100175 __this_cpu_write(hrtimer_interrupts_saved, hrint);
Don Zickus58687ac2010-05-07 17:11:44 -0400176 return 0;
177}
178#endif
179
Don Zickus26e09c62010-05-17 18:06:04 -0400180static int is_softlockup(unsigned long touch_ts)
Don Zickus58687ac2010-05-07 17:11:44 -0400181{
Don Zickus26e09c62010-05-17 18:06:04 -0400182 unsigned long now = get_timestamp(smp_processor_id());
Don Zickus58687ac2010-05-07 17:11:44 -0400183
184 /* Warn about unreasonable delays: */
185 if (time_after(now, touch_ts + softlockup_thresh))
186 return now - touch_ts;
187
188 return 0;
189}
190
Frederic Weisbecker23637d42010-05-15 23:15:20 +0200191#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickus58687ac2010-05-07 17:11:44 -0400192static struct perf_event_attr wd_hw_attr = {
193 .type = PERF_TYPE_HARDWARE,
194 .config = PERF_COUNT_HW_CPU_CYCLES,
195 .size = sizeof(struct perf_event_attr),
196 .pinned = 1,
197 .disabled = 1,
198};
199
200/* Callback function for perf event subsystem */
Lin Ming277b1992010-08-20 11:03:51 +0800201static void watchdog_overflow_callback(struct perf_event *event, int nmi,
Don Zickus58687ac2010-05-07 17:11:44 -0400202 struct perf_sample_data *data,
203 struct pt_regs *regs)
204{
Peter Zijlstrac6db67c2010-08-20 11:49:15 +0200205 /* Ensure the watchdog never gets throttled */
206 event->hw.interrupts = 0;
207
Christoph Lameter909ea962010-12-08 16:22:55 +0100208 if (__this_cpu_read(watchdog_nmi_touch) == true) {
209 __this_cpu_write(watchdog_nmi_touch, false);
Don Zickus58687ac2010-05-07 17:11:44 -0400210 return;
211 }
212
213 /* check for a hardlockup
214 * This is done by making sure our timer interrupt
215 * is incrementing. The timer interrupt should have
216 * fired multiple times before we overflow'd. If it hasn't
217 * then this is a good indication the cpu is stuck
218 */
Don Zickus26e09c62010-05-17 18:06:04 -0400219 if (is_hardlockup()) {
220 int this_cpu = smp_processor_id();
221
Don Zickus58687ac2010-05-07 17:11:44 -0400222 /* only print hardlockups once */
Christoph Lameter909ea962010-12-08 16:22:55 +0100223 if (__this_cpu_read(hard_watchdog_warn) == true)
Don Zickus58687ac2010-05-07 17:11:44 -0400224 return;
225
226 if (hardlockup_panic)
227 panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
228 else
229 WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
230
Christoph Lameter909ea962010-12-08 16:22:55 +0100231 __this_cpu_write(hard_watchdog_warn, true);
Don Zickus58687ac2010-05-07 17:11:44 -0400232 return;
233 }
234
Christoph Lameter909ea962010-12-08 16:22:55 +0100235 __this_cpu_write(hard_watchdog_warn, false);
Don Zickus58687ac2010-05-07 17:11:44 -0400236 return;
237}
238static void watchdog_interrupt_count(void)
239{
Christoph Lameter909ea962010-12-08 16:22:55 +0100240 __this_cpu_inc(hrtimer_interrupts);
Don Zickus58687ac2010-05-07 17:11:44 -0400241}
242#else
243static inline void watchdog_interrupt_count(void) { return; }
Frederic Weisbecker23637d42010-05-15 23:15:20 +0200244#endif /* CONFIG_HARDLOCKUP_DETECTOR */
Don Zickus58687ac2010-05-07 17:11:44 -0400245
246/* watchdog kicker functions */
247static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
248{
Christoph Lameter909ea962010-12-08 16:22:55 +0100249 unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);
Don Zickus58687ac2010-05-07 17:11:44 -0400250 struct pt_regs *regs = get_irq_regs();
251 int duration;
252
253 /* kick the hardlockup detector */
254 watchdog_interrupt_count();
255
256 /* kick the softlockup detector */
Christoph Lameter909ea962010-12-08 16:22:55 +0100257 wake_up_process(__this_cpu_read(softlockup_watchdog));
Don Zickus58687ac2010-05-07 17:11:44 -0400258
259 /* .. and repeat */
260 hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
261
262 if (touch_ts == 0) {
Christoph Lameter909ea962010-12-08 16:22:55 +0100263 if (unlikely(__this_cpu_read(softlockup_touch_sync))) {
Don Zickus58687ac2010-05-07 17:11:44 -0400264 /*
265 * If the time stamp was touched atomically
266 * make sure the scheduler tick is up to date.
267 */
Christoph Lameter909ea962010-12-08 16:22:55 +0100268 __this_cpu_write(softlockup_touch_sync, false);
Don Zickus58687ac2010-05-07 17:11:44 -0400269 sched_clock_tick();
270 }
271 __touch_watchdog();
272 return HRTIMER_RESTART;
273 }
274
275 /* check for a softlockup
276 * This is done by making sure a high priority task is
277 * being scheduled. The task touches the watchdog to
278 * indicate it is getting cpu time. If it hasn't then
279 * this is a good indication some task is hogging the cpu
280 */
Don Zickus26e09c62010-05-17 18:06:04 -0400281 duration = is_softlockup(touch_ts);
Don Zickus58687ac2010-05-07 17:11:44 -0400282 if (unlikely(duration)) {
283 /* only warn once */
Christoph Lameter909ea962010-12-08 16:22:55 +0100284 if (__this_cpu_read(soft_watchdog_warn) == true)
Don Zickus58687ac2010-05-07 17:11:44 -0400285 return HRTIMER_RESTART;
286
287 printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
Don Zickus26e09c62010-05-17 18:06:04 -0400288 smp_processor_id(), duration,
Don Zickus58687ac2010-05-07 17:11:44 -0400289 current->comm, task_pid_nr(current));
290 print_modules();
291 print_irqtrace_events(current);
292 if (regs)
293 show_regs(regs);
294 else
295 dump_stack();
296
297 if (softlockup_panic)
298 panic("softlockup: hung tasks");
Christoph Lameter909ea962010-12-08 16:22:55 +0100299 __this_cpu_write(soft_watchdog_warn, true);
Don Zickus58687ac2010-05-07 17:11:44 -0400300 } else
Christoph Lameter909ea962010-12-08 16:22:55 +0100301 __this_cpu_write(soft_watchdog_warn, false);
Don Zickus58687ac2010-05-07 17:11:44 -0400302
303 return HRTIMER_RESTART;
304}
305
306
307/*
308 * The watchdog thread - touches the timestamp.
309 */
Don Zickus26e09c62010-05-17 18:06:04 -0400310static int watchdog(void *unused)
Don Zickus58687ac2010-05-07 17:11:44 -0400311{
KOSAKI Motohirofe7de492010-10-20 16:01:12 -0700312 static struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
Don Zickus26e09c62010-05-17 18:06:04 -0400313 struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer);
Don Zickus58687ac2010-05-07 17:11:44 -0400314
315 sched_setscheduler(current, SCHED_FIFO, &param);
316
317 /* initialize timestamp */
318 __touch_watchdog();
319
320 /* kick off the timer for the hardlockup detector */
321 /* done here because hrtimer_start can only pin to smp_processor_id() */
322 hrtimer_start(hrtimer, ns_to_ktime(get_sample_period()),
323 HRTIMER_MODE_REL_PINNED);
324
325 set_current_state(TASK_INTERRUPTIBLE);
326 /*
327 * Run briefly once per second to reset the softlockup timestamp.
328 * If this gets delayed for more than 60 seconds then the
Don Zickus26e09c62010-05-17 18:06:04 -0400329 * debug-printout triggers in watchdog_timer_fn().
Don Zickus58687ac2010-05-07 17:11:44 -0400330 */
331 while (!kthread_should_stop()) {
332 __touch_watchdog();
333 schedule();
334
335 if (kthread_should_stop())
336 break;
337
338 set_current_state(TASK_INTERRUPTIBLE);
339 }
340 __set_current_state(TASK_RUNNING);
341
342 return 0;
343}
344
345
Frederic Weisbecker23637d42010-05-15 23:15:20 +0200346#ifdef CONFIG_HARDLOCKUP_DETECTOR
Don Zickus58687ac2010-05-07 17:11:44 -0400347static int watchdog_nmi_enable(int cpu)
348{
349 struct perf_event_attr *wd_attr;
350 struct perf_event *event = per_cpu(watchdog_ev, cpu);
351
352 /* is it already setup and enabled? */
353 if (event && event->state > PERF_EVENT_STATE_OFF)
354 goto out;
355
356 /* it is setup but not enabled */
357 if (event != NULL)
358 goto out_enable;
359
360 /* Try to register using hardware perf events */
361 wd_attr = &wd_hw_attr;
362 wd_attr->sample_period = hw_nmi_get_sample_period();
Matt Helsley38a81da2010-09-13 13:01:20 -0700363 event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback);
Don Zickus58687ac2010-05-07 17:11:44 -0400364 if (!IS_ERR(event)) {
365 printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
366 goto out_save;
367 }
368
Ben Hutchings55142372011-01-02 23:02:42 +0000369 printk(KERN_ERR "NMI watchdog disabled for cpu%i: unable to create perf event: %ld\n",
370 cpu, PTR_ERR(event));
Akinobu Mitaeac24332010-08-31 23:00:08 -0400371 return PTR_ERR(event);
Don Zickus58687ac2010-05-07 17:11:44 -0400372
373 /* success path */
374out_save:
375 per_cpu(watchdog_ev, cpu) = event;
376out_enable:
377 perf_event_enable(per_cpu(watchdog_ev, cpu));
378out:
379 return 0;
380}
381
382static void watchdog_nmi_disable(int cpu)
383{
384 struct perf_event *event = per_cpu(watchdog_ev, cpu);
385
386 if (event) {
387 perf_event_disable(event);
388 per_cpu(watchdog_ev, cpu) = NULL;
389
390 /* should be in cleanup, but blocks oprofile */
391 perf_event_release_kernel(event);
392 }
393 return;
394}
395#else
396static int watchdog_nmi_enable(int cpu) { return 0; }
397static void watchdog_nmi_disable(int cpu) { return; }
Frederic Weisbecker23637d42010-05-15 23:15:20 +0200398#endif /* CONFIG_HARDLOCKUP_DETECTOR */
Don Zickus58687ac2010-05-07 17:11:44 -0400399
400/* prepare/enable/disable routines */
401static int watchdog_prepare_cpu(int cpu)
402{
403 struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
404
405 WARN_ON(per_cpu(softlockup_watchdog, cpu));
406 hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
407 hrtimer->function = watchdog_timer_fn;
408
409 return 0;
410}
411
412static int watchdog_enable(int cpu)
413{
414 struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
Akinobu Mitaeac24332010-08-31 23:00:08 -0400415 int err;
Don Zickus58687ac2010-05-07 17:11:44 -0400416
417 /* enable the perf event */
Akinobu Mitaeac24332010-08-31 23:00:08 -0400418 err = watchdog_nmi_enable(cpu);
419 if (err)
420 return err;
Don Zickus58687ac2010-05-07 17:11:44 -0400421
422 /* create the watchdog thread */
423 if (!p) {
424 p = kthread_create(watchdog, (void *)(unsigned long)cpu, "watchdog/%d", cpu);
425 if (IS_ERR(p)) {
426 printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu);
Akinobu Mitaeac24332010-08-31 23:00:08 -0400427 return PTR_ERR(p);
Don Zickus58687ac2010-05-07 17:11:44 -0400428 }
429 kthread_bind(p, cpu);
430 per_cpu(watchdog_touch_ts, cpu) = 0;
431 per_cpu(softlockup_watchdog, cpu) = p;
432 wake_up_process(p);
433 }
434
Don Zickus68d3f1d2010-08-31 23:00:07 -0400435 /* if any cpu succeeds, watchdog is considered enabled for the system */
436 watchdog_enabled = 1;
437
Don Zickus58687ac2010-05-07 17:11:44 -0400438 return 0;
439}
440
441static void watchdog_disable(int cpu)
442{
443 struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
444 struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
445
446 /*
447 * cancel the timer first to stop incrementing the stats
448 * and waking up the kthread
449 */
450 hrtimer_cancel(hrtimer);
451
452 /* disable the perf event */
453 watchdog_nmi_disable(cpu);
454
455 /* stop the watchdog thread */
456 if (p) {
457 per_cpu(softlockup_watchdog, cpu) = NULL;
458 kthread_stop(p);
459 }
Don Zickus58687ac2010-05-07 17:11:44 -0400460}
461
462static void watchdog_enable_all_cpus(void)
463{
464 int cpu;
Kulikov Vasiliyeb703f92010-07-05 12:00:54 +0400465 int result = 0;
Don Zickus58687ac2010-05-07 17:11:44 -0400466
467 for_each_online_cpu(cpu)
468 result += watchdog_enable(cpu);
469
470 if (result)
471 printk(KERN_ERR "watchdog: failed to be enabled on some cpus\n");
472
473}
474
475static void watchdog_disable_all_cpus(void)
476{
477 int cpu;
478
Stephane Eraniand9ca07a2010-09-14 15:34:01 +0200479 if (no_watchdog)
480 return;
481
Don Zickus58687ac2010-05-07 17:11:44 -0400482 for_each_online_cpu(cpu)
483 watchdog_disable(cpu);
484
485 /* if all watchdogs are disabled, then they are disabled for the system */
486 watchdog_enabled = 0;
487}
488
489
490/* sysctl functions */
491#ifdef CONFIG_SYSCTL
492/*
493 * proc handler for /proc/sys/kernel/nmi_watchdog
494 */
495
496int proc_dowatchdog_enabled(struct ctl_table *table, int write,
497 void __user *buffer, size_t *length, loff_t *ppos)
498{
499 proc_dointvec(table, write, buffer, length, ppos);
500
501 if (watchdog_enabled)
502 watchdog_enable_all_cpus();
503 else
504 watchdog_disable_all_cpus();
505 return 0;
506}
507
508int proc_dowatchdog_thresh(struct ctl_table *table, int write,
509 void __user *buffer,
510 size_t *lenp, loff_t *ppos)
511{
512 return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
513}
Don Zickus58687ac2010-05-07 17:11:44 -0400514#endif /* CONFIG_SYSCTL */
515
516
517/*
518 * Create/destroy watchdog threads as CPUs come and go:
519 */
520static int __cpuinit
521cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
522{
523 int hotcpu = (unsigned long)hcpu;
Akinobu Mitaeac24332010-08-31 23:00:08 -0400524 int err = 0;
Don Zickus58687ac2010-05-07 17:11:44 -0400525
526 switch (action) {
527 case CPU_UP_PREPARE:
528 case CPU_UP_PREPARE_FROZEN:
Akinobu Mitaeac24332010-08-31 23:00:08 -0400529 err = watchdog_prepare_cpu(hotcpu);
Don Zickus58687ac2010-05-07 17:11:44 -0400530 break;
531 case CPU_ONLINE:
532 case CPU_ONLINE_FROZEN:
Akinobu Mitaeac24332010-08-31 23:00:08 -0400533 err = watchdog_enable(hotcpu);
Don Zickus58687ac2010-05-07 17:11:44 -0400534 break;
535#ifdef CONFIG_HOTPLUG_CPU
536 case CPU_UP_CANCELED:
537 case CPU_UP_CANCELED_FROZEN:
538 watchdog_disable(hotcpu);
539 break;
540 case CPU_DEAD:
541 case CPU_DEAD_FROZEN:
542 watchdog_disable(hotcpu);
543 break;
544#endif /* CONFIG_HOTPLUG_CPU */
545 }
Akinobu Mitaeac24332010-08-31 23:00:08 -0400546 return notifier_from_errno(err);
Don Zickus58687ac2010-05-07 17:11:44 -0400547}
548
549static struct notifier_block __cpuinitdata cpu_nfb = {
550 .notifier_call = cpu_callback
551};
552
Peter Zijlstra004417a2010-11-25 18:38:29 +0100553void __init lockup_detector_init(void)
Don Zickus58687ac2010-05-07 17:11:44 -0400554{
555 void *cpu = (void *)(long)smp_processor_id();
556 int err;
557
558 if (no_watchdog)
Peter Zijlstra004417a2010-11-25 18:38:29 +0100559 return;
Don Zickus58687ac2010-05-07 17:11:44 -0400560
561 err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
Akinobu Mitaeac24332010-08-31 23:00:08 -0400562 WARN_ON(notifier_to_errno(err));
Don Zickus58687ac2010-05-07 17:11:44 -0400563
564 cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
565 register_cpu_notifier(&cpu_nfb);
566
Peter Zijlstra004417a2010-11-25 18:38:29 +0100567 return;
Don Zickus58687ac2010-05-07 17:11:44 -0400568}