mce_64.c 21.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
14
15
16
17
 */

#include <linux/init.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/rcupdate.h>
#include <linux/kallsyms.h>
#include <linux/sysdev.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
18
#include <linux/capability.h>
19
20
#include <linux/cpu.h>
#include <linux/percpu.h>
21
22
#include <linux/poll.h>
#include <linux/thread_info.h>
23
#include <linux/ctype.h>
24
#include <linux/kmod.h>
25
#include <linux/kdebug.h>
26
#include <asm/processor.h>
Linus Torvalds's avatar
Linus Torvalds committed
27
28
29
#include <asm/msr.h>
#include <asm/mce.h>
#include <asm/uaccess.h>
30
#include <asm/smp.h>
31
#include <asm/idle.h>
Linus Torvalds's avatar
Linus Torvalds committed
32
33

#define MISC_MCELOG_MINOR 227
34
#define NR_BANKS 6
Linus Torvalds's avatar
Linus Torvalds committed
35

36
37
atomic_t mce_entry;

Linus Torvalds's avatar
Linus Torvalds committed
38
39
static int mce_dont_init;

40
41
42
43
44
45
46
/*
 * 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)
 */
Linus Torvalds's avatar
Linus Torvalds committed
47
48
49
static int tolerant = 1;
static int banks;
static unsigned long bank[NR_BANKS] = { [0 ... NR_BANKS-1] = ~0UL };
50
static unsigned long notify_user;
51
static int rip_msr;
52
static int mce_bootlog = 1;
53
54
55
56
static atomic_t mce_events;

static char trigger[128];
static char *trigger_argv[2] = { trigger, NULL };
Linus Torvalds's avatar
Linus Torvalds committed
57

58
59
static DECLARE_WAIT_QUEUE_HEAD(mce_wait);

Linus Torvalds's avatar
Linus Torvalds committed
60
61
62
63
64
65
/*
 * 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.
 */

66
static struct mce_log mcelog = {
Linus Torvalds's avatar
Linus Torvalds committed
67
68
	MCE_LOG_SIGNATURE,
	MCE_LOG_LEN,
69
};
Linus Torvalds's avatar
Linus Torvalds committed
70
71
72
73

void mce_log(struct mce *mce)
{
	unsigned next, entry;
74
	atomic_inc(&mce_events);
Linus Torvalds's avatar
Linus Torvalds committed
75
	mce->finished = 0;
Mike Waychison's avatar
Mike Waychison committed
76
	wmb();
Linus Torvalds's avatar
Linus Torvalds committed
77
78
	for (;;) {
		entry = rcu_dereference(mcelog.next);
79
80
81
82
		for (;;) {
			/* When the buffer fills up discard new entries. Assume
			   that the earlier errors are the more interesting. */
			if (entry >= MCE_LOG_LEN) {
83
				set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags);
84
85
86
87
88
89
90
				return;
			}
			/* Old left over entry. Skip. */
			if (mcelog.entry[entry].finished) {
				entry++;
				continue;
			}
Mike Waychison's avatar
Mike Waychison committed
91
			break;
Linus Torvalds's avatar
Linus Torvalds committed
92
93
94
95
96
97
98
		}
		smp_rmb();
		next = entry + 1;
		if (cmpxchg(&mcelog.next, entry, next) == entry)
			break;
	}
	memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
Mike Waychison's avatar
Mike Waychison committed
99
	wmb();
Linus Torvalds's avatar
Linus Torvalds committed
100
	mcelog.entry[entry].finished = 1;
Mike Waychison's avatar
Mike Waychison committed
101
	wmb();
Linus Torvalds's avatar
Linus Torvalds committed
102

103
	set_bit(0, &notify_user);
Linus Torvalds's avatar
Linus Torvalds committed
104
105
106
107
108
}

