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