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