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