1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Persistent Storage - platform driver interface parts. 4 * 5 * Copyright (C) 2007-2008 Google, Inc. 6 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com> 7 */ 8 9 #define pr_fmt(fmt) "pstore: " fmt 10 11 #include <linux/atomic.h> 12 #include <linux/types.h> 13 #include <linux/errno.h> 14 #include <linux/init.h> 15 #include <linux/kmsg_dump.h> 16 #include <linux/console.h> 17 #include <linux/module.h> 18 #include <linux/pstore.h> 19 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) 20 #include <linux/lzo.h> 21 #endif 22 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) 23 #include <linux/lz4.h> 24 #endif 25 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS) 26 #include <linux/zstd.h> 27 #endif 28 #include <linux/crypto.h> 29 #include <linux/string.h> 30 #include <linux/timer.h> 31 #include <linux/slab.h> 32 #include <linux/uaccess.h> 33 #include <linux/jiffies.h> 34 #include <linux/workqueue.h> 35 36 #include "internal.h" 37 38 /* 39 * We defer making "oops" entries appear in pstore - see 40 * whether the system is actually still running well enough 41 * to let someone see the entry 42 */ 43 static int pstore_update_ms = -1; 44 module_param_named(update_ms, pstore_update_ms, int, 0600); 45 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content " 46 "(default is -1, which means runtime updates are disabled; " 47 "enabling this option may not be safe; it may lead to further " 48 "corruption on Oopses)"); 49 50 /* Names should be in the same order as the enum pstore_type_id */ 51 static const char * const pstore_type_names[] = { 52 "dmesg", 53 "mce", 54 "console", 55 "ftrace", 56 "rtas", 57 "powerpc-ofw", 58 "powerpc-common", 59 "pmsg", 60 "powerpc-opal", 61 }; 62 63 static int pstore_new_entry; 64 65 static void pstore_timefunc(struct timer_list *); 66 static DEFINE_TIMER(pstore_timer, pstore_timefunc); 67 68 static void pstore_dowork(struct work_struct *); 69 static DECLARE_WORK(pstore_work, pstore_dowork); 70 71 /* 72 * psinfo_lock protects "psinfo" during calls to 73 * pstore_register(), pstore_unregister(), and 74 * the filesystem mount/unmount routines. 75 */ 76 static DEFINE_MUTEX(psinfo_lock); 77 struct pstore_info *psinfo; 78 79 static char *backend; 80 module_param(backend, charp, 0444); 81 MODULE_PARM_DESC(backend, "specific backend to use"); 82 83 static char *compress = 84 #ifdef CONFIG_PSTORE_COMPRESS_DEFAULT 85 CONFIG_PSTORE_COMPRESS_DEFAULT; 86 #else 87 NULL; 88 #endif 89 module_param(compress, charp, 0444); 90 MODULE_PARM_DESC(compress, "compression to use"); 91 92 /* How much of the kernel log to snapshot */ 93 unsigned long kmsg_bytes = CONFIG_PSTORE_DEFAULT_KMSG_BYTES; 94 module_param(kmsg_bytes, ulong, 0444); 95 MODULE_PARM_DESC(kmsg_bytes, "amount of kernel log to snapshot (in bytes)"); 96 97 /* Compression parameters */ 98 static struct crypto_comp *tfm; 99 100 struct pstore_zbackend { 101 int (*zbufsize)(size_t size); 102 const char *name; 103 }; 104 105 static char *big_oops_buf; 106 static size_t big_oops_buf_sz; 107 108 void pstore_set_kmsg_bytes(int bytes) 109 { 110 kmsg_bytes = bytes; 111 } 112 113 /* Tag each group of saved records with a sequence number */ 114 static int oopscount; 115 116 const char *pstore_type_to_name(enum pstore_type_id type) 117 { 118 BUILD_BUG_ON(ARRAY_SIZE(pstore_type_names) != PSTORE_TYPE_MAX); 119 120 if (WARN_ON_ONCE(type >= PSTORE_TYPE_MAX)) 121 return "unknown"; 122 123 return pstore_type_names[type]; 124 } 125 EXPORT_SYMBOL_GPL(pstore_type_to_name); 126 127 enum pstore_type_id pstore_name_to_type(const char *name) 128 { 129 int i; 130 131 for (i = 0; i < PSTORE_TYPE_MAX; i++) { 132 if (!strcmp(pstore_type_names[i], name)) 133 return i; 134 } 135 136 return PSTORE_TYPE_MAX; 137 } 138 EXPORT_SYMBOL_GPL(pstore_name_to_type); 139 140 static void pstore_timer_kick(void) 141 { 142 if (pstore_update_ms < 0) 143 return; 144 145 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 146 } 147 148 static bool pstore_cannot_block_path(enum kmsg_dump_reason reason) 149 { 150 /* 151 * In case of NMI path, pstore shouldn't be blocked 152 * regardless of reason. 153 */ 154 if (in_nmi()) 155 return true; 156 157 switch (reason) { 158 /* In panic case, other cpus are stopped by smp_send_stop(). */ 159 case KMSG_DUMP_PANIC: 160 /* 161 * Emergency restart shouldn't be blocked by spinning on 162 * pstore_info::buf_lock. 163 */ 164 case KMSG_DUMP_EMERG: 165 return true; 166 default: 167 return false; 168 } 169 } 170 171 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) 172 static int zbufsize_deflate(size_t size) 173 { 174 size_t cmpr; 175 176 switch (size) { 177 /* buffer range for efivars */ 178 case 1000 ... 2000: 179 cmpr = 56; 180 break; 181 case 2001 ... 3000: 182 cmpr = 54; 183 break; 184 case 3001 ... 3999: 185 cmpr = 52; 186 break; 187 /* buffer range for nvram, erst */ 188 case 4000 ... 10000: 189 cmpr = 45; 190 break; 191 default: 192 cmpr = 60; 193 break; 194 } 195 196 return (size * 100) / cmpr; 197 } 198 #endif 199 200 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) 201 static int zbufsize_lzo(size_t size) 202 { 203 return lzo1x_worst_compress(size); 204 } 205 #endif 206 207 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) 208 static int zbufsize_lz4(size_t size) 209 { 210 return LZ4_compressBound(size); 211 } 212 #endif 213 214 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) 215 static int zbufsize_842(size_t size) 216 { 217 return size; 218 } 219 #endif 220 221 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS) 222 static int zbufsize_zstd(size_t size) 223 { 224 return zstd_compress_bound(size); 225 } 226 #endif 227 228 static const struct pstore_zbackend *zbackend __ro_after_init; 229 230 static const struct pstore_zbackend zbackends[] = { 231 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) 232 { 233 .zbufsize = zbufsize_deflate, 234 .name = "deflate", 235 }, 236 #endif 237 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) 238 { 239 .zbufsize = zbufsize_lzo, 240 .name = "lzo", 241 }, 242 #endif 243 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) 244 { 245 .zbufsize = zbufsize_lz4, 246 .name = "lz4", 247 }, 248 #endif 249 #if IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) 250 { 251 .zbufsize = zbufsize_lz4, 252 .name = "lz4hc", 253 }, 254 #endif 255 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) 256 { 257 .zbufsize = zbufsize_842, 258 .name = "842", 259 }, 260 #endif 261 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS) 262 { 263 .zbufsize = zbufsize_zstd, 264 .name = "zstd", 265 }, 266 #endif 267 { } 268 }; 269 270 static int pstore_compress(const void *in, void *out, 271 unsigned int inlen, unsigned int outlen) 272 { 273 int ret; 274 275 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS)) 276 return -EINVAL; 277 278 ret = crypto_comp_compress(tfm, in, inlen, out, &outlen); 279 if (ret) { 280 pr_err("crypto_comp_compress failed, ret = %d!\n", ret); 281 return ret; 282 } 283 284 return outlen; 285 } 286 287 static void allocate_buf_for_compression(void) 288 { 289 struct crypto_comp *ctx; 290 int size; 291 char *buf; 292 293 /* Skip if not built-in or compression backend not selected yet. */ 294 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !zbackend) 295 return; 296 297 /* Skip if no pstore backend yet or compression init already done. */ 298 if (!psinfo || tfm) 299 return; 300 301 if (!crypto_has_comp(zbackend->name, 0, 0)) { 302 pr_err("Unknown compression: %s\n", zbackend->name); 303 return; 304 } 305 306 size = zbackend->zbufsize(psinfo->bufsize); 307 if (size <= 0) { 308 pr_err("Invalid compression size for %s: %d\n", 309 zbackend->name, size); 310 return; 311 } 312 313 buf = kmalloc(size, GFP_KERNEL); 314 if (!buf) { 315 pr_err("Failed %d byte compression buffer allocation for: %s\n", 316 size, zbackend->name); 317 return; 318 } 319 320 ctx = crypto_alloc_comp(zbackend->name, 0, 0); 321 if (IS_ERR_OR_NULL(ctx)) { 322 kfree(buf); 323 pr_err("crypto_alloc_comp('%s') failed: %ld\n", zbackend->name, 324 PTR_ERR(ctx)); 325 return; 326 } 327 328 /* A non-NULL big_oops_buf indicates compression is available. */ 329 tfm = ctx; 330 big_oops_buf_sz = size; 331 big_oops_buf = buf; 332 333 pr_info("Using crash dump compression: %s\n", zbackend->name); 334 } 335 336 static void free_buf_for_compression(void) 337 { 338 if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && tfm) { 339 crypto_free_comp(tfm); 340 tfm = NULL; 341 } 342 kfree(big_oops_buf); 343 big_oops_buf = NULL; 344 big_oops_buf_sz = 0; 345 } 346 347 /* 348 * Called when compression fails, since the printk buffer 349 * would be fetched for compression calling it again when 350 * compression fails would have moved the iterator of 351 * printk buffer which results in fetching old contents. 352 * Copy the recent messages from big_oops_buf to psinfo->buf 353 */ 354 static size_t copy_kmsg_to_buffer(int hsize, size_t len) 355 { 356 size_t total_len; 357 size_t diff; 358 359 total_len = hsize + len; 360 361 if (total_len > psinfo->bufsize) { 362 diff = total_len - psinfo->bufsize + hsize; 363 memcpy(psinfo->buf, big_oops_buf, hsize); 364 memcpy(psinfo->buf + hsize, big_oops_buf + diff, 365 psinfo->bufsize - hsize); 366 total_len = psinfo->bufsize; 367 } else 368 memcpy(psinfo->buf, big_oops_buf, total_len); 369 370 return total_len; 371 } 372 373 void pstore_record_init(struct pstore_record *record, 374 struct pstore_info *psinfo) 375 { 376 memset(record, 0, sizeof(*record)); 377 378 record->psi = psinfo; 379 380 /* Report zeroed timestamp if called before timekeeping has resumed. */ 381 record->time = ns_to_timespec64(ktime_get_real_fast_ns()); 382 } 383 384 /* 385 * callback from kmsg_dump. Save as much as we can (up to kmsg_bytes) from the 386 * end of the buffer. 387 */ 388 static void pstore_dump(struct kmsg_dumper *dumper, 389 enum kmsg_dump_reason reason) 390 { 391 struct kmsg_dump_iter iter; 392 unsigned long total = 0; 393 const char *why; 394 unsigned int part = 1; 395 unsigned long flags = 0; 396 int saved_ret = 0; 397 int ret; 398 399 why = kmsg_dump_reason_str(reason); 400 401 if (pstore_cannot_block_path(reason)) { 402 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) { 403 pr_err("dump skipped in %s path because of concurrent dump\n", 404 in_nmi() ? "NMI" : why); 405 return; 406 } 407 } else { 408 spin_lock_irqsave(&psinfo->buf_lock, flags); 409 } 410 411 kmsg_dump_rewind(&iter); 412 413 oopscount++; 414 while (total < kmsg_bytes) { 415 char *dst; 416 size_t dst_size; 417 int header_size; 418 int zipped_len = -1; 419 size_t dump_size; 420 struct pstore_record record; 421 422 pstore_record_init(&record, psinfo); 423 record.type = PSTORE_TYPE_DMESG; 424 record.count = oopscount; 425 record.reason = reason; 426 record.part = part; 427 record.buf = psinfo->buf; 428 429 if (big_oops_buf) { 430 dst = big_oops_buf; 431 dst_size = big_oops_buf_sz; 432 } else { 433 dst = psinfo->buf; 434 dst_size = psinfo->bufsize; 435 } 436 437 /* Write dump header. */ 438 header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why, 439 oopscount, part); 440 dst_size -= header_size; 441 442 /* Write dump contents. */ 443 if (!kmsg_dump_get_buffer(&iter, true, dst + header_size, 444 dst_size, &dump_size)) 445 break; 446 447 if (big_oops_buf) { 448 zipped_len = pstore_compress(dst, psinfo->buf, 449 header_size + dump_size, 450 psinfo->bufsize); 451 452 if (zipped_len > 0) { 453 record.compressed = true; 454 record.size = zipped_len; 455 } else { 456 record.size = copy_kmsg_to_buffer(header_size, 457 dump_size); 458 } 459 } else { 460 record.size = header_size + dump_size; 461 } 462 463 ret = psinfo->write(&record); 464 if (ret == 0 && reason == KMSG_DUMP_OOPS) { 465 pstore_new_entry = 1; 466 pstore_timer_kick(); 467 } else { 468 /* Preserve only the first non-zero returned value. */ 469 if (!saved_ret) 470 saved_ret = ret; 471 } 472 473 total += record.size; 474 part++; 475 } 476 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 477 478 if (saved_ret) { 479 pr_err_once("backend (%s) writing error (%d)\n", psinfo->name, 480 saved_ret); 481 } 482 } 483 484 static struct kmsg_dumper pstore_dumper = { 485 .dump = pstore_dump, 486 }; 487 488 /* 489 * Register with kmsg_dump to save last part of console log on panic. 490 */ 491 static void pstore_register_kmsg(void) 492 { 493 kmsg_dump_register(&pstore_dumper); 494 } 495 496 static void pstore_unregister_kmsg(void) 497 { 498 kmsg_dump_unregister(&pstore_dumper); 499 } 500 501 #ifdef CONFIG_PSTORE_CONSOLE 502 static void pstore_console_write(struct console *con, const char *s, unsigned c) 503 { 504 struct pstore_record record; 505 506 if (!c) 507 return; 508 509 pstore_record_init(&record, psinfo); 510 record.type = PSTORE_TYPE_CONSOLE; 511 512 record.buf = (char *)s; 513 record.size = c; 514 psinfo->write(&record); 515 } 516 517 static struct console pstore_console = { 518 .write = pstore_console_write, 519 .index = -1, 520 }; 521 522 static void pstore_register_console(void) 523 { 524 /* Show which backend is going to get console writes. */ 525 strscpy(pstore_console.name, psinfo->name, 526 sizeof(pstore_console.name)); 527 /* 528 * Always initialize flags here since prior unregister_console() 529 * calls may have changed settings (specifically CON_ENABLED). 530 */ 531 pstore_console.flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME; 532 register_console(&pstore_console); 533 } 534 535 static void pstore_unregister_console(void) 536 { 537 unregister_console(&pstore_console); 538 } 539 #else 540 static void pstore_register_console(void) {} 541 static void pstore_unregister_console(void) {} 542 #endif 543 544 static int pstore_write_user_compat(struct pstore_record *record, 545 const char __user *buf) 546 { 547 int ret = 0; 548 549 if (record->buf) 550 return -EINVAL; 551 552 record->buf = memdup_user(buf, record->size); 553 if (IS_ERR(record->buf)) { 554 ret = PTR_ERR(record->buf); 555 goto out; 556 } 557 558 ret = record->psi->write(record); 559 560 kfree(record->buf); 561 out: 562 record->buf = NULL; 563 564 return unlikely(ret < 0) ? ret : record->size; 565 } 566 567 /* 568 * platform specific persistent storage driver registers with 569 * us here. If pstore is already mounted, call the platform 570 * read function right away to populate the file system. If not 571 * then the pstore mount code will call us later to fill out 572 * the file system. 573 */ 574 int pstore_register(struct pstore_info *psi) 575 { 576 if (backend && strcmp(backend, psi->name)) { 577 pr_warn("backend '%s' already in use: ignoring '%s'\n", 578 backend, psi->name); 579 return -EBUSY; 580 } 581 582 /* Sanity check flags. */ 583 if (!psi->flags) { 584 pr_warn("backend '%s' must support at least one frontend\n", 585 psi->name); 586 return -EINVAL; 587 } 588 589 /* Check for required functions. */ 590 if (!psi->read || !psi->write) { 591 pr_warn("backend '%s' must implement read() and write()\n", 592 psi->name); 593 return -EINVAL; 594 } 595 596 mutex_lock(&psinfo_lock); 597 if (psinfo) { 598 pr_warn("backend '%s' already loaded: ignoring '%s'\n", 599 psinfo->name, psi->name); 600 mutex_unlock(&psinfo_lock); 601 return -EBUSY; 602 } 603 604 if (!psi->write_user) 605 psi->write_user = pstore_write_user_compat; 606 psinfo = psi; 607 mutex_init(&psinfo->read_mutex); 608 spin_lock_init(&psinfo->buf_lock); 609 610 if (psi->flags & PSTORE_FLAGS_DMESG) 611 allocate_buf_for_compression(); 612 613 pstore_get_records(0); 614 615 if (psi->flags & PSTORE_FLAGS_DMESG) { 616 pstore_dumper.max_reason = psinfo->max_reason; 617 pstore_register_kmsg(); 618 } 619 if (psi->flags & PSTORE_FLAGS_CONSOLE) 620 pstore_register_console(); 621 if (psi->flags & PSTORE_FLAGS_FTRACE) 622 pstore_register_ftrace(); 623 if (psi->flags & PSTORE_FLAGS_PMSG) 624 pstore_register_pmsg(); 625 626 /* Start watching for new records, if desired. */ 627 pstore_timer_kick(); 628 629 /* 630 * Update the module parameter backend, so it is visible 631 * through /sys/module/pstore/parameters/backend 632 */ 633 backend = kstrdup(psi->name, GFP_KERNEL); 634 635 pr_info("Registered %s as persistent store backend\n", psi->name); 636 637 mutex_unlock(&psinfo_lock); 638 return 0; 639 } 640 EXPORT_SYMBOL_GPL(pstore_register); 641 642 void pstore_unregister(struct pstore_info *psi) 643 { 644 /* It's okay to unregister nothing. */ 645 if (!psi) 646 return; 647 648 mutex_lock(&psinfo_lock); 649 650 /* Only one backend can be registered at a time. */ 651 if (WARN_ON(psi != psinfo)) { 652 mutex_unlock(&psinfo_lock); 653 return; 654 } 655 656 /* Unregister all callbacks. */ 657 if (psi->flags & PSTORE_FLAGS_PMSG) 658 pstore_unregister_pmsg(); 659 if (psi->flags & PSTORE_FLAGS_FTRACE) 660 pstore_unregister_ftrace(); 661 if (psi->flags & PSTORE_FLAGS_CONSOLE) 662 pstore_unregister_console(); 663 if (psi->flags & PSTORE_FLAGS_DMESG) 664 pstore_unregister_kmsg(); 665 666 /* Stop timer and make sure all work has finished. */ 667 del_timer_sync(&pstore_timer); 668 flush_work(&pstore_work); 669 670 /* Remove all backend records from filesystem tree. */ 671 pstore_put_backend_records(psi); 672 673 free_buf_for_compression(); 674 675 psinfo = NULL; 676 kfree(backend); 677 backend = NULL; 678 679 pr_info("Unregistered %s as persistent store backend\n", psi->name); 680 mutex_unlock(&psinfo_lock); 681 } 682 EXPORT_SYMBOL_GPL(pstore_unregister); 683 684 static void decompress_record(struct pstore_record *record) 685 { 686 int ret; 687 int unzipped_len; 688 char *unzipped, *workspace; 689 690 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed) 691 return; 692 693 /* Only PSTORE_TYPE_DMESG support compression. */ 694 if (record->type != PSTORE_TYPE_DMESG) { 695 pr_warn("ignored compressed record type %d\n", record->type); 696 return; 697 } 698 699 /* Missing compression buffer means compression was not initialized. */ 700 if (!big_oops_buf) { 701 pr_warn("no decompression method initialized!\n"); 702 return; 703 } 704 705 /* Allocate enough space to hold max decompression and ECC. */ 706 unzipped_len = big_oops_buf_sz; 707 workspace = kmalloc(unzipped_len + record->ecc_notice_size, 708 GFP_KERNEL); 709 if (!workspace) 710 return; 711 712 /* After decompression "unzipped_len" is almost certainly smaller. */ 713 ret = crypto_comp_decompress(tfm, record->buf, record->size, 714 workspace, &unzipped_len); 715 if (ret) { 716 pr_err("crypto_comp_decompress failed, ret = %d!\n", ret); 717 kfree(workspace); 718 return; 719 } 720 721 /* Append ECC notice to decompressed buffer. */ 722 memcpy(workspace + unzipped_len, record->buf + record->size, 723 record->ecc_notice_size); 724 725 /* Copy decompressed contents into an minimum-sized allocation. */ 726 unzipped = kmemdup(workspace, unzipped_len + record->ecc_notice_size, 727 GFP_KERNEL); 728 kfree(workspace); 729 if (!unzipped) 730 return; 731 732 /* Swap out compressed contents with decompressed contents. */ 733 kfree(record->buf); 734 record->buf = unzipped; 735 record->size = unzipped_len; 736 record->compressed = false; 737 } 738 739 /* 740 * Read all the records from one persistent store backend. Create 741 * files in our filesystem. Don't warn about -EEXIST errors 742 * when we are re-scanning the backing store looking to add new 743 * error records. 744 */ 745 void pstore_get_backend_records(struct pstore_info *psi, 746 struct dentry *root, int quiet) 747 { 748 int failed = 0; 749 unsigned int stop_loop = 65536; 750 751 if (!psi || !root) 752 return; 753 754 mutex_lock(&psi->read_mutex); 755 if (psi->open && psi->open(psi)) 756 goto out; 757 758 /* 759 * Backend callback read() allocates record.buf. decompress_record() 760 * may reallocate record.buf. On success, pstore_mkfile() will keep 761 * the record.buf, so free it only on failure. 762 */ 763 for (; stop_loop; stop_loop--) { 764 struct pstore_record *record; 765 int rc; 766 767 record = kzalloc(sizeof(*record), GFP_KERNEL); 768 if (!record) { 769 pr_err("out of memory creating record\n"); 770 break; 771 } 772 pstore_record_init(record, psi); 773 774 record->size = psi->read(record); 775 776 /* No more records left in backend? */ 777 if (record->size <= 0) { 778 kfree(record); 779 break; 780 } 781 782 decompress_record(record); 783 rc = pstore_mkfile(root, record); 784 if (rc) { 785 /* pstore_mkfile() did not take record, so free it. */ 786 kfree(record->buf); 787 kfree(record->priv); 788 kfree(record); 789 if (rc != -EEXIST || !quiet) 790 failed++; 791 } 792 } 793 if (psi->close) 794 psi->close(psi); 795 out: 796 mutex_unlock(&psi->read_mutex); 797 798 if (failed) 799 pr_warn("failed to create %d record(s) from '%s'\n", 800 failed, psi->name); 801 if (!stop_loop) 802 pr_err("looping? Too many records seen from '%s'\n", 803 psi->name); 804 } 805 806 static void pstore_dowork(struct work_struct *work) 807 { 808 pstore_get_records(1); 809 } 810 811 static void pstore_timefunc(struct timer_list *unused) 812 { 813 if (pstore_new_entry) { 814 pstore_new_entry = 0; 815 schedule_work(&pstore_work); 816 } 817 818 pstore_timer_kick(); 819 } 820 821 static void __init pstore_choose_compression(void) 822 { 823 const struct pstore_zbackend *step; 824 825 if (!compress) 826 return; 827 828 for (step = zbackends; step->name; step++) { 829 if (!strcmp(compress, step->name)) { 830 zbackend = step; 831 return; 832 } 833 } 834 } 835 836 static int __init pstore_init(void) 837 { 838 int ret; 839 840 pstore_choose_compression(); 841 842 /* 843 * Check if any pstore backends registered earlier but did not 844 * initialize compression because crypto was not ready. If so, 845 * initialize compression now. 846 */ 847 allocate_buf_for_compression(); 848 849 ret = pstore_init_fs(); 850 if (ret) 851 free_buf_for_compression(); 852 853 return ret; 854 } 855 late_initcall(pstore_init); 856 857 static void __exit pstore_exit(void) 858 { 859 pstore_exit_fs(); 860 } 861 module_exit(pstore_exit) 862 863 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); 864 MODULE_LICENSE("GPL"); 865