static void print_mce(struct mce *m)
{
	printk(KERN_EMERG "\n"
109
	       KERN_EMERG "HARDWARE ERROR\n"
Linus Torvalds's avatar
Linus Torvalds committed
110
111
112
	       KERN_EMERG
	       "CPU %d: Machine Check Exception: %16Lx Bank %d: %016Lx\n",
	       m->cpu, m->mcgstatus, m->bank, m->status);
113
	if (m->ip) {
114
		printk(KERN_EMERG "RIP%s %02x:<%016Lx> ",
Linus Torvalds's avatar
Linus Torvalds committed
115
		       !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
116
		       m->cs, m->ip);
Linus Torvalds's avatar
Linus Torvalds committed
117
		if (m->cs == __KERNEL_CS)
118
			print_symbol("{%s}", m->ip);
Linus Torvalds's avatar
Linus Torvalds committed
119
120
		printk("\n");
	}
121
	printk(KERN_EMERG "TSC %Lx ", m->tsc);
Linus Torvalds's avatar
Linus Torvalds committed
122
123
124
	if (m->addr)
		printk("ADDR %Lx ", m->addr);
	if (m->misc)
125
		printk("MISC %Lx ", m->misc);
Linus Torvalds's avatar
Linus Torvalds committed
126
	printk("\n");
127
	printk(KERN_EMERG "This is not a software problem!\n");
128
129
	printk(KERN_EMERG "Run through mcelog --ascii to decode "
	       "and contact your hardware vendor\n");
Linus Torvalds's avatar
Linus Torvalds committed
130
131
132
}

static void mce_panic(char *msg, struct mce *backup, unsigned long start)
133
{
Linus Torvalds's avatar
Linus Torvalds committed
134
	int i;
135

Linus Torvalds's avatar
Linus Torvalds committed
136
137
138
	oops_begin();
	for (i = 0; i < MCE_LOG_LEN; i++) {
		unsigned long tsc = mcelog.entry[i].tsc;
139

Linus Torvalds's avatar
Linus Torvalds committed
140
141
		if (time_before(tsc, start))
			continue;
142
		print_mce(&mcelog.entry[i]);
Linus Torvalds's avatar
Linus Torvalds committed
143
144
145
146
147
		if (backup && mcelog.entry[i].tsc == backup->tsc)
			backup = NULL;
	}
	if (backup)
		print_mce(backup);
148
	panic(msg);
149
}
Linus Torvalds's avatar
Linus Torvalds committed
150
151
152

static int mce_available(struct cpuinfo_x86 *c)
{
153
	return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA);
Linus Torvalds's avatar
Linus Torvalds committed
154
155
}

156
157
158
static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
{
	if (regs && (m->mcgstatus & MCG_STATUS_RIPV)) {
159
		m->ip = regs->ip;
160
161
		m->cs = regs->cs;
	} else {
162
		m->ip = 0;
163
164
165
166
167
		m->cs = 0;
	}
	if (rip_msr) {
		/* Assume the RIP in the MSR is exact. Is this true? */
		m->mcgstatus |= MCG_STATUS_EIPV;
168
		rdmsrl(rip_msr, m->ip);
169
170
171
172
		m->cs = 0;
	}
}

173
/*
Linus Torvalds's avatar
Linus Torvalds committed
174
175
176
177
178
179
180
181
 * 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;
182
183
184
185
186
187
188
189
190
191
	/*
	 * 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;
Linus Torvalds's avatar
Linus Torvalds committed
192

193
194
	atomic_inc(&mce_entry);

Linus Torvalds's avatar
Linus Torvalds committed
195
	if (regs)
196
197
		notify_die(DIE_NMI, "machine check", regs, error_code, 18,
			   SIGKILL);
Linus Torvalds's avatar
Linus Torvalds committed
198
	if (!banks)
199
		goto out2;
Linus Torvalds's avatar
Linus Torvalds committed
200
201

	memset(&m, 0, sizeof(struct mce));
202
	m.cpu = smp_processor_id();
Linus Torvalds's avatar
Linus Torvalds committed
203
	rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus);
204
	/* if the restart IP is not valid, we're done for */
