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         char *new_backend;
 468
 469         if (backend && strcmp(backend, psi->name)) {
 470                 pr_warn("backend '%s' already in use: ignoring '%s'\n",
 471                         backend, psi->name);
 472                 return -EBUSY;
 473         }
 474
 475         /* Sanity check flags. */
 476         if (!psi->flags) {
 477                 pr_warn("backend '%s' must support at least one frontend\n",
 478                         psi->name);
 479                 return -EINVAL;
 480         }
 481
 482         /* Check for required functions. */
 483         if (!psi->read || !psi->write) {
 484                 pr_warn("backend '%s' must implement read() and write()\n",
 485                         psi->name);
 486                 return -EINVAL;
 487         }
 488
 489         new_backend = kstrdup(psi->name, GFP_KERNEL);
 490         if (!new_backend)
 491                 return -ENOMEM;
 492
 493         mutex_lock(&psinfo_lock);
 494         if (psinfo) {
 495                 pr_warn("backend '%s' already loaded: ignoring '%s'\n",
 496                         psinfo->name, psi->name);
 497                 mutex_unlock(&psinfo_lock);
 498                 kfree(new_backend);
 499                 return -EBUSY;
 500         }
 501
 502         if (!psi->write_user)
 503                 psi->write_user = pstore_write_user_compat;
 504         psinfo = psi;
 505         mutex_init(&psinfo->read_mutex);
 506         spin_lock_init(&psinfo->buf_lock);
 507
 508         if (psi->flags & PSTORE_FLAGS_DMESG)
 509                 allocate_buf_for_compression();
 510
 511         pstore_get_records(0);
 512
 513         if (psi->flags & PSTORE_FLAGS_DMESG) {
 514                 pstore_dumper.max_reason = psinfo->max_reason;
 515                 pstore_register_kmsg();
 516         }
 517         if (psi->flags & PSTORE_FLAGS_CONSOLE)
 518                 pstore_register_console();
 519         if (psi->flags & PSTORE_FLAGS_FTRACE)
 520                 pstore_register_ftrace();
 521         if (psi->flags & PSTORE_FLAGS_PMSG)
 522                 pstore_register_pmsg();
 523
 524         /* Start watching for new records, if desired. */
 525         pstore_timer_kick();
 526
 527         /*
 528          * Update the module parameter backend, so it is visible
 529          * through /sys/module/pstore/parameters/backend
 530          */
 531         backend = new_backend;
 532
 533         pr_info("Registered %s as persistent store backend\n", psi->name);
 534
 535         mutex_unlock(&psinfo_lock);
 536         return 0;
 537 }
 538 EXPORT_SYMBOL_GPL(pstore_register);
 539
 540 void pstore_unregister(struct pstore_info *psi)
 541 {
 542         /* It's okay to unregister nothing. */
 543         if (!psi)
 544                 return;
 545
 546         mutex_lock(&psinfo_lock);
 547
 548         /* Only one backend can be registered at a time. */
 549         if (WARN_ON(psi != psinfo)) {
 550                 mutex_unlock(&psinfo_lock);
 551                 return;
 552         }
 553
 554         /* Unregister all callbacks. */
 555         if (psi->flags & PSTORE_FLAGS_PMSG)
 556                 pstore_unregister_pmsg();
 557         if (psi->flags & PSTORE_FLAGS_FTRACE)
 558                 pstore_unregister_ftrace();
 559         if (psi->flags & PSTORE_FLAGS_CONSOLE)
 560                 pstore_unregister_console();
 561         if (psi->flags & PSTORE_FLAGS_DMESG)
 562                 pstore_unregister_kmsg();
 563
 564         /* Stop timer and make sure all work has finished. */
 565         del_timer_sync(&pstore_timer);
 566         flush_work(&pstore_work);
 567
 568         /* Remove all backend records from filesystem tree. */
 569         pstore_put_backend_records(psi);
 570
 571         free_buf_for_compression();
 572
 573         psinfo = NULL;
 574         kfree(backend);
 575         backend = NULL;
 576
 577         pr_info("Unregistered %s as persistent store backend\n", psi->name);
 578         mutex_unlock(&psinfo_lock);
 579 }
 580 EXPORT_SYMBOL_GPL(pstore_unregister);
 581
 582 static void decompress_record(struct pstore_record *record,
 583                               struct z_stream_s *zstream)
 584 {
 585         int ret;
 586         int unzipped_len;
 587         char *unzipped, *workspace;
 588         size_t max_uncompressed_size;
 589
 590         if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed)
 591                 return;
 592
 593         /* Only PSTORE_TYPE_DMESG support compression. */
 594         if (record->type != PSTORE_TYPE_DMESG) {
 595                 pr_warn("ignored compressed record type %d\n", record->type);
 596                 return;
 597         }
 598
 599         /* Missing compression buffer means compression was not initialized. */
 600         if (!zstream->workspace) {
 601                 pr_warn("no decompression method initialized!\n");
 602                 return;
 603         }
 604
 605         ret = zlib_inflateReset(zstream);
 606         if (ret != Z_OK) {
 607                 pr_err("zlib_inflateReset() failed, ret = %d!\n", ret);
 608                 return;
 609         }
 610
 611         /* Allocate enough space to hold max decompression and ECC. */
 612         max_uncompressed_size = 3 * psinfo->bufsize;
 613         workspace = kvzalloc(max_uncompressed_size + record->ecc_notice_size,
 614                              GFP_KERNEL);
 615         if (!workspace)
 616                 return;
 617
 618         zstream->next_in        = record->buf;
 619         zstream->avail_in       = record->size;
 620         zstream->next_out       = workspace;
 621         zstream->avail_out      = max_uncompressed_size;
 622
 623         ret = zlib_inflate(zstream, Z_FINISH);
 624         if (ret != Z_STREAM_END) {
 625                 pr_err_ratelimited("zlib_inflate() failed, ret = %d!\n", ret);
 626                 kvfree(workspace);
 627                 return;
 628         }
 629
 630         unzipped_len = zstream->total_out;
 631
 632         /* Append ECC notice to decompressed buffer. */
 633         memcpy(workspace + unzipped_len, record->buf + record->size,
 634                record->ecc_notice_size);
 635
 636         /* Copy decompressed contents into an minimum-sized allocation. */
 637         unzipped = kvmemdup(workspace, unzipped_len + record->ecc_notice_size,
 638                             GFP_KERNEL);
 639         kvfree(workspace);
 640         if (!unzipped)
 641                 return;
 642
 643         /* Swap out compressed contents with decompressed contents. */
 644         kvfree(record->buf);
 645         record->buf = unzipped;
 646         record->size = unzipped_len;
 647         record->compressed = false;
 648 }
 649
 650 /*
 651  * Read all the records from one persistent store backend. Create
 652  * files in our filesystem.  Don't warn about -EEXIST errors
 653  * when we are re-scanning the backing store looking to add new
 654  * error records.
 655  */
 656 void pstore_get_backend_records(struct pstore_info *psi,
 657                                 struct dentry *root, int quiet)
 658 {
 659         int failed = 0;
 660         unsigned int stop_loop = 65536;
 661         struct z_stream_s zstream = {};
 662
 663         if (!psi || !root)
 664                 return;
 665
 666         if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
 667                 zstream.workspace = kvmalloc(zlib_inflate_workspacesize(),
 668                                              GFP_KERNEL);
 669                 zlib_inflateInit2(&zstream, -DEF_WBITS);
 670         }
 671
 672         mutex_lock(&psi->read_mutex);
 673         if (psi->open && psi->open(psi))
 674                 goto out;
 675
 676         /*
 677          * Backend callback read() allocates record.buf. decompress_record()
 678          * may reallocate record.buf. On success, pstore_mkfile() will keep
 679          * the record.buf, so free it only on failure.
 680          */
 681         for (; stop_loop; stop_loop--) {
 682                 struct pstore_record *record;
 683                 int rc;
 684
 685                 record = kzalloc(sizeof(*record), GFP_KERNEL);
 686                 if (!record) {
 687                         pr_err("out of memory creating record\n");
 688                         break;
 689                 }
 690                 pstore_record_init(record, psi);
 691
 692                 record->size = psi->read(record);
 693
 694                 /* No more records left in backend? */
 695                 if (record->size <= 0) {
 696                         kfree(record);
 697                         break;
 698                 }
 699
 700                 decompress_record(record, &zstream);
 701                 rc = pstore_mkfile(root, record);
 702                 if (rc) {
 703                         /* pstore_mkfile() did not take record, so free it. */
 704                         kvfree(record->buf);
 705                         kfree(record->priv);
 706                         kfree(record);
 707                         if (rc != -EEXIST || !quiet)
 708                                 failed++;
 709                 }
 710         }
 711         if (psi->close)
 712                 psi->close(psi);
 713 out:
 714         mutex_unlock(&psi->read_mutex);
 715
 716         if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
 717                 if (zlib_inflateEnd(&zstream) != Z_OK)
 718                         pr_warn("zlib_inflateEnd() failed\n");
 719                 kvfree(zstream.workspace);
 720         }
 721
 722         if (failed)
 723                 pr_warn("failed to create %d record(s) from '%s'\n",
 724                         failed, psi->name);
 725         if (!stop_loop)
 726                 pr_err("looping? Too many records seen from '%s'\n",
 727                         psi->name);
 728 }
 729
 730 static void pstore_dowork(struct work_struct *work)
 731 {
 732         pstore_get_records(1);
 733 }
 734
 735 static void pstore_timefunc(struct timer_list *unused)
 736 {
 737         if (pstore_new_entry) {
 738                 pstore_new_entry = 0;
 739                 schedule_work(&pstore_work);
 740         }
 741
 742         pstore_timer_kick();
 743 }
 744
 745 static int __init pstore_init(void)
 746 {
 747         int ret;
 748
 749         ret = pstore_init_fs();
 750         if (ret)
 751                 free_buf_for_compression();
 752
 753         return ret;
 754 }
 755 late_initcall(pstore_init);
 756
 757 static void __exit pstore_exit(void)
 758 {
 759         pstore_exit_fs();
 760 }
 761 module_exit(pstore_exit)
 762
 763 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
 764 MODULE_LICENSE("GPL");