Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/kernel/watchdog.c

  1 /*
  2  * Detect hard and soft lockups on a system
  3  *
  4  * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
  5  *
  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
  9  * to those contributors as well.
 10  */
 11 
 12 #define pr_fmt(fmt) "NMI watchdog: " fmt
 13 
 14 #include <linux/mm.h>
 15 #include <linux/cpu.h>
 16 #include <linux/nmi.h>
 17 #include <linux/init.h>
 18 #include <linux/module.h>
 19 #include <linux/sysctl.h>
 20 #include <linux/smpboot.h>
 21 #include <linux/sched/rt.h>
 22 #include <linux/tick.h>
 23 #include <linux/workqueue.h>
 24 
 25 #include <asm/irq_regs.h>
 26 #include <linux/kvm_para.h>
 27 #include <linux/kthread.h>
 28 
 29 static DEFINE_MUTEX(watchdog_proc_mutex);
 30 
 31 #if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
 32 unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED|NMI_WATCHDOG_ENABLED;
 33 #else
 34 unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED;
 35 #endif
 36 int __read_mostly nmi_watchdog_enabled;
 37 int __read_mostly soft_watchdog_enabled;
 38 int __read_mostly watchdog_user_enabled;
 39 int __read_mostly watchdog_thresh = 10;
 40 
 41 #ifdef CONFIG_SMP
 42 int __read_mostly sysctl_softlockup_all_cpu_backtrace;
 43 int __read_mostly sysctl_hardlockup_all_cpu_backtrace;
 44 #endif
 45 static struct cpumask watchdog_cpumask __read_mostly;
 46 unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
 47 
 48 /* Helper for online, unparked cpus. */
 49 #define for_each_watchdog_cpu(cpu) \
 50         for_each_cpu_and((cpu), cpu_online_mask, &watchdog_cpumask)
 51 
 52 atomic_t watchdog_park_in_progress = ATOMIC_INIT(0);
 53 
 54 /*
 55  * The 'watchdog_running' variable is set to 1 when the watchdog threads
 56  * are registered/started and is set to 0 when the watchdog threads are
 57  * unregistered/stopped, so it is an indicator whether the threads exist.
 58  */
 59 static int __read_mostly watchdog_running;
 60 /*
 61  * If a subsystem has a need to deactivate the watchdog temporarily, it
 62  * can use the suspend/resume interface to achieve this. The content of
 63  * the 'watchdog_suspended' variable reflects this state. Existing threads
 64  * are parked/unparked by the lockup_detector_{suspend|resume} functions
 65  * (see comment blocks pertaining to those functions for further details).
 66  *
 67  * 'watchdog_suspended' also prevents threads from being registered/started
 68  * or unregistered/stopped via parameters in /proc/sys/kernel, so the state
 69  * of 'watchdog_running' cannot change while the watchdog is deactivated
 70  * temporarily (see related code in 'proc' handlers).
 71  */
 72 static int __read_mostly watchdog_suspended;
 73 
 74 static u64 __read_mostly sample_period;
 75 
 76 static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
 77 static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
 78 static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
 79 static DEFINE_PER_CPU(bool, softlockup_touch_sync);
 80 static DEFINE_PER_CPU(bool, soft_watchdog_warn);
 81 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
 82 static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt);
 83 static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved);
 84 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
 85 static unsigned long soft_lockup_nmi_warn;
 86 
 87 unsigned int __read_mostly softlockup_panic =
 88                         CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
 89 
 90 static int __init softlockup_panic_setup(char *str)
 91 {
 92         softlockup_panic = simple_strtoul(str, NULL, 0);
 93 
 94         return 1;
 95 }
 96 __setup("softlockup_panic=", softlockup_panic_setup);
 97 
 98 static int __init nowatchdog_setup(char *str)
 99 {
100         watchdog_enabled = 0;
101         return 1;
102 }
103 __setup("nowatchdog", nowatchdog_setup);
104 
105 static int __init nosoftlockup_setup(char *str)
106 {
107         watchdog_enabled &= ~SOFT_WATCHDOG_ENABLED;
108         return 1;
109 }
110 __setup("nosoftlockup", nosoftlockup_setup);
111 
112 #ifdef CONFIG_SMP
113 static int __init softlockup_all_cpu_backtrace_setup(char *str)
114 {
115         sysctl_softlockup_all_cpu_backtrace =
116                 !!simple_strtol(str, NULL, 0);
117         return 1;
118 }
119 __setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);
120 static int __init hardlockup_all_cpu_backtrace_setup(char *str)
121 {
122         sysctl_hardlockup_all_cpu_backtrace =
123                 !!simple_strtol(str, NULL, 0);
124         return 1;
125 }
126 __setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup);
127 #endif
128 
129 /*
130  * Hard-lockup warnings should be triggered after just a few seconds. Soft-
131  * lockups can have false positives under extreme conditions. So we generally
132  * want a higher threshold for soft lockups than for hard lockups. So we couple
133  * the thresholds with a factor: we make the soft threshold twice the amount of
134  * time the hard threshold is.
135  */
136 static int get_softlockup_thresh(void)
137 {
138         return watchdog_thresh * 2;
139 }
140 
141 /*
142  * Returns seconds, approximately.  We don't need nanosecond
143  * resolution, and we don't need to waste time with a big divide when
144  * 2^30ns == 1.074s.
145  */
146 static unsigned long get_timestamp(void)
147 {
148         return running_clock() >> 30LL;  /* 2^30 ~= 10^9 */
149 }
150 
151 static void set_sample_period(void)
152 {
153         /*
154          * convert watchdog_thresh from seconds to ns
155          * the divide by 5 is to give hrtimer several chances (two
156          * or three with the current relation between the soft
157          * and hard thresholds) to increment before the
158          * hardlockup detector generates a warning
159          */
160         sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5);
161 }
162 
163 /* Commands for resetting the watchdog */
164 static void __touch_watchdog(void)
165 {
166         __this_cpu_write(watchdog_touch_ts, get_timestamp());
167 }
168 
169 /**
170  * touch_softlockup_watchdog_sched - touch watchdog on scheduler stalls
171  *
172  * Call when the scheduler may have stalled for legitimate reasons
173  * preventing the watchdog task from executing - e.g. the scheduler
174  * entering idle state.  This should only be used for scheduler events.
175  * Use touch_softlockup_watchdog() for everything else.
176  */
177 void touch_softlockup_watchdog_sched(void)
178 {
179         /*
180          * Preemption can be enabled.  It doesn't matter which CPU's timestamp
181          * gets zeroed here, so use the raw_ operation.
182          */
183         raw_cpu_write(watchdog_touch_ts, 0);
184 }
185 
186 void touch_softlockup_watchdog(void)
187 {
188         touch_softlockup_watchdog_sched();
189         wq_watchdog_touch(raw_smp_processor_id());
190 }
191 EXPORT_SYMBOL(touch_softlockup_watchdog);
192 
193 void touch_all_softlockup_watchdogs(void)
194 {
195         int cpu;
196 
197         /*
198          * this is done lockless
199          * do we care if a 0 races with a timestamp?
200          * all it means is the softlock check starts one cycle later
201          */
202         for_each_watchdog_cpu(cpu)
203                 per_cpu(watchdog_touch_ts, cpu) = 0;
204         wq_watchdog_touch(-1);
205 }
206 
207 void touch_softlockup_watchdog_sync(void)
208 {
209         __this_cpu_write(softlockup_touch_sync, true);
210         __this_cpu_write(watchdog_touch_ts, 0);
211 }
212 
213 /* watchdog detector functions */
214 bool is_hardlockup(void)
215 {
216         unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
217 
218         if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
219                 return true;
220 
221         __this_cpu_write(hrtimer_interrupts_saved, hrint);
222         return false;
223 }
224 
225 static int is_softlockup(unsigned long touch_ts)
226 {
227         unsigned long now = get_timestamp();
228 
229         if ((watchdog_enabled & SOFT_WATCHDOG_ENABLED) && watchdog_thresh){
230                 /* Warn about unreasonable delays. */
231                 if (time_after(now, touch_ts + get_softlockup_thresh()))
232                         return now - touch_ts;
233         }
234         return 0;
235 }
236 
237 static void watchdog_interrupt_count(void)
238 {
239         __this_cpu_inc(hrtimer_interrupts);
240 }
241 
242 /*
243  * These two functions are mostly architecture specific
244  * defining them as weak here.
245  */
246 int __weak watchdog_nmi_enable(unsigned int cpu)
247 {
248         return 0;
249 }
250 void __weak watchdog_nmi_disable(unsigned int cpu)
251 {
252 }
253 
254 static int watchdog_enable_all_cpus(void);
255 static void watchdog_disable_all_cpus(void);
256 
257 /* watchdog kicker functions */
258 static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
259 {
260         unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);
261         struct pt_regs *regs = get_irq_regs();
262         int duration;
263         int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;
264 
265         if (atomic_read(&watchdog_park_in_progress) != 0)
266                 return HRTIMER_NORESTART;
267 
268         /* kick the hardlockup detector */
269         watchdog_interrupt_count();
270 
271         /* kick the softlockup detector */
272         wake_up_process(__this_cpu_read(softlockup_watchdog));
273 
274         /* .. and repeat */
275         hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));
276 
277         if (touch_ts == 0) {
278                 if (unlikely(__this_cpu_read(softlockup_touch_sync))) {
279                         /*
280                          * If the time stamp was touched atomically
281                          * make sure the scheduler tick is up to date.
282                          */
283                         __this_cpu_write(softlockup_touch_sync, false);
284                         sched_clock_tick();
285                 }
286 
287                 /* Clear the guest paused flag on watchdog reset */
288                 kvm_check_and_clear_guest_paused();
289                 __touch_watchdog();
290                 return HRTIMER_RESTART;
291         }
292 
293         /* check for a softlockup
294          * This is done by making sure a high priority task is
295          * being scheduled.  The task touches the watchdog to
296          * indicate it is getting cpu time.  If it hasn't then
297          * this is a good indication some task is hogging the cpu
298          */
299         duration = is_softlockup(touch_ts);
300         if (unlikely(duration)) {
301                 /*
302                  * If a virtual machine is stopped by the host it can look to
303                  * the watchdog like a soft lockup, check to see if the host
304                  * stopped the vm before we issue the warning
305                  */
306                 if (kvm_check_and_clear_guest_paused())
307                         return HRTIMER_RESTART;
308 
309                 /* only warn once */
310                 if (__this_cpu_read(soft_watchdog_warn) == true) {
311                         /*
312                          * When multiple processes are causing softlockups the
313                          * softlockup detector only warns on the first one
314                          * because the code relies on a full quiet cycle to
315                          * re-arm.  The second process prevents the quiet cycle
316                          * and never gets reported.  Use task pointers to detect
317                          * this.
318                          */
319                         if (__this_cpu_read(softlockup_task_ptr_saved) !=
320                             current) {
321                                 __this_cpu_write(soft_watchdog_warn, false);
322                                 __touch_watchdog();
323                         }
324                         return HRTIMER_RESTART;
325                 }
326 
327                 if (softlockup_all_cpu_backtrace) {
328                         /* Prevent multiple soft-lockup reports if one cpu is already
329                          * engaged in dumping cpu back traces
330                          */
331                         if (test_and_set_bit(0, &soft_lockup_nmi_warn)) {
332                                 /* Someone else will report us. Let's give up */
333                                 __this_cpu_write(soft_watchdog_warn, true);
334                                 return HRTIMER_RESTART;
335                         }
336                 }
337 
338                 pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
339                         smp_processor_id(), duration,
340                         current->comm, task_pid_nr(current));
341                 __this_cpu_write(softlockup_task_ptr_saved, current);
342                 print_modules();
343                 print_irqtrace_events(current);
344                 if (regs)
345                         show_regs(regs);
346                 else
347                         dump_stack();
348 
349                 if (softlockup_all_cpu_backtrace) {
350                         /* Avoid generating two back traces for current
351                          * given that one is already made above
352                          */
353                         trigger_allbutself_cpu_backtrace();
354 
355                         clear_bit(0, &soft_lockup_nmi_warn);
356                         /* Barrier to sync with other cpus */
357                         smp_mb__after_atomic();
358                 }
359 
360                 add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK);
361                 if (softlockup_panic)
362                         panic("softlockup: hung tasks");
363                 __this_cpu_write(soft_watchdog_warn, true);
364         } else
365                 __this_cpu_write(soft_watchdog_warn, false);
366 
367         return HRTIMER_RESTART;
368 }
369 
370 static void watchdog_set_prio(unsigned int policy, unsigned int prio)
371 {
372         struct sched_param param = { .sched_priority = prio };
373 
374         sched_setscheduler(current, policy, &param);
375 }
376 
377 static void watchdog_enable(unsigned int cpu)
378 {
379         struct hrtimer *hrtimer = raw_cpu_ptr(&watchdog_hrtimer);
380 
381         /* kick off the timer for the hardlockup detector */
382         hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
383         hrtimer->function = watchdog_timer_fn;
384 
385         /* Enable the perf event */
386         watchdog_nmi_enable(cpu);
387 
388         /* done here because hrtimer_start can only pin to smp_processor_id() */
389         hrtimer_start(hrtimer, ns_to_ktime(sample_period),
390                       HRTIMER_MODE_REL_PINNED);
391 
392         /* initialize timestamp */
393         watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1);
394         __touch_watchdog();
395 }
396 
397 static void watchdog_disable(unsigned int cpu)
398 {
399         struct hrtimer *hrtimer = raw_cpu_ptr(&watchdog_hrtimer);
400 
401         watchdog_set_prio(SCHED_NORMAL, 0);
402         hrtimer_cancel(hrtimer);
403         /* disable the perf event */
404         watchdog_nmi_disable(cpu);
405 }
406 
407 static void watchdog_cleanup(unsigned int cpu, bool online)
408 {
409         watchdog_disable(cpu);
410 }
411 
412 static int watchdog_should_run(unsigned int cpu)
413 {
414         return __this_cpu_read(hrtimer_interrupts) !=
415                 __this_cpu_read(soft_lockup_hrtimer_cnt);
416 }
417 
418 /*
419  * The watchdog thread function - touches the timestamp.
420  *
421  * It only runs once every sample_period seconds (4 seconds by
422  * default) to reset the softlockup timestamp. If this gets delayed
423  * for more than 2*watchdog_thresh seconds then the debug-printout
424  * triggers in watchdog_timer_fn().
425  */
426 static void watchdog(unsigned int cpu)
427 {
428         __this_cpu_write(soft_lockup_hrtimer_cnt,
429                          __this_cpu_read(hrtimer_interrupts));
430         __touch_watchdog();
431 
432         /*
433          * watchdog_nmi_enable() clears the NMI_WATCHDOG_ENABLED bit in the
434          * failure path. Check for failures that can occur asynchronously -
435          * for example, when CPUs are on-lined - and shut down the hardware
436          * perf event on each CPU accordingly.
437          *
438          * The only non-obvious place this bit can be cleared is through
439          * watchdog_nmi_enable(), so a pr_info() is placed there.  Placing a
440          * pr_info here would be too noisy as it would result in a message
441          * every few seconds if the hardlockup was disabled but the softlockup
442          * enabled.
443          */
444         if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))
445                 watchdog_nmi_disable(cpu);
446 }
447 
448 static struct smp_hotplug_thread watchdog_threads = {
449         .store                  = &softlockup_watchdog,
450         .thread_should_run      = watchdog_should_run,
451         .thread_fn              = watchdog,
452         .thread_comm            = "watchdog/%u",
453         .setup                  = watchdog_enable,
454         .cleanup                = watchdog_cleanup,
455         .park                   = watchdog_disable,
456         .unpark                 = watchdog_enable,
457 };
458 
459 /*
460  * park all watchdog threads that are specified in 'watchdog_cpumask'
461  *
462  * This function returns an error if kthread_park() of a watchdog thread
463  * fails. In this situation, the watchdog threads of some CPUs can already
464  * be parked and the watchdog threads of other CPUs can still be runnable.
465  * Callers are expected to handle this special condition as appropriate in
466  * their context.
467  *
468  * This function may only be called in a context that is protected against
469  * races with CPU hotplug - for example, via get_online_cpus().
470  */
471 static int watchdog_park_threads(void)
472 {
473         int cpu, ret = 0;
474 
475         atomic_set(&watchdog_park_in_progress, 1);
476 
477         for_each_watchdog_cpu(cpu) {
478                 ret = kthread_park(per_cpu(softlockup_watchdog, cpu));
479                 if (ret)
480                         break;
481         }
482 
483         atomic_set(&watchdog_park_in_progress, 0);
484 
485         return ret;
486 }
487 
488 /*
489  * unpark all watchdog threads that are specified in 'watchdog_cpumask'
490  *
491  * This function may only be called in a context that is protected against
492  * races with CPU hotplug - for example, via get_online_cpus().
493  */
494 static void watchdog_unpark_threads(void)
495 {
496         int cpu;
497 
498         for_each_watchdog_cpu(cpu)
499                 kthread_unpark(per_cpu(softlockup_watchdog, cpu));
500 }
501 
502 /*
503  * Suspend the hard and soft lockup detector by parking the watchdog threads.
504  */
505 int lockup_detector_suspend(void)
506 {
507         int ret = 0;
508 
509         get_online_cpus();
510         mutex_lock(&watchdog_proc_mutex);
511         /*
512          * Multiple suspend requests can be active in parallel (counted by
513          * the 'watchdog_suspended' variable). If the watchdog threads are
514          * running, the first caller takes care that they will be parked.
515          * The state of 'watchdog_running' cannot change while a suspend
516          * request is active (see related code in 'proc' handlers).
517          */
518         if (watchdog_running && !watchdog_suspended)
519                 ret = watchdog_park_threads();
520 
521         if (ret == 0)
522                 watchdog_suspended++;
523         else {
524                 watchdog_disable_all_cpus();
525                 pr_err("Failed to suspend lockup detectors, disabled\n");
526                 watchdog_enabled = 0;
527         }
528 
529         mutex_unlock(&watchdog_proc_mutex);
530 
531         return ret;
532 }
533 
534 /*
535  * Resume the hard and soft lockup detector by unparking the watchdog threads.
536  */
537 void lockup_detector_resume(void)
538 {
539         mutex_lock(&watchdog_proc_mutex);
540 
541         watchdog_suspended--;
542         /*
543          * The watchdog threads are unparked if they were previously running
544          * and if there is no more active suspend request.
545          */
546         if (watchdog_running && !watchdog_suspended)
547                 watchdog_unpark_threads();
548 
549         mutex_unlock(&watchdog_proc_mutex);
550         put_online_cpus();
551 }
552 
553 static int update_watchdog_all_cpus(void)
554 {
555         int ret;
556 
557         ret = watchdog_park_threads();
558         if (ret)
559                 return ret;
560 
561         watchdog_unpark_threads();
562 
563         return 0;
564 }
565 
566 static int watchdog_enable_all_cpus(void)
567 {
568         int err = 0;
569 
570         if (!watchdog_running) {
571                 err = smpboot_register_percpu_thread_cpumask(&watchdog_threads,
572                                                              &watchdog_cpumask);
573                 if (err)
574                         pr_err("Failed to create watchdog threads, disabled\n");
575                 else
576                         watchdog_running = 1;
577         } else {
578                 /*
579                  * Enable/disable the lockup detectors or
580                  * change the sample period 'on the fly'.
581                  */
582                 err = update_watchdog_all_cpus();
583 
584                 if (err) {
585                         watchdog_disable_all_cpus();
586                         pr_err("Failed to update lockup detectors, disabled\n");
587                 }
588         }
589 
590         if (err)
591                 watchdog_enabled = 0;
592 
593         return err;
594 }
595 
596 static void watchdog_disable_all_cpus(void)
597 {
598         if (watchdog_running) {
599                 watchdog_running = 0;
600                 smpboot_unregister_percpu_thread(&watchdog_threads);
601         }
602 }
603 
604 #ifdef CONFIG_SYSCTL
605 
606 /*
607  * Update the run state of the lockup detectors.
608  */
609 static int proc_watchdog_update(void)
610 {
611         int err = 0;
612 
613         /*
614          * Watchdog threads won't be started if they are already active.
615          * The 'watchdog_running' variable in watchdog_*_all_cpus() takes
616          * care of this. If those threads are already active, the sample
617          * period will be updated and the lockup detectors will be enabled
618          * or disabled 'on the fly'.
619          */
620         if (watchdog_enabled && watchdog_thresh)
621                 err = watchdog_enable_all_cpus();
622         else
623                 watchdog_disable_all_cpus();
624 
625         return err;
626 
627 }
628 
629 /*
630  * common function for watchdog, nmi_watchdog and soft_watchdog parameter
631  *
632  * caller             | table->data points to | 'which' contains the flag(s)
633  * -------------------|-----------------------|-----------------------------
634  * proc_watchdog      | watchdog_user_enabled | NMI_WATCHDOG_ENABLED or'ed
635  *                    |                       | with SOFT_WATCHDOG_ENABLED
636  * -------------------|-----------------------|-----------------------------
637  * proc_nmi_watchdog  | nmi_watchdog_enabled  | NMI_WATCHDOG_ENABLED
638  * -------------------|-----------------------|-----------------------------
639  * proc_soft_watchdog | soft_watchdog_enabled | SOFT_WATCHDOG_ENABLED
640  */
641 static int proc_watchdog_common(int which, struct ctl_table *table, int write,
642                                 void __user *buffer, size_t *lenp, loff_t *ppos)
643 {
644         int err, old, new;
645         int *watchdog_param = (int *)table->data;
646 
647         get_online_cpus();
648         mutex_lock(&watchdog_proc_mutex);
649 
650         if (watchdog_suspended) {
651                 /* no parameter changes allowed while watchdog is suspended */
652                 err = -EAGAIN;
653                 goto out;
654         }
655 
656         /*
657          * If the parameter is being read return the state of the corresponding
658          * bit(s) in 'watchdog_enabled', else update 'watchdog_enabled' and the
659          * run state of the lockup detectors.
660          */
661         if (!write) {
662                 *watchdog_param = (watchdog_enabled & which) != 0;
663                 err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
664         } else {
665                 err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
666                 if (err)
667                         goto out;
668 
669                 /*
670                  * There is a race window between fetching the current value
671                  * from 'watchdog_enabled' and storing the new value. During
672                  * this race window, watchdog_nmi_enable() can sneak in and
673                  * clear the NMI_WATCHDOG_ENABLED bit in 'watchdog_enabled'.
674                  * The 'cmpxchg' detects this race and the loop retries.
675                  */
676                 do {
677                         old = watchdog_enabled;
678                         /*
679                          * If the parameter value is not zero set the
680                          * corresponding bit(s), else clear it(them).
681                          */
682                         if (*watchdog_param)
683                                 new = old | which;
684                         else
685                                 new = old & ~which;
686                 } while (cmpxchg(&watchdog_enabled, old, new) != old);
687 
688                 /*
689                  * Update the run state of the lockup detectors. There is _no_
690                  * need to check the value returned by proc_watchdog_update()
691                  * and to restore the previous value of 'watchdog_enabled' as
692                  * both lockup detectors are disabled if proc_watchdog_update()
693                  * returns an error.
694                  */
695                 if (old == new)
696                         goto out;
697 
698                 err = proc_watchdog_update();
699         }
700 out:
701         mutex_unlock(&watchdog_proc_mutex);
702         put_online_cpus();
703         return err;
704 }
705 
706 /*
707  * /proc/sys/kernel/watchdog
708  */
709 int proc_watchdog(struct ctl_table *table, int write,
710                   void __user *buffer, size_t *lenp, loff_t *ppos)
711 {
712         return proc_watchdog_common(NMI_WATCHDOG_ENABLED|SOFT_WATCHDOG_ENABLED,
713                                     table, write, buffer, lenp, ppos);
714 }
715 
716 /*
717  * /proc/sys/kernel/nmi_watchdog
718  */
719 int proc_nmi_watchdog(struct ctl_table *table, int write,
720                       void __user *buffer, size_t *lenp, loff_t *ppos)
721 {
722         return proc_watchdog_common(NMI_WATCHDOG_ENABLED,
723                                     table, write, buffer, lenp, ppos);
724 }
725 
726 /*
727  * /proc/sys/kernel/soft_watchdog
728  */
729 int proc_soft_watchdog(struct ctl_table *table, int write,
730                         void __user *buffer, size_t *lenp, loff_t *ppos)
731 {
732         return proc_watchdog_common(SOFT_WATCHDOG_ENABLED,
733                                     table, write, buffer, lenp, ppos);
734 }
735 
736 /*
737  * /proc/sys/kernel/watchdog_thresh
738  */
739 int proc_watchdog_thresh(struct ctl_table *table, int write,
740                          void __user *buffer, size_t *lenp, loff_t *ppos)
741 {
742         int err, old, new;
743 
744         get_online_cpus();
745         mutex_lock(&watchdog_proc_mutex);
746 
747         if (watchdog_suspended) {
748                 /* no parameter changes allowed while watchdog is suspended */
749                 err = -EAGAIN;
750                 goto out;
751         }
752 
753         old = ACCESS_ONCE(watchdog_thresh);
754         err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
755 
756         if (err || !write)
757                 goto out;
758 
759         /*
760          * Update the sample period. Restore on failure.
761          */
762         new = ACCESS_ONCE(watchdog_thresh);
763         if (old == new)
764                 goto out;
765 
766         set_sample_period();
767         err = proc_watchdog_update();
768         if (err) {
769                 watchdog_thresh = old;
770                 set_sample_period();
771         }
772 out:
773         mutex_unlock(&watchdog_proc_mutex);
774         put_online_cpus();
775         return err;
776 }
777 
778 /*
779  * The cpumask is the mask of possible cpus that the watchdog can run
780  * on, not the mask of cpus it is actually running on.  This allows the
781  * user to specify a mask that will include cpus that have not yet
782  * been brought online, if desired.
783  */
784 int proc_watchdog_cpumask(struct ctl_table *table, int write,
785                           void __user *buffer, size_t *lenp, loff_t *ppos)
786 {
787         int err;
788 
789         get_online_cpus();
790         mutex_lock(&watchdog_proc_mutex);
791 
792         if (watchdog_suspended) {
793                 /* no parameter changes allowed while watchdog is suspended */
794                 err = -EAGAIN;
795                 goto out;
796         }
797 
798         err = proc_do_large_bitmap(table, write, buffer, lenp, ppos);
799         if (!err && write) {
800                 /* Remove impossible cpus to keep sysctl output cleaner. */
801                 cpumask_and(&watchdog_cpumask, &watchdog_cpumask,
802                             cpu_possible_mask);
803 
804                 if (watchdog_running) {
805                         /*
806                          * Failure would be due to being unable to allocate
807                          * a temporary cpumask, so we are likely not in a
808                          * position to do much else to make things better.
809                          */
810                         if (smpboot_update_cpumask_percpu_thread(
811                                     &watchdog_threads, &watchdog_cpumask) != 0)
812                                 pr_err("cpumask update failed\n");
813                 }
814         }
815 out:
816         mutex_unlock(&watchdog_proc_mutex);
817         put_online_cpus();
818         return err;
819 }
820 
821 #endif /* CONFIG_SYSCTL */
822 
823 void __init lockup_detector_init(void)
824 {
825         set_sample_period();
826 
827 #ifdef CONFIG_NO_HZ_FULL
828         if (tick_nohz_full_enabled()) {
829                 pr_info("Disabling watchdog on nohz_full cores by default\n");
830                 cpumask_copy(&watchdog_cpumask, housekeeping_mask);
831         } else
832                 cpumask_copy(&watchdog_cpumask, cpu_possible_mask);
833 #else
834         cpumask_copy(&watchdog_cpumask, cpu_possible_mask);
835 #endif
836 
837         if (watchdog_enabled)
838                 watchdog_enable_all_cpus();
839 }
840 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us