mce_64.c 24.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * Machine check handler.
 * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
4 5
 * Rest from unknown author(s).
 * 2004 Andi Kleen. Rewrote most of it.
L
Linus Torvalds 已提交
6 7 8 9 10 11
 */

#include <linux/init.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
A
Arnd Bergmann 已提交
12
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
13 14 15 16 17 18
#include <linux/string.h>
#include <linux/rcupdate.h>
#include <linux/kallsyms.h>
#include <linux/sysdev.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
19
#include <linux/capability.h>
20 21
#include <linux/cpu.h>
#include <linux/percpu.h>
22 23
#include <linux/poll.h>
#include <linux/thread_info.h>
24
#include <linux/ctype.h>
25
#include <linux/kmod.h>
26
#include <linux/kdebug.h>
27 28
#include <linux/kobject.h>
#include <linux/sysfs.h>
29
#include <asm/processor.h>
L
Linus Torvalds 已提交
30 31 32
#include <asm/msr.h>
#include <asm/mce.h>
#include <asm/uaccess.h>
33
#include <asm/smp.h>
34
#include <asm/idle.h>
L
Linus Torvalds 已提交
35 36

#define MISC_MCELOG_MINOR 227
37 38 39 40 41 42

/*
 * To support more than 128 would need to escape the predefined
 * Linux defined extended banks first.
 */
#define MAX_NR_BANKS (MCE_EXTENDED_BANK - 1)
L
Linus Torvalds 已提交
43

44 45
atomic_t mce_entry;

L
Linus Torvalds 已提交
46 47
static int mce_dont_init;

48 49 50 51 52 53 54
/*
 * Tolerant levels:
 *   0: always panic on uncorrected errors, log corrected errors
 *   1: panic or SIGBUS on uncorrected errors, log corrected errors
 *   2: SIGBUS or log uncorrected errors (if possible), log corrected errors
 *   3: never panic or SIGBUS, log all errors (for testing only)
 */
L
Linus Torvalds 已提交
55 56
static int tolerant = 1;
static int banks;
57
static u64 *bank;
58
static unsigned long notify_user;
59
static int rip_msr;
60
static int mce_bootlog = -1;
61 62 63 64
static atomic_t mce_events;

static char trigger[128];
static char *trigger_argv[2] = { trigger, NULL };
L
Linus Torvalds 已提交
65

66 67
static DECLARE_WAIT_QUEUE_HEAD(mce_wait);

68 69 70 71 72 73 74 75
/* Do initial initialization of a struct mce */
void mce_setup(struct mce *m)
{
	memset(m, 0, sizeof(struct mce));
	m->cpu = smp_processor_id();
	rdtscll(m->tsc);
}

L
Linus Torvalds 已提交
76 77 78 79 80 81
/*
 * Lockless MCE logging infrastructure.
 * This avoids deadlocks on printk locks without having to break locks. Also
 * separate MCEs from kernel messages to avoid bogus bug reports.
 */

82
static struct mce_log mcelog = {
L
Linus Torvalds 已提交
83 84
	MCE_LOG_SIGNATURE,
	MCE_LOG_LEN,
85
};
L
Linus Torvalds 已提交
86 87 88 89

void mce_log(struct mce *mce)
{
	unsigned next, entry;
90
	atomic_inc(&mce_events);
L
Linus Torvalds 已提交
91
	mce->finished = 0;
M
Mike Waychison 已提交
92
	wmb();
L
Linus Torvalds 已提交
93 94
	for (;;) {
		entry = rcu_dereference(mcelog.next);
95 96 97 98
		for (;;) {
			/* When the buffer fills up discard new entries. Assume
			   that the earlier errors are the more interesting. */
			if (entry >= MCE_LOG_LEN) {
99
				set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags);
100 101 102 103 104 105 106
				return;
			}
			/* Old left over entry. Skip. */
			if (mcelog.entry[entry].finished) {
				entry++;
				continue;
			}
M
Mike Waychison 已提交
107
			break;
L
Linus Torvalds 已提交
108 109 110 111 112 113 114
		}
		smp_rmb();
		next = entry + 1;
		if (cmpxchg(&mcelog.next, entry, next) == entry)
			break;
	}
	memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
M
Mike Waychison 已提交
115
	wmb();
L
Linus Torvalds 已提交
116
	mcelog.entry[entry].finished = 1;
M
Mike Waychison 已提交
117
	wmb();
L
Linus Torvalds 已提交
118

119
	set_bit(0, &notify_user);
L
Linus Torvalds 已提交
120 121 122 123 124
}

