xref: /openbmc/linux/fs/pstore/platform.c (revision 8dd3cdea) 
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  */
43 static int pstore_update_ms = -1;
44 module_param_named(update_ms, pstore_update_ms, int, 0600);
45 MODULE_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 */
51 static 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 
63 static int pstore_new_entry;
64 
65 static void pstore_timefunc(struct timer_list *);
66 static DEFINE_TIMER(pstore_timer, pstore_timefunc);
67 
68 static void pstore_dowork(struct work_struct *);
69 static 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  */
76 static DEFINE_MUTEX(psinfo_lock);
77 struct pstore_info *psinfo;
78 
79 static char *backend;
80 module_param(backend, charp, 0444);
81 MODULE_PARM_DESC(backend, "specific backend to use");
82 
83 static char *compress =
84 #ifdef CONFIG_PSTORE_COMPRESS_DEFAULT
85 		CONFIG_PSTORE_COMPRESS_DEFAULT;
86 #else
87 		NULL;
88 #endif
89 module_param(compress, charp, 0444);
90 MODULE_PARM_DESC(compress, "compression to use");
91 
92 /* Compression parameters */
93 static struct crypto_comp *tfm;
94 
95 struct pstore_zbackend {
96 	int (*zbufsize)(size_t size);
97 	const char *name;
98 };
99 
100 static char *big_oops_buf;
101 static size_t big_oops_buf_sz;
102 
103 /* How much of the console log to snapshot */
104 unsigned long kmsg_bytes = CONFIG_PSTORE_DEFAULT_KMSG_BYTES;
105 
106 void pstore_set_kmsg_bytes(int bytes)
107 {
108 	kmsg_bytes = bytes;
109 }
110 
111 /* Tag each group of saved records with a sequence number */
112 static int	oopscount;
113 
114 const 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 }
123 EXPORT_SYMBOL_GPL(pstore_type_to_name);
124 
125 enum 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 }
136 EXPORT_SYMBOL_GPL(pstore_name_to_type);
137 
138 static 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 static bool pstore_cannot_block_path(enum kmsg_dump_reason reason)
147 {
148 	/*
149 	 * In case of NMI path, pstore shouldn't be blocked
150 	 * regardless of reason.
151 	 */
152 	if (in_nmi())
153 		return true;
154 
155 	switch (reason) {
156 	/* In panic case, other cpus are stopped by smp_send_stop(). */
157 	case KMSG_DUMP_PANIC:
158 	/*
159 	 * Emergency restart shouldn't be blocked by spinning on
160 	 * pstore_info::buf_lock.
161 	 */
162 	case KMSG_DUMP_EMERG:
163 		return true;
164 	default:
165 		return false;
166 	}
167 }
168 
169 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS)
170 static int zbufsize_deflate(size_t size)
171 {
172 	size_t cmpr;
173 
174 	switch (size) {
175 	/* buffer range for efivars */
176 	case 1000 ... 2000:
177 		cmpr = 56;
178 		break;
179 	case 2001 ... 3000:
180 		cmpr = 54;
181 		break;
182 	case 3001 ... 3999:
183 		cmpr = 52;
184 		break;
185 	/* buffer range for nvram, erst */
186 	case 4000 ... 10000:
187 		cmpr = 45;
188 		break;
189 	default:
190 		cmpr = 60;
191 		break;
192 	}
193 
194 	return (size * 100) / cmpr;
195 }
196 #endif
197 
198 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS)
199 static int zbufsize_lzo(size_t size)
200 {
201 	return lzo1x_worst_compress(size);
202 }
203 #endif
204 
205 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS)
206 static int zbufsize_lz4(size_t size)
207 {
208 	return LZ4_compressBound(size);
209 }
210 #endif
211 
212 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS)
213 static int zbufsize_842(size_t size)
214 {
215 	return size;
216 }
217 #endif
218 
219 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS)
220 static int zbufsize_zstd(size_t size)
221 {
222 	return zstd_compress_bound(size);
223 }
224 #endif
225 
226 static const struct pstore_zbackend *zbackend __ro_after_init;
227 
228 static const struct pstore_zbackend zbackends[] = {
229 #if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS)
230 	{
231 		.zbufsize	= zbufsize_deflate,
232 		.name		= "deflate",
233 	},
234 #endif
235 #if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS)
236 	{
237 		.zbufsize	= zbufsize_lzo,
238 		.name		= "lzo",
239 	},
240 #endif
241 #if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS)
242 	{
243 		.zbufsize	= zbufsize_lz4,
244 		.name		= "lz4",
245 	},
246 #endif
247 #if IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS)
248 	{
249 		.zbufsize	= zbufsize_lz4,
250 		.name		= "lz4hc",
251 	},
252 #endif
253 #if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS)
254 	{
255 		.zbufsize	= zbufsize_842,
256 		.name		= "842",
257 	},
258 #endif
259 #if IS_ENABLED(CONFIG_PSTORE_ZSTD_COMPRESS)
260 	{
261 		.zbufsize	= zbufsize_zstd,
262 		.name		= "zstd",
263 	},
264 #endif
265 	{ }
266 };
267 
268 static int pstore_compress(const void *in, void *out,
269 			   unsigned int inlen, unsigned int outlen)
270 {
271 	int ret;
272 
273 	if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS))
274 		return -EINVAL;
275 
276 	ret = crypto_comp_compress(tfm, in, inlen, out, &outlen);
277 	if (ret) {
278 		pr_err("crypto_comp_compress failed, ret = %d!\n", ret);
279 		return ret;
280 	}
281 
282 	return outlen;
283 }
284 
285 static void allocate_buf_for_compression(void)
286 {
287 	struct crypto_comp *ctx;
288 	int size;
289 	char *buf;
290 
291 	/* Skip if not built-in or compression backend not selected yet. */
292 	if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !zbackend)
293 		return;
294 
295 	/* Skip if no pstore backend yet or compression init already done. */
296 	if (!psinfo || tfm)
297 		return;
298 
299 	if (!crypto_has_comp(zbackend->name, 0, 0)) {
300 		pr_err("Unknown compression: %s\n", zbackend->name);
301 		return;
302 	}
303 
304 	size = zbackend->zbufsize(psinfo->bufsize);
305 	if (size <= 0) {
306 		pr_err("Invalid compression size for %s: %d\n",
307 		       zbackend->name, size);
308 		return;
309 	}
310 
311 	buf = kmalloc(size, GFP_KERNEL);
312 	if (!buf) {
313 		pr_err("Failed %d byte compression buffer allocation for: %s\n",
314 		       size, zbackend->name);
315 		return;
316 	}
317 
318 	ctx = crypto_alloc_comp(zbackend->name, 0, 0);
319 	if (IS_ERR_OR_NULL(ctx)) {
320 		kfree(buf);
321 		pr_err("crypto_alloc_comp('%s') failed: %ld\n", zbackend->name,
322 		       PTR_ERR(ctx));
323 		return;
324 	}
325 
326 	/* A non-NULL big_oops_buf indicates compression is available. */
327 	tfm = ctx;
328 	big_oops_buf_sz = size;
329 	big_oops_buf = buf;
330 
331 	pr_info("Using crash dump compression: %s\n", zbackend->name);
332 }
333 
334 static void free_buf_for_compression(void)
335 {
336 	if (IS_ENABLED(CONFIG_PSTORE_COMPRESS) && tfm) {
337 		crypto_free_comp(tfm);
338 		tfm = NULL;
339 	}
340 	kfree(big_oops_buf);
341 	big_oops_buf = NULL;
342 	big_oops_buf_sz = 0;
343 }
344 
345 /*
346  * Called when compression fails, since the printk buffer
347  * would be fetched for compression calling it again when
348  * compression fails would have moved the iterator of
349  * printk buffer which results in fetching old contents.
350  * Copy the recent messages from big_oops_buf to psinfo->buf
351  */
352 static size_t copy_kmsg_to_buffer(int hsize, size_t len)
353 {
354 	size_t total_len;
355 	size_t diff;
356 
357 	total_len = hsize + len;
358 
359 	if (total_len > psinfo->bufsize) {
360 		diff = total_len - psinfo->bufsize + hsize;
361 		memcpy(psinfo->buf, big_oops_buf, hsize);
362 		memcpy(psinfo->buf + hsize, big_oops_buf + diff,
363 					psinfo->bufsize - hsize);
364 		total_len = psinfo->bufsize;
365 	} else
366 		memcpy(psinfo->buf, big_oops_buf, total_len);
367 
368 	return total_len;
369 }
370 
371 void pstore_record_init(struct pstore_record *record,
372 			struct pstore_info *psinfo)
373 {
374 	memset(record, 0, sizeof(*record));
375 
376 	record->psi = psinfo;
377 
378 	/* Report zeroed timestamp if called before timekeeping has resumed. */
379 	record->time = ns_to_timespec64(ktime_get_real_fast_ns());
380 }
381 
382 /*
383  * callback from kmsg_dump. Save as much as we can (up to kmsg_bytes) from the
384  * end of the buffer.
385  */
386 static void pstore_dump(struct kmsg_dumper *dumper,
387 			enum kmsg_dump_reason reason)
388 {
389 	struct kmsg_dump_iter iter;
390 	unsigned long	total = 0;
391 	const char	*why;
392 	unsigned int	part = 1;
393 	unsigned long	flags = 0;
394 	int		ret;
395 
396 	why = kmsg_dump_reason_str(reason);
397 
398 	if (pstore_cannot_block_path(reason)) {
399 		if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) {
400 			pr_err("dump skipped in %s path because of concurrent dump\n",
401 					in_nmi() ? "NMI" : why);
402 			return;
403 		}
404 	} else {
405 		spin_lock_irqsave(&psinfo->buf_lock, flags);
406 	}
407 
408 	kmsg_dump_rewind(&iter);
409 
410 	oopscount++;
411 	while (total < kmsg_bytes) {
412 		char *dst;
413 		size_t dst_size;
414 		int header_size;
415 		int zipped_len = -1;
416 		size_t dump_size;
417 		struct pstore_record record;
418 
419 		pstore_record_init(&record, psinfo);
420 		record.type = PSTORE_TYPE_DMESG;
421 		record.count = oopscount;
422 		record.reason = reason;
423 		record.part = part;
424 		record.buf = psinfo->buf;
425 
426 		if (big_oops_buf) {
427 			dst = big_oops_buf;
428 			dst_size = big_oops_buf_sz;
429 		} else {
430 			dst = psinfo->buf;
431 			dst_size = psinfo->bufsize;
432 		}
433 
434 		/* Write dump header. */
435 		header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why,
436 				 oopscount, part);
437 		dst_size -= header_size;
438 
439 		/* Write dump contents. */
440 		if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,
441 					  dst_size, &dump_size))
442 			break;
443 
444 		if (big_oops_buf) {
445 			zipped_len = pstore_compress(dst, psinfo->buf,
446 						header_size + dump_size,
447 						psinfo->bufsize);
448 
449 			if (zipped_len > 0) {
450 				record.compressed = true;
451 				record.size = zipped_len;
452 			} else {
453 				record.size = copy_kmsg_to_buffer(header_size,
454 								  dump_size);
455 			}
456 		} else {
457 			record.size = header_size + dump_size;
458 		}
459 
460 		ret = psinfo->write(&record);
461 		if (ret == 0 && reason == KMSG_DUMP_OOPS) {
462 			pstore_new_entry = 1;
463 			pstore_timer_kick();
464 		}
465 
466 		total += record.size;
467 		part++;
468 	}
469 	spin_unlock_irqrestore(&psinfo->buf_lock, flags);
470 }
471 
472 static struct kmsg_dumper pstore_dumper = {
473 	.dump = pstore_dump,
474 };
475 
476 /*
477  * Register with kmsg_dump to save last part of console log on panic.
478  */
479 static void pstore_register_kmsg(void)
480 {
481 	kmsg_dump_register(&pstore_dumper);
482 }
483 
484 static void pstore_unregister_kmsg(void)
485 {
486 	kmsg_dump_unregister(&pstore_dumper);
487 }
488 
489 #ifdef CONFIG_PSTORE_CONSOLE
490 static void pstore_console_write(struct console *con, const char *s, unsigned c)
491 {
492 	struct pstore_record record;
493 
494 	if (!c)
495 		return;
496 
497 	pstore_record_init(&record, psinfo);
498 	record.type = PSTORE_TYPE_CONSOLE;
499 
500 	record.buf = (char *)s;
501 	record.size = c;
502 	psinfo->write(&record);
503 }
504 
505 static struct console pstore_console = {
506 	.write	= pstore_console_write,
507 	.index	= -1,
508 };
509 
510 static void pstore_register_console(void)
511 {
512 	/* Show which backend is going to get console writes. */
513 	strscpy(pstore_console.name, psinfo->name,
514 		sizeof(pstore_console.name));
515 	/*
516 	 * Always initialize flags here since prior unregister_console()
517 	 * calls may have changed settings (specifically CON_ENABLED).
518 	 */
519 	pstore_console.flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME;
520 	register_console(&pstore_console);
521 }
522 
523 static void pstore_unregister_console(void)
524 {
525 	unregister_console(&pstore_console);
526 }
527 #else
528 static void pstore_register_console(void) {}
529 static void pstore_unregister_console(void) {}
530 #endif
531 
532 static int pstore_write_user_compat(struct pstore_record *record,
533 				    const char __user *buf)
534 {
535 	int ret = 0;
536 
537 	if (record->buf)
538 		return -EINVAL;
539 
540 	record->buf = memdup_user(buf, record->size);
541 	if (IS_ERR(record->buf)) {
542 		ret = PTR_ERR(record->buf);
543 		goto out;
544 	}
545 
546 	ret = record->psi->write(record);
547 
548 	kfree(record->buf);
549 out:
550 	record->buf = NULL;
551 
552 	return unlikely(ret < 0) ? ret : record->size;
553 }
554 
555 /*
556  * platform specific persistent storage driver registers with
557  * us here. If pstore is already mounted, call the platform
558  * read function right away to populate the file system. If not
559  * then the pstore mount code will call us later to fill out
560  * the file system.
561  */
562 int pstore_register(struct pstore_info *psi)
563 {
564 	if (backend && strcmp(backend, psi->name)) {
565 		pr_warn("ignoring unexpected backend '%s'\n", psi->name);
566 		return -EPERM;
567 	}
568 
569 	/* Sanity check flags. */
570 	if (!psi->flags) {
571 		pr_warn("backend '%s' must support at least one frontend\n",
572 			psi->name);
573 		return -EINVAL;
574 	}
575 
576 	/* Check for required functions. */
577 	if (!psi->read || !psi->write) {
578 		pr_warn("backend '%s' must implement read() and write()\n",
579 			psi->name);
580 		return -EINVAL;
581 	}
582 
583 	mutex_lock(&psinfo_lock);
584 	if (psinfo) {
585 		pr_warn("backend '%s' already loaded: ignoring '%s'\n",
586 			psinfo->name, psi->name);
587 		mutex_unlock(&psinfo_lock);
588 		return -EBUSY;
589 	}
590 
591 	if (!psi->write_user)
592 		psi->write_user = pstore_write_user_compat;
593 	psinfo = psi;
594 	mutex_init(&psinfo->read_mutex);
595 	spin_lock_init(&psinfo->buf_lock);
596 
597 	if (psi->flags & PSTORE_FLAGS_DMESG)
598 		allocate_buf_for_compression();
599 
600 	pstore_get_records(0);
601 
602 	if (psi->flags & PSTORE_FLAGS_DMESG) {
603 		pstore_dumper.max_reason = psinfo->max_reason;
604 		pstore_register_kmsg();
605 	}
606 	if (psi->flags & PSTORE_FLAGS_CONSOLE)
607 		pstore_register_console();
608 	if (psi->flags & PSTORE_FLAGS_FTRACE)
609 		pstore_register_ftrace();
610 	if (psi->flags & PSTORE_FLAGS_PMSG)
611 		pstore_register_pmsg();
612 
613 	/* Start watching for new records, if desired. */
614 	pstore_timer_kick();
615 
616 	/*
617 	 * Update the module parameter backend, so it is visible
618 	 * through /sys/module/pstore/parameters/backend
619 	 */
620 	backend = kstrdup(psi->name, GFP_KERNEL);
621 
622 	pr_info("Registered %s as persistent store backend\n", psi->name);
623 
624 	mutex_unlock(&psinfo_lock);
625 	return 0;
626 }
627 EXPORT_SYMBOL_GPL(pstore_register);
628 
629 void pstore_unregister(struct pstore_info *psi)
630 {
631 	/* It's okay to unregister nothing. */
632 	if (!psi)
633 		return;
634 
635 	mutex_lock(&psinfo_lock);
636 
637 	/* Only one backend can be registered at a time. */
638 	if (WARN_ON(psi != psinfo)) {
639 		mutex_unlock(&psinfo_lock);
640 		return;
641 	}
642 
643 	/* Unregister all callbacks. */
644 	if (psi->flags & PSTORE_FLAGS_PMSG)
645 		pstore_unregister_pmsg();
646 	if (psi->flags & PSTORE_FLAGS_FTRACE)
647 		pstore_unregister_ftrace();
648 	if (psi->flags & PSTORE_FLAGS_CONSOLE)
649 		pstore_unregister_console();
650 	if (psi->flags & PSTORE_FLAGS_DMESG)
651 		pstore_unregister_kmsg();
652 
653 	/* Stop timer and make sure all work has finished. */
654 	del_timer_sync(&pstore_timer);
655 	flush_work(&pstore_work);
656 
657 	/* Remove all backend records from filesystem tree. */
658 	pstore_put_backend_records(psi);
659 
660 	free_buf_for_compression();
661 
662 	psinfo = NULL;
663 	kfree(backend);
664 	backend = NULL;
665 	mutex_unlock(&psinfo_lock);
666 }
667 EXPORT_SYMBOL_GPL(pstore_unregister);
668 
669 static void decompress_record(struct pstore_record *record)
670 {
671 	int ret;
672 	int unzipped_len;
673 	char *unzipped, *workspace;
674 
675 	if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !record->compressed)
676 		return;
677 
678 	/* Only PSTORE_TYPE_DMESG support compression. */
679 	if (record->type != PSTORE_TYPE_DMESG) {
680 		pr_warn("ignored compressed record type %d\n", record->type);
681 		return;
682 	}
683 
684 	/* Missing compression buffer means compression was not initialized. */
685 	if (!big_oops_buf) {
686 		pr_warn("no decompression method initialized!\n");
687 		return;
688 	}
689 
690 	/* Allocate enough space to hold max decompression and ECC. */
691 	unzipped_len = big_oops_buf_sz;
692 	workspace = kmalloc(unzipped_len + record->ecc_notice_size,
693 			    GFP_KERNEL);
694 	if (!workspace)
695 		return;
696 
697 	/* After decompression "unzipped_len" is almost certainly smaller. */
698 	ret = crypto_comp_decompress(tfm, record->buf, record->size,
699 					  workspace, &unzipped_len);
700 	if (ret) {
701 		pr_err("crypto_comp_decompress failed, ret = %d!\n", ret);
702 		kfree(workspace);
703 		return;
704 	}
705 
706 	/* Append ECC notice to decompressed buffer. */
707 	memcpy(workspace + unzipped_len, record->buf + record->size,
708 	       record->ecc_notice_size);
709 
710 	/* Copy decompressed contents into an minimum-sized allocation. */
711 	unzipped = kmemdup(workspace, unzipped_len + record->ecc_notice_size,
712 			   GFP_KERNEL);
713 	kfree(workspace);
714 	if (!unzipped)
715 		return;
716 
717 	/* Swap out compressed contents with decompressed contents. */
718 	kfree(record->buf);
719 	record->buf = unzipped;
720 	record->size = unzipped_len;
721 	record->compressed = false;
722 }
723 
724 /*
725  * Read all the records from one persistent store backend. Create
726  * files in our filesystem.  Don't warn about -EEXIST errors
727  * when we are re-scanning the backing store looking to add new
728  * error records.
729  */
730 void pstore_get_backend_records(struct pstore_info *psi,
731 				struct dentry *root, int quiet)
732 {
733 	int failed = 0;
734 	unsigned int stop_loop = 65536;
735 
736 	if (!psi || !root)
737 		return;
738 
739 	mutex_lock(&psi->read_mutex);
740 	if (psi->open && psi->open(psi))
741 		goto out;
742 
743 	/*
744 	 * Backend callback read() allocates record.buf. decompress_record()
745 	 * may reallocate record.buf. On success, pstore_mkfile() will keep
746 	 * the record.buf, so free it only on failure.
747 	 */
748 	for (; stop_loop; stop_loop--) {
749 		struct pstore_record *record;
750 		int rc;
751 
752 		record = kzalloc(sizeof(*record), GFP_KERNEL);
753 		if (!record) {
754 			pr_err("out of memory creating record\n");
755 			break;
756 		}
757 		pstore_record_init(record, psi);
758 
759 		record->size = psi->read(record);
760 
761 		/* No more records left in backend? */
762 		if (record->size <= 0) {
763 			kfree(record);
764 			break;
765 		}
766 
767 		decompress_record(record);
768 		rc = pstore_mkfile(root, record);
769 		if (rc) {
770 			/* pstore_mkfile() did not take record, so free it. */
771 			kfree(record->buf);
772 			kfree(record);
773 			if (rc != -EEXIST || !quiet)
774 				failed++;
775 		}
776 	}
777 	if (psi->close)
778 		psi->close(psi);
779 out:
780 	mutex_unlock(&psi->read_mutex);
781 
782 	if (failed)
783 		pr_warn("failed to create %d record(s) from '%s'\n",
784 			failed, psi->name);
785 	if (!stop_loop)
786 		pr_err("looping? Too many records seen from '%s'\n",
787 			psi->name);
788 }
789 
790 static void pstore_dowork(struct work_struct *work)
791 {
792 	pstore_get_records(1);
793 }
794 
795 static void pstore_timefunc(struct timer_list *unused)
796 {
797 	if (pstore_new_entry) {
798 		pstore_new_entry = 0;
799 		schedule_work(&pstore_work);
800 	}
801 
802 	pstore_timer_kick();
803 }
804 
805 static void __init pstore_choose_compression(void)
806 {
807 	const struct pstore_zbackend *step;
808 
809 	if (!compress)
810 		return;
811 
812 	for (step = zbackends; step->name; step++) {
813 		if (!strcmp(compress, step->name)) {
814 			zbackend = step;
815 			return;
816 		}
817 	}
818 }
819 
820 static int __init pstore_init(void)
821 {
822 	int ret;
823 
824 	pstore_choose_compression();
825 
826 	/*
827 	 * Check if any pstore backends registered earlier but did not
828 	 * initialize compression because crypto was not ready. If so,
829 	 * initialize compression now.
830 	 */
831 	allocate_buf_for_compression();
832 
833 	ret = pstore_init_fs();
834 	if (ret)
835 		free_buf_for_compression();
836 
837 	return ret;
838 }
839 late_initcall(pstore_init);
840 
841 static void __exit pstore_exit(void)
842 {
843 	pstore_exit_fs();
844 }
845 module_exit(pstore_exit)
846 
847 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
848 MODULE_LICENSE("GPL");
849