[PATCH] x86_64: ignore machine checks from boot time

[powerpc.git] / arch / x86_64 / kernel / mce.c

diff --git a/arch/x86_64/kernel/mce.c b/arch/x86_64/kernel/mce.c
index 21e7062..8aa5673 100644 (file)
--- a/arch/x86_64/kernel/mce.c
+++ b/arch/x86_64/kernel/mce.c
@@ -15,6 +15,8 @@
 #include <linux/sysdev.h>
 #include <linux/miscdevice.h>
 #include <linux/fs.h>
+#include <linux/cpu.h>
+#include <linux/percpu.h>
 #include <asm/processor.h> 
 #include <asm/msr.h>
 #include <asm/mce.h>
@@ -34,6 +36,7 @@ static unsigned long bank[NR_BANKS] = { [0 ... NR_BANKS-1] = ~0UL };
 static unsigned long console_logged;
 static int notify_user;
 static int rip_msr;
+static int mce_bootlog;
 
 /*
  * Lockless MCE logging infrastructure.
@@ -195,10 +198,11 @@ void do_machine_check(struct pt_regs * regs, long error_code)
                        rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr);
 
                mce_get_rip(&m, regs);
-               if (error_code != -1)
+               if (error_code >= 0)
                        rdtscll(m.tsc);
                wrmsrl(MSR_IA32_MC0_STATUS + i*4, 0);
-               mce_log(&m);
+               if (error_code != -2)
+                       mce_log(&m);
 
                /* Did this bank cause the exception? */
                /* Assume that the bank with uncorrectable errors did it,
@@ -313,7 +317,7 @@ static void mce_init(void *dummy)
 
        /* Log the machine checks left over from the previous reset.
           This also clears all registers */
-       do_machine_check(NULL, -1);
+       do_machine_check(NULL, mce_bootlog ? -1 : -2);
 
        set_in_cr4(X86_CR4_MCE);
 
@@ -474,11 +478,17 @@ static int __init mcheck_disable(char *str)
 }
 
 /* mce=off disables machine check. Note you can reenable it later
-   using sysfs */
+   using sysfs.
+   mce=bootlog Log MCEs from before booting. Disabled by default to work
+   around buggy BIOS that leave bogus MCEs.  */
 static int __init mcheck_enable(char *str)
 {
+       if (*str == '=')
+               str++;
        if (!strcmp(str, "off"))
                mce_dont_init = 1;
+       else if (!strcmp(str, "bootlog"))
+               mce_bootlog = 1;
        else
                printk("mce= argument %s ignored. Please use /sys", str); 
        return 0;
@@ -514,10 +524,7 @@ static struct sysdev_class mce_sysclass = {
        set_kset_name("machinecheck"),
 };
 
-static struct sys_device device_mce = {
-       .id     = 0,
-       .cls    = &mce_sysclass,
-};
+static DEFINE_PER_CPU(struct sys_device, device_mce);
 
 /* Why are there no generic functions for this? */
 #define ACCESSOR(name, var, start) \
@@ -542,27 +549,83 @@ ACCESSOR(bank4ctl,bank[4],mce_restart())
 ACCESSOR(tolerant,tolerant,)
 ACCESSOR(check_interval,check_interval,mce_restart())
 
-static __cpuinit int mce_init_device(void)
+/* Per cpu sysdev init.  All of the cpus still share the same ctl bank */
+static __cpuinit int mce_create_device(unsigned int cpu)
 {
        int err;
+       if (!mce_available(&cpu_data[cpu]))
+               return -EIO;
+
+       per_cpu(device_mce,cpu).id = cpu;
+       per_cpu(device_mce,cpu).cls = &mce_sysclass;
+
+       err = sysdev_register(&per_cpu(device_mce,cpu));
+
+       if (!err) {
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank0ctl);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank1ctl);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank2ctl);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank3ctl);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_bank4ctl);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_tolerant);
+               sysdev_create_file(&per_cpu(device_mce,cpu), &attr_check_interval);
+       }
+       return err;
+}
+
+#ifdef CONFIG_HOTPLUG_CPU
+static __cpuinit void mce_remove_device(unsigned int cpu)
+{
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank0ctl);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank1ctl);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank2ctl);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank3ctl);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_bank4ctl);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_tolerant);
+       sysdev_remove_file(&per_cpu(device_mce,cpu), &attr_check_interval);
+       sysdev_unregister(&per_cpu(device_mce,cpu));
+}
+#endif
+
+/* Get notified when a cpu comes on/off. Be hotplug friendly. */
+static __cpuinit int
+mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
+{
+       unsigned int cpu = (unsigned long)hcpu;
+
+       switch (action) {
+       case CPU_ONLINE:
+               mce_create_device(cpu);
+               break;
+#ifdef CONFIG_HOTPLUG_CPU
+       case CPU_DEAD:
+               mce_remove_device(cpu);
+               break;
+#endif
+       }
+       return NOTIFY_OK;
+}
+
+static struct notifier_block mce_cpu_notifier = {
+       .notifier_call = mce_cpu_callback,
+};
+
+static __init int mce_init_device(void)
+{
+       int err;
+       int i = 0;
+
        if (!mce_available(&boot_cpu_data))
                return -EIO;
        err = sysdev_class_register(&mce_sysclass);
-       if (!err)
-               err = sysdev_register(&device_mce);
-       if (!err) { 
-               /* could create per CPU objects, but it is not worth it. */
-               sysdev_create_file(&device_mce, &attr_bank0ctl); 
-               sysdev_create_file(&device_mce, &attr_bank1ctl); 
-               sysdev_create_file(&device_mce, &attr_bank2ctl); 
-               sysdev_create_file(&device_mce, &attr_bank3ctl); 
-               sysdev_create_file(&device_mce, &attr_bank4ctl); 
-               sysdev_create_file(&device_mce, &attr_tolerant); 
-               sysdev_create_file(&device_mce, &attr_check_interval);
-       } 
-       
+
+       for_each_online_cpu(i) {
+               mce_create_device(i);
+       }
+
+       register_cpu_notifier(&mce_cpu_notifier);
        misc_register(&mce_log_device);
        return err;
-
 }
+
 device_initcall(mce_init_device);