xref: /openbmc/linux/kernel/watchdog.c (revision 6f52b16c5b29b89d92c0e7236f4655dc8491ad70)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Detect hard and soft lockups on a system
4  *
5  * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
6  *
7  * Note: Most of this code is borrowed heavily from the original softlockup
8  * detector, so thanks to Ingo for the initial implementation.
9  * Some chunks also taken from the old x86-specific nmi watchdog code, thanks
10  * to those contributors as well.
11  */
12 
13 #define pr_fmt(fmt) "watchdog: " fmt
14 
15 #include <linux/mm.h>
16 #include <linux/cpu.h>
17 #include <linux/nmi.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/sysctl.h>
21 #include <linux/smpboot.h>
22 #include <linux/sched/rt.h>
23 #include <uapi/linux/sched/types.h>
24 #include <linux/tick.h>
25 #include <linux/workqueue.h>
26 #include <linux/sched/clock.h>
27 #include <linux/sched/debug.h>
28 
29 #include <asm/irq_regs.h>
30 #include <linux/kvm_para.h>
31 #include <linux/kthread.h>
32 
33 static DEFINE_MUTEX(watchdog_mutex);
34 
35 #if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HAVE_NMI_WATCHDOG)
36 # define WATCHDOG_DEFAULT	(SOFT_WATCHDOG_ENABLED | NMI_WATCHDOG_ENABLED)
37 # define NMI_WATCHDOG_DEFAULT	1
38 #else
39 # define WATCHDOG_DEFAULT	(SOFT_WATCHDOG_ENABLED)
40 # define NMI_WATCHDOG_DEFAULT	0
41 #endif
42 
43 unsigned long __read_mostly watchdog_enabled;
44 int __read_mostly watchdog_user_enabled = 1;
45 int __read_mostly nmi_watchdog_user_enabled = NMI_WATCHDOG_DEFAULT;
46 int __read_mostly soft_watchdog_user_enabled = 1;
47 int __read_mostly watchdog_thresh = 10;
48 int __read_mostly nmi_watchdog_available;
49 
50 struct cpumask watchdog_allowed_mask __read_mostly;
51 
52 struct cpumask watchdog_cpumask __read_mostly;
53 unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
54 
55 #ifdef CONFIG_HARDLOCKUP_DETECTOR
56 /*
57  * Should we panic when a soft-lockup or hard-lockup occurs:
58  */
59 unsigned int __read_mostly hardlockup_panic =
60 			CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE;
61 /*
62  * We may not want to enable hard lockup detection by default in all cases,
63  * for example when running the kernel as a guest on a hypervisor. In these
64  * cases this function can be called to disable hard lockup detection. This
65  * function should only be executed once by the boot processor before the
66  * kernel command line parameters are parsed, because otherwise it is not
67  * possible to override this in hardlockup_panic_setup().
68  */
69 void __init hardlockup_detector_disable(void)
70 {
71 	nmi_watchdog_user_enabled = 0;
72 }
73 
74 static int __init hardlockup_panic_setup(char *str)
75 {
76 	if (!strncmp(str, "panic", 5))
77 		hardlockup_panic = 1;
78 	else if (!strncmp(str, "nopanic", 7))
79 		hardlockup_panic = 0;
80 	else if (!strncmp(str, "0", 1))
81 		nmi_watchdog_user_enabled = 0;
82 	else if (!strncmp(str, "1", 1))
83 		nmi_watchdog_user_enabled = 1;
84 	return 1;
85 }
86 __setup("nmi_watchdog=", hardlockup_panic_setup);
87 
88 # ifdef CONFIG_SMP
89 int __read_mostly sysctl_hardlockup_all_cpu_backtrace;
90 
91 static int __init hardlockup_all_cpu_backtrace_setup(char *str)
92 {
93 	sysctl_hardlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0);
94 	return 1;
95 }
96 __setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup);
97 # endif /* CONFIG_SMP */
98 #endif /* CONFIG_HARDLOCKUP_DETECTOR */
99 
100 /*
101  * These functions can be overridden if an architecture implements its
102  * own hardlockup detector.
103  *
104  * watchdog_nmi_enable/disable can be implemented to start and stop when
105  * softlockup watchdog threads start and stop. The arch must select the
106  * SOFTLOCKUP_DETECTOR Kconfig.
107  */
108 int __weak watchdog_nmi_enable(unsigned int cpu)
109 {
110 	hardlockup_detector_perf_enable();
111 	return 0;
112 }
113 
114 void __weak watchdog_nmi_disable(unsigned int cpu)
115 {
116 	hardlockup_detector_perf_disable();
117 }
118 
119 /* Return 0, if a NMI watchdog is available. Error code otherwise */
120 int __weak __init watchdog_nmi_probe(void)
121 {
122 	return hardlockup_detector_perf_init();
123 }
124 
125 /**
126  * watchdog_nmi_stop - Stop the watchdog for reconfiguration
127  *
128  * The reconfiguration steps are:
129  * watchdog_nmi_stop();
130  * update_variables();
131  * watchdog_nmi_start();
132  */
133 void __weak watchdog_nmi_stop(void) { }
134 
135 /**
136  * watchdog_nmi_start - Start the watchdog after reconfiguration
137  *
138  * Counterpart to watchdog_nmi_stop().
139  *
140  * The following variables have been updated in update_variables() and
141  * contain the currently valid configuration:
142  * - watchdog_enabled
143  * - watchdog_thresh
144  * - watchdog_cpumask
145  */
146 void __weak watchdog_nmi_start(void) { }
147 
148 /**
149  * lockup_detector_update_enable - Update the sysctl enable bit
150  *
151  * Caller needs to make sure that the NMI/perf watchdogs are off, so this
152  * can't race with watchdog_nmi_disable().
153  */
154 static void lockup_detector_update_enable(void)
155 {
156 	watchdog_enabled = 0;
157 	if (!watchdog_user_enabled)
158 		return;
159 	if (nmi_watchdog_available && nmi_watchdog_user_enabled)
160 		watchdog_enabled |= NMI_WATCHDOG_ENABLED;
161 	if (soft_watchdog_user_enabled)
162 		watchdog_enabled |= SOFT_WATCHDOG_ENABLED;
163 }
164 
165 #ifdef CONFIG_SOFTLOCKUP_DETECTOR
166 
167 /* Global variables, exported for sysctl */
168 unsigned int __read_mostly softlockup_panic =
169 			CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
170 
171 static bool softlockup_threads_initialized __read_mostly;
172 static u64 __read_mostly sample_period;
173 
174 static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
175 static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
176 static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
177 static DEFINE_PER_CPU(bool, softlockup_touch_sync);
178 static DEFINE_PER_CPU(bool, soft_watchdog_warn);
179 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
180 static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt);
181 static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved);
182 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
183 static unsigned long soft_lockup_nmi_warn;
184 
185 static int __init softlockup_panic_setup(char *str)
186 {
187 	softlockup_panic = simple_strtoul(str, NULL, 0);
188 	return 1;
189 }
190 __setup("softlockup_panic=", softlockup_panic_setup);
191 
192 static int __init nowatchdog_setup(char *str)
193 {
194 	watchdog_user_enabled = 0;
195 	return 1;
196 }
197 __setup("nowatchdog", nowatchdog_setup);
198 
199 static int __init nosoftlockup_setup(char *str)
200 {
201 	soft_watchdog_user_enabled = 0;
202 	return 1;
203 }
204 __setup("nosoftlockup", nosoftlockup_setup);
205 
206 #ifdef CONFIG_SMP
207 int __read_mostly sysctl_softlockup_all_cpu_backtrace;
208 
209 static int __init softlockup_all_cpu_backtrace_setup(char *str)
210 {
211 	sysctl_softlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0);
212 	return 1;
213 }
214 __setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);
215 #endif
216 
217 static void __lockup_detector_cleanup(void);
218 
219 /*
220  * Hard-lockup warnings should be triggered after just a few seconds. Soft-
221  * lockups can have false positives under extreme conditions. So we generally
222  * want a higher threshold for soft lockups than for hard lockups. So we couple
223  * the thresholds with a factor: we make the soft threshold twice the amount of
224  * time the hard threshold is.
225  */
226 static int get_softlockup_thresh(void)
227 {
228 	return watchdog_thresh * 2;
229 }
230 
231 /*
232  * Returns seconds, approximately.  We don't need nanosecond
233  * resolution, and we don't need to waste time with a big divide when
234  * 2^30ns == 1.074s.
235  */
236 static unsigned long get_timestamp(void)
237 {
238 	return running_clock() >> 30LL;  /* 2^30 ~= 10^9 */
239 }
240 
241 static void set_sample_period(void)
242 {
243 	/*
244 	 * convert watchdog_thresh from seconds to ns
245 	 * the divide by 5 is to give hrtimer several chances (two
246 	 * or three with the current relation between the soft
247 	 * and hard thresholds) to increment before the
248 	 * hardlockup detector generates a warning
249 	 */
250 	sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5);
251 	watchdog_update_hrtimer_threshold(sample_period);
252 }
253 
254 /* Commands for resetting the watchdog */
255 static void __touch_watchdog(void)
256 {
257 	__this_cpu_write(watchdog_touch_ts, get_timestamp());
258 }
259 
260 /**
261  * touch_softlockup_watchdog_sched - touch watchdog on scheduler stalls
262  *
263  * Call when the scheduler may have stalled for legitimate reasons
264  * preventing the watchdog task from executing - e.g. the scheduler
265  * entering idle state.  This should only be used for scheduler events.
266  * Use touch_softlockup_watchdog() for everything else.
267  */
268 void touch_softlockup_watchdog_sched(void)
269 {
270 	/*
271 	 * Preemption can be enabled.  It doesn't matter which CPU's timestamp
272 	 * gets zeroed here, so use the raw_ operation.
273 	 */
274 	raw_cpu_write(watchdog_touch_ts, 0);
275 }
276 
277 void touch_softlockup_watchdog(void)
278 {
279 	touch_softlockup_watchdog_sched();
280 	wq_watchdog_touch(raw_smp_processor_id());
281 }
282 EXPORT_SYMBOL(touch_softlockup_watchdog);
283 
284 void touch_all_softlockup_watchdogs(void)
285 {
286 	int cpu;
287 
288 	/*
289 	 * watchdog_mutex cannpt be taken here, as this might be called
290 	 * from (soft)interrupt context, so the access to
291 	 * watchdog_allowed_cpumask might race with a concurrent update.
292 	 *
293 	 * The watchdog time stamp can race against a concurrent real
294 	 * update as well, the only side effect might be a cycle delay for
295 	 * the softlockup check.
296 	 */
297 	for_each_cpu(cpu, &watchdog_allowed_mask)
298 		per_cpu(watchdog_touch_ts, cpu) = 0;
299 	wq_watchdog_touch(-1);
300 }
301 
302 void touch_softlockup_watchdog_sync(void)
303 {
304 	__this_cpu_write(softlockup_touch_sync, true);
305 	__this_cpu_write(watchdog_touch_ts, 0);
306 }
307 
308 static int is_softlockup(unsigned long touch_ts)
309 {
310 	unsigned long now = get_timestamp();
311 
312 	if ((watchdog_enabled & SOFT_WATCHDOG_ENABLED) && watchdog_thresh){
313 		/* Warn about unreasonable delays. */
314 		if (time_after(now, touch_ts + get_softlockup_thresh()))
315 			return now - touch_ts;
316 	}
317 	return 0;
318 }
319 
320 /* watchdog detector functions */
321 bool is_hardlockup(void)
322 {
323 	unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
324 
325 	if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
326 		return true;
327 
328 	__this_cpu_write(hrtimer_interrupts_saved, hrint);
329 	return false;
330 }
331 
332 static void watchdog_interrupt_count(void)
333 {
334 	__this_cpu_inc(hrtimer_interrupts);
335 }
336 
337 /* watchdog kicker functions */
338 static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
339 {
340 	unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);
341 	struct pt_regs *regs = get_irq_regs();
342 	int duration;
343 	int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;
344 
345 	if (!watchdog_enabled)
346 		return HRTIMER_NORESTART;
347 
348 	/* kick the hardlockup detector */
349 	watchdog_interrupt_count();
350 
351 	/* kick the softlockup detector */
352 	wake_up_process(__this_cpu_read(softlockup_watchdog));
353 
354 	/* .. and repeat */
355 	hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));
356 
357 	if (touch_ts == 0) {
358 		if (unlikely(__this_cpu_read(softlockup_touch_sync))) {
359 			/*
360 			 * If the time stamp was touched atomically
361 			 * make sure the scheduler tick is up to date.
362 			 */
363 			__this_cpu_write(softlockup_touch_sync, false);
364 			sched_clock_tick();
365 		}
366 
367 		/* Clear the guest paused flag on watchdog reset */
368 		kvm_check_and_clear_guest_paused();
369 		__touch_watchdog();
370 		return HRTIMER_RESTART;
371 	}
372 
373 	/* check for a softlockup
374 	 * This is done by making sure a high priority task is
375 	 * being scheduled.  The task touches the watchdog to
376 	 * indicate it is getting cpu time.  If it hasn't then
377 	 * this is a good indication some task is hogging the cpu
378 	 */
379 	duration = is_softlockup(touch_ts);
380 	if (unlikely(duration)) {
381 		/*
382 		 * If a virtual machine is stopped by the host it can look to
383 		 * the watchdog like a soft lockup, check to see if the host
384 		 * stopped the vm before we issue the warning
385 		 */
386 		if (kvm_check_and_clear_guest_paused())
387 			return HRTIMER_RESTART;
388 
389 		/* only warn once */
390 		if (__this_cpu_read(soft_watchdog_warn) == true) {
391 			/*
392 			 * When multiple processes are causing softlockups the
393 			 * softlockup detector only warns on the first one
394 			 * because the code relies on a full quiet cycle to
395 			 * re-arm.  The second process prevents the quiet cycle
396 			 * and never gets reported.  Use task pointers to detect
397 			 * this.
398 			 */
399 			if (__this_cpu_read(softlockup_task_ptr_saved) !=
400 			    current) {
401 				__this_cpu_write(soft_watchdog_warn, false);
402 				__touch_watchdog();
403 			}
404 			return HRTIMER_RESTART;
405 		}
406 
407 		if (softlockup_all_cpu_backtrace) {
408 			/* Prevent multiple soft-lockup reports if one cpu is already
409 			 * engaged in dumping cpu back traces
410 			 */
411 			if (test_and_set_bit(0, &soft_lockup_nmi_warn)) {
412 				/* Someone else will report us. Let's give up */
413 				__this_cpu_write(soft_watchdog_warn, true);
414 				return HRTIMER_RESTART;
415 			}
416 		}
417 
418 		pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
419 			smp_processor_id(), duration,
420 			current->comm, task_pid_nr(current));
421 		__this_cpu_write(softlockup_task_ptr_saved, current);
422 		print_modules();
423 		print_irqtrace_events(current);
424 		if (regs)
425 			show_regs(regs);
426 		else
427 			dump_stack();
428 
429 		if (softlockup_all_cpu_backtrace) {
430 			/* Avoid generating two back traces for current
431 			 * given that one is already made above
432 			 */
433 			trigger_allbutself_cpu_backtrace();
434 
435 			clear_bit(0, &soft_lockup_nmi_warn);
436 			/* Barrier to sync with other cpus */
437 			smp_mb__after_atomic();
438 		}
439 
440 		add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK);
441 		if (softlockup_panic)
442 			panic("softlockup: hung tasks");
443 		__this_cpu_write(soft_watchdog_warn, true);
444 	} else
445 		__this_cpu_write(soft_watchdog_warn, false);
446 
447 	return HRTIMER_RESTART;
448 }
449 
450 static void watchdog_set_prio(unsigned int policy, unsigned int prio)
451 {
452 	struct sched_param param = { .sched_priority = prio };
453 
454 	sched_setscheduler(current, policy, &param);
455 }
456 
457 static void watchdog_enable(unsigned int cpu)
458 {
459 	struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);
460 
461 	/*
462 	 * Start the timer first to prevent the NMI watchdog triggering
463 	 * before the timer has a chance to fire.
464 	 */
465 	hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
466 	hrtimer->function = watchdog_timer_fn;
467 	hrtimer_start(hrtimer, ns_to_ktime(sample_period),
468 		      HRTIMER_MODE_REL_PINNED);
469 
470 	/* Initialize timestamp */
471 	__touch_watchdog();
472 	/* Enable the perf event */
473 	if (watchdog_enabled & NMI_WATCHDOG_ENABLED)
474 		watchdog_nmi_enable(cpu);
475 
476 	watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1);
477 }
478 
479 static void watchdog_disable(unsigned int cpu)
480 {
481 	struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);
482 
483 	watchdog_set_prio(SCHED_NORMAL, 0);
484 	/*
485 	 * Disable the perf event first. That prevents that a large delay
486 	 * between disabling the timer and disabling the perf event causes
487 	 * the perf NMI to detect a false positive.
488 	 */
489 	watchdog_nmi_disable(cpu);
490 	hrtimer_cancel(hrtimer);
491 }
492 
493 static void watchdog_cleanup(unsigned int cpu, bool online)
494 {
495 	watchdog_disable(cpu);
496 }
497 
498 static int watchdog_should_run(unsigned int cpu)
499 {
500 	return __this_cpu_read(hrtimer_interrupts) !=
501 		__this_cpu_read(soft_lockup_hrtimer_cnt);
502 }
503 
504 /*
505  * The watchdog thread function - touches the timestamp.
506  *
507  * It only runs once every sample_period seconds (4 seconds by
508  * default) to reset the softlockup timestamp. If this gets delayed
509  * for more than 2*watchdog_thresh seconds then the debug-printout
510  * triggers in watchdog_timer_fn().
511  */
512 static void watchdog(unsigned int cpu)
513 {
514 	__this_cpu_write(soft_lockup_hrtimer_cnt,
515 			 __this_cpu_read(hrtimer_interrupts));
516 	__touch_watchdog();
517 }
518 
519 static struct smp_hotplug_thread watchdog_threads = {
520 	.store			= &softlockup_watchdog,
521 	.thread_should_run	= watchdog_should_run,
522 	.thread_fn		= watchdog,
523 	.thread_comm		= "watchdog/%u",
524 	.setup			= watchdog_enable,
525 	.cleanup		= watchdog_cleanup,
526 	.park			= watchdog_disable,
527 	.unpark			= watchdog_enable,
528 };
529 
530 static void softlockup_update_smpboot_threads(void)
531 {
532 	lockdep_assert_held(&watchdog_mutex);
533 
534 	if (!softlockup_threads_initialized)
535 		return;
536 
537 	smpboot_update_cpumask_percpu_thread(&watchdog_threads,
538 					     &watchdog_allowed_mask);
539 }
540 
541 /* Temporarily park all watchdog threads */
542 static void softlockup_park_all_threads(void)
543 {
544 	cpumask_clear(&watchdog_allowed_mask);
545 	softlockup_update_smpboot_threads();
546 }
547 
548 /* Unpark enabled threads */
549 static void softlockup_unpark_threads(void)
550 {
551 	cpumask_copy(&watchdog_allowed_mask, &watchdog_cpumask);
552 	softlockup_update_smpboot_threads();
553 }
554 
555 static void lockup_detector_reconfigure(void)
556 {
557 	cpus_read_lock();
558 	watchdog_nmi_stop();
559 	softlockup_park_all_threads();
560 	set_sample_period();
561 	lockup_detector_update_enable();
562 	if (watchdog_enabled && watchdog_thresh)
563 		softlockup_unpark_threads();
564 	watchdog_nmi_start();
565 	cpus_read_unlock();
566 	/*
567 	 * Must be called outside the cpus locked section to prevent
568 	 * recursive locking in the perf code.
569 	 */
570 	__lockup_detector_cleanup();
571 }
572 
573 /*
574  * Create the watchdog thread infrastructure and configure the detector(s).
575  *
576  * The threads are not unparked as watchdog_allowed_mask is empty.  When
577  * the threads are sucessfully initialized, take the proper locks and
578  * unpark the threads in the watchdog_cpumask if the watchdog is enabled.
579  */
580 static __init void lockup_detector_setup(void)
581 {
582 	int ret;
583 
584 	/*
585 	 * If sysctl is off and watchdog got disabled on the command line,
586 	 * nothing to do here.
587 	 */
588 	lockup_detector_update_enable();
589 
590 	if (!IS_ENABLED(CONFIG_SYSCTL) &&
591 	    !(watchdog_enabled && watchdog_thresh))
592 		return;
593 
594 	ret = smpboot_register_percpu_thread_cpumask(&watchdog_threads,
595 						     &watchdog_allowed_mask);
596 	if (ret) {
597 		pr_err("Failed to initialize soft lockup detector threads\n");
598 		return;
599 	}
600 
601 	mutex_lock(&watchdog_mutex);
602 	softlockup_threads_initialized = true;
603 	lockup_detector_reconfigure();
604 	mutex_unlock(&watchdog_mutex);
605 }
606 
607 #else /* CONFIG_SOFTLOCKUP_DETECTOR */
608 static inline int watchdog_park_threads(void) { return 0; }
609 static inline void watchdog_unpark_threads(void) { }
610 static inline int watchdog_enable_all_cpus(void) { return 0; }
611 static inline void watchdog_disable_all_cpus(void) { }
612 static void lockup_detector_reconfigure(void)
613 {
614 	cpus_read_lock();
615 	watchdog_nmi_stop();
616 	lockup_detector_update_enable();
617 	watchdog_nmi_start();
618 	cpus_read_unlock();
619 }
620 static inline void lockup_detector_setup(void)
621 {
622 	lockup_detector_reconfigure();
623 }
624 #endif /* !CONFIG_SOFTLOCKUP_DETECTOR */
625 
626 static void __lockup_detector_cleanup(void)
627 {
628 	lockdep_assert_held(&watchdog_mutex);
629 	hardlockup_detector_perf_cleanup();
630 }
631 
632 /**
633  * lockup_detector_cleanup - Cleanup after cpu hotplug or sysctl changes
634  *
635  * Caller must not hold the cpu hotplug rwsem.
636  */
637 void lockup_detector_cleanup(void)
638 {
639 	mutex_lock(&watchdog_mutex);
640 	__lockup_detector_cleanup();
641 	mutex_unlock(&watchdog_mutex);
642 }
643 
644 /**
645  * lockup_detector_soft_poweroff - Interface to stop lockup detector(s)
646  *
647  * Special interface for parisc. It prevents lockup detector warnings from
648  * the default pm_poweroff() function which busy loops forever.
649  */
650 void lockup_detector_soft_poweroff(void)
651 {
652 	watchdog_enabled = 0;
653 }
654 
655 #ifdef CONFIG_SYSCTL
656 
657 /* Propagate any changes to the watchdog threads */
658 static void proc_watchdog_update(void)
659 {
660 	/* Remove impossible cpus to keep sysctl output clean. */
661 	cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask);
662 	lockup_detector_reconfigure();
663 }
664 
665 /*
666  * common function for watchdog, nmi_watchdog and soft_watchdog parameter
667  *
668  * caller             | table->data points to      | 'which'
669  * -------------------|----------------------------|--------------------------
670  * proc_watchdog      | watchdog_user_enabled      | NMI_WATCHDOG_ENABLED |
671  *                    |                            | SOFT_WATCHDOG_ENABLED
672  * -------------------|----------------------------|--------------------------
673  * proc_nmi_watchdog  | nmi_watchdog_user_enabled  | NMI_WATCHDOG_ENABLED
674  * -------------------|----------------------------|--------------------------
675  * proc_soft_watchdog | soft_watchdog_user_enabled | SOFT_WATCHDOG_ENABLED
676  */
677 static int proc_watchdog_common(int which, struct ctl_table *table, int write,
678 				void __user *buffer, size_t *lenp, loff_t *ppos)
679 {
680 	int err, old, *param = table->data;
681 
682 	mutex_lock(&watchdog_mutex);
683 
684 	if (!write) {
685 		/*
686 		 * On read synchronize the userspace interface. This is a
687 		 * racy snapshot.
688 		 */
689 		*param = (watchdog_enabled & which) != 0;
690 		err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
691 	} else {
692 		old = READ_ONCE(*param);
693 		err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
694 		if (!err && old != READ_ONCE(*param))
695 			proc_watchdog_update();
696 	}
697 	mutex_unlock(&watchdog_mutex);
698 	return err;
699 }
700 
701 /*
702  * /proc/sys/kernel/watchdog
703  */
704 int proc_watchdog(struct ctl_table *table, int write,
705 		  void __user *buffer, size_t *lenp, loff_t *ppos)
706 {
707 	return proc_watchdog_common(NMI_WATCHDOG_ENABLED|SOFT_WATCHDOG_ENABLED,
708 				    table, write, buffer, lenp, ppos);
709 }
710 
711 /*
712  * /proc/sys/kernel/nmi_watchdog
713  */
714 int proc_nmi_watchdog(struct ctl_table *table, int write,
715 		      void __user *buffer, size_t *lenp, loff_t *ppos)
716 {
717 	if (!nmi_watchdog_available && write)
718 		return -ENOTSUPP;
719 	return proc_watchdog_common(NMI_WATCHDOG_ENABLED,
720 				    table, write, buffer, lenp, ppos);
721 }
722 
723 /*
724  * /proc/sys/kernel/soft_watchdog
725  */
726 int proc_soft_watchdog(struct ctl_table *table, int write,
727 			void __user *buffer, size_t *lenp, loff_t *ppos)
728 {
729 	return proc_watchdog_common(SOFT_WATCHDOG_ENABLED,
730 				    table, write, buffer, lenp, ppos);
731 }
732 
733 /*
734  * /proc/sys/kernel/watchdog_thresh
735  */
736 int proc_watchdog_thresh(struct ctl_table *table, int write,
737 			 void __user *buffer, size_t *lenp, loff_t *ppos)
738 {
739 	int err, old;
740 
741 	mutex_lock(&watchdog_mutex);
742 
743 	old = READ_ONCE(watchdog_thresh);
744 	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
745 
746 	if (!err && write && old != READ_ONCE(watchdog_thresh))
747 		proc_watchdog_update();
748 
749 	mutex_unlock(&watchdog_mutex);
750 	return err;
751 }
752 
753 /*
754  * The cpumask is the mask of possible cpus that the watchdog can run
755  * on, not the mask of cpus it is actually running on.  This allows the
756  * user to specify a mask that will include cpus that have not yet
757  * been brought online, if desired.
758  */
759 int proc_watchdog_cpumask(struct ctl_table *table, int write,
760 			  void __user *buffer, size_t *lenp, loff_t *ppos)
761 {
762 	int err;
763 
764 	mutex_lock(&watchdog_mutex);
765 
766 	err = proc_do_large_bitmap(table, write, buffer, lenp, ppos);
767 	if (!err && write)
768 		proc_watchdog_update();
769 
770 	mutex_unlock(&watchdog_mutex);
771 	return err;
772 }
773 #endif /* CONFIG_SYSCTL */
774 
775 void __init lockup_detector_init(void)
776 {
777 #ifdef CONFIG_NO_HZ_FULL
778 	if (tick_nohz_full_enabled()) {
779 		pr_info("Disabling watchdog on nohz_full cores by default\n");
780 		cpumask_copy(&watchdog_cpumask, housekeeping_mask);
781 	} else
782 		cpumask_copy(&watchdog_cpumask, cpu_possible_mask);
783 #else
784 	cpumask_copy(&watchdog_cpumask, cpu_possible_mask);
785 #endif
786 
787 	if (!watchdog_nmi_probe())
788 		nmi_watchdog_available = true;
789 	lockup_detector_setup();
790 }
791