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 is not 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 * pstore_lock just protects "psinfo" during 73 * calls to pstore_register() 74 */ 75 static DEFINE_SPINLOCK(pstore_lock); 76 struct pstore_info *psinfo; 77 78 static char *backend; 79 static char *compress = 80 #ifdef CONFIG_PSTORE_COMPRESS_DEFAULT 81 CONFIG_PSTORE_COMPRESS_DEFAULT; 82 #else 83 NULL; 84 #endif 85 86 /* Compression parameters */ 87 static struct crypto_comp *tfm; 88 89 struct pstore_zbackend { 90 int (*zbufsize)(size_t size); 91 const char *name; 92 }; 93 94 static char *big_oops_buf; 95 static size_t big_oops_buf_sz; 96 97 /* How much of the console log to snapshot */ 98 unsigned long kmsg_bytes = PSTORE_DEFAULT_KMSG_BYTES; 99 100 void pstore_set_kmsg_bytes(int bytes) 101 { 102 kmsg_bytes = bytes; 103 } 104 105 /* Tag each group of saved records with a sequence number */ 106 static int oopscount; 107 108 const char *pstore_type_to_name(enum pstore_type_id type) 109 { 110 BUILD_BUG_ON(ARRAY_SIZE(pstore_type_names) != PSTORE_TYPE_MAX); 111 112 if (WARN_ON_ONCE(type >= PSTORE_TYPE_MAX)) 113 return "unknown"; 114 115 return pstore_type_names[type]; 116 } 117 EXPORT_SYMBOL_GPL(pstore_type_to_name); 118 119 enum pstore_type_id pstore_name_to_type(const char *name) 120 { 121 int i; 122 123 for (i = 0; i < PSTORE_TYPE_MAX; i++) { 124 if (!strcmp(pstore_type_names[i], name)) 125 return i; 126 } 127 128 return PSTORE_TYPE_MAX; 129 } 130 EXPORT_SYMBOL_GPL(pstore_name_to_type); 131 132 static const char *get_reason_str(enum kmsg_dump_reason reason) 133 { 134 switch (reason) { 135 case KMSG_DUMP_PANIC: 136 return "Panic"; 137 case KMSG_DUMP_OOPS: 138 return "Oops"; 139 case KMSG_DUMP_EMERG: 140 return "Emergency"; 141 case KMSG_DUMP_RESTART: 142 return "Restart"; 143 case KMSG_DUMP_HALT: 144 return "Halt"; 145 case KMSG_DUMP_POWEROFF: 146 return "Poweroff"; 147 default: 148 return "Unknown"; 149 } 150 } 151 152 /* 153 * Should pstore_dump() wait for a concurrent pstore_dump()? If 154 * not, the current pstore_dump() will report a failure to dump 155 * and return. 156 */ 157 static bool pstore_cannot_wait(enum kmsg_dump_reason reason) 158 { 159 /* In NMI path, pstore shouldn't block regardless of reason. */ 160 if (in_nmi()) 161 return true; 162 163 switch (reason) { 164 /* In panic case, other cpus are stopped by smp_send_stop(). */ 165 case KMSG_DUMP_PANIC: 166 /* Emergency restart shouldn't be blocked. */ 167 case KMSG_DUMP_EMERG: 168 return true; 169 default: 170 return false; 171 } 172 } 173 174 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) 175 static int zbufsize_deflate(size_t size) 176 { 177 size_t cmpr; 178 179 switch (size) { 180 /* buffer range for efivars */ 181 case 1000 ... 2000: 182 cmpr = 56; 183 break; 184 case 2001 ... 3000: 185 cmpr = 54; 186 break; 187 case 3001 ... 3999: 188 cmpr = 52; 189 break; 190 /* buffer range for nvram, erst */ 191 case 4000 ... 10000: 192 cmpr = 45; 193 break; 194 default: 195 cmpr = 60; 196 break; 197 } 198 199 return (size * 100) / cmpr; 200 } 201 #endif 202 203 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) 204 static int zbufsize_lzo(size_t size) 205 { 206 return lzo1x_worst_compress(size); 207 } 208 #endif 209 210 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) 211 static int zbufsize_lz4(size_t size) 212 { 213 return LZ4_compressBound(size); 214 } 215 #endif 216 217 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) 218 static int zbufsize_842(size_t size) 219 { 220 return size; 221 } 222 #endif 223 224 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS) 225 static int zbufsize_zstd(size_t size) 226 { 227 return ZSTD_compressBound(size); 228 } 229 #endif 230 231 static const struct pstore_zbackend *zbackend __ro_after_init; 232 233 static const struct pstore_zbackend zbackends[] = { 234 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) 235 { 236 .zbufsize = zbufsize_deflate, 237 .name = "deflate", 238 }, 239 #endif 240 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) 241 { 242 .zbufsize = zbufsize_lzo, 243 .name = "lzo", 244 }, 245 #endif 246 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) 247 { 248 .zbufsize = zbufsize_lz4, 249 .name = "lz4", 250 }, 251 #endif 252 #if IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) 253 { 254 .zbufsize = zbufsize_lz4, 255 .name = "lz4hc", 256 }, 257 #endif 258 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) 259 { 260 .zbufsize = zbufsize_842, 261 .name = "842", 262 }, 263 #endif 264 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS) 265 { 266 .zbufsize = zbufsize_zstd, 267 .name = "zstd", 268 }, 269 #endif 270 { } 271 }; 272 273 static int pstore_compress(const void *in, void *out, 274 unsigned int inlen, unsigned int outlen) 275 { 276 int ret; 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 unsigned long total = 0; 392 const char *why; 393 unsigned int part = 1; 394 int ret; 395 396 why = get_reason_str(reason); 397 398 if (down_trylock(&psinfo->buf_lock)) { 399 /* Failed to acquire lock: give up if we cannot wait. */ 400 if (pstore_cannot_wait(reason)) { 401 pr_err("dump skipped in %s path: may corrupt error record\n", 402 in_nmi() ? "NMI" : why); 403 return; 404 } 405 if (down_interruptible(&psinfo->buf_lock)) { 406 pr_err("could not grab semaphore?!\n"); 407 return; 408 } 409 } 410 411 oopscount++; 412 while (total < kmsg_bytes) { 413 char *dst; 414 size_t dst_size; 415 int header_size; 416 int zipped_len = -1; 417 size_t dump_size; 418 struct pstore_record record; 419 420 pstore_record_init(&record, psinfo); 421 record.type = PSTORE_TYPE_DMESG; 422 record.count = oopscount; 423 record.reason = reason; 424 record.part = part; 425 record.buf = psinfo->buf; 426 427 if (big_oops_buf) { 428 dst = big_oops_buf; 429 dst_size = big_oops_buf_sz; 430 } else { 431 dst = psinfo->buf; 432 dst_size = psinfo->bufsize; 433 } 434 435 /* Write dump header. */ 436 header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why, 437 oopscount, part); 438 dst_size -= header_size; 439 440 /* Write dump contents. */ 441 if (!kmsg_dump_get_buffer(dumper, true, dst + header_size, 442 dst_size, &dump_size)) 443 break; 444 445 if (big_oops_buf) { 446 zipped_len = pstore_compress(dst, psinfo->buf, 447 header_size + dump_size, 448 psinfo->bufsize); 449 450 if (zipped_len > 0) { 451 record.compressed = true; 452 record.size = zipped_len; 453 } else { 454 record.size = copy_kmsg_to_buffer(header_size, 455 dump_size); 456 } 457 } else { 458 record.size = header_size + dump_size; 459 } 460 461 ret = psinfo->write(&record); 462 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 463 pstore_new_entry = 1; 464 465 total += record.size; 466 part++; 467 } 468 469 up(&psinfo->buf_lock); 470 } 471 472 static struct kmsg_dumper pstore_dumper = { 473 .dump = pstore_dump, 474 }; 475 476 /* 477 * Register with kmsg_dump to save last part of console log on panic. 478 */ 479 static void pstore_register_kmsg(void) 480 { 481 kmsg_dump_register(&pstore_dumper); 482 } 483 484 static void pstore_unregister_kmsg(void) 485 { 486 kmsg_dump_unregister(&pstore_dumper); 487 } 488 489 #ifdef CONFIG_PSTORE_CONSOLE 490 static void pstore_console_write(struct console *con, const char *s, unsigned c) 491 { 492 struct pstore_record record; 493 494 if (!c) 495 return; 496 497 pstore_record_init(&record, psinfo); 498 record.type = PSTORE_TYPE_CONSOLE; 499 500 record.buf = (char *)s; 501 record.size = c; 502 psinfo->write(&record); 503 } 504 505 static struct console pstore_console = { 506 .name = "pstore", 507 .write = pstore_console_write, 508 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 509 .index = -1, 510 }; 511 512 static void pstore_register_console(void) 513 { 514 register_console(&pstore_console); 515 } 516 517 static void pstore_unregister_console(void) 518 { 519 unregister_console(&pstore_console); 520 } 521 #else 522 static void pstore_register_console(void) {} 523 static void pstore_unregister_console(void) {} 524 #endif 525 526 static int pstore_write_user_compat(struct pstore_record *record, 527 const char __user *buf) 528 { 529 int ret = 0; 530 531 if (record->buf) 532 return -EINVAL; 533 534 record->buf = memdup_user(buf, record->size); 535 if (IS_ERR(record->buf)) { 536 ret = PTR_ERR(record->buf); 537 goto out; 538 } 539 540 ret = record->psi->write(record); 541 542 kfree(record->buf); 543 out: 544 record->buf = NULL; 545 546 return unlikely(ret < 0) ? ret : record->size; 547 } 548 549 /* 550 * platform specific persistent storage driver registers with 551 * us here. If pstore is already mounted, call the platform 552 * read function right away to populate the file system. If not 553 * then the pstore mount code will call us later to fill out 554 * the file system. 555 */ 556 int pstore_register(struct pstore_info *psi) 557 { 558 struct module *owner = psi->owner; 559 560 if (backend && strcmp(backend, psi->name)) { 561 pr_warn("ignoring unexpected backend '%s'\n", psi->name); 562 return -EPERM; 563 } 564 565 /* Sanity check flags. */ 566 if (!psi->flags) { 567 pr_warn("backend '%s' must support at least one frontend\n", 568 psi->name); 569 return -EINVAL; 570 } 571 572 /* Check for required functions. */ 573 if (!psi->read || !psi->write) { 574 pr_warn("backend '%s' must implement read() and write()\n", 575 psi->name); 576 return -EINVAL; 577 } 578 579 spin_lock(&pstore_lock); 580 if (psinfo) { 581 pr_warn("backend '%s' already loaded: ignoring '%s'\n", 582 psinfo->name, psi->name); 583 spin_unlock(&pstore_lock); 584 return -EBUSY; 585 } 586 587 if (!psi->write_user) 588 psi->write_user = pstore_write_user_compat; 589 psinfo = psi; 590 mutex_init(&psinfo->read_mutex); 591 sema_init(&psinfo->buf_lock, 1); 592 spin_unlock(&pstore_lock); 593 594 if (owner && !try_module_get(owner)) { 595 psinfo = NULL; 596 return -EINVAL; 597 } 598 599 if (psi->flags & PSTORE_FLAGS_DMESG) 600 allocate_buf_for_compression(); 601 602 if (pstore_is_mounted()) 603 pstore_get_records(0); 604 605 if (psi->flags & PSTORE_FLAGS_DMESG) 606 pstore_register_kmsg(); 607 if (psi->flags & PSTORE_FLAGS_CONSOLE) 608 pstore_register_console(); 609 if (psi->flags & PSTORE_FLAGS_FTRACE) 610 pstore_register_ftrace(); 611 if (psi->flags & PSTORE_FLAGS_PMSG) 612 pstore_register_pmsg(); 613 614 /* Start watching for new records, if desired. */ 615 if (pstore_update_ms >= 0) { 616 pstore_timer.expires = jiffies + 617 msecs_to_jiffies(pstore_update_ms); 618 add_timer(&pstore_timer); 619 } 620 621 /* 622 * Update the module parameter backend, so it is visible 623 * through /sys/module/pstore/parameters/backend 624 */ 625 backend = psi->name; 626 627 pr_info("Registered %s as persistent store backend\n", psi->name); 628 629 module_put(owner); 630 631 return 0; 632 } 633 EXPORT_SYMBOL_GPL(pstore_register); 634 635 void pstore_unregister(struct pstore_info *psi) 636 { 637 /* Stop timer and make sure all work has finished. */ 638 pstore_update_ms = -1; 639 del_timer_sync(&pstore_timer); 640 flush_work(&pstore_work); 641 642 if (psi->flags & PSTORE_FLAGS_PMSG) 643 pstore_unregister_pmsg(); 644 if (psi->flags & PSTORE_FLAGS_FTRACE) 645 pstore_unregister_ftrace(); 646 if (psi->flags & PSTORE_FLAGS_CONSOLE) 647 pstore_unregister_console(); 648 if (psi->flags & PSTORE_FLAGS_DMESG) 649 pstore_unregister_kmsg(); 650 651 free_buf_for_compression(); 652 653 psinfo = NULL; 654 backend = NULL; 655 } 656 EXPORT_SYMBOL_GPL(pstore_unregister); 657 658 static void decompress_record(struct pstore_record *record) 659 { 660 int ret; 661 int unzipped_len; 662 char *unzipped, *workspace; 663 664 if (!record->compressed) 665 return; 666 667 /* Only PSTORE_TYPE_DMESG support compression. */ 668 if (record->type != PSTORE_TYPE_DMESG) { 669 pr_warn("ignored compressed record type %d\n", record->type); 670 return; 671 } 672 673 /* Missing compression buffer means compression was not initialized. */ 674 if (!big_oops_buf) { 675 pr_warn("no decompression method initialized!\n"); 676 return; 677 } 678 679 /* Allocate enough space to hold max decompression and ECC. */ 680 unzipped_len = big_oops_buf_sz; 681 workspace = kmalloc(unzipped_len + record->ecc_notice_size, 682 GFP_KERNEL); 683 if (!workspace) 684 return; 685 686 /* After decompression "unzipped_len" is almost certainly smaller. */ 687 ret = crypto_comp_decompress(tfm, record->buf, record->size, 688 workspace, &unzipped_len); 689 if (ret) { 690 pr_err("crypto_comp_decompress failed, ret = %d!\n", ret); 691 kfree(workspace); 692 return; 693 } 694 695 /* Append ECC notice to decompressed buffer. */ 696 memcpy(workspace + unzipped_len, record->buf + record->size, 697 record->ecc_notice_size); 698 699 /* Copy decompressed contents into an minimum-sized allocation. */ 700 unzipped = kmemdup(workspace, unzipped_len + record->ecc_notice_size, 701 GFP_KERNEL); 702 kfree(workspace); 703 if (!unzipped) 704 return; 705 706 /* Swap out compressed contents with decompressed contents. */ 707 kfree(record->buf); 708 record->buf = unzipped; 709 record->size = unzipped_len; 710 record->compressed = false; 711 } 712 713 /* 714 * Read all the records from one persistent store backend. Create 715 * files in our filesystem. Don't warn about -EEXIST errors 716 * when we are re-scanning the backing store looking to add new 717 * error records. 718 */ 719 void pstore_get_backend_records(struct pstore_info *psi, 720 struct dentry *root, int quiet) 721 { 722 int failed = 0; 723 unsigned int stop_loop = 65536; 724 725 if (!psi || !root) 726 return; 727 728 mutex_lock(&psi->read_mutex); 729 if (psi->open && psi->open(psi)) 730 goto out; 731 732 /* 733 * Backend callback read() allocates record.buf. decompress_record() 734 * may reallocate record.buf. On success, pstore_mkfile() will keep 735 * the record.buf, so free it only on failure. 736 */ 737 for (; stop_loop; stop_loop--) { 738 struct pstore_record *record; 739 int rc; 740 741 record = kzalloc(sizeof(*record), GFP_KERNEL); 742 if (!record) { 743 pr_err("out of memory creating record\n"); 744 break; 745 } 746 pstore_record_init(record, psi); 747 748 record->size = psi->read(record); 749 750 /* No more records left in backend? */ 751 if (record->size <= 0) { 752 kfree(record); 753 break; 754 } 755 756 decompress_record(record); 757 rc = pstore_mkfile(root, record); 758 if (rc) { 759 /* pstore_mkfile() did not take record, so free it. */ 760 kfree(record->buf); 761 kfree(record); 762 if (rc != -EEXIST || !quiet) 763 failed++; 764 } 765 } 766 if (psi->close) 767 psi->close(psi); 768 out: 769 mutex_unlock(&psi->read_mutex); 770 771 if (failed) 772 pr_warn("failed to create %d record(s) from '%s'\n", 773 failed, psi->name); 774 if (!stop_loop) 775 pr_err("looping? Too many records seen from '%s'\n", 776 psi->name); 777 } 778 779 static void pstore_dowork(struct work_struct *work) 780 { 781 pstore_get_records(1); 782 } 783 784 static void pstore_timefunc(struct timer_list *unused) 785 { 786 if (pstore_new_entry) { 787 pstore_new_entry = 0; 788 schedule_work(&pstore_work); 789 } 790 791 if (pstore_update_ms >= 0) 792 mod_timer(&pstore_timer, 793 jiffies + msecs_to_jiffies(pstore_update_ms)); 794 } 795 796 void __init pstore_choose_compression(void) 797 { 798 const struct pstore_zbackend *step; 799 800 if (!compress) 801 return; 802 803 for (step = zbackends; step->name; step++) { 804 if (!strcmp(compress, step->name)) { 805 zbackend = step; 806 return; 807 } 808 } 809 } 810 811 static int __init pstore_init(void) 812 { 813 int ret; 814 815 pstore_choose_compression(); 816 817 /* 818 * Check if any pstore backends registered earlier but did not 819 * initialize compression because crypto was not ready. If so, 820 * initialize compression now. 821 */ 822 allocate_buf_for_compression(); 823 824 ret = pstore_init_fs(); 825 if (ret) 826 return ret; 827 828 return 0; 829 } 830 late_initcall(pstore_init); 831 832 static void __exit pstore_exit(void) 833 { 834 pstore_exit_fs(); 835 } 836 module_exit(pstore_exit) 837 838 module_param(compress, charp, 0444); 839 MODULE_PARM_DESC(compress, "Pstore compression to use"); 840 841 module_param(backend, charp, 0444); 842 MODULE_PARM_DESC(backend, "Pstore backend to use"); 843 844 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); 845 MODULE_LICENSE("GPL"); 846