SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/x86/kernel/cpu/mcheck/mce_64.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/smp_lock.h>
  13 #include <linux/string.h>
  14 #include <linux/rcupdate.h>
  15 #include <linux/kallsyms.h>
  16 #include <linux/sysdev.h>
  17 #include <linux/miscdevice.h>
  18 #include <linux/fs.h>
  19 #include <linux/capability.h>
  20 #include <linux/cpu.h>
  21 #include <linux/percpu.h>
  22 #include <linux/poll.h>
  23 #include <linux/thread_info.h>
  24 #include <linux/ctype.h>
  25 #include <linux/kmod.h>
  26 #include <linux/kdebug.h>
  27 #include <asm/processor.h>
  28 #include <asm/msr.h>
  29 #include <asm/mce.h>
  30 #include <asm/uaccess.h>
  31 #include <asm/smp.h>
  32 #include <asm/idle.h>
  33
  34 #define MISC_MCELOG_MINOR 227
  35 #define NR_BANKS 6
  36
  37 atomic_t mce_entry;
  38
  39 static int mce_dont_init;
  40
  41 /*
  42  * Tolerant levels:
  43  *   0: always panic on uncorrected errors, log corrected errors
  44  *   1: panic or SIGBUS on uncorrected errors, log corrected errors
  45  *   2: SIGBUS or log uncorrected errors (if possible), log corrected errors
  46  *   3: never panic or SIGBUS, log all errors (for testing only)
  47  */
  48 static int tolerant = 1;
  49 static int banks;
  50 static unsigned long bank[NR_BANKS] = { [0 ... NR_BANKS-1] = ~0UL };
  51 static unsigned long notify_user;
  52 static int rip_msr;
  53 static int mce_bootlog = -1;
  54 static atomic_t mce_events;
  55
  56 static char trigger[128];
  57 static char *trigger_argv[2] = { trigger, NULL };
  58
  59 static DECLARE_WAIT_QUEUE_HEAD(mce_wait);
  60
  61 /*
  62  * Lockless MCE logging infrastructure.
  63  * This avoids deadlocks on printk locks without having to break locks. Also
  64  * separate MCEs from kernel messages to avoid bogus bug reports.
  65  */
  66
  67 static struct mce_log mcelog = {
  68         MCE_LOG_SIGNATURE,
  69         MCE_LOG_LEN,
  70 };
  71
  72 void mce_log(struct mce *mce)
  73 {
  74         unsigned next, entry;
  75         atomic_inc(&mce_events);
  76         mce->finished = 0;
  77         wmb();
  78         for (;;) {
  79                 entry = rcu_dereference(mcelog.next);
  80                 for (;;) {
  81                         /* When the buffer fills up discard new entries. Assume
  82                            that the earlier errors are the more interesting. */
  83                         if (entry >= MCE_LOG_LEN) {
  84                                 set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags);
  85                                 return;
  86                         }
  87                         /* Old left over entry. Skip. */
  88                         if (mcelog.entry[entry].finished) {
  89                                 entry++;
  90                                 continue;
  91                         }
  92                         break;
  93                 }
  94                 smp_rmb();
  95                 next = entry + 1;
  96                 if (cmpxchg(&mcelog.next, entry, next) == entry)
  97                         break;
  98         }
  99         memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
 100         wmb();
 101         mcelog.entry[entry].finished = 1;
 102         wmb();
 103
 104         set_bit(0, &notify_user);
 105 }
 106
 107 static void print_mce(struct mce *m)
 108 {
 109         printk(KERN_EMERG "\n"
 110                KERN_EMERG "HARDWARE ERROR\n"
 111                KERN_EMERG
 112                "CPU %d: Machine Check Exception: %16Lx Bank %d: %016Lx\n",
 113                m->cpu, m->mcgstatus, m->bank, m->status);
 114         if (m->ip) {
 115                 printk(KERN_EMERG "RIP%s %02x:<%016Lx> ",
 116                        !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
 117                        m->cs, m->ip);
 118                 if (m->cs == __KERNEL_CS)
 119                         print_symbol("{%s}", m->ip);
 120                 printk("\n");
 121         }
 122         printk(KERN_EMERG "TSC %Lx ", m->tsc);
 123         if (m->addr)
 124                 printk("ADDR %Lx ", m->addr);
 125         if (m->misc)
 126                 printk("MISC %Lx ", m->misc);
 127         printk("\n");
 128         printk(KERN_EMERG "This is not a software problem!\n");
 129         printk(KERN_EMERG "Run through mcelog --ascii to decode "
 130                "and contact your hardware vendor\n");
 131 }
 132
 133 static void mce_panic(char *msg, struct mce *backup, unsigned long start)
 134 {
 135         int i;
 136
 137         oops_begin();
 138         for (i = 0; i < MCE_LOG_LEN; i++) {
 139                 unsigned long tsc = mcelog.entry[i].tsc;
 140
 141                 if (time_before(tsc, start))
 142                         continue;
 143                 print_mce(&mcelog.entry[i]);
 144                 if (backup && mcelog.entry[i].tsc == backup->tsc)
 145                         backup = NULL;
 146         }
 147         if (backup)
 148                 print_mce(backup);
 149         panic(msg);
 150 }
 151
 152 static int mce_available(struct cpuinfo_x86 *c)
 153 {
 154         return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA);
 155 }
 156
 157 static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
 158 {
 159         if (regs && (m->mcgstatus & MCG_STATUS_RIPV)) {
 160                 m->ip = regs->ip;
 161                 m->cs = regs->cs;
 162         } else {
 163                 m->ip = 0;
 164                 m->cs = 0;
 165         }
 166         if (rip_msr) {
 167                 /* Assume the RIP in the MSR is exact. Is this true? */
 168                 m->mcgstatus |= MCG_STATUS_EIPV;
 169                 rdmsrl(rip_msr, m->ip);
 170                 m->cs = 0;
 171         }
 172 }
 173
 174 /*
 175  * The actual machine check handler
 176  */
 177 void do_machine_check(struct pt_regs * regs, long error_code)
 178 {
 179         struct mce m, panicm;
 180         u64 mcestart = 0;
 181         int i;
 182         int panicm_found = 0;
 183         /*
 184          * If no_way_out gets set, there is no safe way to recover from this
 185          * MCE.  If tolerant is cranked up, we'll try anyway.
 186          */
 187         int no_way_out = 0;
 188         /*
 189          * If kill_it gets set, there might be a way to recover from this
 190          * error.
 191          */
 192         int kill_it = 0;
 193
 194         atomic_inc(&mce_entry);
 195
 196         if ((regs
 197              && notify_die(DIE_NMI, "machine check", regs, error_code,
 198                            18, SIGKILL) == NOTIFY_STOP)
 199             || !banks)
 200                 goto out2;
 201
 202         memset(&m, 0, sizeof(struct mce));
 203         m.cpu = smp_processor_id();
 204         rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus);
 205         /* if the restart IP is not valid, we're done for */
 206         if (!(m.mcgstatus & MCG_STATUS_RIPV))
 207                 no_way_out = 1;
 208
 209         rdtscll(mcestart);
 210         barrier();
 211
 212         for (i = 0; i < banks; i++) {
 213                 if (!bank[i])
 214                         continue;
 215
 216                 m.misc = 0;
 217                 m.addr = 0;
 218                 m.bank = i;
 219                 m.tsc = 0;
 220
 221                 rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status);
 222                 if ((m.status & MCI_STATUS_VAL) == 0)
 223                         continue;
 224
 225                 if (m.status & MCI_STATUS_EN) {
 226                         /* if PCC was set, there's no way out */
 227                         no_way_out |= !!(m.status & MCI_STATUS_PCC);
 228                         /*
 229                          * If this error was uncorrectable and there was
 230                          * an overflow, we're in trouble.  If no overflow,
 231                          * we might get away with just killing a task.
 232                          */
 233                         if (m.status & MCI_STATUS_UC) {
 234                                 if (tolerant < 1 || m.status & MCI_STATUS_OVER)
 235                                         no_way_out = 1;
 236                                 kill_it = 1;
 237                         }
 238                 }
 239
 240                 if (m.status & MCI_STATUS_MISCV)
 241                         rdmsrl(MSR_IA32_MC0_MISC + i*4, m.misc);
 242                 if (m.status & MCI_STATUS_ADDRV)
 243                         rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr);
 244
 245                 mce_get_rip(&m, regs);
 246                 if (error_code >= 0)
 247                         rdtscll(m.tsc);
 248                 if (error_code != -2)
 249                         mce_log(&m);
 250
 251                 /* Did this bank cause the exception? */
 252                 /* Assume that the bank with uncorrectable errors did it,
 253                    and that there is only a single one. */
 254                 if ((m.status & MCI_STATUS_UC) && (m.status & MCI_STATUS_EN)) {
 255                         panicm = m;
 256                         panicm_found = 1;
 257                 }
 258
 259                 add_taint(TAINT_MACHINE_CHECK);
 260         }
 261
 262         /* Never do anything final in the polling timer */
 263         if (!regs)
 264                 goto out;
 265
 266         /* If we didn't find an uncorrectable error, pick
 267            the last one (shouldn't happen, just being safe). */
 268         if (!panicm_found)
 269                 panicm = m;
 270
 271         /*
 272          * If we have decided that we just CAN'T continue, and the user
 273          *  has not set tolerant to an insane level, give up and die.
 274          */
 275         if (no_way_out && tolerant < 3)
 276                 mce_panic("Machine check", &panicm, mcestart);
 277
 278         /*
 279          * If the error seems to be unrecoverable, something should be
 280          * done.  Try to kill as little as possible.  If we can kill just
 281          * one task, do that.  If the user has set the tolerance very
 282          * high, don't try to do anything at all.
 283          */
 284         if (kill_it && tolerant < 3) {
 285                 int user_space = 0;
 286
 287                 /*
 288                  * If the EIPV bit is set, it means the saved IP is the
 289                  * instruction which caused the MCE.
 290                  */
 291                 if (m.mcgstatus & MCG_STATUS_EIPV)
 292                         user_space = panicm.ip && (panicm.cs & 3);
 293
 294                 /*
 295                  * If we know that the error was in user space, send a
 296                  * SIGBUS.  Otherwise, panic if tolerance is low.
 297                  *
 298                  * do_exit() takes an awful lot of locks and has a slight
 299                  * risk of deadlocking.
 300                  */
 301                 if (user_space) {
 302                         do_exit(SIGBUS);
 303                 } else if (panic_on_oops || tolerant < 2) {
 304                         mce_panic("Uncorrected machine check",
 305                                 &panicm, mcestart);
 306                 }
 307         }
 308
 309         /* notify userspace ASAP */
 310         set_thread_flag(TIF_MCE_NOTIFY);
 311
 312  out:
 313         /* the last thing we do is clear state */
 314         for (i = 0; i < banks; i++)
 315                 wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
 316         wrmsrl(MSR_IA32_MCG_STATUS, 0);
 317  out2:
 318         atomic_dec(&mce_entry);
 319 }
 320
 321 #ifdef CONFIG_X86_MCE_INTEL
 322 /***
 323  * mce_log_therm_throt_event - Logs the thermal throttling event to mcelog
 324  * @cpu: The CPU on which the event occurred.
 325  * @status: Event status information
 326  *
 327  * This function should be called by the thermal interrupt after the
 328  * event has been processed and the decision was made to log the event
 329  * further.
 330  *
 331  * The status parameter will be saved to the 'status' field of 'struct mce'
 332  * and historically has been the register value of the
 333  * MSR_IA32_THERMAL_STATUS (Intel) msr.
 334  */
 335 void mce_log_therm_throt_event(unsigned int cpu, __u64 status)
 336 {
 337         struct mce m;
 338
 339         memset(&m, 0, sizeof(m));
 340         m.cpu = cpu;
 341         m.bank = MCE_THERMAL_BANK;
 342         m.status = status;
 343         rdtscll(m.tsc);
 344         mce_log(&m);
 345 }
 346 #endif /* CONFIG_X86_MCE_INTEL */
 347
 348 /*
 349  * Periodic polling timer for "silent" machine check errors.  If the
 350  * poller finds an MCE, poll 2x faster.  When the poller finds no more
 351  * errors, poll 2x slower (up to check_interval seconds).
 352  */
 353
 354 static int check_interval = 5 * 60; /* 5 minutes */
 355 static int next_interval; /* in jiffies */
 356 static void mcheck_timer(struct work_struct *work);
 357 static DECLARE_DELAYED_WORK(mcheck_work, mcheck_timer);
 358
 359 static void mcheck_check_cpu(void *info)
 360 {
 361         if (mce_available(&current_cpu_data))
 362                 do_machine_check(NULL, 0);
 363 }
 364
 365 static void mcheck_timer(struct work_struct *work)
 366 {
 367         on_each_cpu(mcheck_check_cpu, NULL, 1, 1);
 368
 369         /*
 370          * Alert userspace if needed.  If we logged an MCE, reduce the
 371          * polling interval, otherwise increase the polling interval.
 372          */
 373         if (mce_notify_user()) {
 374                 next_interval = max(next_interval/2, HZ/100);
 375         } else {
 376                 next_interval = min(next_interval * 2,
 377                                 (int)round_jiffies_relative(check_interval*HZ));
 378         }
 379
 380         schedule_delayed_work(&mcheck_work, next_interval);
 381 }
 382
 383 /*
 384  * This is only called from process context.  This is where we do
 385  * anything we need to alert userspace about new MCEs.  This is called
 386  * directly from the poller and also from entry.S and idle, thanks to
 387  * TIF_MCE_NOTIFY.
 388  */
 389 int mce_notify_user(void)
 390 {
 391         clear_thread_flag(TIF_MCE_NOTIFY);
 392         if (test_and_clear_bit(0, &notify_user)) {
 393                 static unsigned long last_print;
 394                 unsigned long now = jiffies;
 395
 396                 wake_up_interruptible(&mce_wait);
 397                 if (trigger[0])
 398                         call_usermodehelper(trigger, trigger_argv, NULL,
 399                                                 UMH_NO_WAIT);
 400
 401                 if (time_after_eq(now, last_print + (check_interval*HZ))) {
 402                         last_print = now;
 403                         printk(KERN_INFO "Machine check events logged\n");
 404                 }
 405
 406                 return 1;
 407         }
 408         return 0;
 409 }
 410
 411 /* see if the idle task needs to notify userspace */
 412 static int
 413 mce_idle_callback(struct notifier_block *nfb, unsigned long action, void *junk)
 414 {
 415         /* IDLE_END should be safe - interrupts are back on */
 416         if (action == IDLE_END && test_thread_flag(TIF_MCE_NOTIFY))
 417                 mce_notify_user();
 418
 419         return NOTIFY_OK;
 420 }
 421
 422 static struct notifier_block mce_idle_notifier = {
 423         .notifier_call = mce_idle_callback,
 424 };
 425
 426 static __init int periodic_mcheck_init(void)
 427 {
 428         next_interval = check_interval * HZ;
 429         if (next_interval)
 430                 schedule_delayed_work(&mcheck_work,
 431                                       round_jiffies_relative(next_interval));
 432         idle_notifier_register(&mce_idle_notifier);
 433         return 0;
 434 }
 435 __initcall(periodic_mcheck_init);
 436
 437
 438 /*
 439  * Initialize Machine Checks for a CPU.
 440  */
 441 static void mce_init(void *dummy)
 442 {
 443         u64 cap;
 444         int i;
 445
 446         rdmsrl(MSR_IA32_MCG_CAP, cap);
 447         banks = cap & 0xff;
 448         if (banks > NR_BANKS) {
 449                 printk(KERN_INFO "MCE: warning: using only %d banks\n", banks);
 450                 banks = NR_BANKS;
 451         }
 452         /* Use accurate RIP reporting if available. */
 453         if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9)
 454                 rip_msr = MSR_IA32_MCG_EIP;
 455
 456         /* Log the machine checks left over from the previous reset.
 457            This also clears all registers */
 458         do_machine_check(NULL, mce_bootlog ? -1 : -2);
 459
 460         set_in_cr4(X86_CR4_MCE);
 461
 462         if (cap & MCG_CTL_P)
 463                 wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff);
 464
 465         for (i = 0; i < banks; i++) {
 466                 wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]);
 467                 wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
 468         }
 469 }
 470
 471 /* Add per CPU specific workarounds here */
 472 static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
 473 {
 474         /* This should be disabled by the BIOS, but isn't always */
 475         if (c->x86_vendor == X86_VENDOR_AMD) {
 476                 if(c->x86 == 15)
 477                         /* disable GART TBL walk error reporting, which trips off
 478                            incorrectly with the IOMMU & 3ware & Cerberus. */
 479                         clear_bit(10, &bank[4]);
 480                 if(c->x86 <= 17 && mce_bootlog < 0)
 481                         /* Lots of broken BIOS around that don't clear them
 482                            by default and leave crap in there. Don't log. */
 483                         mce_bootlog = 0;
 484         }
 485
 486 }
 487
 488 static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
 489 {
 490         switch (c->x86_vendor) {
 491         case X86_VENDOR_INTEL:
 492                 mce_intel_feature_init(c);
 493                 break;
 494         case X86_VENDOR_AMD:
 495                 mce_amd_feature_init(c);
 496                 break;
 497         default:
 498                 break;
 499         }
 500 }
 501
 502 /*
 503  * Called for each booted CPU to set up machine checks.
 504  * Must be called with preempt off.
 505  */
 506 void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
 507 {
 508         static cpumask_t mce_cpus = CPU_MASK_NONE;
 509
 510         mce_cpu_quirks(c);
 511
 512         if (mce_dont_init ||
 513             cpu_test_and_set(smp_processor_id(), mce_cpus) ||
 514             !mce_available(c))
 515                 return;
 516
 517         mce_init(NULL);
 518         mce_cpu_features(c);
 519 }
 520
 521 /*
 522  * Character device to read and clear the MCE log.
 523  */
 524
 525 static DEFINE_SPINLOCK(mce_state_lock);
 526 static int open_count;  /* #times opened */
 527 static int open_exclu;  /* already open exclusive? */
 528
 529 static int mce_open(struct inode *inode, struct file *file)
 530 {
 531         lock_kernel();
 532         spin_lock(&mce_state_lock);
 533
 534         if (open_exclu || (open_count && (file->f_flags & O_EXCL))) {
 535                 spin_unlock(&mce_state_lock);
 536                 unlock_kernel();
 537                 return -EBUSY;
 538         }
 539
 540         if (file->f_flags & O_EXCL)
 541                 open_exclu = 1;
 542         open_count++;
 543
 544         spin_unlock(&mce_state_lock);
 545         unlock_kernel();
 546
 547         return nonseekable_open(inode, file);
 548 }
 549
 550 static int mce_release(struct inode *inode, struct file *file)
 551 {
 552         spin_lock(&mce_state_lock);
 553
 554         open_count--;
 555         open_exclu = 0;
 556
 557         spin_unlock(&mce_state_lock);
 558
 559         return 0;
 560 }
 561
 562 static void collect_tscs(void *data)
 563 {
 564         unsigned long *cpu_tsc = (unsigned long *)data;
 565
 566         rdtscll(cpu_tsc[smp_processor_id()]);
 567 }
 568
 569 static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
 570                         loff_t *off)
 571 {
 572         unsigned long *cpu_tsc;
 573         static DEFINE_MUTEX(mce_read_mutex);
 574         unsigned next;
 575         char __user *buf = ubuf;
 576         int i, err;
 577
 578         cpu_tsc = kmalloc(NR_CPUS * sizeof(long), GFP_KERNEL);
 579         if (!cpu_tsc)
 580                 return -ENOMEM;
 581
 582         mutex_lock(&mce_read_mutex);
 583         next = rcu_dereference(mcelog.next);
 584
 585         /* Only supports full reads right now */
 586         if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) {
 587                 mutex_unlock(&mce_read_mutex);
 588                 kfree(cpu_tsc);
 589                 return -EINVAL;
 590         }
 591
 592         err = 0;
 593         for (i = 0; i < next; i++) {
 594                 unsigned long start = jiffies;
 595
 596                 while (!mcelog.entry[i].finished) {
 597                         if (time_after_eq(jiffies, start + 2)) {
 598                                 memset(mcelog.entry + i,0, sizeof(struct mce));
 599                                 goto timeout;
 600                         }
 601                         cpu_relax();
 602                 }
 603                 smp_rmb();
 604                 err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce));
 605                 buf += sizeof(struct mce);
 606  timeout:
 607                 ;
 608         }
 609
 610         memset(mcelog.entry, 0, next * sizeof(struct mce));
 611         mcelog.next = 0;
 612
 613         synchronize_sched();
 614
 615         /*
 616          * Collect entries that were still getting written before the
 617          * synchronize.
 618          */
 619         on_each_cpu(collect_tscs, cpu_tsc, 1, 1);
 620         for (i = next; i < MCE_LOG_LEN; i++) {
 621                 if (mcelog.entry[i].finished &&
 622                     mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {
 623                         err |= copy_to_user(buf, mcelog.entry+i,
 624                                             sizeof(struct mce));
 625                         smp_rmb();
 626                         buf += sizeof(struct mce);
 627                         memset(&mcelog.entry[i], 0, sizeof(struct mce));
 628                 }
 629         }
 630         mutex_unlock(&mce_read_mutex);
 631         kfree(cpu_tsc);
 632         return err ? -EFAULT : buf - ubuf;
 633 }
 634
 635 static unsigned int mce_poll(struct file *file, poll_table *wait)
 636 {
 637         poll_wait(file, &mce_wait, wait);
 638         if (rcu_dereference(mcelog.next))
 639                 return POLLIN | POLLRDNORM;
 640         return 0;
 641 }
 642
 643 static long mce_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 644 {
 645         int __user *p = (int __user *)arg;
 646
 647         if (!capable(CAP_SYS_ADMIN))
 648                 return -EPERM;
 649         switch (cmd) {
 650         case MCE_GET_RECORD_LEN:
 651                 return put_user(sizeof(struct mce), p);
 652         case MCE_GET_LOG_LEN:
 653                 return put_user(MCE_LOG_LEN, p);
 654         case MCE_GETCLEAR_FLAGS: {
 655                 unsigned flags;
 656
 657                 do {
 658                         flags = mcelog.flags;
 659                 } while (cmpxchg(&mcelog.flags, flags, 0) != flags);
 660                 return put_user(flags, p);
 661         }
 662         default:
 663                 return -ENOTTY;
 664         }
 665 }
 666
 667 static const struct file_operations mce_chrdev_ops = {
 668         .open = mce_open,
 669         .release = mce_release,
 670         .read = mce_read,
 671         .poll = mce_poll,
 672         .unlocked_ioctl = mce_ioctl,
 673 };
 674
 675 static struct miscdevice mce_log_device = {
 676         MISC_MCELOG_MINOR,
 677         "mcelog",
 678         &mce_chrdev_ops,
 679 };
 680
 681 static unsigned long old_cr4 __initdata;
 682
 683 void __init stop_mce(void)
 684 {
 685         old_cr4 = read_cr4();
 686         clear_in_cr4(X86_CR4_MCE);
 687 }
 688
 689 void __init restart_mce(void)
 690 {
 691         if (old_cr4 & X86_CR4_MCE)
 692                 set_in_cr4(X86_CR4_MCE);
 693 }
 694
 695 /*
 696  * Old style boot options parsing. Only for compatibility.
 697  */
 698 static int __init mcheck_disable(char *str)
 699 {
 700         mce_dont_init = 1;
 701         return 1;
 702 }
 703
 704 /* mce=off disables machine check. Note you can re-enable it later
 705    using sysfs.
 706    mce=TOLERANCELEVEL (number, see above)
 707    mce=bootlog Log MCEs from before booting. Disabled by default on AMD.
 708    mce=nobootlog Don't log MCEs from before booting. */
 709 static int __init mcheck_enable(char *str)
 710 {
 711         if (!strcmp(str, "off"))
 712                 mce_dont_init = 1;
 713         else if (!strcmp(str, "bootlog") || !strcmp(str,"nobootlog"))
 714                 mce_bootlog = str[0] == 'b';
 715         else if (isdigit(str[0]))
 716                 get_option(&str, &tolerant);
 717         else
 718                 printk("mce= argument %s ignored. Please use /sys", str);
 719         return 1;
 720 }
 721
 722 __setup("nomce", mcheck_disable);
 723 __setup("mce=", mcheck_enable);
 724
 725 /*
 726  * Sysfs support
 727  */
 728
 729 /* On resume clear all MCE state. Don't want to see leftovers from the BIOS.
 730    Only one CPU is active at this time, the others get readded later using
 731    CPU hotplug. */
 732 static int mce_resume(struct sys_device *dev)
 733 {
 734         mce_init(NULL);
 735         return 0;
 736 }
 737
 738 /* Reinit MCEs after user configuration changes */
 739 static void mce_restart(void)
 740 {
 741         if (next_interval)
 742                 cancel_delayed_work(&mcheck_work);
 743         /* Timer race is harmless here */
 744         on_each_cpu(mce_init, NULL, 1, 1);
 745         next_interval = check_interval * HZ;
 746         if (next_interval)
 747                 schedule_delayed_work(&mcheck_work,
 748                                       round_jiffies_relative(next_interval));
 749 }
 750
 751 static struct sysdev_class mce_sysclass = {
 752         .resume = mce_resume,
 753         .name = "machinecheck",
 754 };
 755
 756 DEFINE_PER_CPU(struct sys_device, device_mce);
 757
 758 /* Why are there no generic functions for this? */
 759 #define ACCESSOR(name, var, start) \
 760         static ssize_t show_ ## name(struct sys_device *s, char *buf) { \
 761                 return sprintf(buf, "%lx\n", (unsigned long)var);       \
 762         }                                                               \
 763         static ssize_t set_ ## name(struct sys_device *s,const char *buf,size_t siz) { \
 764                 char *end;                                              \
 765                 unsigned long new = simple_strtoul(buf, &end, 0);       \
 766                 if (end == buf) return -EINVAL;                         \
 767                 var = new;                                              \
 768                 start;                                                  \
 769                 return end-buf;                                         \
 770         }                                                               \
 771         static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name);
 772
 773 /* TBD should generate these dynamically based on number of available banks */
 774 ACCESSOR(bank0ctl,bank[0],mce_restart())
 775 ACCESSOR(bank1ctl,bank[1],mce_restart())
 776 ACCESSOR(bank2ctl,bank[2],mce_restart())
 777 ACCESSOR(bank3ctl,bank[3],mce_restart())
 778 ACCESSOR(bank4ctl,bank[4],mce_restart())
 779 ACCESSOR(bank5ctl,bank[5],mce_restart())
 780
 781 static ssize_t show_trigger(struct sys_device *s, char *buf)
 782 {
 783         strcpy(buf, trigger);
 784         strcat(buf, "\n");
 785         return strlen(trigger) + 1;
 786 }
 787
 788 static ssize_t set_trigger(struct sys_device *s,const char *buf,size_t siz)
 789 {
 790         char *p;
 791         int len;
 792         strncpy(trigger, buf, sizeof(trigger));
 793         trigger[sizeof(trigger)-1] = 0;
 794         len = strlen(trigger);
 795         p = strchr(trigger, '\n');
 796         if (*p) *p = 0;
 797         return len;
 798 }
 799
 800 static SYSDEV_ATTR(trigger, 0644, show_trigger, set_trigger);
 801 ACCESSOR(tolerant,tolerant,)
 802 ACCESSOR(check_interval,check_interval,mce_restart())
 803 static struct sysdev_attribute *mce_attributes[] = {
 804         &attr_bank0ctl, &attr_bank1ctl, &attr_bank2ctl,
 805         &attr_bank3ctl, &attr_bank4ctl, &attr_bank5ctl,
 806         &attr_tolerant, &attr_check_interval, &attr_trigger,
 807         NULL
 808 };
 809
 810 static cpumask_t mce_device_initialized = CPU_MASK_NONE;
 811
 812 /* Per cpu sysdev init.  All of the cpus still share the same ctl bank */
 813 static __cpuinit int mce_create_device(unsigned int cpu)
 814 {
 815         int err;
 816         int i;
 817
 818         if (!mce_available(&boot_cpu_data))
 819                 return -EIO;
 820
 821         memset(&per_cpu(device_mce, cpu).kobj, 0, sizeof(struct kobject));
 822         per_cpu(device_mce,cpu).id = cpu;
 823         per_cpu(device_mce,cpu).cls = &mce_sysclass;
 824
 825         err = sysdev_register(&per_cpu(device_mce,cpu));
 826         if (err)
 827                 return err;
 828
 829         for (i = 0; mce_attributes[i]; i++) {
 830                 err = sysdev_create_file(&per_cpu(device_mce,cpu),
 831                                          mce_attributes[i]);
 832                 if (err)
 833                         goto error;
 834         }
 835         cpu_set(cpu, mce_device_initialized);
 836
 837         return 0;
 838 error:
 839         while (i--) {
 840                 sysdev_remove_file(&per_cpu(device_mce,cpu),
 841                                    mce_attributes[i]);
 842         }
 843         sysdev_unregister(&per_cpu(device_mce,cpu));
 844
 845         return err;
 846 }
 847
 848 static void mce_remove_device(unsigned int cpu)
 849 {
 850         int i;
 851
 852         if (!cpu_isset(cpu, mce_device_initialized))
 853                 return;
 854
 855         for (i = 0; mce_attributes[i]; i++)
 856                 sysdev_remove_file(&per_cpu(device_mce,cpu),
 857                         mce_attributes[i]);
 858         sysdev_unregister(&per_cpu(device_mce,cpu));
 859         cpu_clear(cpu, mce_device_initialized);
 860 }
 861
 862 /* Get notified when a cpu comes on/off. Be hotplug friendly. */
 863 static int __cpuinit mce_cpu_callback(struct notifier_block *nfb,
 864                                       unsigned long action, void *hcpu)
 865 {
 866         unsigned int cpu = (unsigned long)hcpu;
 867
 868         switch (action) {
 869         case CPU_ONLINE:
 870         case CPU_ONLINE_FROZEN:
 871                 mce_create_device(cpu);
 872                 break;
 873         case CPU_DEAD:
 874         case CPU_DEAD_FROZEN:
 875                 mce_remove_device(cpu);
 876                 break;
 877         }
 878         return NOTIFY_OK;
 879 }
 880
 881 static struct notifier_block mce_cpu_notifier __cpuinitdata = {
 882         .notifier_call = mce_cpu_callback,
 883 };
 884
 885 static __init int mce_init_device(void)
 886 {
 887         int err;
 888         int i = 0;
 889
 890         if (!mce_available(&boot_cpu_data))
 891                 return -EIO;
 892         err = sysdev_class_register(&mce_sysclass);
 893         if (err)
 894                 return err;
 895
 896         for_each_online_cpu(i) {
 897                 err = mce_create_device(i);
 898                 if (err)
 899                         return err;
 900         }
 901
 902         register_hotcpu_notifier(&mce_cpu_notifier);
 903         misc_register(&mce_log_device);
 904         return err;
 905 }
 906
 907 device_initcall(mce_init_device);