static void print_mce(struct mce *m)
{
	printk(KERN_EMERG "\n"
125
	       KERN_EMERG "HARDWARE ERROR\n"
L
Linus Torvalds 已提交
126 127 128
	       KERN_EMERG
	       "CPU %d: Machine Check Exception: %16Lx Bank %d: %016Lx\n",
	       m->cpu, m->mcgstatus, m->bank, m->status);
129
	if (m->ip) {
130
		printk(KERN_EMERG "RIP%s %02x:<%016Lx> ",
L
Linus Torvalds 已提交
131
		       !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
132
		       m->cs, m->ip);
L
Linus Torvalds 已提交
133
		if (m->cs == __KERNEL_CS)
134
			print_symbol("{%s}", m->ip);
L
Linus Torvalds 已提交
135 136
		printk("\n");
	}
137
	printk(KERN_EMERG "TSC %Lx ", m->tsc);
L
Linus Torvalds 已提交
138 139 140
	if (m->addr)
		printk("ADDR %Lx ", m->addr);
	if (m->misc)
141
		printk("MISC %Lx ", m->misc);
L
Linus Torvalds 已提交
142
	printk("\n");
143
	printk(KERN_EMERG "This is not a software problem!\n");
144 145
	printk(KERN_EMERG "Run through mcelog --ascii to decode "
	       "and contact your hardware vendor\n");
L
Linus Torvalds 已提交
146 147 148
}

static void mce_panic(char *msg, struct mce *backup, unsigned long start)
149
{
L
Linus Torvalds 已提交
150
	int i;
151

L
Linus Torvalds 已提交
152 153 154
	oops_begin();
	for (i = 0; i < MCE_LOG_LEN; i++) {
		unsigned long tsc = mcelog.entry[i].tsc;
155

L
Linus Torvalds 已提交
156 157
		if (time_before(tsc, start))
			continue;
158
		print_mce(&mcelog.entry[i]);
L
Linus Torvalds 已提交
159 160 161 162 163
		if (backup && mcelog.entry[i].tsc == backup->tsc)
			backup = NULL;
	}
	if (backup)
		print_mce(backup);
164
	panic(msg);
165
}
L
Linus Torvalds 已提交
166 167 168

static int mce_available(struct cpuinfo_x86 *c)
{
169 170
	if (mce_dont_init)
		return 0;
171
	return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA);
L
Linus Torvalds 已提交
172 173
}

174 175 176
static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
{
	if (regs && (m->mcgstatus & MCG_STATUS_RIPV)) {
177
		m->ip = regs->ip;
178 179
		m->cs = regs->cs;
	} else {
180
		m->ip = 0;
181 182 183 184 185
		m->cs = 0;
	}
	if (rip_msr) {
		/* Assume the RIP in the MSR is exact. Is this true? */
		m->mcgstatus |= MCG_STATUS_EIPV;
186
		rdmsrl(rip_msr, m->ip);
187 188 189 190
		m->cs = 0;
	}
}

191
/*
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199
 * The actual machine check handler
 */
void do_machine_check(struct pt_regs * regs, long error_code)
{
	struct mce m, panicm;
	u64 mcestart = 0;
	int i;
	int panicm_found = 0;
200 201 202 203 204 205 206 207 208 209
	/*
	 * If no_way_out gets set, there is no safe way to recover from this
	 * MCE.  If tolerant is cranked up, we'll try anyway.
	 */
	int no_way_out = 0;
	/*
	 * If kill_it gets set, there might be a way to recover from this
	 * error.
	 */
	int kill_it = 0;
L
Linus Torvalds 已提交
210

211 212
	atomic_inc(&mce_entry);

213 214 215 216
	if ((regs
	     && notify_die(DIE_NMI, "machine check", regs, error_code,
			   18, SIGKILL) == NOTIFY_STOP)
	    || !banks)
217
		goto out2;
L
Linus Torvalds 已提交
218

219 220
	mce_setup(&m);

L
Linus Torvalds 已提交
221
	rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus);
222
	/* if the restart IP is not valid, we're done for */
L
Linus Torvalds 已提交
223
	if (!(m.mcgstatus & MCG_STATUS_RIPV))
224
		no_way_out = 1;
225

L
Linus Torvalds 已提交
226 227 228 229
	rdtscll(mcestart);
	barrier();

	for (i = 0; i < banks; i++) {
230
		if (!bank[i])
L
Linus Torvalds 已提交
231
			continue;
232 233

		m.misc = 0;
L
Linus Torvalds 已提交
234 235 236 237 238 239 240 241
		m.addr = 0;
		m.bank = i;

		rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status);
		if ((m.status & MCI_STATUS_VAL) == 0)
			continue;

		if (m.status & MCI_STATUS_EN) {
242 243 244 245 246 247 248 249 250 251 252 253
			/* if PCC was set, there's no way out */
			no_way_out |= !!(m.status & MCI_STATUS_PCC);
			/*
			 * If this error was uncorrectable and there was
			 * an overflow, we're in trouble.  If no overflow,
			 * we might get away with just killing a task.
			 */
			if (m.status & MCI_STATUS_UC) {
				if (tolerant < 1 || m.status & MCI_STATUS_OVER)
					no_way_out = 1;
				kill_it = 1;
			}
L
Linus Torvalds 已提交
254 255 256 257 258 259 260
		}

		if (m.status & MCI_STATUS_MISCV)
			rdmsrl(MSR_IA32_MC0_MISC + i*4, m.misc);
		if (m.status & MCI_STATUS_ADDRV)
			rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr);

261
		mce_get_rip(&m, regs);
262 263
		if (error_code < 0)
			m.tsc = 0;
