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