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 #ifdef CONFIG_PSTORE_ZLIB_COMPRESS 32 #include <linux/zlib.h> 33 #endif 34 #ifdef CONFIG_PSTORE_LZO_COMPRESS 35 #include <linux/lzo.h> 36 #endif 37 #ifdef CONFIG_PSTORE_LZ4_COMPRESS 38 #include <linux/lz4.h> 39 #endif 40 #include <linux/string.h> 41 #include <linux/timer.h> 42 #include <linux/slab.h> 43 #include <linux/uaccess.h> 44 #include <linux/hardirq.h> 45 #include <linux/jiffies.h> 46 #include <linux/workqueue.h> 47 48 #include "internal.h" 49 50 /* 51 * We defer making "oops" entries appear in pstore - see 52 * whether the system is actually still running well enough 53 * to let someone see the entry 54 */ 55 static int pstore_update_ms = -1; 56 module_param_named(update_ms, pstore_update_ms, int, 0600); 57 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content " 58 "(default is -1, which means runtime updates are disabled; " 59 "enabling this option is not safe, it may lead to further " 60 "corruption on Oopses)"); 61 62 static int pstore_new_entry; 63 64 static void pstore_timefunc(unsigned long); 65 static DEFINE_TIMER(pstore_timer, pstore_timefunc, 0, 0); 66 67 static void pstore_dowork(struct work_struct *); 68 static DECLARE_WORK(pstore_work, pstore_dowork); 69 70 /* 71 * pstore_lock just protects "psinfo" during 72 * calls to pstore_register() 73 */ 74 static DEFINE_SPINLOCK(pstore_lock); 75 struct pstore_info *psinfo; 76 77 static char *backend; 78 79 /* Compression parameters */ 80 #ifdef CONFIG_PSTORE_ZLIB_COMPRESS 81 #define COMPR_LEVEL 6 82 #define WINDOW_BITS 12 83 #define MEM_LEVEL 4 84 static struct z_stream_s stream; 85 #else 86 static unsigned char *workspace; 87 #endif 88 89 struct pstore_zbackend { 90 int (*compress)(const void *in, void *out, size_t inlen, size_t outlen); 91 int (*decompress)(void *in, void *out, size_t inlen, size_t outlen); 92 void (*allocate)(void); 93 void (*free)(void); 94 95 const char *name; 96 }; 97 98 static char *big_oops_buf; 99 static size_t big_oops_buf_sz; 100 101 /* How much of the console log to snapshot */ 102 static unsigned long kmsg_bytes = 10240; 103 104 void pstore_set_kmsg_bytes(int bytes) 105 { 106 kmsg_bytes = bytes; 107 } 108 109 /* Tag each group of saved records with a sequence number */ 110 static int oopscount; 111 112 static const char *get_reason_str(enum kmsg_dump_reason reason) 113 { 114 switch (reason) { 115 case KMSG_DUMP_PANIC: 116 return "Panic"; 117 case KMSG_DUMP_OOPS: 118 return "Oops"; 119 case KMSG_DUMP_EMERG: 120 return "Emergency"; 121 case KMSG_DUMP_RESTART: 122 return "Restart"; 123 case KMSG_DUMP_HALT: 124 return "Halt"; 125 case KMSG_DUMP_POWEROFF: 126 return "Poweroff"; 127 default: 128 return "Unknown"; 129 } 130 } 131 132 bool pstore_cannot_block_path(enum kmsg_dump_reason reason) 133 { 134 /* 135 * In case of NMI path, pstore shouldn't be blocked 136 * regardless of reason. 137 */ 138 if (in_nmi()) 139 return true; 140 141 switch (reason) { 142 /* In panic case, other cpus are stopped by smp_send_stop(). */ 143 case KMSG_DUMP_PANIC: 144 /* Emergency restart shouldn't be blocked by spin lock. */ 145 case KMSG_DUMP_EMERG: 146 return true; 147 default: 148 return false; 149 } 150 } 151 EXPORT_SYMBOL_GPL(pstore_cannot_block_path); 152 153 #ifdef CONFIG_PSTORE_ZLIB_COMPRESS 154 /* Derived from logfs_compress() */ 155 static int compress_zlib(const void *in, void *out, size_t inlen, size_t outlen) 156 { 157 int err, ret; 158 159 ret = -EIO; 160 err = zlib_deflateInit2(&stream, COMPR_LEVEL, Z_DEFLATED, WINDOW_BITS, 161 MEM_LEVEL, Z_DEFAULT_STRATEGY); 162 if (err != Z_OK) 163 goto error; 164 165 stream.next_in = in; 166 stream.avail_in = inlen; 167 stream.total_in = 0; 168 stream.next_out = out; 169 stream.avail_out = outlen; 170 stream.total_out = 0; 171 172 err = zlib_deflate(&stream, Z_FINISH); 173 if (err != Z_STREAM_END) 174 goto error; 175 176 err = zlib_deflateEnd(&stream); 177 if (err != Z_OK) 178 goto error; 179 180 if (stream.total_out >= stream.total_in) 181 goto error; 182 183 ret = stream.total_out; 184 error: 185 return ret; 186 } 187 188 /* Derived from logfs_uncompress */ 189 static int decompress_zlib(void *in, void *out, size_t inlen, size_t outlen) 190 { 191 int err, ret; 192 193 ret = -EIO; 194 err = zlib_inflateInit2(&stream, WINDOW_BITS); 195 if (err != Z_OK) 196 goto error; 197 198 stream.next_in = in; 199 stream.avail_in = inlen; 200 stream.total_in = 0; 201 stream.next_out = out; 202 stream.avail_out = outlen; 203 stream.total_out = 0; 204 205 err = zlib_inflate(&stream, Z_FINISH); 206 if (err != Z_STREAM_END) 207 goto error; 208 209 err = zlib_inflateEnd(&stream); 210 if (err != Z_OK) 211 goto error; 212 213 ret = stream.total_out; 214 error: 215 return ret; 216 } 217 218 static void allocate_zlib(void) 219 { 220 size_t size; 221 size_t cmpr; 222 223 switch (psinfo->bufsize) { 224 /* buffer range for efivars */ 225 case 1000 ... 2000: 226 cmpr = 56; 227 break; 228 case 2001 ... 3000: 229 cmpr = 54; 230 break; 231 case 3001 ... 3999: 232 cmpr = 52; 233 break; 234 /* buffer range for nvram, erst */ 235 case 4000 ... 10000: 236 cmpr = 45; 237 break; 238 default: 239 cmpr = 60; 240 break; 241 } 242 243 big_oops_buf_sz = (psinfo->bufsize * 100) / cmpr; 244 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 245 if (big_oops_buf) { 246 size = max(zlib_deflate_workspacesize(WINDOW_BITS, MEM_LEVEL), 247 zlib_inflate_workspacesize()); 248 stream.workspace = kmalloc(size, GFP_KERNEL); 249 if (!stream.workspace) { 250 pr_err("No memory for compression workspace; skipping compression\n"); 251 kfree(big_oops_buf); 252 big_oops_buf = NULL; 253 } 254 } else { 255 pr_err("No memory for uncompressed data; skipping compression\n"); 256 stream.workspace = NULL; 257 } 258 259 } 260 261 static void free_zlib(void) 262 { 263 kfree(stream.workspace); 264 stream.workspace = NULL; 265 kfree(big_oops_buf); 266 big_oops_buf = NULL; 267 big_oops_buf_sz = 0; 268 } 269 270 static struct pstore_zbackend backend_zlib = { 271 .compress = compress_zlib, 272 .decompress = decompress_zlib, 273 .allocate = allocate_zlib, 274 .free = free_zlib, 275 .name = "zlib", 276 }; 277 #endif 278 279 #ifdef CONFIG_PSTORE_LZO_COMPRESS 280 static int compress_lzo(const void *in, void *out, size_t inlen, size_t outlen) 281 { 282 int ret; 283 284 ret = lzo1x_1_compress(in, inlen, out, &outlen, workspace); 285 if (ret != LZO_E_OK) { 286 pr_err("lzo_compress error, ret = %d!\n", ret); 287 return -EIO; 288 } 289 290 return outlen; 291 } 292 293 static int decompress_lzo(void *in, void *out, size_t inlen, size_t outlen) 294 { 295 int ret; 296 297 ret = lzo1x_decompress_safe(in, inlen, out, &outlen); 298 if (ret != LZO_E_OK) { 299 pr_err("lzo_decompress error, ret = %d!\n", ret); 300 return -EIO; 301 } 302 303 return outlen; 304 } 305 306 static void allocate_lzo(void) 307 { 308 big_oops_buf_sz = lzo1x_worst_compress(psinfo->bufsize); 309 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 310 if (big_oops_buf) { 311 workspace = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL); 312 if (!workspace) { 313 pr_err("No memory for compression workspace; skipping compression\n"); 314 kfree(big_oops_buf); 315 big_oops_buf = NULL; 316 } 317 } else { 318 pr_err("No memory for uncompressed data; skipping compression\n"); 319 workspace = NULL; 320 } 321 } 322 323 static void free_lzo(void) 324 { 325 kfree(workspace); 326 kfree(big_oops_buf); 327 big_oops_buf = NULL; 328 big_oops_buf_sz = 0; 329 } 330 331 static struct pstore_zbackend backend_lzo = { 332 .compress = compress_lzo, 333 .decompress = decompress_lzo, 334 .allocate = allocate_lzo, 335 .free = free_lzo, 336 .name = "lzo", 337 }; 338 #endif 339 340 #ifdef CONFIG_PSTORE_LZ4_COMPRESS 341 static int compress_lz4(const void *in, void *out, size_t inlen, size_t outlen) 342 { 343 int ret; 344 345 ret = lz4_compress(in, inlen, out, &outlen, workspace); 346 if (ret) { 347 pr_err("lz4_compress error, ret = %d!\n", ret); 348 return -EIO; 349 } 350 351 return outlen; 352 } 353 354 static int decompress_lz4(void *in, void *out, size_t inlen, size_t outlen) 355 { 356 int ret; 357 358 ret = lz4_decompress_unknownoutputsize(in, inlen, out, &outlen); 359 if (ret) { 360 pr_err("lz4_decompress error, ret = %d!\n", ret); 361 return -EIO; 362 } 363 364 return outlen; 365 } 366 367 static void allocate_lz4(void) 368 { 369 big_oops_buf_sz = lz4_compressbound(psinfo->bufsize); 370 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 371 if (big_oops_buf) { 372 workspace = kmalloc(LZ4_MEM_COMPRESS, GFP_KERNEL); 373 if (!workspace) { 374 pr_err("No memory for compression workspace; skipping compression\n"); 375 kfree(big_oops_buf); 376 big_oops_buf = NULL; 377 } 378 } else { 379 pr_err("No memory for uncompressed data; skipping compression\n"); 380 workspace = NULL; 381 } 382 } 383 384 static void free_lz4(void) 385 { 386 kfree(workspace); 387 kfree(big_oops_buf); 388 big_oops_buf = NULL; 389 big_oops_buf_sz = 0; 390 } 391 392 static struct pstore_zbackend backend_lz4 = { 393 .compress = compress_lz4, 394 .decompress = decompress_lz4, 395 .allocate = allocate_lz4, 396 .free = free_lz4, 397 .name = "lz4", 398 }; 399 #endif 400 401 static struct pstore_zbackend *zbackend = 402 #if defined(CONFIG_PSTORE_ZLIB_COMPRESS) 403 &backend_zlib; 404 #elif defined(CONFIG_PSTORE_LZO_COMPRESS) 405 &backend_lzo; 406 #elif defined(CONFIG_PSTORE_LZ4_COMPRESS) 407 &backend_lz4; 408 #else 409 NULL; 410 #endif 411 412 static int pstore_compress(const void *in, void *out, 413 size_t inlen, size_t outlen) 414 { 415 if (zbackend) 416 return zbackend->compress(in, out, inlen, outlen); 417 else 418 return -EIO; 419 } 420 421 static int pstore_decompress(void *in, void *out, size_t inlen, size_t outlen) 422 { 423 if (zbackend) 424 return zbackend->decompress(in, out, inlen, outlen); 425 else 426 return -EIO; 427 } 428 429 static void allocate_buf_for_compression(void) 430 { 431 if (zbackend) { 432 pr_info("using %s compression\n", zbackend->name); 433 zbackend->allocate(); 434 } else { 435 pr_err("allocate compression buffer error!\n"); 436 } 437 } 438 439 static void free_buf_for_compression(void) 440 { 441 if (zbackend) 442 zbackend->free(); 443 else 444 pr_err("free compression buffer error!\n"); 445 } 446 447 /* 448 * Called when compression fails, since the printk buffer 449 * would be fetched for compression calling it again when 450 * compression fails would have moved the iterator of 451 * printk buffer which results in fetching old contents. 452 * Copy the recent messages from big_oops_buf to psinfo->buf 453 */ 454 static size_t copy_kmsg_to_buffer(int hsize, size_t len) 455 { 456 size_t total_len; 457 size_t diff; 458 459 total_len = hsize + len; 460 461 if (total_len > psinfo->bufsize) { 462 diff = total_len - psinfo->bufsize + hsize; 463 memcpy(psinfo->buf, big_oops_buf, hsize); 464 memcpy(psinfo->buf + hsize, big_oops_buf + diff, 465 psinfo->bufsize - hsize); 466 total_len = psinfo->bufsize; 467 } else 468 memcpy(psinfo->buf, big_oops_buf, total_len); 469 470 return total_len; 471 } 472 473 /* 474 * callback from kmsg_dump. (s2,l2) has the most recently 475 * written bytes, older bytes are in (s1,l1). Save as much 476 * as we can from the end of the buffer. 477 */ 478 static void pstore_dump(struct kmsg_dumper *dumper, 479 enum kmsg_dump_reason reason) 480 { 481 unsigned long total = 0; 482 const char *why; 483 u64 id; 484 unsigned int part = 1; 485 unsigned long flags = 0; 486 int is_locked; 487 int ret; 488 489 why = get_reason_str(reason); 490 491 if (pstore_cannot_block_path(reason)) { 492 is_locked = spin_trylock_irqsave(&psinfo->buf_lock, flags); 493 if (!is_locked) { 494 pr_err("pstore dump routine blocked in %s path, may corrupt error record\n" 495 , in_nmi() ? "NMI" : why); 496 return; 497 } 498 } else { 499 spin_lock_irqsave(&psinfo->buf_lock, flags); 500 is_locked = 1; 501 } 502 oopscount++; 503 while (total < kmsg_bytes) { 504 char *dst; 505 unsigned long size; 506 int hsize; 507 int zipped_len = -1; 508 size_t len; 509 bool compressed = false; 510 size_t total_len; 511 512 if (big_oops_buf && is_locked) { 513 dst = big_oops_buf; 514 size = big_oops_buf_sz; 515 } else { 516 dst = psinfo->buf; 517 size = psinfo->bufsize; 518 } 519 520 hsize = sprintf(dst, "%s#%d Part%u\n", why, oopscount, part); 521 size -= hsize; 522 523 if (!kmsg_dump_get_buffer(dumper, true, dst + hsize, 524 size, &len)) 525 break; 526 527 if (big_oops_buf && is_locked) { 528 zipped_len = pstore_compress(dst, psinfo->buf, 529 hsize + len, psinfo->bufsize); 530 531 if (zipped_len > 0) { 532 compressed = true; 533 total_len = zipped_len; 534 } else { 535 total_len = copy_kmsg_to_buffer(hsize, len); 536 } 537 } else { 538 total_len = hsize + len; 539 } 540 541 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 542 oopscount, compressed, total_len, psinfo); 543 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 544 pstore_new_entry = 1; 545 546 total += total_len; 547 part++; 548 } 549 if (is_locked) 550 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 551 } 552 553 static struct kmsg_dumper pstore_dumper = { 554 .dump = pstore_dump, 555 }; 556 557 /* 558 * Register with kmsg_dump to save last part of console log on panic. 559 */ 560 static void pstore_register_kmsg(void) 561 { 562 kmsg_dump_register(&pstore_dumper); 563 } 564 565 static void pstore_unregister_kmsg(void) 566 { 567 kmsg_dump_unregister(&pstore_dumper); 568 } 569 570 #ifdef CONFIG_PSTORE_CONSOLE 571 static void pstore_console_write(struct console *con, const char *s, unsigned c) 572 { 573 const char *e = s + c; 574 575 while (s < e) { 576 unsigned long flags; 577 u64 id; 578 579 if (c > psinfo->bufsize) 580 c = psinfo->bufsize; 581 582 if (oops_in_progress) { 583 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) 584 break; 585 } else { 586 spin_lock_irqsave(&psinfo->buf_lock, flags); 587 } 588 psinfo->write_buf(PSTORE_TYPE_CONSOLE, 0, &id, 0, 589 s, 0, c, psinfo); 590 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 591 s += c; 592 c = e - s; 593 } 594 } 595 596 static struct console pstore_console = { 597 .name = "pstore", 598 .write = pstore_console_write, 599 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 600 .index = -1, 601 }; 602 603 static void pstore_register_console(void) 604 { 605 register_console(&pstore_console); 606 } 607 608 static void pstore_unregister_console(void) 609 { 610 unregister_console(&pstore_console); 611 } 612 #else 613 static void pstore_register_console(void) {} 614 static void pstore_unregister_console(void) {} 615 #endif 616 617 static int pstore_write_compat(enum pstore_type_id type, 618 enum kmsg_dump_reason reason, 619 u64 *id, unsigned int part, int count, 620 bool compressed, size_t size, 621 struct pstore_info *psi) 622 { 623 return psi->write_buf(type, reason, id, part, psinfo->buf, compressed, 624 size, psi); 625 } 626 627 static int pstore_write_buf_user_compat(enum pstore_type_id type, 628 enum kmsg_dump_reason reason, 629 u64 *id, unsigned int part, 630 const char __user *buf, 631 bool compressed, size_t size, 632 struct pstore_info *psi) 633 { 634 unsigned long flags = 0; 635 size_t i, bufsize = size; 636 long ret = 0; 637 638 if (unlikely(!access_ok(VERIFY_READ, buf, size))) 639 return -EFAULT; 640 if (bufsize > psinfo->bufsize) 641 bufsize = psinfo->bufsize; 642 spin_lock_irqsave(&psinfo->buf_lock, flags); 643 for (i = 0; i < size; ) { 644 size_t c = min(size - i, bufsize); 645 646 ret = __copy_from_user(psinfo->buf, buf + i, c); 647 if (unlikely(ret != 0)) { 648 ret = -EFAULT; 649 break; 650 } 651 ret = psi->write_buf(type, reason, id, part, psinfo->buf, 652 compressed, c, psi); 653 if (unlikely(ret < 0)) 654 break; 655 i += c; 656 } 657 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 658 return unlikely(ret < 0) ? ret : size; 659 } 660 661 /* 662 * platform specific persistent storage driver registers with 663 * us here. If pstore is already mounted, call the platform 664 * read function right away to populate the file system. If not 665 * then the pstore mount code will call us later to fill out 666 * the file system. 667 */ 668 int pstore_register(struct pstore_info *psi) 669 { 670 struct module *owner = psi->owner; 671 672 if (backend && strcmp(backend, psi->name)) 673 return -EPERM; 674 675 spin_lock(&pstore_lock); 676 if (psinfo) { 677 spin_unlock(&pstore_lock); 678 return -EBUSY; 679 } 680 681 if (!psi->write) 682 psi->write = pstore_write_compat; 683 if (!psi->write_buf_user) 684 psi->write_buf_user = pstore_write_buf_user_compat; 685 psinfo = psi; 686 mutex_init(&psinfo->read_mutex); 687 spin_unlock(&pstore_lock); 688 689 if (owner && !try_module_get(owner)) { 690 psinfo = NULL; 691 return -EINVAL; 692 } 693 694 allocate_buf_for_compression(); 695 696 if (pstore_is_mounted()) 697 pstore_get_records(0); 698 699 if (psi->flags & PSTORE_FLAGS_DMESG) 700 pstore_register_kmsg(); 701 if (psi->flags & PSTORE_FLAGS_CONSOLE) 702 pstore_register_console(); 703 if (psi->flags & PSTORE_FLAGS_FTRACE) 704 pstore_register_ftrace(); 705 if (psi->flags & PSTORE_FLAGS_PMSG) 706 pstore_register_pmsg(); 707 708 if (pstore_update_ms >= 0) { 709 pstore_timer.expires = jiffies + 710 msecs_to_jiffies(pstore_update_ms); 711 add_timer(&pstore_timer); 712 } 713 714 /* 715 * Update the module parameter backend, so it is visible 716 * through /sys/module/pstore/parameters/backend 717 */ 718 backend = psi->name; 719 720 module_put(owner); 721 722 pr_info("Registered %s as persistent store backend\n", psi->name); 723 724 return 0; 725 } 726 EXPORT_SYMBOL_GPL(pstore_register); 727 728 void pstore_unregister(struct pstore_info *psi) 729 { 730 if (psi->flags & PSTORE_FLAGS_PMSG) 731 pstore_unregister_pmsg(); 732 if (psi->flags & PSTORE_FLAGS_FTRACE) 733 pstore_unregister_ftrace(); 734 if (psi->flags & PSTORE_FLAGS_CONSOLE) 735 pstore_unregister_console(); 736 if (psi->flags & PSTORE_FLAGS_DMESG) 737 pstore_unregister_kmsg(); 738 739 free_buf_for_compression(); 740 741 psinfo = NULL; 742 backend = NULL; 743 } 744 EXPORT_SYMBOL_GPL(pstore_unregister); 745 746 /* 747 * Read all the records from the persistent store. Create 748 * files in our filesystem. Don't warn about -EEXIST errors 749 * when we are re-scanning the backing store looking to add new 750 * error records. 751 */ 752 void pstore_get_records(int quiet) 753 { 754 struct pstore_info *psi = psinfo; 755 char *buf = NULL; 756 ssize_t size; 757 u64 id; 758 int count; 759 enum pstore_type_id type; 760 struct timespec time; 761 int failed = 0, rc; 762 bool compressed; 763 int unzipped_len = -1; 764 ssize_t ecc_notice_size = 0; 765 766 if (!psi) 767 return; 768 769 mutex_lock(&psi->read_mutex); 770 if (psi->open && psi->open(psi)) 771 goto out; 772 773 while ((size = psi->read(&id, &type, &count, &time, &buf, &compressed, 774 &ecc_notice_size, psi)) > 0) { 775 if (compressed && (type == PSTORE_TYPE_DMESG)) { 776 if (big_oops_buf) 777 unzipped_len = pstore_decompress(buf, 778 big_oops_buf, size, 779 big_oops_buf_sz); 780 781 if (unzipped_len > 0) { 782 if (ecc_notice_size) 783 memcpy(big_oops_buf + unzipped_len, 784 buf + size, ecc_notice_size); 785 kfree(buf); 786 buf = big_oops_buf; 787 size = unzipped_len; 788 compressed = false; 789 } else { 790 pr_err("decompression failed;returned %d\n", 791 unzipped_len); 792 compressed = true; 793 } 794 } 795 rc = pstore_mkfile(type, psi->name, id, count, buf, 796 compressed, size + ecc_notice_size, 797 time, psi); 798 if (unzipped_len < 0) { 799 /* Free buffer other than big oops */ 800 kfree(buf); 801 buf = NULL; 802 } else 803 unzipped_len = -1; 804 if (rc && (rc != -EEXIST || !quiet)) 805 failed++; 806 } 807 if (psi->close) 808 psi->close(psi); 809 out: 810 mutex_unlock(&psi->read_mutex); 811 812 if (failed) 813 pr_warn("failed to load %d record(s) from '%s'\n", 814 failed, psi->name); 815 } 816 817 static void pstore_dowork(struct work_struct *work) 818 { 819 pstore_get_records(1); 820 } 821 822 static void pstore_timefunc(unsigned long dummy) 823 { 824 if (pstore_new_entry) { 825 pstore_new_entry = 0; 826 schedule_work(&pstore_work); 827 } 828 829 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 830 } 831 832 module_param(backend, charp, 0444); 833 MODULE_PARM_DESC(backend, "Pstore backend to use"); 834