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(struct timer_list *); 65 static DEFINE_TIMER(pstore_timer, pstore_timefunc); 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 unsigned long kmsg_bytes = PSTORE_DEFAULT_KMSG_BYTES; 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 const 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 const 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_default(in, out, inlen, outlen, workspace); 346 if (!ret) { 347 pr_err("LZ4_compress_default error; compression failed!\n"); 348 return -EIO; 349 } 350 351 return ret; 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_safe(in, out, inlen, outlen); 359 if (ret < 0) { 360 /* 361 * LZ4_decompress_safe will return an error code 362 * (< 0) if decompression failed 363 */ 364 pr_err("LZ4_decompress_safe error, ret = %d!\n", ret); 365 return -EIO; 366 } 367 368 return ret; 369 } 370 371 static void allocate_lz4(void) 372 { 373 big_oops_buf_sz = LZ4_compressBound(psinfo->bufsize); 374 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 375 if (big_oops_buf) { 376 workspace = kmalloc(LZ4_MEM_COMPRESS, GFP_KERNEL); 377 if (!workspace) { 378 pr_err("No memory for compression workspace; skipping compression\n"); 379 kfree(big_oops_buf); 380 big_oops_buf = NULL; 381 } 382 } else { 383 pr_err("No memory for uncompressed data; skipping compression\n"); 384 workspace = NULL; 385 } 386 } 387 388 static void free_lz4(void) 389 { 390 kfree(workspace); 391 kfree(big_oops_buf); 392 big_oops_buf = NULL; 393 big_oops_buf_sz = 0; 394 } 395 396 static const struct pstore_zbackend backend_lz4 = { 397 .compress = compress_lz4, 398 .decompress = decompress_lz4, 399 .allocate = allocate_lz4, 400 .free = free_lz4, 401 .name = "lz4", 402 }; 403 #endif 404 405 static const struct pstore_zbackend *zbackend = 406 #if defined(CONFIG_PSTORE_ZLIB_COMPRESS) 407 &backend_zlib; 408 #elif defined(CONFIG_PSTORE_LZO_COMPRESS) 409 &backend_lzo; 410 #elif defined(CONFIG_PSTORE_LZ4_COMPRESS) 411 &backend_lz4; 412 #else 413 NULL; 414 #endif 415 416 static int pstore_compress(const void *in, void *out, 417 size_t inlen, size_t outlen) 418 { 419 if (zbackend) 420 return zbackend->compress(in, out, inlen, outlen); 421 else 422 return -EIO; 423 } 424 425 static int pstore_decompress(void *in, void *out, size_t inlen, size_t outlen) 426 { 427 if (zbackend) 428 return zbackend->decompress(in, out, inlen, outlen); 429 else 430 return -EIO; 431 } 432 433 static void allocate_buf_for_compression(void) 434 { 435 if (zbackend) { 436 pr_info("using %s compression\n", zbackend->name); 437 zbackend->allocate(); 438 } else { 439 pr_err("allocate compression buffer error!\n"); 440 } 441 } 442 443 static void free_buf_for_compression(void) 444 { 445 if (zbackend) 446 zbackend->free(); 447 else 448 pr_err("free compression buffer error!\n"); 449 } 450 451 /* 452 * Called when compression fails, since the printk buffer 453 * would be fetched for compression calling it again when 454 * compression fails would have moved the iterator of 455 * printk buffer which results in fetching old contents. 456 * Copy the recent messages from big_oops_buf to psinfo->buf 457 */ 458 static size_t copy_kmsg_to_buffer(int hsize, size_t len) 459 { 460 size_t total_len; 461 size_t diff; 462 463 total_len = hsize + len; 464 465 if (total_len > psinfo->bufsize) { 466 diff = total_len - psinfo->bufsize + hsize; 467 memcpy(psinfo->buf, big_oops_buf, hsize); 468 memcpy(psinfo->buf + hsize, big_oops_buf + diff, 469 psinfo->bufsize - hsize); 470 total_len = psinfo->bufsize; 471 } else 472 memcpy(psinfo->buf, big_oops_buf, total_len); 473 474 return total_len; 475 } 476 477 void pstore_record_init(struct pstore_record *record, 478 struct pstore_info *psinfo) 479 { 480 memset(record, 0, sizeof(*record)); 481 482 record->psi = psinfo; 483 484 /* Report zeroed timestamp if called before timekeeping has resumed. */ 485 record->time = ns_to_timespec(ktime_get_real_fast_ns()); 486 } 487 488 /* 489 * callback from kmsg_dump. (s2,l2) has the most recently 490 * written bytes, older bytes are in (s1,l1). Save as much 491 * as we can from the end of the buffer. 492 */ 493 static void pstore_dump(struct kmsg_dumper *dumper, 494 enum kmsg_dump_reason reason) 495 { 496 unsigned long total = 0; 497 const char *why; 498 unsigned int part = 1; 499 unsigned long flags = 0; 500 int is_locked; 501 int ret; 502 503 why = get_reason_str(reason); 504 505 if (pstore_cannot_block_path(reason)) { 506 is_locked = spin_trylock_irqsave(&psinfo->buf_lock, flags); 507 if (!is_locked) { 508 pr_err("pstore dump routine blocked in %s path, may corrupt error record\n" 509 , in_nmi() ? "NMI" : why); 510 return; 511 } 512 } else { 513 spin_lock_irqsave(&psinfo->buf_lock, flags); 514 is_locked = 1; 515 } 516 oopscount++; 517 while (total < kmsg_bytes) { 518 char *dst; 519 size_t dst_size; 520 int header_size; 521 int zipped_len = -1; 522 size_t dump_size; 523 struct pstore_record record; 524 525 pstore_record_init(&record, psinfo); 526 record.type = PSTORE_TYPE_DMESG; 527 record.count = oopscount; 528 record.reason = reason; 529 record.part = part; 530 record.buf = psinfo->buf; 531 532 if (big_oops_buf && is_locked) { 533 dst = big_oops_buf; 534 dst_size = big_oops_buf_sz; 535 } else { 536 dst = psinfo->buf; 537 dst_size = psinfo->bufsize; 538 } 539 540 /* Write dump header. */ 541 header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why, 542 oopscount, part); 543 dst_size -= header_size; 544 545 /* Write dump contents. */ 546 if (!kmsg_dump_get_buffer(dumper, true, dst + header_size, 547 dst_size, &dump_size)) 548 break; 549 550 if (big_oops_buf && is_locked) { 551 zipped_len = pstore_compress(dst, psinfo->buf, 552 header_size + dump_size, 553 psinfo->bufsize); 554 555 if (zipped_len > 0) { 556 record.compressed = true; 557 record.size = zipped_len; 558 } else { 559 record.size = copy_kmsg_to_buffer(header_size, 560 dump_size); 561 } 562 } else { 563 record.size = header_size + dump_size; 564 } 565 566 ret = psinfo->write(&record); 567 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 568 pstore_new_entry = 1; 569 570 total += record.size; 571 part++; 572 } 573 if (is_locked) 574 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 575 } 576 577 static struct kmsg_dumper pstore_dumper = { 578 .dump = pstore_dump, 579 }; 580 581 /* 582 * Register with kmsg_dump to save last part of console log on panic. 583 */ 584 static void pstore_register_kmsg(void) 585 { 586 kmsg_dump_register(&pstore_dumper); 587 } 588 589 static void pstore_unregister_kmsg(void) 590 { 591 kmsg_dump_unregister(&pstore_dumper); 592 } 593 594 #ifdef CONFIG_PSTORE_CONSOLE 595 static void pstore_console_write(struct console *con, const char *s, unsigned c) 596 { 597 const char *e = s + c; 598 599 while (s < e) { 600 struct pstore_record record; 601 unsigned long flags; 602 603 pstore_record_init(&record, psinfo); 604 record.type = PSTORE_TYPE_CONSOLE; 605 606 if (c > psinfo->bufsize) 607 c = psinfo->bufsize; 608 609 if (oops_in_progress) { 610 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) 611 break; 612 } else { 613 spin_lock_irqsave(&psinfo->buf_lock, flags); 614 } 615 record.buf = (char *)s; 616 record.size = c; 617 psinfo->write(&record); 618 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 619 s += c; 620 c = e - s; 621 } 622 } 623 624 static struct console pstore_console = { 625 .name = "pstore", 626 .write = pstore_console_write, 627 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 628 .index = -1, 629 }; 630 631 static void pstore_register_console(void) 632 { 633 register_console(&pstore_console); 634 } 635 636 static void pstore_unregister_console(void) 637 { 638 unregister_console(&pstore_console); 639 } 640 #else 641 static void pstore_register_console(void) {} 642 static void pstore_unregister_console(void) {} 643 #endif 644 645 static int pstore_write_user_compat(struct pstore_record *record, 646 const char __user *buf) 647 { 648 int ret = 0; 649 650 if (record->buf) 651 return -EINVAL; 652 653 record->buf = memdup_user(buf, record->size); 654 if (IS_ERR(record->buf)) { 655 ret = PTR_ERR(record->buf); 656 goto out; 657 } 658 659 ret = record->psi->write(record); 660 661 kfree(record->buf); 662 out: 663 record->buf = NULL; 664 665 return unlikely(ret < 0) ? ret : record->size; 666 } 667 668 /* 669 * platform specific persistent storage driver registers with 670 * us here. If pstore is already mounted, call the platform 671 * read function right away to populate the file system. If not 672 * then the pstore mount code will call us later to fill out 673 * the file system. 674 */ 675 int pstore_register(struct pstore_info *psi) 676 { 677 struct module *owner = psi->owner; 678 679 if (backend && strcmp(backend, psi->name)) { 680 pr_warn("ignoring unexpected backend '%s'\n", psi->name); 681 return -EPERM; 682 } 683 684 /* Sanity check flags. */ 685 if (!psi->flags) { 686 pr_warn("backend '%s' must support at least one frontend\n", 687 psi->name); 688 return -EINVAL; 689 } 690 691 /* Check for required functions. */ 692 if (!psi->read || !psi->write) { 693 pr_warn("backend '%s' must implement read() and write()\n", 694 psi->name); 695 return -EINVAL; 696 } 697 698 spin_lock(&pstore_lock); 699 if (psinfo) { 700 pr_warn("backend '%s' already loaded: ignoring '%s'\n", 701 psinfo->name, psi->name); 702 spin_unlock(&pstore_lock); 703 return -EBUSY; 704 } 705 706 if (!psi->write_user) 707 psi->write_user = pstore_write_user_compat; 708 psinfo = psi; 709 mutex_init(&psinfo->read_mutex); 710 spin_unlock(&pstore_lock); 711 712 if (owner && !try_module_get(owner)) { 713 psinfo = NULL; 714 return -EINVAL; 715 } 716 717 allocate_buf_for_compression(); 718 719 if (pstore_is_mounted()) 720 pstore_get_records(0); 721 722 if (psi->flags & PSTORE_FLAGS_DMESG) 723 pstore_register_kmsg(); 724 if (psi->flags & PSTORE_FLAGS_CONSOLE) 725 pstore_register_console(); 726 if (psi->flags & PSTORE_FLAGS_FTRACE) 727 pstore_register_ftrace(); 728 if (psi->flags & PSTORE_FLAGS_PMSG) 729 pstore_register_pmsg(); 730 731 /* Start watching for new records, if desired. */ 732 if (pstore_update_ms >= 0) { 733 pstore_timer.expires = jiffies + 734 msecs_to_jiffies(pstore_update_ms); 735 add_timer(&pstore_timer); 736 } 737 738 /* 739 * Update the module parameter backend, so it is visible 740 * through /sys/module/pstore/parameters/backend 741 */ 742 backend = psi->name; 743 744 pr_info("Registered %s as persistent store backend\n", psi->name); 745 746 module_put(owner); 747 748 return 0; 749 } 750 EXPORT_SYMBOL_GPL(pstore_register); 751 752 void pstore_unregister(struct pstore_info *psi) 753 { 754 /* Stop timer and make sure all work has finished. */ 755 pstore_update_ms = -1; 756 del_timer_sync(&pstore_timer); 757 flush_work(&pstore_work); 758 759 if (psi->flags & PSTORE_FLAGS_PMSG) 760 pstore_unregister_pmsg(); 761 if (psi->flags & PSTORE_FLAGS_FTRACE) 762 pstore_unregister_ftrace(); 763 if (psi->flags & PSTORE_FLAGS_CONSOLE) 764 pstore_unregister_console(); 765 if (psi->flags & PSTORE_FLAGS_DMESG) 766 pstore_unregister_kmsg(); 767 768 free_buf_for_compression(); 769 770 psinfo = NULL; 771 backend = NULL; 772 } 773 EXPORT_SYMBOL_GPL(pstore_unregister); 774 775 static void decompress_record(struct pstore_record *record) 776 { 777 int unzipped_len; 778 char *decompressed; 779 780 if (!record->compressed) 781 return; 782 783 /* Only PSTORE_TYPE_DMESG support compression. */ 784 if (record->type != PSTORE_TYPE_DMESG) { 785 pr_warn("ignored compressed record type %d\n", record->type); 786 return; 787 } 788 789 /* No compression method has created the common buffer. */ 790 if (!big_oops_buf) { 791 pr_warn("no decompression buffer allocated\n"); 792 return; 793 } 794 795 unzipped_len = pstore_decompress(record->buf, big_oops_buf, 796 record->size, big_oops_buf_sz); 797 if (unzipped_len <= 0) { 798 pr_err("decompression failed: %d\n", unzipped_len); 799 return; 800 } 801 802 /* Build new buffer for decompressed contents. */ 803 decompressed = kmalloc(unzipped_len + record->ecc_notice_size, 804 GFP_KERNEL); 805 if (!decompressed) { 806 pr_err("decompression ran out of memory\n"); 807 return; 808 } 809 memcpy(decompressed, big_oops_buf, unzipped_len); 810 811 /* Append ECC notice to decompressed buffer. */ 812 memcpy(decompressed + unzipped_len, record->buf + record->size, 813 record->ecc_notice_size); 814 815 /* Swap out compresed contents with decompressed contents. */ 816 kfree(record->buf); 817 record->buf = decompressed; 818 record->size = unzipped_len; 819 record->compressed = false; 820 } 821 822 /* 823 * Read all the records from one persistent store backend. Create 824 * files in our filesystem. Don't warn about -EEXIST errors 825 * when we are re-scanning the backing store looking to add new 826 * error records. 827 */ 828 void pstore_get_backend_records(struct pstore_info *psi, 829 struct dentry *root, int quiet) 830 { 831 int failed = 0; 832 unsigned int stop_loop = 65536; 833 834 if (!psi || !root) 835 return; 836 837 mutex_lock(&psi->read_mutex); 838 if (psi->open && psi->open(psi)) 839 goto out; 840 841 /* 842 * Backend callback read() allocates record.buf. decompress_record() 843 * may reallocate record.buf. On success, pstore_mkfile() will keep 844 * the record.buf, so free it only on failure. 845 */ 846 for (; stop_loop; stop_loop--) { 847 struct pstore_record *record; 848 int rc; 849 850 record = kzalloc(sizeof(*record), GFP_KERNEL); 851 if (!record) { 852 pr_err("out of memory creating record\n"); 853 break; 854 } 855 pstore_record_init(record, psi); 856 857 record->size = psi->read(record); 858 859 /* No more records left in backend? */ 860 if (record->size <= 0) { 861 kfree(record); 862 break; 863 } 864 865 decompress_record(record); 866 rc = pstore_mkfile(root, record); 867 if (rc) { 868 /* pstore_mkfile() did not take record, so free it. */ 869 kfree(record->buf); 870 kfree(record); 871 if (rc != -EEXIST || !quiet) 872 failed++; 873 } 874 } 875 if (psi->close) 876 psi->close(psi); 877 out: 878 mutex_unlock(&psi->read_mutex); 879 880 if (failed) 881 pr_warn("failed to create %d record(s) from '%s'\n", 882 failed, psi->name); 883 if (!stop_loop) 884 pr_err("looping? Too many records seen from '%s'\n", 885 psi->name); 886 } 887 888 static void pstore_dowork(struct work_struct *work) 889 { 890 pstore_get_records(1); 891 } 892 893 static void pstore_timefunc(struct timer_list *unused) 894 { 895 if (pstore_new_entry) { 896 pstore_new_entry = 0; 897 schedule_work(&pstore_work); 898 } 899 900 if (pstore_update_ms >= 0) 901 mod_timer(&pstore_timer, 902 jiffies + msecs_to_jiffies(pstore_update_ms)); 903 } 904 905 module_param(backend, charp, 0444); 906 MODULE_PARM_DESC(backend, "Pstore backend to use"); 907