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