Linus Torvalds's avatar
Linus Torvalds committed
205
	if (!(m.mcgstatus & MCG_STATUS_RIPV))
206
		no_way_out = 1;
207

Linus Torvalds's avatar
Linus Torvalds committed
208
209
210
211
212
213
	rdtscll(mcestart);
	barrier();

	for (i = 0; i < banks; i++) {
		if (!bank[i])
			continue;
214
215

		m.misc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
216
217
218
219
220
221
222
223
224
		m.addr = 0;
		m.bank = i;
		m.tsc = 0;

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

		if (m.status & MCI_STATUS_EN) {
225
226
227
228
229
230
231
232
233
234
235
236
			/* 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;
			}
Linus Torvalds's avatar
Linus Torvalds committed
237
238
239
240
241
242
243
		}

		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);

244
		mce_get_rip(&m, regs);
245
		if (error_code >= 0)
Linus Torvalds's avatar
Linus Torvalds committed
246
			rdtscll(m.tsc);
247
248
		if (error_code != -2)
			mce_log(&m);
Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
252
253
254
255
256
257

		/* 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;
		}

258
		add_taint(TAINT_MACHINE_CHECK);
Linus Torvalds's avatar
Linus Torvalds committed
259
260
261
	}

	/* Never do anything final in the polling timer */
262
	if (!regs)
Linus Torvalds's avatar
Linus Torvalds committed
263
264
265
266
267
268
		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;
269
270
271
272
273
274

	/*
	 * 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)
Linus Torvalds's avatar
Linus Torvalds committed
275
		mce_panic("Machine check", &panicm, mcestart);
276
277
278
279
280
281
282
283

	/*
	 * 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) {
Linus Torvalds's avatar
Linus Torvalds committed
284
285
		int user_space = 0;

286
287
288
289
290
		/*
		 * If the EIPV bit is set, it means the saved IP is the
		 * instruction which caused the MCE.
		 */
		if (m.mcgstatus & MCG_STATUS_EIPV)
291
			user_space = panicm.ip && (panicm.cs & 3);
292
293
294
295
296
297
298
299
300

		/*
		 * If we know that the error was in user space, send a
		 * SIGBUS.  Otherwise, panic if tolerance is low.
		 *
		 * do_exit() takes an awful lot of locks and has a slight
		 * risk of deadlocking.
		 */
		if (user_space) {
Linus Torvalds's avatar
Linus Torvalds committed
301
			do_exit(SIGBUS);
302
303
304
305
		} else if (panic_on_oops || tolerant < 2) {
			mce_panic("Uncorrected machine check",
				&panicm, mcestart);
		}
Linus Torvalds's avatar
Linus Torvalds committed
306
307
	}

308
309
310
	/* notify userspace ASAP */
	set_thread_flag(TIF_MCE_NOTIFY);

Linus Torvalds's avatar
Linus Torvalds committed
311
 out:
312
313
314
	/* the last thing we do is clear state */
	for (i = 0; i < banks; i++)
		wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
Linus Torvalds's avatar
Linus Torvalds committed
315
	wrmsrl(MSR_IA32_MCG_STATUS, 0);
316
317
 out2:
	atomic_dec(&mce_entry);
Linus Torvalds's avatar
Linus Torvalds committed
318
319
}

320
321
322
#ifdef CONFIG_X86_MCE_INTEL
/***
 * mce_log_therm_throt_event - Logs the thermal throttling event to mcelog
Simon Arlott's avatar
Simon Arlott committed
323
 * @cpu: The CPU on which the event occurred.
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 * @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.
 */
void mce_log_therm_throt_event(unsigned int cpu, __u64 status)
{
	struct mce m;

	memset(&m, 0, sizeof(m));
	m.cpu = cpu;
	m.bank = MCE_THERMAL_BANK;
	m.status = status;
	rdtscll(m.tsc);
	mce_log(&m);
}
#endif /* CONFIG_X86_MCE_INTEL */