264 265
		if (error_code != -2)
			mce_log(&m);
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274

		/* Did this bank cause the exception? */
		/* Assume that the bank with uncorrectable errors did it,
		   and that there is only a single one. */
		if ((m.status & MCI_STATUS_UC) && (m.status & MCI_STATUS_EN)) {
			panicm = m;
			panicm_found = 1;
		}

275
		add_taint(TAINT_MACHINE_CHECK);
L
Linus Torvalds 已提交
276 277 278
	}

	/* Never do anything final in the polling timer */
279
	if (!regs)
L
Linus Torvalds 已提交
280 281 282 283 284 285
		goto out;

	/* If we didn't find an uncorrectable error, pick
	   the last one (shouldn't happen, just being safe). */
	if (!panicm_found)
		panicm = m;
286 287 288 289 290 291

	/*
	 * If we have decided that we just CAN'T continue, and the user
	 *  has not set tolerant to an insane level, give up and die.
	 */
	if (no_way_out && tolerant < 3)
L
Linus Torvalds 已提交
292
		mce_panic("Machine check", &panicm, mcestart);
293 294 295 296 297 298 299 300

	/*
	 * If the error seems to be unrecoverable, something should be
	 * done.  Try to kill as little as possible.  If we can kill just
	 * one task, do that.  If the user has set the tolerance very
	 * high, don't try to do anything at all.
	 */
	if (kill_it && tolerant < 3) {
L
Linus Torvalds 已提交
301 302
		int user_space = 0;

303 304 305 306 307
		/*
		 * If the EIPV bit is set, it means the saved IP is the
		 * instruction which caused the MCE.
		 */
		if (m.mcgstatus & MCG_STATUS_EIPV)
308
			user_space = panicm.ip && (panicm.cs & 3);
309 310 311 312 313

		/*
		 * If we know that the error was in user space, send a
		 * SIGBUS.  Otherwise, panic if tolerance is low.
		 *
314
		 * force_sig() takes an awful lot of locks and has a slight
315 316 317
		 * risk of deadlocking.
		 */
		if (user_space) {
318
			force_sig(SIGBUS, current);
319 320 321 322
		} else if (panic_on_oops || tolerant < 2) {
			mce_panic("Uncorrected machine check",
				&panicm, mcestart);
		}
L
Linus Torvalds 已提交
323 324
	}

325 326 327
	/* notify userspace ASAP */
	set_thread_flag(TIF_MCE_NOTIFY);

L
Linus Torvalds 已提交
328
 out:
329 330 331
	/* the last thing we do is clear state */
	for (i = 0; i < banks; i++)
		wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
L
Linus Torvalds 已提交
332
	wrmsrl(MSR_IA32_MCG_STATUS, 0);
333 334
 out2:
	atomic_dec(&mce_entry);
L
Linus Torvalds 已提交
335 336
}

337 338 339
#ifdef CONFIG_X86_MCE_INTEL
/***
 * mce_log_therm_throt_event - Logs the thermal throttling event to mcelog
S
Simon Arlott 已提交
340
 * @cpu: The CPU on which the event occurred.
341 342 343 344 345 346 347 348 349 350
 * @status: Event status information
 *
 * This function should be called by the thermal interrupt after the
 * event has been processed and the decision was made to log the event
 * further.
 *
 * The status parameter will be saved to the 'status' field of 'struct mce'
 * and historically has been the register value of the
 * MSR_IA32_THERMAL_STATUS (Intel) msr.
 */
351
void mce_log_therm_throt_event(__u64 status)
352 353 354
{
	struct mce m;

355
	mce_setup(&m);
356 357 358 359 360 361
	m.bank = MCE_THERMAL_BANK;
	m.status = status;
	mce_log(&m);
}
#endif /* CONFIG_X86_MCE_INTEL */

L
Linus Torvalds 已提交
362
/*
363 364 365
 * Periodic polling timer for "silent" machine check errors.  If the
 * poller finds an MCE, poll 2x faster.  When the poller finds no more
 * errors, poll 2x slower (up to check_interval seconds).
L
Linus Torvalds 已提交
366 367 368
 */

static int check_interval = 5 * 60; /* 5 minutes */
369
static int next_interval; /* in jiffies */
370 371
static void mcheck_timer(unsigned long);
static DEFINE_PER_CPU(struct timer_list, mce_timer);
L
Linus Torvalds 已提交
372

373
static void mcheck_timer(unsigned long data)
L
Linus Torvalds 已提交
374
{
375 376 377 378
	struct timer_list *t = &per_cpu(mce_timer, data);

	WARN_ON(smp_processor_id() != data);

L
Linus Torvalds 已提交
379 380 381 382
	if (mce_available(&current_cpu_data))
		do_machine_check(NULL, 0);

	/*
383 384
	 * Alert userspace if needed.  If we logged an MCE, reduce the
	 * polling interval, otherwise increase the polling interval.
L
Linus Torvalds 已提交
385
	 */
386 387 388
	if (mce_notify_user()) {
		next_interval = max(next_interval/2, HZ/100);
	} else {
389
		next_interval = min(next_interval * 2,
390
				(int)round_jiffies_relative(check_interval*HZ));
391 392
	}

393 394
	t->expires = jiffies + next_interval;
	add_timer(t);
395 396
}

