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.
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/module.h>
17 #include <linux/nmi.h>
18 #include <linux/sysdev.h>
19 #include <linux/sysctl.h>
20 #include <linux/percpu.h>
21 #include <linux/kprobes.h>
22 #include <linux/cpumask.h>
23 #include <linux/kernel_stat.h>
24 #include <linux/kdebug.h>
29 #include "mach_traps.h"
31 int unknown_nmi_panic
;
32 int nmi_watchdog_enabled
;
34 static cpumask_t backtrace_mask
= CPU_MASK_NONE
;
37 * >0: the lapic NMI watchdog is active, but can be disabled
38 * <0: the lapic NMI watchdog has not been set up, and cannot
40 * 0: the lapic NMI watchdog is disabled, but can be enabled
42 atomic_t nmi_active
= ATOMIC_INIT(0); /* oprofile uses this */
44 unsigned int nmi_watchdog
= NMI_DEFAULT
;
45 static unsigned int nmi_hz
= HZ
;
47 static DEFINE_PER_CPU(short, wd_enabled
);
49 /* local prototypes */
50 static int unknown_nmi_panic_callback(struct pt_regs
*regs
, int cpu
);
52 static int endflag __initdata
= 0;
55 /* The performance counters used by NMI_LOCAL_APIC don't trigger when
56 * the CPU is idle. To make sure the NMI watchdog really ticks on all
57 * CPUs during the test make them busy.
59 static __init
void nmi_cpu_busy(void *data
)
61 local_irq_enable_in_hardirq();
62 /* Intentionally don't use cpu_relax here. This is
63 to make sure that the performance counter really ticks,
64 even if there is a simulator or similar that catches the
65 pause instruction. On a real HT machine this is fine because
66 all other CPUs are busy with "useless" delay loops and don't
67 care if they get somewhat less cycles. */
73 static int __init
check_nmi_watchdog(void)
75 unsigned int *prev_nmi_count
;
78 if ((nmi_watchdog
== NMI_NONE
) || (nmi_watchdog
== NMI_DISABLED
))
81 if (!atomic_read(&nmi_active
))
84 prev_nmi_count
= kmalloc(NR_CPUS
* sizeof(int), GFP_KERNEL
);
88 printk(KERN_INFO
"Testing NMI watchdog ... ");
91 if (nmi_watchdog
== NMI_LOCAL_APIC
)
92 smp_call_function(nmi_cpu_busy
, (void *)&endflag
, 0, 0);
95 for_each_possible_cpu(cpu
)
96 prev_nmi_count
[cpu
] = nmi_count(cpu
);
98 mdelay((20*1000)/nmi_hz
); // wait 20 ticks
100 for_each_possible_cpu(cpu
) {
102 /* Check cpu_callin_map here because that is set
103 after the timer is started. */
104 if (!cpu_isset(cpu
, cpu_callin_map
))
107 if (!per_cpu(wd_enabled
, cpu
))
109 if (nmi_count(cpu
) - prev_nmi_count
[cpu
] <= 5) {
110 printk(KERN_WARNING
"WARNING: CPU#%d: NMI "
111 "appears to be stuck (%d->%d)!\n",
115 per_cpu(wd_enabled
, cpu
) = 0;
116 atomic_dec(&nmi_active
);
120 if (!atomic_read(&nmi_active
)) {
121 kfree(prev_nmi_count
);
122 atomic_set(&nmi_active
, -1);
127 /* now that we know it works we can reduce NMI frequency to
128 something more reasonable; makes a difference in some configs */
129 if (nmi_watchdog
== NMI_LOCAL_APIC
)
130 nmi_hz
= lapic_adjust_nmi_hz(1);
132 kfree(prev_nmi_count
);
135 /* This needs to happen later in boot so counters are working */
136 late_initcall(check_nmi_watchdog
);
138 static int __init
setup_nmi_watchdog(char *str
)
142 get_option(&str
, &nmi
);
144 if ((nmi
>= NMI_INVALID
) || (nmi
< NMI_NONE
))
151 __setup("nmi_watchdog=", setup_nmi_watchdog
);
154 /* Suspend/resume support */
158 static int nmi_pm_active
; /* nmi_active before suspend */
160 static int lapic_nmi_suspend(struct sys_device
*dev
, pm_message_t state
)
162 /* only CPU0 goes here, other CPUs should be offline */
163 nmi_pm_active
= atomic_read(&nmi_active
);
164 stop_apic_nmi_watchdog(NULL
);
165 BUG_ON(atomic_read(&nmi_active
) != 0);
169 static int lapic_nmi_resume(struct sys_device
*dev
)
171 /* only CPU0 goes here, other CPUs should be offline */
172 if (nmi_pm_active
> 0) {
173 setup_apic_nmi_watchdog(NULL
);
174 touch_nmi_watchdog();
180 static struct sysdev_class nmi_sysclass
= {
182 .resume
= lapic_nmi_resume
,
183 .suspend
= lapic_nmi_suspend
,
186 static struct sys_device device_lapic_nmi
= {
188 .cls
= &nmi_sysclass
,
191 static int __init
init_lapic_nmi_sysfs(void)
195 /* should really be a BUG_ON but b/c this is an
196 * init call, it just doesn't work. -dcz
198 if (nmi_watchdog
!= NMI_LOCAL_APIC
)
201 if (atomic_read(&nmi_active
) < 0)
204 error
= sysdev_class_register(&nmi_sysclass
);
206 error
= sysdev_register(&device_lapic_nmi
);
209 /* must come after the local APIC's device_initcall() */
210 late_initcall(init_lapic_nmi_sysfs
);
212 #endif /* CONFIG_PM */
214 static void __acpi_nmi_enable(void *__unused
)
216 apic_write_around(APIC_LVT0
, APIC_DM_NMI
);
220 * Enable timer based NMIs on all CPUs:
222 void acpi_nmi_enable(void)
224 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
225 on_each_cpu(__acpi_nmi_enable
, NULL
, 0, 1);
228 static void __acpi_nmi_disable(void *__unused
)
230 apic_write(APIC_LVT0
, APIC_DM_NMI
| APIC_LVT_MASKED
);
234 * Disable timer based NMIs on all CPUs:
236 void acpi_nmi_disable(void)
238 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
239 on_each_cpu(__acpi_nmi_disable
, NULL
, 0, 1);
242 void setup_apic_nmi_watchdog(void *unused
)
244 if (__get_cpu_var(wd_enabled
))
247 /* cheap hack to support suspend/resume */
248 /* if cpu0 is not active neither should the other cpus */
249 if ((smp_processor_id() != 0) && (atomic_read(&nmi_active
) <= 0))
252 switch (nmi_watchdog
) {
254 __get_cpu_var(wd_enabled
) = 1; /* enable it before to avoid race with handler */
255 if (lapic_watchdog_init(nmi_hz
) < 0) {
256 __get_cpu_var(wd_enabled
) = 0;
261 __get_cpu_var(wd_enabled
) = 1;
262 atomic_inc(&nmi_active
);
266 void stop_apic_nmi_watchdog(void *unused
)
268 /* only support LOCAL and IO APICs for now */
269 if ((nmi_watchdog
!= NMI_LOCAL_APIC
) &&
270 (nmi_watchdog
!= NMI_IO_APIC
))
272 if (__get_cpu_var(wd_enabled
) == 0)
274 if (nmi_watchdog
== NMI_LOCAL_APIC
)
275 lapic_watchdog_stop();
276 __get_cpu_var(wd_enabled
) = 0;
277 atomic_dec(&nmi_active
);
281 * the best way to detect whether a CPU has a 'hard lockup' problem
282 * is to check it's local APIC timer IRQ counts. If they are not
283 * changing then that CPU has some problem.
285 * as these watchdog NMI IRQs are generated on every CPU, we only
286 * have to check the current processor.
288 * since NMIs don't listen to _any_ locks, we have to be extremely
289 * careful not to rely on unsafe variables. The printk might lock
290 * up though, so we have to break up any console locks first ...
291 * [when there will be more tty-related locks, break them up
296 last_irq_sums
[NR_CPUS
],
297 alert_counter
[NR_CPUS
];
299 void touch_nmi_watchdog(void)
301 if (nmi_watchdog
> 0) {
305 * Just reset the alert counters, (other CPUs might be
306 * spinning on locks we hold):
308 for_each_present_cpu(cpu
) {
309 if (alert_counter
[cpu
])
310 alert_counter
[cpu
] = 0;
315 * Tickle the softlockup detector too:
317 touch_softlockup_watchdog();
319 EXPORT_SYMBOL(touch_nmi_watchdog
);
321 extern void die_nmi(struct pt_regs
*, const char *msg
);
323 __kprobes
int nmi_watchdog_tick(struct pt_regs
* regs
, unsigned reason
)
327 * Since current_thread_info()-> is always on the stack, and we
328 * always switch the stack NMI-atomically, it's safe to use
329 * smp_processor_id().
333 int cpu
= smp_processor_id();
336 /* check for other users first */
337 if (notify_die(DIE_NMI
, "nmi", regs
, reason
, 2, SIGINT
)
343 if (cpu_isset(cpu
, backtrace_mask
)) {
344 static DEFINE_SPINLOCK(lock
); /* Serialise the printks */
347 printk("NMI backtrace for cpu %d\n", cpu
);
350 cpu_clear(cpu
, backtrace_mask
);
354 * Take the local apic timer and PIT/HPET into account. We don't
355 * know which one is active, when we have highres/dyntick on
357 sum
= per_cpu(irq_stat
, cpu
).apic_timer_irqs
+
358 per_cpu(irq_stat
, cpu
).irq0_irqs
;
360 /* if the none of the timers isn't firing, this cpu isn't doing much */
361 if (!touched
&& last_irq_sums
[cpu
] == sum
) {
363 * Ayiee, looks like this CPU is stuck ...
364 * wait a few IRQs (5 seconds) before doing the oops ...
366 alert_counter
[cpu
]++;
367 if (alert_counter
[cpu
] == 5*nmi_hz
)
369 * die_nmi will return ONLY if NOTIFY_STOP happens..
371 die_nmi(regs
, "BUG: NMI Watchdog detected LOCKUP");
373 last_irq_sums
[cpu
] = sum
;
374 alert_counter
[cpu
] = 0;
376 /* see if the nmi watchdog went off */
377 if (!__get_cpu_var(wd_enabled
))
379 switch (nmi_watchdog
) {
381 rc
|= lapic_wd_event(nmi_hz
);
384 /* don't know how to accurately check for this.
385 * just assume it was a watchdog timer interrupt
386 * This matches the old behaviour.
394 int do_nmi_callback(struct pt_regs
* regs
, int cpu
)
397 if (unknown_nmi_panic
)
398 return unknown_nmi_panic_callback(regs
, cpu
);
405 static int unknown_nmi_panic_callback(struct pt_regs
*regs
, int cpu
)
407 unsigned char reason
= get_nmi_reason();
410 sprintf(buf
, "NMI received for unknown reason %02x\n", reason
);
416 * proc handler for /proc/sys/kernel/nmi
418 int proc_nmi_enabled(struct ctl_table
*table
, int write
, struct file
*file
,
419 void __user
*buffer
, size_t *length
, loff_t
*ppos
)
423 nmi_watchdog_enabled
= (atomic_read(&nmi_active
) > 0) ? 1 : 0;
424 old_state
= nmi_watchdog_enabled
;
425 proc_dointvec(table
, write
, file
, buffer
, length
, ppos
);
426 if (!!old_state
== !!nmi_watchdog_enabled
)
429 if (atomic_read(&nmi_active
) < 0 || nmi_watchdog
== NMI_DISABLED
) {
430 printk( KERN_WARNING
"NMI watchdog is permanently disabled\n");
434 if (nmi_watchdog
== NMI_DEFAULT
) {
435 if (lapic_watchdog_ok())
436 nmi_watchdog
= NMI_LOCAL_APIC
;
438 nmi_watchdog
= NMI_IO_APIC
;
441 if (nmi_watchdog
== NMI_LOCAL_APIC
) {
442 if (nmi_watchdog_enabled
)
443 enable_lapic_nmi_watchdog();
445 disable_lapic_nmi_watchdog();
448 "NMI watchdog doesn't know what hardware to touch\n");
456 void __trigger_all_cpu_backtrace(void)
460 backtrace_mask
= cpu_online_map
;
461 /* Wait for up to 10 seconds for all CPUs to do the backtrace */
462 for (i
= 0; i
< 10 * 1000; i
++) {
463 if (cpus_empty(backtrace_mask
))
469 EXPORT_SYMBOL(nmi_active
);
470 EXPORT_SYMBOL(nmi_watchdog
);