[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / apei / erst-dbg.c

/*
 * APEI Error Record Serialization Table debug support
 *
 * ERST is a way provided by APEI to save and retrieve hardware error
 * information to and from a persistent store. This file provide the
 * debugging/testing support for ERST kernel support and firmware
 * implementation.
 *
 * Copyright 2010 Intel Corp.
 *   Author: Huang Ying <ying.huang@intel.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/uaccess.h>
#include <acpi/apei.h>
#include <linux/miscdevice.h>

#include "apei-internal.h"

#define ERST_DBG_PFX			"ERST DBG: "

#define ERST_DBG_RECORD_LEN_MAX		0x4000

static void *erst_dbg_buf;
static unsigned int erst_dbg_buf_len;

/* Prevent erst_dbg_read/write from being invoked concurrently */
static DEFINE_MUTEX(erst_dbg_mutex);

static int erst_dbg_open(struct inode *inode, struct file *file)
{
	int rc, *pos;

	if (erst_disable)
		return -ENODEV;

	pos = (int *)&file->private_data;

	rc = erst_get_record_id_begin(pos);
	if (rc)
		return rc;

	return nonseekable_open(inode, file);
}

static int erst_dbg_release(struct inode *inode, struct file *file)
{
	erst_get_record_id_end();

	return 0;
}

static long erst_dbg_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
	int rc;
	u64 record_id;
	u32 record_count;

	switch (cmd) {
	case APEI_ERST_CLEAR_RECORD:
		rc = copy_from_user(&record_id, (void __user *)arg,
				    sizeof(record_id));
		if (rc)
			return -EFAULT;
		return erst_clear(record_id);
	case APEI_ERST_GET_RECORD_COUNT:
		rc = erst_get_record_count();
		if (rc < 0)
			return rc;
		record_count = rc;
		rc = put_user(record_count, (u32 __user *)arg);
		if (rc)
			return rc;
		return 0;
	default:
		return -ENOTTY;
	}
}

static ssize_t erst_dbg_read(struct file *filp, char __user *ubuf,
			     size_t usize, loff_t *off)
{
	int rc, *pos;
	ssize_t len = 0;
	u64 id;

	if (*off)
		return -EINVAL;

	if (mutex_lock_interruptible(&erst_dbg_mutex) != 0)
		return -EINTR;

	pos = (int *)&filp->private_data;

retry_next:
	rc = erst_get_record_id_next(pos, &id);
	if (rc)
		goto out;
	/* no more record */
	if (id == APEI_ERST_INVALID_RECORD_ID) {
		/*
		 * If the persistent store is empty initially, the function
		 * 'erst_read' below will return "-ENOENT" value. This causes
		 * 'retry_next' label is entered again. The returned value
		 * should be zero indicating the read operation is EOF.
		 */
		len = 0;

		goto out;
	}
retry:
	rc = len = erst_read(id, erst_dbg_buf, erst_dbg_buf_len);
	/* The record may be cleared by others, try read next record */
	if (rc == -ENOENT)
		goto retry_next;
	if (rc < 0)
		goto out;
	if (len > ERST_DBG_RECORD_LEN_MAX) {
		pr_warning(ERST_DBG_PFX
			   "Record (ID: 0x%llx) length is too long: %zd\n",
			   id, len);
		rc = -EIO;
		goto out;
	}
	if (len > erst_dbg_buf_len) {
		void *p;
		rc = -ENOMEM;
		p = kmalloc(len, GFP_KERNEL);
		if (!p)
			goto out;
		kfree(erst_dbg_buf);
		erst_dbg_buf = p;
		erst_dbg_buf_len = len;
		goto retry;
	}

	rc = -EINVAL;
	if (len > usize)
		goto out;

	rc = -EFAULT;
	if (copy_to_user(ubuf, erst_dbg_buf, len))
		goto out;
	rc = 0;
out:
	mutex_unlock(&erst_dbg_mutex);
	return rc ? rc : len;
}

static ssize_t erst_dbg_write(struct file *filp, const char __user *ubuf,
			      size_t usize, loff_t *off)
{
	int rc;
	struct cper_record_header *rcd;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (usize > ERST_DBG_RECORD_LEN_MAX) {
		pr_err(ERST_DBG_PFX "Too long record to be written\n");
		return -EINVAL;
	}

	if (mutex_lock_interruptible(&erst_dbg_mutex))
		return -EINTR;
	if (usize > erst_dbg_buf_len) {
		void *p;
		rc = -ENOMEM;
		p = kmalloc(usize, GFP_KERNEL);
		if (!p)
			goto out;
		kfree(erst_dbg_buf);
		erst_dbg_buf = p;
		erst_dbg_buf_len = usize;
	}
	rc = copy_from_user(erst_dbg_buf, ubuf, usize);
	if (rc) {
		rc = -EFAULT;
		goto out;
	}
	rcd = erst_dbg_buf;
	rc = -EINVAL;
	if (rcd->record_length != usize)
		goto out;

	rc = erst_write(erst_dbg_buf);

out:
	mutex_unlock(&erst_dbg_mutex);
	return rc < 0 ? rc : usize;
}

