[mirror_ubuntu-zesty-kernel.git] / arch / x86 / kernel / cpu / mcheck / mce-inject.c

/*
 * Machine check injection support.
 * Copyright 2008 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 2
 * of the License.
 *
 * Authors:
 * Andi Kleen
 * Ying Huang
 */
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/smp.h>
#include <asm/uaccess.h>
#include <asm/mce.h>

/* Update fake mce registers on current CPU. */
static void inject_mce(struct mce *m)
{
	struct mce *i = &per_cpu(injectm, m->cpu);

	/* Make sure noone reads partially written injectm */
	i->finished = 0;
	mb();
	m->finished = 0;
	/* First set the fields after finished */
	i->cpu = m->cpu;
	mb();
	/* Now write record in order, finished last (except above) */
	memcpy(i, m, sizeof(struct mce));
	/* Finally activate it */
	mb();
	i->finished = 1;
}

struct delayed_mce {
	struct timer_list timer;
	struct mce m;
};

/* Inject mce on current CPU */
static void raise_mce(unsigned long data)
{
	struct delayed_mce *dm = (struct delayed_mce *)data;
	struct mce *m = &dm->m;
	int cpu = m->cpu;

	inject_mce(m);
	if (m->status & MCI_STATUS_UC) {
		struct pt_regs regs;
		memset(&regs, 0, sizeof(struct pt_regs));
		regs.ip = m->ip;
		regs.cs = m->cs;
		printk(KERN_INFO "Triggering MCE exception on CPU %d\n", cpu);
		do_machine_check(&regs, 0);
		printk(KERN_INFO "MCE exception done on CPU %d\n", cpu);
	} else {
		mce_banks_t b;
		memset(&b, 0xff, sizeof(mce_banks_t));
		printk(KERN_INFO "Starting machine check poll CPU %d\n", cpu);
		machine_check_poll(0, &b);
		mce_notify_user();
		printk(KERN_INFO "Finished machine check poll on CPU %d\n",
		       cpu);
	}
	kfree(dm);
}

/* Error injection interface */
static ssize_t mce_write(struct file *filp, const char __user *ubuf,
			 size_t usize, loff_t *off)
{
	struct delayed_mce *dm;
	struct mce m;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	/*
	 * There are some cases where real MSR reads could slip
	 * through.
	 */
	if (!boot_cpu_has(X86_FEATURE_MCE) || !boot_cpu_has(X86_FEATURE_MCA))
		return -EIO;

	if ((unsigned long)usize > sizeof(struct mce))
		usize = sizeof(struct mce);
	if (copy_from_user(&m, ubuf, usize))
		return -EFAULT;

	if (m.cpu >= NR_CPUS || !cpu_online(m.cpu))
		return -EINVAL;

	dm = kmalloc(sizeof(struct delayed_mce), GFP_KERNEL);
	if (!dm)
		return -ENOMEM;

	/*
	 * Need to give user space some time to set everything up,
	 * so do it a jiffie or two later everywhere.
	 * Should we use a hrtimer here for better synchronization?
	 */
	memcpy(&dm->m, &m, sizeof(struct mce));
	setup_timer(&dm->timer, raise_mce, (unsigned long)dm);
	dm->timer.expires = jiffies + 2;
	add_timer_on(&dm->timer, m.cpu);
	return usize;
}

static int inject_init(void)
{
	printk(KERN_INFO "Machine check injector initialized\n");
	mce_chrdev_ops.write = mce_write;
	return 0;
}

module_init(inject_init);
/* Cannot tolerate unloading currently because we cannot
 * guarantee all openers of mce_chrdev will get a reference to us.
 */
