arch/x86/kernel/cpu/mcheck/mce.c

   1 /*
   2  * Machine check handler.
   3  *
   4  * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
   5  * Rest from unknown author(s).
   6  * 2004 Andi Kleen. Rewrote most of it.
   7  * Copyright 2008 Intel Corporation
   8  * Author: Andi Kleen
   9  */
  10 #include <linux/thread_info.h>
  11 #include <linux/capability.h>
  12 #include <linux/miscdevice.h>
  13 #include <linux/ratelimit.h>
  14 #include <linux/kallsyms.h>
  15 #include <linux/rcupdate.h>
  16 #include <linux/kobject.h>
  17 #include <linux/uaccess.h>
  18 #include <linux/kdebug.h>
  19 #include <linux/kernel.h>
  20 #include <linux/percpu.h>
  21 #include <linux/string.h>
  22 #include <linux/device.h>
  23 #include <linux/syscore_ops.h>
  24 #include <linux/delay.h>
  25 #include <linux/ctype.h>
  26 #include <linux/sched.h>
  27 #include <linux/sysfs.h>
  28 #include <linux/types.h>
  29 #include <linux/slab.h>
  30 #include <linux/init.h>
  31 #include <linux/kmod.h>
  32 #include <linux/poll.h>
  33 #include <linux/nmi.h>
  34 #include <linux/cpu.h>
  35 #include <linux/smp.h>
  36 #include <linux/fs.h>
  37 #include <linux/mm.h>
  38 #include <linux/debugfs.h>
  39 #include <linux/irq_work.h>
  40 #include <linux/export.h>
  41
  42 #include <asm/processor.h>
  43 #include <asm/mce.h>
  44 #include <asm/msr.h>
  45
  46 #include "mce-internal.h"
  47
  48 static DEFINE_MUTEX(mce_chrdev_read_mutex);
  49
  50 #define rcu_dereference_check_mce(p) \
  51         rcu_dereference_index_check((p), \
  52                               rcu_read_lock_sched_held() || \
  53                               lockdep_is_held(&mce_chrdev_read_mutex))
  54
  55 #define CREATE_TRACE_POINTS
  56 #include <trace/events/mce.h>
  57
  58 int mce_disabled __read_mostly;
  59
  60 #define MISC_MCELOG_MINOR       227
  61
  62 #define SPINUNIT 100    /* 100ns */
  63
  64 atomic_t mce_entry;
  65
  66 DEFINE_PER_CPU(unsigned, mce_exception_count);
  67
  68 /*
  69  * Tolerant levels:
  70  *   0: always panic on uncorrected errors, log corrected errors
  71  *   1: panic or SIGBUS on uncorrected errors, log corrected errors
  72  *   2: SIGBUS or log uncorrected errors (if possible), log corrected errors
  73  *   3: never panic or SIGBUS, log all errors (for testing only)
  74  */
  75 static int                      tolerant                __read_mostly = 1;
  76 static int                      banks                   __read_mostly;
  77 static int                      rip_msr                 __read_mostly;
  78 static int                      mce_bootlog             __read_mostly = -1;
  79 static int                      monarch_timeout         __read_mostly = -1;
  80 static int                      mce_panic_timeout       __read_mostly;
  81 static int                      mce_dont_log_ce         __read_mostly;
  82 int                             mce_cmci_disabled       __read_mostly;
  83 int                             mce_ignore_ce           __read_mostly;
  84 int                             mce_ser                 __read_mostly;
  85
  86 struct mce_bank                *mce_banks               __read_mostly;
  87
  88 /* User mode helper program triggered by machine check event */
  89 static unsigned long            mce_need_notify;
  90 static char                     mce_helper[128];
  91 static char                     *mce_helper_argv[2] = { mce_helper, NULL };
  92
  93 static DECLARE_WAIT_QUEUE_HEAD(mce_chrdev_wait);
  94
  95 static DEFINE_PER_CPU(struct mce, mces_seen);
  96 static int                      cpu_missing;
  97
  98 /* MCA banks polled by the period polling timer for corrected events */
  99 DEFINE_PER_CPU(mce_banks_t, mce_poll_banks) = {
 100         [0 ... BITS_TO_LONGS(MAX_NR_BANKS)-1] = ~0UL
 101 };
 102
 103 static DEFINE_PER_CPU(struct work_struct, mce_work);
 104
 105 /*
 106  * CPU/chipset specific EDAC code can register a notifier call here to print
 107  * MCE errors in a human-readable form.
 108  */
 109 ATOMIC_NOTIFIER_HEAD(x86_mce_decoder_chain);
 110
 111 /* Do initial initialization of a struct mce */
 112 void mce_setup(struct mce *m)
 113 {
 114         memset(m, 0, sizeof(struct mce));
 115         m->cpu = m->extcpu = smp_processor_id();
 116         rdtscll(m->tsc);
 117         /* We hope get_seconds stays lockless */
 118         m->time = get_seconds();
 119         m->cpuvendor = boot_cpu_data.x86_vendor;
 120         m->cpuid = cpuid_eax(1);
 121         m->socketid = cpu_data(m->extcpu).phys_proc_id;
 122         m->apicid = cpu_data(m->extcpu).initial_apicid;
 123         rdmsrl(MSR_IA32_MCG_CAP, m->mcgcap);
 124 }
 125
 126 DEFINE_PER_CPU(struct mce, injectm);
 127 EXPORT_PER_CPU_SYMBOL_GPL(injectm);
 128
 129 /*
 130  * Lockless MCE logging infrastructure.
 131  * This avoids deadlocks on printk locks without having to break locks. Also
 132  * separate MCEs from kernel messages to avoid bogus bug reports.
 133  */
 134
 135 static struct mce_log mcelog = {
 136         .signature      = MCE_LOG_SIGNATURE,
 137         .len            = MCE_LOG_LEN,
 138         .recordlen      = sizeof(struct mce),
 139 };
 140
 141 void mce_log(struct mce *mce)
 142 {
 143         unsigned next, entry;
 144         int ret = 0;
 145
 146         /* Emit the trace record: */
 147         trace_mce_record(mce);
 148
 149         ret = atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, mce);
 150         if (ret == NOTIFY_STOP)
 151                 return;
 152
 153         mce->finished = 0;
 154         wmb();
 155         for (;;) {
 156                 entry = rcu_dereference_check_mce(mcelog.next);
 157                 for (;;) {
 158
 159                         /*
 160                          * When the buffer fills up discard new entries.
 161                          * Assume that the earlier errors are the more
 162                          * interesting ones:
 163                          */
 164                         if (entry >= MCE_LOG_LEN) {
 165                                 set_bit(MCE_OVERFLOW,
 166                                         (unsigned long *)&mcelog.flags);
 167                                 return;
 168                         }
 169                         /* Old left over entry. Skip: */
 170                         if (mcelog.entry[entry].finished) {
 171                                 entry++;
 172                                 continue;
 173                         }
 174                         break;
 175                 }
 176                 smp_rmb();
 177                 next = entry + 1;
 178                 if (cmpxchg(&mcelog.next, entry, next) == entry)
 179                         break;
 180         }
 181         memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
 182         wmb();
 183         mcelog.entry[entry].finished = 1;
 184         wmb();
 185
 186         mce->finished = 1;
 187         set_bit(0, &mce_need_notify);
 188 }
 189
 190 static void drain_mcelog_buffer(void)
 191 {
 192         unsigned int next, i, prev = 0;
 193
 194         next = rcu_dereference_check_mce(mcelog.next);
 195
 196         do {
 197                 struct mce *m;
 198
 199                 /* drain what was logged during boot */
 200                 for (i = prev; i < next; i++) {
 201                         unsigned long start = jiffies;
 202                         unsigned retries = 1;
 203
 204                         m = &mcelog.entry[i];
 205
 206                         while (!m->finished) {
 207                                 if (time_after_eq(jiffies, start + 2*retries))
 208                                         retries++;
 209
 210                                 cpu_relax();
 211
 212                                 if (!m->finished && retries >= 4) {
 213                                         pr_err("MCE: skipping error being logged currently!\n");
 214                                         break;
 215                                 }
 216                         }
 217                         smp_rmb();
 218                         atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, m);
 219                 }
 220
 221                 memset(mcelog.entry + prev, 0, (next - prev) * sizeof(*m));
 222                 prev = next;
 223                 next = cmpxchg(&mcelog.next, prev, 0);
 224         } while (next != prev);
 225 }
 226
 227
 228 void mce_register_decode_chain(struct notifier_block *nb)
 229 {
 230         atomic_notifier_chain_register(&x86_mce_decoder_chain, nb);
 231         drain_mcelog_buffer();
 232 }
 233 EXPORT_SYMBOL_GPL(mce_register_decode_chain);
 234
 235 void mce_unregister_decode_chain(struct notifier_block *nb)
 236 {
 237         atomic_notifier_chain_unregister(&x86_mce_decoder_chain, nb);
 238 }
 239 EXPORT_SYMBOL_GPL(mce_unregister_decode_chain);
 240
 241 static void print_mce(struct mce *m)
 242 {
 243         int ret = 0;
 244
 245         pr_emerg(HW_ERR "CPU %d: Machine Check Exception: %Lx Bank %d: %016Lx\n",
 246                m->extcpu, m->mcgstatus, m->bank, m->status);
 247
 248         if (m->ip) {
 249                 pr_emerg(HW_ERR "RIP%s %02x:<%016Lx> ",
 250                         !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
 251                                 m->cs, m->ip);
 252
 253                 if (m->cs == __KERNEL_CS)
 254                         print_symbol("{%s}", m->ip);
 255                 pr_cont("\n");
 256         }
 257
 258         pr_emerg(HW_ERR "TSC %llx ", m->tsc);
 259         if (m->addr)
 260                 pr_cont("ADDR %llx ", m->addr);
 261         if (m->misc)
 262                 pr_cont("MISC %llx ", m->misc);
 263
 264         pr_cont("\n");
 265         /*
 266          * Note this output is parsed by external tools and old fields
 267          * should not be changed.
 268          */
 269         pr_emerg(HW_ERR "PROCESSOR %u:%x TIME %llu SOCKET %u APIC %x microcode %x\n",
 270                 m->cpuvendor, m->cpuid, m->time, m->socketid, m->apicid,
 271                 cpu_data(m->extcpu).microcode);
 272
 273         /*
 274          * Print out human-readable details about the MCE error,
 275          * (if the CPU has an implementation for that)
 276          */
 277         ret = atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, m);
 278         if (ret == NOTIFY_STOP)
 279                 return;
 280
 281         pr_emerg_ratelimited(HW_ERR "Run the above through 'mcelog --ascii'\n");
 282 }
 283
 284 #define PANIC_TIMEOUT 5 /* 5 seconds */
 285
 286 static atomic_t mce_paniced;
 287
 288 static int fake_panic;
 289 static atomic_t mce_fake_paniced;
 290
 291 /* Panic in progress. Enable interrupts and wait for final IPI */
 292 static void wait_for_panic(void)
 293 {
 294         long timeout = PANIC_TIMEOUT*USEC_PER_SEC;
 295
 296         preempt_disable();
 297         local_irq_enable();
 298         while (timeout-- > 0)
 299                 udelay(1);
 300         if (panic_timeout == 0)
 301                 panic_timeout = mce_panic_timeout;
 302         panic("Panicing machine check CPU died");
 303 }
 304
 305 static void mce_panic(char *msg, struct mce *final, char *exp)
 306 {
 307         int i, apei_err = 0;
 308
 309         if (!fake_panic) {
 310                 /*
 311                  * Make sure only one CPU runs in machine check panic
 312                  */
 313                 if (atomic_inc_return(&mce_paniced) > 1)
 314                         wait_for_panic();
 315                 barrier();
 316
 317                 bust_spinlocks(1);
 318                 console_verbose();
 319         } else {
 320                 /* Don't log too much for fake panic */
 321                 if (atomic_inc_return(&mce_fake_paniced) > 1)
 322                         return;
 323         }
 324         /* First print corrected ones that are still unlogged */
 325         for (i = 0; i < MCE_LOG_LEN; i++) {
 326                 struct mce *m = &mcelog.entry[i];
 327                 if (!(m->status & MCI_STATUS_VAL))
 328                         continue;
 329                 if (!(m->status & MCI_STATUS_UC)) {
 330                         print_mce(m);
 331                         if (!apei_err)
 332                                 apei_err = apei_write_mce(m);
 333                 }
 334         }
 335         /* Now print uncorrected but with the final one last */
 336         for (i = 0; i < MCE_LOG_LEN; i++) {
 337                 struct mce *m = &mcelog.entry[i];
 338                 if (!(m->status & MCI_STATUS_VAL))
 339                         continue;
 340                 if (!(m->status & MCI_STATUS_UC))
 341                         continue;
 342                 if (!final || memcmp(m, final, sizeof(struct mce))) {
 343                         print_mce(m);
 344                         if (!apei_err)
 345                                 apei_err = apei_write_mce(m);
 346                 }
 347         }
 348         if (final) {
 349                 print_mce(final);
 350                 if (!apei_err)
 351                         apei_err = apei_write_mce(final);
 352         }
 353         if (cpu_missing)
 354                 pr_emerg(HW_ERR "Some CPUs didn't answer in synchronization\n");
 355         if (exp)
 356                 pr_emerg(HW_ERR "Machine check: %s\n", exp);
 357         if (!fake_panic) {
 358                 if (panic_timeout == 0)
 359                         panic_timeout = mce_panic_timeout;
 360                 panic(msg);
 361         } else
 362                 pr_emerg(HW_ERR "Fake kernel panic: %s\n", msg);
 363 }
 364
 365 /* Support code for software error injection */
 366
 367 static int msr_to_offset(u32 msr)
 368 {
 369         unsigned bank = __this_cpu_read(injectm.bank);
 370
 371         if (msr == rip_msr)
 372                 return offsetof(struct mce, ip);
 373         if (msr == MSR_IA32_MCx_STATUS(bank))
 374                 return offsetof(struct mce, status);
 375         if (msr == MSR_IA32_MCx_ADDR(bank))
 376                 return offsetof(struct mce, addr);
 377         if (msr == MSR_IA32_MCx_MISC(bank))
 378                 return offsetof(struct mce, misc);
 379         if (msr == MSR_IA32_MCG_STATUS)
 380                 return offsetof(struct mce, mcgstatus);
 381         return -1;
 382 }
 383
 384 /* MSR access wrappers used for error injection */
 385 static u64 mce_rdmsrl(u32 msr)
 386 {
 387         u64 v;
 388
 389         if (__this_cpu_read(injectm.finished)) {
 390                 int offset = msr_to_offset(msr);
 391
 392                 if (offset < 0)
 393                         return 0;
 394                 return *(u64 *)((char *)&__get_cpu_var(injectm) + offset);
 395         }
 396
 397         if (rdmsrl_safe(msr, &v)) {
 398                 WARN_ONCE(1, "mce: Unable to read msr %d!\n", msr);
 399                 /*
 400                  * Return zero in case the access faulted. This should
 401                  * not happen normally but can happen if the CPU does
 402                  * something weird, or if the code is buggy.
 403                  */
 404                 v = 0;
 405         }
 406
 407         return v;
 408 }
 409
 410 static void mce_wrmsrl(u32 msr, u64 v)
 411 {
 412         if (__this_cpu_read(injectm.finished)) {
 413                 int offset = msr_to_offset(msr);
 414
 415                 if (offset >= 0)
 416                         *(u64 *)((char *)&__get_cpu_var(injectm) + offset) = v;
 417                 return;
 418         }
 419         wrmsrl(msr, v);
 420 }
 421
 422 /*
 423  * Collect all global (w.r.t. this processor) status about this machine
 424  * check into our "mce" struct so that we can use it later to assess
 425  * the severity of the problem as we read per-bank specific details.
 426  */
 427 static inline void mce_gather_info(struct mce *m, struct pt_regs *regs)
 428 {
 429         mce_setup(m);
 430
 431         m->mcgstatus = mce_rdmsrl(MSR_IA32_MCG_STATUS);
 432         if (regs) {
 433                 /*
 434                  * Get the address of the instruction at the time of
 435                  * the machine check error.
 436                  */
 437                 if (m->mcgstatus & (MCG_STATUS_RIPV|MCG_STATUS_EIPV)) {
 438                         m->ip = regs->ip;
 439                         m->cs = regs->cs;
 440                 }
 441                 /* Use accurate RIP reporting if available. */
 442                 if (rip_msr)
 443                         m->ip = mce_rdmsrl(rip_msr);
 444         }
 445 }
 446
 447 /*
 448  * Simple lockless ring to communicate PFNs from the exception handler with the
 449  * process context work function. This is vastly simplified because there's
 450  * only a single reader and a single writer.
 451  */
 452 #define MCE_RING_SIZE 16        /* we use one entry less */
 453
 454 struct mce_ring {
 455         unsigned short start;
 456         unsigned short end;
 457         unsigned long ring[MCE_RING_SIZE];
 458 };
 459 static DEFINE_PER_CPU(struct mce_ring, mce_ring);
 460
 461 /* Runs with CPU affinity in workqueue */
 462 static int mce_ring_empty(void)
 463 {
 464         struct mce_ring *r = &__get_cpu_var(mce_ring);
 465
 466         return r->start == r->end;
 467 }
 468
 469 static int mce_ring_get(unsigned long *pfn)
 470 {
 471         struct mce_ring *r;
 472         int ret = 0;
 473
 474         *pfn = 0;
 475         get_cpu();
 476         r = &__get_cpu_var(mce_ring);
 477         if (r->start == r->end)
 478                 goto out;
 479         *pfn = r->ring[r->start];
 480         r->start = (r->start + 1) % MCE_RING_SIZE;
 481         ret = 1;
 482 out:
 483         put_cpu();
 484         return ret;
 485 }
 486
 487 /* Always runs in MCE context with preempt off */
 488 static int mce_ring_add(unsigned long pfn)
 489 {
 490         struct mce_ring *r = &__get_cpu_var(mce_ring);
 491         unsigned next;
 492
 493         next = (r->end + 1) % MCE_RING_SIZE;
 494         if (next == r->start)
 495                 return -1;
 496         r->ring[r->end] = pfn;
 497         wmb();
 498         r->end = next;
 499         return 0;
 500 }
 501
 502 int mce_available(struct cpuinfo_x86 *c)
 503 {
 504         if (mce_disabled)
 505                 return 0;
 506         return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA);
 507 }
 508
 509 static void mce_schedule_work(void)
 510 {
 511         if (!mce_ring_empty()) {
 512                 struct work_struct *work = &__get_cpu_var(mce_work);
 513                 if (!work_pending(work))
 514                         schedule_work(work);
 515         }
 516 }
 517
 518 DEFINE_PER_CPU(struct irq_work, mce_irq_work);
 519
 520 static void mce_irq_work_cb(struct irq_work *entry)
 521 {
 522         mce_notify_irq();
 523         mce_schedule_work();
 524 }
 525
 526 static void mce_report_event(struct pt_regs *regs)
 527 {
 528         if (regs->flags & (X86_VM_MASK|X86_EFLAGS_IF)) {
 529                 mce_notify_irq();
 530                 /*
 531                  * Triggering the work queue here is just an insurance
 532                  * policy in case the syscall exit notify handler
 533                  * doesn't run soon enough or ends up running on the
 534                  * wrong CPU (can happen when audit sleeps)
 535                  */
 536                 mce_schedule_work();
 537                 return;
 538         }
 539
 540         irq_work_queue(&__get_cpu_var(mce_irq_work));
 541 }
 542
 543 /*
 544  * Read ADDR and MISC registers.
 545  */
 546 static void mce_read_aux(struct mce *m, int i)
 547 {
 548         if (m->status & MCI_STATUS_MISCV)
 549                 m->misc = mce_rdmsrl(MSR_IA32_MCx_MISC(i));
 550         if (m->status & MCI_STATUS_ADDRV) {
 551                 m->addr = mce_rdmsrl(MSR_IA32_MCx_ADDR(i));
 552
 553                 /*
 554                  * Mask the reported address by the reported granularity.
 555                  */
 556                 if (mce_ser && (m->status & MCI_STATUS_MISCV)) {
 557                         u8 shift = MCI_MISC_ADDR_LSB(m->misc);
 558                         m->addr >>= shift;
 559                         m->addr <<= shift;
 560                 }
 561         }
 562 }
 563
 564 DEFINE_PER_CPU(unsigned, mce_poll_count);
 565
 566 /*
 567  * Poll for corrected events or events that happened before reset.
 568  * Those are just logged through /dev/mcelog.
 569  *
 570  * This is executed in standard interrupt context.
 571  *
 572  * Note: spec recommends to panic for fatal unsignalled
 573  * errors here. However this would be quite problematic --
 574  * we would need to reimplement the Monarch handling and
 575  * it would mess up the exclusion between exception handler
 576  * and poll hander -- * so we skip this for now.
 577  * These cases should not happen anyways, or only when the CPU
 578  * is already totally * confused. In this case it's likely it will
 579  * not fully execute the machine check handler either.
 580  */
 581 void machine_check_poll(enum mcp_flags flags, mce_banks_t *b)
 582 {
 583         struct mce m;
 584         int i;
 585
 586         percpu_inc(mce_poll_count);
 587
 588         mce_gather_info(&m, NULL);
 589
 590         for (i = 0; i < banks; i++) {
 591                 if (!mce_banks[i].ctl || !test_bit(i, *b))
 592                         continue;
 593
 594                 m.misc = 0;
 595                 m.addr = 0;
 596                 m.bank = i;
 597                 m.tsc = 0;
 598
 599                 barrier();
 600                 m.status = mce_rdmsrl(MSR_IA32_MCx_STATUS(i));
 601                 if (!(m.status & MCI_STATUS_VAL))
 602                         continue;
 603
 604                 /*
 605                  * Uncorrected or signalled events are handled by the exception
 606                  * handler when it is enabled, so don't process those here.
 607                  *
 608                  * TBD do the same check for MCI_STATUS_EN here?
 609                  */
 610                 if (!(flags & MCP_UC) &&
 611                     (m.status & (mce_ser ? MCI_STATUS_S : MCI_STATUS_UC)))
 612                         continue;
 613
 614                 mce_read_aux(&m, i);
 615
 616                 if (!(flags & MCP_TIMESTAMP))
 617                         m.tsc = 0;
 618                 /*
 619                  * Don't get the IP here because it's unlikely to
 620                  * have anything to do with the actual error location.
 621                  */
 622                 if (!(flags & MCP_DONTLOG) && !mce_dont_log_ce)
 623                         mce_log(&m);
 624
 625                 /*
 626                  * Clear state for this bank.
 627                  */
 628                 mce_wrmsrl(MSR_IA32_MCx_STATUS(i), 0);
 629         }
 630
 631         /*
 632          * Don't clear MCG_STATUS here because it's only defined for
 633          * exceptions.
 634          */
 635
 636         sync_core();
 637 }
 638 EXPORT_SYMBOL_GPL(machine_check_poll);
 639
 640 /*
 641  * Do a quick check if any of the events requires a panic.
 642  * This decides if we keep the events around or clear them.
 643  */
 644 static int mce_no_way_out(struct mce *m, char **msg)
 645 {
 646         int i;
 647
 648         for (i = 0; i < banks; i++) {
 649                 m->status = mce_rdmsrl(MSR_IA32_MCx_STATUS(i));
 650                 if (mce_severity(m, tolerant, msg) >= MCE_PANIC_SEVERITY)
 651                         return 1;
 652         }
 653         return 0;
 654 }
 655
 656 /*
 657  * Variable to establish order between CPUs while scanning.
 658  * Each CPU spins initially until executing is equal its number.
 659  */
 660 static atomic_t mce_executing;
 661
 662 /*
 663  * Defines order of CPUs on entry. First CPU becomes Monarch.
 664  */
 665 static atomic_t mce_callin;
 666
 667 /*
 668  * Check if a timeout waiting for other CPUs happened.
 669  */
 670 static int mce_timed_out(u64 *t)
 671 {
 672         /*
 673          * The others already did panic for some reason.
 674          * Bail out like in a timeout.
 675          * rmb() to tell the compiler that system_state
 676          * might have been modified by someone else.
 677          */
 678         rmb();
 679         if (atomic_read(&mce_paniced))
 680                 wait_for_panic();
 681         if (!monarch_timeout)
 682                 goto out;
 683         if ((s64)*t < SPINUNIT) {
 684                 /* CHECKME: Make panic default for 1 too? */
 685                 if (tolerant < 1)
 686                         mce_panic("Timeout synchronizing machine check over CPUs",
 687                                   NULL, NULL);
 688                 cpu_missing = 1;
 689                 return 1;
 690         }
 691         *t -= SPINUNIT;
 692 out:
 693         touch_nmi_watchdog();
 694         return 0;
 695 }
 696
 697 /*
 698  * The Monarch's reign.  The Monarch is the CPU who entered
 699  * the machine check handler first. It waits for the others to
 700  * raise the exception too and then grades them. When any
 701  * error is fatal panic. Only then let the others continue.
 702  *
 703  * The other CPUs entering the MCE handler will be controlled by the
 704  * Monarch. They are called Subjects.
 705  *
 706  * This way we prevent any potential data corruption in a unrecoverable case
 707  * and also makes sure always all CPU's errors are examined.
 708  *
 709  * Also this detects the case of a machine check event coming from outer
 710  * space (not detected by any CPUs) In this case some external agent wants
 711  * us to shut down, so panic too.
 712  *
 713  * The other CPUs might still decide to panic if the handler happens
 714  * in a unrecoverable place, but in this case the system is in a semi-stable
 715  * state and won't corrupt anything by itself. It's ok to let the others
 716  * continue for a bit first.
 717  *
 718  * All the spin loops have timeouts; when a timeout happens a CPU
 719  * typically elects itself to be Monarch.
 720  */
 721 static void mce_reign(void)
 722 {
 723         int cpu;
 724         struct mce *m = NULL;
 725         int global_worst = 0;
 726         char *msg = NULL;
 727         char *nmsg = NULL;
 728
 729         /*
 730          * This CPU is the Monarch and the other CPUs have run
 731          * through their handlers.
 732          * Grade the severity of the errors of all the CPUs.
 733          */
 734         for_each_possible_cpu(cpu) {
 735                 int severity = mce_severity(&per_cpu(mces_seen, cpu), tolerant,
 736                                             &nmsg);
 737                 if (severity > global_worst) {
 738                         msg = nmsg;
 739                         global_worst = severity;
 740                         m = &per_cpu(mces_seen, cpu);
 741                 }
 742         }
 743
 744         /*
 745          * Cannot recover? Panic here then.
 746          * This dumps all the mces in the log buffer and stops the
 747          * other CPUs.
 748          */
 749         if (m && global_worst >= MCE_PANIC_SEVERITY && tolerant < 3)
 750                 mce_panic("Fatal Machine check", m, msg);
 751
 752         /*
 753          * For UC somewhere we let the CPU who detects it handle it.
 754          * Also must let continue the others, otherwise the handling
 755          * CPU could deadlock on a lock.
 756          */
 757
 758         /*
 759          * No machine check event found. Must be some external
 760          * source or one CPU is hung. Panic.
 761          */
 762         if (global_worst <= MCE_KEEP_SEVERITY && tolerant < 3)
 763                 mce_panic("Machine check from unknown source", NULL, NULL);
 764
 765         /*
 766          * Now clear all the mces_seen so that they don't reappear on
 767          * the next mce.
 768          */
 769         for_each_possible_cpu(cpu)
 770                 memset(&per_cpu(mces_seen, cpu), 0, sizeof(struct mce));
 771 }
 772
 773 static atomic_t global_nwo;
 774
 775 /*
 776  * Start of Monarch synchronization. This waits until all CPUs have
 777  * entered the exception handler and then determines if any of them
 778  * saw a fatal event that requires panic. Then it executes them
 779  * in the entry order.
 780  * TBD double check parallel CPU hotunplug
 781  */
 782 static int mce_start(int *no_way_out)
 783 {
 784         int order;
 785         int cpus = num_online_cpus();
 786         u64 timeout = (u64)monarch_timeout * NSEC_PER_USEC;
 787
 788         if (!timeout)
 789                 return -1;
 790
 791         atomic_add(*no_way_out, &global_nwo);
 792         /*
 793          * global_nwo should be updated before mce_callin
 794          */
 795         smp_wmb();
 796         order = atomic_inc_return(&mce_callin);
 797
 798         /*
 799          * Wait for everyone.
 800          */
 801         while (atomic_read(&mce_callin) != cpus) {
 802                 if (mce_timed_out(&timeout)) {
 803                         atomic_set(&global_nwo, 0);
 804                         return -1;
 805                 }
 806                 ndelay(SPINUNIT);
 807         }
 808
 809         /*
 810          * mce_callin should be read before global_nwo
 811          */
 812         smp_rmb();
 813
 814         if (order == 1) {
 815                 /*
 816                  * Monarch: Starts executing now, the others wait.
 817                  */
 818                 atomic_set(&mce_executing, 1);
 819         } else {
 820                 /*
 821                  * Subject: Now start the scanning loop one by one in
 822                  * the original callin order.
 823                  * This way when there are any shared banks it will be
 824                  * only seen by one CPU before cleared, avoiding duplicates.
 825                  */
 826                 while (atomic_read(&mce_executing) < order) {
 827                         if (mce_timed_out(&timeout)) {
 828                                 atomic_set(&global_nwo, 0);
 829                                 return -1;
 830                         }
 831                         ndelay(SPINUNIT);
 832                 }
 833         }
 834
 835         /*
 836          * Cache the global no_way_out state.
 837          */
 838         *no_way_out = atomic_read(&global_nwo);
 839
 840         return order;
 841 }
 842
 843 /*
 844  * Synchronize between CPUs after main scanning loop.
 845  * This invokes the bulk of the Monarch processing.
 846  */
 847 static int mce_end(int order)
 848 {
 849         int ret = -1;
 850         u64 timeout = (u64)monarch_timeout * NSEC_PER_USEC;
 851
 852         if (!timeout)
 853                 goto reset;
 854         if (order < 0)
 855                 goto reset;
 856
 857         /*
 858          * Allow others to run.
 859          */
 860         atomic_inc(&mce_executing);
 861
 862         if (order == 1) {
 863                 /* CHECKME: Can this race with a parallel hotplug? */
 864                 int cpus = num_online_cpus();
 865
 866                 /*
 867                  * Monarch: Wait for everyone to go through their scanning
 868                  * loops.
 869                  */
 870                 while (atomic_read(&mce_executing) <= cpus) {
 871                         if (mce_timed_out(&timeout))
 872                                 goto reset;
 873                         ndelay(SPINUNIT);
 874                 }
 875
 876                 mce_reign();
 877                 barrier();
 878                 ret = 0;
 879         } else {
 880                 /*
 881                  * Subject: Wait for Monarch to finish.
 882                  */
 883                 while (atomic_read(&mce_executing) != 0) {
 884                         if (mce_timed_out(&timeout))
 885                                 goto reset;
 886                         ndelay(SPINUNIT);
 887                 }
 888
 889                 /*
 890                  * Don't reset anything. That's done by the Monarch.
 891                  */
 892                 return 0;
 893         }
 894
 895         /*
 896          * Reset all global state.
 897          */
 898 reset:
 899         atomic_set(&global_nwo, 0);
 900         atomic_set(&mce_callin, 0);
 901         barrier();
 902
 903         /*
 904          * Let others run again.
 905          */
 906         atomic_set(&mce_executing, 0);
 907         return ret;
 908 }
 909
 910 /*
 911  * Check if the address reported by the CPU is in a format we can parse.
 912  * It would be possible to add code for most other cases, but all would
 913  * be somewhat complicated (e.g. segment offset would require an instruction
 914  * parser). So only support physical addresses up to page granuality for now.
 915  */
 916 static int mce_usable_address(struct mce *m)
 917 {
 918         if (!(m->status & MCI_STATUS_MISCV) || !(m->status & MCI_STATUS_ADDRV))
 919                 return 0;
 920         if (MCI_MISC_ADDR_LSB(m->misc) > PAGE_SHIFT)
 921                 return 0;
 922         if (MCI_MISC_ADDR_MODE(m->misc) != MCI_MISC_ADDR_PHYS)
 923                 return 0;
 924         return 1;
 925 }
 926
 927 static void mce_clear_state(unsigned long *toclear)
 928 {
 929         int i;
 930
 931         for (i = 0; i < banks; i++) {
 932                 if (test_bit(i, toclear))
 933                         mce_wrmsrl(MSR_IA32_MCx_STATUS(i), 0);
 934         }
 935 }
 936
 937 /*
 938  * Need to save faulting physical address associated with a process
 939  * in the machine check handler some place where we can grab it back
 940  * later in mce_notify_process()
 941  */
 942 #define MCE_INFO_MAX    16
 943
 944 struct mce_info {
 945         atomic_t                inuse;
 946         struct task_struct      *t;
 947         __u64                   paddr;
 948 } mce_info[MCE_INFO_MAX];
 949
 950 static void mce_save_info(__u64 addr)
 951 {
 952         struct mce_info *mi;
 953
 954         for (mi = mce_info; mi < &mce_info[MCE_INFO_MAX]; mi++) {
 955                 if (atomic_cmpxchg(&mi->inuse, 0, 1) == 0) {
 956                         mi->t = current;
 957                         mi->paddr = addr;
 958                         return;
 959                 }
 960         }
 961
 962         mce_panic("Too many concurrent recoverable errors", NULL, NULL);
 963 }
 964
 965 static struct mce_info *mce_find_info(void)
 966 {
 967         struct mce_info *mi;
 968
 969         for (mi = mce_info; mi < &mce_info[MCE_INFO_MAX]; mi++)
 970                 if (atomic_read(&mi->inuse) && mi->t == current)
 971                         return mi;
 972         return NULL;
 973 }
 974
 975 static void mce_clear_info(struct mce_info *mi)
 976 {
 977         atomic_set(&mi->inuse, 0);
 978 }
 979
 980 /*
 981  * The actual machine check handler. This only handles real
 982  * exceptions when something got corrupted coming in through int 18.
 983  *
 984  * This is executed in NMI context not subject to normal locking rules. This
 985  * implies that most kernel services cannot be safely used. Don't even
 986  * think about putting a printk in there!
 987  *
 988  * On Intel systems this is entered on all CPUs in parallel through
 989  * MCE broadcast. However some CPUs might be broken beyond repair,
 990  * so be always careful when synchronizing with others.
 991  */
 992 void do_machine_check(struct pt_regs *regs, long error_code)
 993 {
 994         struct mce m, *final;
 995         int i;
 996         int worst = 0;
 997         int severity;
 998         /*
 999          * Establish sequential order between the CPUs entering the machine
1000          * check handler.
1001          */
1002         int order;
1003         /*
1004          * If no_way_out gets set, there is no safe way to recover from this
1005          * MCE.  If tolerant is cranked up, we'll try anyway.
1006          */
1007         int no_way_out = 0;
1008         /*
1009          * If kill_it gets set, there might be a way to recover from this
1010          * error.
1011          */
1012         int kill_it = 0;
1013         DECLARE_BITMAP(toclear, MAX_NR_BANKS);
1014         char *msg = "Unknown";
1015
1016         atomic_inc(&mce_entry);
1017
1018         percpu_inc(mce_exception_count);
1019
1020         if (!banks)
1021                 goto out;
1022
1023         mce_gather_info(&m, regs);
1024
1025         final = &__get_cpu_var(mces_seen);
1026         *final = m;
1027
1028         no_way_out = mce_no_way_out(&m, &msg);
1029
1030         barrier();
1031
1032         /*
1033          * When no restart IP might need to kill or panic.
1034          * Assume the worst for now, but if we find the
1035          * severity is MCE_AR_SEVERITY we have other options.
1036          */
1037         if (!(m.mcgstatus & MCG_STATUS_RIPV))
1038                 kill_it = 1;
1039
1040         /*
1041          * Go through all the banks in exclusion of the other CPUs.
1042          * This way we don't report duplicated events on shared banks
1043          * because the first one to see it will clear it.
1044          */
1045         order = mce_start(&no_way_out);
1046         for (i = 0; i < banks; i++) {
1047                 __clear_bit(i, toclear);
1048                 if (!mce_banks[i].ctl)
1049                         continue;
1050
1051                 m.misc = 0;
1052                 m.addr = 0;
1053                 m.bank = i;
1054
1055                 m.status = mce_rdmsrl(MSR_IA32_MCx_STATUS(i));
1056                 if ((m.status & MCI_STATUS_VAL) == 0)
1057                         continue;
1058
1059                 /*
1060                  * Non uncorrected or non signaled errors are handled by
1061                  * machine_check_poll. Leave them alone, unless this panics.
1062                  */
1063                 if (!(m.status & (mce_ser ? MCI_STATUS_S : MCI_STATUS_UC)) &&
1064                         !no_way_out)
1065                         continue;
1066
1067                 /*
1068                  * Set taint even when machine check was not enabled.
1069                  */
1070                 add_taint(TAINT_MACHINE_CHECK);
1071
1072                 severity = mce_severity(&m, tolerant, NULL);
1073
1074                 /*
1075                  * When machine check was for corrected handler don't touch,
1076                  * unless we're panicing.
1077                  */
1078                 if (severity == MCE_KEEP_SEVERITY && !no_way_out)
1079                         continue;
1080                 __set_bit(i, toclear);
1081                 if (severity == MCE_NO_SEVERITY) {
1082                         /*
1083                          * Machine check event was not enabled. Clear, but
1084                          * ignore.
1085                          */
1086                         continue;
1087                 }
1088
1089                 mce_read_aux(&m, i);
1090
1091                 /*
1092                  * Action optional error. Queue address for later processing.
1093                  * When the ring overflows we just ignore the AO error.
1094                  * RED-PEN add some logging mechanism when
1095                  * usable_address or mce_add_ring fails.
1096                  * RED-PEN don't ignore overflow for tolerant == 0
1097                  */
1098                 if (severity == MCE_AO_SEVERITY && mce_usable_address(&m))
1099                         mce_ring_add(m.addr >> PAGE_SHIFT);
1100
1101                 mce_log(&m);
1102
1103                 if (severity > worst) {
1104                         *final = m;
1105                         worst = severity;
1106                 }
1107         }
1108
1109         /* mce_clear_state will clear *final, save locally for use later */
1110         m = *final;
1111
1112         if (!no_way_out)
1113                 mce_clear_state(toclear);
1114
1115         /*
1116          * Do most of the synchronization with other CPUs.
1117          * When there's any problem use only local no_way_out state.
1118          */
1119         if (mce_end(order) < 0)
1120                 no_way_out = worst >= MCE_PANIC_SEVERITY;
1121
1122         /*
1123          * At insane "tolerant" levels we take no action. Otherwise
1124          * we only die if we have no other choice. For less serious
1125          * issues we try to recover, or limit damage to the current
1126          * process.
1127          */
1128         if (tolerant < 3) {
1129                 if (no_way_out)
1130                         mce_panic("Fatal machine check on current CPU", &m, msg);
1131                 if (worst == MCE_AR_SEVERITY) {
1132                         /* schedule action before return to userland */
1133                         mce_save_info(m.addr);
1134                         set_thread_flag(TIF_MCE_NOTIFY);
1135                 } else if (kill_it) {
1136                         force_sig(SIGBUS, current);
1137                 }
1138         }
1139
1140         if (worst > 0)
1141                 mce_report_event(regs);
1142         mce_wrmsrl(MSR_IA32_MCG_STATUS, 0);
1143 out:
1144         atomic_dec(&mce_entry);
1145         sync_core();
1146 }
1147 EXPORT_SYMBOL_GPL(do_machine_check);
1148
1149 #ifndef CONFIG_MEMORY_FAILURE
1150 int memory_failure(unsigned long pfn, int vector, int flags)
1151 {
1152         /* mce_severity() should not hand us an ACTION_REQUIRED error */
1153         BUG_ON(flags & MF_ACTION_REQUIRED);
1154         printk(KERN_ERR "Uncorrected memory error in page 0x%lx ignored\n"
1155                 "Rebuild kernel with CONFIG_MEMORY_FAILURE=y for smarter handling\n", pfn);
1156
1157         return 0;
1158 }
1159 #endif
1160
1161 /*
1162  * Called in process context that interrupted by MCE and marked with
1163  * TIF_MCE_NOTIFY, just before returning to erroneous userland.
1164  * This code is allowed to sleep.
1165  * Attempt possible recovery such as calling the high level VM handler to
1166  * process any corrupted pages, and kill/signal current process if required.
1167  * Action required errors are handled here.
1168  */
1169 void mce_notify_process(void)
1170 {
1171         unsigned long pfn;
1172         struct mce_info *mi = mce_find_info();
1173
1174         if (!mi)
1175                 mce_panic("Lost physical address for unconsumed uncorrectable error", NULL, NULL);
1176         pfn = mi->paddr >> PAGE_SHIFT;
1177
1178         clear_thread_flag(TIF_MCE_NOTIFY);
1179
1180         pr_err("Uncorrected hardware memory error in user-access at %llx",
1181                  mi->paddr);
1182         if (memory_failure(pfn, MCE_VECTOR, MF_ACTION_REQUIRED) < 0) {
1183                 pr_err("Memory error not recovered");
1184                 force_sig(SIGBUS, current);
1185         }
1186         mce_clear_info(mi);
1187 }
1188
1189 /*
1190  * Action optional processing happens here (picking up
1191  * from the list of faulting pages that do_machine_check()
1192  * placed into the "ring").
1193  */
1194 static void mce_process_work(struct work_struct *dummy)
1195 {
1196         unsigned long pfn;
1197
1198         while (mce_ring_get(&pfn))
1199                 memory_failure(pfn, MCE_VECTOR, 0);
1200 }
1201
1202 #ifdef CONFIG_X86_MCE_INTEL
1203 /***
1204  * mce_log_therm_throt_event - Logs the thermal throttling event to mcelog
1205  * @cpu: The CPU on which the event occurred.
1206  * @status: Event status information
1207  *
1208  * This function should be called by the thermal interrupt after the
1209  * event has been processed and the decision was made to log the event
1210  * further.
1211  *
1212  * The status parameter will be saved to the 'status' field of 'struct mce'
1213  * and historically has been the register value of the
1214  * MSR_IA32_THERMAL_STATUS (Intel) msr.
1215  */
1216 void mce_log_therm_throt_event(__u64 status)
1217 {
1218         struct mce m;
1219
1220         mce_setup(&m);
1221         m.bank = MCE_THERMAL_BANK;
1222         m.status = status;
1223         mce_log(&m);
1224 }
1225 #endif /* CONFIG_X86_MCE_INTEL */
1226
1227 /*
1228  * Periodic polling timer for "silent" machine check errors.  If the
1229  * poller finds an MCE, poll 2x faster.  When the poller finds no more
1230  * errors, poll 2x slower (up to check_interval seconds).
1231  */
1232 static int check_interval = 5 * 60; /* 5 minutes */
1233
1234 static DEFINE_PER_CPU(int, mce_next_interval); /* in jiffies */
1235 static DEFINE_PER_CPU(struct timer_list, mce_timer);
1236
1237 static void mce_start_timer(unsigned long data)
1238 {
1239         struct timer_list *t = &per_cpu(mce_timer, data);
1240         int *n;
1241
1242         WARN_ON(smp_processor_id() != data);
1243
1244         if (mce_available(__this_cpu_ptr(&cpu_info))) {
1245                 machine_check_poll(MCP_TIMESTAMP,
1246                                 &__get_cpu_var(mce_poll_banks));
1247         }
1248
1249         /*
1250          * Alert userspace if needed.  If we logged an MCE, reduce the
1251          * polling interval, otherwise increase the polling interval.
1252          */
1253         n = &__get_cpu_var(mce_next_interval);
1254         if (mce_notify_irq())
1255                 *n = max(*n/2, HZ/100);
1256         else
1257                 *n = min(*n*2, (int)round_jiffies_relative(check_interval*HZ));
1258
1259         t->expires = jiffies + *n;
1260         add_timer_on(t, smp_processor_id());
1261 }
1262
1263 /* Must not be called in IRQ context where del_timer_sync() can deadlock */
1264 static void mce_timer_delete_all(void)
1265 {
1266         int cpu;
1267
1268         for_each_online_cpu(cpu)
1269                 del_timer_sync(&per_cpu(mce_timer, cpu));
1270 }
1271
1272 static void mce_do_trigger(struct work_struct *work)
1273 {
1274         call_usermodehelper(mce_helper, mce_helper_argv, NULL, UMH_NO_WAIT);
1275 }
1276
1277 static DECLARE_WORK(mce_trigger_work, mce_do_trigger);
1278
1279 /*
1280  * Notify the user(s) about new machine check events.
1281  * Can be called from interrupt context, but not from machine check/NMI
1282  * context.
1283  */
1284 int mce_notify_irq(void)
1285 {
1286         /* Not more than two messages every minute */
1287         static DEFINE_RATELIMIT_STATE(ratelimit, 60*HZ, 2);
1288
1289         if (test_and_clear_bit(0, &mce_need_notify)) {
1290                 /* wake processes polling /dev/mcelog */
1291                 wake_up_interruptible(&mce_chrdev_wait);
1292
1293                 /*
1294                  * There is no risk of missing notifications because
1295                  * work_pending is always cleared before the function is
1296                  * executed.
1297                  */
1298                 if (mce_helper[0] && !work_pending(&mce_trigger_work))
1299                         schedule_work(&mce_trigger_work);
1300
1301                 if (__ratelimit(&ratelimit))
1302                         pr_info(HW_ERR "Machine check events logged\n");
1303
1304                 return 1;
1305         }
1306         return 0;
1307 }
1308 EXPORT_SYMBOL_GPL(mce_notify_irq);
1309
1310 static int __cpuinit __mcheck_cpu_mce_banks_init(void)
1311 {
1312         int i;
1313
1314         mce_banks = kzalloc(banks * sizeof(struct mce_bank), GFP_KERNEL);
1315         if (!mce_banks)
1316                 return -ENOMEM;
1317         for (i = 0; i < banks; i++) {
1318                 struct mce_bank *b = &mce_banks[i];
1319
1320                 b->ctl = -1ULL;
1321                 b->init = 1;
1322         }
1323         return 0;
1324 }
1325
1326 /*
1327  * Initialize Machine Checks for a CPU.
1328  */
1329 static int __cpuinit __mcheck_cpu_cap_init(void)
1330 {
1331         unsigned b;
1332         u64 cap;
1333
1334         rdmsrl(MSR_IA32_MCG_CAP, cap);
1335
1336         b = cap & MCG_BANKCNT_MASK;
1337         if (!banks)
1338                 printk(KERN_INFO "mce: CPU supports %d MCE banks\n", b);
1339
1340         if (b > MAX_NR_BANKS) {
1341                 printk(KERN_WARNING
1342                        "MCE: Using only %u machine check banks out of %u\n",
1343                         MAX_NR_BANKS, b);
1344                 b = MAX_NR_BANKS;
1345         }
1346
1347         /* Don't support asymmetric configurations today */
1348         WARN_ON(banks != 0 && b != banks);
1349         banks = b;
1350         if (!mce_banks) {
1351                 int err = __mcheck_cpu_mce_banks_init();
1352
1353                 if (err)
1354                         return err;
1355         }
1356
1357         /* Use accurate RIP reporting if available. */
1358         if ((cap & MCG_EXT_P) && MCG_EXT_CNT(cap) >= 9)
1359                 rip_msr = MSR_IA32_MCG_EIP;
1360
1361         if (cap & MCG_SER_P)
1362                 mce_ser = 1;
1363
1364         return 0;
1365 }
1366
1367 static void __mcheck_cpu_init_generic(void)
1368 {
1369         mce_banks_t all_banks;
1370         u64 cap;
1371         int i;
1372
1373         /*
1374          * Log the machine checks left over from the previous reset.
1375          */
1376         bitmap_fill(all_banks, MAX_NR_BANKS);
1377         machine_check_poll(MCP_UC|(!mce_bootlog ? MCP_DONTLOG : 0), &all_banks);
1378
1379         set_in_cr4(X86_CR4_MCE);
1380
1381         rdmsrl(MSR_IA32_MCG_CAP, cap);
1382         if (cap & MCG_CTL_P)
1383                 wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff);
1384
1385         for (i = 0; i < banks; i++) {
1386                 struct mce_bank *b = &mce_banks[i];
1387
1388                 if (!b->init)
1389                         continue;
1390                 wrmsrl(MSR_IA32_MCx_CTL(i), b->ctl);
1391                 wrmsrl(MSR_IA32_MCx_STATUS(i), 0);
1392         }
1393 }
1394
1395 /* Add per CPU specific workarounds here */
1396 static int __cpuinit __mcheck_cpu_apply_quirks(struct cpuinfo_x86 *c)
1397 {
1398         if (c->x86_vendor == X86_VENDOR_UNKNOWN) {
1399                 pr_info("MCE: unknown CPU type - not enabling MCE support.\n");
1400                 return -EOPNOTSUPP;
1401         }
1402
1403         /* This should be disabled by the BIOS, but isn't always */
1404         if (c->x86_vendor == X86_VENDOR_AMD) {
1405                 if (c->x86 == 15 && banks > 4) {
1406                         /*
1407                          * disable GART TBL walk error reporting, which
1408                          * trips off incorrectly with the IOMMU & 3ware
1409                          * & Cerberus:
1410                          */
1411                         clear_bit(10, (unsigned long *)&mce_banks[4].ctl);
1412                 }
1413                 if (c->x86 <= 17 && mce_bootlog < 0) {
1414                         /*
1415                          * Lots of broken BIOS around that don't clear them
1416                          * by default and leave crap in there. Don't log:
1417                          */
1418                         mce_bootlog = 0;
1419                 }
1420                 /*
1421                  * Various K7s with broken bank 0 around. Always disable
1422                  * by default.
1423                  */
1424                  if (c->x86 == 6 && banks > 0)
1425                         mce_banks[0].ctl = 0;
1426         }
1427
1428         if (c->x86_vendor == X86_VENDOR_INTEL) {
1429                 /*
1430                  * SDM documents that on family 6 bank 0 should not be written
1431                  * because it aliases to another special BIOS controlled
1432                  * register.
1433                  * But it's not aliased anymore on model 0x1a+
1434                  * Don't ignore bank 0 completely because there could be a
1435                  * valid event later, merely don't write CTL0.
1436                  */
1437
1438                 if (c->x86 == 6 && c->x86_model < 0x1A && banks > 0)
1439                         mce_banks[0].init = 0;
1440
1441                 /*
1442                  * All newer Intel systems support MCE broadcasting. Enable
1443                  * synchronization with a one second timeout.
1444                  */
1445                 if ((c->x86 > 6 || (c->x86 == 6 && c->x86_model >= 0xe)) &&
1446                         monarch_timeout < 0)
1447                         monarch_timeout = USEC_PER_SEC;
1448
1449                 /*
1450                  * There are also broken BIOSes on some Pentium M and
1451                  * earlier systems:
1452                  */
1453                 if (c->x86 == 6 && c->x86_model <= 13 && mce_bootlog < 0)
1454                         mce_bootlog = 0;
1455         }
1456         if (monarch_timeout < 0)
1457                 monarch_timeout = 0;
1458         if (mce_bootlog != 0)
1459                 mce_panic_timeout = 30;
1460
1461         return 0;
1462 }
1463
1464 static int __cpuinit __mcheck_cpu_ancient_init(struct cpuinfo_x86 *c)
1465 {
1466         if (c->x86 != 5)
1467                 return 0;
1468
1469         switch (c->x86_vendor) {
1470         case X86_VENDOR_INTEL:
1471                 intel_p5_mcheck_init(c);
1472                 return 1;
1473                 break;
1474         case X86_VENDOR_CENTAUR:
1475                 winchip_mcheck_init(c);
1476                 return 1;
1477                 break;
1478         }
1479
1480         return 0;
1481 }
1482
1483 static void __mcheck_cpu_init_vendor(struct cpuinfo_x86 *c)
1484 {
1485         switch (c->x86_vendor) {
1486         case X86_VENDOR_INTEL:
1487                 mce_intel_feature_init(c);
1488                 break;
1489         case X86_VENDOR_AMD:
1490                 mce_amd_feature_init(c);
1491                 break;
1492         default:
1493                 break;
1494         }
1495 }
1496
1497 static void __mcheck_cpu_init_timer(void)
1498 {
1499         struct timer_list *t = &__get_cpu_var(mce_timer);
1500         int *n = &__get_cpu_var(mce_next_interval);
1501
1502         setup_timer(t, mce_start_timer, smp_processor_id());
1503
1504         if (mce_ignore_ce)
1505                 return;
1506
1507         *n = check_interval * HZ;
1508         if (!*n)
1509                 return;
1510         t->expires = round_jiffies(jiffies + *n);
1511         add_timer_on(t, smp_processor_id());
1512 }
1513
1514 /* Handle unconfigured int18 (should never happen) */
1515 static void unexpected_machine_check(struct pt_regs *regs, long error_code)
1516 {
1517         printk(KERN_ERR "CPU#%d: Unexpected int18 (Machine Check).\n",
1518                smp_processor_id());
1519 }
1520
1521 /* Call the installed machine check handler for this CPU setup. */
1522 void (*machine_check_vector)(struct pt_regs *, long error_code) =
1523                                                 unexpected_machine_check;
1524
1525 /*
1526  * Called for each booted CPU to set up machine checks.
1527  * Must be called with preempt off:
1528  */
1529 void __cpuinit mcheck_cpu_init(struct cpuinfo_x86 *c)
1530 {
1531         if (mce_disabled)
1532                 return;
1533
1534         if (__mcheck_cpu_ancient_init(c))
1535                 return;
1536
1537         if (!mce_available(c))
1538                 return;
1539
1540         if (__mcheck_cpu_cap_init() < 0 || __mcheck_cpu_apply_quirks(c) < 0) {
1541                 mce_disabled = 1;
1542                 return;
1543         }
1544
1545         machine_check_vector = do_machine_check;
1546
1547         __mcheck_cpu_init_generic();
1548         __mcheck_cpu_init_vendor(c);
1549         __mcheck_cpu_init_timer();
1550         INIT_WORK(&__get_cpu_var(mce_work), mce_process_work);
1551         init_irq_work(&__get_cpu_var(mce_irq_work), &mce_irq_work_cb);
1552 }
1553
1554 /*
1555  * mce_chrdev: Character device /dev/mcelog to read and clear the MCE log.
1556  */
1557
1558 static DEFINE_SPINLOCK(mce_chrdev_state_lock);
1559 static int mce_chrdev_open_count;       /* #times opened */
1560 static int mce_chrdev_open_exclu;       /* already open exclusive? */
1561
1562 static int mce_chrdev_open(struct inode *inode, struct file *file)
1563 {
1564         spin_lock(&mce_chrdev_state_lock);
1565
1566         if (mce_chrdev_open_exclu ||
1567             (mce_chrdev_open_count && (file->f_flags & O_EXCL))) {
1568                 spin_unlock(&mce_chrdev_state_lock);
1569
1570                 return -EBUSY;
1571         }
1572
1573         if (file->f_flags & O_EXCL)
1574                 mce_chrdev_open_exclu = 1;
1575         mce_chrdev_open_count++;
1576
1577         spin_unlock(&mce_chrdev_state_lock);
1578
1579         return nonseekable_open(inode, file);
1580 }
1581
1582 static int mce_chrdev_release(struct inode *inode, struct file *file)
1583 {
1584         spin_lock(&mce_chrdev_state_lock);
1585
1586         mce_chrdev_open_count--;
1587         mce_chrdev_open_exclu = 0;
1588
1589         spin_unlock(&mce_chrdev_state_lock);
1590
1591         return 0;
1592 }
1593
1594 static void collect_tscs(void *data)
1595 {
1596         unsigned long *cpu_tsc = (unsigned long *)data;
1597
1598         rdtscll(cpu_tsc[smp_processor_id()]);
1599 }
1600
1601 static int mce_apei_read_done;
1602
1603 /* Collect MCE record of previous boot in persistent storage via APEI ERST. */
1604 static int __mce_read_apei(char __user **ubuf, size_t usize)
1605 {
1606         int rc;
1607         u64 record_id;
1608         struct mce m;
1609
1610         if (usize < sizeof(struct mce))
1611                 return -EINVAL;
1612
1613         rc = apei_read_mce(&m, &record_id);
1614         /* Error or no more MCE record */
1615         if (rc <= 0) {
1616                 mce_apei_read_done = 1;
1617                 return rc;
1618         }
1619         rc = -EFAULT;
1620         if (copy_to_user(*ubuf, &m, sizeof(struct mce)))
1621                 return rc;
1622         /*
1623          * In fact, we should have cleared the record after that has
1624          * been flushed to the disk or sent to network in
1625          * /sbin/mcelog, but we have no interface to support that now,
1626          * so just clear it to avoid duplication.
1627          */
1628         rc = apei_clear_mce(record_id);
1629         if (rc) {
1630                 mce_apei_read_done = 1;
1631                 return rc;
1632         }
1633         *ubuf += sizeof(struct mce);
1634
1635         return 0;
1636 }
1637
1638 static ssize_t mce_chrdev_read(struct file *filp, char __user *ubuf,
1639                                 size_t usize, loff_t *off)
1640 {
1641         char __user *buf = ubuf;
1642         unsigned long *cpu_tsc;
1643         unsigned prev, next;
1644         int i, err;
1645
1646         cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL);
1647         if (!cpu_tsc)
1648                 return -ENOMEM;
1649
1650         mutex_lock(&mce_chrdev_read_mutex);
1651
1652         if (!mce_apei_read_done) {
1653                 err = __mce_read_apei(&buf, usize);
1654                 if (err || buf != ubuf)
1655                         goto out;
1656         }
1657
1658         next = rcu_dereference_check_mce(mcelog.next);
1659
1660         /* Only supports full reads right now */
1661         err = -EINVAL;
1662         if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce))
1663                 goto out;
1664
1665         err = 0;
1666         prev = 0;
1667         do {
1668                 for (i = prev; i < next; i++) {
1669                         unsigned long start = jiffies;
1670                         struct mce *m = &mcelog.entry[i];
1671
1672                         while (!m->finished) {
1673                                 if (time_after_eq(jiffies, start + 2)) {
1674                                         memset(m, 0, sizeof(*m));
1675                                         goto timeout;
1676                                 }
1677                                 cpu_relax();
1678                         }
1679                         smp_rmb();
1680                         err |= copy_to_user(buf, m, sizeof(*m));
1681                         buf += sizeof(*m);
1682 timeout:
1683                         ;
1684                 }
1685
1686                 memset(mcelog.entry + prev, 0,
1687                        (next - prev) * sizeof(struct mce));
1688                 prev = next;
1689                 next = cmpxchg(&mcelog.next, prev, 0);
1690         } while (next != prev);
1691
1692         synchronize_sched();
1693
1694         /*
1695          * Collect entries that were still getting written before the
1696          * synchronize.
1697          */
1698         on_each_cpu(collect_tscs, cpu_tsc, 1);
1699
1700         for (i = next; i < MCE_LOG_LEN; i++) {
1701                 struct mce *m = &mcelog.entry[i];
1702
1703                 if (m->finished && m->tsc < cpu_tsc[m->cpu]) {
1704                         err |= copy_to_user(buf, m, sizeof(*m));
1705                         smp_rmb();
1706                         buf += sizeof(*m);
1707                         memset(m, 0, sizeof(*m));
1708                 }
1709         }
1710
1711         if (err)
1712                 err = -EFAULT;
1713
1714 out:
1715         mutex_unlock(&mce_chrdev_read_mutex);
1716         kfree(cpu_tsc);
1717
1718         return err ? err : buf - ubuf;
1719 }
1720
1721 static unsigned int mce_chrdev_poll(struct file *file, poll_table *wait)
1722 {
1723         poll_wait(file, &mce_chrdev_wait, wait);
1724         if (rcu_access_index(mcelog.next))
1725                 return POLLIN | POLLRDNORM;
1726         if (!mce_apei_read_done && apei_check_mce())
1727                 return POLLIN | POLLRDNORM;
1728         return 0;
1729 }
1730
1731 static long mce_chrdev_ioctl(struct file *f, unsigned int cmd,
1732                                 unsigned long arg)
1733 {
1734         int __user *p = (int __user *)arg;
1735
1736         if (!capable(CAP_SYS_ADMIN))
1737                 return -EPERM;
1738
1739         switch (cmd) {
1740         case MCE_GET_RECORD_LEN:
1741                 return put_user(sizeof(struct mce), p);
1742         case MCE_GET_LOG_LEN:
1743                 return put_user(MCE_LOG_LEN, p);
1744         case MCE_GETCLEAR_FLAGS: {
1745                 unsigned flags;
1746
1747                 do {
1748                         flags = mcelog.flags;
1749                 } while (cmpxchg(&mcelog.flags, flags, 0) != flags);
1750
1751                 return put_user(flags, p);
1752         }
1753         default:
1754                 return -ENOTTY;
1755         }
1756 }
1757
1758 static ssize_t (*mce_write)(struct file *filp, const char __user *ubuf,
1759                             size_t usize, loff_t *off);
1760
1761 void register_mce_write_callback(ssize_t (*fn)(struct file *filp,
1762                              const char __user *ubuf,
1763                              size_t usize, loff_t *off))
1764 {
1765         mce_write = fn;
1766 }
1767 EXPORT_SYMBOL_GPL(register_mce_write_callback);
1768
1769 ssize_t mce_chrdev_write(struct file *filp, const char __user *ubuf,
1770                          size_t usize, loff_t *off)
1771 {
1772         if (mce_write)
1773                 return mce_write(filp, ubuf, usize, off);
1774         else
1775                 return -EINVAL;
1776 }
1777
1778 static const struct file_operations mce_chrdev_ops = {
1779         .open                   = mce_chrdev_open,
1780         .release                = mce_chrdev_release,
1781         .read                   = mce_chrdev_read,
1782         .write                  = mce_chrdev_write,
1783         .poll                   = mce_chrdev_poll,
1784         .unlocked_ioctl         = mce_chrdev_ioctl,
1785         .llseek                 = no_llseek,
1786 };
1787
1788 static struct miscdevice mce_chrdev_device = {
1789         MISC_MCELOG_MINOR,
1790         "mcelog",
1791         &mce_chrdev_ops,
1792 };
1793
1794 /*
1795  * mce=off Disables machine check
1796  * mce=no_cmci Disables CMCI
1797  * mce=dont_log_ce Clears corrected events silently, no log created for CEs.
1798  * mce=ignore_ce Disables polling and CMCI, corrected events are not cleared.
1799  * mce=TOLERANCELEVEL[,monarchtimeout] (number, see above)
1800  *      monarchtimeout is how long to wait for other CPUs on machine
1801  *      check, or 0 to not wait
1802  * mce=bootlog Log MCEs from before booting. Disabled by default on AMD.
1803  * mce=nobootlog Don't log MCEs from before booting.
1804  */
1805 static int __init mcheck_enable(char *str)
1806 {
1807         if (*str == 0) {
1808                 enable_p5_mce();
1809                 return 1;
1810         }
1811         if (*str == '=')
1812                 str++;
1813         if (!strcmp(str, "off"))
1814                 mce_disabled = 1;
1815         else if (!strcmp(str, "no_cmci"))
1816                 mce_cmci_disabled = 1;
1817         else if (!strcmp(str, "dont_log_ce"))
1818                 mce_dont_log_ce = 1;
1819         else if (!strcmp(str, "ignore_ce"))
1820                 mce_ignore_ce = 1;
1821         else if (!strcmp(str, "bootlog") || !strcmp(str, "nobootlog"))
1822                 mce_bootlog = (str[0] == 'b');
1823         else if (isdigit(str[0])) {
1824                 get_option(&str, &tolerant);
1825                 if (*str == ',') {
1826                         ++str;
1827                         get_option(&str, &monarch_timeout);
1828                 }
1829         } else {
1830                 printk(KERN_INFO "mce argument %s ignored. Please use /sys\n",
1831                        str);
1832                 return 0;
1833         }
1834         return 1;
1835 }
1836 __setup("mce", mcheck_enable);
1837
1838 int __init mcheck_init(void)
1839 {
1840         mcheck_intel_therm_init();
1841
1842         return 0;
1843 }
1844
1845 /*
1846  * mce_syscore: PM support
1847  */
1848
1849 /*
1850  * Disable machine checks on suspend and shutdown. We can't really handle
1851  * them later.
1852  */
1853 static int mce_disable_error_reporting(void)
1854 {
1855         int i;
1856
1857         for (i = 0; i < banks; i++) {
1858                 struct mce_bank *b = &mce_banks[i];
1859
1860                 if (b->init)
1861                         wrmsrl(MSR_IA32_MCx_CTL(i), 0);
1862         }
1863         return 0;
1864 }
1865
1866 static int mce_syscore_suspend(void)
1867 {
1868         return mce_disable_error_reporting();
1869 }
1870
1871 static void mce_syscore_shutdown(void)
1872 {
1873         mce_disable_error_reporting();
1874 }
1875
1876 /*
1877  * On resume clear all MCE state. Don't want to see leftovers from the BIOS.
1878  * Only one CPU is active at this time, the others get re-added later using
1879  * CPU hotplug:
1880  */
1881 static void mce_syscore_resume(void)
1882 {
1883         __mcheck_cpu_init_generic();
1884         __mcheck_cpu_init_vendor(__this_cpu_ptr(&cpu_info));
1885 }
1886
1887 static struct syscore_ops mce_syscore_ops = {
1888         .suspend        = mce_syscore_suspend,
1889         .shutdown       = mce_syscore_shutdown,
1890         .resume         = mce_syscore_resume,
1891 };
1892
1893 /*
1894  * mce_device: Sysfs support
1895  */
1896
1897 static void mce_cpu_restart(void *data)
1898 {
1899         if (!mce_available(__this_cpu_ptr(&cpu_info)))
1900                 return;
1901         __mcheck_cpu_init_generic();
1902         __mcheck_cpu_init_timer();
1903 }
1904
1905 /* Reinit MCEs after user configuration changes */
1906 static void mce_restart(void)
1907 {
1908         mce_timer_delete_all();
1909         on_each_cpu(mce_cpu_restart, NULL, 1);
1910 }
1911
1912 /* Toggle features for corrected errors */
1913 static void mce_disable_cmci(void *data)
1914 {
1915         if (!mce_available(__this_cpu_ptr(&cpu_info)))
1916                 return;
1917         cmci_clear();
1918 }
1919
1920 static void mce_enable_ce(void *all)
1921 {
1922         if (!mce_available(__this_cpu_ptr(&cpu_info)))
1923                 return;
1924         cmci_reenable();
1925         cmci_recheck();
1926         if (all)
1927                 __mcheck_cpu_init_timer();
1928 }
1929
1930 static struct bus_type mce_subsys = {
1931         .name           = "machinecheck",
1932         .dev_name       = "machinecheck",
1933 };
1934
1935 struct device *mce_device[CONFIG_NR_CPUS];
1936
1937 __cpuinitdata
1938 void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu);
1939
1940 static inline struct mce_bank *attr_to_bank(struct device_attribute *attr)
1941 {
1942         return container_of(attr, struct mce_bank, attr);
1943 }
1944
1945 static ssize_t show_bank(struct device *s, struct device_attribute *attr,
1946                          char *buf)
1947 {
1948         return sprintf(buf, "%llx\n", attr_to_bank(attr)->ctl);
1949 }
1950
1951 static ssize_t set_bank(struct device *s, struct device_attribute *attr,
1952                         const char *buf, size_t size)
1953 {
1954         u64 new;
1955
1956         if (strict_strtoull(buf, 0, &new) < 0)
1957                 return -EINVAL;
1958
1959         attr_to_bank(attr)->ctl = new;
1960         mce_restart();
1961
1962         return size;
1963 }
1964
1965 static ssize_t
1966 show_trigger(struct device *s, struct device_attribute *attr, char *buf)
1967 {
1968         strcpy(buf, mce_helper);
1969         strcat(buf, "\n");
1970         return strlen(mce_helper) + 1;
1971 }
1972
1973 static ssize_t set_trigger(struct device *s, struct device_attribute *attr,
1974                                 const char *buf, size_t siz)
1975 {
1976         char *p;
1977
1978         strncpy(mce_helper, buf, sizeof(mce_helper));
1979         mce_helper[sizeof(mce_helper)-1] = 0;
1980         p = strchr(mce_helper, '\n');
1981
1982         if (p)
1983                 *p = 0;
1984
1985         return strlen(mce_helper) + !!p;
1986 }
1987
1988 static ssize_t set_ignore_ce(struct device *s,
1989                              struct device_attribute *attr,
1990                              const char *buf, size_t size)
1991 {
1992         u64 new;
1993
1994         if (strict_strtoull(buf, 0, &new) < 0)
1995                 return -EINVAL;
1996
1997         if (mce_ignore_ce ^ !!new) {
1998                 if (new) {
1999                         /* disable ce features */
2000                         mce_timer_delete_all();
2001                         on_each_cpu(mce_disable_cmci, NULL, 1);
2002                         mce_ignore_ce = 1;
2003                 } else {
2004                         /* enable ce features */
2005                         mce_ignore_ce = 0;
2006                         on_each_cpu(mce_enable_ce, (void *)1, 1);
2007                 }
2008         }
2009         return size;
2010 }
2011
2012 static ssize_t set_cmci_disabled(struct device *s,
2013                                  struct device_attribute *attr,
2014                                  const char *buf, size_t size)
2015 {
2016         u64 new;
2017
2018         if (strict_strtoull(buf, 0, &new) < 0)
2019                 return -EINVAL;
2020
2021         if (mce_cmci_disabled ^ !!new) {
2022                 if (new) {
2023                         /* disable cmci */
2024                         on_each_cpu(mce_disable_cmci, NULL, 1);
2025                         mce_cmci_disabled = 1;
2026                 } else {
2027                         /* enable cmci */
2028                         mce_cmci_disabled = 0;
2029                         on_each_cpu(mce_enable_ce, NULL, 1);
2030                 }
2031         }
2032         return size;
2033 }
2034
2035 static ssize_t store_int_with_restart(struct device *s,
2036                                       struct device_attribute *attr,
2037                                       const char *buf, size_t size)
2038 {
2039         ssize_t ret = device_store_int(s, attr, buf, size);
2040         mce_restart();
2041         return ret;
2042 }
2043
2044 static DEVICE_ATTR(trigger, 0644, show_trigger, set_trigger);
2045 static DEVICE_INT_ATTR(tolerant, 0644, tolerant);
2046 static DEVICE_INT_ATTR(monarch_timeout, 0644, monarch_timeout);
2047 static DEVICE_INT_ATTR(dont_log_ce, 0644, mce_dont_log_ce);
2048
2049 static struct dev_ext_attribute dev_attr_check_interval = {
2050         __ATTR(check_interval, 0644, device_show_int, store_int_with_restart),
2051         &check_interval
2052 };
2053
2054 static struct dev_ext_attribute dev_attr_ignore_ce = {
2055         __ATTR(ignore_ce, 0644, device_show_int, set_ignore_ce),
2056         &mce_ignore_ce
2057 };
2058
2059 static struct dev_ext_attribute dev_attr_cmci_disabled = {
2060         __ATTR(cmci_disabled, 0644, device_show_int, set_cmci_disabled),
2061         &mce_cmci_disabled
2062 };
2063
2064 static struct device_attribute *mce_device_attrs[] = {
2065         &dev_attr_tolerant.attr,
2066         &dev_attr_check_interval.attr,
2067         &dev_attr_trigger,
2068         &dev_attr_monarch_timeout.attr,
2069         &dev_attr_dont_log_ce.attr,
2070         &dev_attr_ignore_ce.attr,
2071         &dev_attr_cmci_disabled.attr,
2072         NULL
2073 };
2074
2075 static cpumask_var_t mce_device_initialized;
2076
2077 static void mce_device_release(struct device *dev)
2078 {
2079         kfree(dev);
2080 }
2081
2082 /* Per cpu device init. All of the cpus still share the same ctrl bank: */
2083 static __cpuinit int mce_device_create(unsigned int cpu)
2084 {
2085         struct device *dev;
2086         int err;
2087         int i, j;
2088
2089         if (!mce_available(&boot_cpu_data))
2090                 return -EIO;
2091
2092         dev = kzalloc(sizeof *dev, GFP_KERNEL);
2093         if (!dev)
2094                 return -ENOMEM;
2095         dev->id  = cpu;
2096         dev->bus = &mce_subsys;
2097         dev->release = &mce_device_release;
2098
2099         err = device_register(dev);
2100         if (err)
2101                 return err;
2102
2103         for (i = 0; mce_device_attrs[i]; i++) {
2104                 err = device_create_file(dev, mce_device_attrs[i]);
2105                 if (err)
2106                         goto error;
2107         }
2108         for (j = 0; j < banks; j++) {
2109                 err = device_create_file(dev, &mce_banks[j].attr);
2110                 if (err)
2111                         goto error2;
2112         }
2113         cpumask_set_cpu(cpu, mce_device_initialized);
2114         mce_device[cpu] = dev;
2115
2116         return 0;
2117 error2:
2118         while (--j >= 0)
2119                 device_remove_file(dev, &mce_banks[j].attr);
2120 error:
2121         while (--i >= 0)
2122                 device_remove_file(dev, mce_device_attrs[i]);
2123
2124         device_unregister(dev);
2125
2126         return err;
2127 }
2128
2129 static __cpuinit void mce_device_remove(unsigned int cpu)
2130 {
2131         struct device *dev = mce_device[cpu];
2132         int i;
2133
2134         if (!cpumask_test_cpu(cpu, mce_device_initialized))
2135                 return;
2136
2137         for (i = 0; mce_device_attrs[i]; i++)
2138                 device_remove_file(dev, mce_device_attrs[i]);
2139
2140         for (i = 0; i < banks; i++)
2141                 device_remove_file(dev, &mce_banks[i].attr);
2142
2143         device_unregister(dev);
2144         cpumask_clear_cpu(cpu, mce_device_initialized);
2145         mce_device[cpu] = NULL;
2146 }
2147
2148 /* Make sure there are no machine checks on offlined CPUs. */
2149 static void __cpuinit mce_disable_cpu(void *h)
2150 {
2151         unsigned long action = *(unsigned long *)h;
2152         int i;
2153
2154         if (!mce_available(__this_cpu_ptr(&cpu_info)))
2155                 return;
2156
2157         if (!(action & CPU_TASKS_FROZEN))
2158                 cmci_clear();
2159         for (i = 0; i < banks; i++) {
2160                 struct mce_bank *b = &mce_banks[i];
2161
2162                 if (b->init)
2163                         wrmsrl(MSR_IA32_MCx_CTL(i), 0);
2164         }
2165 }
2166
2167 static void __cpuinit mce_reenable_cpu(void *h)
2168 {
2169         unsigned long action = *(unsigned long *)h;
2170         int i;
2171
2172         if (!mce_available(__this_cpu_ptr(&cpu_info)))
2173                 return;
2174
2175         if (!(action & CPU_TASKS_FROZEN))
2176                 cmci_reenable();
2177         for (i = 0; i < banks; i++) {
2178                 struct mce_bank *b = &mce_banks[i];
2179
2180                 if (b->init)
2181                         wrmsrl(MSR_IA32_MCx_CTL(i), b->ctl);
2182         }
2183 }
2184
2185 /* Get notified when a cpu comes on/off. Be hotplug friendly. */
2186 static int __cpuinit
2187 mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
2188 {
2189         unsigned int cpu = (unsigned long)hcpu;
2190         struct timer_list *t = &per_cpu(mce_timer, cpu);
2191
2192         switch (action) {
2193         case CPU_ONLINE:
2194         case CPU_ONLINE_FROZEN:
2195                 mce_device_create(cpu);
2196                 if (threshold_cpu_callback)
2197                         threshold_cpu_callback(action, cpu);
2198                 break;
2199         case CPU_DEAD:
2200         case CPU_DEAD_FROZEN:
2201                 if (threshold_cpu_callback)
2202                         threshold_cpu_callback(action, cpu);
2203                 mce_device_remove(cpu);
2204                 break;
2205         case CPU_DOWN_PREPARE:
2206         case CPU_DOWN_PREPARE_FROZEN:
2207                 del_timer_sync(t);
2208                 smp_call_function_single(cpu, mce_disable_cpu, &action, 1);
2209                 break;
2210         case CPU_DOWN_FAILED:
2211         case CPU_DOWN_FAILED_FROZEN:
2212                 if (!mce_ignore_ce && check_interval) {
2213                         t->expires = round_jiffies(jiffies +
2214                                            __get_cpu_var(mce_next_interval));
2215                         add_timer_on(t, cpu);
2216                 }
2217                 smp_call_function_single(cpu, mce_reenable_cpu, &action, 1);
2218                 break;
2219         case CPU_POST_DEAD:
2220                 /* intentionally ignoring frozen here */
2221                 cmci_rediscover(cpu);
2222                 break;
2223         }
2224         return NOTIFY_OK;
2225 }
2226
2227 static struct notifier_block mce_cpu_notifier __cpuinitdata = {
2228         .notifier_call = mce_cpu_callback,
2229 };
2230
2231 static __init void mce_init_banks(void)
2232 {
2233         int i;
2234
2235         for (i = 0; i < banks; i++) {
2236                 struct mce_bank *b = &mce_banks[i];
2237                 struct device_attribute *a = &b->attr;
2238
2239                 sysfs_attr_init(&a->attr);
2240                 a->attr.name    = b->attrname;
2241                 snprintf(b->attrname, ATTR_LEN, "bank%d", i);
2242
2243                 a->attr.mode    = 0644;
2244                 a->show         = show_bank;
2245                 a->store        = set_bank;
2246         }
2247 }
2248
2249 static __init int mcheck_init_device(void)
2250 {
2251         int err;
2252         int i = 0;
2253
2254         if (!mce_available(&boot_cpu_data))
2255                 return -EIO;
2256
2257         zalloc_cpumask_var(&mce_device_initialized, GFP_KERNEL);
2258
2259         mce_init_banks();
2260
2261         err = subsys_system_register(&mce_subsys, NULL);
2262         if (err)
2263                 return err;
2264
2265         for_each_online_cpu(i) {
2266                 err = mce_device_create(i);
2267                 if (err)
2268                         return err;
2269         }
2270
2271         register_syscore_ops(&mce_syscore_ops);
2272         register_hotcpu_notifier(&mce_cpu_notifier);
2273
2274         /* register character device /dev/mcelog */
2275         misc_register(&mce_chrdev_device);
2276
2277         return err;
2278 }
2279 device_initcall(mcheck_init_device);
2280
2281 /*
2282  * Old style boot options parsing. Only for compatibility.
2283  */
2284 static int __init mcheck_disable(char *str)
2285 {
2286         mce_disabled = 1;
2287         return 1;
2288 }
2289 __setup("nomce", mcheck_disable);
2290
2291 #ifdef CONFIG_DEBUG_FS
2292 struct dentry *mce_get_debugfs_dir(void)
2293 {
2294         static struct dentry *dmce;
2295
2296         if (!dmce)
2297                 dmce = debugfs_create_dir("mce", NULL);
2298
2299         return dmce;
2300 }
2301
2302 static void mce_reset(void)
2303 {
2304         cpu_missing = 0;
2305         atomic_set(&mce_fake_paniced, 0);
2306         atomic_set(&mce_executing, 0);
2307         atomic_set(&mce_callin, 0);
2308         atomic_set(&global_nwo, 0);
2309 }
2310
2311 static int fake_panic_get(void *data, u64 *val)
2312 {
2313         *val = fake_panic;
2314         return 0;
2315 }
2316
2317 static int fake_panic_set(void *data, u64 val)
2318 {
2319         mce_reset();
2320         fake_panic = val;
2321         return 0;
2322 }
2323
2324 DEFINE_SIMPLE_ATTRIBUTE(fake_panic_fops, fake_panic_get,
2325                         fake_panic_set, "%llu\n");
2326
2327 static int __init mcheck_debugfs_init(void)
2328 {
2329         struct dentry *dmce, *ffake_panic;
2330
2331         dmce = mce_get_debugfs_dir();
2332         if (!dmce)
2333                 return -ENOMEM;
2334         ffake_panic = debugfs_create_file("fake_panic", 0444, dmce, NULL,
2335                                           &fake_panic_fops);
2336         if (!ffake_panic)
2337                 return -ENOMEM;
2338
2339         return 0;
2340 }
2341 late_initcall(mcheck_debugfs_init);
2342 #endif