static const struct file_operations erst_dbg_ops = {
	.owner		= THIS_MODULE,
	.open		= erst_dbg_open,
	.release	= erst_dbg_release,
	.read		= erst_dbg_read,
	.write		= erst_dbg_write,
	.unlocked_ioctl	= erst_dbg_ioctl,
	.llseek		= no_llseek,
};

static struct miscdevice erst_dbg_dev = {
	.minor	= MISC_DYNAMIC_MINOR,
	.name	= "erst_dbg",
	.fops	= &erst_dbg_ops,
};

static __init int erst_dbg_init(void)
{
	if (erst_disable) {
		pr_info(ERST_DBG_PFX "ERST support is disabled.\n");
		return -ENODEV;
	}
	return misc_register(&erst_dbg_dev);
}

static __exit void erst_dbg_exit(void)
{
	misc_deregister(&erst_dbg_dev);
	kfree(erst_dbg_buf);
}

module_init(erst_dbg_init);
module_exit(erst_dbg_exit);

MODULE_AUTHOR("Huang Ying");
MODULE_DESCRIPTION("APEI Error Record Serialization Table debug support");
MODULE_LICENSE("GPL");
Commit	Line	Data
2ff729d5 HY	1	/*
	2	* APEI Error Record Serialization Table debug support
	3	*
	4	* ERST is a way provided by APEI to save and retrieve hardware error
58f87ed0	5	* information to and from a persistent store. This file provide the
2ff729d5 HY	6	* debugging/testing support for ERST kernel support and firmware
	7	* implementation.
	8	*
	9	* Copyright 2010 Intel Corp.
	10	* Author: Huang Ying <ying.huang@intel.com>
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License version
	14	* 2 as published by the Free Software Foundation.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*/
	25
	26	#include <linux/kernel.h>
	27	#include <linux/module.h>
	28	#include <linux/uaccess.h>
	29	#include <acpi/apei.h>
	30	#include <linux/miscdevice.h>
	31
	32	#include "apei-internal.h"
	33
	34	#define ERST_DBG_PFX "ERST DBG: "
	35
d37afc50	36	#define ERST_DBG_RECORD_LEN_MAX 0x4000
2ff729d5 HY	37
	38	static void *erst_dbg_buf;
	39	static unsigned int erst_dbg_buf_len;
	40
	41	/* Prevent erst_dbg_read/write from being invoked concurrently */
	42	static DEFINE_MUTEX(erst_dbg_mutex);
	43
	44	static int erst_dbg_open(struct inode inode, struct file file)
	45	{
885b976f HY	46	int rc, *pos;
885b976f HY	47
2ff729d5 HY	48	if (erst_disable)
	49	return -ENODEV;
	50
885b976f HY	51	pos = (int *)&file->private_data;
	52
	53	rc = erst_get_record_id_begin(pos);
	54	if (rc)
	55	return rc;
	56
2ff729d5 HY	57	return nonseekable_open(inode, file);
	58	}
	59
885b976f HY	60	static int erst_dbg_release(struct inode inode, struct file file)
	61	{
	62	erst_get_record_id_end();
	63
	64	return 0;
	65	}
	66
