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