Merge ../torvalds-2.6/
[linux-2.6] / arch / x86_64 / kernel / mce.c
1 /*
2  * Machine check handler.
3  * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
4  * Rest from unknown author(s). 
5  * 2004 Andi Kleen. Rewrote most of it. 
6  */
7
8 #include <linux/init.h>
9 #include <linux/types.h>
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/string.h>
13 #include <linux/rcupdate.h>
14 #include <linux/kallsyms.h>
15 #include <linux/sysdev.h>
16 #include <linux/miscdevice.h>
17 #include <linux/fs.h>
18 #include <linux/cpu.h>
19 #include <linux/percpu.h>
20 #include <linux/ctype.h>
21 #include <asm/processor.h> 
22 #include <asm/msr.h>
23 #include <asm/mce.h>
24 #include <asm/kdebug.h>
25 #include <asm/uaccess.h>
26
27 #define MISC_MCELOG_MINOR 227
28 #define NR_BANKS 5
29
30 static int mce_dont_init;
31
32 /* 0: always panic, 1: panic if deadlock possible, 2: try to avoid panic,
33    3: never panic or exit (for testing only) */
34 static int tolerant = 1;
35 static int banks;
36 static unsigned long bank[NR_BANKS] = { [0 ... NR_BANKS-1] = ~0UL };
37 static unsigned long console_logged;
38 static int notify_user;
39 static int rip_msr;
40 static int mce_bootlog;
41
42 /*
43  * Lockless MCE logging infrastructure.
44  * This avoids deadlocks on printk locks without having to break locks. Also
45  * separate MCEs from kernel messages to avoid bogus bug reports.
46  */
47
48 struct mce_log mcelog = { 
49         MCE_LOG_SIGNATURE,
50         MCE_LOG_LEN,
51 }; 
52
53 void mce_log(struct mce *mce)
54 {
55         unsigned next, entry;
56         mce->finished = 0;
57         smp_wmb();
58         for (;;) {
59                 entry = rcu_dereference(mcelog.next);
60                 for (;;) {
61                         /* When the buffer fills up discard new entries. Assume
62                            that the earlier errors are the more interesting. */
63                         if (entry >= MCE_LOG_LEN) {
64                                 set_bit(MCE_OVERFLOW, &mcelog.flags);
65                                 return;
66                         }
67                         /* Old left over entry. Skip. */
68                         if (mcelog.entry[entry].finished) {
69                                 entry++;
70                                 continue;
71                         }
72                 }
73                 smp_rmb();
74                 next = entry + 1;
75                 if (cmpxchg(&mcelog.next, entry, next) == entry)
76                         break;
77         }
78         memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
79         smp_wmb();
80         mcelog.entry[entry].finished = 1;
81         smp_wmb();
82
83         if (!test_and_set_bit(0, &console_logged))
84                 notify_user = 1;
85 }
86
87 static void print_mce(struct mce *m)
88 {
89         printk(KERN_EMERG "\n"
90                KERN_EMERG
91                "CPU %d: Machine Check Exception: %16Lx Bank %d: %016Lx\n",
92                m->cpu, m->mcgstatus, m->bank, m->status);
93         if (m->rip) {
94                 printk(KERN_EMERG 
95                        "RIP%s %02x:<%016Lx> ",
96                        !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
97                        m->cs, m->rip);
98                 if (m->cs == __KERNEL_CS)
99                         print_symbol("{%s}", m->rip);
100                 printk("\n");
101         }
102         printk(KERN_EMERG "TSC %Lx ", m->tsc); 
103         if (m->addr)
104                 printk("ADDR %Lx ", m->addr);
105         if (m->misc)
106                 printk("MISC %Lx ", m->misc);   
107         printk("\n");
108 }
109
110 static void mce_panic(char *msg, struct mce *backup, unsigned long start)
111
112         int i;
113         oops_begin();
114         for (i = 0; i < MCE_LOG_LEN; i++) {
115                 unsigned long tsc = mcelog.entry[i].tsc;
116                 if (time_before(tsc, start))
117                         continue;
118                 print_mce(&mcelog.entry[i]); 
119                 if (backup && mcelog.entry[i].tsc == backup->tsc)
120                         backup = NULL;
121         }
122         if (backup)
123                 print_mce(backup);
124         if (tolerant >= 3)
125                 printk("Fake panic: %s\n", msg);
126         else
127                 panic(msg);
128
129
130 static int mce_available(struct cpuinfo_x86 *c)
131 {
132         return test_bit(X86_FEATURE_MCE, &c->x86_capability) &&
133                test_bit(X86_FEATURE_MCA, &c->x86_capability);
134 }
135
136 static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
137 {
138         if (regs && (m->mcgstatus & MCG_STATUS_RIPV)) {
139                 m->rip = regs->rip;
140                 m->cs = regs->cs;
141         } else {
142                 m->rip = 0;
143                 m->cs = 0;
144         }
145         if (rip_msr) {
146                 /* Assume the RIP in the MSR is exact. Is this true? */
147                 m->mcgstatus |= MCG_STATUS_EIPV;
148                 rdmsrl(rip_msr, m->rip);
149                 m->cs = 0;
150         }
151 }
152
153 /* 
154  * The actual machine check handler
155  */
156
157 void do_machine_check(struct pt_regs * regs, long error_code)
158 {
159         struct mce m, panicm;
160         int nowayout = (tolerant < 1); 
161         int kill_it = 0;
162         u64 mcestart = 0;
163         int i;
164         int panicm_found = 0;
165
166         if (regs)
167                 notify_die(DIE_NMI, "machine check", regs, error_code, 255, SIGKILL);
168         if (!banks)
169                 return;
170
171         memset(&m, 0, sizeof(struct mce));
172         m.cpu = hard_smp_processor_id();
173         rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus);
174         if (!(m.mcgstatus & MCG_STATUS_RIPV))
175                 kill_it = 1;
176         
177         rdtscll(mcestart);
178         barrier();
179
180         for (i = 0; i < banks; i++) {
181                 if (!bank[i])
182                         continue;
183                 
184                 m.misc = 0; 
185                 m.addr = 0;
186                 m.bank = i;
187                 m.tsc = 0;
188
189                 rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status);
190                 if ((m.status & MCI_STATUS_VAL) == 0)
191                         continue;
192
193                 if (m.status & MCI_STATUS_EN) {
194                         /* In theory _OVER could be a nowayout too, but
195                            assume any overflowed errors were no fatal. */
196                         nowayout |= !!(m.status & MCI_STATUS_PCC);
197                         kill_it |= !!(m.status & MCI_STATUS_UC);
198                 }
199
200                 if (m.status & MCI_STATUS_MISCV)
201                         rdmsrl(MSR_IA32_MC0_MISC + i*4, m.misc);
202                 if (m.status & MCI_STATUS_ADDRV)
203                         rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr);
204
205                 mce_get_rip(&m, regs);
206                 if (error_code >= 0)
207                         rdtscll(m.tsc);
208                 wrmsrl(MSR_IA32_MC0_STATUS + i*4, 0);
209                 if (error_code != -2)
210                         mce_log(&m);
211
212                 /* Did this bank cause the exception? */
213                 /* Assume that the bank with uncorrectable errors did it,
214                    and that there is only a single one. */
215                 if ((m.status & MCI_STATUS_UC) && (m.status & MCI_STATUS_EN)) {
216                         panicm = m;
217                         panicm_found = 1;
218                 }
219
220                 tainted |= TAINT_MACHINE_CHECK;
221         }
222
223         /* Never do anything final in the polling timer */
224         if (!regs)
225                 goto out;
226
227         /* If we didn't find an uncorrectable error, pick
228            the last one (shouldn't happen, just being safe). */
229         if (!panicm_found)
230                 panicm = m;
231         if (nowayout)
232                 mce_panic("Machine check", &panicm, mcestart);
233         if (kill_it) {
234                 int user_space = 0;
235
236                 if (m.mcgstatus & MCG_STATUS_RIPV)
237                         user_space = panicm.rip && (panicm.cs & 3);
238                 
239                 /* When the machine was in user space and the CPU didn't get
240                    confused it's normally not necessary to panic, unless you 
241                    are paranoid (tolerant == 0)
242
243                    RED-PEN could be more tolerant for MCEs in idle,
244                    but most likely they occur at boot anyways, where
245                    it is best to just halt the machine. */
246                 if ((!user_space && (panic_on_oops || tolerant < 2)) ||
247                     (unsigned)current->pid <= 1)
248                         mce_panic("Uncorrected machine check", &panicm, mcestart);
249
250                 /* do_exit takes an awful lot of locks and has as
251                    slight risk of deadlocking. If you don't want that
252                    don't set tolerant >= 2 */
253                 if (tolerant < 3)
254                         do_exit(SIGBUS);
255         }
256
257  out:
258         /* Last thing done in the machine check exception to clear state. */
259         wrmsrl(MSR_IA32_MCG_STATUS, 0);
260 }
261
262 /*
263  * Periodic polling timer for "silent" machine check errors.
264  */
265
266 static int check_interval = 5 * 60; /* 5 minutes */
267 static void mcheck_timer(void *data);
268 static DECLARE_WORK(mcheck_work, mcheck_timer, NULL);
269
270 static void mcheck_check_cpu(void *info)
271 {
272         if (mce_available(&current_cpu_data))
273                 do_machine_check(NULL, 0);
274 }
275
276 static void mcheck_timer(void *data)
277 {
278         on_each_cpu(mcheck_check_cpu, NULL, 1, 1);
279         schedule_delayed_work(&mcheck_work, check_interval * HZ);
280
281         /*
282          * It's ok to read stale data here for notify_user and
283          * console_logged as we'll simply get the updated versions
284          * on the next mcheck_timer execution and atomic operations
285          * on console_logged act as synchronization for notify_user
286          * writes.
287          */
288         if (notify_user && console_logged) {
289                 notify_user = 0;
290                 clear_bit(0, &console_logged);
291                 printk(KERN_INFO "Machine check events logged\n");
292         }
293 }
294
295
296 static __init int periodic_mcheck_init(void)
297
298         if (check_interval)
299                 schedule_delayed_work(&mcheck_work, check_interval*HZ);
300         return 0;
301
302 __initcall(periodic_mcheck_init);
303
304
305 /* 
306  * Initialize Machine Checks for a CPU.
307  */
308 static void mce_init(void *dummy)
309 {
310         u64 cap;
311         int i;
312
313         rdmsrl(MSR_IA32_MCG_CAP, cap);
314         banks = cap & 0xff;
315         if (banks > NR_BANKS) { 
316                 printk(KERN_INFO "MCE: warning: using only %d banks\n", banks);
317                 banks = NR_BANKS; 
318         }
319         /* Use accurate RIP reporting if available. */
320         if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9)
321                 rip_msr = MSR_IA32_MCG_EIP;
322
323         /* Log the machine checks left over from the previous reset.
324            This also clears all registers */
325         do_machine_check(NULL, mce_bootlog ? -1 : -2);
326
327         set_in_cr4(X86_CR4_MCE);
328
329         if (cap & MCG_CTL_P)
330                 wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff);
331
332         for (i = 0; i < banks; i++) {
333                 wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]);
334                 wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
335         }       
336 }
337
338 /* Add per CPU specific workarounds here */
339 static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
340
341         /* This should be disabled by the BIOS, but isn't always */
342         if (c->x86_vendor == X86_VENDOR_AMD && c->x86 == 15) {
343                 /* disable GART TBL walk error reporting, which trips off 
344                    incorrectly with the IOMMU & 3ware & Cerberus. */
345                 clear_bit(10, &bank[4]);
346         }
347 }                       
348
349 static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
350 {
351         switch (c->x86_vendor) {
352         case X86_VENDOR_INTEL:
353                 mce_intel_feature_init(c);
354                 break;
355         default:
356                 break;
357         }
358 }
359
360 /* 
361  * Called for each booted CPU to set up machine checks.
362  * Must be called with preempt off. 
363  */
364 void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
365 {
366         static cpumask_t mce_cpus __initdata = CPU_MASK_NONE;
367
368         mce_cpu_quirks(c); 
369
370         if (mce_dont_init ||
371             cpu_test_and_set(smp_processor_id(), mce_cpus) ||
372             !mce_available(c))
373                 return;
374
375         mce_init(NULL);
376         mce_cpu_features(c);
377 }
378
379 /*
380  * Character device to read and clear the MCE log.
381  */
382
383 static void collect_tscs(void *data) 
384
385         unsigned long *cpu_tsc = (unsigned long *)data;
386         rdtscll(cpu_tsc[smp_processor_id()]);
387
388
389 static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, loff_t *off)
390 {
391         unsigned long *cpu_tsc;
392         static DECLARE_MUTEX(mce_read_sem);
393         unsigned next;
394         char __user *buf = ubuf;
395         int i, err;
396
397         cpu_tsc = kmalloc(NR_CPUS * sizeof(long), GFP_KERNEL);
398         if (!cpu_tsc)
399                 return -ENOMEM;
400
401         down(&mce_read_sem); 
402         next = rcu_dereference(mcelog.next);
403
404         /* Only supports full reads right now */
405         if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) { 
406                 up(&mce_read_sem);
407                 kfree(cpu_tsc);
408                 return -EINVAL;
409         }
410
411         err = 0;
412         for (i = 0; i < next; i++) {            
413                 unsigned long start = jiffies;
414                 while (!mcelog.entry[i].finished) {
415                         if (!time_before(jiffies, start + 2)) {
416                                 memset(mcelog.entry + i,0, sizeof(struct mce));
417                                 continue;
418                         }
419                         cpu_relax();
420                 }
421                 smp_rmb();
422                 err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce));
423                 buf += sizeof(struct mce); 
424         } 
425
426         memset(mcelog.entry, 0, next * sizeof(struct mce));
427         mcelog.next = 0;
428
429         synchronize_sched();
430
431         /* Collect entries that were still getting written before the synchronize. */
432
433         on_each_cpu(collect_tscs, cpu_tsc, 1, 1);
434         for (i = next; i < MCE_LOG_LEN; i++) { 
435                 if (mcelog.entry[i].finished && 
436                     mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {  
437                         err |= copy_to_user(buf, mcelog.entry+i, sizeof(struct mce));
438                         smp_rmb();
439                         buf += sizeof(struct mce);
440                         memset(&mcelog.entry[i], 0, sizeof(struct mce));
441                 }
442         }       
443         up(&mce_read_sem);
444         kfree(cpu_tsc);
445         return err ? -EFAULT : buf - ubuf; 
446 }
447
448 static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd, unsigned long arg)
449 {
450         int __user *p = (int __user *)arg;
451         if (!capable(CAP_SYS_ADMIN))
452                 return -EPERM; 
453         switch (cmd) {
454         case MCE_GET_RECORD_LEN: 
455                 return put_user(sizeof(struct mce), p);
456         case MCE_GET_LOG_LEN:
457                 return put_user(MCE_LOG_LEN, p);                
458         case MCE_GETCLEAR_FLAGS: {
459                 unsigned flags;
460                 do { 
461                         flags = mcelog.flags;
462                 } while (cmpxchg(&mcelog.flags, flags, 0) != flags); 
463                 return put_user(flags, p); 
464         }
465         default:
466                 return -ENOTTY; 
467         } 
468 }
469
470 static struct file_operations mce_chrdev_ops = {
471         .read = mce_read,
472         .ioctl = mce_ioctl,
473 };
474
475 static struct miscdevice mce_log_device = {
476         MISC_MCELOG_MINOR,
477         "mcelog",
478         &mce_chrdev_ops,
479 };
480
481 /* 
482  * Old style boot options parsing. Only for compatibility. 
483  */
484
485 static int __init mcheck_disable(char *str)
486 {
487         mce_dont_init = 1;
488         return 0;
489 }
490
491 /* mce=off disables machine check. Note you can reenable it later
492    using sysfs.
493    mce=TOLERANCELEVEL (number, see above)
494    mce=bootlog Log MCEs from before booting. Disabled by default to work
495    around buggy BIOS that leave bogus MCEs.  */
496 static int __init mcheck_enable(char *str)
497 {
498         if (*str == '=')
499                 str++;
500         if (!strcmp(str, "off"))
501                 mce_dont_init = 1;
502         else if (!strcmp(str, "bootlog"))
503                 mce_bootlog = 1;
504         else if (isdigit(str[0]))
505                 get_option(&str, &tolerant);
506         else
507                 printk("mce= argument %s ignored. Please use /sys", str); 
508         return 0;
509 }
510
511 __setup("nomce", mcheck_disable);
512 __setup("mce", mcheck_enable);
513
514 /* 
515  * Sysfs support
516  */ 
517
518 /* On resume clear all MCE state. Don't want to see leftovers from the BIOS.
519    Only one CPU is active at this time, the others get readded later using
520    CPU hotplug. */
521 static int mce_resume(struct sys_device *dev)
522 {
523         mce_init(NULL);
524         return 0;
525 }
526
527 /* Reinit MCEs after user configuration changes */
528 static void mce_restart(void) 
529
530         if (check_interval)
531                 cancel_delayed_work(&mcheck_work);
532         /* Timer race is harmless here */
533         on_each_cpu(mce_init, NULL, 1, 1);       
534         if (check_interval)
535                 schedule_delayed_work(&mcheck_work, check_interval*HZ);
536 }
537
538 static struct sysdev_class mce_sysclass = {
539         .resume = mce_resume,
540         set_kset_name("machinecheck"),
541 };
542
543 static DEFINE_PER_CPU(struct sys_device, device_mce);
544
545 /* Why are there no generic functions for this? */
546 #define ACCESSOR(name, var, start) \
547         static ssize_t show_ ## name(struct sys_device *s, char *buf) {                    \
548                 return sprintf(buf, "%lx\n", (unsigned long)var);                  \
549         }                                                                          \
550         static ssize_t set_ ## name(struct sys_device *s,const char *buf,size_t siz) { \
551                 char *end;                                                         \
552                 unsigned long new = simple_strtoul(buf, &end, 0);                  \
553                 if (end == buf) return -EINVAL;                                    \
554                 var = new;                                                         \
555                 start;                                                             \
556                 return end-buf;                                                    \
557         }                                                                          \
558         static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name);
559
560 ACCESSOR(bank0ctl,bank[0],mce_restart())
561 ACCESSOR(bank1ctl,bank[1],mce_restart())
562 ACCESSOR(bank2ctl,bank[2],mce_restart())
563 ACCESSOR(bank3ctl,bank[3],mce_restart())
564 ACCESSOR(bank4ctl,bank[4],mce_restart())
565 ACCESSOR(tolerant,tolerant,)
566 ACCESSOR(check_interval,check_interval,mce_restart())
567
568 /* Per cpu sysdev init.  All of the cpus still share the same ctl bank */
569 static __cpuinit int mce_create_device(unsigned int cpu)
570 {
571         int err;
572         if (!mce_available(&cpu_data[cpu]))
573                 return -EIO;
574
575         per_cpu(device_mce,cpu).id = cpu;
576         per_cpu(device_mce,cpu).cls = &mce_sysclass;
577
578         err = sysdev_register(&per_cpu(device_mce,cpu));
579
580         if (!err) {
581                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank0ctl);
582                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank1ctl);
583                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank2ctl);
584                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank3ctl);
585                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank4ctl);
586                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_tolerant);
587                 sysdev_create_file(&per_cpu(device_mce,cpu), &attr_check_interval);
588         }
589         return err;
590 }
591
592 #ifdef CONFIG_HOTPLUG_CPU
593 static __cpuinit void mce_remove_device(unsigned int cpu)
594 {
595         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank0ctl);
596         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank1ctl);
597         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank2ctl);
598         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank3ctl);
599         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank4ctl);
600         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_tolerant);
601         sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_check_interval);
602         sysdev_unregister(&per_cpu(device_mce,cpu));
603 }
604 #endif
605
606 /* Get notified when a cpu comes on/off. Be hotplug friendly. */
607 static __cpuinit int
608 mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
609 {
610         unsigned int cpu = (unsigned long)hcpu;
611
612         switch (action) {
613         case CPU_ONLINE:
614                 mce_create_device(cpu);
615                 break;
616 #ifdef CONFIG_HOTPLUG_CPU
617         case CPU_DEAD:
618                 mce_remove_device(cpu);
619                 break;
620 #endif
621         }
622         return NOTIFY_OK;
623 }
624
625 static struct notifier_block mce_cpu_notifier = {
626         .notifier_call = mce_cpu_callback,
627 };
628
629 static __init int mce_init_device(void)
630 {
631         int err;
632         int i = 0;
633
634         if (!mce_available(&boot_cpu_data))
635                 return -EIO;
636         err = sysdev_class_register(&mce_sysclass);
637
638         for_each_online_cpu(i) {
639                 mce_create_device(i);
640         }
641
642         register_cpu_notifier(&mce_cpu_notifier);
643         misc_register(&mce_log_device);
644         return err;
645 }
646
647 device_initcall(mce_init_device);