397 398 399 400 401 402 403
static void mce_do_trigger(struct work_struct *work)
{
	call_usermodehelper(trigger, trigger_argv, NULL, UMH_NO_WAIT);
}

static DECLARE_WORK(mce_trigger_work, mce_do_trigger);

404
/*
405 406 407
 * Notify the user(s) about new machine check events.
 * Can be called from interrupt context, but not from machine check/NMI
 * context.
408 409 410 411 412
 */
int mce_notify_user(void)
{
	clear_thread_flag(TIF_MCE_NOTIFY);
	if (test_and_clear_bit(0, &notify_user)) {
413 414 415
		static unsigned long last_print;
		unsigned long now = jiffies;

416
		wake_up_interruptible(&mce_wait);
417 418 419 420 421 422 423 424

		/*
		 * There is no risk of missing notifications because
		 * work_pending is always cleared before the function is
		 * executed.
		 */
		if (trigger[0] && !work_pending(&mce_trigger_work))
			schedule_work(&mce_trigger_work);
425

426 427 428 429
		if (time_after_eq(now, last_print + (check_interval*HZ))) {
			last_print = now;
			printk(KERN_INFO "Machine check events logged\n");
		}
430 431

		return 1;
L
Linus Torvalds 已提交
432
	}
433 434
	return 0;
}
435

436 437 438 439 440 441 442 443 444
/* see if the idle task needs to notify userspace */
static int
mce_idle_callback(struct notifier_block *nfb, unsigned long action, void *junk)
{
	/* IDLE_END should be safe - interrupts are back on */
	if (action == IDLE_END && test_thread_flag(TIF_MCE_NOTIFY))
		mce_notify_user();

	return NOTIFY_OK;
L
Linus Torvalds 已提交
445 446
}

447 448 449
static struct notifier_block mce_idle_notifier = {
	.notifier_call = mce_idle_callback,
};
L
Linus Torvalds 已提交
450 451

static __init int periodic_mcheck_init(void)
452
{
453 454
       idle_notifier_register(&mce_idle_notifier);
       return 0;
455
}
L
Linus Torvalds 已提交
456 457
__initcall(periodic_mcheck_init);

458
/*
L
Linus Torvalds 已提交
459 460
 * Initialize Machine Checks for a CPU.
 */
461
static int mce_cap_init(void)
L
Linus Torvalds 已提交
462 463
{
	u64 cap;
464
	unsigned b;
L
Linus Torvalds 已提交
465 466

	rdmsrl(MSR_IA32_MCG_CAP, cap);
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	b = cap & 0xff;
	if (b > MAX_NR_BANKS) {
		printk(KERN_WARNING
		       "MCE: Using only %u machine check banks out of %u\n",
			MAX_NR_BANKS, b);
		b = MAX_NR_BANKS;
	}

	/* Don't support asymmetric configurations today */
	WARN_ON(banks != 0 && b != banks);
	banks = b;
	if (!bank) {
		bank = kmalloc(banks * sizeof(u64), GFP_KERNEL);
		if (!bank)
			return -ENOMEM;
		memset(bank, 0xff, banks * sizeof(u64));
L
Linus Torvalds 已提交
483
	}
484

485 486 487
	/* Use accurate RIP reporting if available. */
	if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9)
		rip_msr = MSR_IA32_MCG_EIP;
L
Linus Torvalds 已提交
488

489 490 491 492 493 494 495 496
	return 0;
}

static void mce_init(void *dummy)
{
	u64 cap;
	int i;

L
Linus Torvalds 已提交
497 498
	/* Log the machine checks left over from the previous reset.
	   This also clears all registers */
499
	do_machine_check(NULL, mce_bootlog ? -1 : -2);
L
Linus Torvalds 已提交
500 501 502

	set_in_cr4(X86_CR4_MCE);

503
	rdmsrl(MSR_IA32_MCG_CAP, cap);
L
Linus Torvalds 已提交
504 505 506 507
	if (cap & MCG_CTL_P)
		wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff);

	for (i = 0; i < banks; i++) {
508
		wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]);
L
Linus Torvalds 已提交
509
		wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
510
	}
L
Linus Torvalds 已提交
511 512 513
}

/* Add per CPU specific workarounds here */
514
static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
515
{
L
Linus Torvalds 已提交
516
	/* This should be disabled by the BIOS, but isn't always */
517
	if (c->x86_vendor == X86_VENDOR_AMD) {
518
		if (c->x86 == 15 && banks > 4)
519 520
			/* disable GART TBL walk error reporting, which trips off
			   incorrectly with the IOMMU & 3ware & Cerberus. */
521
			clear_bit(10, (unsigned long *)&bank[4]);
522 523 524 525
		if(c->x86 <= 17 && mce_bootlog < 0)
			/* Lots of broken BIOS around that don't clear them
			   by default and leave crap in there. Don't log. */
			mce_bootlog = 0;
L
Linus Torvalds 已提交
526
	}
527

528
}
L
Linus Torvalds 已提交
529

