2 * linux/arch/x86_64/nmi.c
4 * NMI watchdog support on APIC systems
6 * Started by Ingo Molnar <mingo@redhat.com>
9 * Mikael Pettersson : AMD K7 support for local APIC NMI watchdog.
10 * Mikael Pettersson : Power Management for local APIC NMI watchdog.
12 * Mikael Pettersson : PM converted to driver model. Disable/enable API.
15 #include <linux/config.h>
17 #include <linux/irq.h>
18 #include <linux/delay.h>
19 #include <linux/bootmem.h>
20 #include <linux/smp_lock.h>
21 #include <linux/interrupt.h>
22 #include <linux/mc146818rtc.h>
23 #include <linux/kernel_stat.h>
24 #include <linux/module.h>
25 #include <linux/sysdev.h>
26 #include <linux/nmi.h>
27 #include <linux/sysctl.h>
31 #include <asm/mpspec.h>
34 #include <asm/proto.h>
35 #include <asm/kdebug.h>
38 * lapic_nmi_owner tracks the ownership of the lapic NMI hardware:
39 * - it may be reserved by some other driver, or not
40 * - when not reserved by some other driver, it may be used for
41 * the NMI watchdog, or not
43 * This is maintained separately from nmi_active because the NMI
44 * watchdog may also be driven from the I/O APIC timer.
46 static DEFINE_SPINLOCK(lapic_nmi_owner_lock);
47 static unsigned int lapic_nmi_owner;
48 #define LAPIC_NMI_WATCHDOG (1<<0)
49 #define LAPIC_NMI_RESERVED (1<<1)
52 * +1: the lapic NMI watchdog is active, but can be disabled
53 * 0: the lapic NMI watchdog has not been set up, and cannot
55 * -1: the lapic NMI watchdog is disabled, but can be enabled
57 int nmi_active; /* oprofile uses this */
60 unsigned int nmi_watchdog = NMI_DEFAULT;
61 static unsigned int nmi_hz = HZ;
62 unsigned int nmi_perfctr_msr; /* the MSR to reset in NMI handler */
64 /* Note that these events don't tick when the CPU idles. This means
65 the frequency varies with CPU load. */
67 #define K7_EVNTSEL_ENABLE (1 << 22)
68 #define K7_EVNTSEL_INT (1 << 20)
69 #define K7_EVNTSEL_OS (1 << 17)
70 #define K7_EVNTSEL_USR (1 << 16)
71 #define K7_EVENT_CYCLES_PROCESSOR_IS_RUNNING 0x76
72 #define K7_NMI_EVENT K7_EVENT_CYCLES_PROCESSOR_IS_RUNNING
74 #define P6_EVNTSEL0_ENABLE (1 << 22)
75 #define P6_EVNTSEL_INT (1 << 20)
76 #define P6_EVNTSEL_OS (1 << 17)
77 #define P6_EVNTSEL_USR (1 << 16)
78 #define P6_EVENT_CPU_CLOCKS_NOT_HALTED 0x79
79 #define P6_NMI_EVENT P6_EVENT_CPU_CLOCKS_NOT_HALTED
81 /* Run after command line and cpu_init init, but before all other checks */
82 void __init nmi_watchdog_default(void)
84 if (nmi_watchdog != NMI_DEFAULT)
87 /* For some reason the IO APIC watchdog doesn't work on the AMD
88 8111 chipset. For now switch to local APIC mode using
89 perfctr0 there. On Intel CPUs we don't have code to handle
90 the perfctr and the IO-APIC seems to work, so use that. */
92 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
93 nmi_watchdog = NMI_LOCAL_APIC;
95 "Using local APIC NMI watchdog using perfctr0\n");
97 printk(KERN_INFO "Using IO APIC NMI watchdog\n");
98 nmi_watchdog = NMI_IO_APIC;
102 /* Why is there no CPUID flag for this? */
103 static __init int cpu_has_lapic(void)
105 switch (boot_cpu_data.x86_vendor) {
106 case X86_VENDOR_INTEL:
108 return boot_cpu_data.x86 >= 6;
109 /* .... add more cpus here or find a different way to figure this out. */
115 static int __init check_nmi_watchdog (void)
120 if (nmi_watchdog == NMI_NONE)
123 if (nmi_watchdog == NMI_LOCAL_APIC && !cpu_has_lapic()) {
124 nmi_watchdog = NMI_NONE;
128 counts = kmalloc(NR_CPUS * sizeof(int),GFP_KERNEL);
130 nmi_watchdog = NMI_NONE;
134 printk(KERN_INFO "Testing NMI watchdog ... ");
136 for (cpu = 0; cpu < NR_CPUS; cpu++)
137 counts[cpu] = cpu_pda[cpu].__nmi_count;
139 mdelay((10*1000)/nmi_hz); // wait 10 ticks
141 for (cpu = 0; cpu < NR_CPUS; cpu++) {
142 if (cpu_pda[cpu].__nmi_count - counts[cpu] <= 5) {
143 printk("CPU#%d: NMI appears to be stuck (%d)!\n",
145 cpu_pda[cpu].__nmi_count);
147 lapic_nmi_owner &= ~LAPIC_NMI_WATCHDOG;
154 /* now that we know it works we can reduce NMI frequency to
155 something more reasonable; makes a difference in some configs */
156 if (nmi_watchdog == NMI_LOCAL_APIC)
162 /* Have this called later during boot so counters are updating */
163 late_initcall(check_nmi_watchdog);
165 int __init setup_nmi_watchdog(char *str)
169 if (!strncmp(str,"panic",5)) {
170 panic_on_timeout = 1;
171 str = strchr(str, ',');
177 get_option(&str, &nmi);
179 if (nmi >= NMI_INVALID)
185 __setup("nmi_watchdog=", setup_nmi_watchdog);
187 static void disable_lapic_nmi_watchdog(void)
191 switch (boot_cpu_data.x86_vendor) {
193 wrmsr(MSR_K7_EVNTSEL0, 0, 0);
195 case X86_VENDOR_INTEL:
196 wrmsr(MSR_IA32_EVNTSEL0, 0, 0);
200 /* tell do_nmi() and others that we're not active any more */
204 static void enable_lapic_nmi_watchdog(void)
206 if (nmi_active < 0) {
207 nmi_watchdog = NMI_LOCAL_APIC;
208 setup_apic_nmi_watchdog();
212 int reserve_lapic_nmi(void)
214 unsigned int old_owner;
216 spin_lock(&lapic_nmi_owner_lock);
217 old_owner = lapic_nmi_owner;
218 lapic_nmi_owner |= LAPIC_NMI_RESERVED;
219 spin_unlock(&lapic_nmi_owner_lock);
220 if (old_owner & LAPIC_NMI_RESERVED)
222 if (old_owner & LAPIC_NMI_WATCHDOG)
223 disable_lapic_nmi_watchdog();
227 void release_lapic_nmi(void)
229 unsigned int new_owner;
231 spin_lock(&lapic_nmi_owner_lock);
232 new_owner = lapic_nmi_owner & ~LAPIC_NMI_RESERVED;
233 lapic_nmi_owner = new_owner;
234 spin_unlock(&lapic_nmi_owner_lock);
235 if (new_owner & LAPIC_NMI_WATCHDOG)
236 enable_lapic_nmi_watchdog();
239 void disable_timer_nmi_watchdog(void)
241 if ((nmi_watchdog != NMI_IO_APIC) || (nmi_active <= 0))
245 unset_nmi_callback();
247 nmi_watchdog = NMI_NONE;
250 void enable_timer_nmi_watchdog(void)
252 if (nmi_active < 0) {
253 nmi_watchdog = NMI_IO_APIC;
254 touch_nmi_watchdog();
262 static int nmi_pm_active; /* nmi_active before suspend */
264 static int lapic_nmi_suspend(struct sys_device *dev, pm_message_t state)
266 nmi_pm_active = nmi_active;
267 disable_lapic_nmi_watchdog();
271 static int lapic_nmi_resume(struct sys_device *dev)
273 if (nmi_pm_active > 0)
274 enable_lapic_nmi_watchdog();
278 static struct sysdev_class nmi_sysclass = {
279 set_kset_name("lapic_nmi"),
280 .resume = lapic_nmi_resume,
281 .suspend = lapic_nmi_suspend,
284 static struct sys_device device_lapic_nmi = {
286 .cls = &nmi_sysclass,
289 static int __init init_lapic_nmi_sysfs(void)
293 if (nmi_active == 0 || nmi_watchdog != NMI_LOCAL_APIC)
296 error = sysdev_class_register(&nmi_sysclass);
298 error = sysdev_register(&device_lapic_nmi);
301 /* must come after the local APIC's device_initcall() */
302 late_initcall(init_lapic_nmi_sysfs);
304 #endif /* CONFIG_PM */
307 * Activate the NMI watchdog via the local APIC.
308 * Original code written by Keith Owens.
311 static void setup_k7_watchdog(void)
314 unsigned int evntsel;
316 /* No check, so can start with slow frequency */
319 /* XXX should check these in EFER */
321 nmi_perfctr_msr = MSR_K7_PERFCTR0;
323 for(i = 0; i < 4; ++i) {
324 /* Simulator may not support it */
325 if (checking_wrmsrl(MSR_K7_EVNTSEL0+i, 0UL))
327 wrmsrl(MSR_K7_PERFCTR0+i, 0UL);
330 evntsel = K7_EVNTSEL_INT
335 wrmsr(MSR_K7_EVNTSEL0, evntsel, 0);
336 wrmsrl(MSR_K7_PERFCTR0, -((u64)cpu_khz*1000) / nmi_hz);
337 apic_write(APIC_LVTPC, APIC_DM_NMI);
338 evntsel |= K7_EVNTSEL_ENABLE;
339 wrmsr(MSR_K7_EVNTSEL0, evntsel, 0);
342 void setup_apic_nmi_watchdog(void)
344 switch (boot_cpu_data.x86_vendor) {
346 if (boot_cpu_data.x86 != 15)
348 if (strstr(boot_cpu_data.x86_model_id, "Screwdriver"))
355 lapic_nmi_owner = LAPIC_NMI_WATCHDOG;
360 * the best way to detect whether a CPU has a 'hard lockup' problem
361 * is to check it's local APIC timer IRQ counts. If they are not
362 * changing then that CPU has some problem.
364 * as these watchdog NMI IRQs are generated on every CPU, we only
365 * have to check the current processor.
367 * since NMIs don't listen to _any_ locks, we have to be extremely
368 * careful not to rely on unsafe variables. The printk might lock
369 * up though, so we have to break up any console locks first ...
370 * [when there will be more tty-related locks, break them up
375 last_irq_sums [NR_CPUS],
376 alert_counter [NR_CPUS];
378 void touch_nmi_watchdog (void)
383 * Just reset the alert counters, (other CPUs might be
384 * spinning on locks we hold):
386 for (i = 0; i < NR_CPUS; i++)
387 alert_counter[i] = 0;
390 void nmi_watchdog_tick (struct pt_regs * regs, unsigned reason)
394 cpu = safe_smp_processor_id();
395 sum = read_pda(apic_timer_irqs);
396 if (last_irq_sums[cpu] == sum) {
398 * Ayiee, looks like this CPU is stuck ...
399 * wait a few IRQs (5 seconds) before doing the oops ...
401 alert_counter[cpu]++;
402 if (alert_counter[cpu] == 5*nmi_hz) {
403 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT)
405 alert_counter[cpu] = 0;
408 die_nmi("NMI Watchdog detected LOCKUP on CPU%d", regs);
411 last_irq_sums[cpu] = sum;
412 alert_counter[cpu] = 0;
415 wrmsr(nmi_perfctr_msr, -(cpu_khz/nmi_hz*1000), -1);
418 static int dummy_nmi_callback(struct pt_regs * regs, int cpu)
423 static nmi_callback_t nmi_callback = dummy_nmi_callback;
425 asmlinkage void do_nmi(struct pt_regs * regs, long error_code)
427 int cpu = safe_smp_processor_id();
430 add_pda(__nmi_count,1);
431 if (!nmi_callback(regs, cpu))
432 default_do_nmi(regs);
436 void set_nmi_callback(nmi_callback_t callback)
438 nmi_callback = callback;
441 void unset_nmi_callback(void)
443 nmi_callback = dummy_nmi_callback;
448 static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu)
450 unsigned char reason = get_nmi_reason();
453 if (!(reason & 0xc0)) {
454 sprintf(buf, "NMI received for unknown reason %02x\n", reason);
461 * proc handler for /proc/sys/kernel/unknown_nmi_panic
463 int proc_unknown_nmi_panic(struct ctl_table *table, int write, struct file *file,
464 void __user *buffer, size_t *length, loff_t *ppos)
468 old_state = unknown_nmi_panic;
469 proc_dointvec(table, write, file, buffer, length, ppos);
470 if (!!old_state == !!unknown_nmi_panic)
473 if (unknown_nmi_panic) {
474 if (reserve_lapic_nmi() < 0) {
475 unknown_nmi_panic = 0;
478 set_nmi_callback(unknown_nmi_panic_callback);
482 unset_nmi_callback();
489 EXPORT_SYMBOL(nmi_active);
490 EXPORT_SYMBOL(nmi_watchdog);
491 EXPORT_SYMBOL(reserve_lapic_nmi);
492 EXPORT_SYMBOL(release_lapic_nmi);
493 EXPORT_SYMBOL(disable_timer_nmi_watchdog);
494 EXPORT_SYMBOL(enable_timer_nmi_watchdog);
495 EXPORT_SYMBOL(touch_nmi_watchdog);