mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-30 08:02:30 +00:00
933ca4e323
As said in commit f2c2cbcc35
("powerpc: Use pr_warn instead of
pr_warning"), removing pr_warning so all logging messages use a
consistent <prefix>_warn style. Let's do it.
Link: http://lkml.kernel.org/r/20191018031850.48498-8-wangkefeng.wang@huawei.com
To: linux-kernel@vger.kernel.org
Cc: "Rafael J. Wysocki" <rjw@rjwysocki.net>
Cc: Len Brown <lenb@kernel.org>
Cc: James Morse <james.morse@arm.com>
Signed-off-by: Kefeng Wang <wangkefeng.wang@huawei.com>
Reviewed-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
[pmladek@suse.com: two more indentation fixes]
Signed-off-by: Petr Mladek <pmladek@suse.com>
230 lines
4.8 KiB
C
230 lines
4.8 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* 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>
|
|
*/
|
|
|
|
#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_warn(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");
|