Linus Torvalds's avatar
Linus Torvalds committed
347
/*
348
349
350
 * 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).
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
 */

static int check_interval = 5 * 60; /* 5 minutes */
354
static int next_interval; /* in jiffies */
355
356
static void mcheck_timer(struct work_struct *work);
static DECLARE_DELAYED_WORK(mcheck_work, mcheck_timer);
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
362
363

static void mcheck_check_cpu(void *info)
{
	if (mce_available(&current_cpu_data))
		do_machine_check(NULL, 0);
}

364
static void mcheck_timer(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
365
366
367
368
{
	on_each_cpu(mcheck_check_cpu, NULL, 1, 1);

	/*
369
370
	 * Alert userspace if needed.  If we logged an MCE, reduce the
	 * polling interval, otherwise increase the polling interval.
Linus Torvalds's avatar
Linus Torvalds committed
371
	 */
372
373
374
	if (mce_notify_user()) {
		next_interval = max(next_interval/2, HZ/100);
	} else {
375
		next_interval = min(next_interval * 2,
376
				(int)round_jiffies_relative(check_interval*HZ));
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
	}

	schedule_delayed_work(&mcheck_work, next_interval);
}

/*
 * This is only called from process context.  This is where we do
 * anything we need to alert userspace about new MCEs.  This is called
 * directly from the poller and also from entry.S and idle, thanks to
 * TIF_MCE_NOTIFY.
 */
int mce_notify_user(void)
{
	clear_thread_flag(TIF_MCE_NOTIFY);
	if (test_and_clear_bit(0, &notify_user)) {
392
393
394
		static unsigned long last_print;
		unsigned long now = jiffies;

395
396
397
398
399
		wake_up_interruptible(&mce_wait);
		if (trigger[0])
			call_usermodehelper(trigger, trigger_argv, NULL,
						UMH_NO_WAIT);

400
401
402
403
		if (time_after_eq(now, last_print + (check_interval*HZ))) {
			last_print = now;
			printk(KERN_INFO "Machine check events logged\n");
		}
404
405

		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
406
	}
407
408
	return 0;
}
409

410
411
412
413
414
415
416
417
418
/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
419
420
}

421
422
423
static struct notifier_block mce_idle_notifier = {
	.notifier_call = mce_idle_callback,
};
Linus Torvalds's avatar
Linus Torvalds committed
424
425

static __init int periodic_mcheck_init(void)
426
{
427
428
	next_interval = check_interval * HZ;
	if (next_interval)
429
430
		schedule_delayed_work(&mcheck_work,
				      round_jiffies_relative(next_interval));
431
	idle_notifier_register(&mce_idle_notifier);
Linus Torvalds's avatar
Linus Torvalds committed
432
	return 0;
433
}
Linus Torvalds's avatar
Linus Torvalds committed
434
435
436
__initcall(periodic_mcheck_init);


437
/*
Linus Torvalds's avatar
Linus Torvalds committed
438
439
440
441
442
443
444
445
446
 * Initialize Machine Checks for a CPU.
 */
static void mce_init(void *dummy)
{
	u64 cap;
	int i;

	rdmsrl(MSR_IA32_MCG_CAP, cap);
	banks = cap & 0xff;
447
	if (banks > NR_BANKS) {
Linus Torvalds's avatar
Linus Torvalds committed
448
		printk(KERN_INFO "MCE: warning: using only %d banks\n", banks);
449
		banks = NR_BANKS;
Linus Torvalds's avatar
Linus Torvalds committed
450
	}
451
452
453
	/* Use accurate RIP reporting if available. */
	if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9)
		rip_msr = MSR_IA32_MCG_EIP;
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456

	/* Log the machine checks left over from the previous reset.
	   This also clears all registers */