530
static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
531 532 533 534 535
{
	switch (c->x86_vendor) {
	case X86_VENDOR_INTEL:
		mce_intel_feature_init(c);
		break;
536 537 538
	case X86_VENDOR_AMD:
		mce_amd_feature_init(c);
		break;
L
Linus Torvalds 已提交
539 540 541 542 543
	default:
		break;
	}
}

544 545 546 547 548 549 550 551 552 553 554 555 556 557
static void mce_init_timer(void)
{
	struct timer_list *t = &__get_cpu_var(mce_timer);

	/* data race harmless because everyone sets to the same value */
	if (!next_interval)
		next_interval = check_interval * HZ;
	if (!next_interval)
		return;
	setup_timer(t, mcheck_timer, smp_processor_id());
	t->expires = round_jiffies_relative(jiffies + next_interval);
	add_timer(t);
}

558
/*
L
Linus Torvalds 已提交
559
 * Called for each booted CPU to set up machine checks.
560
 * Must be called with preempt off.
L
Linus Torvalds 已提交
561
 */
562
void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
563
{
564
	if (!mce_available(c))
L
Linus Torvalds 已提交
565 566
		return;

567 568 569 570 571 572
	if (mce_cap_init() < 0) {
		mce_dont_init = 1;
		return;
	}
	mce_cpu_quirks(c);

L
Linus Torvalds 已提交
573 574
	mce_init(NULL);
	mce_cpu_features(c);
575
	mce_init_timer();
L
Linus Torvalds 已提交
576 577 578 579 580 581
}

/*
 * Character device to read and clear the MCE log.
 */

T
Tim Hockin 已提交
582 583 584 585 586 587
static DEFINE_SPINLOCK(mce_state_lock);
static int open_count;	/* #times opened */
static int open_exclu;	/* already open exclusive? */

static int mce_open(struct inode *inode, struct file *file)
{
A
Arnd Bergmann 已提交
588
	lock_kernel();
T
Tim Hockin 已提交
589 590 591 592
	spin_lock(&mce_state_lock);

	if (open_exclu || (open_count && (file->f_flags & O_EXCL))) {
		spin_unlock(&mce_state_lock);
A
Arnd Bergmann 已提交
593
		unlock_kernel();
T
Tim Hockin 已提交
594 595 596 597 598 599 600 601
		return -EBUSY;
	}

	if (file->f_flags & O_EXCL)
		open_exclu = 1;
	open_count++;

	spin_unlock(&mce_state_lock);
A
Arnd Bergmann 已提交
602
	unlock_kernel();
T
Tim Hockin 已提交
603

604
	return nonseekable_open(inode, file);
T
Tim Hockin 已提交
605 606 607 608 609 610 611 612 613 614 615 616 617 618
}

static int mce_release(struct inode *inode, struct file *file)
{
	spin_lock(&mce_state_lock);

	open_count--;
	open_exclu = 0;

	spin_unlock(&mce_state_lock);

	return 0;
}

619 620
static void collect_tscs(void *data)
{
L
Linus Torvalds 已提交
621
	unsigned long *cpu_tsc = (unsigned long *)data;
622

L
Linus Torvalds 已提交
623
	rdtscll(cpu_tsc[smp_processor_id()]);
624
}
L
Linus Torvalds 已提交
625

626 627
static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
			loff_t *off)
L
Linus Torvalds 已提交
628
{
629
	unsigned long *cpu_tsc;
630
	static DEFINE_MUTEX(mce_read_mutex);
631
	unsigned prev, next;
L
Linus Torvalds 已提交
632 633 634
	char __user *buf = ubuf;
	int i, err;

635
	cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL);
636 637 638
	if (!cpu_tsc)
		return -ENOMEM;

639
	mutex_lock(&mce_read_mutex);
L
Linus Torvalds 已提交
640 641 642
	next = rcu_dereference(mcelog.next);

	/* Only supports full reads right now */
643
	if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) {
644
		mutex_unlock(&mce_read_mutex);
645
		kfree(cpu_tsc);
L
Linus Torvalds 已提交
646 647 648 649
		return -EINVAL;
	}

	err = 0;
650 651 652 653 654 655 656 657 658 659 660 661
	prev = 0;
	do {
		for (i = prev; i < next; i++) {
			unsigned long start = jiffies;

			while (!mcelog.entry[i].finished) {
				if (time_after_eq(jiffies, start + 2)) {
					memset(mcelog.entry + i, 0,
					       sizeof(struct mce));
					goto timeout;
				}
				cpu_relax();
662
			}
663 664 665 666 667 668
			smp_rmb();
			err |= copy_to_user(buf, mcelog.entry + i,
					    sizeof(struct mce));
			buf += sizeof(struct mce);
timeout:
			;
669
		}
L
Linus Torvalds 已提交
670

671 672 673 674 675
		memset(mcelog.entry + prev, 0,
		       (next - prev) * sizeof(struct mce));
		prev = next;
		next = cmpxchg(&mcelog.next, prev, 0);
	} while (next != prev);