MODULE_LICENSE("GPL");
Commit	Line	Data
ea149b36 AK	1	/*
	2	* Machine check injection support.
	3	* Copyright 2008 Intel Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License
	7	* as published by the Free Software Foundation; version 2
	8	* of the License.
	9	*
	10	* Authors:
	11	* Andi Kleen
	12	* Ying Huang
	13	*/
	14	#include <linux/module.h>
	15	#include <linux/timer.h>
	16	#include <linux/kernel.h>
	17	#include <linux/string.h>
	18	#include <linux/fs.h>
	19	#include <linux/smp.h>
	20	#include <asm/uaccess.h>
	21	#include <asm/mce.h>
	22
	23	/* Update fake mce registers on current CPU. */
	24	static void inject_mce(struct mce *m)
	25	{
	26	struct mce *i = &per_cpu(injectm, m->cpu);
	27
	28	/* Make sure noone reads partially written injectm */
	29	i->finished = 0;
	30	mb();
	31	m->finished = 0;
	32	/* First set the fields after finished */
	33	i->cpu = m->cpu;
	34	mb();
	35	/* Now write record in order, finished last (except above) */
	36	memcpy(i, m, sizeof(struct mce));
	37	/* Finally activate it */
	38	mb();
	39	i->finished = 1;
	40	}
	41
	42	struct delayed_mce {
	43	struct timer_list timer;
	44	struct mce m;
	45	};
	46
	47	/* Inject mce on current CPU */
	48	static void raise_mce(unsigned long data)
	49	{
	50	struct delayed_mce dm = (struct delayed_mce )data;
	51	struct mce *m = &dm->m;
	52	int cpu = m->cpu;
	53
	54	inject_mce(m);
	55	if (m->status & MCI_STATUS_UC) {
	56	struct pt_regs regs;
	57	memset(&regs, 0, sizeof(struct pt_regs));
	58	regs.ip = m->ip;
	59	regs.cs = m->cs;
	60	printk(KERN_INFO "Triggering MCE exception on CPU %d\n", cpu);
	61	do_machine_check(&regs, 0);
	62	printk(KERN_INFO "MCE exception done on CPU %d\n", cpu);
	63	} else {
	64	mce_banks_t b;
65	memset(&b, 0xff, sizeof(mce_banks_t));
66	printk(KERN_INFO "Starting machine check poll CPU %d\n", cpu);
67	machine_check_poll(0, &b);
68	mce_notify_user();
69	printk(KERN_INFO "Finished machine check poll on CPU %d\n",
70	cpu);
71	}
72	kfree(dm);
73	}
74
75	/* Error injection interface */
76	static ssize_t mce_write(struct file filp, const char __user ubuf,
77	size_t usize, loff_t *off)
78	{
79	struct delayed_mce *dm;
80	struct mce m;
81
82	if (!capable(CAP_SYS_ADMIN))
83	return -EPERM;
84	/*
85	* There are some cases where real MSR reads could slip
86	* through.
87	*/
88	if (!boot_cpu_has(X86_FEATURE_MCE) \|\| !boot_cpu_has(X86_FEATURE_MCA))
89	return -EIO;
90
91	if ((unsigned long)usize > sizeof(struct mce))
92	usize = sizeof(struct mce);
93	if (copy_from_user(&m, ubuf, usize))
94	return -EFAULT;
95
96	if (m.cpu >= NR_CPUS \|\| !cpu_online(m.cpu))
97	return -EINVAL;
98
99	dm = kmalloc(sizeof(struct delayed_mce), GFP_KERNEL);
100	if (!dm)
101	return -ENOMEM;
102
103	/*
104	* Need to give user space some time to set everything up,
105	* so do it a jiffie or two later everywhere.
106	* Should we use a hrtimer here for better synchronization?
107	*/
108	memcpy(&dm->m, &m, sizeof(struct mce));
109	setup_timer(&dm->timer, raise_mce, (unsigned long)dm);
110	dm->timer.expires = jiffies + 2;
111	add_timer_on(&dm->timer, m.cpu);
112	return usize;
113	}
114
115	static int inject_init(void)
116	{
117	printk(KERN_INFO "Machine check injector initialized\n");
118	mce_chrdev_ops.write = mce_write;
119	return 0;
120	}
121
122	module_init(inject_init);
123	/* Cannot tolerate unloading currently because we cannot
124	* guarantee all openers of mce_chrdev will get a reference to us.
125	*/
126	MODULE_LICENSE("GPL");