457
	do_machine_check(NULL, mce_bootlog ? -1 : -2);
Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
462
463
464
465
466

	set_in_cr4(X86_CR4_MCE);

	if (cap & MCG_CTL_P)
		wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff);

	for (i = 0; i < banks; i++) {
		wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]);
		wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
467
	}
Linus Torvalds's avatar
Linus Torvalds committed
468
469
470
}

/* Add per CPU specific workarounds here */
471
static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
472
{
Linus Torvalds's avatar
Linus Torvalds committed
473
474
	/* This should be disabled by the BIOS, but isn't always */
	if (c->x86_vendor == X86_VENDOR_AMD && c->x86 == 15) {
475
		/* disable GART TBL walk error reporting, which trips off
Linus Torvalds's avatar
Linus Torvalds committed
476
477
		   incorrectly with the IOMMU & 3ware & Cerberus. */
		clear_bit(10, &bank[4]);
478
479
480
		/* Lots of broken BIOS around that don't clear them
		   by default and leave crap in there. Don't log. */
		mce_bootlog = 0;
Linus Torvalds's avatar
Linus Torvalds committed
481
	}
482

483
}
Linus Torvalds's avatar
Linus Torvalds committed
484

485
static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
486
487
488
489
490
{
	switch (c->x86_vendor) {
	case X86_VENDOR_INTEL:
		mce_intel_feature_init(c);
		break;
491
492
493
	case X86_VENDOR_AMD:
		mce_amd_feature_init(c);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
494
495
496
497
498
	default:
		break;
	}
}

499
/*
Linus Torvalds's avatar
Linus Torvalds committed
500
 * Called for each booted CPU to set up machine checks.
501
 * Must be called with preempt off.
Linus Torvalds's avatar
Linus Torvalds committed
502
 */
503
void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
504
{
505
	static cpumask_t mce_cpus = CPU_MASK_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
506

507
	mce_cpu_quirks(c);
Linus Torvalds's avatar
Linus Torvalds committed
508
509
510
511
512
513
514
515
516
517
518
519
520
521

	if (mce_dont_init ||
	    cpu_test_and_set(smp_processor_id(), mce_cpus) ||
	    !mce_available(c))
		return;

	mce_init(NULL);
	mce_cpu_features(c);
}

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

Tim Hockin's avatar
Tim Hockin committed
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
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)
{
	spin_lock(&mce_state_lock);

	if (open_exclu || (open_count && (file->f_flags & O_EXCL))) {
		spin_unlock(&mce_state_lock);
		return -EBUSY;
	}

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

	spin_unlock(&mce_state_lock);

541
	return nonseekable_open(inode, file);
Tim Hockin's avatar
Tim Hockin committed
542
543
544
545
546
547
548
549
550
551
552
553
554
555
}

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;
}

556
557
static void collect_tscs(void *data)
{
Linus Torvalds's avatar
Linus Torvalds committed
558
	unsigned long *cpu_tsc = (unsigned long *)data;
559

Linus Torvalds's avatar
Linus Torvalds committed
560
	rdtscll(cpu_tsc[smp_processor_id()]);
561
}
Linus Torvalds's avatar
Linus Torvalds committed
562

563
564
static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
			loff_t *off)
Linus Torvalds's avatar
Linus Torvalds committed
565
{
566
	unsigned long *cpu_tsc;
567
	static DEFINE_MUTEX(mce_read_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
568
569
570
571
	unsigned next;
	char __user *buf = ubuf;
	int i, err;

572
573
574
575
	cpu_tsc = kmalloc(NR_CPUS * sizeof(long), GFP_KERNEL);
	if (!cpu_tsc)
		return -ENOMEM;

576
	mutex_lock(&mce_read_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
577
578
579
	next = rcu_dereference(mcelog.next);

	/* Only supports full reads right now */
580
	if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) {
581
		mutex_unlock(&mce_read_mutex);
582
		kfree(cpu_tsc);
Linus Torvalds's avatar
Linus Torvalds committed
583
584
585
586
		return -EINVAL;
	}

	err = 0;
587
	for (i = 0; i < next; i++) {
588
		unsigned long start = jiffies;
589

590
		while (!mcelog.entry[i].finished) {
591
			if (time_after_eq(jiffies, start + 2)) {
592
				memset(mcelog.entry + i,0, sizeof(struct mce));
593
				goto timeout;
594
595
596
			}
			cpu_relax();
		}
Linus Torvalds's avatar
Linus Torvalds committed
597
598
		smp_rmb();
		err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce));
599
		buf += sizeof(struct mce);
600
601
 timeout:
		;
602
	}
