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