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