fs/pstore/platform.c

   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/mm.h>
  18 #include <linux/module.h>
  19 #include <linux/pstore.h>
  20 #include <linux/string.h>
  21 #include <linux/timer.h>
  22 #include <linux/slab.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/vmalloc.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/zlib.h>
  28
  29 #include "internal.h"
  30
  31 /*
  32  * We defer making "oops" entries appear in pstore - see
  33  * whether the system is actually still running well enough
  34  * to let someone see the entry
  35  */
  36 static int pstore_update_ms = -1;
  37 module_param_named(update_ms, pstore_update_ms, int, 0600);
  38 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content "
  39                  "(default is -1, which means runtime updates are disabled; "
  40                  "enabling this option may not be safe; it may lead to further "
  41                  "corruption on Oopses)");
  42
  43 /* Names should be in the same order as the enum pstore_type_id */
  44 static const char * const pstore_type_names[] = {
  45         "dmesg",
  46         "mce",
  47         "console",
  48         "ftrace",
  49         "rtas",
  50         "powerpc-ofw",
  51         "powerpc-common",
  52         "pmsg",
  53         "powerpc-opal",
  54 };
  55
  56 static int pstore_new_entry;
  57
  58 static void pstore_timefunc(struct timer_list *);
  59 static DEFINE_TIMER(pstore_timer, pstore_timefunc);
  60
  61 static void pstore_dowork(struct work_struct *);
  62 static DECLARE_WORK(pstore_work, pstore_dowork);
  63
  64 /*
  65  * psinfo_lock protects "psinfo" during calls to
  66  * pstore_register(), pstore_unregister(), and
  67  * the filesystem mount/unmount routines.
  68  */
  69 static DEFINE_MUTEX(psinfo_lock);
  70 struct pstore_info *psinfo;
  71
  72 static char *backend;
  73 module_param(backend, charp, 0444);
  74 MODULE_PARM_DESC(backend, "specific backend to use");
  75
  76 /*
  77  * pstore no longer implements compression via the crypto API, and only
  78  * supports zlib deflate compression implemented using the zlib library
  79  * interface. This removes additional complexity which is hard to justify for a
  80  * diagnostic facility that has to operate in conditions where the system may
  81  * have become unstable. Zlib deflate is comparatively small in terms of code
  82  * size, and compresses ASCII text comparatively well. In terms of compression
  83  * speed, deflate is not the best performer but for recording the log output on
  84  * a kernel panic, this is not considered critical.
  85  *
  86  * The only remaining arguments supported by the compress= module parameter are
  87  * 'deflate' and 'none'. To retain compatibility with existing installations,
  88  * all other values are logged and replaced with 'deflate'.
  89  */
  90 static char *compress = "deflate";
  91 module_param(compress, charp, 0444);
  92 MODULE_PARM_DESC(compress, "compression to use");
  93
  94 /* How much of the kernel log to snapshot */
  95 unsigned long kmsg_bytes = CONFIG_PSTORE_DEFAULT_KMSG_BYTES;
  96 module_param(kmsg_bytes, ulong, 0444);
  97 MODULE_PARM_DESC(kmsg_bytes, "amount of kernel log to snapshot (in bytes)");
  98
  99 static void *compress_workspace;
 100
 101 /*
 102  * Compression is only used for dmesg output, which consists of low-entropy
 103  * ASCII text, and so we can assume worst-case 60%.
 104  */
 105 #define DMESG_COMP_PERCENT      60
 106
 107 static char *big_oops_buf;
 108 static size_t max_compressed_size;
 109
 110 void pstore_set_kmsg_bytes(int bytes)
 111 {
 112         kmsg_bytes = bytes;
 113 }
 114
 115 /* Tag each group of saved records with a sequence number */
 116 static int      oopscount;
 117
 118 const char *pstore_type_to_name(enum pstore_type_id type)
 119 {
 120         BUILD_BUG_ON(ARRAY_SIZE(pstore_type_names) != PSTORE_TYPE_MAX);
 121
 122         if (WARN_ON_ONCE(type >= PSTORE_TYPE_MAX))
 123                 return "unknown";
 124
 125         return pstore_type_names[type];
 126 }
 127 EXPORT_SYMBOL_GPL(pstore_type_to_name);
 128
 129 enum pstore_type_id pstore_name_to_type(const char *name)
 130 {
 131         int i;
 132
 133         for (i = 0; i < PSTORE_TYPE_MAX; i++) {
 134                 if (!strcmp(pstore_type_names[i], name))
 135                         return i;
 136         }
 137
 138         return PSTORE_TYPE_MAX;
 139 }
 140 EXPORT_SYMBOL_GPL(pstore_name_to_type);
 141
 142 static void pstore_timer_kick(void)
 143 {
 144         if (pstore_update_ms < 0)
 145                 return;
 146
 147         mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms));
 148 }
 149
 150 static bool pstore_cannot_block_path(enum kmsg_dump_reason reason)
 151 {
 152         /*
 153          * In case of NMI path, pstore shouldn't be blocked
 154          * regardless of reason.
 155          */
 156         if (in_nmi())
 157                 return true;
 158
 159         switch (reason) {
 160         /* In panic case, other cpus are stopped by smp_send_stop(). */
 161         case KMSG_DUMP_PANIC:
 162         /*
 163          * Emergency restart shouldn't be blocked by spinning on
 164          * pstore_info::buf_lock.
 165          */
 166         case KMSG_DUMP_EMERG:
 167                 return true;
 168         default:
 169                 return false;
 170         }
 171 }
 172
 173 static int pstore_compress(const void *in, void *out,
 174                            unsigned int inlen, unsigned int outlen)
 175 {
 176         struct z_stream_s zstream = {
 177                 .next_in        = in,
 178                 .avail_in       = inlen,
 179                 .next_out       = out,
 180                 .avail_out      = outlen,
 181                 .workspace      = compress_workspace,
 182         };
 183         int ret;
 184
 185         if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS))
 186                 return -EINVAL;
 187
 188         ret = zlib_deflateInit2(&zstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 189                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
 190         if (ret != Z_OK)
 191                 return -EINVAL;
 192
 193         ret = zlib_deflate(&zstream, Z_FINISH);
 194         if (ret != Z_STREAM_END)
 195                 return -EINVAL;
 196
 197         ret = zlib_deflateEnd(&zstream);
 198         if (ret != Z_OK)
 199                 pr_warn_once("zlib_deflateEnd() failed: %d\n", ret);
 200
 201         return zstream.total_out;
 202 }
 203
 204 static void allocate_buf_for_compression(void)
 205 {
 206         size_t compressed_size;
 207         char *buf;
 208
 209         /* Skip if not built-in or compression disabled. */
 210         if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !compress ||
 211             !strcmp(compress, "none")) {
 212                 compress = NULL;
 213                 return;
 214         }
 215
 216         if (strcmp(compress, "deflate")) {
 217                 pr_err("Unsupported compression '%s', falling back to deflate\n",
 218                        compress);
 219                 compress = "deflate";
 220         }
 221
 222         /*
 223          * The compression buffer only needs to be as large as the maximum
 224          * uncompressed record size, since any record that would be expanded by
 225          * compression is just stored uncompressed.
 226          */
 227         compressed_size = (psinfo->bufsize * 100) / DMESG_COMP_PERCENT;
 228         buf = kvzalloc(compressed_size, GFP_KERNEL);
 229         if (!buf) {
 230                 pr_err("Failed %zu byte compression buffer allocation for: %s\n",
 231                        psinfo->bufsize, compress);
 232                 return;
 233         }
 234
 235         compress_workspace =
 236                 vmalloc(zlib_deflate_workspacesize(MAX_WBITS, DEF_MEM_LEVEL));
 237         if (!compress_workspace) {
 238                 pr_err("Failed to allocate zlib deflate workspace\n");
 239                 kvfree(buf);
 240                 return;
 241         }
 242
 243         /* A non-NULL big_oops_buf indicates compression is available. */
 244         big_oops_buf = buf;
 245         max_compressed_size = compressed_size;
 246
 247         pr_info("Using crash dump compression: %s\n", compress);
 248 }
 249
 250 static void free_buf_for_compression(void)
 251 {
 252         if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress_workspace) {
 253                 vfree(compress_workspace);
 254                 compress_workspace = NULL;
 255         }
 256
 257         kvfree(big_oops_buf);
 258         big_oops_buf = NULL;
 259         max_compressed_size = 0;
 260 }
 261
 262 void pstore_record_init(struct pstore_record *record,
 263                         struct pstore_info *psinfo)
 264 {
 265         memset(record, 0, sizeof(*record));
 266
 267         record->psi = psinfo;
 268
 269         /* Report zeroed timestamp if called before timekeeping has resumed. */
 270         record->time = ns_to_timespec64(ktime_get_real_fast_ns());
 271 }
 272
 273 /*
 274  * callback from kmsg_dump. Save as much as we can (up to kmsg_bytes) from the
 275  * end of the buffer.
 276  */
 277 static void pstore_dump(struct kmsg_dumper *dumper,
 278                         enum kmsg_dump_reason reason)
 279 {
 280         struct kmsg_dump_iter iter;
 281         unsigned long   total = 0;
 282         const char      *why;
 283         unsigned int    part = 1;
 284         unsigned long   flags = 0;
 285         int             saved_ret = 0;
 286         int             ret;
 287
 288         why = kmsg_dump_reason_str(reason);
 289
 290         if (pstore_cannot_block_path(reason)) {
 291                 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) {
 292                         pr_err("dump skipped in %s path because of concurrent dump\n",
 293                                         in_nmi() ? "NMI" : why);
 294                         return;
 295                 }
 296         } else {
 297                 spin_lock_irqsave(&psinfo->buf_lock, flags);
 298         }
 299
 300         kmsg_dump_rewind(&iter);
 301
 302         oopscount++;
 303         while (total < kmsg_bytes) {
 304                 char *dst;
 305                 size_t dst_size;
 306                 int header_size;
 307                 int zipped_len = -1;
 308                 size_t dump_size;
 309                 struct pstore_record record;
 310
 311                 pstore_record_init(&record, psinfo);
 312                 record.type = PSTORE_TYPE_DMESG;
 313                 record.count = oopscount;
 314                 record.reason = reason;
 315                 record.part = part;
 316                 record.buf = psinfo->buf;
 317
 318                 dst = big_oops_buf ?: psinfo->buf;
 319                 dst_size = max_compressed_size ?: psinfo->bufsize;
 320
 321                 /* Write dump header. */
 322                 header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why,
 323                                  oopscount, part);
 324                 dst_size -= header_size;
 325
 326                 /* Write dump contents. */
 327                 if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,
 328                                           dst_size, &dump_size))
 329                         break;
 330
 331                 if (big_oops_buf) {
 332                         zipped_len = pstore_compress(dst, psinfo->buf,
 333                                                 header_size + dump_size,
 334                                                 psinfo->bufsize);
 335
 336                         if (zipped_len > 0) {
 337                                 record.compressed = true;
 338                                 record.size = zipped_len;
 339                         } else {
 340                                 /*
 341                                  * Compression failed, so the buffer is most
 342                                  * likely filled with binary data that does not
 343                                  * compress as well as ASCII text. Copy as much
 344                                  * of the uncompressed data as possible into
 345                                  * the pstore record, and discard the rest.
 346                                  */
 347                                 record.size = psinfo->bufsize;
 348                                 memcpy(psinfo->buf, dst, psinfo->bufsize);
 349                         }
 350                 } else {
 351                         record.size = header_size + dump_size;
 352                 }
 353
 354                 ret = psinfo->write(&record);
 355                 if (ret == 0 && reason == KMSG_DUMP_OOPS) {
 356                         pstore_new_entry = 1;
 357                         pstore_timer_kick();
 358                 } else {
 359                         /* Preserve only the first non-zero returned value. */
 360                         if (!saved_ret)
 361                                 saved_ret = ret;
 362                 }
 363
 364                 total += record.size;
 365                 part++;
 366         }
 367         spin_unlock_irqrestore(&psinfo->buf_lock, flags);
 368
 369         if (saved_ret) {
 370                 pr_err_once("backend (%s) writing error (%d)\n", psinfo->name,
 371                             saved_ret);
 372         }
 373 }
 374
 375 static struct kmsg_dumper pstore_dumper = {
 376         .dump = pstore_dump,
 377 };
 378
 379 /*
 380  * Register with kmsg_dump to save last part of console log on panic.
 381  */
 382 static void pstore_register_kmsg(void)
 383 {
 384         kmsg_dump_register(&pstore_dumper);
 385 }
 386
 387 static void pstore_unregister_kmsg(void)
 388 {
 389         kmsg_dump_unregister(&pstore_dumper);
 390 }
 391
 392 #ifdef CONFIG_PSTORE_CONSOLE
 393 static void pstore_console_write(struct console *con, const char *s, unsigned c)
 394 {
 395         struct pstore_record record;
 396
 397         if (!c)
 398                 return;
 399
 400         pstore_record_init(&record, psinfo);
 401         record.type = PSTORE_TYPE_CONSOLE;
 402
 403         record.buf = (char *)s;
 404         record.size = c;
 405         psinfo->write(&record);
 406 }
 407
 408 static struct console pstore_console = {
 409         .write  = pstore_console_write,
 410         .index  = -1,
 411 };
 412
 413 static void pstore_register_console(void)
 414 {
 415         /* Show which backend is going to get console writes. */
 416         strscpy(pstore_console.name, psinfo->name,
 417                 sizeof(pstore_console.name));
 418         /*
 419          * Always initialize flags here since prior unregister_console()
 420          * calls may have changed settings (specifically CON_ENABLED).
 421          */
 422         pstore_console.flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME;
 423         register_console(&pstore_console);
 424 }
 425
 426 static void pstore_unregister_console(void)
 427 {
 428         unregister_console(&pstore_console);
 429 }
 430 #else
 431 static void pstore_register_console(void) {}
 432 static void pstore_unregister_console(void) {}
 433 #endif
 434
 435 static int pstore_write_user_compat(struct pstore_record *record,
 436                                     const char __user *buf)
 437 {
 438         int ret = 0;
 439
 440         if (record->buf)
 441                 return -EINVAL;
 442
 443         record->buf = vmemdup_user(buf, record->size);
 444         if (IS_ERR(record->buf)) {
 445                 ret = PTR_ERR(record->buf);
 446                 goto out;
 447         }
 448
 449         ret = record->psi->write(record);
 450
 451         kvfree(record->buf);
 452 out:
 453         record->buf = NULL;
 454
 455         return unlikely(ret < 0) ? ret : record->size;
 456 }
 457
 458 /*
 459  * platform specific persistent storage driver registers with
 460  * us here. If pstore is already mounted, call the platform
 461  * read function right away to populate the file system. If not
 462  * then the pstore mount code will call us later to fill out
 463  * the file system.
 464  */
 465 int pstore_register(struct pstore_info *psi)
 466 {
 467         if (backend && strcmp(backend, psi->name)) {
 468                 pr_warn("backend '%s' already in use: ignoring '%s'\n",
 469                         backend, psi->name);
 470                 return -EBUSY;
 471         }
 472
 473         /* Sanity check flags. */
 474         if (!psi->flags) {
 475                 pr_warn("backend '%s' must support at least one frontend\n",
 476                         psi->name);
 477                 return -EINVAL;
 478         }
 479
 480         /* Check for required functions. */
 481         if (!psi->read || !psi->write) {
 482                 pr_warn("backend '%s' must implement read() and write()\n",
 483                         psi->name);
 484                 return -EINVAL;
 485         }
 486
 487         mutex_lock(&psinfo_lock);
 488         if (psinfo) {
 489                 pr_warn("backend '%s' already loaded: ignoring '%s'\n",
 490                         psinfo->name, psi->name);
 491                 mutex_unlock(&psinfo_lock);
 492                 return -EBUSY;
 493         }
 494
 495         if (!psi->write_user)
 496                 psi->write_user = pstore_write_user_compat;
 497         psinfo = psi;
 498         mutex_init(&psinfo->read_mutex);
 499         spin_lock_init(&psinfo->buf_lock);
 500
 501         if (psi->flags & PSTORE_FLAGS_DMESG)
 502                 allocate_buf_for_compression();
 503
 504         pstore_get_records(0);
 505
 506         if (psi->flags & PSTORE_FLAGS_DMESG) {
 507                 pstore_dumper.max_reason = psinfo->max_reason;
 508                 pstore_register_kmsg();
 509         }
 510         if (psi->flags & PSTORE_FLAGS_CONSOLE)
 511                 pstore_register_console();
 512         if (psi->flags & PSTORE_FLAGS_FTRACE)
 513                 pstore_register_ftrace();
 514         if (psi->flags & PSTORE_FLAGS_PMSG)
 515                 pstore_register_pmsg();
 516
 517         /* Start watching for new records, if desired. */
 518         pstore_timer_kick();
 519
 520         /*
 521          * Update the module parameter backend, so it is visible
 522          * through /sys/module/pstore/parameters/backend
 523          */
 524         backend = kstrdup(psi->name, GFP_KERNEL);
 525
 526         pr_info("Registered %s as persistent store backend\n", psi->name);
 527
 528         mutex_unlock(&psinfo_lock);
 529         return 0;
 530 }
 531 EXPORT_SYMBOL_GPL(pstore_register);
 532
 533 void pstore_unregister(struct pstore_info *psi)
 534 {
 535         /* It's okay to unregister nothing. */
 536         if (!psi)
 537                 return;
 538
 539         mutex_lock(&psinfo_lock);
 540
 541         /* Only one backend can be registered at a time. */
 542         if (WARN_ON(psi != psinfo)) {
 543                 mutex_unlock(&psinfo_lock);
 544                 return;
 545         }
 546
 547         /* Unregister all callbacks. */
 548         if (psi->flags & PSTORE_FLAGS_PMSG)
 549                 pstore_unregister_pmsg();
 550         if (psi->flags & PSTORE_FLAGS_FTRACE)
 551                 pstore_unregister_ftrace();
 552         if (psi->flags & PSTORE_FLAGS_CONSOLE)
 553                 pstore_unregister_console();
 554         if (psi->flags & PSTORE_FLAGS_DMESG)
 555                 pstore_unregister_kmsg();
 556
 557         /* Stop timer and make sure all work has finished. */
 558         del_timer_sync(&pstore_timer);
 559         flush_work(&pstore_work);
 560
 561         /* Remove all backend records from filesystem tree. */
 562         pstore_put_backend_records(psi);
 563
 564         free_buf_for_compression();
 565
 566         psinfo = NULL;
 567         kfree(backend);
 568         backend = NULL;
 569
 570         pr_info("Unregistered %s as persistent store backend\n", psi->name);
 571         mutex_unlock(&psinfo_lock);
 572 }
 573 EXPORT_SYMBOL_GPL(pstore_unregister);
 574
 575 static void decompress_record(struct pstore_record *record,
 576                               struct z_stream_s *zstream)
 577 {
 578         int ret;
 579         int unzipped_len;
 580         char *unzipped, *workspace;
 581         size_t max_uncompressed_size;
 582
 583         if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed)
 584                 return;
 585
 586         /* Only PSTORE_TYPE_DMESG support compression. */
 587         if (record->type != PSTORE_TYPE_DMESG) {
 588                 pr_warn("ignored compressed record type %d\n", record->type);
 589                 return;
 590         }
 591
 592         /* Missing compression buffer means compression was not initialized. */
 593         if (!zstream->workspace) {
 594                 pr_warn("no decompression method initialized!\n");
 595                 return;
 596         }
 597
 598         ret = zlib_inflateReset(zstream);
 599         if (ret != Z_OK) {
 600                 pr_err("zlib_inflateReset() failed, ret = %d!\n", ret);
 601                 return;
 602         }
 603
 604         /* Allocate enough space to hold max decompression and ECC. */
 605         max_uncompressed_size = 3 * psinfo->bufsize;
 606         workspace = kvzalloc(max_uncompressed_size + record->ecc_notice_size,
 607                              GFP_KERNEL);
 608         if (!workspace)
 609                 return;
 610
 611         zstream->next_in        = record->buf;
 612         zstream->avail_in       = record->size;
 613         zstream->next_out       = workspace;
 614         zstream->avail_out      = max_uncompressed_size;
 615
 616         ret = zlib_inflate(zstream, Z_FINISH);
 617         if (ret != Z_STREAM_END) {
 618                 pr_err_ratelimited("zlib_inflate() failed, ret = %d!\n", ret);
 619                 kvfree(workspace);
 620                 return;
 621         }
 622
 623         unzipped_len = zstream->total_out;
 624
 625         /* Append ECC notice to decompressed buffer. */
 626         memcpy(workspace + unzipped_len, record->buf + record->size,
 627                record->ecc_notice_size);
 628
 629         /* Copy decompressed contents into an minimum-sized allocation. */
 630         unzipped = kvmemdup(workspace, unzipped_len + record->ecc_notice_size,
 631                             GFP_KERNEL);
 632         kvfree(workspace);
 633         if (!unzipped)
 634                 return;
 635
 636         /* Swap out compressed contents with decompressed contents. */
 637         kvfree(record->buf);
 638         record->buf = unzipped;
 639         record->size = unzipped_len;
 640         record->compressed = false;
 641 }
 642
 643 /*
 644  * Read all the records from one persistent store backend. Create
 645  * files in our filesystem.  Don't warn about -EEXIST errors
 646  * when we are re-scanning the backing store looking to add new
 647  * error records.
 648  */
 649 void pstore_get_backend_records(struct pstore_info *psi,
 650                                 struct dentry *root, int quiet)
 651 {
 652         int failed = 0;
 653         unsigned int stop_loop = 65536;
 654         struct z_stream_s zstream = {};
 655
 656         if (!psi || !root)
 657                 return;
 658
 659         if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
 660                 zstream.workspace = kvmalloc(zlib_inflate_workspacesize(),
 661                                              GFP_KERNEL);
 662                 zlib_inflateInit2(&zstream, -DEF_WBITS);
 663         }
 664
 665         mutex_lock(&psi->read_mutex);
 666         if (psi->open && psi->open(psi))
 667                 goto out;
 668
 669         /*
 670          * Backend callback read() allocates record.buf. decompress_record()
 671          * may reallocate record.buf. On success, pstore_mkfile() will keep
 672          * the record.buf, so free it only on failure.
 673          */
 674         for (; stop_loop; stop_loop--) {
 675                 struct pstore_record *record;
 676                 int rc;
 677
 678                 record = kzalloc(sizeof(*record), GFP_KERNEL);
 679                 if (!record) {
 680                         pr_err("out of memory creating record\n");
 681                         break;
 682                 }
 683                 pstore_record_init(record, psi);
 684
 685                 record->size = psi->read(record);
 686
 687                 /* No more records left in backend? */
 688                 if (record->size <= 0) {
 689                         kfree(record);
 690                         break;
 691                 }
 692
 693                 decompress_record(record, &zstream);
 694                 rc = pstore_mkfile(root, record);
 695                 if (rc) {
 696                         /* pstore_mkfile() did not take record, so free it. */
 697                         kvfree(record->buf);
 698                         kfree(record->priv);
 699                         kfree(record);
 700                         if (rc != -EEXIST || !quiet)
 701                                 failed++;
 702                 }
 703         }
 704         if (psi->close)
 705                 psi->close(psi);
 706 out:
 707         mutex_unlock(&psi->read_mutex);
 708
 709         if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
 710                 if (zlib_inflateEnd(&zstream) != Z_OK)
 711                         pr_warn("zlib_inflateEnd() failed\n");
 712                 kvfree(zstream.workspace);
 713         }
 714
 715         if (failed)
 716                 pr_warn("failed to create %d record(s) from '%s'\n",
 717                         failed, psi->name);
 718         if (!stop_loop)
 719                 pr_err("looping? Too many records seen from '%s'\n",
 720                         psi->name);
 721 }
 722
 723 static void pstore_dowork(struct work_struct *work)
 724 {
 725         pstore_get_records(1);
 726 }
 727
 728 static void pstore_timefunc(struct timer_list *unused)
 729 {
 730         if (pstore_new_entry) {
 731                 pstore_new_entry = 0;
 732                 schedule_work(&pstore_work);
 733         }
 734
 735         pstore_timer_kick();
 736 }
 737
 738 static int __init pstore_init(void)
 739 {
 740         int ret;
 741
 742         ret = pstore_init_fs();
 743         if (ret)
 744                 free_buf_for_compression();
 745
 746         return ret;
 747 }
 748 late_initcall(pstore_init);
 749
 750 static void __exit pstore_exit(void)
 751 {
 752         pstore_exit_fs();
 753 }
 754 module_exit(pstore_exit)
 755
 756 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
 757 MODULE_LICENSE("GPL");