Commit | Line | Data |
---|---|---|
58687acb DZ |
1 | /* |
2 | * Detect hard and soft lockups on a system | |
3 | * | |
4 | * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc. | |
5 | * | |
86f5e6a7 FLVC |
6 | * Note: Most of this code is borrowed heavily from the original softlockup |
7 | * detector, so thanks to Ingo for the initial implementation. | |
8 | * Some chunks also taken from the old x86-specific nmi watchdog code, thanks | |
58687acb DZ |
9 | * to those contributors as well. |
10 | */ | |
11 | ||
4501980a AM |
12 | #define pr_fmt(fmt) "NMI watchdog: " fmt |
13 | ||
58687acb DZ |
14 | #include <linux/mm.h> |
15 | #include <linux/cpu.h> | |
16 | #include <linux/nmi.h> | |
17 | #include <linux/init.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/freezer.h> | |
20 | #include <linux/kthread.h> | |
21 | #include <linux/lockdep.h> | |
22 | #include <linux/notifier.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/sysctl.h> | |
bcd951cf | 25 | #include <linux/smpboot.h> |
8bd75c77 | 26 | #include <linux/sched/rt.h> |
58687acb DZ |
27 | |
28 | #include <asm/irq_regs.h> | |
5d1c0f4a | 29 | #include <linux/kvm_para.h> |
58687acb DZ |
30 | #include <linux/perf_event.h> |
31 | ||
4135038a | 32 | int watchdog_enabled = 1; |
4eec42f3 | 33 | int __read_mostly watchdog_thresh = 10; |
bcd951cf | 34 | static int __read_mostly watchdog_disabled; |
0f34c400 | 35 | static u64 __read_mostly sample_period; |
58687acb DZ |
36 | |
37 | static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts); | |
38 | static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog); | |
39 | static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer); | |
40 | static DEFINE_PER_CPU(bool, softlockup_touch_sync); | |
58687acb | 41 | static DEFINE_PER_CPU(bool, soft_watchdog_warn); |
bcd951cf TG |
42 | static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts); |
43 | static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt); | |
23637d47 | 44 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
cafcd80d DZ |
45 | static DEFINE_PER_CPU(bool, hard_watchdog_warn); |
46 | static DEFINE_PER_CPU(bool, watchdog_nmi_touch); | |
58687acb DZ |
47 | static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved); |
48 | static DEFINE_PER_CPU(struct perf_event *, watchdog_ev); | |
49 | #endif | |
50 | ||
58687acb DZ |
51 | /* boot commands */ |
52 | /* | |
53 | * Should we panic when a soft-lockup or hard-lockup occurs: | |
54 | */ | |
23637d47 | 55 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
fef2c9bc DZ |
56 | static int hardlockup_panic = |
57 | CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE; | |
58687acb DZ |
58 | |
59 | static int __init hardlockup_panic_setup(char *str) | |
60 | { | |
61 | if (!strncmp(str, "panic", 5)) | |
62 | hardlockup_panic = 1; | |
fef2c9bc DZ |
63 | else if (!strncmp(str, "nopanic", 7)) |
64 | hardlockup_panic = 0; | |
5dc30558 | 65 | else if (!strncmp(str, "0", 1)) |
4135038a | 66 | watchdog_enabled = 0; |
58687acb DZ |
67 | return 1; |
68 | } | |
69 | __setup("nmi_watchdog=", hardlockup_panic_setup); | |
70 | #endif | |
71 | ||
72 | unsigned int __read_mostly softlockup_panic = | |
73 | CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE; | |
74 | ||
75 | static int __init softlockup_panic_setup(char *str) | |
76 | { | |
77 | softlockup_panic = simple_strtoul(str, NULL, 0); | |
78 | ||
79 | return 1; | |
80 | } | |
81 | __setup("softlockup_panic=", softlockup_panic_setup); | |
82 | ||
83 | static int __init nowatchdog_setup(char *str) | |
84 | { | |
4135038a | 85 | watchdog_enabled = 0; |
58687acb DZ |
86 | return 1; |
87 | } | |
88 | __setup("nowatchdog", nowatchdog_setup); | |
89 | ||
90 | /* deprecated */ | |
91 | static int __init nosoftlockup_setup(char *str) | |
92 | { | |
4135038a | 93 | watchdog_enabled = 0; |
58687acb DZ |
94 | return 1; |
95 | } | |
96 | __setup("nosoftlockup", nosoftlockup_setup); | |
97 | /* */ | |
98 | ||
4eec42f3 MSB |
99 | /* |
100 | * Hard-lockup warnings should be triggered after just a few seconds. Soft- | |
101 | * lockups can have false positives under extreme conditions. So we generally | |
102 | * want a higher threshold for soft lockups than for hard lockups. So we couple | |
103 | * the thresholds with a factor: we make the soft threshold twice the amount of | |
104 | * time the hard threshold is. | |
105 | */ | |
6e9101ae | 106 | static int get_softlockup_thresh(void) |
4eec42f3 MSB |
107 | { |
108 | return watchdog_thresh * 2; | |
109 | } | |
58687acb DZ |
110 | |
111 | /* | |
112 | * Returns seconds, approximately. We don't need nanosecond | |
113 | * resolution, and we don't need to waste time with a big divide when | |
114 | * 2^30ns == 1.074s. | |
115 | */ | |
116 | static unsigned long get_timestamp(int this_cpu) | |
117 | { | |
118 | return cpu_clock(this_cpu) >> 30LL; /* 2^30 ~= 10^9 */ | |
119 | } | |
120 | ||
0f34c400 | 121 | static void set_sample_period(void) |
58687acb DZ |
122 | { |
123 | /* | |
586692a5 | 124 | * convert watchdog_thresh from seconds to ns |
86f5e6a7 FLVC |
125 | * the divide by 5 is to give hrtimer several chances (two |
126 | * or three with the current relation between the soft | |
127 | * and hard thresholds) to increment before the | |
128 | * hardlockup detector generates a warning | |
58687acb | 129 | */ |
0f34c400 | 130 | sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5); |
58687acb DZ |
131 | } |
132 | ||
133 | /* Commands for resetting the watchdog */ | |
134 | static void __touch_watchdog(void) | |
135 | { | |
26e09c6e | 136 | int this_cpu = smp_processor_id(); |
58687acb | 137 | |
909ea964 | 138 | __this_cpu_write(watchdog_touch_ts, get_timestamp(this_cpu)); |
58687acb DZ |
139 | } |
140 | ||
332fbdbc | 141 | void touch_softlockup_watchdog(void) |
58687acb | 142 | { |
909ea964 | 143 | __this_cpu_write(watchdog_touch_ts, 0); |
58687acb | 144 | } |
0167c781 | 145 | EXPORT_SYMBOL(touch_softlockup_watchdog); |
58687acb | 146 | |
332fbdbc | 147 | void touch_all_softlockup_watchdogs(void) |
58687acb DZ |
148 | { |
149 | int cpu; | |
150 | ||
151 | /* | |
152 | * this is done lockless | |
153 | * do we care if a 0 races with a timestamp? | |
154 | * all it means is the softlock check starts one cycle later | |
155 | */ | |
156 | for_each_online_cpu(cpu) | |
157 | per_cpu(watchdog_touch_ts, cpu) = 0; | |
158 | } | |
159 | ||
cafcd80d | 160 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
58687acb DZ |
161 | void touch_nmi_watchdog(void) |
162 | { | |
68d3f1d8 DZ |
163 | if (watchdog_enabled) { |
164 | unsigned cpu; | |
165 | ||
166 | for_each_present_cpu(cpu) { | |
167 | if (per_cpu(watchdog_nmi_touch, cpu) != true) | |
168 | per_cpu(watchdog_nmi_touch, cpu) = true; | |
169 | } | |
170 | } | |
332fbdbc | 171 | touch_softlockup_watchdog(); |
58687acb DZ |
172 | } |
173 | EXPORT_SYMBOL(touch_nmi_watchdog); | |
174 | ||
cafcd80d DZ |
175 | #endif |
176 | ||
58687acb DZ |
177 | void touch_softlockup_watchdog_sync(void) |
178 | { | |
179 | __raw_get_cpu_var(softlockup_touch_sync) = true; | |
180 | __raw_get_cpu_var(watchdog_touch_ts) = 0; | |
181 | } | |
182 | ||
23637d47 | 183 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
58687acb | 184 | /* watchdog detector functions */ |
26e09c6e | 185 | static int is_hardlockup(void) |
58687acb | 186 | { |
909ea964 | 187 | unsigned long hrint = __this_cpu_read(hrtimer_interrupts); |
58687acb | 188 | |
909ea964 | 189 | if (__this_cpu_read(hrtimer_interrupts_saved) == hrint) |
58687acb DZ |
190 | return 1; |
191 | ||
909ea964 | 192 | __this_cpu_write(hrtimer_interrupts_saved, hrint); |
58687acb DZ |
193 | return 0; |
194 | } | |
195 | #endif | |
196 | ||
26e09c6e | 197 | static int is_softlockup(unsigned long touch_ts) |
58687acb | 198 | { |
26e09c6e | 199 | unsigned long now = get_timestamp(smp_processor_id()); |
58687acb DZ |
200 | |
201 | /* Warn about unreasonable delays: */ | |
4eec42f3 | 202 | if (time_after(now, touch_ts + get_softlockup_thresh())) |
58687acb DZ |
203 | return now - touch_ts; |
204 | ||
205 | return 0; | |
206 | } | |
207 | ||
23637d47 | 208 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
1880c4ae | 209 | |
58687acb DZ |
210 | static struct perf_event_attr wd_hw_attr = { |
211 | .type = PERF_TYPE_HARDWARE, | |
212 | .config = PERF_COUNT_HW_CPU_CYCLES, | |
213 | .size = sizeof(struct perf_event_attr), | |
214 | .pinned = 1, | |
215 | .disabled = 1, | |
216 | }; | |
217 | ||
218 | /* Callback function for perf event subsystem */ | |
a8b0ca17 | 219 | static void watchdog_overflow_callback(struct perf_event *event, |
58687acb DZ |
220 | struct perf_sample_data *data, |
221 | struct pt_regs *regs) | |
222 | { | |
c6db67cd PZ |
223 | /* Ensure the watchdog never gets throttled */ |
224 | event->hw.interrupts = 0; | |
225 | ||
909ea964 CL |
226 | if (__this_cpu_read(watchdog_nmi_touch) == true) { |
227 | __this_cpu_write(watchdog_nmi_touch, false); | |
58687acb DZ |
228 | return; |
229 | } | |
230 | ||
231 | /* check for a hardlockup | |
232 | * This is done by making sure our timer interrupt | |
233 | * is incrementing. The timer interrupt should have | |
234 | * fired multiple times before we overflow'd. If it hasn't | |
235 | * then this is a good indication the cpu is stuck | |
236 | */ | |
26e09c6e DZ |
237 | if (is_hardlockup()) { |
238 | int this_cpu = smp_processor_id(); | |
239 | ||
58687acb | 240 | /* only print hardlockups once */ |
909ea964 | 241 | if (__this_cpu_read(hard_watchdog_warn) == true) |
58687acb DZ |
242 | return; |
243 | ||
244 | if (hardlockup_panic) | |
245 | panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu); | |
246 | else | |
247 | WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu); | |
248 | ||
909ea964 | 249 | __this_cpu_write(hard_watchdog_warn, true); |
58687acb DZ |
250 | return; |
251 | } | |
252 | ||
909ea964 | 253 | __this_cpu_write(hard_watchdog_warn, false); |
58687acb DZ |
254 | return; |
255 | } | |
bcd951cf TG |
256 | #endif /* CONFIG_HARDLOCKUP_DETECTOR */ |
257 | ||
58687acb DZ |
258 | static void watchdog_interrupt_count(void) |
259 | { | |
909ea964 | 260 | __this_cpu_inc(hrtimer_interrupts); |
58687acb | 261 | } |
bcd951cf TG |
262 | |
263 | static int watchdog_nmi_enable(unsigned int cpu); | |
264 | static void watchdog_nmi_disable(unsigned int cpu); | |
58687acb DZ |
265 | |
266 | /* watchdog kicker functions */ | |
267 | static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer) | |
268 | { | |
909ea964 | 269 | unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts); |
58687acb DZ |
270 | struct pt_regs *regs = get_irq_regs(); |
271 | int duration; | |
272 | ||
273 | /* kick the hardlockup detector */ | |
274 | watchdog_interrupt_count(); | |
275 | ||
276 | /* kick the softlockup detector */ | |
909ea964 | 277 | wake_up_process(__this_cpu_read(softlockup_watchdog)); |
58687acb DZ |
278 | |
279 | /* .. and repeat */ | |
0f34c400 | 280 | hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period)); |
58687acb DZ |
281 | |
282 | if (touch_ts == 0) { | |
909ea964 | 283 | if (unlikely(__this_cpu_read(softlockup_touch_sync))) { |
58687acb DZ |
284 | /* |
285 | * If the time stamp was touched atomically | |
286 | * make sure the scheduler tick is up to date. | |
287 | */ | |
909ea964 | 288 | __this_cpu_write(softlockup_touch_sync, false); |
58687acb DZ |
289 | sched_clock_tick(); |
290 | } | |
5d1c0f4a EM |
291 | |
292 | /* Clear the guest paused flag on watchdog reset */ | |
293 | kvm_check_and_clear_guest_paused(); | |
58687acb DZ |
294 | __touch_watchdog(); |
295 | return HRTIMER_RESTART; | |
296 | } | |
297 | ||
298 | /* check for a softlockup | |
299 | * This is done by making sure a high priority task is | |
300 | * being scheduled. The task touches the watchdog to | |
301 | * indicate it is getting cpu time. If it hasn't then | |
302 | * this is a good indication some task is hogging the cpu | |
303 | */ | |
26e09c6e | 304 | duration = is_softlockup(touch_ts); |
58687acb | 305 | if (unlikely(duration)) { |
5d1c0f4a EM |
306 | /* |
307 | * If a virtual machine is stopped by the host it can look to | |
308 | * the watchdog like a soft lockup, check to see if the host | |
309 | * stopped the vm before we issue the warning | |
310 | */ | |
311 | if (kvm_check_and_clear_guest_paused()) | |
312 | return HRTIMER_RESTART; | |
313 | ||
58687acb | 314 | /* only warn once */ |
909ea964 | 315 | if (__this_cpu_read(soft_watchdog_warn) == true) |
58687acb DZ |
316 | return HRTIMER_RESTART; |
317 | ||
b0f4c4b3 | 318 | printk(KERN_EMERG "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n", |
26e09c6e | 319 | smp_processor_id(), duration, |
58687acb DZ |
320 | current->comm, task_pid_nr(current)); |
321 | print_modules(); | |
322 | print_irqtrace_events(current); | |
323 | if (regs) | |
324 | show_regs(regs); | |
325 | else | |
326 | dump_stack(); | |
327 | ||
328 | if (softlockup_panic) | |
329 | panic("softlockup: hung tasks"); | |
909ea964 | 330 | __this_cpu_write(soft_watchdog_warn, true); |
58687acb | 331 | } else |
909ea964 | 332 | __this_cpu_write(soft_watchdog_warn, false); |
58687acb DZ |
333 | |
334 | return HRTIMER_RESTART; | |
335 | } | |
336 | ||
bcd951cf TG |
337 | static void watchdog_set_prio(unsigned int policy, unsigned int prio) |
338 | { | |
339 | struct sched_param param = { .sched_priority = prio }; | |
58687acb | 340 | |
bcd951cf TG |
341 | sched_setscheduler(current, policy, ¶m); |
342 | } | |
343 | ||
344 | static void watchdog_enable(unsigned int cpu) | |
58687acb | 345 | { |
26e09c6e | 346 | struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer); |
58687acb | 347 | |
3935e895 BM |
348 | /* kick off the timer for the hardlockup detector */ |
349 | hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); | |
350 | hrtimer->function = watchdog_timer_fn; | |
351 | ||
bcd951cf TG |
352 | if (!watchdog_enabled) { |
353 | kthread_park(current); | |
354 | return; | |
355 | } | |
356 | ||
357 | /* Enable the perf event */ | |
358 | watchdog_nmi_enable(cpu); | |
58687acb | 359 | |
58687acb | 360 | /* done here because hrtimer_start can only pin to smp_processor_id() */ |
0f34c400 | 361 | hrtimer_start(hrtimer, ns_to_ktime(sample_period), |
58687acb DZ |
362 | HRTIMER_MODE_REL_PINNED); |
363 | ||
bcd951cf TG |
364 | /* initialize timestamp */ |
365 | watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1); | |
366 | __touch_watchdog(); | |
367 | } | |
58687acb | 368 | |
bcd951cf TG |
369 | static void watchdog_disable(unsigned int cpu) |
370 | { | |
371 | struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer); | |
58687acb | 372 | |
bcd951cf TG |
373 | watchdog_set_prio(SCHED_NORMAL, 0); |
374 | hrtimer_cancel(hrtimer); | |
375 | /* disable the perf event */ | |
376 | watchdog_nmi_disable(cpu); | |
58687acb DZ |
377 | } |
378 | ||
bcd951cf TG |
379 | static int watchdog_should_run(unsigned int cpu) |
380 | { | |
381 | return __this_cpu_read(hrtimer_interrupts) != | |
382 | __this_cpu_read(soft_lockup_hrtimer_cnt); | |
383 | } | |
384 | ||
385 | /* | |
386 | * The watchdog thread function - touches the timestamp. | |
387 | * | |
0f34c400 | 388 | * It only runs once every sample_period seconds (4 seconds by |
bcd951cf TG |
389 | * default) to reset the softlockup timestamp. If this gets delayed |
390 | * for more than 2*watchdog_thresh seconds then the debug-printout | |
391 | * triggers in watchdog_timer_fn(). | |
392 | */ | |
393 | static void watchdog(unsigned int cpu) | |
394 | { | |
395 | __this_cpu_write(soft_lockup_hrtimer_cnt, | |
396 | __this_cpu_read(hrtimer_interrupts)); | |
397 | __touch_watchdog(); | |
398 | } | |
58687acb | 399 | |
23637d47 | 400 | #ifdef CONFIG_HARDLOCKUP_DETECTOR |
a7027046 DZ |
401 | /* |
402 | * People like the simple clean cpu node info on boot. | |
403 | * Reduce the watchdog noise by only printing messages | |
404 | * that are different from what cpu0 displayed. | |
405 | */ | |
406 | static unsigned long cpu0_err; | |
407 | ||
bcd951cf | 408 | static int watchdog_nmi_enable(unsigned int cpu) |
58687acb DZ |
409 | { |
410 | struct perf_event_attr *wd_attr; | |
411 | struct perf_event *event = per_cpu(watchdog_ev, cpu); | |
412 | ||
413 | /* is it already setup and enabled? */ | |
414 | if (event && event->state > PERF_EVENT_STATE_OFF) | |
415 | goto out; | |
416 | ||
417 | /* it is setup but not enabled */ | |
418 | if (event != NULL) | |
419 | goto out_enable; | |
420 | ||
58687acb | 421 | wd_attr = &wd_hw_attr; |
4eec42f3 | 422 | wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh); |
1880c4ae CG |
423 | |
424 | /* Try to register using hardware perf events */ | |
4dc0da86 | 425 | event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback, NULL); |
a7027046 DZ |
426 | |
427 | /* save cpu0 error for future comparision */ | |
428 | if (cpu == 0 && IS_ERR(event)) | |
429 | cpu0_err = PTR_ERR(event); | |
430 | ||
58687acb | 431 | if (!IS_ERR(event)) { |
a7027046 DZ |
432 | /* only print for cpu0 or different than cpu0 */ |
433 | if (cpu == 0 || cpu0_err) | |
434 | pr_info("enabled on all CPUs, permanently consumes one hw-PMU counter.\n"); | |
58687acb DZ |
435 | goto out_save; |
436 | } | |
437 | ||
a7027046 DZ |
438 | /* skip displaying the same error again */ |
439 | if (cpu > 0 && (PTR_ERR(event) == cpu0_err)) | |
440 | return PTR_ERR(event); | |
5651f7f4 DZ |
441 | |
442 | /* vary the KERN level based on the returned errno */ | |
443 | if (PTR_ERR(event) == -EOPNOTSUPP) | |
4501980a | 444 | pr_info("disabled (cpu%i): not supported (no LAPIC?)\n", cpu); |
5651f7f4 | 445 | else if (PTR_ERR(event) == -ENOENT) |
4501980a AM |
446 | pr_warning("disabled (cpu%i): hardware events not enabled\n", |
447 | cpu); | |
5651f7f4 | 448 | else |
4501980a AM |
449 | pr_err("disabled (cpu%i): unable to create perf event: %ld\n", |
450 | cpu, PTR_ERR(event)); | |
eac24335 | 451 | return PTR_ERR(event); |
58687acb DZ |
452 | |
453 | /* success path */ | |
454 | out_save: | |
455 | per_cpu(watchdog_ev, cpu) = event; | |
456 | out_enable: | |
457 | perf_event_enable(per_cpu(watchdog_ev, cpu)); | |
458 | out: | |
459 | return 0; | |
460 | } | |
461 | ||
bcd951cf | 462 | static void watchdog_nmi_disable(unsigned int cpu) |
58687acb DZ |
463 | { |
464 | struct perf_event *event = per_cpu(watchdog_ev, cpu); | |
465 | ||
466 | if (event) { | |
467 | perf_event_disable(event); | |
468 | per_cpu(watchdog_ev, cpu) = NULL; | |
469 | ||
470 | /* should be in cleanup, but blocks oprofile */ | |
471 | perf_event_release_kernel(event); | |
472 | } | |
473 | return; | |
474 | } | |
475 | #else | |
bcd951cf TG |
476 | static int watchdog_nmi_enable(unsigned int cpu) { return 0; } |
477 | static void watchdog_nmi_disable(unsigned int cpu) { return; } | |
23637d47 | 478 | #endif /* CONFIG_HARDLOCKUP_DETECTOR */ |
58687acb DZ |
479 | |
480 | /* prepare/enable/disable routines */ | |
4ff81951 VA |
481 | /* sysctl functions */ |
482 | #ifdef CONFIG_SYSCTL | |
58687acb DZ |
483 | static void watchdog_enable_all_cpus(void) |
484 | { | |
bcd951cf | 485 | unsigned int cpu; |
58687acb | 486 | |
bcd951cf TG |
487 | if (watchdog_disabled) { |
488 | watchdog_disabled = 0; | |
489 | for_each_online_cpu(cpu) | |
490 | kthread_unpark(per_cpu(softlockup_watchdog, cpu)); | |
491 | } | |
58687acb DZ |
492 | } |
493 | ||
494 | static void watchdog_disable_all_cpus(void) | |
495 | { | |
bcd951cf | 496 | unsigned int cpu; |
58687acb | 497 | |
bcd951cf TG |
498 | if (!watchdog_disabled) { |
499 | watchdog_disabled = 1; | |
500 | for_each_online_cpu(cpu) | |
501 | kthread_park(per_cpu(softlockup_watchdog, cpu)); | |
502 | } | |
58687acb DZ |
503 | } |
504 | ||
58687acb | 505 | /* |
586692a5 | 506 | * proc handler for /proc/sys/kernel/nmi_watchdog,watchdog_thresh |
58687acb DZ |
507 | */ |
508 | ||
586692a5 MSB |
509 | int proc_dowatchdog(struct ctl_table *table, int write, |
510 | void __user *buffer, size_t *lenp, loff_t *ppos) | |
58687acb | 511 | { |
e04ab2bc | 512 | int ret; |
58687acb | 513 | |
bcd951cf TG |
514 | if (watchdog_disabled < 0) |
515 | return -ENODEV; | |
516 | ||
586692a5 | 517 | ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); |
e04ab2bc | 518 | if (ret || !write) |
bcd951cf | 519 | return ret; |
e04ab2bc | 520 | |
0f34c400 | 521 | set_sample_period(); |
586692a5 | 522 | if (watchdog_enabled && watchdog_thresh) |
e04ab2bc MSB |
523 | watchdog_enable_all_cpus(); |
524 | else | |
525 | watchdog_disable_all_cpus(); | |
526 | ||
e04ab2bc | 527 | return ret; |
58687acb | 528 | } |
58687acb DZ |
529 | #endif /* CONFIG_SYSCTL */ |
530 | ||
bcd951cf TG |
531 | static struct smp_hotplug_thread watchdog_threads = { |
532 | .store = &softlockup_watchdog, | |
533 | .thread_should_run = watchdog_should_run, | |
534 | .thread_fn = watchdog, | |
535 | .thread_comm = "watchdog/%u", | |
536 | .setup = watchdog_enable, | |
537 | .park = watchdog_disable, | |
538 | .unpark = watchdog_enable, | |
58687acb DZ |
539 | }; |
540 | ||
004417a6 | 541 | void __init lockup_detector_init(void) |
58687acb | 542 | { |
0f34c400 | 543 | set_sample_period(); |
bcd951cf TG |
544 | if (smpboot_register_percpu_thread(&watchdog_threads)) { |
545 | pr_err("Failed to create watchdog threads, disabled\n"); | |
546 | watchdog_disabled = -ENODEV; | |
547 | } | |
58687acb | 548 | } |