~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/watchdog.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp