1/* 2 * c 2001 PPC 64 Team, IBM Corp 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * scan-log-data driver for PPC64 Todd Inglett <tinglett@vnet.ibm.com> 10 * 11 * When ppc64 hardware fails the service processor dumps internal state 12 * of the system. After a reboot the operating system can access a dump 13 * of this data using this driver. A dump exists if the device-tree 14 * /chosen/ibm,scan-log-data property exists. 15 * 16 * This driver exports /proc/ppc64/scan-log-dump which can be read. 17 * The driver supports only sequential reads. 18 * 19 * The driver looks at a write to the driver for the single word "reset". 20 * If given, the driver will reset the scanlog so the platform can free it. 21 */ 22 23#include <linux/module.h> 24#include <linux/types.h> 25#include <linux/errno.h> 26#include <linux/proc_fs.h> 27#include <linux/init.h> 28#include <linux/delay.h> 29#include <asm/uaccess.h> 30#include <asm/rtas.h> 31#include <asm/prom.h> 32 33#define MODULE_VERS "1.0" 34#define MODULE_NAME "scanlog" 35 36/* Status returns from ibm,scan-log-dump */ 37#define SCANLOG_COMPLETE 0 38#define SCANLOG_HWERROR -1 39#define SCANLOG_CONTINUE 1 40 41#define DEBUG(A...) do { if (scanlog_debug) printk(KERN_ERR "scanlog: " A); } while (0) 42 43static int scanlog_debug; 44static unsigned int ibm_scan_log_dump; /* RTAS token */ 45static struct proc_dir_entry *proc_ppc64_scan_log_dump; /* The proc file */ 46 47static ssize_t scanlog_read(struct file *file, char __user *buf, 48 size_t count, loff_t *ppos) 49{ 50 struct inode * inode = file->f_path.dentry->d_inode; 51 struct proc_dir_entry *dp; 52 unsigned int *data; 53 int status; 54 unsigned long len, off; 55 unsigned int wait_time; 56 57 dp = PDE(inode); 58 data = (unsigned int *)dp->data; 59 60 if (!data) { 61 printk(KERN_ERR "scanlog: read failed no data\n"); 62 return -EIO; 63 } 64 65 if (count > RTAS_DATA_BUF_SIZE) 66 count = RTAS_DATA_BUF_SIZE; 67 68 if (count < 1024) { 69 /* This is the min supported by this RTAS call. Rather 70 * than do all the buffering we insist the user code handle 71 * larger reads. As long as cp works... :) 72 */ 73 printk(KERN_ERR "scanlog: cannot perform a small read (%ld)\n", count); 74 return -EINVAL; 75 } 76 77 if (!access_ok(VERIFY_WRITE, buf, count)) 78 return -EFAULT; 79 80 for (;;) { 81 wait_time = 500; /* default wait if no data */ 82 spin_lock(&rtas_data_buf_lock); 83 memcpy(rtas_data_buf, data, RTAS_DATA_BUF_SIZE); 84 status = rtas_call(ibm_scan_log_dump, 2, 1, NULL, 85 (u32) __pa(rtas_data_buf), (u32) count); 86 memcpy(data, rtas_data_buf, RTAS_DATA_BUF_SIZE); 87 spin_unlock(&rtas_data_buf_lock); 88 89 DEBUG("status=%d, data[0]=%x, data[1]=%x, data[2]=%x\n", 90 status, data[0], data[1], data[2]); 91 switch (status) { 92 case SCANLOG_COMPLETE: 93 DEBUG("hit eof\n"); 94 return 0; 95 case SCANLOG_HWERROR: 96 DEBUG("hardware error reading scan log data\n"); 97 return -EIO; 98 case SCANLOG_CONTINUE: 99 /* We may or may not have data yet */ 100 len = data[1]; 101 off = data[2]; 102 if (len > 0) { 103 if (copy_to_user(buf, ((char *)data)+off, len)) 104 return -EFAULT; 105 return len; 106 } 107 /* Break to sleep default time */ 108 break; 109 default: 110 /* Assume extended busy */ 111 wait_time = rtas_busy_delay_time(status); 112 if (!wait_time) { 113 printk(KERN_ERR "scanlog: unknown error from rtas: %d\n", status); 114 return -EIO; 115 } 116 } 117 /* Apparently no data yet. Wait and try again. */ 118 msleep_interruptible(wait_time); 119 } 120 /*NOTREACHED*/ 121} 122 123static ssize_t scanlog_write(struct file * file, const char __user * buf, 124 size_t count, loff_t *ppos) 125{ 126 char stkbuf[20]; 127 int status; 128 129 if (count > 19) count = 19; 130 if (copy_from_user (stkbuf, buf, count)) { 131 return -EFAULT; 132 } 133 stkbuf[count] = 0; 134 135 if (buf) { 136 if (strncmp(stkbuf, "reset", 5) == 0) { 137 DEBUG("reset scanlog\n"); 138 status = rtas_call(ibm_scan_log_dump, 2, 1, NULL, 0, 0); 139 DEBUG("rtas returns %d\n", status); 140 } else if (strncmp(stkbuf, "debugon", 7) == 0) { 141 printk(KERN_ERR "scanlog: debug on\n"); 142 scanlog_debug = 1; 143 } else if (strncmp(stkbuf, "debugoff", 8) == 0) { 144 printk(KERN_ERR "scanlog: debug off\n"); 145 scanlog_debug = 0; 146 } 147 } 148 return count; 149} 150 151static int scanlog_open(struct inode * inode, struct file * file) 152{ 153 struct proc_dir_entry *dp = PDE(inode); 154 unsigned int *data = (unsigned int *)dp->data; 155 156 if (!data) { 157 printk(KERN_ERR "scanlog: open failed no data\n"); 158 return -EIO; 159 } 160 161 if (data[0] != 0) { 162 /* This imperfect test stops a second copy of the 163 * data (or a reset while data is being copied) 164 */ 165 return -EBUSY; 166 } 167 168 data[0] = 0; /* re-init so we restart the scan */ 169 170 return 0; 171} 172 173static int scanlog_release(struct inode * inode, struct file * file) 174{ 175 struct proc_dir_entry *dp = PDE(inode); 176 unsigned int *data = (unsigned int *)dp->data; 177 178 if (!data) { 179 printk(KERN_ERR "scanlog: release failed no data\n"); 180 return -EIO; 181 } 182 data[0] = 0; 183 184 return 0; 185} 186 187const struct file_operations scanlog_fops = { 188 .owner = THIS_MODULE, 189 .read = scanlog_read, 190 .write = scanlog_write, 191 .open = scanlog_open, 192 .release = scanlog_release, 193}; 194 195static int __init scanlog_init(void) 196{ 197 struct proc_dir_entry *ent; 198 199 ibm_scan_log_dump = rtas_token("ibm,scan-log-dump"); 200 if (ibm_scan_log_dump == RTAS_UNKNOWN_SERVICE) { 201 printk(KERN_ERR "scan-log-dump not implemented on this system\n"); 202 return -EIO; 203 } 204 205 ent = create_proc_entry("ppc64/rtas/scan-log-dump", S_IRUSR, NULL); 206 if (ent) { 207 ent->proc_fops = &scanlog_fops; 208 /* Ideally we could allocate a buffer < 4G */ 209 ent->data = kmalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL); 210 if (!ent->data) { 211 printk(KERN_ERR "Failed to allocate a buffer\n"); 212 remove_proc_entry("scan-log-dump", ent->parent); 213 return -ENOMEM; 214 } 215 ((unsigned int *)ent->data)[0] = 0; 216 } else { 217 printk(KERN_ERR "Failed to create ppc64/scan-log-dump proc entry\n"); 218 return -EIO; 219 } 220 proc_ppc64_scan_log_dump = ent; 221 222 return 0; 223} 224 225static void __exit scanlog_cleanup(void) 226{ 227 if (proc_ppc64_scan_log_dump) { 228 kfree(proc_ppc64_scan_log_dump->data); 229 remove_proc_entry("scan-log-dump", proc_ppc64_scan_log_dump->parent); 230 } 231} 232 233module_init(scanlog_init); 234module_exit(scanlog_cleanup); 235MODULE_LICENSE("GPL"); 236