L
Linus Torvalds 已提交
676

677
	synchronize_sched();
L
Linus Torvalds 已提交
678

679 680 681 682
	/*
	 * Collect entries that were still getting written before the
	 * synchronize.
	 */
683
	on_each_cpu(collect_tscs, cpu_tsc, 1);
684 685 686 687 688
	for (i = next; i < MCE_LOG_LEN; i++) {
		if (mcelog.entry[i].finished &&
		    mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {
			err |= copy_to_user(buf, mcelog.entry+i,
					    sizeof(struct mce));
L
Linus Torvalds 已提交
689 690 691 692
			smp_rmb();
			buf += sizeof(struct mce);
			memset(&mcelog.entry[i], 0, sizeof(struct mce));
		}
693
	}
694
	mutex_unlock(&mce_read_mutex);
695
	kfree(cpu_tsc);
696
	return err ? -EFAULT : buf - ubuf;
L
Linus Torvalds 已提交
697 698
}

699 700 701 702 703 704 705 706
static unsigned int mce_poll(struct file *file, poll_table *wait)
{
	poll_wait(file, &mce_wait, wait);
	if (rcu_dereference(mcelog.next))
		return POLLIN | POLLRDNORM;
	return 0;
}

707
static long mce_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
708 709
{
	int __user *p = (int __user *)arg;
710

L
Linus Torvalds 已提交
711
	if (!capable(CAP_SYS_ADMIN))
712
		return -EPERM;
L
Linus Torvalds 已提交
713
	switch (cmd) {
714
	case MCE_GET_RECORD_LEN:
L
Linus Torvalds 已提交
715 716
		return put_user(sizeof(struct mce), p);
	case MCE_GET_LOG_LEN:
717
		return put_user(MCE_LOG_LEN, p);
L
Linus Torvalds 已提交
718 719
	case MCE_GETCLEAR_FLAGS: {
		unsigned flags;
720 721

		do {
L
Linus Torvalds 已提交
722
			flags = mcelog.flags;
723 724
		} while (cmpxchg(&mcelog.flags, flags, 0) != flags);
		return put_user(flags, p);
L
Linus Torvalds 已提交
725 726
	}
	default:
727 728
		return -ENOTTY;
	}
L
Linus Torvalds 已提交
729 730
}

731
static const struct file_operations mce_chrdev_ops = {
T
Tim Hockin 已提交
732 733
	.open = mce_open,
	.release = mce_release,
L
Linus Torvalds 已提交
734
	.read = mce_read,
735
	.poll = mce_poll,
736
	.unlocked_ioctl = mce_ioctl,
L
Linus Torvalds 已提交
737 738 739 740 741 742 743 744
};

static struct miscdevice mce_log_device = {
	MISC_MCELOG_MINOR,
	"mcelog",
	&mce_chrdev_ops,
};

745 746
/*
 * Old style boot options parsing. Only for compatibility.
L
Linus Torvalds 已提交
747 748 749 750
 */
static int __init mcheck_disable(char *str)
{
	mce_dont_init = 1;
751
	return 1;
L
Linus Torvalds 已提交
752 753
}

754
/* mce=off disables machine check.
755
   mce=TOLERANCELEVEL (number, see above)
756 757
   mce=bootlog Log MCEs from before booting. Disabled by default on AMD.
   mce=nobootlog Don't log MCEs from before booting. */
L
Linus Torvalds 已提交
758 759 760 761
static int __init mcheck_enable(char *str)
{
	if (!strcmp(str, "off"))
		mce_dont_init = 1;
762 763
	else if (!strcmp(str, "bootlog") || !strcmp(str,"nobootlog"))
		mce_bootlog = str[0] == 'b';
764 765
	else if (isdigit(str[0]))
		get_option(&str, &tolerant);
L
Linus Torvalds 已提交
766
	else
767
		printk("mce= argument %s ignored. Please use /sys", str);
768
	return 1;
L
Linus Torvalds 已提交
769 770 771
}

__setup("nomce", mcheck_disable);
772
__setup("mce=", mcheck_enable);
L
Linus Torvalds 已提交
773

774
/*
L
Linus Torvalds 已提交
775
 * Sysfs support
776
 */
L
Linus Torvalds 已提交
777

778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
/*
 * Disable machine checks on suspend and shutdown. We can't really handle
 * them later.
 */
static int mce_disable(void)
{
	int i;

	for (i = 0; i < banks; i++)
		wrmsrl(MSR_IA32_MC0_CTL + i*4, 0);
	return 0;
}

static int mce_suspend(struct sys_device *dev, pm_message_t state)
{
	return mce_disable();
}

static int mce_shutdown(struct sys_device *dev)
{
	return mce_disable();
}

801 802 803
/* On resume clear all MCE state. Don't want to see leftovers from the BIOS.
   Only one CPU is active at this time, the others get readded later using
   CPU hotplug. */
L
Linus Torvalds 已提交
804 805
static int mce_resume(struct sys_device *dev)
{
806
	mce_init(NULL);
807
	mce_cpu_features(&current_cpu_data);
L
Linus Torvalds 已提交
808 809 810
	return 0;
}

