2 * NMI watchdog support on APIC systems
4 * Started by Ingo Molnar <mingo@redhat.com>
7 * Mikael Pettersson : AMD K7 support for local APIC NMI watchdog.
8 * Mikael Pettersson : Power Management for local APIC NMI watchdog.
9 * Mikael Pettersson : Pentium 4 support for local APIC NMI watchdog.
11 * Mikael Pettersson : PM converted to driver model. Disable/enable API.
16 #include <linux/nmi.h>
18 #include <linux/delay.h>
19 #include <linux/interrupt.h>
20 #include <linux/module.h>
21 #include <linux/sysdev.h>
22 #include <linux/sysctl.h>
23 #include <linux/percpu.h>
24 #include <linux/kprobes.h>
25 #include <linux/cpumask.h>
26 #include <linux/kernel_stat.h>
27 #include <linux/kdebug.h>
28 #include <linux/smp.h>
30 #include <asm/i8259.h>
31 #include <asm/io_apic.h>
32 #include <asm/proto.h>
33 #include <asm/timer.h>
37 #include <asm/mach_traps.h>
39 int unknown_nmi_panic
;
40 int nmi_watchdog_enabled
;
42 /* For reliability, we're prepared to waste bits here. */
43 static DECLARE_BITMAP(backtrace_mask
, NR_CPUS
) __read_mostly
;
46 * >0: the lapic NMI watchdog is active, but can be disabled
47 * <0: the lapic NMI watchdog has not been set up, and cannot
49 * 0: the lapic NMI watchdog is disabled, but can be enabled
51 atomic_t nmi_active
= ATOMIC_INIT(0); /* oprofile uses this */
52 EXPORT_SYMBOL(nmi_active
);
54 unsigned int nmi_watchdog
= NMI_NONE
;
55 EXPORT_SYMBOL(nmi_watchdog
);
57 static int panic_on_timeout
;
59 static unsigned int nmi_hz
= HZ
;
60 static DEFINE_PER_CPU(short, wd_enabled
);
61 static int endflag __initdata
;
63 static inline unsigned int get_nmi_count(int cpu
)
65 return per_cpu(irq_stat
, cpu
).__nmi_count
;
68 static inline int mce_in_progress(void)
70 #if defined(CONFIG_X86_MCE)
71 return atomic_read(&mce_entry
) > 0;
77 * Take the local apic timer and PIT/HPET into account. We don't
78 * know which one is active, when we have highres/dyntick on
80 static inline unsigned int get_timer_irqs(int cpu
)
82 return per_cpu(irq_stat
, cpu
).apic_timer_irqs
+
83 per_cpu(irq_stat
, cpu
).irq0_irqs
;
88 * The performance counters used by NMI_LOCAL_APIC don't trigger when
89 * the CPU is idle. To make sure the NMI watchdog really ticks on all
90 * CPUs during the test make them busy.
92 static __init
void nmi_cpu_busy(void *data
)
94 local_irq_enable_in_hardirq();
96 * Intentionally don't use cpu_relax here. This is
97 * to make sure that the performance counter really ticks,
98 * even if there is a simulator or similar that catches the
99 * pause instruction. On a real HT machine this is fine because
100 * all other CPUs are busy with "useless" delay loops and don't
101 * care if they get somewhat less cycles.
108 static void report_broken_nmi(int cpu
, unsigned int *prev_nmi_count
)
110 printk(KERN_CONT
"\n");
113 "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n",
114 cpu
, prev_nmi_count
[cpu
], get_nmi_count(cpu
));
117 "Please report this to bugzilla.kernel.org,\n");
119 "and attach the output of the 'dmesg' command.\n");
121 per_cpu(wd_enabled
, cpu
) = 0;
122 atomic_dec(&nmi_active
);
125 static void __acpi_nmi_disable(void *__unused
)
127 apic_write(APIC_LVT0
, APIC_DM_NMI
| APIC_LVT_MASKED
);
130 int __init
check_nmi_watchdog(void)
132 unsigned int *prev_nmi_count
;
135 if (!nmi_watchdog_active() || !atomic_read(&nmi_active
))
138 prev_nmi_count
= kmalloc(nr_cpu_ids
* sizeof(int), GFP_KERNEL
);
142 printk(KERN_INFO
"Testing NMI watchdog ... ");
145 if (nmi_watchdog
== NMI_LOCAL_APIC
)
146 smp_call_function(nmi_cpu_busy
, (void *)&endflag
, 0);
149 for_each_possible_cpu(cpu
)
150 prev_nmi_count
[cpu
] = get_nmi_count(cpu
);
152 mdelay((20 * 1000) / nmi_hz
); /* wait 20 ticks */
154 for_each_online_cpu(cpu
) {
155 if (!per_cpu(wd_enabled
, cpu
))
157 if (get_nmi_count(cpu
) - prev_nmi_count
[cpu
] <= 5)
158 report_broken_nmi(cpu
, prev_nmi_count
);
161 if (!atomic_read(&nmi_active
)) {
162 kfree(prev_nmi_count
);
163 atomic_set(&nmi_active
, -1);
169 * now that we know it works we can reduce NMI frequency to
170 * something more reasonable; makes a difference in some configs
172 if (nmi_watchdog
== NMI_LOCAL_APIC
)
173 nmi_hz
= lapic_adjust_nmi_hz(1);
175 kfree(prev_nmi_count
);
178 if (nmi_watchdog
== NMI_IO_APIC
) {
179 if (!timer_through_8259
)
180 legacy_pic
->chip
->mask(0);
181 on_each_cpu(__acpi_nmi_disable
, NULL
, 1);
190 static int __init
setup_nmi_watchdog(char *str
)
194 if (!strncmp(str
, "panic", 5)) {
195 panic_on_timeout
= 1;
196 str
= strchr(str
, ',');
202 if (!strncmp(str
, "lapic", 5))
203 nmi_watchdog
= NMI_LOCAL_APIC
;
204 else if (!strncmp(str
, "ioapic", 6))
205 nmi_watchdog
= NMI_IO_APIC
;
207 get_option(&str
, &nmi
);
208 if (nmi
>= NMI_INVALID
)
215 __setup("nmi_watchdog=", setup_nmi_watchdog
);
218 * Suspend/resume support
222 static int nmi_pm_active
; /* nmi_active before suspend */
224 static int lapic_nmi_suspend(struct sys_device
*dev
, pm_message_t state
)
226 /* only CPU0 goes here, other CPUs should be offline */
227 nmi_pm_active
= atomic_read(&nmi_active
);
228 stop_apic_nmi_watchdog(NULL
);
229 BUG_ON(atomic_read(&nmi_active
) != 0);
233 static int lapic_nmi_resume(struct sys_device
*dev
)
235 /* only CPU0 goes here, other CPUs should be offline */
236 if (nmi_pm_active
> 0) {
237 setup_apic_nmi_watchdog(NULL
);
238 touch_nmi_watchdog();
243 static struct sysdev_class nmi_sysclass
= {
245 .resume
= lapic_nmi_resume
,
246 .suspend
= lapic_nmi_suspend
,
249 static struct sys_device device_lapic_nmi
= {
251 .cls
= &nmi_sysclass
,
254 static int __init
init_lapic_nmi_sysfs(void)
259 * should really be a BUG_ON but b/c this is an
260 * init call, it just doesn't work. -dcz
262 if (nmi_watchdog
!= NMI_LOCAL_APIC
)
265 if (atomic_read(&nmi_active
) < 0)
268 error
= sysdev_class_register(&nmi_sysclass
);
270 error
= sysdev_register(&device_lapic_nmi
);
274 /* must come after the local APIC's device_initcall() */
275 late_initcall(init_lapic_nmi_sysfs
);
277 #endif /* CONFIG_PM */
279 static void __acpi_nmi_enable(void *__unused
)
281 apic_write(APIC_LVT0
, APIC_DM_NMI
);
285 * Enable timer based NMIs on all CPUs:
287 void acpi_nmi_enable(void)
289 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
290 on_each_cpu(__acpi_nmi_enable
, NULL
, 1);
294 * Disable timer based NMIs on all CPUs:
296 void acpi_nmi_disable(void)
298 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
299 on_each_cpu(__acpi_nmi_disable
, NULL
, 1);
303 * This function is called as soon the LAPIC NMI watchdog driver has everything
304 * in place and it's ready to check if the NMIs belong to the NMI watchdog
306 void cpu_nmi_set_wd_enabled(void)
308 __get_cpu_var(wd_enabled
) = 1;
311 void setup_apic_nmi_watchdog(void *unused
)
313 if (__get_cpu_var(wd_enabled
))
316 /* cheap hack to support suspend/resume */
317 /* if cpu0 is not active neither should the other cpus */
318 if (smp_processor_id() != 0 && atomic_read(&nmi_active
) <= 0)
321 switch (nmi_watchdog
) {
323 if (lapic_watchdog_init(nmi_hz
) < 0) {
324 __get_cpu_var(wd_enabled
) = 0;
329 __get_cpu_var(wd_enabled
) = 1;
330 atomic_inc(&nmi_active
);
334 void stop_apic_nmi_watchdog(void *unused
)
336 /* only support LOCAL and IO APICs for now */
337 if (!nmi_watchdog_active())
339 if (__get_cpu_var(wd_enabled
) == 0)
341 if (nmi_watchdog
== NMI_LOCAL_APIC
)
342 lapic_watchdog_stop();
344 __acpi_nmi_disable(NULL
);
345 __get_cpu_var(wd_enabled
) = 0;
346 atomic_dec(&nmi_active
);
350 * the best way to detect whether a CPU has a 'hard lockup' problem
351 * is to check it's local APIC timer IRQ counts. If they are not
352 * changing then that CPU has some problem.
354 * as these watchdog NMI IRQs are generated on every CPU, we only
355 * have to check the current processor.
357 * since NMIs don't listen to _any_ locks, we have to be extremely
358 * careful not to rely on unsafe variables. The printk might lock
359 * up though, so we have to break up any console locks first ...
360 * [when there will be more tty-related locks, break them up here too!]
363 static DEFINE_PER_CPU(unsigned, last_irq_sum
);
364 static DEFINE_PER_CPU(long, alert_counter
);
365 static DEFINE_PER_CPU(int, nmi_touch
);
367 void touch_nmi_watchdog(void)
369 if (nmi_watchdog_active()) {
373 * Tell other CPUs to reset their alert counters. We cannot
374 * do it ourselves because the alert count increase is not
377 for_each_present_cpu(cpu
) {
378 if (per_cpu(nmi_touch
, cpu
) != 1)
379 per_cpu(nmi_touch
, cpu
) = 1;
384 * Tickle the softlockup detector too:
386 touch_softlockup_watchdog();
388 EXPORT_SYMBOL(touch_nmi_watchdog
);
390 notrace __kprobes
int
391 nmi_watchdog_tick(struct pt_regs
*regs
, unsigned reason
)
394 * Since current_thread_info()-> is always on the stack, and we
395 * always switch the stack NMI-atomically, it's safe to use
396 * smp_processor_id().
400 int cpu
= smp_processor_id();
403 /* check for other users first */
404 if (notify_die(DIE_NMI
, "nmi", regs
, reason
, 2, SIGINT
)
410 sum
= get_timer_irqs(cpu
);
412 if (__get_cpu_var(nmi_touch
)) {
413 __get_cpu_var(nmi_touch
) = 0;
417 /* We can be called before check_nmi_watchdog, hence NULL check. */
418 if (cpumask_test_cpu(cpu
, to_cpumask(backtrace_mask
))) {
419 static DEFINE_RAW_SPINLOCK(lock
); /* Serialise the printks */
421 raw_spin_lock(&lock
);
422 printk(KERN_WARNING
"NMI backtrace for cpu %d\n", cpu
);
425 raw_spin_unlock(&lock
);
426 cpumask_clear_cpu(cpu
, to_cpumask(backtrace_mask
));
431 /* Could check oops_in_progress here too, but it's safer not to */
432 if (mce_in_progress())
435 /* if the none of the timers isn't firing, this cpu isn't doing much */
436 if (!touched
&& __get_cpu_var(last_irq_sum
) == sum
) {
438 * Ayiee, looks like this CPU is stuck ...
439 * wait a few IRQs (5 seconds) before doing the oops ...
441 __this_cpu_inc(per_cpu_var(alert_counter
));
442 if (__this_cpu_read(per_cpu_var(alert_counter
)) == 5 * nmi_hz
)
444 * die_nmi will return ONLY if NOTIFY_STOP happens..
446 die_nmi("BUG: NMI Watchdog detected LOCKUP",
447 regs
, panic_on_timeout
);
449 __get_cpu_var(last_irq_sum
) = sum
;
450 __this_cpu_write(per_cpu_var(alert_counter
), 0);
453 /* see if the nmi watchdog went off */
454 if (!__get_cpu_var(wd_enabled
))
456 switch (nmi_watchdog
) {
458 rc
|= lapic_wd_event(nmi_hz
);
462 * don't know how to accurately check for this.
463 * just assume it was a watchdog timer interrupt
464 * This matches the old behaviour.
474 static void enable_ioapic_nmi_watchdog_single(void *unused
)
476 __get_cpu_var(wd_enabled
) = 1;
477 atomic_inc(&nmi_active
);
478 __acpi_nmi_enable(NULL
);
481 static void enable_ioapic_nmi_watchdog(void)
483 on_each_cpu(enable_ioapic_nmi_watchdog_single
, NULL
, 1);
484 touch_nmi_watchdog();
487 static void disable_ioapic_nmi_watchdog(void)
489 on_each_cpu(stop_apic_nmi_watchdog
, NULL
, 1);
492 static int __init
setup_unknown_nmi_panic(char *str
)
494 unknown_nmi_panic
= 1;
497 __setup("unknown_nmi_panic", setup_unknown_nmi_panic
);
499 static int unknown_nmi_panic_callback(struct pt_regs
*regs
, int cpu
)
501 unsigned char reason
= get_nmi_reason();
504 sprintf(buf
, "NMI received for unknown reason %02x\n", reason
);
505 die_nmi(buf
, regs
, 1); /* Always panic here */
510 * proc handler for /proc/sys/kernel/nmi
512 int proc_nmi_enabled(struct ctl_table
*table
, int write
,
513 void __user
*buffer
, size_t *length
, loff_t
*ppos
)
517 nmi_watchdog_enabled
= (atomic_read(&nmi_active
) > 0) ? 1 : 0;
518 old_state
= nmi_watchdog_enabled
;
519 proc_dointvec(table
, write
, buffer
, length
, ppos
);
520 if (!!old_state
== !!nmi_watchdog_enabled
)
523 if (atomic_read(&nmi_active
) < 0 || !nmi_watchdog_active()) {
525 "NMI watchdog is permanently disabled\n");
529 if (nmi_watchdog
== NMI_LOCAL_APIC
) {
530 if (nmi_watchdog_enabled
)
531 enable_lapic_nmi_watchdog();
533 disable_lapic_nmi_watchdog();
534 } else if (nmi_watchdog
== NMI_IO_APIC
) {
535 if (nmi_watchdog_enabled
)
536 enable_ioapic_nmi_watchdog();
538 disable_ioapic_nmi_watchdog();
541 "NMI watchdog doesn't know what hardware to touch\n");
547 #endif /* CONFIG_SYSCTL */
549 int do_nmi_callback(struct pt_regs
*regs
, int cpu
)
552 if (unknown_nmi_panic
)
553 return unknown_nmi_panic_callback(regs
, cpu
);
558 void arch_trigger_all_cpu_backtrace(void)
562 cpumask_copy(to_cpumask(backtrace_mask
), cpu_online_mask
);
564 printk(KERN_INFO
"sending NMI to all CPUs:\n");
565 apic
->send_IPI_all(NMI_VECTOR
);
567 /* Wait for up to 10 seconds for all CPUs to do the backtrace */
568 for (i
= 0; i
< 10 * 1000; i
++) {
569 if (cpumask_empty(to_cpumask(backtrace_mask
)))