1 /* 2 * Persistent Storage - platform driver interface parts. 3 * 4 * Copyright (C) 2007-2008 Google, Inc. 5 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/atomic.h> 22 #include <linux/types.h> 23 #include <linux/errno.h> 24 #include <linux/init.h> 25 #include <linux/kmsg_dump.h> 26 #include <linux/console.h> 27 #include <linux/module.h> 28 #include <linux/pstore.h> 29 #include <linux/string.h> 30 #include <linux/timer.h> 31 #include <linux/slab.h> 32 #include <linux/uaccess.h> 33 #include <linux/hardirq.h> 34 #include <linux/jiffies.h> 35 #include <linux/workqueue.h> 36 37 #include "internal.h" 38 39 /* 40 * We defer making "oops" entries appear in pstore - see 41 * whether the system is actually still running well enough 42 * to let someone see the entry 43 */ 44 static int pstore_update_ms = -1; 45 module_param_named(update_ms, pstore_update_ms, int, 0600); 46 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content " 47 "(default is -1, which means runtime updates are disabled; " 48 "enabling this option is not safe, it may lead to further " 49 "corruption on Oopses)"); 50 51 static int pstore_new_entry; 52 53 static void pstore_timefunc(unsigned long); 54 static DEFINE_TIMER(pstore_timer, pstore_timefunc, 0, 0); 55 56 static void pstore_dowork(struct work_struct *); 57 static DECLARE_WORK(pstore_work, pstore_dowork); 58 59 /* 60 * pstore_lock just protects "psinfo" during 61 * calls to pstore_register() 62 */ 63 static DEFINE_SPINLOCK(pstore_lock); 64 struct pstore_info *psinfo; 65 66 static char *backend; 67 68 /* How much of the console log to snapshot */ 69 static unsigned long kmsg_bytes = 10240; 70 71 void pstore_set_kmsg_bytes(int bytes) 72 { 73 kmsg_bytes = bytes; 74 } 75 76 /* Tag each group of saved records with a sequence number */ 77 static int oopscount; 78 79 static const char *get_reason_str(enum kmsg_dump_reason reason) 80 { 81 switch (reason) { 82 case KMSG_DUMP_PANIC: 83 return "Panic"; 84 case KMSG_DUMP_OOPS: 85 return "Oops"; 86 case KMSG_DUMP_EMERG: 87 return "Emergency"; 88 case KMSG_DUMP_RESTART: 89 return "Restart"; 90 case KMSG_DUMP_HALT: 91 return "Halt"; 92 case KMSG_DUMP_POWEROFF: 93 return "Poweroff"; 94 default: 95 return "Unknown"; 96 } 97 } 98 99 /* 100 * callback from kmsg_dump. (s2,l2) has the most recently 101 * written bytes, older bytes are in (s1,l1). Save as much 102 * as we can from the end of the buffer. 103 */ 104 static void pstore_dump(struct kmsg_dumper *dumper, 105 enum kmsg_dump_reason reason) 106 { 107 unsigned long total = 0; 108 const char *why; 109 u64 id; 110 unsigned int part = 1; 111 unsigned long flags = 0; 112 int is_locked = 0; 113 int ret; 114 115 why = get_reason_str(reason); 116 117 if (in_nmi()) { 118 is_locked = spin_trylock(&psinfo->buf_lock); 119 if (!is_locked) 120 pr_err("pstore dump routine blocked in NMI, may corrupt error record\n"); 121 } else 122 spin_lock_irqsave(&psinfo->buf_lock, flags); 123 oopscount++; 124 while (total < kmsg_bytes) { 125 char *dst; 126 unsigned long size; 127 int hsize; 128 size_t len; 129 130 dst = psinfo->buf; 131 hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part); 132 size = psinfo->bufsize - hsize; 133 dst += hsize; 134 135 if (!kmsg_dump_get_buffer(dumper, true, dst, size, &len)) 136 break; 137 138 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 139 hsize + len, psinfo); 140 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 141 pstore_new_entry = 1; 142 143 total += hsize + len; 144 part++; 145 } 146 if (in_nmi()) { 147 if (is_locked) 148 spin_unlock(&psinfo->buf_lock); 149 } else 150 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 151 } 152 153 static struct kmsg_dumper pstore_dumper = { 154 .dump = pstore_dump, 155 }; 156 157 #ifdef CONFIG_PSTORE_CONSOLE 158 static void pstore_console_write(struct console *con, const char *s, unsigned c) 159 { 160 const char *e = s + c; 161 162 while (s < e) { 163 unsigned long flags; 164 165 if (c > psinfo->bufsize) 166 c = psinfo->bufsize; 167 spin_lock_irqsave(&psinfo->buf_lock, flags); 168 memcpy(psinfo->buf, s, c); 169 psinfo->write(PSTORE_TYPE_CONSOLE, 0, NULL, 0, c, psinfo); 170 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 171 s += c; 172 c = e - s; 173 } 174 } 175 176 static struct console pstore_console = { 177 .name = "pstore", 178 .write = pstore_console_write, 179 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 180 .index = -1, 181 }; 182 183 static void pstore_register_console(void) 184 { 185 register_console(&pstore_console); 186 } 187 #else 188 static void pstore_register_console(void) {} 189 #endif 190 191 static int pstore_write_compat(enum pstore_type_id type, 192 enum kmsg_dump_reason reason, 193 u64 *id, unsigned int part, 194 size_t size, struct pstore_info *psi) 195 { 196 return psi->write_buf(type, reason, id, part, psinfo->buf, size, psi); 197 } 198 199 /* 200 * platform specific persistent storage driver registers with 201 * us here. If pstore is already mounted, call the platform 202 * read function right away to populate the file system. If not 203 * then the pstore mount code will call us later to fill out 204 * the file system. 205 * 206 * Register with kmsg_dump to save last part of console log on panic. 207 */ 208 int pstore_register(struct pstore_info *psi) 209 { 210 struct module *owner = psi->owner; 211 212 spin_lock(&pstore_lock); 213 if (psinfo) { 214 spin_unlock(&pstore_lock); 215 return -EBUSY; 216 } 217 218 if (backend && strcmp(backend, psi->name)) { 219 spin_unlock(&pstore_lock); 220 return -EINVAL; 221 } 222 223 if (!psi->write) 224 psi->write = pstore_write_compat; 225 psinfo = psi; 226 mutex_init(&psinfo->read_mutex); 227 spin_unlock(&pstore_lock); 228 229 if (owner && !try_module_get(owner)) { 230 psinfo = NULL; 231 return -EINVAL; 232 } 233 234 if (pstore_is_mounted()) 235 pstore_get_records(0); 236 237 kmsg_dump_register(&pstore_dumper); 238 pstore_register_console(); 239 240 if (pstore_update_ms >= 0) { 241 pstore_timer.expires = jiffies + 242 msecs_to_jiffies(pstore_update_ms); 243 add_timer(&pstore_timer); 244 } 245 246 return 0; 247 } 248 EXPORT_SYMBOL_GPL(pstore_register); 249 250 /* 251 * Read all the records from the persistent store. Create 252 * files in our filesystem. Don't warn about -EEXIST errors 253 * when we are re-scanning the backing store looking to add new 254 * error records. 255 */ 256 void pstore_get_records(int quiet) 257 { 258 struct pstore_info *psi = psinfo; 259 char *buf = NULL; 260 ssize_t size; 261 u64 id; 262 enum pstore_type_id type; 263 struct timespec time; 264 int failed = 0, rc; 265 266 if (!psi) 267 return; 268 269 mutex_lock(&psi->read_mutex); 270 if (psi->open && psi->open(psi)) 271 goto out; 272 273 while ((size = psi->read(&id, &type, &time, &buf, psi)) > 0) { 274 rc = pstore_mkfile(type, psi->name, id, buf, (size_t)size, 275 time, psi); 276 kfree(buf); 277 buf = NULL; 278 if (rc && (rc != -EEXIST || !quiet)) 279 failed++; 280 } 281 if (psi->close) 282 psi->close(psi); 283 out: 284 mutex_unlock(&psi->read_mutex); 285 286 if (failed) 287 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 288 failed, psi->name); 289 } 290 291 static void pstore_dowork(struct work_struct *work) 292 { 293 pstore_get_records(1); 294 } 295 296 static void pstore_timefunc(unsigned long dummy) 297 { 298 if (pstore_new_entry) { 299 pstore_new_entry = 0; 300 schedule_work(&pstore_work); 301 } 302 303 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 304 } 305 306 module_param(backend, charp, 0444); 307 MODULE_PARM_DESC(backend, "Pstore backend to use"); 308