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 /* 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_COMPRESS)) 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 struct kmsg_dump_iter iter; 389 unsigned long total = 0; 390 const char *why; 391 unsigned int part = 1; 392 int ret; 393 394 why = kmsg_dump_reason_str(reason); 395 396 if (down_trylock(&psinfo->buf_lock)) { 397 /* Failed to acquire lock: give up if we cannot wait. */ 398 if (pstore_cannot_wait(reason)) { 399 pr_err("dump skipped in %s path: may corrupt error record\n", 400 in_nmi() ? "NMI" : why); 401 return; 402 } 403 if (down_interruptible(&psinfo->buf_lock)) { 404 pr_err("could not grab semaphore?!\n"); 405 return; 406 } 407 } 408 409 kmsg_dump_rewind(&iter); 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(&iter, 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) { 463 pstore_new_entry = 1; 464 pstore_timer_kick(); 465 } 466 467 total += record.size; 468 part++; 469 } 470 471 up(&psinfo->buf_lock); 472 } 473 474 static struct kmsg_dumper pstore_dumper = { 475 .dump = pstore_dump, 476 }; 477 478 /* 479 * Register with kmsg_dump to save last part of console log on panic. 480 */ 481 static void pstore_register_kmsg(void) 482 { 483 kmsg_dump_register(&pstore_dumper); 484 } 485 486 static void pstore_unregister_kmsg(void) 487 { 488 kmsg_dump_unregister(&pstore_dumper); 489 } 490 491 #ifdef CONFIG_PSTORE_CONSOLE 492 static void pstore_console_write(struct console *con, const char *s, unsigned c) 493 { 494 struct pstore_record record; 495 496 if (!c) 497 return; 498 499 pstore_record_init(&record, psinfo); 500 record.type = PSTORE_TYPE_CONSOLE; 501 502 record.buf = (char *)s; 503 record.size = c; 504 psinfo->write(&record); 505 } 506 507 static struct console pstore_console = { 508 .write = pstore_console_write, 509 .index = -1, 510 }; 511 512 static void pstore_register_console(void) 513 { 514 /* Show which backend is going to get console writes. */ 515 strscpy(pstore_console.name, psinfo->name, 516 sizeof(pstore_console.name)); 517 /* 518 * Always initialize flags here since prior unregister_console() 519 * calls may have changed settings (specifically CON_ENABLED). 520 */ 521 pstore_console.flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME; 522 register_console(&pstore_console); 523 } 524 525 static void pstore_unregister_console(void) 526 { 527 unregister_console(&pstore_console); 528 } 529 #else 530 static void pstore_register_console(void) {} 531 static void pstore_unregister_console(void) {} 532 #endif 533 534 static int pstore_write_user_compat(struct pstore_record *record, 535 const char __user *buf) 536 { 537 int ret = 0; 538 539 if (record->buf) 540 return -EINVAL; 541 542 record->buf = memdup_user(buf, record->size); 543 if (IS_ERR(record->buf)) { 544 ret = PTR_ERR(record->buf); 545 goto out; 546 } 547 548 ret = record->psi->write(record); 549 550 kfree(record->buf); 551 out: 552 record->buf = NULL; 553 554 return unlikely(ret < 0) ? ret : record->size; 555 } 556 557 /* 558 * platform specific persistent storage driver registers with 559 * us here. If pstore is already mounted, call the platform 560 * read function right away to populate the file system. If not 561 * then the pstore mount code will call us later to fill out 562 * the file system. 563 */ 564 int pstore_register(struct pstore_info *psi) 565 { 566 if (backend && strcmp(backend, psi->name)) { 567 pr_warn("ignoring unexpected backend '%s'\n", psi->name); 568 return -EPERM; 569 } 570 571 /* Sanity check flags. */ 572 if (!psi->flags) { 573 pr_warn("backend '%s' must support at least one frontend\n", 574 psi->name); 575 return -EINVAL; 576 } 577 578 /* Check for required functions. */ 579 if (!psi->read || !psi->write) { 580 pr_warn("backend '%s' must implement read() and write()\n", 581 psi->name); 582 return -EINVAL; 583 } 584 585 mutex_lock(&psinfo_lock); 586 if (psinfo) { 587 pr_warn("backend '%s' already loaded: ignoring '%s'\n", 588 psinfo->name, psi->name); 589 mutex_unlock(&psinfo_lock); 590 return -EBUSY; 591 } 592 593 if (!psi->write_user) 594 psi->write_user = pstore_write_user_compat; 595 psinfo = psi; 596 mutex_init(&psinfo->read_mutex); 597 sema_init(&psinfo->buf_lock, 1); 598 599 if (psi->flags & PSTORE_FLAGS_DMESG) 600 allocate_buf_for_compression(); 601 602 pstore_get_records(0); 603 604 if (psi->flags & PSTORE_FLAGS_DMESG) { 605 pstore_dumper.max_reason = psinfo->max_reason; 606 pstore_register_kmsg(); 607 } 608 if (psi->flags & PSTORE_FLAGS_CONSOLE) 609 pstore_register_console(); 610 if (psi->flags & PSTORE_FLAGS_FTRACE) 611 pstore_register_ftrace(); 612 if (psi->flags & PSTORE_FLAGS_PMSG) 613 pstore_register_pmsg(); 614 615 /* Start watching for new records, if desired. */ 616 pstore_timer_kick(); 617 618 /* 619 * Update the module parameter backend, so it is visible 620 * through /sys/module/pstore/parameters/backend 621 */ 622 backend = kstrdup(psi->name, GFP_KERNEL); 623 624 pr_info("Registered %s as persistent store backend\n", psi->name); 625 626 mutex_unlock(&psinfo_lock); 627 return 0; 628 } 629 EXPORT_SYMBOL_GPL(pstore_register); 630 631 void pstore_unregister(struct pstore_info *psi) 632 { 633 /* It's okay to unregister nothing. */ 634 if (!psi) 635 return; 636 637 mutex_lock(&psinfo_lock); 638 639 /* Only one backend can be registered at a time. */ 640 if (WARN_ON(psi != psinfo)) { 641 mutex_unlock(&psinfo_lock); 642 return; 643 } 644 645 /* Unregister all callbacks. */ 646 if (psi->flags & PSTORE_FLAGS_PMSG) 647 pstore_unregister_pmsg(); 648 if (psi->flags & PSTORE_FLAGS_FTRACE) 649 pstore_unregister_ftrace(); 650 if (psi->flags & PSTORE_FLAGS_CONSOLE) 651 pstore_unregister_console(); 652 if (psi->flags & PSTORE_FLAGS_DMESG) 653 pstore_unregister_kmsg(); 654 655 /* Stop timer and make sure all work has finished. */ 656 del_timer_sync(&pstore_timer); 657 flush_work(&pstore_work); 658 659 /* Remove all backend records from filesystem tree. */ 660 pstore_put_backend_records(psi); 661 662 free_buf_for_compression(); 663 664 psinfo = NULL; 665 kfree(backend); 666 backend = NULL; 667 mutex_unlock(&psinfo_lock); 668 } 669 EXPORT_SYMBOL_GPL(pstore_unregister); 670 671 static void decompress_record(struct pstore_record *record) 672 { 673 int ret; 674 int unzipped_len; 675 char *unzipped, *workspace; 676 677 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed) 678 return; 679 680 /* Only PSTORE_TYPE_DMESG support compression. */ 681 if (record->type != PSTORE_TYPE_DMESG) { 682 pr_warn("ignored compressed record type %d\n", record->type); 683 return; 684 } 685 686 /* Missing compression buffer means compression was not initialized. */ 687 if (!big_oops_buf) { 688 pr_warn("no decompression method initialized!\n"); 689 return; 690 } 691 692 /* Allocate enough space to hold max decompression and ECC. */ 693 unzipped_len = big_oops_buf_sz; 694 workspace = kmalloc(unzipped_len + record->ecc_notice_size, 695 GFP_KERNEL); 696 if (!workspace) 697 return; 698 699 /* After decompression "unzipped_len" is almost certainly smaller. */ 700 ret = crypto_comp_decompress(tfm, record->buf, record->size, 701 workspace, &unzipped_len); 702 if (ret) { 703 pr_err("crypto_comp_decompress failed, ret = %d!\n", ret); 704 kfree(workspace); 705 return; 706 } 707 708 /* Append ECC notice to decompressed buffer. */ 709 memcpy(workspace + unzipped_len, record->buf + record->size, 710 record->ecc_notice_size); 711 712 /* Copy decompressed contents into an minimum-sized allocation. */ 713 unzipped = kmemdup(workspace, unzipped_len + record->ecc_notice_size, 714 GFP_KERNEL); 715 kfree(workspace); 716 if (!unzipped) 717 return; 718 719 /* Swap out compressed contents with decompressed contents. */ 720 kfree(record->buf); 721 record->buf = unzipped; 722 record->size = unzipped_len; 723 record->compressed = false; 724 } 725 726 /* 727 * Read all the records from one persistent store backend. Create 728 * files in our filesystem. Don't warn about -EEXIST errors 729 * when we are re-scanning the backing store looking to add new 730 * error records. 731 */ 732 void pstore_get_backend_records(struct pstore_info *psi, 733 struct dentry *root, int quiet) 734 { 735 int failed = 0; 736 unsigned int stop_loop = 65536; 737 738 if (!psi || !root) 739 return; 740 741 mutex_lock(&psi->read_mutex); 742 if (psi->open && psi->open(psi)) 743 goto out; 744 745 /* 746 * Backend callback read() allocates record.buf. decompress_record() 747 * may reallocate record.buf. On success, pstore_mkfile() will keep 748 * the record.buf, so free it only on failure. 749 */ 750 for (; stop_loop; stop_loop--) { 751 struct pstore_record *record; 752 int rc; 753 754 record = kzalloc(sizeof(*record), GFP_KERNEL); 755 if (!record) { 756 pr_err("out of memory creating record\n"); 757 break; 758 } 759 pstore_record_init(record, psi); 760 761 record->size = psi->read(record); 762 763 /* No more records left in backend? */ 764 if (record->size <= 0) { 765 kfree(record); 766 break; 767 } 768 769 decompress_record(record); 770 rc = pstore_mkfile(root, record); 771 if (rc) { 772 /* pstore_mkfile() did not take record, so free it. */ 773 kfree(record->buf); 774 kfree(record); 775 if (rc != -EEXIST || !quiet) 776 failed++; 777 } 778 } 779 if (psi->close) 780 psi->close(psi); 781 out: 782 mutex_unlock(&psi->read_mutex); 783 784 if (failed) 785 pr_warn("failed to create %d record(s) from '%s'\n", 786 failed, psi->name); 787 if (!stop_loop) 788 pr_err("looping? Too many records seen from '%s'\n", 789 psi->name); 790 } 791 792 static void pstore_dowork(struct work_struct *work) 793 { 794 pstore_get_records(1); 795 } 796 797 static void pstore_timefunc(struct timer_list *unused) 798 { 799 if (pstore_new_entry) { 800 pstore_new_entry = 0; 801 schedule_work(&pstore_work); 802 } 803 804 pstore_timer_kick(); 805 } 806 807 static void __init pstore_choose_compression(void) 808 { 809 const struct pstore_zbackend *step; 810 811 if (!compress) 812 return; 813 814 for (step = zbackends; step->name; step++) { 815 if (!strcmp(compress, step->name)) { 816 zbackend = step; 817 return; 818 } 819 } 820 } 821 822 static int __init pstore_init(void) 823 { 824 int ret; 825 826 pstore_choose_compression(); 827 828 /* 829 * Check if any pstore backends registered earlier but did not 830 * initialize compression because crypto was not ready. If so, 831 * initialize compression now. 832 */ 833 allocate_buf_for_compression(); 834 835 ret = pstore_init_fs(); 836 if (ret) 837 free_buf_for_compression(); 838 839 return ret; 840 } 841 late_initcall(pstore_init); 842 843 static void __exit pstore_exit(void) 844 { 845 pstore_exit_fs(); 846 } 847 module_exit(pstore_exit) 848 849 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); 850 MODULE_LICENSE("GPL"); 851