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