Linus Torvalds's avatar
Linus Torvalds committed
603
604
605
606

	memset(mcelog.entry, 0, next * sizeof(struct mce));
	mcelog.next = 0;

607
	synchronize_sched();
Linus Torvalds's avatar
Linus Torvalds committed
608

609
610
611
612
	/*
	 * Collect entries that were still getting written before the
	 * synchronize.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
613
	on_each_cpu(collect_tscs, cpu_tsc, 1, 1);
614
615
616
617
618
	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));
Linus Torvalds's avatar
Linus Torvalds committed
619
620
621
622
			smp_rmb();
			buf += sizeof(struct mce);
			memset(&mcelog.entry[i], 0, sizeof(struct mce));
		}
623
	}
624
	mutex_unlock(&mce_read_mutex);
625
	kfree(cpu_tsc);
626
	return err ? -EFAULT : buf - ubuf;
Linus Torvalds's avatar
Linus Torvalds committed
627
628
}

629
630
631
632
633
634
635
636
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;
}

637
638
static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd,
		     unsigned long arg)
Linus Torvalds's avatar
Linus Torvalds committed
639
640
{
	int __user *p = (int __user *)arg;
641

Linus Torvalds's avatar
Linus Torvalds committed
642
	if (!capable(CAP_SYS_ADMIN))
643
		return -EPERM;
Linus Torvalds's avatar
Linus Torvalds committed
644
	switch (cmd) {
645
	case MCE_GET_RECORD_LEN:
Linus Torvalds's avatar
Linus Torvalds committed
646
647
		return put_user(sizeof(struct mce), p);
	case MCE_GET_LOG_LEN:
648
		return put_user(MCE_LOG_LEN, p);
Linus Torvalds's avatar
Linus Torvalds committed
649
650
	case MCE_GETCLEAR_FLAGS: {
		unsigned flags;
651
652

		do {
Linus Torvalds's avatar
Linus Torvalds committed
653
			flags = mcelog.flags;
654
655
		} while (cmpxchg(&mcelog.flags, flags, 0) != flags);
		return put_user(flags, p);
Linus Torvalds's avatar
Linus Torvalds committed
656
657
	}
	default:
658
659
		return -ENOTTY;
	}
Linus Torvalds's avatar
Linus Torvalds committed
660
661
}

662
static const struct file_operations mce_chrdev_ops = {
Tim Hockin's avatar
Tim Hockin committed
663
664
	.open = mce_open,
	.release = mce_release,
Linus Torvalds's avatar
Linus Torvalds committed
665
	.read = mce_read,
666
	.poll = mce_poll,
Linus Torvalds's avatar
Linus Torvalds committed
667
668
669
670
671
672
673
674
675
	.ioctl = mce_ioctl,
};

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

676
677
678
679
680
681
682
683
684
685
686
687
688
689
static unsigned long old_cr4 __initdata;

void __init stop_mce(void)
{
	old_cr4 = read_cr4();
	clear_in_cr4(X86_CR4_MCE);
}

void __init restart_mce(void)
{
	if (old_cr4 & X86_CR4_MCE)
		set_in_cr4(X86_CR4_MCE);
}

690
691
/*
 * Old style boot options parsing. Only for compatibility.
Linus Torvalds's avatar
Linus Torvalds committed
692
693
694
695
 */