811 812 813 814 815 816 817 818
static void mce_cpu_restart(void *data)
{
	del_timer_sync(&__get_cpu_var(mce_timer));
	if (mce_available(&current_cpu_data))
		mce_init(NULL);
	mce_init_timer();
}

L
Linus Torvalds 已提交
819
/* Reinit MCEs after user configuration changes */
820 821
static void mce_restart(void)
{
822
	next_interval = check_interval * HZ;
823
	on_each_cpu(mce_cpu_restart, NULL, 1);
L
Linus Torvalds 已提交
824 825 826
}

static struct sysdev_class mce_sysclass = {
827 828
	.suspend = mce_suspend,
	.shutdown = mce_shutdown,
L
Linus Torvalds 已提交
829
	.resume = mce_resume,
830
	.name = "machinecheck",
L
Linus Torvalds 已提交
831 832
};

833
DEFINE_PER_CPU(struct sys_device, device_mce);
834
void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu) __cpuinitdata;
L
Linus Torvalds 已提交
835 836 837

/* Why are there no generic functions for this? */
#define ACCESSOR(name, var, start) \
838 839 840
	static ssize_t show_ ## name(struct sys_device *s,		\
				     struct sysdev_attribute *attr,	\
				     char *buf) {			\
841 842
		return sprintf(buf, "%lx\n", (unsigned long)var);	\
	}								\
843 844 845
	static ssize_t set_ ## name(struct sys_device *s,		\
				    struct sysdev_attribute *attr,	\
				    const char *buf, size_t siz) {	\
846 847 848 849 850 851 852
		char *end;						\
		unsigned long new = simple_strtoul(buf, &end, 0);	\
		if (end == buf) return -EINVAL;				\
		var = new;						\
		start;							\
		return end-buf;						\
	}								\
L
Linus Torvalds 已提交
853 854
	static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name);

855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
static struct sysdev_attribute *bank_attrs;

static ssize_t show_bank(struct sys_device *s, struct sysdev_attribute *attr,
			 char *buf)
{
	u64 b = bank[attr - bank_attrs];
	return sprintf(buf, "%Lx\n", b);
}

static ssize_t set_bank(struct sys_device *s, struct sysdev_attribute *attr,
			const char *buf, size_t siz)
{
	char *end;
	u64 new = simple_strtoull(buf, &end, 0);
	if (end == buf)
		return -EINVAL;
	bank[attr - bank_attrs] = new;
	mce_restart();
	return end-buf;
}
875

876 877
static ssize_t show_trigger(struct sys_device *s, struct sysdev_attribute *attr,
				char *buf)
878 879 880 881 882 883
{
	strcpy(buf, trigger);
	strcat(buf, "\n");
	return strlen(trigger) + 1;
}

884 885
static ssize_t set_trigger(struct sys_device *s, struct sysdev_attribute *attr,
				const char *buf,size_t siz)
886 887 888 889 890 891 892 893 894 895 896 897
{
	char *p;
	int len;
	strncpy(trigger, buf, sizeof(trigger));
	trigger[sizeof(trigger)-1] = 0;
	len = strlen(trigger);
	p = strchr(trigger, '\n');
	if (*p) *p = 0;
	return len;
}

static SYSDEV_ATTR(trigger, 0644, show_trigger, set_trigger);
898
static SYSDEV_INT_ATTR(tolerant, 0644, tolerant);
L
Linus Torvalds 已提交
899
ACCESSOR(check_interval,check_interval,mce_restart())
900
static struct sysdev_attribute *mce_attributes[] = {
901
	&attr_tolerant.attr, &attr_check_interval, &attr_trigger,
902 903
	NULL
};
L
Linus Torvalds 已提交
904

905 906
static cpumask_t mce_device_initialized = CPU_MASK_NONE;

907 908
/* Per cpu sysdev init.  All of the cpus still share the same ctl bank */
static __cpuinit int mce_create_device(unsigned int cpu)
L
Linus Torvalds 已提交
909 910
{
	int err;
911
	int i;
912

A
Andreas Herrmann 已提交
913
	if (!mce_available(&boot_cpu_data))
914 915
		return -EIO;

916
	memset(&per_cpu(device_mce, cpu).kobj, 0, sizeof(struct kobject));
917 918 919 920
	per_cpu(device_mce,cpu).id = cpu;
	per_cpu(device_mce,cpu).cls = &mce_sysclass;

	err = sysdev_register(&per_cpu(device_mce,cpu));
921 922 923 924 925 926 927 928 929
	if (err)
		return err;

	for (i = 0; mce_attributes[i]; i++) {
		err = sysdev_create_file(&per_cpu(device_mce,cpu),
					 mce_attributes[i]);
		if (err)
			goto error;
	}
930 931 932 933 934 935
	for (i = 0; i < banks; i++) {
		err = sysdev_create_file(&per_cpu(device_mce, cpu),
					&bank_attrs[i]);
		if (err)
			goto error2;
	}
936
	cpu_set(cpu, mce_device_initialized);
937

938
	return 0;
939 940 941 942 943
error2:
	while (--i >= 0) {
		sysdev_remove_file(&per_cpu(device_mce, cpu),
					&bank_attrs[i]);
	}
944
error:
945
	while (--i >= 0) {
946 947
		sysdev_remove_file(&per_cpu(device_mce,cpu),
				   mce_attributes[i]);
948
	}
949 950
	sysdev_unregister(&per_cpu(device_mce,cpu));

951 952 953
	return err;
}

