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

TOMOYO Linux Cross Reference
Linux/kernel/watchdog.c

Version: ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Detect hard and soft lockups on a system
  3  *
  4  * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
  5  *
  6  * this code detects hard lockups: incidents in where on a CPU
  7  * the kernel does not respond to anything except NMI.
  8  *
  9  * Note: Most of this code is borrowed heavily from softlockup.c,
 10  * so thanks to Ingo for the initial implementation.
 11  * Some chunks also taken from arch/x86/kernel/apic/nmi.c, thanks
 12  * to those contributors as well.
 13  */
 14 
 15 #include <linux/mm.h>
 16 #include <linux/cpu.h>
 17 #include <linux/nmi.h>
 18 #include <linux/init.h>
 19 #include <linux/delay.h>
 20 #include <linux/freezer.h>
 21 #include <linux/kthread.h>
 22 #include <linux/lockdep.h>
 23 #include <linux/notifier.h>
 24 #include <linux/module.h>
 25 #include <linux/sysctl.h>
 26 
 27 #include <asm/irq_regs.h>
 28 #include <linux/perf_event.h>
 29 
 30 int watchdog_enabled = 1;
 31 int __read_mostly watchdog_thresh = 10;
 32 
 33 static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
 34 static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);
 35 static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
 36 static DEFINE_PER_CPU(bool, softlockup_touch_sync);
 37 static DEFINE_PER_CPU(bool, soft_watchdog_warn);
 38 #ifdef CONFIG_HARDLOCKUP_DETECTOR
 39 static DEFINE_PER_CPU(bool, hard_watchdog_warn);
 40 static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
 41 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
 42 static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
 43 static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
 44 #endif
 45 
 46 /* boot commands */
 47 /*
 48  * Should we panic when a soft-lockup or hard-lockup occurs:
 49  */
 50 #ifdef CONFIG_HARDLOCKUP_DETECTOR
 51 static int hardlockup_panic =
 52                         CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE;
 53 
 54 static int __init hardlockup_panic_setup(char *str)
 55 {
 56         if (!strncmp(str, "panic", 5))
 57                 hardlockup_panic = 1;
 58         else if (!strncmp(str, "nopanic", 7))
 59                 hardlockup_panic = 0;
 60         else if (!strncmp(str, "", 1))
 61                 watchdog_enabled = 0;
 62         return 1;
 63 }
 64 __setup("nmi_watchdog=", hardlockup_panic_setup);
 65 #endif
 66 
 67 unsigned int __read_mostly softlockup_panic =
 68                         CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
 69 
 70 static int __init softlockup_panic_setup(char *str)
 71 {
 72         softlockup_panic = simple_strtoul(str, NULL, 0);
 73 
 74         return 1;
 75 }
 76 __setup("softlockup_panic=", softlockup_panic_setup);
 77 
 78 static int __init nowatchdog_setup(char *str)
 79 {
 80         watchdog_enabled = 0;
 81         return 1;
 82 }
 83 __setup("nowatchdog", nowatchdog_setup);
 84 
 85 /* deprecated */
 86 static int __init nosoftlockup_setup(char *str)
 87 {
 88         watchdog_enabled = 0;
 89         return 1;
 90 }
 91 __setup("nosoftlockup", nosoftlockup_setup);
 92 /*  */
 93 
 94 /*
 95  * Hard-lockup warnings should be triggered after just a few seconds. Soft-
 96  * lockups can have false positives under extreme conditions. So we generally
 97  * want a higher threshold for soft lockups than for hard lockups. So we couple
 98  * the thresholds with a factor: we make the soft threshold twice the amount of
 99  * time the hard threshold is.
100  */
101 static int get_softlockup_thresh(void)
102 {
103         return watchdog_thresh * 2;
104 }
105 
106 /*
107  * Returns seconds, approximately.  We don't need nanosecond
108  * resolution, and we don't need to waste time with a big divide when
109  * 2^30ns == 1.074s.
110  */
111 static unsigned long get_timestamp(int this_cpu)
112 {
113         return cpu_clock(this_cpu) >> 30LL;  /* 2^30 ~= 10^9 */
114 }
115 
116 static u64 get_sample_period(void)
117 {
118         /*
119          * convert watchdog_thresh from seconds to ns
120          * the divide by 5 is to give hrtimer 5 chances to
121          * increment before the hardlockup detector generates
122          * a warning
123          */
124         return get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5);
125 }
126 
127 /* Commands for resetting the watchdog */
128 static void __touch_watchdog(void)
129 {
130         int this_cpu = smp_processor_id();
131 
132         __this_cpu_write(watchdog_touch_ts, get_timestamp(this_cpu));
133 }
134 
135 void touch_softlockup_watchdog(void)
136 {
137         __this_cpu_write(watchdog_touch_ts, 0);
138 }
139 EXPORT_SYMBOL(touch_softlockup_watchdog);
140 
141 void touch_all_softlockup_watchdogs(void)
142 {
143         int cpu;
144 
145         /*
146          * this is done lockless
147          * do we care if a 0 races with a timestamp?
148          * all it means is the softlock check starts one cycle later
149          */
150         for_each_online_cpu(cpu)
151                 per_cpu(watchdog_touch_ts, cpu) = 0;
152 }
153 
154 #ifdef CONFIG_HARDLOCKUP_DETECTOR
155 void touch_nmi_watchdog(void)
156 {
157         if (watchdog_enabled) {
158                 unsigned cpu;
159 
160                 for_each_present_cpu(cpu) {
161                         if (per_cpu(watchdog_nmi_touch, cpu) != true)
162                                 per_cpu(watchdog_nmi_touch, cpu) = true;
163                 }
164         }
165         touch_softlockup_watchdog();
166 }
167 EXPORT_SYMBOL(touch_nmi_watchdog);
168 
169 #endif
170 
171 void touch_softlockup_watchdog_sync(void)
172 {
173         __raw_get_cpu_var(softlockup_touch_sync) = true;
174         __raw_get_cpu_var(watchdog_touch_ts) = 0;
175 }
176 
177 #ifdef CONFIG_HARDLOCKUP_DETECTOR
178 /* watchdog detector functions */
179 static int is_hardlockup(void)
180 {
181         unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
182 
183         if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
184                 return 1;
185 
186         __this_cpu_write(hrtimer_interrupts_saved, hrint);
187         return 0;
188 }
189 #endif
190 
191 static int is_softlockup(unsigned long touch_ts)
192 {
193         unsigned long now = get_timestamp(smp_processor_id());
194 
195         /* Warn about unreasonable delays: */
196         if (time_after(now, touch_ts + get_softlockup_thresh()))
197                 return now - touch_ts;
198 
199         return 0;
200 }
201 
202 #ifdef CONFIG_HARDLOCKUP_DETECTOR
203 static struct perf_event_attr wd_hw_attr = {
204         .type           = PERF_TYPE_HARDWARE,
205         .config         = PERF_COUNT_HW_CPU_CYCLES,
206         .size           = sizeof(struct perf_event_attr),
207         .pinned         = 1,
208         .disabled       = 1,
209 };
210 
211 /* Callback function for perf event subsystem */
212 static void watchdog_overflow_callback(struct perf_event *event, int nmi,
213                  struct perf_sample_data *data,
214                  struct pt_regs *regs)
215 {
216         /* Ensure the watchdog never gets throttled */
217         event->hw.interrupts = 0;
218 
219         if (__this_cpu_read(watchdog_nmi_touch) == true) {
220                 __this_cpu_write(watchdog_nmi_touch, false);
221                 return;
222         }
223 
224         /* check for a hardlockup
225          * This is done by making sure our timer interrupt
226          * is incrementing.  The timer interrupt should have
227          * fired multiple times before we overflow'd.  If it hasn't
228          * then this is a good indication the cpu is stuck
229          */
230         if (is_hardlockup()) {
231                 int this_cpu = smp_processor_id();
232 
233                 /* only print hardlockups once */
234                 if (__this_cpu_read(hard_watchdog_warn) == true)
235                         return;
236 
237                 if (hardlockup_panic)
238                         panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
239                 else
240                         WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
241 
242                 __this_cpu_write(hard_watchdog_warn, true);
243                 return;
244         }
245 
246         __this_cpu_write(hard_watchdog_warn, false);
247         return;
248 }
249 static void watchdog_interrupt_count(void)
250 {
251         __this_cpu_inc(hrtimer_interrupts);
252 }
253 #else
254 static inline void watchdog_interrupt_count(void) { return; }
255 #endif /* CONFIG_HARDLOCKUP_DETECTOR */
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 
264         /* kick the hardlockup detector */
265         watchdog_interrupt_count();
266 
267         /* kick the softlockup detector */
268         wake_up_process(__this_cpu_read(softlockup_watchdog));
269 
270         /* .. and repeat */
271         hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
272 
273         if (touch_ts == 0) {
274                 if (unlikely(__this_cpu_read(softlockup_touch_sync))) {
275                         /*
276                          * If the time stamp was touched atomically
277                          * make sure the scheduler tick is up to date.
278                          */
279                         __this_cpu_write(softlockup_touch_sync, false);
280                         sched_clock_tick();
281                 }
282                 __touch_watchdog();
283                 return HRTIMER_RESTART;
284         }
285 
286         /* check for a softlockup
287          * This is done by making sure a high priority task is
288          * being scheduled.  The task touches the watchdog to
289          * indicate it is getting cpu time.  If it hasn't then
290          * this is a good indication some task is hogging the cpu
291          */
292         duration = is_softlockup(touch_ts);
293         if (unlikely(duration)) {
294                 /* only warn once */
295                 if (__this_cpu_read(soft_watchdog_warn) == true)
296                         return HRTIMER_RESTART;
297 
298                 printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
299                         smp_processor_id(), duration,
300                         current->comm, task_pid_nr(current));
301                 print_modules();
302                 print_irqtrace_events(current);
303                 if (regs)
304                         show_regs(regs);
305                 else
306                         dump_stack();
307 
308                 if (softlockup_panic)
309                         panic("softlockup: hung tasks");
310                 __this_cpu_write(soft_watchdog_warn, true);
311         } else
312                 __this_cpu_write(soft_watchdog_warn, false);
313 
314         return HRTIMER_RESTART;
315 }
316 
317 
318 /*
319  * The watchdog thread - touches the timestamp.
320  */
321 static int watchdog(void *unused)
322 {
323         static struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
324         struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer);
325 
326         sched_setscheduler(current, SCHED_FIFO, &param);
327 
328         /* initialize timestamp */
329         __touch_watchdog();
330 
331         /* kick off the timer for the hardlockup detector */
332         /* done here because hrtimer_start can only pin to smp_processor_id() */
333         hrtimer_start(hrtimer, ns_to_ktime(get_sample_period()),
334                       HRTIMER_MODE_REL_PINNED);
335 
336         set_current_state(TASK_INTERRUPTIBLE);
337         /*
338          * Run briefly once per second to reset the softlockup timestamp.
339          * If this gets delayed for more than 60 seconds then the
340          * debug-printout triggers in watchdog_timer_fn().
341          */
342         while (!kthread_should_stop()) {
343                 __touch_watchdog();
344                 schedule();
345 
346                 if (kthread_should_stop())
347                         break;
348 
349                 set_current_state(TASK_INTERRUPTIBLE);
350         }
351         __set_current_state(TASK_RUNNING);
352 
353         return 0;
354 }
355 
356 
357 #ifdef CONFIG_HARDLOCKUP_DETECTOR
358 static int watchdog_nmi_enable(int cpu)
359 {
360         struct perf_event_attr *wd_attr;
361         struct perf_event *event = per_cpu(watchdog_ev, cpu);
362 
363         /* is it already setup and enabled? */
364         if (event && event->state > PERF_EVENT_STATE_OFF)
365                 goto out;
366 
367         /* it is setup but not enabled */
368         if (event != NULL)
369                 goto out_enable;
370 
371         /* Try to register using hardware perf events */
372         wd_attr = &wd_hw_attr;
373         wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh);
374         event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback);
375         if (!IS_ERR(event)) {
376                 printk(KERN_INFO "NMI watchdog enabled, takes one hw-pmu counter.\n");
377                 goto out_save;
378         }
379 
380 
381         /* vary the KERN level based on the returned errno */
382         if (PTR_ERR(event) == -EOPNOTSUPP)
383                 printk(KERN_INFO "NMI watchdog disabled (cpu%i): not supported (no LAPIC?)\n", cpu);
384         else if (PTR_ERR(event) == -ENOENT)
385                 printk(KERN_WARNING "NMI watchdog disabled (cpu%i): hardware events not enabled\n", cpu);
386         else
387                 printk(KERN_ERR "NMI watchdog disabled (cpu%i): unable to create perf event: %ld\n", cpu, PTR_ERR(event));
388         return PTR_ERR(event);
389 
390         /* success path */
391 out_save:
392         per_cpu(watchdog_ev, cpu) = event;
393 out_enable:
394         perf_event_enable(per_cpu(watchdog_ev, cpu));
395 out:
396         return 0;
397 }
398 
399 static void watchdog_nmi_disable(int cpu)
400 {
401         struct perf_event *event = per_cpu(watchdog_ev, cpu);
402 
403         if (event) {
404                 perf_event_disable(event);
405                 per_cpu(watchdog_ev, cpu) = NULL;
406 
407                 /* should be in cleanup, but blocks oprofile */
408                 perf_event_release_kernel(event);
409         }
410         return;
411 }
412 #else
413 static int watchdog_nmi_enable(int cpu) { return 0; }
414 static void watchdog_nmi_disable(int cpu) { return; }
415 #endif /* CONFIG_HARDLOCKUP_DETECTOR */
416 
417 /* prepare/enable/disable routines */
418 static void watchdog_prepare_cpu(int cpu)
419 {
420         struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
421 
422         WARN_ON(per_cpu(softlockup_watchdog, cpu));
423         hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
424         hrtimer->function = watchdog_timer_fn;
425 }
426 
427 static int watchdog_enable(int cpu)
428 {
429         struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
430         int err = 0;
431 
432         /* enable the perf event */
433         err = watchdog_nmi_enable(cpu);
434 
435         /* Regardless of err above, fall through and start softlockup */
436 
437         /* create the watchdog thread */
438         if (!p) {
439                 p = kthread_create(watchdog, (void *)(unsigned long)cpu, "watchdog/%d", cpu);
440                 if (IS_ERR(p)) {
441                         printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu);
442                         if (!err) {
443                                 /* if hardlockup hasn't already set this */
444                                 err = PTR_ERR(p);
445                                 /* and disable the perf event */
446                                 watchdog_nmi_disable(cpu);
447                         }
448                         goto out;
449                 }
450                 kthread_bind(p, cpu);
451                 per_cpu(watchdog_touch_ts, cpu) = 0;
452                 per_cpu(softlockup_watchdog, cpu) = p;
453                 wake_up_process(p);
454         }
455 
456 out:
457         return err;
458 }
459 
460 static void watchdog_disable(int cpu)
461 {
462         struct task_struct *p = per_cpu(softlockup_watchdog, cpu);
463         struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);
464 
465         /*
466          * cancel the timer first to stop incrementing the stats
467          * and waking up the kthread
468          */
469         hrtimer_cancel(hrtimer);
470 
471         /* disable the perf event */
472         watchdog_nmi_disable(cpu);
473 
474         /* stop the watchdog thread */
475         if (p) {
476                 per_cpu(softlockup_watchdog, cpu) = NULL;
477                 kthread_stop(p);
478         }
479 }
480 
481 static void watchdog_enable_all_cpus(void)
482 {
483         int cpu;
484 
485         watchdog_enabled = 0;
486 
487         for_each_online_cpu(cpu)
488                 if (!watchdog_enable(cpu))
489                         /* if any cpu succeeds, watchdog is considered
490                            enabled for the system */
491                         watchdog_enabled = 1;
492 
493         if (!watchdog_enabled)
494                 printk(KERN_ERR "watchdog: failed to be enabled on some cpus\n");
495 
496 }
497 
498 static void watchdog_disable_all_cpus(void)
499 {
500         int cpu;
501 
502         for_each_online_cpu(cpu)
503                 watchdog_disable(cpu);
504 
505         /* if all watchdogs are disabled, then they are disabled for the system */
506         watchdog_enabled = 0;
507 }
508 
509 
510 /* sysctl functions */
511 #ifdef CONFIG_SYSCTL
512 /*
513  * proc handler for /proc/sys/kernel/nmi_watchdog,watchdog_thresh
514  */
515 
516 int proc_dowatchdog(struct ctl_table *table, int write,
517                     void __user *buffer, size_t *lenp, loff_t *ppos)
518 {
519         int ret;
520 
521         ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
522         if (ret || !write)
523                 goto out;
524 
525         if (watchdog_enabled && watchdog_thresh)
526                 watchdog_enable_all_cpus();
527         else
528                 watchdog_disable_all_cpus();
529 
530 out:
531         return ret;
532 }
533 #endif /* CONFIG_SYSCTL */
534 
535 
536 /*
537  * Create/destroy watchdog threads as CPUs come and go:
538  */
539 static int __cpuinit
540 cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
541 {
542         int hotcpu = (unsigned long)hcpu;
543 
544         switch (action) {
545         case CPU_UP_PREPARE:
546         case CPU_UP_PREPARE_FROZEN:
547                 watchdog_prepare_cpu(hotcpu);
548                 break;
549         case CPU_ONLINE:
550         case CPU_ONLINE_FROZEN:
551                 if (watchdog_enabled)
552                         watchdog_enable(hotcpu);
553                 break;
554 #ifdef CONFIG_HOTPLUG_CPU
555         case CPU_UP_CANCELED:
556         case CPU_UP_CANCELED_FROZEN:
557                 watchdog_disable(hotcpu);
558                 break;
559         case CPU_DEAD:
560         case CPU_DEAD_FROZEN:
561                 watchdog_disable(hotcpu);
562                 break;
563 #endif /* CONFIG_HOTPLUG_CPU */
564         }
565 
566         /*
567          * hardlockup and softlockup are not important enough
568          * to block cpu bring up.  Just always succeed and
569          * rely on printk output to flag problems.
570          */
571         return NOTIFY_OK;
572 }
573 
574 static struct notifier_block __cpuinitdata cpu_nfb = {
575         .notifier_call = cpu_callback
576 };
577 
578 void __init lockup_detector_init(void)
579 {
580         void *cpu = (void *)(long)smp_processor_id();
581         int err;
582 
583         err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
584         WARN_ON(notifier_to_errno(err));
585 
586         cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
587         register_cpu_notifier(&cpu_nfb);
588 
589         return;
590 }
591 

~ [ 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