static int __init mcheck_disable(char *str)
{
	mce_dont_init = 1;
696
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
697
698
}

Simon Arlott's avatar
Simon Arlott committed
699
/* mce=off disables machine check. Note you can re-enable it later
700
   using sysfs.
701
   mce=TOLERANCELEVEL (number, see above)
702
703
   mce=bootlog Log MCEs from before booting. Disabled by default on AMD.
   mce=nobootlog Don't log MCEs from before booting. */
Linus Torvalds's avatar
Linus Torvalds committed
704
705
706
707
static int __init mcheck_enable(char *str)
{
	if (!strcmp(str, "off"))
		mce_dont_init = 1;
708
709
	else if (!strcmp(str, "bootlog") || !strcmp(str,"nobootlog"))
		mce_bootlog = str[0] == 'b';
710
711
	else if (isdigit(str[0]))
		get_option(&str, &tolerant);
Linus Torvalds's avatar
Linus Torvalds committed
712
	else
713
		printk("mce= argument %s ignored. Please use /sys", str);
714
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
715
716
717
}

__setup("nomce", mcheck_disable);
718
__setup("mce=", mcheck_enable);
Linus Torvalds's avatar
Linus Torvalds committed
719

720
/*
Linus Torvalds's avatar
Linus Torvalds committed
721
 * Sysfs support
722
 */
Linus Torvalds's avatar
Linus Torvalds committed
723

724
725
726
/* 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. */
Linus Torvalds's avatar
Linus Torvalds committed
727
728
static int mce_resume(struct sys_device *dev)
{
729
	mce_init(NULL);
Linus Torvalds's avatar
Linus Torvalds committed
730
731
732
733
	return 0;
}

/* Reinit MCEs after user configuration changes */
734
735
static void mce_restart(void)
{
736
	if (next_interval)
Linus Torvalds's avatar
Linus Torvalds committed
737
738
		cancel_delayed_work(&mcheck_work);
	/* Timer race is harmless here */
739
	on_each_cpu(mce_init, NULL, 1, 1);
740
741
	next_interval = check_interval * HZ;
	if (next_interval)
742
743
		schedule_delayed_work(&mcheck_work,
				      round_jiffies_relative(next_interval));
Linus Torvalds's avatar
Linus Torvalds committed
744
745
746
747
}

static struct sysdev_class mce_sysclass = {
	.resume = mce_resume,
748
	.name = "machinecheck",
Linus Torvalds's avatar
Linus Torvalds committed
749
750
};

751
DEFINE_PER_CPU(struct sys_device, device_mce);
Linus Torvalds's avatar
Linus Torvalds committed
752
753
754

/* Why are there no generic functions for this? */
#define ACCESSOR(name, var, start) \
755
756
757
	static ssize_t show_ ## name(struct sys_device *s, char *buf) {	\
		return sprintf(buf, "%lx\n", (unsigned long)var);	\
	}								\
Linus Torvalds's avatar
Linus Torvalds committed
758
	static ssize_t set_ ## name(struct sys_device *s,const char *buf,size_t siz) { \
759
760
761
762
763
764
765
		char *end;						\
		unsigned long new = simple_strtoul(buf, &end, 0);	\
		if (end == buf) return -EINVAL;				\
		var = new;						\
		start;							\
		return end-buf;						\
	}								\
Linus Torvalds's avatar
Linus Torvalds committed
766
767
	static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name);

768
/* TBD should generate these dynamically based on number of available banks */
Linus Torvalds's avatar
Linus Torvalds committed
769
770
771
772
773
ACCESSOR(bank0ctl,bank[0],mce_restart())
ACCESSOR(bank1ctl,bank[1],mce_restart())
ACCESSOR(bank2ctl,bank[2],mce_restart())
ACCESSOR(bank3ctl,bank[3],mce_restart())
ACCESSOR(bank4ctl,bank[4],mce_restart())
774
ACCESSOR(bank5ctl,bank[5],mce_restart())
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795

