Merge branch 'drm-patches' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied...
[linux-2.6] / arch / i386 / kernel / nmi.c
1 /*
2  *  linux/arch/i386/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  *  Mikael Pettersson   : Pentium 4 support for local APIC NMI watchdog.
12  *  Pavel Machek and
13  *  Mikael Pettersson   : PM converted to driver model. Disable/enable API.
14  */
15
16 #include <linux/delay.h>
17 #include <linux/interrupt.h>
18 #include <linux/module.h>
19 #include <linux/nmi.h>
20 #include <linux/sysdev.h>
21 #include <linux/sysctl.h>
22 #include <linux/percpu.h>
23 #include <linux/dmi.h>
24 #include <linux/kprobes.h>
25 #include <linux/cpumask.h>
26
27 #include <asm/smp.h>
28 #include <asm/nmi.h>
29 #include <asm/kdebug.h>
30 #include <asm/intel_arch_perfmon.h>
31
32 #include "mach_traps.h"
33
34 int unknown_nmi_panic;
35 int nmi_watchdog_enabled;
36
37 /* perfctr_nmi_owner tracks the ownership of the perfctr registers:
38  * evtsel_nmi_owner tracks the ownership of the event selection
39  * - different performance counters/ event selection may be reserved for
40  *   different subsystems this reservation system just tries to coordinate
41  *   things a little
42  */
43 static DEFINE_PER_CPU(unsigned long, perfctr_nmi_owner);
44 static DEFINE_PER_CPU(unsigned long, evntsel_nmi_owner[3]);
45
46 static cpumask_t backtrace_mask = CPU_MASK_NONE;
47
48 /* this number is calculated from Intel's MSR_P4_CRU_ESCR5 register and it's
49  * offset from MSR_P4_BSU_ESCR0.  It will be the max for all platforms (for now)
50  */
51 #define NMI_MAX_COUNTER_BITS 66
52
53 /* nmi_active:
54  * >0: the lapic NMI watchdog is active, but can be disabled
55  * <0: the lapic NMI watchdog has not been set up, and cannot
56  *     be enabled
57  *  0: the lapic NMI watchdog is disabled, but can be enabled
58  */
59 atomic_t nmi_active = ATOMIC_INIT(0);           /* oprofile uses this */
60
61 unsigned int nmi_watchdog = NMI_DEFAULT;
62 static unsigned int nmi_hz = HZ;
63
64 struct nmi_watchdog_ctlblk {
65         int enabled;
66         u64 check_bit;
67         unsigned int cccr_msr;
68         unsigned int perfctr_msr;  /* the MSR to reset in NMI handler */
69         unsigned int evntsel_msr;  /* the MSR to select the events to handle */
70 };
71 static DEFINE_PER_CPU(struct nmi_watchdog_ctlblk, nmi_watchdog_ctlblk);
72
73 /* local prototypes */
74 static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu);
75
76 extern void show_registers(struct pt_regs *regs);
77 extern int unknown_nmi_panic;
78
79 /* converts an msr to an appropriate reservation bit */
80 static inline unsigned int nmi_perfctr_msr_to_bit(unsigned int msr)
81 {
82         /* returns the bit offset of the performance counter register */
83         switch (boot_cpu_data.x86_vendor) {
84         case X86_VENDOR_AMD:
85                 return (msr - MSR_K7_PERFCTR0);
86         case X86_VENDOR_INTEL:
87                 if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON))
88                         return (msr - MSR_ARCH_PERFMON_PERFCTR0);
89
90                 switch (boot_cpu_data.x86) {
91                 case 6:
92                         return (msr - MSR_P6_PERFCTR0);
93                 case 15:
94                         return (msr - MSR_P4_BPU_PERFCTR0);
95                 }
96         }
97         return 0;
98 }
99
100 /* converts an msr to an appropriate reservation bit */
101 static inline unsigned int nmi_evntsel_msr_to_bit(unsigned int msr)
102 {
103         /* returns the bit offset of the event selection register */
104         switch (boot_cpu_data.x86_vendor) {
105         case X86_VENDOR_AMD:
106                 return (msr - MSR_K7_EVNTSEL0);
107         case X86_VENDOR_INTEL:
108                 if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON))
109                         return (msr - MSR_ARCH_PERFMON_EVENTSEL0);
110
111                 switch (boot_cpu_data.x86) {
112                 case 6:
113                         return (msr - MSR_P6_EVNTSEL0);
114                 case 15:
115                         return (msr - MSR_P4_BSU_ESCR0);
116                 }
117         }
118         return 0;
119 }
120
121 /* checks for a bit availability (hack for oprofile) */
122 int avail_to_resrv_perfctr_nmi_bit(unsigned int counter)
123 {
124         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
125
126         return (!test_bit(counter, &__get_cpu_var(perfctr_nmi_owner)));
127 }
128
129 /* checks the an msr for availability */
130 int avail_to_resrv_perfctr_nmi(unsigned int msr)
131 {
132         unsigned int counter;
133
134         counter = nmi_perfctr_msr_to_bit(msr);
135         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
136
137         return (!test_bit(counter, &__get_cpu_var(perfctr_nmi_owner)));
138 }
139
140 int reserve_perfctr_nmi(unsigned int msr)
141 {
142         unsigned int counter;
143
144         counter = nmi_perfctr_msr_to_bit(msr);
145         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
146
147         if (!test_and_set_bit(counter, &__get_cpu_var(perfctr_nmi_owner)))
148                 return 1;
149         return 0;
150 }
151
152 void release_perfctr_nmi(unsigned int msr)
153 {
154         unsigned int counter;
155
156         counter = nmi_perfctr_msr_to_bit(msr);
157         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
158
159         clear_bit(counter, &__get_cpu_var(perfctr_nmi_owner));
160 }
161
162 int reserve_evntsel_nmi(unsigned int msr)
163 {
164         unsigned int counter;
165
166         counter = nmi_evntsel_msr_to_bit(msr);
167         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
168
169         if (!test_and_set_bit(counter, &__get_cpu_var(evntsel_nmi_owner)[0]))
170                 return 1;
171         return 0;
172 }
173
174 void release_evntsel_nmi(unsigned int msr)
175 {
176         unsigned int counter;
177
178         counter = nmi_evntsel_msr_to_bit(msr);
179         BUG_ON(counter > NMI_MAX_COUNTER_BITS);
180
181         clear_bit(counter, &__get_cpu_var(evntsel_nmi_owner)[0]);
182 }
183
184 static __cpuinit inline int nmi_known_cpu(void)
185 {
186         switch (boot_cpu_data.x86_vendor) {
187         case X86_VENDOR_AMD:
188                 return ((boot_cpu_data.x86 == 15) || (boot_cpu_data.x86 == 6));
189         case X86_VENDOR_INTEL:
190                 if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON))
191                         return 1;
192                 else
193                         return ((boot_cpu_data.x86 == 15) || (boot_cpu_data.x86 == 6));
194         }
195         return 0;
196 }
197
198 #ifdef CONFIG_SMP
199 /* The performance counters used by NMI_LOCAL_APIC don't trigger when
200  * the CPU is idle. To make sure the NMI watchdog really ticks on all
201  * CPUs during the test make them busy.
202  */
203 static __init void nmi_cpu_busy(void *data)
204 {
205         volatile int *endflag = data;
206         local_irq_enable_in_hardirq();
207         /* Intentionally don't use cpu_relax here. This is
208            to make sure that the performance counter really ticks,
209            even if there is a simulator or similar that catches the
210            pause instruction. On a real HT machine this is fine because
211            all other CPUs are busy with "useless" delay loops and don't
212            care if they get somewhat less cycles. */
213         while (*endflag == 0)
214                 barrier();
215 }
216 #endif
217
218 static int __init check_nmi_watchdog(void)
219 {
220         volatile int endflag = 0;
221         unsigned int *prev_nmi_count;
222         int cpu;
223
224         /* Enable NMI watchdog for newer systems.
225            Probably safe on most older systems too, but let's be careful.
226            IBM ThinkPads use INT10 inside SMM and that allows early NMI inside SMM
227            which hangs the system. Disable watchdog for all thinkpads */
228         if (nmi_watchdog == NMI_DEFAULT && dmi_get_year(DMI_BIOS_DATE) >= 2004 &&
229                 !dmi_name_in_vendors("ThinkPad"))
230                 nmi_watchdog = NMI_LOCAL_APIC;
231
232         if ((nmi_watchdog == NMI_NONE) || (nmi_watchdog == NMI_DEFAULT))
233                 return 0;
234
235         if (!atomic_read(&nmi_active))
236                 return 0;
237
238         prev_nmi_count = kmalloc(NR_CPUS * sizeof(int), GFP_KERNEL);
239         if (!prev_nmi_count)
240                 return -1;
241
242         printk(KERN_INFO "Testing NMI watchdog ... ");
243
244         if (nmi_watchdog == NMI_LOCAL_APIC)
245                 smp_call_function(nmi_cpu_busy, (void *)&endflag, 0, 0);
246
247         for_each_possible_cpu(cpu)
248                 prev_nmi_count[cpu] = per_cpu(irq_stat, cpu).__nmi_count;
249         local_irq_enable();
250         mdelay((10*1000)/nmi_hz); // wait 10 ticks
251
252         for_each_possible_cpu(cpu) {
253 #ifdef CONFIG_SMP
254                 /* Check cpu_callin_map here because that is set
255                    after the timer is started. */
256                 if (!cpu_isset(cpu, cpu_callin_map))
257                         continue;
258 #endif
259                 if (!per_cpu(nmi_watchdog_ctlblk, cpu).enabled)
260                         continue;
261                 if (nmi_count(cpu) - prev_nmi_count[cpu] <= 5) {
262                         printk("CPU#%d: NMI appears to be stuck (%d->%d)!\n",
263                                 cpu,
264                                 prev_nmi_count[cpu],
265                                 nmi_count(cpu));
266                         per_cpu(nmi_watchdog_ctlblk, cpu).enabled = 0;
267                         atomic_dec(&nmi_active);
268                 }
269         }
270         if (!atomic_read(&nmi_active)) {
271                 kfree(prev_nmi_count);
272                 atomic_set(&nmi_active, -1);
273                 return -1;
274         }
275         endflag = 1;
276         printk("OK.\n");
277
278         /* now that we know it works we can reduce NMI frequency to
279            something more reasonable; makes a difference in some configs */
280         if (nmi_watchdog == NMI_LOCAL_APIC) {
281                 struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
282
283                 nmi_hz = 1;
284                 /*
285                  * On Intel CPUs with ARCH_PERFMON only 32 bits in the counter
286                  * are writable, with higher bits sign extending from bit 31.
287                  * So, we can only program the counter with 31 bit values and
288                  * 32nd bit should be 1, for 33.. to be 1.
289                  * Find the appropriate nmi_hz
290                  */
291                 if (wd->perfctr_msr == MSR_ARCH_PERFMON_PERFCTR0 &&
292                         ((u64)cpu_khz * 1000) > 0x7fffffffULL) {
293                         u64 count = (u64)cpu_khz * 1000;
294                         do_div(count, 0x7fffffffUL);
295                         nmi_hz = count + 1;
296                 }
297         }
298
299         kfree(prev_nmi_count);
300         return 0;
301 }
302 /* This needs to happen later in boot so counters are working */
303 late_initcall(check_nmi_watchdog);
304
305 static int __init setup_nmi_watchdog(char *str)
306 {
307         int nmi;
308
309         get_option(&str, &nmi);
310
311         if ((nmi >= NMI_INVALID) || (nmi < NMI_NONE))
312                 return 0;
313         /*
314          * If any other x86 CPU has a local APIC, then
315          * please test the NMI stuff there and send me the
316          * missing bits. Right now Intel P6/P4 and AMD K7 only.
317          */
318         if ((nmi == NMI_LOCAL_APIC) && (nmi_known_cpu() == 0))
319                 return 0;  /* no lapic support */
320         nmi_watchdog = nmi;
321         return 1;
322 }
323
324 __setup("nmi_watchdog=", setup_nmi_watchdog);
325
326 static void disable_lapic_nmi_watchdog(void)
327 {
328         BUG_ON(nmi_watchdog != NMI_LOCAL_APIC);
329
330         if (atomic_read(&nmi_active) <= 0)
331                 return;
332
333         on_each_cpu(stop_apic_nmi_watchdog, NULL, 0, 1);
334
335         BUG_ON(atomic_read(&nmi_active) != 0);
336 }
337
338 static void enable_lapic_nmi_watchdog(void)
339 {
340         BUG_ON(nmi_watchdog != NMI_LOCAL_APIC);
341
342         /* are we already enabled */
343         if (atomic_read(&nmi_active) != 0)
344                 return;
345
346         /* are we lapic aware */
347         if (nmi_known_cpu() <= 0)
348                 return;
349
350         on_each_cpu(setup_apic_nmi_watchdog, NULL, 0, 1);
351         touch_nmi_watchdog();
352 }
353
354 void disable_timer_nmi_watchdog(void)
355 {
356         BUG_ON(nmi_watchdog != NMI_IO_APIC);
357
358         if (atomic_read(&nmi_active) <= 0)
359                 return;
360
361         disable_irq(0);
362         on_each_cpu(stop_apic_nmi_watchdog, NULL, 0, 1);
363
364         BUG_ON(atomic_read(&nmi_active) != 0);
365 }
366
367 void enable_timer_nmi_watchdog(void)
368 {
369         BUG_ON(nmi_watchdog != NMI_IO_APIC);
370
371         if (atomic_read(&nmi_active) == 0) {
372                 touch_nmi_watchdog();
373                 on_each_cpu(setup_apic_nmi_watchdog, NULL, 0, 1);
374                 enable_irq(0);
375         }
376 }
377
378 #ifdef CONFIG_PM
379
380 static int nmi_pm_active; /* nmi_active before suspend */
381
382 static int lapic_nmi_suspend(struct sys_device *dev, pm_message_t state)
383 {
384         /* only CPU0 goes here, other CPUs should be offline */
385         nmi_pm_active = atomic_read(&nmi_active);
386         stop_apic_nmi_watchdog(NULL);
387         BUG_ON(atomic_read(&nmi_active) != 0);
388         return 0;
389 }
390
391 static int lapic_nmi_resume(struct sys_device *dev)
392 {
393         /* only CPU0 goes here, other CPUs should be offline */
394         if (nmi_pm_active > 0) {
395                 setup_apic_nmi_watchdog(NULL);
396                 touch_nmi_watchdog();
397         }
398         return 0;
399 }
400
401
402 static struct sysdev_class nmi_sysclass = {
403         set_kset_name("lapic_nmi"),
404         .resume         = lapic_nmi_resume,
405         .suspend        = lapic_nmi_suspend,
406 };
407
408 static struct sys_device device_lapic_nmi = {
409         .id     = 0,
410         .cls    = &nmi_sysclass,
411 };
412
413 static int __init init_lapic_nmi_sysfs(void)
414 {
415         int error;
416
417         /* should really be a BUG_ON but b/c this is an
418          * init call, it just doesn't work.  -dcz
419          */
420         if (nmi_watchdog != NMI_LOCAL_APIC)
421                 return 0;
422
423         if ( atomic_read(&nmi_active) < 0 )
424                 return 0;
425
426         error = sysdev_class_register(&nmi_sysclass);
427         if (!error)
428                 error = sysdev_register(&device_lapic_nmi);
429         return error;
430 }
431 /* must come after the local APIC's device_initcall() */
432 late_initcall(init_lapic_nmi_sysfs);
433
434 #endif  /* CONFIG_PM */
435
436 /*
437  * Activate the NMI watchdog via the local APIC.
438  * Original code written by Keith Owens.
439  */
440
441 static void write_watchdog_counter(unsigned int perfctr_msr, const char *descr)
442 {
443         u64 count = (u64)cpu_khz * 1000;
444
445         do_div(count, nmi_hz);
446         if(descr)
447                 Dprintk("setting %s to -0x%08Lx\n", descr, count);
448         wrmsrl(perfctr_msr, 0 - count);
449 }
450
451 /* Note that these events don't tick when the CPU idles. This means
452    the frequency varies with CPU load. */
453
454 #define K7_EVNTSEL_ENABLE       (1 << 22)
455 #define K7_EVNTSEL_INT          (1 << 20)
456 #define K7_EVNTSEL_OS           (1 << 17)
457 #define K7_EVNTSEL_USR          (1 << 16)
458 #define K7_EVENT_CYCLES_PROCESSOR_IS_RUNNING    0x76
459 #define K7_NMI_EVENT            K7_EVENT_CYCLES_PROCESSOR_IS_RUNNING
460
461 static int setup_k7_watchdog(void)
462 {
463         unsigned int perfctr_msr, evntsel_msr;
464         unsigned int evntsel;
465         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
466
467         perfctr_msr = MSR_K7_PERFCTR0;
468         evntsel_msr = MSR_K7_EVNTSEL0;
469         if (!reserve_perfctr_nmi(perfctr_msr))
470                 goto fail;
471
472         if (!reserve_evntsel_nmi(evntsel_msr))
473                 goto fail1;
474
475         wrmsrl(perfctr_msr, 0UL);
476
477         evntsel = K7_EVNTSEL_INT
478                 | K7_EVNTSEL_OS
479                 | K7_EVNTSEL_USR
480                 | K7_NMI_EVENT;
481
482         /* setup the timer */
483         wrmsr(evntsel_msr, evntsel, 0);
484         write_watchdog_counter(perfctr_msr, "K7_PERFCTR0");
485         apic_write(APIC_LVTPC, APIC_DM_NMI);
486         evntsel |= K7_EVNTSEL_ENABLE;
487         wrmsr(evntsel_msr, evntsel, 0);
488
489         wd->perfctr_msr = perfctr_msr;
490         wd->evntsel_msr = evntsel_msr;
491         wd->cccr_msr = 0;  //unused
492         wd->check_bit = 1ULL<<63;
493         return 1;
494 fail1:
495         release_perfctr_nmi(perfctr_msr);
496 fail:
497         return 0;
498 }
499
500 static void stop_k7_watchdog(void)
501 {
502         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
503
504         wrmsr(wd->evntsel_msr, 0, 0);
505
506         release_evntsel_nmi(wd->evntsel_msr);
507         release_perfctr_nmi(wd->perfctr_msr);
508 }
509
510 #define P6_EVNTSEL0_ENABLE      (1 << 22)
511 #define P6_EVNTSEL_INT          (1 << 20)
512 #define P6_EVNTSEL_OS           (1 << 17)
513 #define P6_EVNTSEL_USR          (1 << 16)
514 #define P6_EVENT_CPU_CLOCKS_NOT_HALTED  0x79
515 #define P6_NMI_EVENT            P6_EVENT_CPU_CLOCKS_NOT_HALTED
516
517 static int setup_p6_watchdog(void)
518 {
519         unsigned int perfctr_msr, evntsel_msr;
520         unsigned int evntsel;
521         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
522
523         perfctr_msr = MSR_P6_PERFCTR0;
524         evntsel_msr = MSR_P6_EVNTSEL0;
525         if (!reserve_perfctr_nmi(perfctr_msr))
526                 goto fail;
527
528         if (!reserve_evntsel_nmi(evntsel_msr))
529                 goto fail1;
530
531         wrmsrl(perfctr_msr, 0UL);
532
533         evntsel = P6_EVNTSEL_INT
534                 | P6_EVNTSEL_OS
535                 | P6_EVNTSEL_USR
536                 | P6_NMI_EVENT;
537
538         /* setup the timer */
539         wrmsr(evntsel_msr, evntsel, 0);
540         write_watchdog_counter(perfctr_msr, "P6_PERFCTR0");
541         apic_write(APIC_LVTPC, APIC_DM_NMI);
542         evntsel |= P6_EVNTSEL0_ENABLE;
543         wrmsr(evntsel_msr, evntsel, 0);
544
545         wd->perfctr_msr = perfctr_msr;
546         wd->evntsel_msr = evntsel_msr;
547         wd->cccr_msr = 0;  //unused
548         wd->check_bit = 1ULL<<39;
549         return 1;
550 fail1:
551         release_perfctr_nmi(perfctr_msr);
552 fail:
553         return 0;
554 }
555
556 static void stop_p6_watchdog(void)
557 {
558         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
559
560         wrmsr(wd->evntsel_msr, 0, 0);
561
562         release_evntsel_nmi(wd->evntsel_msr);
563         release_perfctr_nmi(wd->perfctr_msr);
564 }
565
566 /* Note that these events don't tick when the CPU idles. This means
567    the frequency varies with CPU load. */
568
569 #define MSR_P4_MISC_ENABLE_PERF_AVAIL   (1<<7)
570 #define P4_ESCR_EVENT_SELECT(N) ((N)<<25)
571 #define P4_ESCR_OS              (1<<3)
572 #define P4_ESCR_USR             (1<<2)
573 #define P4_CCCR_OVF_PMI0        (1<<26)
574 #define P4_CCCR_OVF_PMI1        (1<<27)
575 #define P4_CCCR_THRESHOLD(N)    ((N)<<20)
576 #define P4_CCCR_COMPLEMENT      (1<<19)
577 #define P4_CCCR_COMPARE         (1<<18)
578 #define P4_CCCR_REQUIRED        (3<<16)
579 #define P4_CCCR_ESCR_SELECT(N)  ((N)<<13)
580 #define P4_CCCR_ENABLE          (1<<12)
581 #define P4_CCCR_OVF             (1<<31)
582 /* Set up IQ_COUNTER0 to behave like a clock, by having IQ_CCCR0 filter
583    CRU_ESCR0 (with any non-null event selector) through a complemented
584    max threshold. [IA32-Vol3, Section 14.9.9] */
585
586 static int setup_p4_watchdog(void)
587 {
588         unsigned int perfctr_msr, evntsel_msr, cccr_msr;
589         unsigned int evntsel, cccr_val;
590         unsigned int misc_enable, dummy;
591         unsigned int ht_num;
592         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
593
594         rdmsr(MSR_IA32_MISC_ENABLE, misc_enable, dummy);
595         if (!(misc_enable & MSR_P4_MISC_ENABLE_PERF_AVAIL))
596                 return 0;
597
598 #ifdef CONFIG_SMP
599         /* detect which hyperthread we are on */
600         if (smp_num_siblings == 2) {
601                 unsigned int ebx, apicid;
602
603                 ebx = cpuid_ebx(1);
604                 apicid = (ebx >> 24) & 0xff;
605                 ht_num = apicid & 1;
606         } else
607 #endif
608                 ht_num = 0;
609
610         /* performance counters are shared resources
611          * assign each hyperthread its own set
612          * (re-use the ESCR0 register, seems safe
613          * and keeps the cccr_val the same)
614          */
615         if (!ht_num) {
616                 /* logical cpu 0 */
617                 perfctr_msr = MSR_P4_IQ_PERFCTR0;
618                 evntsel_msr = MSR_P4_CRU_ESCR0;
619                 cccr_msr = MSR_P4_IQ_CCCR0;
620                 cccr_val = P4_CCCR_OVF_PMI0 | P4_CCCR_ESCR_SELECT(4);
621         } else {
622                 /* logical cpu 1 */
623                 perfctr_msr = MSR_P4_IQ_PERFCTR1;
624                 evntsel_msr = MSR_P4_CRU_ESCR0;
625                 cccr_msr = MSR_P4_IQ_CCCR1;
626                 cccr_val = P4_CCCR_OVF_PMI1 | P4_CCCR_ESCR_SELECT(4);
627         }
628
629         if (!reserve_perfctr_nmi(perfctr_msr))
630                 goto fail;
631
632         if (!reserve_evntsel_nmi(evntsel_msr))
633                 goto fail1;
634
635         evntsel = P4_ESCR_EVENT_SELECT(0x3F)
636                 | P4_ESCR_OS
637                 | P4_ESCR_USR;
638
639         cccr_val |= P4_CCCR_THRESHOLD(15)
640                  | P4_CCCR_COMPLEMENT
641                  | P4_CCCR_COMPARE
642                  | P4_CCCR_REQUIRED;
643
644         wrmsr(evntsel_msr, evntsel, 0);
645         wrmsr(cccr_msr, cccr_val, 0);
646         write_watchdog_counter(perfctr_msr, "P4_IQ_COUNTER0");
647         apic_write(APIC_LVTPC, APIC_DM_NMI);
648         cccr_val |= P4_CCCR_ENABLE;
649         wrmsr(cccr_msr, cccr_val, 0);
650         wd->perfctr_msr = perfctr_msr;
651         wd->evntsel_msr = evntsel_msr;
652         wd->cccr_msr = cccr_msr;
653         wd->check_bit = 1ULL<<39;
654         return 1;
655 fail1:
656         release_perfctr_nmi(perfctr_msr);
657 fail:
658         return 0;
659 }
660
661 static void stop_p4_watchdog(void)
662 {
663         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
664
665         wrmsr(wd->cccr_msr, 0, 0);
666         wrmsr(wd->evntsel_msr, 0, 0);
667
668         release_evntsel_nmi(wd->evntsel_msr);
669         release_perfctr_nmi(wd->perfctr_msr);
670 }
671
672 #define ARCH_PERFMON_NMI_EVENT_SEL      ARCH_PERFMON_UNHALTED_CORE_CYCLES_SEL
673 #define ARCH_PERFMON_NMI_EVENT_UMASK    ARCH_PERFMON_UNHALTED_CORE_CYCLES_UMASK
674
675 static int setup_intel_arch_watchdog(void)
676 {
677         unsigned int ebx;
678         union cpuid10_eax eax;
679         unsigned int unused;
680         unsigned int perfctr_msr, evntsel_msr;
681         unsigned int evntsel;
682         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
683
684         /*
685          * Check whether the Architectural PerfMon supports
686          * Unhalted Core Cycles Event or not.
687          * NOTE: Corresponding bit = 0 in ebx indicates event present.
688          */
689         cpuid(10, &(eax.full), &ebx, &unused, &unused);
690         if ((eax.split.mask_length < (ARCH_PERFMON_UNHALTED_CORE_CYCLES_INDEX+1)) ||
691             (ebx & ARCH_PERFMON_UNHALTED_CORE_CYCLES_PRESENT))
692                 goto fail;
693
694         perfctr_msr = MSR_ARCH_PERFMON_PERFCTR0;
695         evntsel_msr = MSR_ARCH_PERFMON_EVENTSEL0;
696
697         if (!reserve_perfctr_nmi(perfctr_msr))
698                 goto fail;
699
700         if (!reserve_evntsel_nmi(evntsel_msr))
701                 goto fail1;
702
703         wrmsrl(perfctr_msr, 0UL);
704
705         evntsel = ARCH_PERFMON_EVENTSEL_INT
706                 | ARCH_PERFMON_EVENTSEL_OS
707                 | ARCH_PERFMON_EVENTSEL_USR
708                 | ARCH_PERFMON_NMI_EVENT_SEL
709                 | ARCH_PERFMON_NMI_EVENT_UMASK;
710
711         /* setup the timer */
712         wrmsr(evntsel_msr, evntsel, 0);
713         write_watchdog_counter(perfctr_msr, "INTEL_ARCH_PERFCTR0");
714         apic_write(APIC_LVTPC, APIC_DM_NMI);
715         evntsel |= ARCH_PERFMON_EVENTSEL0_ENABLE;
716         wrmsr(evntsel_msr, evntsel, 0);
717
718         wd->perfctr_msr = perfctr_msr;
719         wd->evntsel_msr = evntsel_msr;
720         wd->cccr_msr = 0;  //unused
721         wd->check_bit = 1ULL << (eax.split.bit_width - 1);
722         return 1;
723 fail1:
724         release_perfctr_nmi(perfctr_msr);
725 fail:
726         return 0;
727 }
728
729 static void stop_intel_arch_watchdog(void)
730 {
731         unsigned int ebx;
732         union cpuid10_eax eax;
733         unsigned int unused;
734         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
735
736         /*
737          * Check whether the Architectural PerfMon supports
738          * Unhalted Core Cycles Event or not.
739          * NOTE: Corresponding bit = 0 in ebx indicates event present.
740          */
741         cpuid(10, &(eax.full), &ebx, &unused, &unused);
742         if ((eax.split.mask_length < (ARCH_PERFMON_UNHALTED_CORE_CYCLES_INDEX+1)) ||
743             (ebx & ARCH_PERFMON_UNHALTED_CORE_CYCLES_PRESENT))
744                 return;
745
746         wrmsr(wd->evntsel_msr, 0, 0);
747         release_evntsel_nmi(wd->evntsel_msr);
748         release_perfctr_nmi(wd->perfctr_msr);
749 }
750
751 void setup_apic_nmi_watchdog (void *unused)
752 {
753         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
754
755         /* only support LOCAL and IO APICs for now */
756         if ((nmi_watchdog != NMI_LOCAL_APIC) &&
757             (nmi_watchdog != NMI_IO_APIC))
758                 return;
759
760         if (wd->enabled == 1)
761                 return;
762
763         /* cheap hack to support suspend/resume */
764         /* if cpu0 is not active neither should the other cpus */
765         if ((smp_processor_id() != 0) && (atomic_read(&nmi_active) <= 0))
766                 return;
767
768         if (nmi_watchdog == NMI_LOCAL_APIC) {
769                 switch (boot_cpu_data.x86_vendor) {
770                 case X86_VENDOR_AMD:
771                         if (boot_cpu_data.x86 != 6 && boot_cpu_data.x86 != 15)
772                                 return;
773                         if (!setup_k7_watchdog())
774                                 return;
775                         break;
776                 case X86_VENDOR_INTEL:
777                         if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON)) {
778                                 if (!setup_intel_arch_watchdog())
779                                         return;
780                                 break;
781                         }
782                         switch (boot_cpu_data.x86) {
783                         case 6:
784                                 if (boot_cpu_data.x86_model > 0xd)
785                                         return;
786
787                                 if (!setup_p6_watchdog())
788                                         return;
789                                 break;
790                         case 15:
791                                 if (boot_cpu_data.x86_model > 0x4)
792                                         return;
793
794                                 if (!setup_p4_watchdog())
795                                         return;
796                                 break;
797                         default:
798                                 return;
799                         }
800                         break;
801                 default:
802                         return;
803                 }
804         }
805         wd->enabled = 1;
806         atomic_inc(&nmi_active);
807 }
808
809 void stop_apic_nmi_watchdog(void *unused)
810 {
811         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
812
813         /* only support LOCAL and IO APICs for now */
814         if ((nmi_watchdog != NMI_LOCAL_APIC) &&
815             (nmi_watchdog != NMI_IO_APIC))
816                 return;
817
818         if (wd->enabled == 0)
819                 return;
820
821         if (nmi_watchdog == NMI_LOCAL_APIC) {
822                 switch (boot_cpu_data.x86_vendor) {
823                 case X86_VENDOR_AMD:
824                         stop_k7_watchdog();
825                         break;
826                 case X86_VENDOR_INTEL:
827                         if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON)) {
828                                 stop_intel_arch_watchdog();
829                                 break;
830                         }
831                         switch (boot_cpu_data.x86) {
832                         case 6:
833                                 if (boot_cpu_data.x86_model > 0xd)
834                                         break;
835                                 stop_p6_watchdog();
836                                 break;
837                         case 15:
838                                 if (boot_cpu_data.x86_model > 0x4)
839                                         break;
840                                 stop_p4_watchdog();
841                                 break;
842                         }
843                         break;
844                 default:
845                         return;
846                 }
847         }
848         wd->enabled = 0;
849         atomic_dec(&nmi_active);
850 }
851
852 /*
853  * the best way to detect whether a CPU has a 'hard lockup' problem
854  * is to check it's local APIC timer IRQ counts. If they are not
855  * changing then that CPU has some problem.
856  *
857  * as these watchdog NMI IRQs are generated on every CPU, we only
858  * have to check the current processor.
859  *
860  * since NMIs don't listen to _any_ locks, we have to be extremely
861  * careful not to rely on unsafe variables. The printk might lock
862  * up though, so we have to break up any console locks first ...
863  * [when there will be more tty-related locks, break them up
864  *  here too!]
865  */
866
867 static unsigned int
868         last_irq_sums [NR_CPUS],
869         alert_counter [NR_CPUS];
870
871 void touch_nmi_watchdog (void)
872 {
873         if (nmi_watchdog > 0) {
874                 unsigned cpu;
875
876                 /*
877                  * Just reset the alert counters, (other CPUs might be
878                  * spinning on locks we hold):
879                  */
880                 for_each_present_cpu (cpu)
881                         alert_counter[cpu] = 0;
882         }
883
884         /*
885          * Tickle the softlockup detector too:
886          */
887         touch_softlockup_watchdog();
888 }
889 EXPORT_SYMBOL(touch_nmi_watchdog);
890
891 extern void die_nmi(struct pt_regs *, const char *msg);
892
893 __kprobes int nmi_watchdog_tick(struct pt_regs * regs, unsigned reason)
894 {
895
896         /*
897          * Since current_thread_info()-> is always on the stack, and we
898          * always switch the stack NMI-atomically, it's safe to use
899          * smp_processor_id().
900          */
901         unsigned int sum;
902         int touched = 0;
903         int cpu = smp_processor_id();
904         struct nmi_watchdog_ctlblk *wd = &__get_cpu_var(nmi_watchdog_ctlblk);
905         u64 dummy;
906         int rc=0;
907
908         /* check for other users first */
909         if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT)
910                         == NOTIFY_STOP) {
911                 rc = 1;
912                 touched = 1;
913         }
914
915         if (cpu_isset(cpu, backtrace_mask)) {
916                 static DEFINE_SPINLOCK(lock);   /* Serialise the printks */
917
918                 spin_lock(&lock);
919                 printk("NMI backtrace for cpu %d\n", cpu);
920                 dump_stack();
921                 spin_unlock(&lock);
922                 cpu_clear(cpu, backtrace_mask);
923         }
924
925         sum = per_cpu(irq_stat, cpu).apic_timer_irqs;
926
927         /* if the apic timer isn't firing, this cpu isn't doing much */
928         if (!touched && last_irq_sums[cpu] == sum) {
929                 /*
930                  * Ayiee, looks like this CPU is stuck ...
931                  * wait a few IRQs (5 seconds) before doing the oops ...
932                  */
933                 alert_counter[cpu]++;
934                 if (alert_counter[cpu] == 5*nmi_hz)
935                         /*
936                          * die_nmi will return ONLY if NOTIFY_STOP happens..
937                          */
938                         die_nmi(regs, "BUG: NMI Watchdog detected LOCKUP");
939         } else {
940                 last_irq_sums[cpu] = sum;
941                 alert_counter[cpu] = 0;
942         }
943         /* see if the nmi watchdog went off */
944         if (wd->enabled) {
945                 if (nmi_watchdog == NMI_LOCAL_APIC) {
946                         rdmsrl(wd->perfctr_msr, dummy);
947                         if (dummy & wd->check_bit){
948                                 /* this wasn't a watchdog timer interrupt */
949                                 goto done;
950                         }
951
952                         /* only Intel P4 uses the cccr msr */
953                         if (wd->cccr_msr != 0) {
954                                 /*
955                                  * P4 quirks:
956                                  * - An overflown perfctr will assert its interrupt
957                                  *   until the OVF flag in its CCCR is cleared.
958                                  * - LVTPC is masked on interrupt and must be
959                                  *   unmasked by the LVTPC handler.
960                                  */
961                                 rdmsrl(wd->cccr_msr, dummy);
962                                 dummy &= ~P4_CCCR_OVF;
963                                 wrmsrl(wd->cccr_msr, dummy);
964                                 apic_write(APIC_LVTPC, APIC_DM_NMI);
965                         }
966                         else if (wd->perfctr_msr == MSR_P6_PERFCTR0 ||
967                                  wd->perfctr_msr == MSR_ARCH_PERFMON_PERFCTR0) {
968                                 /* P6 based Pentium M need to re-unmask
969                                  * the apic vector but it doesn't hurt
970                                  * other P6 variant.
971                                  * ArchPerfom/Core Duo also needs this */
972                                 apic_write(APIC_LVTPC, APIC_DM_NMI);
973                         }
974                         /* start the cycle over again */
975                         write_watchdog_counter(wd->perfctr_msr, NULL);
976                         rc = 1;
977                 } else if (nmi_watchdog == NMI_IO_APIC) {
978                         /* don't know how to accurately check for this.
979                          * just assume it was a watchdog timer interrupt
980                          * This matches the old behaviour.
981                          */
982                         rc = 1;
983                 }
984         }
985 done:
986         return rc;
987 }
988
989 int do_nmi_callback(struct pt_regs * regs, int cpu)
990 {
991 #ifdef CONFIG_SYSCTL
992         if (unknown_nmi_panic)
993                 return unknown_nmi_panic_callback(regs, cpu);
994 #endif
995         return 0;
996 }
997
998 #ifdef CONFIG_SYSCTL
999
1000 static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu)
1001 {
1002         unsigned char reason = get_nmi_reason();
1003         char buf[64];
1004
1005         sprintf(buf, "NMI received for unknown reason %02x\n", reason);
1006         die_nmi(regs, buf);
1007         return 0;
1008 }
1009
1010 /*
1011  * proc handler for /proc/sys/kernel/nmi
1012  */
1013 int proc_nmi_enabled(struct ctl_table *table, int write, struct file *file,
1014                         void __user *buffer, size_t *length, loff_t *ppos)
1015 {
1016         int old_state;
1017
1018         nmi_watchdog_enabled = (atomic_read(&nmi_active) > 0) ? 1 : 0;
1019         old_state = nmi_watchdog_enabled;
1020         proc_dointvec(table, write, file, buffer, length, ppos);
1021         if (!!old_state == !!nmi_watchdog_enabled)
1022                 return 0;
1023
1024         if (atomic_read(&nmi_active) < 0) {
1025                 printk( KERN_WARNING "NMI watchdog is permanently disabled\n");
1026                 return -EIO;
1027         }
1028
1029         if (nmi_watchdog == NMI_DEFAULT) {
1030                 if (nmi_known_cpu() > 0)
1031                         nmi_watchdog = NMI_LOCAL_APIC;
1032                 else
1033                         nmi_watchdog = NMI_IO_APIC;
1034         }
1035
1036         if (nmi_watchdog == NMI_LOCAL_APIC) {
1037                 if (nmi_watchdog_enabled)
1038                         enable_lapic_nmi_watchdog();
1039                 else
1040                         disable_lapic_nmi_watchdog();
1041         } else {
1042                 printk( KERN_WARNING
1043                         "NMI watchdog doesn't know what hardware to touch\n");
1044                 return -EIO;
1045         }
1046         return 0;
1047 }
1048
1049 #endif
1050
1051 void __trigger_all_cpu_backtrace(void)
1052 {
1053         int i;
1054
1055         backtrace_mask = cpu_online_map;
1056         /* Wait for up to 10 seconds for all CPUs to do the backtrace */
1057         for (i = 0; i < 10 * 1000; i++) {
1058                 if (cpus_empty(backtrace_mask))
1059                         break;
1060                 mdelay(1);
1061         }
1062 }
1063
1064 EXPORT_SYMBOL(nmi_active);
1065 EXPORT_SYMBOL(nmi_watchdog);
1066 EXPORT_SYMBOL(avail_to_resrv_perfctr_nmi);
1067 EXPORT_SYMBOL(avail_to_resrv_perfctr_nmi_bit);
1068 EXPORT_SYMBOL(reserve_perfctr_nmi);
1069 EXPORT_SYMBOL(release_perfctr_nmi);
1070 EXPORT_SYMBOL(reserve_evntsel_nmi);
1071 EXPORT_SYMBOL(release_evntsel_nmi);
1072 EXPORT_SYMBOL(disable_timer_nmi_watchdog);
1073 EXPORT_SYMBOL(enable_timer_nmi_watchdog);