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 #define pr_fmt(fmt) "pstore: " fmt 22 23 #include <linux/atomic.h> 24 #include <linux/types.h> 25 #include <linux/errno.h> 26 #include <linux/init.h> 27 #include <linux/kmsg_dump.h> 28 #include <linux/console.h> 29 #include <linux/module.h> 30 #include <linux/pstore.h> 31 #include <linux/zlib.h> 32 #include <linux/string.h> 33 #include <linux/timer.h> 34 #include <linux/slab.h> 35 #include <linux/uaccess.h> 36 #include <linux/hardirq.h> 37 #include <linux/jiffies.h> 38 #include <linux/workqueue.h> 39 40 #include "internal.h" 41 42 /* 43 * We defer making "oops" entries appear in pstore - see 44 * whether the system is actually still running well enough 45 * to let someone see the entry 46 */ 47 static int pstore_update_ms = -1; 48 module_param_named(update_ms, pstore_update_ms, int, 0600); 49 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content " 50 "(default is -1, which means runtime updates are disabled; " 51 "enabling this option is not safe, it may lead to further " 52 "corruption on Oopses)"); 53 54 static int pstore_new_entry; 55 56 static void pstore_timefunc(unsigned long); 57 static DEFINE_TIMER(pstore_timer, pstore_timefunc, 0, 0); 58 59 static void pstore_dowork(struct work_struct *); 60 static DECLARE_WORK(pstore_work, pstore_dowork); 61 62 /* 63 * pstore_lock just protects "psinfo" during 64 * calls to pstore_register() 65 */ 66 static DEFINE_SPINLOCK(pstore_lock); 67 struct pstore_info *psinfo; 68 69 static char *backend; 70 71 /* Compression parameters */ 72 #define COMPR_LEVEL 6 73 #define WINDOW_BITS 12 74 #define MEM_LEVEL 4 75 static struct z_stream_s stream; 76 77 static char *big_oops_buf; 78 static size_t big_oops_buf_sz; 79 80 /* How much of the console log to snapshot */ 81 static unsigned long kmsg_bytes = 10240; 82 83 void pstore_set_kmsg_bytes(int bytes) 84 { 85 kmsg_bytes = bytes; 86 } 87 88 /* Tag each group of saved records with a sequence number */ 89 static int oopscount; 90 91 static const char *get_reason_str(enum kmsg_dump_reason reason) 92 { 93 switch (reason) { 94 case KMSG_DUMP_PANIC: 95 return "Panic"; 96 case KMSG_DUMP_OOPS: 97 return "Oops"; 98 case KMSG_DUMP_EMERG: 99 return "Emergency"; 100 case KMSG_DUMP_RESTART: 101 return "Restart"; 102 case KMSG_DUMP_HALT: 103 return "Halt"; 104 case KMSG_DUMP_POWEROFF: 105 return "Poweroff"; 106 default: 107 return "Unknown"; 108 } 109 } 110 111 bool pstore_cannot_block_path(enum kmsg_dump_reason reason) 112 { 113 /* 114 * In case of NMI path, pstore shouldn't be blocked 115 * regardless of reason. 116 */ 117 if (in_nmi()) 118 return true; 119 120 switch (reason) { 121 /* In panic case, other cpus are stopped by smp_send_stop(). */ 122 case KMSG_DUMP_PANIC: 123 /* Emergency restart shouldn't be blocked by spin lock. */ 124 case KMSG_DUMP_EMERG: 125 return true; 126 default: 127 return false; 128 } 129 } 130 EXPORT_SYMBOL_GPL(pstore_cannot_block_path); 131 132 /* Derived from logfs_compress() */ 133 static int pstore_compress(const void *in, void *out, size_t inlen, 134 size_t outlen) 135 { 136 int err, ret; 137 138 ret = -EIO; 139 err = zlib_deflateInit2(&stream, COMPR_LEVEL, Z_DEFLATED, WINDOW_BITS, 140 MEM_LEVEL, Z_DEFAULT_STRATEGY); 141 if (err != Z_OK) 142 goto error; 143 144 stream.next_in = in; 145 stream.avail_in = inlen; 146 stream.total_in = 0; 147 stream.next_out = out; 148 stream.avail_out = outlen; 149 stream.total_out = 0; 150 151 err = zlib_deflate(&stream, Z_FINISH); 152 if (err != Z_STREAM_END) 153 goto error; 154 155 err = zlib_deflateEnd(&stream); 156 if (err != Z_OK) 157 goto error; 158 159 if (stream.total_out >= stream.total_in) 160 goto error; 161 162 ret = stream.total_out; 163 error: 164 return ret; 165 } 166 167 /* Derived from logfs_uncompress */ 168 static int pstore_decompress(void *in, void *out, size_t inlen, size_t outlen) 169 { 170 int err, ret; 171 172 ret = -EIO; 173 err = zlib_inflateInit2(&stream, WINDOW_BITS); 174 if (err != Z_OK) 175 goto error; 176 177 stream.next_in = in; 178 stream.avail_in = inlen; 179 stream.total_in = 0; 180 stream.next_out = out; 181 stream.avail_out = outlen; 182 stream.total_out = 0; 183 184 err = zlib_inflate(&stream, Z_FINISH); 185 if (err != Z_STREAM_END) 186 goto error; 187 188 err = zlib_inflateEnd(&stream); 189 if (err != Z_OK) 190 goto error; 191 192 ret = stream.total_out; 193 error: 194 return ret; 195 } 196 197 static void allocate_buf_for_compression(void) 198 { 199 size_t size; 200 size_t cmpr; 201 202 switch (psinfo->bufsize) { 203 /* buffer range for efivars */ 204 case 1000 ... 2000: 205 cmpr = 56; 206 break; 207 case 2001 ... 3000: 208 cmpr = 54; 209 break; 210 case 3001 ... 3999: 211 cmpr = 52; 212 break; 213 /* buffer range for nvram, erst */ 214 case 4000 ... 10000: 215 cmpr = 45; 216 break; 217 default: 218 cmpr = 60; 219 break; 220 } 221 222 big_oops_buf_sz = (psinfo->bufsize * 100) / cmpr; 223 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 224 if (big_oops_buf) { 225 size = max(zlib_deflate_workspacesize(WINDOW_BITS, MEM_LEVEL), 226 zlib_inflate_workspacesize()); 227 stream.workspace = kmalloc(size, GFP_KERNEL); 228 if (!stream.workspace) { 229 pr_err("No memory for compression workspace; skipping compression\n"); 230 kfree(big_oops_buf); 231 big_oops_buf = NULL; 232 } 233 } else { 234 pr_err("No memory for uncompressed data; skipping compression\n"); 235 stream.workspace = NULL; 236 } 237 238 } 239 240 /* 241 * Called when compression fails, since the printk buffer 242 * would be fetched for compression calling it again when 243 * compression fails would have moved the iterator of 244 * printk buffer which results in fetching old contents. 245 * Copy the recent messages from big_oops_buf to psinfo->buf 246 */ 247 static size_t copy_kmsg_to_buffer(int hsize, size_t len) 248 { 249 size_t total_len; 250 size_t diff; 251 252 total_len = hsize + len; 253 254 if (total_len > psinfo->bufsize) { 255 diff = total_len - psinfo->bufsize + hsize; 256 memcpy(psinfo->buf, big_oops_buf, hsize); 257 memcpy(psinfo->buf + hsize, big_oops_buf + diff, 258 psinfo->bufsize - hsize); 259 total_len = psinfo->bufsize; 260 } else 261 memcpy(psinfo->buf, big_oops_buf, total_len); 262 263 return total_len; 264 } 265 266 /* 267 * callback from kmsg_dump. (s2,l2) has the most recently 268 * written bytes, older bytes are in (s1,l1). Save as much 269 * as we can from the end of the buffer. 270 */ 271 static void pstore_dump(struct kmsg_dumper *dumper, 272 enum kmsg_dump_reason reason) 273 { 274 unsigned long total = 0; 275 const char *why; 276 u64 id; 277 unsigned int part = 1; 278 unsigned long flags = 0; 279 int is_locked = 0; 280 int ret; 281 282 why = get_reason_str(reason); 283 284 if (pstore_cannot_block_path(reason)) { 285 is_locked = spin_trylock_irqsave(&psinfo->buf_lock, flags); 286 if (!is_locked) { 287 pr_err("pstore dump routine blocked in %s path, may corrupt error record\n" 288 , in_nmi() ? "NMI" : why); 289 } 290 } else 291 spin_lock_irqsave(&psinfo->buf_lock, flags); 292 oopscount++; 293 while (total < kmsg_bytes) { 294 char *dst; 295 unsigned long size; 296 int hsize; 297 int zipped_len = -1; 298 size_t len; 299 bool compressed; 300 size_t total_len; 301 302 if (big_oops_buf) { 303 dst = big_oops_buf; 304 hsize = sprintf(dst, "%s#%d Part%u\n", why, 305 oopscount, part); 306 size = big_oops_buf_sz - hsize; 307 308 if (!kmsg_dump_get_buffer(dumper, true, dst + hsize, 309 size, &len)) 310 break; 311 312 zipped_len = pstore_compress(dst, psinfo->buf, 313 hsize + len, psinfo->bufsize); 314 315 if (zipped_len > 0) { 316 compressed = true; 317 total_len = zipped_len; 318 } else { 319 compressed = false; 320 total_len = copy_kmsg_to_buffer(hsize, len); 321 } 322 } else { 323 dst = psinfo->buf; 324 hsize = sprintf(dst, "%s#%d Part%u\n", why, oopscount, 325 part); 326 size = psinfo->bufsize - hsize; 327 dst += hsize; 328 329 if (!kmsg_dump_get_buffer(dumper, true, dst, 330 size, &len)) 331 break; 332 333 compressed = false; 334 total_len = hsize + len; 335 } 336 337 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 338 oopscount, compressed, total_len, psinfo); 339 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 340 pstore_new_entry = 1; 341 342 total += total_len; 343 part++; 344 } 345 if (pstore_cannot_block_path(reason)) { 346 if (is_locked) 347 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 348 } else 349 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 350 } 351 352 static struct kmsg_dumper pstore_dumper = { 353 .dump = pstore_dump, 354 }; 355 356 #ifdef CONFIG_PSTORE_CONSOLE 357 static void pstore_console_write(struct console *con, const char *s, unsigned c) 358 { 359 const char *e = s + c; 360 361 while (s < e) { 362 unsigned long flags; 363 u64 id; 364 365 if (c > psinfo->bufsize) 366 c = psinfo->bufsize; 367 368 if (oops_in_progress) { 369 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) 370 break; 371 } else { 372 spin_lock_irqsave(&psinfo->buf_lock, flags); 373 } 374 memcpy(psinfo->buf, s, c); 375 psinfo->write(PSTORE_TYPE_CONSOLE, 0, &id, 0, 0, 0, c, psinfo); 376 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 377 s += c; 378 c = e - s; 379 } 380 } 381 382 static struct console pstore_console = { 383 .name = "pstore", 384 .write = pstore_console_write, 385 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 386 .index = -1, 387 }; 388 389 static void pstore_register_console(void) 390 { 391 register_console(&pstore_console); 392 } 393 #else 394 static void pstore_register_console(void) {} 395 #endif 396 397 static int pstore_write_compat(enum pstore_type_id type, 398 enum kmsg_dump_reason reason, 399 u64 *id, unsigned int part, int count, 400 bool compressed, size_t size, 401 struct pstore_info *psi) 402 { 403 return psi->write_buf(type, reason, id, part, psinfo->buf, compressed, 404 size, psi); 405 } 406 407 /* 408 * platform specific persistent storage driver registers with 409 * us here. If pstore is already mounted, call the platform 410 * read function right away to populate the file system. If not 411 * then the pstore mount code will call us later to fill out 412 * the file system. 413 * 414 * Register with kmsg_dump to save last part of console log on panic. 415 */ 416 int pstore_register(struct pstore_info *psi) 417 { 418 struct module *owner = psi->owner; 419 420 if (backend && strcmp(backend, psi->name)) 421 return -EPERM; 422 423 spin_lock(&pstore_lock); 424 if (psinfo) { 425 spin_unlock(&pstore_lock); 426 return -EBUSY; 427 } 428 429 if (!psi->write) 430 psi->write = pstore_write_compat; 431 psinfo = psi; 432 mutex_init(&psinfo->read_mutex); 433 spin_unlock(&pstore_lock); 434 435 if (owner && !try_module_get(owner)) { 436 psinfo = NULL; 437 return -EINVAL; 438 } 439 440 allocate_buf_for_compression(); 441 442 if (pstore_is_mounted()) 443 pstore_get_records(0); 444 445 kmsg_dump_register(&pstore_dumper); 446 447 if ((psi->flags & PSTORE_FLAGS_FRAGILE) == 0) { 448 pstore_register_console(); 449 pstore_register_ftrace(); 450 pstore_register_pmsg(); 451 } 452 453 if (pstore_update_ms >= 0) { 454 pstore_timer.expires = jiffies + 455 msecs_to_jiffies(pstore_update_ms); 456 add_timer(&pstore_timer); 457 } 458 459 pr_info("Registered %s as persistent store backend\n", psi->name); 460 461 return 0; 462 } 463 EXPORT_SYMBOL_GPL(pstore_register); 464 465 /* 466 * Read all the records from the persistent store. Create 467 * files in our filesystem. Don't warn about -EEXIST errors 468 * when we are re-scanning the backing store looking to add new 469 * error records. 470 */ 471 void pstore_get_records(int quiet) 472 { 473 struct pstore_info *psi = psinfo; 474 char *buf = NULL; 475 ssize_t size; 476 u64 id; 477 int count; 478 enum pstore_type_id type; 479 struct timespec time; 480 int failed = 0, rc; 481 bool compressed; 482 int unzipped_len = -1; 483 484 if (!psi) 485 return; 486 487 mutex_lock(&psi->read_mutex); 488 if (psi->open && psi->open(psi)) 489 goto out; 490 491 while ((size = psi->read(&id, &type, &count, &time, &buf, &compressed, 492 psi)) > 0) { 493 if (compressed && (type == PSTORE_TYPE_DMESG)) { 494 if (big_oops_buf) 495 unzipped_len = pstore_decompress(buf, 496 big_oops_buf, size, 497 big_oops_buf_sz); 498 499 if (unzipped_len > 0) { 500 kfree(buf); 501 buf = big_oops_buf; 502 size = unzipped_len; 503 compressed = false; 504 } else { 505 pr_err("decompression failed;returned %d\n", 506 unzipped_len); 507 compressed = true; 508 } 509 } 510 rc = pstore_mkfile(type, psi->name, id, count, buf, 511 compressed, (size_t)size, time, psi); 512 if (unzipped_len < 0) { 513 /* Free buffer other than big oops */ 514 kfree(buf); 515 buf = NULL; 516 } else 517 unzipped_len = -1; 518 if (rc && (rc != -EEXIST || !quiet)) 519 failed++; 520 } 521 if (psi->close) 522 psi->close(psi); 523 out: 524 mutex_unlock(&psi->read_mutex); 525 526 if (failed) 527 pr_warn("failed to load %d record(s) from '%s'\n", 528 failed, psi->name); 529 } 530 531 static void pstore_dowork(struct work_struct *work) 532 { 533 pstore_get_records(1); 534 } 535 536 static void pstore_timefunc(unsigned long dummy) 537 { 538 if (pstore_new_entry) { 539 pstore_new_entry = 0; 540 schedule_work(&pstore_work); 541 } 542 543 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 544 } 545 546 module_param(backend, charp, 0444); 547 MODULE_PARM_DESC(backend, "Pstore backend to use"); 548