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>
28 #include <asm/timer.h>
30 #include "mach_traps.h"
32 int unknown_nmi_panic
;
33 int nmi_watchdog_enabled
;
35 static cpumask_t backtrace_mask
= CPU_MASK_NONE
;
38 * >0: the lapic NMI watchdog is active, but can be disabled
39 * <0: the lapic NMI watchdog has not been set up, and cannot
41 * 0: the lapic NMI watchdog is disabled, but can be enabled
43 atomic_t nmi_active
= ATOMIC_INIT(0); /* oprofile uses this */
45 unsigned int nmi_watchdog
= NMI_DEFAULT
;
46 static unsigned int nmi_hz
= HZ
;
48 static DEFINE_PER_CPU(short, wd_enabled
);
50 /* local prototypes */
51 static int unknown_nmi_panic_callback(struct pt_regs
*regs
, int cpu
);
53 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
)
62 local_irq_enable_in_hardirq();
63 /* Intentionally don't use cpu_relax here. This is
64 to make sure that the performance counter really ticks,
65 even if there is a simulator or similar that catches the
66 pause instruction. On a real HT machine this is fine because
67 all other CPUs are busy with "useless" delay loops and don't
68 care if they get somewhat less cycles. */
74 static int __init
check_nmi_watchdog(void)
76 unsigned int *prev_nmi_count
;
79 if ((nmi_watchdog
== NMI_NONE
) || (nmi_watchdog
== NMI_DISABLED
))
82 if (!atomic_read(&nmi_active
))
85 prev_nmi_count
= kmalloc(NR_CPUS
* sizeof(int), GFP_KERNEL
);
89 printk(KERN_INFO
"Testing NMI watchdog ... ");
91 if (nmi_watchdog
== NMI_LOCAL_APIC
)
92 smp_call_function(nmi_cpu_busy
, (void *)&endflag
, 0, 0);
94 for_each_possible_cpu(cpu
)
95 prev_nmi_count
[cpu
] = per_cpu(irq_stat
, cpu
).__nmi_count
;
97 mdelay((20*1000)/nmi_hz
); // wait 20 ticks
99 for_each_possible_cpu(cpu
) {
101 /* Check cpu_callin_map here because that is set
102 after the timer is started. */
103 if (!cpu_isset(cpu
, cpu_callin_map
))
106 if (!per_cpu(wd_enabled
, cpu
))
108 if (nmi_count(cpu
) - prev_nmi_count
[cpu
] <= 5) {
109 printk("CPU#%d: NMI appears to be stuck (%d->%d)!\n",
113 per_cpu(wd_enabled
, cpu
) = 0;
114 atomic_dec(&nmi_active
);
118 if (!atomic_read(&nmi_active
)) {
119 kfree(prev_nmi_count
);
120 atomic_set(&nmi_active
, -1);
125 /* now that we know it works we can reduce NMI frequency to
126 something more reasonable; makes a difference in some configs */
127 if (nmi_watchdog
== NMI_LOCAL_APIC
)
128 nmi_hz
= lapic_adjust_nmi_hz(1);
130 kfree(prev_nmi_count
);
133 timer_ack
= !cpu_has_tsc
;
137 /* This needs to happen later in boot so counters are working */
138 late_initcall(check_nmi_watchdog
);
140 static int __init
setup_nmi_watchdog(char *str
)
144 get_option(&str
, &nmi
);
146 if ((nmi
>= NMI_INVALID
) || (nmi
< NMI_NONE
))
153 __setup("nmi_watchdog=", setup_nmi_watchdog
);
156 /* Suspend/resume support */
160 static int nmi_pm_active
; /* nmi_active before suspend */
162 static int lapic_nmi_suspend(struct sys_device
*dev
, pm_message_t state
)
164 /* only CPU0 goes here, other CPUs should be offline */
165 nmi_pm_active
= atomic_read(&nmi_active
);
166 stop_apic_nmi_watchdog(NULL
);
167 BUG_ON(atomic_read(&nmi_active
) != 0);
171 static int lapic_nmi_resume(struct sys_device
*dev
)
173 /* only CPU0 goes here, other CPUs should be offline */
174 if (nmi_pm_active
> 0) {
175 setup_apic_nmi_watchdog(NULL
);
176 touch_nmi_watchdog();
182 static struct sysdev_class nmi_sysclass
= {
183 set_kset_name("lapic_nmi"),
184 .resume
= lapic_nmi_resume
,
185 .suspend
= lapic_nmi_suspend
,
188 static struct sys_device device_lapic_nmi
= {
190 .cls
= &nmi_sysclass
,
193 static int __init
init_lapic_nmi_sysfs(void)
197 /* should really be a BUG_ON but b/c this is an
198 * init call, it just doesn't work. -dcz
200 if (nmi_watchdog
!= NMI_LOCAL_APIC
)
203 if (atomic_read(&nmi_active
) < 0)
206 error
= sysdev_class_register(&nmi_sysclass
);
208 error
= sysdev_register(&device_lapic_nmi
);
211 /* must come after the local APIC's device_initcall() */
212 late_initcall(init_lapic_nmi_sysfs
);
214 #endif /* CONFIG_PM */
216 static void __acpi_nmi_enable(void *__unused
)
218 apic_write_around(APIC_LVT0
, APIC_DM_NMI
);
222 * Enable timer based NMIs on all CPUs:
224 void acpi_nmi_enable(void)
226 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
227 on_each_cpu(__acpi_nmi_enable
, NULL
, 0, 1);
230 static void __acpi_nmi_disable(void *__unused
)
232 apic_write(APIC_LVT0
, APIC_DM_NMI
| APIC_LVT_MASKED
);
236 * Disable timer based NMIs on all CPUs:
238 void acpi_nmi_disable(void)
240 if (atomic_read(&nmi_active
) && nmi_watchdog
== NMI_IO_APIC
)
241 on_each_cpu(__acpi_nmi_disable
, NULL
, 0, 1);
244 void setup_apic_nmi_watchdog (void *unused
)
246 if (__get_cpu_var(wd_enabled
))
249 /* cheap hack to support suspend/resume */
250 /* if cpu0 is not active neither should the other cpus */
251 if ((smp_processor_id() != 0) && (atomic_read(&nmi_active
) <= 0))
254 switch (nmi_watchdog
) {
256 __get_cpu_var(wd_enabled
) = 1; /* enable it before to avoid race with handler */
257 if (lapic_watchdog_init(nmi_hz
) < 0) {
258 __get_cpu_var(wd_enabled
) = 0;
263 __get_cpu_var(wd_enabled
) = 1;
264 atomic_inc(&nmi_active
);
268 void stop_apic_nmi_watchdog(void *unused
)
270 /* only support LOCAL and IO APICs for now */
271 if ((nmi_watchdog
!= NMI_LOCAL_APIC
) &&
272 (nmi_watchdog
!= NMI_IO_APIC
))
274 if (__get_cpu_var(wd_enabled
) == 0)
276 if (nmi_watchdog
== NMI_LOCAL_APIC
)
277 lapic_watchdog_stop();
278 __get_cpu_var(wd_enabled
) = 0;
279 atomic_dec(&nmi_active
);
283 * the best way to detect whether a CPU has a 'hard lockup' problem
284 * is to check it's local APIC timer IRQ counts. If they are not
285 * changing then that CPU has some problem.
287 * as these watchdog NMI IRQs are generated on every CPU, we only
288 * have to check the current processor.
290 * since NMIs don't listen to _any_ locks, we have to be extremely
291 * careful not to rely on unsafe variables. The printk might lock
292 * up though, so we have to break up any console locks first ...
293 * [when there will be more tty-related locks, break them up
298 last_irq_sums
[NR_CPUS
],
299 alert_counter
[NR_CPUS
];
301 void touch_nmi_watchdog(void)
303 if (nmi_watchdog
> 0) {
307 * Just reset the alert counters, (other CPUs might be
308 * spinning on locks we hold):
310 for_each_present_cpu(cpu
) {
311 if (alert_counter
[cpu
])
312 alert_counter
[cpu
] = 0;
317 * Tickle the softlockup detector too:
319 touch_softlockup_watchdog();
321 EXPORT_SYMBOL(touch_nmi_watchdog
);
323 extern void die_nmi(struct pt_regs
*, const char *msg
);
325 __kprobes
int nmi_watchdog_tick(struct pt_regs
* regs
, unsigned reason
)
329 * Since current_thread_info()-> is always on the stack, and we
330 * always switch the stack NMI-atomically, it's safe to use
331 * smp_processor_id().
335 int cpu
= smp_processor_id();
338 /* check for other users first */
339 if (notify_die(DIE_NMI
, "nmi", regs
, reason
, 2, SIGINT
)
345 if (cpu_isset(cpu
, backtrace_mask
)) {
346 static DEFINE_SPINLOCK(lock
); /* Serialise the printks */
349 printk("NMI backtrace for cpu %d\n", cpu
);
352 cpu_clear(cpu
, backtrace_mask
);
356 * Take the local apic timer and PIT/HPET into account. We don't
357 * know which one is active, when we have highres/dyntick on
359 sum
= per_cpu(irq_stat
, cpu
).apic_timer_irqs
+
360 per_cpu(irq_stat
, cpu
).irq0_irqs
;
362 /* if the none of the timers isn't firing, this cpu isn't doing much */
363 if (!touched
&& last_irq_sums
[cpu
] == sum
) {
365 * Ayiee, looks like this CPU is stuck ...
366 * wait a few IRQs (5 seconds) before doing the oops ...
368 alert_counter
[cpu
]++;
369 if (alert_counter
[cpu
] == 5*nmi_hz
)
371 * die_nmi will return ONLY if NOTIFY_STOP happens..
373 die_nmi(regs
, "BUG: NMI Watchdog detected LOCKUP");
375 last_irq_sums
[cpu
] = sum
;
376 alert_counter
[cpu
] = 0;
378 /* see if the nmi watchdog went off */
379 if (!__get_cpu_var(wd_enabled
))
381 switch (nmi_watchdog
) {
383 rc
|= lapic_wd_event(nmi_hz
);
386 /* don't know how to accurately check for this.
387 * just assume it was a watchdog timer interrupt
388 * This matches the old behaviour.
396 int do_nmi_callback(struct pt_regs
* regs
, int cpu
)
399 if (unknown_nmi_panic
)
400 return unknown_nmi_panic_callback(regs
, cpu
);
407 static int unknown_nmi_panic_callback(struct pt_regs
*regs
, int cpu
)
409 unsigned char reason
= get_nmi_reason();
412 sprintf(buf
, "NMI received for unknown reason %02x\n", reason
);
418 * proc handler for /proc/sys/kernel/nmi
420 int proc_nmi_enabled(struct ctl_table
*table
, int write
, struct file
*file
,
421 void __user
*buffer
, size_t *length
, loff_t
*ppos
)
425 nmi_watchdog_enabled
= (atomic_read(&nmi_active
) > 0) ? 1 : 0;
426 old_state
= nmi_watchdog_enabled
;
427 proc_dointvec(table
, write
, file
, buffer
, length
, ppos
);
428 if (!!old_state
== !!nmi_watchdog_enabled
)
431 if (atomic_read(&nmi_active
) < 0 || nmi_watchdog
== NMI_DISABLED
) {
432 printk( KERN_WARNING
"NMI watchdog is permanently disabled\n");
436 if (nmi_watchdog
== NMI_DEFAULT
) {
437 if (lapic_watchdog_ok())
438 nmi_watchdog
= NMI_LOCAL_APIC
;
440 nmi_watchdog
= NMI_IO_APIC
;
443 if (nmi_watchdog
== NMI_LOCAL_APIC
) {
444 if (nmi_watchdog_enabled
)
445 enable_lapic_nmi_watchdog();
447 disable_lapic_nmi_watchdog();
450 "NMI watchdog doesn't know what hardware to touch\n");
458 void __trigger_all_cpu_backtrace(void)
462 backtrace_mask
= cpu_online_map
;
463 /* Wait for up to 10 seconds for all CPUs to do the backtrace */
464 for (i
= 0; i
< 10 * 1000; i
++) {
465 if (cpus_empty(backtrace_mask
))
471 EXPORT_SYMBOL(nmi_active
);
472 EXPORT_SYMBOL(nmi_watchdog
);