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