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