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

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