[PATCH] check nmi watchdog is broken
[linux-2.6.git] / arch / x86_64 / kernel / nmi.c
1 /*
2  *  linux/arch/x86_64/nmi.c
3  *
4  *  NMI watchdog support on APIC systems
5  *
6  *  Started by Ingo Molnar <mingo@redhat.com>
7  *
8  *  Fixes:
9  *  Mikael Pettersson   : AMD K7 support for local APIC NMI watchdog.
10  *  Mikael Pettersson   : Power Management for local APIC NMI watchdog.
11  *  Pavel Machek and
12  *  Mikael Pettersson   : PM converted to driver model. Disable/enable API.
13  */
14
15 #include <linux/config.h>
16 #include <linux/mm.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>
28
29 #include <asm/smp.h>
30 #include <asm/mtrr.h>
31 #include <asm/mpspec.h>
32 #include <asm/nmi.h>
33 #include <asm/msr.h>
34 #include <asm/proto.h>
35 #include <asm/kdebug.h>
36
37 /*
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
42  *
43  * This is maintained separately from nmi_active because the NMI
44  * watchdog may also be driven from the I/O APIC timer.
45  */
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)
50
51 /* nmi_active:
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
54  *     be enabled
55  * -1: the lapic NMI watchdog is disabled, but can be enabled
56  */
57 int nmi_active;         /* oprofile uses this */
58 int panic_on_timeout;
59
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 */
63
64 /* Note that these events don't tick when the CPU idles. This means
65    the frequency varies with CPU load. */
66
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
73
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
80
81 /* Run after command line and cpu_init init, but before all other checks */
82 void __init nmi_watchdog_default(void)
83 {
84         if (nmi_watchdog != NMI_DEFAULT)
85                 return;
86
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.  */
91
92         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
93                 nmi_watchdog = NMI_LOCAL_APIC; 
94                 printk(KERN_INFO 
95               "Using local APIC NMI watchdog using perfctr0\n");
96         } else {
97                 printk(KERN_INFO "Using IO APIC NMI watchdog\n");
98                 nmi_watchdog = NMI_IO_APIC;
99         }
100 }
101
102 /* Why is there no CPUID flag for this? */
103 static __init int cpu_has_lapic(void)
104 {
105         switch (boot_cpu_data.x86_vendor) { 
106         case X86_VENDOR_INTEL:
107         case X86_VENDOR_AMD: 
108                 return boot_cpu_data.x86 >= 6; 
109         /* .... add more cpus here or find a different way to figure this out. */       
110         default:
111                 return 0;
112         }       
113 }
114
115 static int __init check_nmi_watchdog (void)
116 {
117         int counts[NR_CPUS];
118         int cpu;
119
120         if (nmi_watchdog == NMI_NONE)
121                 return 0;
122
123         if (nmi_watchdog == NMI_LOCAL_APIC && !cpu_has_lapic())  {
124                 nmi_watchdog = NMI_NONE;
125                 return -1; 
126         }       
127
128         printk(KERN_INFO "Testing NMI watchdog ... ");
129
130         for (cpu = 0; cpu < NR_CPUS; cpu++)
131                 counts[cpu] = cpu_pda[cpu].__nmi_count; 
132         local_irq_enable();
133         mdelay((10*1000)/nmi_hz); // wait 10 ticks
134
135         for (cpu = 0; cpu < NR_CPUS; cpu++) {
136                 if (cpu_pda[cpu].__nmi_count - counts[cpu] <= 5) {
137                         printk("CPU#%d: NMI appears to be stuck (%d)!\n", 
138                                cpu,
139                                cpu_pda[cpu].__nmi_count);
140                         nmi_active = 0;
141                         lapic_nmi_owner &= ~LAPIC_NMI_WATCHDOG;
142                         return -1;
143                 }
144         }
145         printk("OK.\n");
146
147         /* now that we know it works we can reduce NMI frequency to
148            something more reasonable; makes a difference in some configs */
149         if (nmi_watchdog == NMI_LOCAL_APIC)
150                 nmi_hz = 1;
151
152         return 0;
153 }
154 /* Have this called later during boot so counters are updating */
155 late_initcall(check_nmi_watchdog);
156
157 int __init setup_nmi_watchdog(char *str)
158 {
159         int nmi;
160
161         if (!strncmp(str,"panic",5)) {
162                 panic_on_timeout = 1;
163                 str = strchr(str, ',');
164                 if (!str)
165                         return 1;
166                 ++str;
167         }
168
169         get_option(&str, &nmi);
170
171         if (nmi >= NMI_INVALID)
172                 return 0;
173                 nmi_watchdog = nmi;
174         return 1;
175 }
176
177 __setup("nmi_watchdog=", setup_nmi_watchdog);
178
179 static void disable_lapic_nmi_watchdog(void)
180 {
181         if (nmi_active <= 0)
182                 return;
183         switch (boot_cpu_data.x86_vendor) {
184         case X86_VENDOR_AMD:
185                 wrmsr(MSR_K7_EVNTSEL0, 0, 0);
186                 break;
187         case X86_VENDOR_INTEL:
188                 wrmsr(MSR_IA32_EVNTSEL0, 0, 0);
189                 break;
190         }
191         nmi_active = -1;
192         /* tell do_nmi() and others that we're not active any more */
193         nmi_watchdog = 0;
194 }
195
196 static void enable_lapic_nmi_watchdog(void)
197 {
198         if (nmi_active < 0) {
199                 nmi_watchdog = NMI_LOCAL_APIC;
200                 setup_apic_nmi_watchdog();
201         }
202 }
203
204 int reserve_lapic_nmi(void)
205 {
206         unsigned int old_owner;
207
208         spin_lock(&lapic_nmi_owner_lock);
209         old_owner = lapic_nmi_owner;
210         lapic_nmi_owner |= LAPIC_NMI_RESERVED;
211         spin_unlock(&lapic_nmi_owner_lock);
212         if (old_owner & LAPIC_NMI_RESERVED)
213                 return -EBUSY;
214         if (old_owner & LAPIC_NMI_WATCHDOG)
215                 disable_lapic_nmi_watchdog();
216         return 0;
217 }
218
219 void release_lapic_nmi(void)
220 {
221         unsigned int new_owner;
222
223         spin_lock(&lapic_nmi_owner_lock);
224         new_owner = lapic_nmi_owner & ~LAPIC_NMI_RESERVED;
225         lapic_nmi_owner = new_owner;
226         spin_unlock(&lapic_nmi_owner_lock);
227         if (new_owner & LAPIC_NMI_WATCHDOG)
228                 enable_lapic_nmi_watchdog();
229 }
230
231 void disable_timer_nmi_watchdog(void)
232 {
233         if ((nmi_watchdog != NMI_IO_APIC) || (nmi_active <= 0))
234                 return;
235
236         disable_irq(0);
237         unset_nmi_callback();
238         nmi_active = -1;
239         nmi_watchdog = NMI_NONE;
240 }
241
242 void enable_timer_nmi_watchdog(void)
243 {
244         if (nmi_active < 0) {
245                 nmi_watchdog = NMI_IO_APIC;
246                 touch_nmi_watchdog();
247                 nmi_active = 1;
248                 enable_irq(0);
249         }
250 }
251
252 #ifdef CONFIG_PM
253
254 static int nmi_pm_active; /* nmi_active before suspend */
255
256 static int lapic_nmi_suspend(struct sys_device *dev, pm_message_t state)
257 {
258         nmi_pm_active = nmi_active;
259         disable_lapic_nmi_watchdog();
260         return 0;
261 }
262
263 static int lapic_nmi_resume(struct sys_device *dev)
264 {
265         if (nmi_pm_active > 0)
266         enable_lapic_nmi_watchdog();
267         return 0;
268 }
269
270 static struct sysdev_class nmi_sysclass = {
271         set_kset_name("lapic_nmi"),
272         .resume         = lapic_nmi_resume,
273         .suspend        = lapic_nmi_suspend,
274 };
275
276 static struct sys_device device_lapic_nmi = {
277         .id             = 0,
278         .cls    = &nmi_sysclass,
279 };
280
281 static int __init init_lapic_nmi_sysfs(void)
282 {
283         int error;
284
285         if (nmi_active == 0 || nmi_watchdog != NMI_LOCAL_APIC)
286                 return 0;
287
288         error = sysdev_class_register(&nmi_sysclass);
289         if (!error)
290                 error = sysdev_register(&device_lapic_nmi);
291         return error;
292 }
293 /* must come after the local APIC's device_initcall() */
294 late_initcall(init_lapic_nmi_sysfs);
295
296 #endif  /* CONFIG_PM */
297
298 /*
299  * Activate the NMI watchdog via the local APIC.
300  * Original code written by Keith Owens.
301  */
302
303 static void setup_k7_watchdog(void)
304 {
305         int i;
306         unsigned int evntsel;
307
308         /* No check, so can start with slow frequency */
309         nmi_hz = 1; 
310
311         /* XXX should check these in EFER */
312
313         nmi_perfctr_msr = MSR_K7_PERFCTR0;
314
315         for(i = 0; i < 4; ++i) {
316                 /* Simulator may not support it */
317                 if (checking_wrmsrl(MSR_K7_EVNTSEL0+i, 0UL))
318                         return;
319                 wrmsrl(MSR_K7_PERFCTR0+i, 0UL);
320         }
321
322         evntsel = K7_EVNTSEL_INT
323                 | K7_EVNTSEL_OS
324                 | K7_EVNTSEL_USR
325                 | K7_NMI_EVENT;
326
327         wrmsr(MSR_K7_EVNTSEL0, evntsel, 0);
328         wrmsrl(MSR_K7_PERFCTR0, -((u64)cpu_khz*1000) / nmi_hz);
329         apic_write(APIC_LVTPC, APIC_DM_NMI);
330         evntsel |= K7_EVNTSEL_ENABLE;
331         wrmsr(MSR_K7_EVNTSEL0, evntsel, 0);
332 }
333
334 void setup_apic_nmi_watchdog(void)
335 {
336         switch (boot_cpu_data.x86_vendor) {
337         case X86_VENDOR_AMD:
338                 if (boot_cpu_data.x86 != 15)
339                         return;
340                 if (strstr(boot_cpu_data.x86_model_id, "Screwdriver"))
341                         return;
342                 setup_k7_watchdog();
343                 break;
344         default:
345                 return;
346         }
347         lapic_nmi_owner = LAPIC_NMI_WATCHDOG;
348         nmi_active = 1;
349 }
350
351 /*
352  * the best way to detect whether a CPU has a 'hard lockup' problem
353  * is to check it's local APIC timer IRQ counts. If they are not
354  * changing then that CPU has some problem.
355  *
356  * as these watchdog NMI IRQs are generated on every CPU, we only
357  * have to check the current processor.
358  *
359  * since NMIs don't listen to _any_ locks, we have to be extremely
360  * careful not to rely on unsafe variables. The printk might lock
361  * up though, so we have to break up any console locks first ...
362  * [when there will be more tty-related locks, break them up
363  *  here too!]
364  */
365
366 static unsigned int
367         last_irq_sums [NR_CPUS],
368         alert_counter [NR_CPUS];
369
370 void touch_nmi_watchdog (void)
371 {
372         int i;
373
374         /*
375          * Just reset the alert counters, (other CPUs might be
376          * spinning on locks we hold):
377          */
378         for (i = 0; i < NR_CPUS; i++)
379                 alert_counter[i] = 0;
380 }
381
382 void nmi_watchdog_tick (struct pt_regs * regs, unsigned reason)
383 {
384         int sum, cpu;
385
386         cpu = safe_smp_processor_id();
387         sum = read_pda(apic_timer_irqs);
388         if (last_irq_sums[cpu] == sum) {
389                 /*
390                  * Ayiee, looks like this CPU is stuck ...
391                  * wait a few IRQs (5 seconds) before doing the oops ...
392                  */
393                 alert_counter[cpu]++;
394                 if (alert_counter[cpu] == 5*nmi_hz) {
395                         if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT)
396                                                         == NOTIFY_STOP) {
397                                 alert_counter[cpu] = 0; 
398                                 return;
399                         } 
400                         die_nmi("NMI Watchdog detected LOCKUP on CPU%d", regs);
401                 }
402         } else {
403                 last_irq_sums[cpu] = sum;
404                 alert_counter[cpu] = 0;
405         }
406         if (nmi_perfctr_msr)
407                 wrmsr(nmi_perfctr_msr, -(cpu_khz/nmi_hz*1000), -1);
408 }
409
410 static int dummy_nmi_callback(struct pt_regs * regs, int cpu)
411 {
412         return 0;
413 }
414  
415 static nmi_callback_t nmi_callback = dummy_nmi_callback;
416  
417 asmlinkage void do_nmi(struct pt_regs * regs, long error_code)
418 {
419         int cpu = safe_smp_processor_id();
420
421         nmi_enter();
422         add_pda(__nmi_count,1);
423         if (!nmi_callback(regs, cpu))
424                 default_do_nmi(regs);
425         nmi_exit();
426 }
427
428 void set_nmi_callback(nmi_callback_t callback)
429 {
430         nmi_callback = callback;
431 }
432
433 void unset_nmi_callback(void)
434 {
435         nmi_callback = dummy_nmi_callback;
436 }
437
438 #ifdef CONFIG_SYSCTL
439
440 static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu)
441 {
442         unsigned char reason = get_nmi_reason();
443         char buf[64];
444
445         if (!(reason & 0xc0)) {
446                 sprintf(buf, "NMI received for unknown reason %02x\n", reason);
447                 die_nmi(buf,regs);
448         }
449         return 0;
450 }
451
452 /*
453  * proc handler for /proc/sys/kernel/unknown_nmi_panic
454  */
455 int proc_unknown_nmi_panic(struct ctl_table *table, int write, struct file *file,
456                         void __user *buffer, size_t *length, loff_t *ppos)
457 {
458         int old_state;
459
460         old_state = unknown_nmi_panic;
461         proc_dointvec(table, write, file, buffer, length, ppos);
462         if (!!old_state == !!unknown_nmi_panic)
463                 return 0;
464
465         if (unknown_nmi_panic) {
466                 if (reserve_lapic_nmi() < 0) {
467                         unknown_nmi_panic = 0;
468                         return -EBUSY;
469                 } else {
470                         set_nmi_callback(unknown_nmi_panic_callback);
471                 }
472         } else {
473                 release_lapic_nmi();
474                 unset_nmi_callback();
475         }
476         return 0;
477 }
478
479 #endif
480
481 EXPORT_SYMBOL(nmi_active);
482 EXPORT_SYMBOL(nmi_watchdog);
483 EXPORT_SYMBOL(reserve_lapic_nmi);
484 EXPORT_SYMBOL(release_lapic_nmi);
485 EXPORT_SYMBOL(disable_timer_nmi_watchdog);
486 EXPORT_SYMBOL(enable_timer_nmi_watchdog);
487 EXPORT_SYMBOL(touch_nmi_watchdog);