static ssize_t show_trigger(struct sys_device *s, char *buf)
{
	strcpy(buf, trigger);
	strcat(buf, "\n");
	return strlen(trigger) + 1;
}

static ssize_t set_trigger(struct sys_device *s,const char *buf,size_t siz)
{
	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);
Linus Torvalds's avatar
Linus Torvalds committed
796
797
ACCESSOR(tolerant,tolerant,)
ACCESSOR(check_interval,check_interval,mce_restart())
798
799
800
801
802
803
static struct sysdev_attribute *mce_attributes[] = {
	&attr_bank0ctl, &attr_bank1ctl, &attr_bank2ctl,
	&attr_bank3ctl, &attr_bank4ctl, &attr_bank5ctl,
	&attr_tolerant, &attr_check_interval, &attr_trigger,
	NULL
};
Linus Torvalds's avatar
Linus Torvalds committed
804

805
806
static cpumask_t mce_device_initialized = CPU_MASK_NONE;

807
808
/* Per cpu sysdev init.  All of the cpus still share the same ctl bank */
static __cpuinit int mce_create_device(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
809
810
{
	int err;
811
	int i;
812

813
	if (!mce_available(&boot_cpu_data))
814
815
		return -EIO;

816
	memset(&per_cpu(device_mce, cpu).kobj, 0, sizeof(struct kobject));
817
818
819
820
	per_cpu(device_mce,cpu).id = cpu;
	per_cpu(device_mce,cpu).cls = &mce_sysclass;

	err = sysdev_register(&per_cpu(device_mce,cpu));
821
822
823
824
825
826
827
828
829
	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;
	}
830
	cpu_set(cpu, mce_device_initialized);
831

832
833
834
835
836
	return 0;
error:
	while (i--) {
		sysdev_remove_file(&per_cpu(device_mce,cpu),
				   mce_attributes[i]);
837
	}
838
839
	sysdev_unregister(&per_cpu(device_mce,cpu));

840
841
842
	return err;
}

843
static void mce_remove_device(unsigned int cpu)
844
{
845
846
	int i;

847
848
849
	if (!cpu_isset(cpu, mce_device_initialized))
		return;

850
	for (i = 0; mce_attributes[i]; i++)
851
		sysdev_remove_file(&per_cpu(device_mce,cpu),
852
			mce_attributes[i]);
853
	sysdev_unregister(&per_cpu(device_mce,cpu));
854
	cpu_clear(cpu, mce_device_initialized);
855
856
857
}

/* Get notified when a cpu comes on/off. Be hotplug friendly. */
858
static int
859
860
861
862
863
mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;

	switch (action) {
864
865
866
	case CPU_ONLINE:
	case CPU_ONLINE_FROZEN:
		mce_create_device(cpu);
867
868
		break;
	case CPU_DEAD:
869
	case CPU_DEAD_FROZEN:
870
871
872
		mce_remove_device(cpu);
		break;
	}
873
	return NOTIFY_OK;
874
875
}

876
static struct notifier_block mce_cpu_notifier = {
877
878
879
880
881
882
883
884
	.notifier_call = mce_cpu_callback,
};

static __init int mce_init_device(void)
{
	int err;
	int i = 0;

Linus Torvalds's avatar
Linus Torvalds committed
885
886
887
	if (!mce_available(&boot_cpu_data))
		return -EIO;
	err = sysdev_class_register(&mce_sysclass);
888
889
	if (err)
		return err;
890
891

	for_each_online_cpu(i) {
892
893
894
		err = mce_create_device(i);
		if (err)
			return err;
895
896
	}

897
	register_hotcpu_notifier(&mce_cpu_notifier);
Linus Torvalds's avatar
Linus Torvalds committed
898
899
900
	misc_register(&mce_log_device);
	return err;
}
901

Linus Torvalds's avatar
Linus Torvalds committed
902
device_initcall(mce_init_device);