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