2ff729d5 HY	67	static long erst_dbg_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
	68	{
	69	int rc;
	70	u64 record_id;
	71	u32 record_count;
	72
	73	switch (cmd) {
	74	case APEI_ERST_CLEAR_RECORD:
	75	rc = copy_from_user(&record_id, (void __user *)arg,
	76	sizeof(record_id));
	77	if (rc)
	78	return -EFAULT;
	79	return erst_clear(record_id);
	80	case APEI_ERST_GET_RECORD_COUNT:
	81	rc = erst_get_record_count();
	82	if (rc < 0)
	83	return rc;
	84	record_count = rc;
	85	rc = put_user(record_count, (u32 __user *)arg);
	86	if (rc)
	87	return rc;
	88	return 0;
	89	default:
	90	return -ENOTTY;
	91	}
	92	}
	93
	94	static ssize_t erst_dbg_read(struct file filp, char __user ubuf,
	95	size_t usize, loff_t *off)
	96	{
885b976f	97	int rc, *pos;
2ff729d5 HY	98	ssize_t len = 0;
	99	u64 id;
	100
885b976f	101	if (*off)
2ff729d5 HY	102	return -EINVAL;
	103
	104	if (mutex_lock_interruptible(&erst_dbg_mutex) != 0)
	105	return -EINTR;
	106
885b976f HY	107	pos = (int *)&filp->private_data;
885b976f HY	108
2ff729d5	109	retry_next:
885b976f	110	rc = erst_get_record_id_next(pos, &id);
2ff729d5 HY	111	if (rc)
	112	goto out;
	113	/* no more record */
6780aa68 AH	114	if (id == APEI_ERST_INVALID_RECORD_ID) {
	115	/*
	116	* If the persistent store is empty initially, the function
	117	* 'erst_read' below will return "-ENOENT" value. This causes
	118	* 'retry_next' label is entered again. The returned value
	119	* should be zero indicating the read operation is EOF.
	120	*/
	121	len = 0;
	122
2ff729d5	123	goto out;
6780aa68	124	}
2ff729d5 HY	125	retry:
	126	rc = len = erst_read(id, erst_dbg_buf, erst_dbg_buf_len);
	127	/* The record may be cleared by others, try read next record */
	128	if (rc == -ENOENT)
	129	goto retry_next;
	130	if (rc < 0)
	131	goto out;
	132	if (len > ERST_DBG_RECORD_LEN_MAX) {
	133	pr_warning(ERST_DBG_PFX
	134	"Record (ID: 0x%llx) length is too long: %zd\n",
	135	id, len);
	136	rc = -EIO;
	137	goto out;
	138	}
	139	if (len > erst_dbg_buf_len) {
23f124ca	140	void *p;
2ff729d5	141	rc = -ENOMEM;
23f124ca HY	142	p = kmalloc(len, GFP_KERNEL);
23f124ca HY	143	if (!p)
2ff729d5	144	goto out;
23f124ca HY	145	kfree(erst_dbg_buf);
23f124ca HY	146	erst_dbg_buf = p;
2ff729d5 HY	147	erst_dbg_buf_len = len;
	148	goto retry;
	149	}
	150
	151	rc = -EINVAL;
	152	if (len > usize)
	153	goto out;
	154
	155	rc = -EFAULT;
	156	if (copy_to_user(ubuf, erst_dbg_buf, len))
	157	goto out;
	158	rc = 0;
	159	out:
	160	mutex_unlock(&erst_dbg_mutex);
	161	return rc ? rc : len;
	162	}
	163
	164	static ssize_t erst_dbg_write(struct file filp, const char __user ubuf,
	165	size_t usize, loff_t *off)
	166	{
	167	int rc;
	168	struct cper_record_header *rcd;
	169
	170	if (!capable(CAP_SYS_ADMIN))
	171	return -EPERM;
	172
	173	if (usize > ERST_DBG_RECORD_LEN_MAX) {
	174	pr_err(ERST_DBG_PFX "Too long record to be written\n");
	175	return -EINVAL;
	176	}
	177
	178	if (mutex_lock_interruptible(&erst_dbg_mutex))
	179	return -EINTR;
	180	if (usize > erst_dbg_buf_len) {
23f124ca	181	void *p;
2ff729d5	182	rc = -ENOMEM;
23f124ca HY	183	p = kmalloc(usize, GFP_KERNEL);
23f124ca HY	184	if (!p)
2ff729d5	185	goto out;
23f124ca HY	186	kfree(erst_dbg_buf);
23f124ca HY	187	erst_dbg_buf = p;
2ff729d5 HY	188	erst_dbg_buf_len = usize;
	189	}
	190	rc = copy_from_user(erst_dbg_buf, ubuf, usize);
	191	if (rc) {
	192	rc = -EFAULT;
	193	goto out;
	194	}
	195	rcd = erst_dbg_buf;
	196	rc = -EINVAL;
	197	if (rcd->record_length != usize)
	198	goto out;
	199
	200	rc = erst_write(erst_dbg_buf);
	201
	202	out:
	203	mutex_unlock(&erst_dbg_mutex);
	204	return rc < 0 ? rc : usize;
	205	}
	206
	207	static const struct file_operations erst_dbg_ops = {
	208	.owner = THIS_MODULE,
	209	.open = erst_dbg_open,
885b976f	210	.release = erst_dbg_release,
2ff729d5 HY	211	.read = erst_dbg_read,
	212	.write = erst_dbg_write,
	213	.unlocked_ioctl = erst_dbg_ioctl,
6038f373	214	.llseek = no_llseek,
2ff729d5 HY	215	};
	216
	217	static struct miscdevice erst_dbg_dev = {
	218	.minor = MISC_DYNAMIC_MINOR,
	219	.name = "erst_dbg",
	220	.fops = &erst_dbg_ops,
	221	};
	222
	223	static __init int erst_dbg_init(void)
	224	{
ca7cc511 HY	225	if (erst_disable) {
	226	pr_info(ERST_DBG_PFX "ERST support is disabled.\n");
	227	return -ENODEV;
	228	}
2ff729d5 HY	229	return misc_register(&erst_dbg_dev);
	230	}
	231
	232	static __exit void erst_dbg_exit(void)
	233	{
	234	misc_deregister(&erst_dbg_dev);
	235	kfree(erst_dbg_buf);
	236	}
	237
	238	module_init(erst_dbg_init);
	239	module_exit(erst_dbg_exit);
	240
	241	MODULE_AUTHOR("Huang Ying");
	242	MODULE_DESCRIPTION("APEI Error Record Serialization Table debug support");
	243	MODULE_LICENSE("GPL");