954
static __cpuinit void mce_remove_device(unsigned int cpu)
955
{
956 957
	int i;

958 959 960
	if (!cpu_isset(cpu, mce_device_initialized))
		return;

961
	for (i = 0; mce_attributes[i]; i++)
962
		sysdev_remove_file(&per_cpu(device_mce,cpu),
963
			mce_attributes[i]);
964 965 966
	for (i = 0; i < banks; i++)
		sysdev_remove_file(&per_cpu(device_mce, cpu),
			&bank_attrs[i]);
967
	sysdev_unregister(&per_cpu(device_mce,cpu));
968
	cpu_clear(cpu, mce_device_initialized);
969 970
}

971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
/* Make sure there are no machine checks on offlined CPUs. */
static void __cpuexit mce_disable_cpu(void *h)
{
	int i;

	if (!mce_available(&current_cpu_data))
		return;
	for (i = 0; i < banks; i++)
		wrmsrl(MSR_IA32_MC0_CTL + i*4, 0);
}

static void __cpuexit mce_reenable_cpu(void *h)
{
	int i;

	if (!mce_available(&current_cpu_data))
		return;
	for (i = 0; i < banks; i++)
		wrmsrl(MSR_IA32_MC0_CTL + i*4, bank[i]);
}

992
/* Get notified when a cpu comes on/off. Be hotplug friendly. */
993 994
static int __cpuinit mce_cpu_callback(struct notifier_block *nfb,
				      unsigned long action, void *hcpu)
995 996
{
	unsigned int cpu = (unsigned long)hcpu;
997
	struct timer_list *t = &per_cpu(mce_timer, cpu);
998 999

	switch (action) {
1000 1001 1002
	case CPU_ONLINE:
	case CPU_ONLINE_FROZEN:
		mce_create_device(cpu);
1003 1004
		if (threshold_cpu_callback)
			threshold_cpu_callback(action, cpu);
1005 1006
		break;
	case CPU_DEAD:
1007
	case CPU_DEAD_FROZEN:
1008 1009
		if (threshold_cpu_callback)
			threshold_cpu_callback(action, cpu);
1010 1011
		mce_remove_device(cpu);
		break;
1012 1013 1014
	case CPU_DOWN_PREPARE:
	case CPU_DOWN_PREPARE_FROZEN:
		del_timer_sync(t);
1015
		smp_call_function_single(cpu, mce_disable_cpu, NULL, 1);
1016 1017 1018 1019 1020
		break;
	case CPU_DOWN_FAILED:
	case CPU_DOWN_FAILED_FROZEN:
		t->expires = round_jiffies_relative(jiffies + next_interval);
		add_timer_on(t, cpu);
1021
		smp_call_function_single(cpu, mce_reenable_cpu, NULL, 1);
1022
		break;
1023
	}
1024
	return NOTIFY_OK;
1025 1026
}

1027
static struct notifier_block mce_cpu_notifier __cpuinitdata = {
1028 1029 1030
	.notifier_call = mce_cpu_callback,
};

1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
static __init int mce_init_banks(void)
{
	int i;

	bank_attrs = kzalloc(sizeof(struct sysdev_attribute) * banks,
				GFP_KERNEL);
	if (!bank_attrs)
		return -ENOMEM;

	for (i = 0; i < banks; i++) {
		struct sysdev_attribute *a = &bank_attrs[i];
		a->attr.name = kasprintf(GFP_KERNEL, "bank%d", i);
		if (!a->attr.name)
			goto nomem;
		a->attr.mode = 0644;
		a->show = show_bank;
		a->store = set_bank;
	}
	return 0;

nomem:
	while (--i >= 0)
		kfree(bank_attrs[i].attr.name);
	kfree(bank_attrs);
	bank_attrs = NULL;
	return -ENOMEM;
}

1059 1060 1061 1062 1063
static __init int mce_init_device(void)
{
	int err;
	int i = 0;

L
Linus Torvalds 已提交
1064 1065
	if (!mce_available(&boot_cpu_data))
		return -EIO;
1066 1067 1068 1069 1070

	err = mce_init_banks();
	if (err)
		return err;

L
Linus Torvalds 已提交
1071
	err = sysdev_class_register(&mce_sysclass);
1072 1073
	if (err)
		return err;
1074 1075

	for_each_online_cpu(i) {
1076 1077 1078
		err = mce_create_device(i);
		if (err)
			return err;
1079 1080
	}

1081
	register_hotcpu_notifier(&mce_cpu_notifier);
L
Linus Torvalds 已提交
1082 1083 1084
	misc_register(&mce_log_device);
	return err;
}
1085

L
Linus Torvalds 已提交
1086
device_initcall(mce_init_device);