linux/fs/pstore/platform.c
<<
>>
Prefs
   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 */
  43static int pstore_update_ms = -1;
  44module_param_named(update_ms, pstore_update_ms, int, 0600);
  45MODULE_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 */
  51static 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
  63static int pstore_new_entry;
  64
  65static void pstore_timefunc(struct timer_list *);
  66static DEFINE_TIMER(pstore_timer, pstore_timefunc);
  67
  68static void pstore_dowork(struct work_struct *);
  69static 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 */
  76static DEFINE_MUTEX(psinfo_lock);
  77struct pstore_info *psinfo;
  78
  79static char *backend;
  80module_param(backend, charp, 0444);
  81MODULE_PARM_DESC(backend, "specific backend to use");
  82
  83static char *compress =
  84#ifdef CONFIG_PSTORE_COMPRESS_DEFAULT
  85                CONFIG_PSTORE_COMPRESS_DEFAULT;
  86#else
  87                NULL;
  88#endif
  89module_param(compress, charp, 0444);
  90MODULE_PARM_DESC(compress, "compression to use");
  91
  92/* Compression parameters */
  93static struct crypto_comp *tfm;
  94
  95struct pstore_zbackend {
  96        int (*zbufsize)(size_t size);
  97        const char *name;
  98};
  99
 100static char *big_oops_buf;
 101static size_t big_oops_buf_sz;
 102
 103/* How much of the console log to snapshot */
 104unsigned long kmsg_bytes = CONFIG_PSTORE_DEFAULT_KMSG_BYTES;
 105
 106void pstore_set_kmsg_bytes(int bytes)
 107{
 108        kmsg_bytes = bytes;
 109}
 110
 111/* Tag each group of saved records with a sequence number */
 112static int      oopscount;
 113
 114const 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}
 123EXPORT_SYMBOL_GPL(pstore_type_to_name);
 124
 125enum 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}
 136EXPORT_SYMBOL_GPL(pstore_name_to_type);
 137
 138static 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 */
 151static 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)
 169static 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)
 198static 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)
 205static int zbufsize_lz4(size_t size)
 206{
 207        return LZ4_compressBound(size);
 208}
 209#endif
 210
 211#if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS)
 212static int zbufsize_842(size_t size)
 213{
 214        return size;
 215}
 216#endif
 217
 218#if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS)
 219static int zbufsize_zstd(size_t size)
 220{
 221        return zstd_compress_bound(size);
 222}
 223#endif
 224
 225static const struct pstore_zbackend *zbackend __ro_after_init;
 226
 227static 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
 267static 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
 284static 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
 333static 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 */
 351static 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
 370void 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 */
 385static 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
 474static 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 */
 481static void pstore_register_kmsg(void)
 482{
 483        kmsg_dump_register(&pstore_dumper);
 484}
 485
 486static void pstore_unregister_kmsg(void)
 487{
 488        kmsg_dump_unregister(&pstore_dumper);
 489}
 490
 491#ifdef CONFIG_PSTORE_CONSOLE
 492static 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
 507static struct console pstore_console = {
 508        .write  = pstore_console_write,
 509        .index  = -1,
 510};
 511
 512static 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
 525static void pstore_unregister_console(void)
 526{
 527        unregister_console(&pstore_console);
 528}
 529#else
 530static void pstore_register_console(void) {}
 531static void pstore_unregister_console(void) {}
 532#endif
 533
 534static 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);
 551out:
 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 */
 564int 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}
 629EXPORT_SYMBOL_GPL(pstore_register);
 630
 631void 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}
 669EXPORT_SYMBOL_GPL(pstore_unregister);
 670
 671static 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 */
 732void 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);
 781out:
 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
 792static void pstore_dowork(struct work_struct *work)
 793{
 794        pstore_get_records(1);
 795}
 796
 797static 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
 807static 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
 822static 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}
 841late_initcall(pstore_init);
 842
 843static void __exit pstore_exit(void)
 844{
 845        pstore_exit_fs();
 846}
 847module_exit(pstore_exit)
 848
 849MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
 850MODULE_LICENSE("GPL");
 851