1 // SPDX-License-Identifier: GPL-2.0-only
3 * Persistent Storage - platform driver interface parts.
5 * Copyright (C) 2007-2008 Google, Inc.
6 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
9 #define pr_fmt(fmt) "pstore: " fmt
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>
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>
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
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)");
43 /* Names should be in the same order as the enum pstore_type_id */
44 static const char * const pstore_type_names[] = {
56 static int pstore_new_entry;
58 static void pstore_timefunc(struct timer_list *);
59 static DEFINE_TIMER(pstore_timer, pstore_timefunc);
61 static void pstore_dowork(struct work_struct *);
62 static DECLARE_WORK(pstore_work, pstore_dowork);
65 * psinfo_lock protects "psinfo" during calls to
66 * pstore_register(), pstore_unregister(), and
67 * the filesystem mount/unmount routines.
69 static DEFINE_MUTEX(psinfo_lock);
70 struct pstore_info *psinfo;
73 module_param(backend, charp, 0444);
74 MODULE_PARM_DESC(backend, "specific backend to use");
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.
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'.
90 static char *compress = "deflate";
91 module_param(compress, charp, 0444);
92 MODULE_PARM_DESC(compress, "compression to use");
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)");
99 static void *compress_workspace;
101 static char *big_oops_buf;
103 void pstore_set_kmsg_bytes(int bytes)
108 /* Tag each group of saved records with a sequence number */
109 static int oopscount;
111 const char *pstore_type_to_name(enum pstore_type_id type)
113 BUILD_BUG_ON(ARRAY_SIZE(pstore_type_names) != PSTORE_TYPE_MAX);
115 if (WARN_ON_ONCE(type >= PSTORE_TYPE_MAX))
118 return pstore_type_names[type];
120 EXPORT_SYMBOL_GPL(pstore_type_to_name);
122 enum pstore_type_id pstore_name_to_type(const char *name)
126 for (i = 0; i < PSTORE_TYPE_MAX; i++) {
127 if (!strcmp(pstore_type_names[i], name))
131 return PSTORE_TYPE_MAX;
133 EXPORT_SYMBOL_GPL(pstore_name_to_type);
135 static void pstore_timer_kick(void)
137 if (pstore_update_ms < 0)
140 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms));
143 static bool pstore_cannot_block_path(enum kmsg_dump_reason reason)
146 * In case of NMI path, pstore shouldn't be blocked
147 * regardless of reason.
153 /* In panic case, other cpus are stopped by smp_send_stop(). */
154 case KMSG_DUMP_PANIC:
156 * Emergency restart shouldn't be blocked by spinning on
157 * pstore_info::buf_lock.
159 case KMSG_DUMP_EMERG:
166 static int pstore_compress(const void *in, void *out,
167 unsigned int inlen, unsigned int outlen)
169 struct z_stream_s zstream = {
174 .workspace = compress_workspace,
178 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS))
181 ret = zlib_deflateInit2(&zstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
182 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
186 ret = zlib_deflate(&zstream, Z_FINISH);
187 if (ret != Z_STREAM_END)
190 ret = zlib_deflateEnd(&zstream);
192 pr_warn_once("zlib_deflateEnd() failed: %d\n", ret);
194 return zstream.total_out;
197 static void allocate_buf_for_compression(void)
201 /* Skip if not built-in or compression disabled. */
202 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !compress ||
203 !strcmp(compress, "none")) {
208 if (strcmp(compress, "deflate")) {
209 pr_err("Unsupported compression '%s', falling back to deflate\n",
211 compress = "deflate";
215 * The compression buffer only needs to be as large as the maximum
216 * uncompressed record size, since any record that would be expanded by
217 * compression is just stored uncompressed.
219 buf = kvzalloc(psinfo->bufsize, GFP_KERNEL);
221 pr_err("Failed %zu byte compression buffer allocation for: %s\n",
222 psinfo->bufsize, compress);
227 vmalloc(zlib_deflate_workspacesize(MAX_WBITS, DEF_MEM_LEVEL));
228 if (!compress_workspace) {
229 pr_err("Failed to allocate zlib deflate workspace\n");
234 /* A non-NULL big_oops_buf indicates compression is available. */
237 pr_info("Using crash dump compression: %s\n", compress);
240 static void free_buf_for_compression(void)
242 if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress_workspace) {
243 vfree(compress_workspace);
244 compress_workspace = NULL;
247 kvfree(big_oops_buf);
251 void pstore_record_init(struct pstore_record *record,
252 struct pstore_info *psinfo)
254 memset(record, 0, sizeof(*record));
256 record->psi = psinfo;
258 /* Report zeroed timestamp if called before timekeeping has resumed. */
259 record->time = ns_to_timespec64(ktime_get_real_fast_ns());
263 * callback from kmsg_dump. Save as much as we can (up to kmsg_bytes) from the
266 static void pstore_dump(struct kmsg_dumper *dumper,
267 enum kmsg_dump_reason reason)
269 struct kmsg_dump_iter iter;
270 unsigned long total = 0;
272 unsigned int part = 1;
273 unsigned long flags = 0;
277 why = kmsg_dump_reason_str(reason);
279 if (pstore_cannot_block_path(reason)) {
280 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) {
281 pr_err("dump skipped in %s path because of concurrent dump\n",
282 in_nmi() ? "NMI" : why);
286 spin_lock_irqsave(&psinfo->buf_lock, flags);
289 kmsg_dump_rewind(&iter);
292 while (total < kmsg_bytes) {
298 struct pstore_record record;
300 pstore_record_init(&record, psinfo);
301 record.type = PSTORE_TYPE_DMESG;
302 record.count = oopscount;
303 record.reason = reason;
305 record.buf = psinfo->buf;
307 dst = big_oops_buf ?: psinfo->buf;
308 dst_size = psinfo->bufsize;
310 /* Write dump header. */
311 header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why,
313 dst_size -= header_size;
315 /* Write dump contents. */
316 if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,
317 dst_size, &dump_size))
321 zipped_len = pstore_compress(dst, psinfo->buf,
322 header_size + dump_size,
325 if (zipped_len > 0) {
326 record.compressed = true;
327 record.size = zipped_len;
329 record.size = header_size + dump_size;
330 memcpy(psinfo->buf, dst, record.size);
333 record.size = header_size + dump_size;
336 ret = psinfo->write(&record);
337 if (ret == 0 && reason == KMSG_DUMP_OOPS) {
338 pstore_new_entry = 1;
341 /* Preserve only the first non-zero returned value. */
346 total += record.size;
349 spin_unlock_irqrestore(&psinfo->buf_lock, flags);
352 pr_err_once("backend (%s) writing error (%d)\n", psinfo->name,
357 static struct kmsg_dumper pstore_dumper = {
362 * Register with kmsg_dump to save last part of console log on panic.
364 static void pstore_register_kmsg(void)
366 kmsg_dump_register(&pstore_dumper);
369 static void pstore_unregister_kmsg(void)
371 kmsg_dump_unregister(&pstore_dumper);
374 #ifdef CONFIG_PSTORE_CONSOLE
375 static void pstore_console_write(struct console *con, const char *s, unsigned c)
377 struct pstore_record record;
382 pstore_record_init(&record, psinfo);
383 record.type = PSTORE_TYPE_CONSOLE;
385 record.buf = (char *)s;
387 psinfo->write(&record);
390 static struct console pstore_console = {
391 .write = pstore_console_write,
395 static void pstore_register_console(void)
397 /* Show which backend is going to get console writes. */
398 strscpy(pstore_console.name, psinfo->name,
399 sizeof(pstore_console.name));
401 * Always initialize flags here since prior unregister_console()
402 * calls may have changed settings (specifically CON_ENABLED).
404 pstore_console.flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME;
405 register_console(&pstore_console);
408 static void pstore_unregister_console(void)
410 unregister_console(&pstore_console);
413 static void pstore_register_console(void) {}
414 static void pstore_unregister_console(void) {}
417 static int pstore_write_user_compat(struct pstore_record *record,
418 const char __user *buf)
425 record->buf = vmemdup_user(buf, record->size);
426 if (IS_ERR(record->buf)) {
427 ret = PTR_ERR(record->buf);
431 ret = record->psi->write(record);
437 return unlikely(ret < 0) ? ret : record->size;
441 * platform specific persistent storage driver registers with
442 * us here. If pstore is already mounted, call the platform
443 * read function right away to populate the file system. If not
444 * then the pstore mount code will call us later to fill out
447 int pstore_register(struct pstore_info *psi)
449 if (backend && strcmp(backend, psi->name)) {
450 pr_warn("backend '%s' already in use: ignoring '%s'\n",
455 /* Sanity check flags. */
457 pr_warn("backend '%s' must support at least one frontend\n",
462 /* Check for required functions. */
463 if (!psi->read || !psi->write) {
464 pr_warn("backend '%s' must implement read() and write()\n",
469 mutex_lock(&psinfo_lock);
471 pr_warn("backend '%s' already loaded: ignoring '%s'\n",
472 psinfo->name, psi->name);
473 mutex_unlock(&psinfo_lock);
477 if (!psi->write_user)
478 psi->write_user = pstore_write_user_compat;
480 mutex_init(&psinfo->read_mutex);
481 spin_lock_init(&psinfo->buf_lock);
483 if (psi->flags & PSTORE_FLAGS_DMESG)
484 allocate_buf_for_compression();
486 pstore_get_records(0);
488 if (psi->flags & PSTORE_FLAGS_DMESG) {
489 pstore_dumper.max_reason = psinfo->max_reason;
490 pstore_register_kmsg();
492 if (psi->flags & PSTORE_FLAGS_CONSOLE)
493 pstore_register_console();
494 if (psi->flags & PSTORE_FLAGS_FTRACE)
495 pstore_register_ftrace();
496 if (psi->flags & PSTORE_FLAGS_PMSG)
497 pstore_register_pmsg();
499 /* Start watching for new records, if desired. */
503 * Update the module parameter backend, so it is visible
504 * through /sys/module/pstore/parameters/backend
506 backend = kstrdup(psi->name, GFP_KERNEL);
508 pr_info("Registered %s as persistent store backend\n", psi->name);
510 mutex_unlock(&psinfo_lock);
513 EXPORT_SYMBOL_GPL(pstore_register);
515 void pstore_unregister(struct pstore_info *psi)
517 /* It's okay to unregister nothing. */
521 mutex_lock(&psinfo_lock);
523 /* Only one backend can be registered at a time. */
524 if (WARN_ON(psi != psinfo)) {
525 mutex_unlock(&psinfo_lock);
529 /* Unregister all callbacks. */
530 if (psi->flags & PSTORE_FLAGS_PMSG)
531 pstore_unregister_pmsg();
532 if (psi->flags & PSTORE_FLAGS_FTRACE)
533 pstore_unregister_ftrace();
534 if (psi->flags & PSTORE_FLAGS_CONSOLE)
535 pstore_unregister_console();
536 if (psi->flags & PSTORE_FLAGS_DMESG)
537 pstore_unregister_kmsg();
539 /* Stop timer and make sure all work has finished. */
540 del_timer_sync(&pstore_timer);
541 flush_work(&pstore_work);
543 /* Remove all backend records from filesystem tree. */
544 pstore_put_backend_records(psi);
546 free_buf_for_compression();
552 pr_info("Unregistered %s as persistent store backend\n", psi->name);
553 mutex_unlock(&psinfo_lock);
555 EXPORT_SYMBOL_GPL(pstore_unregister);
557 static void decompress_record(struct pstore_record *record,
558 struct z_stream_s *zstream)
562 char *unzipped, *workspace;
564 if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed)
567 /* Only PSTORE_TYPE_DMESG support compression. */
568 if (record->type != PSTORE_TYPE_DMESG) {
569 pr_warn("ignored compressed record type %d\n", record->type);
573 /* Missing compression buffer means compression was not initialized. */
574 if (!zstream->workspace) {
575 pr_warn("no decompression method initialized!\n");
579 ret = zlib_inflateReset(zstream);
581 pr_err("zlib_inflateReset() failed, ret = %d!\n", ret);
585 /* Allocate enough space to hold max decompression and ECC. */
586 workspace = kvzalloc(psinfo->bufsize + record->ecc_notice_size,
591 zstream->next_in = record->buf;
592 zstream->avail_in = record->size;
593 zstream->next_out = workspace;
594 zstream->avail_out = psinfo->bufsize;
596 ret = zlib_inflate(zstream, Z_FINISH);
597 if (ret != Z_STREAM_END) {
598 pr_err("zlib_inflate() failed, ret = %d!\n", ret);
603 unzipped_len = zstream->total_out;
605 /* Append ECC notice to decompressed buffer. */
606 memcpy(workspace + unzipped_len, record->buf + record->size,
607 record->ecc_notice_size);
609 /* Copy decompressed contents into an minimum-sized allocation. */
610 unzipped = kvmemdup(workspace, unzipped_len + record->ecc_notice_size,
616 /* Swap out compressed contents with decompressed contents. */
618 record->buf = unzipped;
619 record->size = unzipped_len;
620 record->compressed = false;
624 * Read all the records from one persistent store backend. Create
625 * files in our filesystem. Don't warn about -EEXIST errors
626 * when we are re-scanning the backing store looking to add new
629 void pstore_get_backend_records(struct pstore_info *psi,
630 struct dentry *root, int quiet)
633 unsigned int stop_loop = 65536;
634 struct z_stream_s zstream = {};
639 if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
640 zstream.workspace = kvmalloc(zlib_inflate_workspacesize(),
642 zlib_inflateInit2(&zstream, -DEF_WBITS);
645 mutex_lock(&psi->read_mutex);
646 if (psi->open && psi->open(psi))
650 * Backend callback read() allocates record.buf. decompress_record()
651 * may reallocate record.buf. On success, pstore_mkfile() will keep
652 * the record.buf, so free it only on failure.
654 for (; stop_loop; stop_loop--) {
655 struct pstore_record *record;
658 record = kzalloc(sizeof(*record), GFP_KERNEL);
660 pr_err("out of memory creating record\n");
663 pstore_record_init(record, psi);
665 record->size = psi->read(record);
667 /* No more records left in backend? */
668 if (record->size <= 0) {
673 decompress_record(record, &zstream);
674 rc = pstore_mkfile(root, record);
676 /* pstore_mkfile() did not take record, so free it. */
680 if (rc != -EEXIST || !quiet)
687 mutex_unlock(&psi->read_mutex);
689 if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && compress) {
690 if (zlib_inflateEnd(&zstream) != Z_OK)
691 pr_warn("zlib_inflateEnd() failed\n");
692 kvfree(zstream.workspace);
696 pr_warn("failed to create %d record(s) from '%s'\n",
699 pr_err("looping? Too many records seen from '%s'\n",
703 static void pstore_dowork(struct work_struct *work)
705 pstore_get_records(1);
708 static void pstore_timefunc(struct timer_list *unused)
710 if (pstore_new_entry) {
711 pstore_new_entry = 0;
712 schedule_work(&pstore_work);
718 static int __init pstore_init(void)
722 ret = pstore_init_fs();
724 free_buf_for_compression();
728 late_initcall(pstore_init);
730 static void __exit pstore_exit(void)
734 module_exit(pstore_exit)
736 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
737 MODULE_LICENSE("GPL");