* [PATCH v7 01/18] pstore/ram: Move dump_oops to end of module_param list
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 02/18] pstore/platform: Switch pstore_info::name to const Kees Cook
` (18 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
When reading "modinfo" details, dump_oops was before max_reason, which
seems odd given dump_oops is now considered deprecated. Move it to the
very end instead.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/ram.c | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 198d04cceb3e..7f956053f4e5 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -57,11 +57,6 @@ module_param(mem_type, uint, 0400);
MODULE_PARM_DESC(mem_type,
"set to 1 to try to use unbuffered memory (default 0)");
-static int ramoops_dump_oops = -1;
-module_param_named(dump_oops, ramoops_dump_oops, int, 0400);
-MODULE_PARM_DESC(dump_oops,
- "set to 1 to dump oopses & panics, 0 to only dump panics (deprecated: use max_reason instead)");
-
static int ramoops_max_reason = KMSG_DUMP_OOPS;
module_param_named(max_reason, ramoops_max_reason, int, 0400);
MODULE_PARM_DESC(max_reason,
@@ -74,6 +69,11 @@ MODULE_PARM_DESC(ramoops_ecc,
"ECC buffer size in bytes (1 is a special value, means 16 "
"bytes ECC)");
+static int ramoops_dump_oops = -1;
+module_param_named(dump_oops, ramoops_dump_oops, int, 0400);
+MODULE_PARM_DESC(dump_oops,
+ "(deprecated: use max_reason instead) set to 1 to dump oopses & panics, 0 to only dump panics");
+
struct ramoops_context {
struct persistent_ram_zone **dprzs; /* Oops dump zones */
struct persistent_ram_zone *cprz; /* Console zone */
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 02/18] pstore/platform: Switch pstore_info::name to const
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
2020-05-10 20:24 ` [PATCH v7 01/18] pstore/ram: Move dump_oops to end of module_param list Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 03/18] pstore/platform: Move module params after declarations Kees Cook
` (17 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
In order to more cleanly pass around backend names, make the "name" member
const. This means the module param needs to be dynamic (technically, it
was before, so this actually cleans up a minor memory leak if a backend
was specified and then gets unloaded.)
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/platform.c | 3 ++-
include/linux/pstore.h | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index b882919b8784..e7bf22f01928 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -626,7 +626,7 @@ int pstore_register(struct pstore_info *psi)
* Update the module parameter backend, so it is visible
* through /sys/module/pstore/parameters/backend
*/
- backend = psi->name;
+ backend = kstrdup(psi->name, GFP_KERNEL);
pr_info("Registered %s as persistent store backend\n", psi->name);
@@ -669,6 +669,7 @@ void pstore_unregister(struct pstore_info *psi)
free_buf_for_compression();
psinfo = NULL;
+ kfree(backend);
backend = NULL;
mutex_unlock(&psinfo_lock);
}
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 16a1fdafc167..eb93a54cff31 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -176,7 +176,7 @@ struct pstore_record {
*/
struct pstore_info {
struct module *owner;
- char *name;
+ const char *name;
struct semaphore buf_lock;
char *buf;
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 03/18] pstore/platform: Move module params after declarations
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
2020-05-10 20:24 ` [PATCH v7 01/18] pstore/ram: Move dump_oops to end of module_param list Kees Cook
2020-05-10 20:24 ` [PATCH v7 02/18] pstore/platform: Switch pstore_info::name to const Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 04/18] pstore/platform: Use backend name for console registration Kees Cook
` (16 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
It is easier to see how module params are used if they're near the
variables they use.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/platform.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index e7bf22f01928..bf7fa7b278bd 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -77,12 +77,17 @@ static DEFINE_MUTEX(psinfo_lock);
struct pstore_info *psinfo;
static char *backend;
+module_param(backend, charp, 0444);
+MODULE_PARM_DESC(backend, "specific backend to use");
+
static char *compress =
#ifdef CONFIG_PSTORE_COMPRESS_DEFAULT
CONFIG_PSTORE_COMPRESS_DEFAULT;
#else
NULL;
#endif
+module_param(compress, charp, 0444);
+MODULE_PARM_DESC(compress, "compression to use");
/* Compression parameters */
static struct crypto_comp *tfm;
@@ -853,11 +858,5 @@ static void __exit pstore_exit(void)
}
module_exit(pstore_exit)
-module_param(compress, charp, 0444);
-MODULE_PARM_DESC(compress, "Pstore compression to use");
-
-module_param(backend, charp, 0444);
-MODULE_PARM_DESC(backend, "Pstore backend to use");
-
MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
MODULE_LICENSE("GPL");
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 04/18] pstore/platform: Use backend name for console registration
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (2 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 03/18] pstore/platform: Move module params after declarations Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 05/18] pstore/ram: Refactor ftrace buffer merging Kees Cook
` (15 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
If the pstore backend changes, there's no indication in the logs what
the console is (it always says "pstore"). Instead, pass through the
active backend's name.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/platform.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index bf7fa7b278bd..90d146fbc7d2 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -519,13 +519,15 @@ static void pstore_console_write(struct console *con, const char *s, unsigned c)
}
static struct console pstore_console = {
- .name = "pstore",
.write = pstore_console_write,
.index = -1,
};
static void pstore_register_console(void)
{
+ /* Show which backend is going to get console writes. */
+ strscpy(pstore_console.name, psinfo->name,
+ sizeof(pstore_console.name));
/*
* Always initialize flags here since prior unregister_console()
* calls may have changed settings (specifically CON_ENABLED).
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 05/18] pstore/ram: Refactor ftrace buffer merging
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (3 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 04/18] pstore/platform: Use backend name for console registration Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 06/18] pstore/ftrace: Provide ftrace log merging routine Kees Cook
` (14 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
This changes the ftrace record merging code to be agnostic of
pstore/ram, as the first step to making it available as a generic
routine for other backends to use, such as pstore/zone.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/ram.c | 29 +++++++++++++++++------------
1 file changed, 17 insertions(+), 12 deletions(-)
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 7f956053f4e5..672ad80646c5 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -172,8 +172,9 @@ static bool prz_ok(struct persistent_ram_zone *prz)
persistent_ram_ecc_string(prz, NULL, 0));
}
-static ssize_t ftrace_log_combine(struct persistent_ram_zone *dest,
- struct persistent_ram_zone *src)
+static
+ssize_t ftrace_log_combine(char **dest_log, size_t *dest_log_size,
+ const char *src_log, size_t src_log_size)
{
size_t dest_size, src_size, total, dest_off, src_off;
size_t dest_idx = 0, src_idx = 0, merged_idx = 0;
@@ -181,19 +182,19 @@ static ssize_t ftrace_log_combine(struct persistent_ram_zone *dest,
struct pstore_ftrace_record *drec, *srec, *mrec;
size_t record_size = sizeof(struct pstore_ftrace_record);
- dest_off = dest->old_log_size % record_size;
- dest_size = dest->old_log_size - dest_off;
+ dest_off = *dest_log_size % record_size;
+ dest_size = *dest_log_size - dest_off;
- src_off = src->old_log_size % record_size;
- src_size = src->old_log_size - src_off;
+ src_off = src_log_size % record_size;
+ src_size = src_log_size - src_off;
total = dest_size + src_size;
merged_buf = kmalloc(total, GFP_KERNEL);
if (!merged_buf)
return -ENOMEM;
- drec = (struct pstore_ftrace_record *)(dest->old_log + dest_off);
- srec = (struct pstore_ftrace_record *)(src->old_log + src_off);
+ drec = (struct pstore_ftrace_record *)(*dest_log + dest_off);
+ srec = (struct pstore_ftrace_record *)(src_log + src_off);
mrec = (struct pstore_ftrace_record *)(merged_buf);
while (dest_size > 0 && src_size > 0) {
@@ -217,9 +218,9 @@ static ssize_t ftrace_log_combine(struct persistent_ram_zone *dest,
src_size -= record_size;
}
- kfree(dest->old_log);
- dest->old_log = merged_buf;
- dest->old_log_size = total;
+ kfree(*dest_log);
+ *dest_log = merged_buf;
+ *dest_log_size = total;
return 0;
}
@@ -295,7 +296,11 @@ static ssize_t ramoops_pstore_read(struct pstore_record *record)
tmp_prz->corrected_bytes +=
prz_next->corrected_bytes;
tmp_prz->bad_blocks += prz_next->bad_blocks;
- size = ftrace_log_combine(tmp_prz, prz_next);
+
+ size = ftrace_log_combine(&tmp_prz->old_log,
+ &tmp_prz->old_log_size,
+ prz_next->old_log,
+ prz_next->old_log_size);
if (size)
goto out;
}
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 06/18] pstore/ftrace: Provide ftrace log merging routine
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (4 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 05/18] pstore/ram: Refactor ftrace buffer merging Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str() Kees Cook
` (13 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
Move the ftrace log merging logic out of pstore/ram into pstore/ftrace
so other backends can use it, like pstore/zone.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/ftrace.c | 54 +++++++++++++++++++++++++++++++++++++++++
fs/pstore/internal.h | 9 +++++++
fs/pstore/ram.c | 57 +++-----------------------------------------
3 files changed, 66 insertions(+), 54 deletions(-)
diff --git a/fs/pstore/ftrace.c b/fs/pstore/ftrace.c
index bfbfc2698070..5c0450701293 100644
--- a/fs/pstore/ftrace.c
+++ b/fs/pstore/ftrace.c
@@ -16,6 +16,7 @@
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/cache.h>
+#include <linux/slab.h>
#include <asm/barrier.h>
#include "internal.h"
@@ -132,3 +133,56 @@ void pstore_unregister_ftrace(void)
debugfs_remove_recursive(pstore_ftrace_dir);
}
+
+ssize_t pstore_ftrace_combine_log(char **dest_log, size_t *dest_log_size,
+ const char *src_log, size_t src_log_size)
+{
+ size_t dest_size, src_size, total, dest_off, src_off;
+ size_t dest_idx = 0, src_idx = 0, merged_idx = 0;
+ void *merged_buf;
+ struct pstore_ftrace_record *drec, *srec, *mrec;
+ size_t record_size = sizeof(struct pstore_ftrace_record);
+
+ dest_off = *dest_log_size % record_size;
+ dest_size = *dest_log_size - dest_off;
+
+ src_off = src_log_size % record_size;
+ src_size = src_log_size - src_off;
+
+ total = dest_size + src_size;
+ merged_buf = kmalloc(total, GFP_KERNEL);
+ if (!merged_buf)
+ return -ENOMEM;
+
+ drec = (struct pstore_ftrace_record *)(*dest_log + dest_off);
+ srec = (struct pstore_ftrace_record *)(src_log + src_off);
+ mrec = (struct pstore_ftrace_record *)(merged_buf);
+
+ while (dest_size > 0 && src_size > 0) {
+ if (pstore_ftrace_read_timestamp(&drec[dest_idx]) <
+ pstore_ftrace_read_timestamp(&srec[src_idx])) {
+ mrec[merged_idx++] = drec[dest_idx++];
+ dest_size -= record_size;
+ } else {
+ mrec[merged_idx++] = srec[src_idx++];
+ src_size -= record_size;
+ }
+ }
+
+ while (dest_size > 0) {
+ mrec[merged_idx++] = drec[dest_idx++];
+ dest_size -= record_size;
+ }
+
+ while (src_size > 0) {
+ mrec[merged_idx++] = srec[src_idx++];
+ src_size -= record_size;
+ }
+
+ kfree(*dest_log);
+ *dest_log = merged_buf;
+ *dest_log_size = total;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(pstore_ftrace_combine_log);
diff --git a/fs/pstore/internal.h b/fs/pstore/internal.h
index 8efd72d93b10..7fb219042f13 100644
--- a/fs/pstore/internal.h
+++ b/fs/pstore/internal.h
@@ -12,9 +12,18 @@ extern unsigned long kmsg_bytes;
#ifdef CONFIG_PSTORE_FTRACE
extern void pstore_register_ftrace(void);
extern void pstore_unregister_ftrace(void);
+ssize_t pstore_ftrace_combine_log(char **dest_log, size_t *dest_log_size,
+ const char *src_log, size_t src_log_size);
#else
static inline void pstore_register_ftrace(void) {}
static inline void pstore_unregister_ftrace(void) {}
+static inline ssize_t
+pstore_ftrace_combine_log(char **dest_log, size_t *dest_log_size,
+ const char *src_log, size_t src_log_size)
+{
+ *dest_log_size = 0;
+ return 0;
+}
#endif
#ifdef CONFIG_PSTORE_PMSG
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 672ad80646c5..b7929fdc0c72 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -21,6 +21,7 @@
#include <linux/pstore_ram.h>
#include <linux/of.h>
#include <linux/of_address.h>
+#include "internal.h"
#define RAMOOPS_KERNMSG_HDR "===="
#define MIN_MEM_SIZE 4096UL
@@ -172,59 +173,6 @@ static bool prz_ok(struct persistent_ram_zone *prz)
persistent_ram_ecc_string(prz, NULL, 0));
}
-static
-ssize_t ftrace_log_combine(char **dest_log, size_t *dest_log_size,
- const char *src_log, size_t src_log_size)
-{
- size_t dest_size, src_size, total, dest_off, src_off;
- size_t dest_idx = 0, src_idx = 0, merged_idx = 0;
- void *merged_buf;
- struct pstore_ftrace_record *drec, *srec, *mrec;
- size_t record_size = sizeof(struct pstore_ftrace_record);
-
- dest_off = *dest_log_size % record_size;
- dest_size = *dest_log_size - dest_off;
-
- src_off = src_log_size % record_size;
- src_size = src_log_size - src_off;
-
- total = dest_size + src_size;
- merged_buf = kmalloc(total, GFP_KERNEL);
- if (!merged_buf)
- return -ENOMEM;
-
- drec = (struct pstore_ftrace_record *)(*dest_log + dest_off);
- srec = (struct pstore_ftrace_record *)(src_log + src_off);
- mrec = (struct pstore_ftrace_record *)(merged_buf);
-
- while (dest_size > 0 && src_size > 0) {
- if (pstore_ftrace_read_timestamp(&drec[dest_idx]) <
- pstore_ftrace_read_timestamp(&srec[src_idx])) {
- mrec[merged_idx++] = drec[dest_idx++];
- dest_size -= record_size;
- } else {
- mrec[merged_idx++] = srec[src_idx++];
- src_size -= record_size;
- }
- }
-
- while (dest_size > 0) {
- mrec[merged_idx++] = drec[dest_idx++];
- dest_size -= record_size;
- }
-
- while (src_size > 0) {
- mrec[merged_idx++] = srec[src_idx++];
- src_size -= record_size;
- }
-
- kfree(*dest_log);
- *dest_log = merged_buf;
- *dest_log_size = total;
-
- return 0;
-}
-
static ssize_t ramoops_pstore_read(struct pstore_record *record)
{
ssize_t size = 0;
@@ -297,7 +245,8 @@ static ssize_t ramoops_pstore_read(struct pstore_record *record)
prz_next->corrected_bytes;
tmp_prz->bad_blocks += prz_next->bad_blocks;
- size = ftrace_log_combine(&tmp_prz->old_log,
+ size = pstore_ftrace_combine_log(
+ &tmp_prz->old_log,
&tmp_prz->old_log_size,
prz_next->old_log,
prz_next->old_log_size);
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str()
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (5 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 06/18] pstore/ftrace: Provide ftrace log merging routine Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-12 8:44 ` Petr Mladek
2020-05-13 5:08 ` Sergey Senozhatsky
2020-05-10 20:24 ` [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones Kees Cook
` (12 subsequent siblings)
19 siblings, 2 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
The pstore subsystem already had a private version of this function.
With the coming addition of the pstore/zone driver, this needs to be
shared. As it really should live with printk, move it there instead.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/platform.c | 22 +---------------------
include/linux/kmsg_dump.h | 7 +++++++
kernel/printk/printk.c | 21 +++++++++++++++++++++
3 files changed, 29 insertions(+), 21 deletions(-)
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 90d146fbc7d2..a9e297eefdff 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -135,26 +135,6 @@ enum pstore_type_id pstore_name_to_type(const char *name)
}
EXPORT_SYMBOL_GPL(pstore_name_to_type);
-static const char *get_reason_str(enum kmsg_dump_reason reason)
-{
- switch (reason) {
- case KMSG_DUMP_PANIC:
- return "Panic";
- case KMSG_DUMP_OOPS:
- return "Oops";
- case KMSG_DUMP_EMERG:
- return "Emergency";
- case KMSG_DUMP_RESTART:
- return "Restart";
- case KMSG_DUMP_HALT:
- return "Halt";
- case KMSG_DUMP_POWEROFF:
- return "Poweroff";
- default:
- return "Unknown";
- }
-}
-
static void pstore_timer_kick(void)
{
if (pstore_update_ms < 0)
@@ -407,7 +387,7 @@ static void pstore_dump(struct kmsg_dumper *dumper,
unsigned int part = 1;
int ret;
- why = get_reason_str(reason);
+ why = kmsg_dump_reason_str(reason);
if (down_trylock(&psinfo->buf_lock)) {
/* Failed to acquire lock: give up if we cannot wait. */
diff --git a/include/linux/kmsg_dump.h b/include/linux/kmsg_dump.h
index cfc042066be7..b3ddb0b2ee40 100644
--- a/include/linux/kmsg_dump.h
+++ b/include/linux/kmsg_dump.h
@@ -72,6 +72,8 @@ void kmsg_dump_rewind(struct kmsg_dumper *dumper);
int kmsg_dump_register(struct kmsg_dumper *dumper);
int kmsg_dump_unregister(struct kmsg_dumper *dumper);
+
+const char *kmsg_dump_reason_str(enum kmsg_dump_reason reason);
#else
static inline void kmsg_dump(enum kmsg_dump_reason reason)
{
@@ -113,6 +115,11 @@ static inline int kmsg_dump_unregister(struct kmsg_dumper *dumper)
{
return -EINVAL;
}
+
+static inline const char *kmsg_dump_reason_str(enum kmsg_dump_reason reason)
+{
+ return "Disabled";
+}
#endif
#endif /* _LINUX_KMSG_DUMP_H */
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 1aab69a8a2bf..67a284830d74 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -3144,6 +3144,27 @@ EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
static bool always_kmsg_dump;
module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
+const char *kmsg_dump_reason_str(enum kmsg_dump_reason reason)
+{
+ switch (reason) {
+ case KMSG_DUMP_PANIC:
+ return "Panic";
+ case KMSG_DUMP_OOPS:
+ return "Oops";
+ case KMSG_DUMP_EMERG:
+ return "Emergency";
+ case KMSG_DUMP_RESTART:
+ return "Restart";
+ case KMSG_DUMP_HALT:
+ return "Halt";
+ case KMSG_DUMP_POWEROFF:
+ return "Poweroff";
+ default:
+ return "Unknown";
+ }
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_reason_str);
+
/**
* kmsg_dump - dump kernel log to kernel message dumpers.
* @reason: the reason (oops, panic etc) for dumping
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str()
2020-05-10 20:24 ` [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str() Kees Cook
@ 2020-05-12 8:44 ` Petr Mladek
2020-05-12 19:44 ` Kees Cook
2020-05-13 5:08 ` Sergey Senozhatsky
1 sibling, 1 reply; 37+ messages in thread
From: Petr Mladek @ 2020-05-12 8:44 UTC (permalink / raw)
To: Kees Cook
Cc: WeiXiong Liao, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Sergey Senozhatsky, Steven Rostedt,
Rob Herring, Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Sun 2020-05-10 13:24:25, Kees Cook wrote:
> The pstore subsystem already had a private version of this function.
> With the coming addition of the pstore/zone driver, this needs to be
> shared. As it really should live with printk, move it there instead.
>
> Signed-off-by: Kees Cook <keescook@chromium.org>
I looked only at this printk part and it looks good to me ;-)
Acked-by: Petr Mladek <pmladek@suse.com>
Best Regards,
Petr
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str()
2020-05-12 8:44 ` Petr Mladek
@ 2020-05-12 19:44 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-12 19:44 UTC (permalink / raw)
To: Petr Mladek
Cc: WeiXiong Liao, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Sergey Senozhatsky, Steven Rostedt,
Rob Herring, Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Tue, May 12, 2020 at 10:44:42AM +0200, Petr Mladek wrote:
> On Sun 2020-05-10 13:24:25, Kees Cook wrote:
> > The pstore subsystem already had a private version of this function.
> > With the coming addition of the pstore/zone driver, this needs to be
> > shared. As it really should live with printk, move it there instead.
> >
> > Signed-off-by: Kees Cook <keescook@chromium.org>
>
> I looked only at this printk part and it looks good to me ;-)
>
> Acked-by: Petr Mladek <pmladek@suse.com>
Excellent; thanks!
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str()
2020-05-10 20:24 ` [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str() Kees Cook
2020-05-12 8:44 ` Petr Mladek
@ 2020-05-13 5:08 ` Sergey Senozhatsky
1 sibling, 0 replies; 37+ messages in thread
From: Sergey Senozhatsky @ 2020-05-13 5:08 UTC (permalink / raw)
To: Kees Cook
Cc: WeiXiong Liao, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
On (20/05/10 13:24), Kees Cook wrote:
> The pstore subsystem already had a private version of this function.
> With the coming addition of the pstore/zone driver, this needs to be
> shared. As it really should live with printk, move it there instead.
Acked-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
-ss
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (6 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 07/18] printk: Introduce kmsg_dump_reason_str() Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 8:36 ` WeiXiong Liao
2020-05-10 20:24 ` [PATCH v7 09/18] pstore/blk: Introduce backend for block devices Kees Cook
` (11 subsequent siblings)
19 siblings, 1 reply; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Implement a common set of APIs needed to support pstore storage zones,
based on how ramoops is designed. This will be used by pstore/blk with
the intention of migrating pstore/ram in the future.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-2-git-send-email-liaoweixiong@allwinnertech.com
Co-developed-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/Kconfig | 7 +
fs/pstore/Makefile | 3 +
fs/pstore/zone.c | 985 ++++++++++++++++++++++++++++++++++++
include/linux/pstore_zone.h | 44 ++
4 files changed, 1039 insertions(+)
create mode 100644 fs/pstore/zone.c
create mode 100644 include/linux/pstore_zone.h
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index 8f0369aad22a..98d2457bdd9f 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -153,3 +153,10 @@ config PSTORE_RAM
"ramoops.ko".
For more information, see Documentation/admin-guide/ramoops.rst.
+
+config PSTORE_ZONE
+ tristate
+ depends on PSTORE
+ help
+ The common layer for pstore/blk (and pstore/ram in the future)
+ to manage storage in zones.
diff --git a/fs/pstore/Makefile b/fs/pstore/Makefile
index 967b5891f325..58a967cbe4af 100644
--- a/fs/pstore/Makefile
+++ b/fs/pstore/Makefile
@@ -12,3 +12,6 @@ pstore-$(CONFIG_PSTORE_PMSG) += pmsg.o
ramoops-objs += ram.o ram_core.o
obj-$(CONFIG_PSTORE_RAM) += ramoops.o
+
+pstore_zone-objs += zone.o
+obj-$(CONFIG_PSTORE_ZONE) += pstore_zone.o
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
new file mode 100644
index 000000000000..a388c299ebb1
--- /dev/null
+++ b/fs/pstore/zone.c
@@ -0,0 +1,985 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Provide a pstore intermediate backend, organized into kernel memory
+ * allocated zones that are then mapped and flushed into a single
+ * contiguous region on a storage backend of some kind (block, mtd, etc).
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/mount.h>
+#include <linux/printk.h>
+#include <linux/fs.h>
+#include <linux/pstore_zone.h>
+#include <linux/kdev_t.h>
+#include <linux/device.h>
+#include <linux/namei.h>
+#include <linux/fcntl.h>
+#include <linux/uio.h>
+#include <linux/writeback.h>
+#include "internal.h"
+
+/**
+ * struct psz_head - header of zone to flush to storage
+ *
+ * @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value)
+ * @datalen: length of data in @data
+ * @data: zone data.
+ */
+struct psz_buffer {
+#define PSZ_SIG (0x43474244) /* DBGC */
+ uint32_t sig;
+ atomic_t datalen;
+ uint8_t data[];
+};
+
+/**
+ * struct psz_kmsg_header - kmsg dump-specific header to flush to storage
+ *
+ * @magic: magic num for oops header
+ * @time: oops/panic trigger time
+ * @compressed: whether conpressed
+ * @counter: oops/panic counter
+ * @reason: identify oops or panic
+ * @data: pointer to log data
+ *
+ * This is a sub-header for a kmsg dump, trailing after &psz_buffer.
+ */
+struct psz_kmsg_header {
+#define OOPS_HEADER_MAGIC 0x4dfc3ae5 /* Just a random number */
+ uint32_t magic;
+ struct timespec64 time;
+ bool compressed;
+ uint32_t counter;
+ enum kmsg_dump_reason reason;
+ uint8_t data[];
+};
+
+/**
+ * struct pstore_zone - single stored buffer
+ *
+ * @off: zone offset of storage
+ * @type: front-end type for this zone
+ * @name: front-end name for this zone
+ * @buffer: pointer to data buffer managed by this zone
+ * @oldbuf: pointer to old data buffer
+ * @buffer_size: bytes in @buffer->data
+ * @should_recover: whether this zone should recover from storage
+ * @dirty: whether the data in @buffer dirty
+ *
+ * zone structure in memory.
+ */
+struct pstore_zone {
+ loff_t off;
+ const char *name;
+ enum pstore_type_id type;
+
+ struct psz_buffer *buffer;
+ struct psz_buffer *oldbuf;
+ size_t buffer_size;
+ bool should_recover;
+ atomic_t dirty;
+};
+
+/**
+ * struct psz_context - all about running state of pstore/zone
+ *
+ * @opszs: oops/panic storage zones
+ * @kmsg_max_cnt: max count of @opszs
+ * @kmsg_read_cnt: counter to read oops zone
+ * @kmsg_write_cnt: counter to write
+ * @oops_counter: counter to oops
+ * @panic_counter: counter to panic
+ * @recovered: whether finish recovering data from storage
+ * @on_panic: whether occur panic
+ * @pstore_zone_info_lock: lock to @pstore_zone_info
+ * @pstore_zone_info: information from back-end
+ * @pstore: structure for pstore
+ */
+struct psz_context {
+ struct pstore_zone **opszs;
+ unsigned int kmsg_max_cnt;
+ unsigned int kmsg_read_cnt;
+ unsigned int kmsg_write_cnt;
+ /*
+ * the counter should be recovered when recover.
+ * It records the oops/panic times after burning rather than booting.
+ */
+ unsigned int oops_counter;
+ unsigned int panic_counter;
+ atomic_t recovered;
+ atomic_t on_panic;
+
+ /*
+ * pstore_zone_info_lock protects this entire structure during calls
+ * to register_pstore_zone()/unregister_pstore_zone().
+ */
+ struct mutex pstore_zone_info_lock;
+ struct pstore_zone_info *pstore_zone_info;
+ struct pstore_info pstore;
+};
+static struct psz_context pstore_zone_cxt;
+
+/**
+ * enum psz_flush_mode - flush mode for psz_zone_write()
+ *
+ * @FLUSH_NONE: do not flush to storage but update data on memory
+ * @FLUSH_PART: just flush part of data including meta data to storage
+ * @FLUSH_META: just flush meta data of zone to storage
+ * @FLUSH_ALL: flush all of zone
+ */
+enum psz_flush_mode {
+ FLUSH_NONE = 0,
+ FLUSH_PART,
+ FLUSH_META,
+ FLUSH_ALL,
+};
+
+static inline int buffer_datalen(struct pstore_zone *zone)
+{
+ return atomic_read(&zone->buffer->datalen);
+}
+
+static inline bool is_on_panic(void)
+{
+ return atomic_read(&pstore_zone_cxt.on_panic);
+}
+
+static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
+ size_t len, unsigned long off)
+{
+ if (!buf || !zone->buffer)
+ return -EINVAL;
+ if (off > zone->buffer_size)
+ return -EINVAL;
+ len = min_t(size_t, len, zone->buffer_size - off);
+ memcpy(buf, zone->buffer->data + off, len);
+ return len;
+}
+
+static int psz_zone_write(struct pstore_zone *zone,
+ enum psz_flush_mode flush_mode, const char *buf,
+ size_t len, unsigned long off)
+{
+ struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
+ ssize_t wcnt = 0;
+ ssize_t (*writeop)(const char *buf, size_t bytes, loff_t pos);
+ size_t wlen;
+
+ if (off > zone->buffer_size)
+ return -EINVAL;
+
+ wlen = min_t(size_t, len, zone->buffer_size - off);
+ if (buf && wlen) {
+ memcpy(zone->buffer->data + off, buf, wlen);
+ atomic_set(&zone->buffer->datalen, wlen + off);
+ }
+
+ /* avoid to damage old records */
+ if (!is_on_panic() && !atomic_read(&pstore_zone_cxt.recovered))
+ goto dirty;
+
+ writeop = is_on_panic() ? info->panic_write : info->write;
+ if (!writeop)
+ goto dirty;
+
+ switch (flush_mode) {
+ case FLUSH_NONE:
+ if (unlikely(buf && wlen))
+ goto dirty;
+ return 0;
+ case FLUSH_PART:
+ wcnt = writeop((const char *)zone->buffer->data + off, wlen,
+ zone->off + sizeof(*zone->buffer) + off);
+ if (wcnt != wlen)
+ goto dirty;
+ fallthrough;
+ case FLUSH_META:
+ wlen = sizeof(struct psz_buffer);
+ wcnt = writeop((const char *)zone->buffer, wlen, zone->off);
+ if (wcnt != wlen)
+ goto dirty;
+ break;
+ case FLUSH_ALL:
+ wlen = zone->buffer_size + sizeof(*zone->buffer);
+ wcnt = writeop((const char *)zone->buffer, wlen, zone->off);
+ if (wcnt != wlen)
+ goto dirty;
+ break;
+ }
+
+ return 0;
+dirty:
+ atomic_set(&zone->dirty, true);
+ return -EBUSY;
+}
+
+static int psz_flush_dirty_zone(struct pstore_zone *zone)
+{
+ int ret;
+
+ if (unlikely(!zone))
+ return -EINVAL;
+
+ if (unlikely(!atomic_read(&pstore_zone_cxt.recovered)))
+ return -EBUSY;
+
+ if (!atomic_xchg(&zone->dirty, false))
+ return 0;
+
+ ret = psz_zone_write(zone, FLUSH_ALL, NULL, 0, 0);
+ if (ret)
+ atomic_set(&zone->dirty, true);
+ return ret;
+}
+
+static int psz_flush_dirty_zones(struct pstore_zone **zones, unsigned int cnt)
+{
+ int i, ret;
+ struct pstore_zone *zone;
+
+ if (!zones)
+ return -EINVAL;
+
+ for (i = 0; i < cnt; i++) {
+ zone = zones[i];
+ if (!zone)
+ return -EINVAL;
+ ret = psz_flush_dirty_zone(zone);
+ if (ret)
+ return ret;
+ }
+ return 0;
+}
+
+static int psz_move_zone(struct pstore_zone *old, struct pstore_zone *new)
+{
+ const char *data = (const char *)old->buffer->data;
+ int ret;
+
+ ret = psz_zone_write(new, FLUSH_ALL, data, buffer_datalen(old), 0);
+ if (ret) {
+ atomic_set(&new->buffer->datalen, 0);
+ atomic_set(&new->dirty, false);
+ return ret;
+ }
+ atomic_set(&old->buffer->datalen, 0);
+ return 0;
+}
+
+static int psz_kmsg_recover_data(struct psz_context *cxt)
+{
+ struct pstore_zone_info *info = cxt->pstore_zone_info;
+ struct pstore_zone *zone = NULL;
+ struct psz_buffer *buf;
+ unsigned long i;
+ ssize_t rcnt;
+
+ if (!info->read)
+ return -EINVAL;
+
+ for (i = 0; i < cxt->kmsg_max_cnt; i++) {
+ zone = cxt->opszs[i];
+ if (unlikely(!zone))
+ return -EINVAL;
+ if (atomic_read(&zone->dirty)) {
+ unsigned int wcnt = cxt->kmsg_write_cnt;
+ struct pstore_zone *new = cxt->opszs[wcnt];
+ int ret;
+
+ ret = psz_move_zone(zone, new);
+ if (ret) {
+ pr_err("move zone from %lu to %d failed\n",
+ i, wcnt);
+ return ret;
+ }
+ cxt->kmsg_write_cnt = (wcnt + 1) % cxt->kmsg_max_cnt;
+ }
+ if (!zone->should_recover)
+ continue;
+ buf = zone->buffer;
+ rcnt = info->read((char *)buf, zone->buffer_size + sizeof(*buf),
+ zone->off);
+ if (rcnt != zone->buffer_size + sizeof(*buf))
+ return (int)rcnt < 0 ? (int)rcnt : -EIO;
+ }
+ return 0;
+}
+
+static int psz_kmsg_recover_meta(struct psz_context *cxt)
+{
+ struct pstore_zone_info *info = cxt->pstore_zone_info;
+ struct pstore_zone *zone;
+ size_t rcnt, len;
+ struct psz_buffer *buf;
+ struct psz_kmsg_header *hdr;
+ struct timespec64 time = { };
+ unsigned long i;
+ /*
+ * Recover may on panic, we can't allocate any memory by kmalloc.
+ * So, we use local array instead.
+ */
+ char buffer_header[sizeof(*buf) + sizeof(*hdr)] = {0};
+
+ if (!info->read)
+ return -EINVAL;
+
+ len = sizeof(*buf) + sizeof(*hdr);
+ buf = (struct psz_buffer *)buffer_header;
+ for (i = 0; i < cxt->kmsg_max_cnt; i++) {
+ zone = cxt->opszs[i];
+ if (unlikely(!zone))
+ return -EINVAL;
+
+ rcnt = info->read((char *)buf, len, zone->off);
+ if (rcnt != len) {
+ pr_err("read %s with id %lu failed\n", zone->name, i);
+ return (int)rcnt < 0 ? (int)rcnt : -EIO;
+ }
+
+ if (buf->sig != zone->buffer->sig) {
+ pr_debug("no valid data in oops zone %lu\n", i);
+ continue;
+ }
+
+ if (zone->buffer_size < atomic_read(&buf->datalen)) {
+ pr_info("found overtop zone: %s: id %lu, off %lld, size %zu\n",
+ zone->name, i, zone->off,
+ zone->buffer_size);
+ continue;
+ }
+
+ hdr = (struct psz_kmsg_header *)buf->data;
+ if (hdr->magic != OOPS_HEADER_MAGIC) {
+ pr_info("found invalid zone: %s: id %lu, off %lld, size %zu\n",
+ zone->name, i, zone->off,
+ zone->buffer_size);
+ continue;
+ }
+
+ /*
+ * we get the newest zone, and the next one must be the oldest
+ * or unused zone, because we do write one by one like a circle.
+ */
+ if (hdr->time.tv_sec >= time.tv_sec) {
+ time.tv_sec = hdr->time.tv_sec;
+ cxt->kmsg_write_cnt = (i + 1) % cxt->kmsg_max_cnt;
+ }
+
+ if (hdr->reason == KMSG_DUMP_OOPS)
+ cxt->oops_counter =
+ max(cxt->oops_counter, hdr->counter);
+ else if (hdr->reason == KMSG_DUMP_PANIC)
+ cxt->panic_counter =
+ max(cxt->panic_counter, hdr->counter);
+
+ if (!atomic_read(&buf->datalen)) {
+ pr_debug("found erased zone: %s: id %lu, off %lld, size %zu, datalen %d\n",
+ zone->name, i, zone->off,
+ zone->buffer_size,
+ atomic_read(&buf->datalen));
+ continue;
+ }
+
+ if (!is_on_panic())
+ zone->should_recover = true;
+ pr_debug("found nice zone: %s: id %lu, off %lld, size %zu, datalen %d\n",
+ zone->name, i, zone->off,
+ zone->buffer_size, atomic_read(&buf->datalen));
+ }
+
+ return 0;
+}
+
+static int psz_kmsg_recover(struct psz_context *cxt)
+{
+ int ret;
+
+ if (!cxt->opszs)
+ return 0;
+
+ ret = psz_kmsg_recover_meta(cxt);
+ if (ret)
+ goto recover_fail;
+
+ ret = psz_kmsg_recover_data(cxt);
+ if (ret)
+ goto recover_fail;
+
+ return 0;
+recover_fail:
+ pr_debug("psz_recover_kmsg failed\n");
+ return ret;
+}
+
+/**
+ * psz_recovery() - recover data from storage
+ * @cxt: the context of pstore/zone
+ *
+ * recovery means reading data back from storage after rebooting
+ *
+ * Return: 0 on success, others on failure.
+ */
+static inline int psz_recovery(struct psz_context *cxt)
+{
+ int ret = -EBUSY;
+
+ if (atomic_read(&cxt->recovered))
+ return 0;
+
+ ret = psz_kmsg_recover(cxt);
+ if (ret)
+ goto recover_fail;
+
+ pr_debug("recover end!\n");
+ atomic_set(&cxt->recovered, 1);
+ return 0;
+
+recover_fail:
+ pr_err("recover failed\n");
+ return ret;
+}
+
+static int psz_pstore_open(struct pstore_info *psi)
+{
+ struct psz_context *cxt = psi->data;
+
+ cxt->kmsg_read_cnt = 0;
+ return 0;
+}
+
+static inline bool psz_ok(struct pstore_zone *zone)
+{
+ if (zone && zone->buffer && buffer_datalen(zone))
+ return true;
+ return false;
+}
+
+static inline int psz_kmsg_erase(struct psz_context *cxt,
+ struct pstore_zone *zone, struct pstore_record *record)
+{
+ struct psz_buffer *buffer = zone->buffer;
+ struct psz_kmsg_header *hdr =
+ (struct psz_kmsg_header *)buffer->data;
+
+ if (unlikely(!psz_ok(zone)))
+ return 0;
+ /* this zone is already updated, no need to erase */
+ if (record->count != hdr->counter)
+ return 0;
+
+ atomic_set(&zone->buffer->datalen, 0);
+ return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
+}
+
+static int psz_pstore_erase(struct pstore_record *record)
+{
+ struct psz_context *cxt = record->psi->data;
+
+ switch (record->type) {
+ case PSTORE_TYPE_DMESG:
+ if (record->id >= cxt->kmsg_max_cnt)
+ return -EINVAL;
+ return psz_kmsg_erase(cxt, cxt->opszs[record->id], record);
+ default:
+ return -EINVAL;
+ }
+}
+
+static void psz_write_kmsg_hdr(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ struct psz_context *cxt = record->psi->data;
+ struct psz_buffer *buffer = zone->buffer;
+ struct psz_kmsg_header *hdr =
+ (struct psz_kmsg_header *)buffer->data;
+
+ hdr->magic = OOPS_HEADER_MAGIC;
+ hdr->compressed = record->compressed;
+ hdr->time.tv_sec = record->time.tv_sec;
+ hdr->time.tv_nsec = record->time.tv_nsec;
+ hdr->reason = record->reason;
+ if (hdr->reason == KMSG_DUMP_OOPS)
+ hdr->counter = ++cxt->oops_counter;
+ else
+ hdr->counter = ++cxt->panic_counter;
+}
+
+static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,
+ struct pstore_record *record)
+{
+ size_t size, hlen;
+ struct pstore_zone *zone;
+ unsigned int zonenum;
+
+ zonenum = cxt->kmsg_write_cnt;
+ zone = cxt->opszs[zonenum];
+ if (unlikely(!zone))
+ return -ENOSPC;
+ cxt->kmsg_write_cnt = (zonenum + 1) % cxt->kmsg_max_cnt;
+
+ pr_debug("write %s to zone id %d\n", zone->name, zonenum);
+ psz_write_kmsg_hdr(zone, record);
+ hlen = sizeof(struct psz_kmsg_header);
+ size = min_t(size_t, record->size, zone->buffer_size - hlen);
+ return psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen);
+}
+
+static int notrace psz_kmsg_write(struct psz_context *cxt,
+ struct pstore_record *record)
+{
+ int ret;
+
+ /*
+ * Explicitly only take the first part of any new crash.
+ * If our buffer is larger than kmsg_bytes, this can never happen,
+ * and if our buffer is smaller than kmsg_bytes, we don't want the
+ * report split across multiple records.
+ */
+ if (record->part != 1)
+ return -ENOSPC;
+
+ if (!cxt->opszs)
+ return -ENOSPC;
+
+ ret = psz_kmsg_write_record(cxt, record);
+ if (!ret) {
+ pr_debug("try to flush other dirty oops zones\n");
+ psz_flush_dirty_zones(cxt->opszs, cxt->kmsg_max_cnt);
+ }
+
+ /* always return 0 as we had handled it on buffer */
+ return 0;
+}
+
+static int notrace psz_pstore_write(struct pstore_record *record)
+{
+ struct psz_context *cxt = record->psi->data;
+
+ if (record->type == PSTORE_TYPE_DMESG &&
+ record->reason == KMSG_DUMP_PANIC)
+ atomic_set(&cxt->on_panic, 1);
+
+ switch (record->type) {
+ case PSTORE_TYPE_DMESG:
+ return psz_kmsg_write(cxt, record);
+ default:
+ return -EINVAL;
+ }
+}
+
+static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
+{
+ struct pstore_zone *zone = NULL;
+
+ while (cxt->kmsg_read_cnt < cxt->kmsg_max_cnt) {
+ zone = cxt->opszs[cxt->kmsg_read_cnt++];
+ if (psz_ok(zone))
+ return zone;
+ }
+
+ return NULL;
+}
+
+static int psz_kmsg_read_hdr(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ struct psz_buffer *buffer = zone->buffer;
+ struct psz_kmsg_header *hdr =
+ (struct psz_kmsg_header *)buffer->data;
+
+ if (hdr->magic != OOPS_HEADER_MAGIC)
+ return -EINVAL;
+ record->compressed = hdr->compressed;
+ record->time.tv_sec = hdr->time.tv_sec;
+ record->time.tv_nsec = hdr->time.tv_nsec;
+ record->reason = hdr->reason;
+ record->count = hdr->counter;
+ return 0;
+}
+
+static ssize_t psz_kmsg_read(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ ssize_t size, hlen = 0;
+
+ size = buffer_datalen(zone);
+ /* Clear and skip this oops record if it has no valid header */
+ if (psz_kmsg_read_hdr(zone, record)) {
+ atomic_set(&zone->buffer->datalen, 0);
+ atomic_set(&zone->dirty, 0);
+ return -ENOMSG;
+ }
+ size -= sizeof(struct psz_kmsg_header);
+
+ if (!record->compressed) {
+ char *buf = kasprintf(GFP_KERNEL, "%s: Total %d times\n",
+ kmsg_dump_reason_str(record->reason),
+ record->count);
+ hlen = strlen(buf);
+ record->buf = krealloc(buf, hlen + size, GFP_KERNEL);
+ if (!record->buf) {
+ kfree(buf);
+ return -ENOMEM;
+ }
+ } else {
+ record->buf = kmalloc(size, GFP_KERNEL);
+ if (!record->buf)
+ return -ENOMEM;
+ }
+
+ size = psz_zone_read(zone, record->buf + hlen, size,
+ sizeof(struct psz_kmsg_header));
+ if (unlikely(size < 0)) {
+ kfree(record->buf);
+ return -ENOMSG;
+ }
+
+ return size + hlen;
+}
+
+static ssize_t psz_pstore_read(struct pstore_record *record)
+{
+ struct psz_context *cxt = record->psi->data;
+ ssize_t (*readop)(struct pstore_zone *zone,
+ struct pstore_record *record);
+ struct pstore_zone *zone;
+ ssize_t ret;
+
+ /* before read, we must recover from storage */
+ ret = psz_recovery(cxt);
+ if (ret)
+ return ret;
+
+next_zone:
+ zone = psz_read_next_zone(cxt);
+ if (!zone)
+ return 0;
+
+ record->type = zone->type;
+ switch (record->type) {
+ case PSTORE_TYPE_DMESG:
+ readop = psz_kmsg_read;
+ record->id = cxt->kmsg_read_cnt - 1;
+ break;
+ default:
+ goto next_zone;
+ }
+
+ ret = readop(zone, record);
+ if (ret == -ENOMSG)
+ goto next_zone;
+ return ret;
+}
+
+static struct psz_context pstore_zone_cxt = {
+ .pstore_zone_info_lock =
+ __MUTEX_INITIALIZER(pstore_zone_cxt.pstore_zone_info_lock),
+ .recovered = ATOMIC_INIT(0),
+ .on_panic = ATOMIC_INIT(0),
+ .pstore = {
+ .owner = THIS_MODULE,
+ .open = psz_pstore_open,
+ .read = psz_pstore_read,
+ .write = psz_pstore_write,
+ .erase = psz_pstore_erase,
+ },
+};
+
+static void psz_free_zone(struct pstore_zone **pszone)
+{
+ struct pstore_zone *zone = *pszone;
+
+ if (!zone)
+ return;
+
+ kfree(zone->buffer);
+ kfree(zone);
+ *pszone = NULL;
+}
+
+static void psz_free_zones(struct pstore_zone ***pszones, unsigned int *cnt)
+{
+ struct pstore_zone **zones = *pszones;
+
+ if (!zones)
+ return;
+
+ while (*cnt > 0) {
+ (*cnt)--;
+ psz_free_zone(&(zones[*cnt]));
+ }
+ kfree(zones);
+ *pszones = NULL;
+}
+
+static void psz_free_all_zones(struct psz_context *cxt)
+{
+ if (cxt->opszs)
+ psz_free_zones(&cxt->opszs, &cxt->kmsg_max_cnt);
+}
+
+static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
+ loff_t *off, size_t size)
+{
+ struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
+ struct pstore_zone *zone;
+ const char *name = pstore_type_to_name(type);
+
+ if (!size)
+ return NULL;
+
+ if (*off + size > info->total_size) {
+ pr_err("no room for %s (0x%zx@0x%llx over 0x%lx)\n",
+ name, size, *off, info->total_size);
+ return ERR_PTR(-ENOMEM);
+ }
+
+ zone = kzalloc(sizeof(struct pstore_zone), GFP_KERNEL);
+ if (!zone)
+ return ERR_PTR(-ENOMEM);
+
+ zone->buffer = kmalloc(size, GFP_KERNEL);
+ if (!zone->buffer) {
+ kfree(zone);
+ return ERR_PTR(-ENOMEM);
+ }
+ memset(zone->buffer, 0xFF, size);
+ zone->off = *off;
+ zone->name = name;
+ zone->type = type;
+ zone->buffer_size = size - sizeof(struct psz_buffer);
+ zone->buffer->sig = type ^ PSZ_SIG;
+ atomic_set(&zone->dirty, 0);
+ atomic_set(&zone->buffer->datalen, 0);
+
+ *off += size;
+
+ pr_debug("pszone %s: off 0x%llx, %zu header, %zu data\n", zone->name,
+ zone->off, sizeof(*zone->buffer), zone->buffer_size);
+ return zone;
+}
+
+static struct pstore_zone **psz_init_zones(enum pstore_type_id type,
+ loff_t *off, size_t total_size, ssize_t record_size,
+ unsigned int *cnt)
+{
+ struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
+ struct pstore_zone **zones, *zone;
+ const char *name = pstore_type_to_name(type);
+ int c, i;
+
+ *cnt = 0;
+ if (!total_size || !record_size)
+ return NULL;
+
+ if (*off + total_size > info->total_size) {
+ pr_err("no room for zones %s (0x%zx@0x%llx over 0x%lx)\n",
+ name, total_size, *off, info->total_size);
+ return ERR_PTR(-ENOMEM);
+ }
+
+ c = total_size / record_size;
+ zones = kcalloc(c, sizeof(*zones), GFP_KERNEL);
+ if (!zones) {
+ pr_err("allocate for zones %s failed\n", name);
+ return ERR_PTR(-ENOMEM);
+ }
+ memset(zones, 0, c * sizeof(*zones));
+
+ for (i = 0; i < c; i++) {
+ zone = psz_init_zone(type, off, record_size);
+ if (!zone || IS_ERR(zone)) {
+ pr_err("initialize zones %s failed\n", name);
+ psz_free_zones(&zones, &i);
+ return (void *)zone;
+ }
+ zones[i] = zone;
+ }
+
+ *cnt = c;
+ return zones;
+}
+
+static int psz_alloc_zones(struct psz_context *cxt)
+{
+ struct pstore_zone_info *info = cxt->pstore_zone_info;
+ loff_t off = 0;
+ int err;
+ size_t size;
+
+ size = info->total_size;
+ cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, size,
+ info->kmsg_size, &cxt->kmsg_max_cnt);
+ if (IS_ERR(cxt->opszs)) {
+ err = PTR_ERR(cxt->opszs);
+ cxt->opszs = NULL;
+ goto fail_out;
+ }
+
+ return 0;
+fail_out:
+ return err;
+}
+
+/**
+ * register_pstore_zone() - register to pstore/zone
+ *
+ * @info: back-end driver information. See &struct pstore_zone_info.
+ *
+ * Only one back-end at one time.
+ *
+ * Return: 0 on success, others on failure.
+ */
+int register_pstore_zone(struct pstore_zone_info *info)
+{
+ int err = -EINVAL;
+ struct psz_context *cxt = &pstore_zone_cxt;
+
+ if (info->total_size < 4096) {
+ pr_warn("total_size must be >= 4096\n");
+ return -EINVAL;
+ }
+
+ if (!info->kmsg_size) {
+ pr_warn("at least one record size must be non-zero\n");
+ return -EINVAL;
+ }
+
+ if (!info->name || !info->name[0])
+ return -EINVAL;
+
+#define check_size(name, size) { \
+ if (info->name > 0 && info->name < (size)) { \
+ pr_err(#name " must be over %d\n", (size)); \
+ return -EINVAL; \
+ } \
+ if (info->name & (size - 1)) { \
+ pr_err(#name " must be a multiple of %d\n", \
+ (size)); \
+ return -EINVAL; \
+ } \
+ }
+
+ check_size(total_size, 4096);
+ check_size(kmsg_size, SECTOR_SIZE);
+
+#undef check_size
+
+ /*
+ * the @read and @write must be applied.
+ * if no @read, pstore may mount failed.
+ * if no @write, pstore do not support to remove record file.
+ */
+ if (!info->read || !info->write) {
+ pr_err("no valid general read/write interface\n");
+ return -EINVAL;
+ }
+
+ mutex_lock(&cxt->pstore_zone_info_lock);
+ if (cxt->pstore_zone_info) {
+ pr_warn("'%s' already loaded: ignoring '%s'\n",
+ cxt->pstore_zone_info->name, info->name);
+ mutex_unlock(&cxt->pstore_zone_info_lock);
+ return -EBUSY;
+ }
+ cxt->pstore_zone_info = info;
+
+ pr_debug("register %s with properties:\n", info->name);
+ pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
+ pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
+
+ err = psz_alloc_zones(cxt);
+ if (err) {
+ pr_err("alloc zones failed\n");
+ goto fail_out;
+ }
+
+ if (info->kmsg_size) {
+ cxt->pstore.bufsize = cxt->opszs[0]->buffer_size -
+ sizeof(struct psz_kmsg_header);
+ cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);
+ if (!cxt->pstore.buf) {
+ err = -ENOMEM;
+ goto fail_free;
+ }
+ }
+ cxt->pstore.data = cxt;
+
+ pr_info("registered %s as backend for", info->name);
+ cxt->pstore.max_reason = info->max_reason;
+ cxt->pstore.name = info->name;
+ if (info->kmsg_size) {
+ cxt->pstore.flags |= PSTORE_FLAGS_DMESG;
+ pr_cont(" kmsg(%s",
+ kmsg_dump_reason_str(cxt->pstore.max_reason));
+ if (cxt->pstore_zone_info->panic_write)
+ pr_cont(",panic_write");
+ pr_cont(")");
+ }
+ pr_cont("\n");
+
+ err = pstore_register(&cxt->pstore);
+ if (err) {
+ pr_err("registering with pstore failed\n");
+ goto fail_free;
+ }
+ mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
+
+ return 0;
+
+fail_free:
+ kfree(cxt->pstore.buf);
+ cxt->pstore.buf = NULL;
+ cxt->pstore.bufsize = 0;
+ psz_free_all_zones(cxt);
+fail_out:
+ pstore_zone_cxt.pstore_zone_info = NULL;
+ mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
+ return err;
+}
+EXPORT_SYMBOL_GPL(register_pstore_zone);
+
+/**
+ * unregister_pstore_zone() - unregister to pstore/zone
+ *
+ * @info: back-end driver information. See struct pstore_zone_info.
+ */
+void unregister_pstore_zone(struct pstore_zone_info *info)
+{
+ struct psz_context *cxt = &pstore_zone_cxt;
+
+ mutex_lock(&cxt->pstore_zone_info_lock);
+ if (!cxt->pstore_zone_info) {
+ mutex_unlock(&cxt->pstore_zone_info_lock);
+ return;
+ }
+
+ /* Stop incoming writes from pstore. */
+ pstore_unregister(&cxt->pstore);
+
+ /* Clean up allocations. */
+ kfree(cxt->pstore.buf);
+ cxt->pstore.buf = NULL;
+ cxt->pstore.bufsize = 0;
+ cxt->pstore_zone_info = NULL;
+
+ psz_free_all_zones(cxt);
+
+ /* Clear counters and zone state. */
+ cxt->oops_counter = 0;
+ cxt->panic_counter = 0;
+ atomic_set(&cxt->recovered, 0);
+ atomic_set(&cxt->on_panic, 0);
+
+ mutex_unlock(&cxt->pstore_zone_info_lock);
+}
+EXPORT_SYMBOL_GPL(unregister_pstore_zone);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
+MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
+MODULE_DESCRIPTION("Storage Manager for pstore/blk");
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
new file mode 100644
index 000000000000..eb005d9ae40c
--- /dev/null
+++ b/include/linux/pstore_zone.h
@@ -0,0 +1,44 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __PSTORE_ZONE_H_
+#define __PSTORE_ZONE_H_
+
+#include <linux/types.h>
+
+typedef ssize_t (*pstore_zone_read_op)(char *, size_t, loff_t);
+typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
+/**
+ * struct pstore_zone_info - pstore/zone back-end driver structure
+ *
+ * @owner: Module which is responsible for this back-end driver.
+ * @name: Name of the back-end driver.
+ * @total_size: The total size in bytes pstore/zone can use. It must be greater
+ * than 4096 and be multiple of 4096.
+ * @kmsg_size: The size of oops/panic zone. Zero means disabled, otherwise,
+ * it must be multiple of SECTOR_SIZE(512 Bytes).
+ * @max_reason: Maximum kmsg dump reason to store.
+ * @read: The general read operation. Both of the function parameters
+ * @size and @offset are relative value to storage.
+ * On success, the number of bytes should be returned, others
+ * means error.
+ * @write: The same as @read.
+ * @panic_write:The write operation only used for panic case. It's optional
+ * if you do not care panic log. The parameters and return value
+ * are the same as @read.
+ */
+struct pstore_zone_info {
+ struct module *owner;
+ const char *name;
+
+ unsigned long total_size;
+ unsigned long kmsg_size;
+ int max_reason;
+ pstore_zone_read_op read;
+ pstore_zone_write_op write;
+ pstore_zone_write_op panic_write;
+};
+
+extern int register_pstore_zone(struct pstore_zone_info *info);
+extern void unregister_pstore_zone(struct pstore_zone_info *info);
+
+#endif
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones
2020-05-10 20:24 ` [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones Kees Cook
@ 2020-05-11 8:36 ` WeiXiong Liao
2020-05-11 23:02 ` Kees Cook
0 siblings, 1 reply; 37+ messages in thread
From: WeiXiong Liao @ 2020-05-11 8:36 UTC (permalink / raw)
To: Kees Cook
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
hi Kees Cook,
On 2020/5/11 AM 4:24, Kees Cook wrote:
> From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
>
> Implement a common set of APIs needed to support pstore storage zones,
> based on how ramoops is designed. This will be used by pstore/blk with
> the intention of migrating pstore/ram in the future.
>
> Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
> Link: https://lore.kernel.org/r/1585126506-18635-2-git-send-email-liaoweixiong@allwinnertech.com
> Co-developed-by: Kees Cook <keescook@chromium.org>
> Signed-off-by: Kees Cook <keescook@chromium.org>
> ---
> fs/pstore/Kconfig | 7 +
> fs/pstore/Makefile | 3 +
> fs/pstore/zone.c | 985 ++++++++++++++++++++++++++++++++++++
> include/linux/pstore_zone.h | 44 ++
> 4 files changed, 1039 insertions(+)
> create mode 100644 fs/pstore/zone.c
> create mode 100644 include/linux/pstore_zone.h
>
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index 8f0369aad22a..98d2457bdd9f 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -153,3 +153,10 @@ config PSTORE_RAM
> "ramoops.ko".
>
> For more information, see Documentation/admin-guide/ramoops.rst.
> +
> +config PSTORE_ZONE
> + tristate
> + depends on PSTORE
> + help
> + The common layer for pstore/blk (and pstore/ram in the future)
> + to manage storage in zones.
> diff --git a/fs/pstore/Makefile b/fs/pstore/Makefile
> index 967b5891f325..58a967cbe4af 100644
> --- a/fs/pstore/Makefile
> +++ b/fs/pstore/Makefile
> @@ -12,3 +12,6 @@ pstore-$(CONFIG_PSTORE_PMSG) += pmsg.o
>
> ramoops-objs += ram.o ram_core.o
> obj-$(CONFIG_PSTORE_RAM) += ramoops.o
> +
> +pstore_zone-objs += zone.o
> +obj-$(CONFIG_PSTORE_ZONE) += pstore_zone.o
> diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
> new file mode 100644
> index 000000000000..a388c299ebb1
> --- /dev/null
> +++ b/fs/pstore/zone.c
> @@ -0,0 +1,985 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Provide a pstore intermediate backend, organized into kernel memory
> + * allocated zones that are then mapped and flushed into a single
> + * contiguous region on a storage backend of some kind (block, mtd, etc).
> + */
> +
> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/mount.h>
> +#include <linux/printk.h>
> +#include <linux/fs.h>
> +#include <linux/pstore_zone.h>
> +#include <linux/kdev_t.h>
> +#include <linux/device.h>
> +#include <linux/namei.h>
> +#include <linux/fcntl.h>
> +#include <linux/uio.h>
> +#include <linux/writeback.h>
> +#include "internal.h"
> +
> +/**
> + * struct psz_head - header of zone to flush to storage
> + *
> + * @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value)
> + * @datalen: length of data in @data
> + * @data: zone data.
> + */
> +struct psz_buffer {
> +#define PSZ_SIG (0x43474244) /* DBGC */
> + uint32_t sig;
> + atomic_t datalen;
> + uint8_t data[];
> +};
> +
> +/**
> + * struct psz_kmsg_header - kmsg dump-specific header to flush to storage
> + *
> + * @magic: magic num for oops header
> + * @time: oops/panic trigger time
> + * @compressed: whether conpressed
> + * @counter: oops/panic counter
> + * @reason: identify oops or panic
> + * @data: pointer to log data
> + *
The above comment should be corrected since it is not only oops/panic
any more.
> + * This is a sub-header for a kmsg dump, trailing after &psz_buffer.
> + */
> +struct psz_kmsg_header {
> +#define OOPS_HEADER_MAGIC 0x4dfc3ae5 /* Just a random number */
I think 'OOPS_*' is confused, how about "KMSG_*" ?
> + uint32_t magic;
> + struct timespec64 time;
> + bool compressed;
> + uint32_t counter;
> + enum kmsg_dump_reason reason;
> + uint8_t data[];
> +};
> +
> +/**
> + * struct pstore_zone - single stored buffer
> + *
> + * @off: zone offset of storage
> + * @type: front-end type for this zone
> + * @name: front-end name for this zone
> + * @buffer: pointer to data buffer managed by this zone
> + * @oldbuf: pointer to old data buffer
> + * @buffer_size: bytes in @buffer->data
> + * @should_recover: whether this zone should recover from storage
> + * @dirty: whether the data in @buffer dirty
> + *
> + * zone structure in memory.
> + */
> +struct pstore_zone {
> + loff_t off;
> + const char *name;
> + enum pstore_type_id type;
> +
> + struct psz_buffer *buffer;
> + struct psz_buffer *oldbuf;
> + size_t buffer_size;
> + bool should_recover;
> + atomic_t dirty;
> +};
> +
> +/**
> + * struct psz_context - all about running state of pstore/zone
> + *
> + * @opszs: oops/panic storage zones
This comment should also be currented.
> + * @kmsg_max_cnt: max count of @opszs
> + * @kmsg_read_cnt: counter to read oops zone
> + * @kmsg_write_cnt: counter to write
> + * @oops_counter: counter to oops
> + * @panic_counter: counter to panic
> + * @recovered: whether finish recovering data from storage
> + * @on_panic: whether occur panic
> + * @pstore_zone_info_lock: lock to @pstore_zone_info
> + * @pstore_zone_info: information from back-end
> + * @pstore: structure for pstore
> + */
> +struct psz_context {
> + struct pstore_zone **opszs;
"opszs" is confused, I think it should be "kpszs".
> + unsigned int kmsg_max_cnt;
> + unsigned int kmsg_read_cnt;
> + unsigned int kmsg_write_cnt;
> + /*
> + * the counter should be recovered when recover.
> + * It records the oops/panic times after burning rather than booting.
> + */
> + unsigned int oops_counter;
> + unsigned int panic_counter;
> + atomic_t recovered;
> + atomic_t on_panic;
> +
> + /*
> + * pstore_zone_info_lock protects this entire structure during calls
> + * to register_pstore_zone()/unregister_pstore_zone().
> + */
> + struct mutex pstore_zone_info_lock;
> + struct pstore_zone_info *pstore_zone_info;
> + struct pstore_info pstore;
> +};
> +static struct psz_context pstore_zone_cxt;
> +
> +/**
> + * enum psz_flush_mode - flush mode for psz_zone_write()
> + *
> + * @FLUSH_NONE: do not flush to storage but update data on memory
> + * @FLUSH_PART: just flush part of data including meta data to storage
> + * @FLUSH_META: just flush meta data of zone to storage
> + * @FLUSH_ALL: flush all of zone
> + */
> +enum psz_flush_mode {
> + FLUSH_NONE = 0,
> + FLUSH_PART,
> + FLUSH_META,
> + FLUSH_ALL,
> +};
> +
> +static inline int buffer_datalen(struct pstore_zone *zone)
> +{
> + return atomic_read(&zone->buffer->datalen);
> +}
> +
> +static inline bool is_on_panic(void)
> +{
> + return atomic_read(&pstore_zone_cxt.on_panic);
> +}
> +
> +static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
> + size_t len, unsigned long off)
> +{
> + if (!buf || !zone->buffer)
> + return -EINVAL;
> + if (off > zone->buffer_size)
> + return -EINVAL;
> + len = min_t(size_t, len, zone->buffer_size - off);
> + memcpy(buf, zone->buffer->data + off, len);
> + return len;
> +}
> +
> +static int psz_zone_write(struct pstore_zone *zone,
> + enum psz_flush_mode flush_mode, const char *buf,
> + size_t len, unsigned long off)
> +{
> + struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
> + ssize_t wcnt = 0;
> + ssize_t (*writeop)(const char *buf, size_t bytes, loff_t pos);
> + size_t wlen;
> +
> + if (off > zone->buffer_size)
> + return -EINVAL;
> +
> + wlen = min_t(size_t, len, zone->buffer_size - off);
> + if (buf && wlen) {
> + memcpy(zone->buffer->data + off, buf, wlen);
> + atomic_set(&zone->buffer->datalen, wlen + off);
> + }
> +
> + /* avoid to damage old records */
> + if (!is_on_panic() && !atomic_read(&pstore_zone_cxt.recovered))
> + goto dirty;
> +
> + writeop = is_on_panic() ? info->panic_write : info->write;
> + if (!writeop)
> + goto dirty;
> +
> + switch (flush_mode) {
> + case FLUSH_NONE:
> + if (unlikely(buf && wlen))
> + goto dirty;
> + return 0;
> + case FLUSH_PART:
> + wcnt = writeop((const char *)zone->buffer->data + off, wlen,
> + zone->off + sizeof(*zone->buffer) + off);
> + if (wcnt != wlen)
> + goto dirty;
> + fallthrough;
> + case FLUSH_META:
> + wlen = sizeof(struct psz_buffer);
> + wcnt = writeop((const char *)zone->buffer, wlen, zone->off);
> + if (wcnt != wlen)
> + goto dirty;
> + break;
> + case FLUSH_ALL:
> + wlen = zone->buffer_size + sizeof(*zone->buffer);
> + wcnt = writeop((const char *)zone->buffer, wlen, zone->off);
> + if (wcnt != wlen)
> + goto dirty;
> + break;
> + }
> +
> + return 0;
> +dirty:
> + atomic_set(&zone->dirty, true);
> + return -EBUSY;
> +}
> +
> +static int psz_flush_dirty_zone(struct pstore_zone *zone)
> +{
> + int ret;
> +
> + if (unlikely(!zone))
> + return -EINVAL;
> +
> + if (unlikely(!atomic_read(&pstore_zone_cxt.recovered)))
> + return -EBUSY;
> +
> + if (!atomic_xchg(&zone->dirty, false))
> + return 0;
> +
> + ret = psz_zone_write(zone, FLUSH_ALL, NULL, 0, 0);
> + if (ret)
> + atomic_set(&zone->dirty, true);
> + return ret;
> +}
> +
> +static int psz_flush_dirty_zones(struct pstore_zone **zones, unsigned int cnt)
> +{
> + int i, ret;
> + struct pstore_zone *zone;
> +
> + if (!zones)
> + return -EINVAL;
> +
> + for (i = 0; i < cnt; i++) {
> + zone = zones[i];
> + if (!zone)
> + return -EINVAL;
> + ret = psz_flush_dirty_zone(zone);
> + if (ret)
> + return ret;
> + }
> + return 0;
> +}
> +
> +static int psz_move_zone(struct pstore_zone *old, struct pstore_zone *new)
> +{
> + const char *data = (const char *)old->buffer->data;
> + int ret;
> +
> + ret = psz_zone_write(new, FLUSH_ALL, data, buffer_datalen(old), 0);
> + if (ret) {
> + atomic_set(&new->buffer->datalen, 0);
> + atomic_set(&new->dirty, false);
> + return ret;
> + }
> + atomic_set(&old->buffer->datalen, 0);
> + return 0;
> +}
> +
> +static int psz_kmsg_recover_data(struct psz_context *cxt)
> +{
> + struct pstore_zone_info *info = cxt->pstore_zone_info;
> + struct pstore_zone *zone = NULL;
> + struct psz_buffer *buf;
> + unsigned long i;
> + ssize_t rcnt;
> +
> + if (!info->read)
> + return -EINVAL;
> +
> + for (i = 0; i < cxt->kmsg_max_cnt; i++) {
> + zone = cxt->opszs[i];
> + if (unlikely(!zone))
> + return -EINVAL;
> + if (atomic_read(&zone->dirty)) {
> + unsigned int wcnt = cxt->kmsg_write_cnt;
> + struct pstore_zone *new = cxt->opszs[wcnt];
> + int ret;
> +
> + ret = psz_move_zone(zone, new);
> + if (ret) {
> + pr_err("move zone from %lu to %d failed\n",
> + i, wcnt);
> + return ret;
> + }
> + cxt->kmsg_write_cnt = (wcnt + 1) % cxt->kmsg_max_cnt;
> + }
> + if (!zone->should_recover)
> + continue;
> + buf = zone->buffer;
> + rcnt = info->read((char *)buf, zone->buffer_size + sizeof(*buf),
> + zone->off);
> + if (rcnt != zone->buffer_size + sizeof(*buf))
> + return (int)rcnt < 0 ? (int)rcnt : -EIO;
> + }
> + return 0;
> +}
> +
> +static int psz_kmsg_recover_meta(struct psz_context *cxt)
> +{
> + struct pstore_zone_info *info = cxt->pstore_zone_info;
> + struct pstore_zone *zone;
> + size_t rcnt, len;
> + struct psz_buffer *buf;
> + struct psz_kmsg_header *hdr;
> + struct timespec64 time = { };
> + unsigned long i;
> + /*
> + * Recover may on panic, we can't allocate any memory by kmalloc.
> + * So, we use local array instead.
> + */
> + char buffer_header[sizeof(*buf) + sizeof(*hdr)] = {0};
> +
> + if (!info->read)
> + return -EINVAL;
> +
> + len = sizeof(*buf) + sizeof(*hdr);
> + buf = (struct psz_buffer *)buffer_header;
> + for (i = 0; i < cxt->kmsg_max_cnt; i++) {
> + zone = cxt->opszs[i];
> + if (unlikely(!zone))
> + return -EINVAL;
> +
> + rcnt = info->read((char *)buf, len, zone->off);
> + if (rcnt != len) {
> + pr_err("read %s with id %lu failed\n", zone->name, i);
> + return (int)rcnt < 0 ? (int)rcnt : -EIO;
> + }
> +
> + if (buf->sig != zone->buffer->sig) {
> + pr_debug("no valid data in oops zone %lu\n", i);
Also here.
> + continue;
> + }
> +
> + if (zone->buffer_size < atomic_read(&buf->datalen)) {
> + pr_info("found overtop zone: %s: id %lu, off %lld, size %zu\n",
> + zone->name, i, zone->off,
> + zone->buffer_size);
> + continue;
> + }
> +
> + hdr = (struct psz_kmsg_header *)buf->data;
> + if (hdr->magic != OOPS_HEADER_MAGIC) {
> + pr_info("found invalid zone: %s: id %lu, off %lld, size %zu\n",
> + zone->name, i, zone->off,
> + zone->buffer_size);
> + continue;
> + }
> +
> + /*
> + * we get the newest zone, and the next one must be the oldest
> + * or unused zone, because we do write one by one like a circle.
> + */
> + if (hdr->time.tv_sec >= time.tv_sec) {
> + time.tv_sec = hdr->time.tv_sec;
> + cxt->kmsg_write_cnt = (i + 1) % cxt->kmsg_max_cnt;
> + }
> +
> + if (hdr->reason == KMSG_DUMP_OOPS)
> + cxt->oops_counter =
> + max(cxt->oops_counter, hdr->counter);
> + else if (hdr->reason == KMSG_DUMP_PANIC)
> + cxt->panic_counter =
> + max(cxt->panic_counter, hdr->counter);
> +
> + if (!atomic_read(&buf->datalen)) {
> + pr_debug("found erased zone: %s: id %lu, off %lld, size %zu, datalen %d\n",
> + zone->name, i, zone->off,
> + zone->buffer_size,
> + atomic_read(&buf->datalen));
> + continue;
> + }
> +
> + if (!is_on_panic())
> + zone->should_recover = true;
> + pr_debug("found nice zone: %s: id %lu, off %lld, size %zu, datalen %d\n",
> + zone->name, i, zone->off,
> + zone->buffer_size, atomic_read(&buf->datalen));
> + }
> +
> + return 0;
> +}
> +
> +static int psz_kmsg_recover(struct psz_context *cxt)
> +{
> + int ret;
> +
> + if (!cxt->opszs)
> + return 0;
> +
> + ret = psz_kmsg_recover_meta(cxt);
> + if (ret)
> + goto recover_fail;
> +
> + ret = psz_kmsg_recover_data(cxt);
> + if (ret)
> + goto recover_fail;
> +
> + return 0;
> +recover_fail:
> + pr_debug("psz_recover_kmsg failed\n");
> + return ret;
> +}
> +
> +/**
> + * psz_recovery() - recover data from storage
> + * @cxt: the context of pstore/zone
> + *
> + * recovery means reading data back from storage after rebooting
> + *
> + * Return: 0 on success, others on failure.
> + */
> +static inline int psz_recovery(struct psz_context *cxt)
> +{
> + int ret = -EBUSY;
> +
> + if (atomic_read(&cxt->recovered))
> + return 0;
> +
> + ret = psz_kmsg_recover(cxt);
> + if (ret)
> + goto recover_fail;
> +
> + pr_debug("recover end!\n");
> + atomic_set(&cxt->recovered, 1);
> + return 0;
> +
> +recover_fail:
> + pr_err("recover failed\n");
> + return ret;
> +}
> +
> +static int psz_pstore_open(struct pstore_info *psi)
> +{
> + struct psz_context *cxt = psi->data;
> +
> + cxt->kmsg_read_cnt = 0;
> + return 0;
> +}
> +
> +static inline bool psz_ok(struct pstore_zone *zone)
> +{
> + if (zone && zone->buffer && buffer_datalen(zone))
> + return true;
> + return false;
> +}
> +
> +static inline int psz_kmsg_erase(struct psz_context *cxt,
> + struct pstore_zone *zone, struct pstore_record *record)
> +{
> + struct psz_buffer *buffer = zone->buffer;
> + struct psz_kmsg_header *hdr =
> + (struct psz_kmsg_header *)buffer->data;
> +
> + if (unlikely(!psz_ok(zone)))
> + return 0;
> + /* this zone is already updated, no need to erase */
> + if (record->count != hdr->counter)
> + return 0;
> +
> + atomic_set(&zone->buffer->datalen, 0);
> + return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
> +}
> +
> +static int psz_pstore_erase(struct pstore_record *record)
> +{
> + struct psz_context *cxt = record->psi->data;
> +
> + switch (record->type) {
> + case PSTORE_TYPE_DMESG:
> + if (record->id >= cxt->kmsg_max_cnt)
> + return -EINVAL;
> + return psz_kmsg_erase(cxt, cxt->opszs[record->id], record);
> + default:
> + return -EINVAL;
> + }
> +}
> +
> +static void psz_write_kmsg_hdr(struct pstore_zone *zone,
> + struct pstore_record *record)
> +{
> + struct psz_context *cxt = record->psi->data;
> + struct psz_buffer *buffer = zone->buffer;
> + struct psz_kmsg_header *hdr =
> + (struct psz_kmsg_header *)buffer->data;
> +
> + hdr->magic = OOPS_HEADER_MAGIC;
> + hdr->compressed = record->compressed;
> + hdr->time.tv_sec = record->time.tv_sec;
> + hdr->time.tv_nsec = record->time.tv_nsec;
> + hdr->reason = record->reason;
> + if (hdr->reason == KMSG_DUMP_OOPS)
> + hdr->counter = ++cxt->oops_counter;
> + else
> + hdr->counter = ++cxt->panic_counter;
Here should be:
if (hdr->reason == KMSG_DUMP_OOPS)
hdr->counter = ++cxt->oops_counter;
else if (hdr->reason == KMSG_DUMP_PANIC)
hdr->counter = ++cxt->panic_counter;
else
hdr->counter = 0;
> +}
> +
> +static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,
> + struct pstore_record *record)
> +{
> + size_t size, hlen;
> + struct pstore_zone *zone;
> + unsigned int zonenum;
> +
> + zonenum = cxt->kmsg_write_cnt;
> + zone = cxt->opszs[zonenum];
> + if (unlikely(!zone))
> + return -ENOSPC;
> + cxt->kmsg_write_cnt = (zonenum + 1) % cxt->kmsg_max_cnt;
> +
> + pr_debug("write %s to zone id %d\n", zone->name, zonenum);
> + psz_write_kmsg_hdr(zone, record);
> + hlen = sizeof(struct psz_kmsg_header);
> + size = min_t(size_t, record->size, zone->buffer_size - hlen);
> + return psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen);
> +}
> +
> +static int notrace psz_kmsg_write(struct psz_context *cxt,
> + struct pstore_record *record)
> +{
> + int ret;
> +
> + /*
> + * Explicitly only take the first part of any new crash.
> + * If our buffer is larger than kmsg_bytes, this can never happen,
> + * and if our buffer is smaller than kmsg_bytes, we don't want the
> + * report split across multiple records.
> + */
> + if (record->part != 1)
> + return -ENOSPC;
> +
> + if (!cxt->opszs)
> + return -ENOSPC;
> +
> + ret = psz_kmsg_write_record(cxt, record);
> + if (!ret) {
> + pr_debug("try to flush other dirty oops zones\n");
Also here.
> + psz_flush_dirty_zones(cxt->opszs, cxt->kmsg_max_cnt);
> + }
> +
> + /* always return 0 as we had handled it on buffer */
> + return 0;
> +}
> +
> +static int notrace psz_pstore_write(struct pstore_record *record)
> +{
> + struct psz_context *cxt = record->psi->data;
> +
> + if (record->type == PSTORE_TYPE_DMESG &&
> + record->reason == KMSG_DUMP_PANIC)
> + atomic_set(&cxt->on_panic, 1);
> +
> + switch (record->type) {
> + case PSTORE_TYPE_DMESG:
> + return psz_kmsg_write(cxt, record);
> + default:
> + return -EINVAL;
> + }
> +}
> +
> +static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
> +{
> + struct pstore_zone *zone = NULL;
> +
> + while (cxt->kmsg_read_cnt < cxt->kmsg_max_cnt) {
> + zone = cxt->opszs[cxt->kmsg_read_cnt++];
> + if (psz_ok(zone))
> + return zone;
> + }
> +
> + return NULL;
> +}
> +
> +static int psz_kmsg_read_hdr(struct pstore_zone *zone,
> + struct pstore_record *record)
> +{
> + struct psz_buffer *buffer = zone->buffer;
> + struct psz_kmsg_header *hdr =
> + (struct psz_kmsg_header *)buffer->data;
> +
> + if (hdr->magic != OOPS_HEADER_MAGIC)
> + return -EINVAL;
> + record->compressed = hdr->compressed;
> + record->time.tv_sec = hdr->time.tv_sec;
> + record->time.tv_nsec = hdr->time.tv_nsec;
> + record->reason = hdr->reason;
> + record->count = hdr->counter;
> + return 0;
> +}
> +
> +static ssize_t psz_kmsg_read(struct pstore_zone *zone,
> + struct pstore_record *record)
> +{
> + ssize_t size, hlen = 0;
> +
> + size = buffer_datalen(zone);
> + /* Clear and skip this oops record if it has no valid header */
Also here.
> + if (psz_kmsg_read_hdr(zone, record)) {
> + atomic_set(&zone->buffer->datalen, 0);
> + atomic_set(&zone->dirty, 0);
> + return -ENOMSG;
> + }
> + size -= sizeof(struct psz_kmsg_header);
> +
> + if (!record->compressed) {
> + char *buf = kasprintf(GFP_KERNEL, "%s: Total %d times\n",
> + kmsg_dump_reason_str(record->reason),
> + record->count);
> + hlen = strlen(buf);
> + record->buf = krealloc(buf, hlen + size, GFP_KERNEL);
> + if (!record->buf) {
> + kfree(buf);
> + return -ENOMEM;
> + }
> + } else {
> + record->buf = kmalloc(size, GFP_KERNEL);
> + if (!record->buf)
> + return -ENOMEM;
> + }
> +
> + size = psz_zone_read(zone, record->buf + hlen, size,
> + sizeof(struct psz_kmsg_header));
> + if (unlikely(size < 0)) {
> + kfree(record->buf);
> + return -ENOMSG;
> + }
> +
> + return size + hlen;
> +}
> +
> +static ssize_t psz_pstore_read(struct pstore_record *record)
> +{
> + struct psz_context *cxt = record->psi->data;
> + ssize_t (*readop)(struct pstore_zone *zone,
> + struct pstore_record *record);
> + struct pstore_zone *zone;
> + ssize_t ret;
> +
> + /* before read, we must recover from storage */
> + ret = psz_recovery(cxt);
> + if (ret)
> + return ret;
> +
> +next_zone:
> + zone = psz_read_next_zone(cxt);
> + if (!zone)
> + return 0;
> +
> + record->type = zone->type;
> + switch (record->type) {
> + case PSTORE_TYPE_DMESG:
> + readop = psz_kmsg_read;
> + record->id = cxt->kmsg_read_cnt - 1;
> + break;
> + default:
> + goto next_zone;
> + }
> +
> + ret = readop(zone, record);
> + if (ret == -ENOMSG)
> + goto next_zone;
> + return ret;
> +}
> +
> +static struct psz_context pstore_zone_cxt = {
> + .pstore_zone_info_lock =
> + __MUTEX_INITIALIZER(pstore_zone_cxt.pstore_zone_info_lock),
> + .recovered = ATOMIC_INIT(0),
> + .on_panic = ATOMIC_INIT(0),
> + .pstore = {
> + .owner = THIS_MODULE,
> + .open = psz_pstore_open,
> + .read = psz_pstore_read,
> + .write = psz_pstore_write,
> + .erase = psz_pstore_erase,
> + },
> +};
> +
> +static void psz_free_zone(struct pstore_zone **pszone)
> +{
> + struct pstore_zone *zone = *pszone;
> +
> + if (!zone)
> + return;
> +
> + kfree(zone->buffer);
> + kfree(zone);
> + *pszone = NULL;
> +}
> +
> +static void psz_free_zones(struct pstore_zone ***pszones, unsigned int *cnt)
> +{
> + struct pstore_zone **zones = *pszones;
> +
> + if (!zones)
> + return;
> +
> + while (*cnt > 0) {
> + (*cnt)--;
> + psz_free_zone(&(zones[*cnt]));
> + }
> + kfree(zones);
> + *pszones = NULL;
> +}
> +
> +static void psz_free_all_zones(struct psz_context *cxt)
> +{
> + if (cxt->opszs)
> + psz_free_zones(&cxt->opszs, &cxt->kmsg_max_cnt);
> +}
> +
> +static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
> + loff_t *off, size_t size)
> +{
> + struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
> + struct pstore_zone *zone;
> + const char *name = pstore_type_to_name(type);
> +
> + if (!size)
> + return NULL;
> +
> + if (*off + size > info->total_size) {
> + pr_err("no room for %s (0x%zx@0x%llx over 0x%lx)\n",
> + name, size, *off, info->total_size);
> + return ERR_PTR(-ENOMEM);
> + }
> +
> + zone = kzalloc(sizeof(struct pstore_zone), GFP_KERNEL);
> + if (!zone)
> + return ERR_PTR(-ENOMEM);
> +
> + zone->buffer = kmalloc(size, GFP_KERNEL);
> + if (!zone->buffer) {
> + kfree(zone);
> + return ERR_PTR(-ENOMEM);
> + }
> + memset(zone->buffer, 0xFF, size);
> + zone->off = *off;
> + zone->name = name;
> + zone->type = type;
> + zone->buffer_size = size - sizeof(struct psz_buffer);
> + zone->buffer->sig = type ^ PSZ_SIG;
> + atomic_set(&zone->dirty, 0);
> + atomic_set(&zone->buffer->datalen, 0);
> +
> + *off += size;
> +
> + pr_debug("pszone %s: off 0x%llx, %zu header, %zu data\n", zone->name,
> + zone->off, sizeof(*zone->buffer), zone->buffer_size);
> + return zone;
> +}
> +
> +static struct pstore_zone **psz_init_zones(enum pstore_type_id type,
> + loff_t *off, size_t total_size, ssize_t record_size,
> + unsigned int *cnt)
> +{
> + struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info;
> + struct pstore_zone **zones, *zone;
> + const char *name = pstore_type_to_name(type);
> + int c, i;
> +
> + *cnt = 0;
> + if (!total_size || !record_size)
> + return NULL;
> +
> + if (*off + total_size > info->total_size) {
> + pr_err("no room for zones %s (0x%zx@0x%llx over 0x%lx)\n",
> + name, total_size, *off, info->total_size);
> + return ERR_PTR(-ENOMEM);
> + }
> +
> + c = total_size / record_size;
> + zones = kcalloc(c, sizeof(*zones), GFP_KERNEL);
> + if (!zones) {
> + pr_err("allocate for zones %s failed\n", name);
> + return ERR_PTR(-ENOMEM);
> + }
> + memset(zones, 0, c * sizeof(*zones));
> +
> + for (i = 0; i < c; i++) {
> + zone = psz_init_zone(type, off, record_size);
> + if (!zone || IS_ERR(zone)) {
> + pr_err("initialize zones %s failed\n", name);
> + psz_free_zones(&zones, &i);
> + return (void *)zone;
> + }
> + zones[i] = zone;
> + }
> +
> + *cnt = c;
> + return zones;
> +}
> +
> +static int psz_alloc_zones(struct psz_context *cxt)
> +{
> + struct pstore_zone_info *info = cxt->pstore_zone_info;
> + loff_t off = 0;
> + int err;
> + size_t size;
> +
> + size = info->total_size;
> + cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, size,
> + info->kmsg_size, &cxt->kmsg_max_cnt);
> + if (IS_ERR(cxt->opszs)) {
> + err = PTR_ERR(cxt->opszs);
> + cxt->opszs = NULL;
> + goto fail_out;
> + }
> +
> + return 0;
> +fail_out:
> + return err;
> +}
> +
> +/**
> + * register_pstore_zone() - register to pstore/zone
> + *
> + * @info: back-end driver information. See &struct pstore_zone_info.
> + *
> + * Only one back-end at one time.
> + *
> + * Return: 0 on success, others on failure.
> + */
> +int register_pstore_zone(struct pstore_zone_info *info)
> +{
> + int err = -EINVAL;
> + struct psz_context *cxt = &pstore_zone_cxt;
> +
> + if (info->total_size < 4096) {
> + pr_warn("total_size must be >= 4096\n");
> + return -EINVAL;
> + }
> +
> + if (!info->kmsg_size) {
> + pr_warn("at least one record size must be non-zero\n");
> + return -EINVAL;
> + }
> +
> + if (!info->name || !info->name[0])
> + return -EINVAL;
> +
> +#define check_size(name, size) { \
> + if (info->name > 0 && info->name < (size)) { \
> + pr_err(#name " must be over %d\n", (size)); \
> + return -EINVAL; \
> + } \
> + if (info->name & (size - 1)) { \
> + pr_err(#name " must be a multiple of %d\n", \
> + (size)); \
> + return -EINVAL; \
> + } \
> + }
> +
> + check_size(total_size, 4096);
> + check_size(kmsg_size, SECTOR_SIZE);
> +
> +#undef check_size
> +
> + /*
> + * the @read and @write must be applied.
> + * if no @read, pstore may mount failed.
> + * if no @write, pstore do not support to remove record file.
> + */
> + if (!info->read || !info->write) {
> + pr_err("no valid general read/write interface\n");
> + return -EINVAL;
> + }
> +
> + mutex_lock(&cxt->pstore_zone_info_lock);
> + if (cxt->pstore_zone_info) {
> + pr_warn("'%s' already loaded: ignoring '%s'\n",
> + cxt->pstore_zone_info->name, info->name);
> + mutex_unlock(&cxt->pstore_zone_info_lock);
> + return -EBUSY;
> + }
> + cxt->pstore_zone_info = info;
> +
> + pr_debug("register %s with properties:\n", info->name);
> + pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
> + pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
> +
> + err = psz_alloc_zones(cxt);
> + if (err) {
> + pr_err("alloc zones failed\n");
> + goto fail_out;
> + }
> +
> + if (info->kmsg_size) {
> + cxt->pstore.bufsize = cxt->opszs[0]->buffer_size -
> + sizeof(struct psz_kmsg_header);
> + cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);
> + if (!cxt->pstore.buf) {
> + err = -ENOMEM;
> + goto fail_free;
> + }
> + }
> + cxt->pstore.data = cxt;
> +
> + pr_info("registered %s as backend for", info->name);
> + cxt->pstore.max_reason = info->max_reason;
> + cxt->pstore.name = info->name;
> + if (info->kmsg_size) {
> + cxt->pstore.flags |= PSTORE_FLAGS_DMESG;
> + pr_cont(" kmsg(%s",
> + kmsg_dump_reason_str(cxt->pstore.max_reason));
> + if (cxt->pstore_zone_info->panic_write)
> + pr_cont(",panic_write");
> + pr_cont(")");
> + }
> + pr_cont("\n");
> +
> + err = pstore_register(&cxt->pstore);
> + if (err) {
> + pr_err("registering with pstore failed\n");
> + goto fail_free;
> + }
> + mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
> +
> + return 0;
> +
> +fail_free:
> + kfree(cxt->pstore.buf);
> + cxt->pstore.buf = NULL;
> + cxt->pstore.bufsize = 0;
> + psz_free_all_zones(cxt);
> +fail_out:
> + pstore_zone_cxt.pstore_zone_info = NULL;
> + mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
> + return err;
> +}
> +EXPORT_SYMBOL_GPL(register_pstore_zone);
> +
> +/**
> + * unregister_pstore_zone() - unregister to pstore/zone
> + *
> + * @info: back-end driver information. See struct pstore_zone_info.
> + */
> +void unregister_pstore_zone(struct pstore_zone_info *info)
> +{
> + struct psz_context *cxt = &pstore_zone_cxt;
> +
> + mutex_lock(&cxt->pstore_zone_info_lock);
> + if (!cxt->pstore_zone_info) {
> + mutex_unlock(&cxt->pstore_zone_info_lock);
> + return;
> + }
> +
> + /* Stop incoming writes from pstore. */
> + pstore_unregister(&cxt->pstore);
> +
> + /* Clean up allocations. */
> + kfree(cxt->pstore.buf);
> + cxt->pstore.buf = NULL;
> + cxt->pstore.bufsize = 0;
> + cxt->pstore_zone_info = NULL;
> +
> + psz_free_all_zones(cxt);
> +
> + /* Clear counters and zone state. */
> + cxt->oops_counter = 0;
> + cxt->panic_counter = 0;
> + atomic_set(&cxt->recovered, 0);
> + atomic_set(&cxt->on_panic, 0);
> +
> + mutex_unlock(&cxt->pstore_zone_info_lock);
> +}
> +EXPORT_SYMBOL_GPL(unregister_pstore_zone);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
> +MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
> +MODULE_DESCRIPTION("Storage Manager for pstore/blk");
Maybe we should correct the module description since it's not only for
psotre/blk?
> diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
> new file mode 100644
> index 000000000000..eb005d9ae40c
> --- /dev/null
> +++ b/include/linux/pstore_zone.h
> @@ -0,0 +1,44 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +
> +#ifndef __PSTORE_ZONE_H_
> +#define __PSTORE_ZONE_H_
> +
> +#include <linux/types.h>
> +
> +typedef ssize_t (*pstore_zone_read_op)(char *, size_t, loff_t);
> +typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
> +/**
> + * struct pstore_zone_info - pstore/zone back-end driver structure
> + *
> + * @owner: Module which is responsible for this back-end driver.
> + * @name: Name of the back-end driver.
> + * @total_size: The total size in bytes pstore/zone can use. It must be greater
> + * than 4096 and be multiple of 4096.
> + * @kmsg_size: The size of oops/panic zone. Zero means disabled, otherwise,
> + * it must be multiple of SECTOR_SIZE(512 Bytes).
> + * @max_reason: Maximum kmsg dump reason to store.
> + * @read: The general read operation. Both of the function parameters
> + * @size and @offset are relative value to storage.
> + * On success, the number of bytes should be returned, others
> + * means error.
> + * @write: The same as @read.
> + * @panic_write:The write operation only used for panic case. It's optional
> + * if you do not care panic log. The parameters and return value
> + * are the same as @read.
> + */
> +struct pstore_zone_info {
> + struct module *owner;
> + const char *name;
> +
> + unsigned long total_size;
> + unsigned long kmsg_size;
> + int max_reason;
> + pstore_zone_read_op read;
> + pstore_zone_write_op write;
> + pstore_zone_write_op panic_write;
> +};
> +
> +extern int register_pstore_zone(struct pstore_zone_info *info);
> +extern void unregister_pstore_zone(struct pstore_zone_info *info);
> +
> +#endif
>
--
WeiXiong Liao
^ permalink raw reply [flat|nested] 37+ messages in thread* Re: [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones
2020-05-11 8:36 ` WeiXiong Liao
@ 2020-05-11 23:02 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:02 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Mon, May 11, 2020 at 04:36:21PM +0800, WeiXiong Liao wrote:
> On 2020/5/11 AM 4:24, Kees Cook wrote:
> > [...]
> > + * @time: oops/panic trigger time
>
> The above comment should be corrected since it is not only oops/panic
> any more.
Ah yes, thanks! I'll clean these all up.
> > [...]
> > + if (hdr->reason == KMSG_DUMP_OOPS)
> > + hdr->counter = ++cxt->oops_counter;
> > + else
> > + hdr->counter = ++cxt->panic_counter;
>
> Here should be:
>
> if (hdr->reason == KMSG_DUMP_OOPS)
> hdr->counter = ++cxt->oops_counter;
> else if (hdr->reason == KMSG_DUMP_PANIC)
> hdr->counter = ++cxt->panic_counter;
> else
> hdr->counter = 0;
Good catch; thanks! I'll move the lost later hunk to here.
> > [...]
> > +MODULE_DESCRIPTION("Storage Manager for pstore/blk");
I'm going to leave this as-is for now since it's accurate for the
moment. :)
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 09/18] pstore/blk: Introduce backend for block devices
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (7 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 08/18] pstore/zone: Introduce common layer to manage storage zones Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 8:36 ` WeiXiong Liao
2020-05-11 15:36 ` Randy Dunlap
2020-05-10 20:24 ` [PATCH v7 10/18] pstore/zone,blk: Add support for pmsg frontend Kees Cook
` (10 subsequent siblings)
19 siblings, 2 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
pstore/blk is similar to pstore/ram, but uses a block device as the
storage rather than persistent ram.
The pstore/blk backend solves two common use-cases that used to preclude
using pstore/ram:
- not all devices have a battery that could be used to persist
regular RAM across power failures.
- most embedded intelligent equipment have no persistent ram, which
increases costs, instead preferring cheaper solutions, like block
devices.
pstore/blk provides separate configurations for the end user and for the
block drivers. User configuration determines how pstore/blk operates, such
as record sizes, max kmsg dump reasons, etc. These can be set by Kconfig
and/or module parameters, but module parameter have priority over Kconfig.
Driver configuration covers all the details about the target block device,
such as total size of the device and how to perform read/write operations.
These are provided by block drivers, calling pstore_register_blkdev(),
including an optional panic_write callback used to bypass regular IO
APIs in an effort to avoid potentially destabilized kernel code during
a panic.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-3-git-send-email-liaoweixiong@allwinnertech.com
Co-developed-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/Kconfig | 64 ++++++
fs/pstore/Makefile | 3 +
fs/pstore/blk.c | 436 +++++++++++++++++++++++++++++++++++++
include/linux/pstore_blk.h | 51 +++++
4 files changed, 554 insertions(+)
create mode 100644 fs/pstore/blk.c
create mode 100644 include/linux/pstore_blk.h
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index 98d2457bdd9f..92ba73bd0b62 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -160,3 +160,67 @@ config PSTORE_ZONE
help
The common layer for pstore/blk (and pstore/ram in the future)
to manage storage in zones.
+
+config PSTORE_BLK
+ tristate "Log panic/oops to a block device"
+ depends on PSTORE
+ depends on BLOCK
+ select PSTORE_ZONE
+ default n
+ help
+ This enables panic and oops message to be logged to a block dev
+ where it can be read back at some later point.
+
+ If unsure, say N.
+
+config PSTORE_BLK_BLKDEV
+ string "block device identifier"
+ depends on PSTORE_BLK
+ default ""
+ help
+ Which block device should be used for pstore/blk.
+
+ It accept the following variants:
+ 1) <hex_major><hex_minor> device number in hexadecimal represents
+ itself no leading 0x, for example b302.
+ 2) /dev/<disk_name> represents the device number of disk
+ 3) /dev/<disk_name><decimal> represents the device number
+ of partition - device number of disk plus the partition number
+ 4) /dev/<disk_name>p<decimal> - same as the above, this form is
+ used when disk name of partitioned disk ends with a digit.
+ 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
+ unique id of a partition if the partition table provides it.
+ The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
+ partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
+ filled hex representation of the 32-bit "NT disk signature", and PP
+ is a zero-filled hex representation of the 1-based partition number.
+ 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation
+ to a partition with a known unique id.
+ 7) <major>:<minor> major and minor number of the device separated by
+ a colon.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
+
+config PSTORE_BLK_KMSG_SIZE
+ int "Size in Kbytes of kmsg dump log to store"
+ depends on PSTORE_BLK
+ default 64
+ help
+ This just sets size of kmsg dump (oops, panic, etc) log for
+ pstore/blk. The size is in KB and must be a multiple of 4.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
+
+config PSTORE_BLK_MAX_REASON
+ int "Maximum kmsg dump reason to store"
+ depends on PSTORE_BLK
+ default 2
+ help
+ The maximum reason for kmsg dumps to store. The default is
+ 2 (KMSG_DUMP_OOPS), see include/linux/kmsg_dump.h's
+ enum kmsg_dump_reason for more details.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
diff --git a/fs/pstore/Makefile b/fs/pstore/Makefile
index 58a967cbe4af..c270467aeece 100644
--- a/fs/pstore/Makefile
+++ b/fs/pstore/Makefile
@@ -15,3 +15,6 @@ obj-$(CONFIG_PSTORE_RAM) += ramoops.o
pstore_zone-objs += zone.o
obj-$(CONFIG_PSTORE_ZONE) += pstore_zone.o
+
+pstore_blk-objs += blk.o
+obj-$(CONFIG_PSTORE_BLK) += pstore_blk.o
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
new file mode 100644
index 000000000000..cec1fa261d1b
--- /dev/null
+++ b/fs/pstore/blk.c
@@ -0,0 +1,436 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Implements pstore backend driver that write to block (or non-block) storage
+ * devices, using the pstore/zone API.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include "../../block/blk.h"
+#include <linux/blkdev.h>
+#include <linux/string.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+#include <linux/pstore_blk.h>
+#include <linux/mount.h>
+#include <linux/uio.h>
+
+static long kmsg_size = CONFIG_PSTORE_BLK_KMSG_SIZE;
+module_param(kmsg_size, long, 0400);
+MODULE_PARM_DESC(kmsg_size, "kmsg dump record size in kbytes");
+
+static int max_reason = CONFIG_PSTORE_BLK_MAX_REASON;
+module_param(max_reason, int, 0400);
+MODULE_PARM_DESC(max_reason,
+ "maximum reason for kmsg dump (default 2: Oops and Panic)");
+
+/*
+ * blkdev - the block device to use for pstore storage
+ *
+ * Usually, this will be a partition of a block device.
+ *
+ * blkdev accepts the following variants:
+ * 1) <hex_major><hex_minor> device number in hexadecimal represents itself
+ * no leading 0x, for example b302.
+ * 2) /dev/<disk_name> represents the device number of disk
+ * 3) /dev/<disk_name><decimal> represents the device number
+ * of partition - device number of disk plus the partition number
+ * 4) /dev/<disk_name>p<decimal> - same as the above, that form is
+ * used when disk name of partitioned disk ends on a digit.
+ * 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
+ * unique id of a partition if the partition table provides it.
+ * The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
+ * partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
+ * filled hex representation of the 32-bit "NT disk signature", and PP
+ * is a zero-filled hex representation of the 1-based partition number.
+ * 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
+ * a partition with a known unique id.
+ * 7) <major>:<minor> major and minor number of the device separated by
+ * a colon.
+ */
+static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
+module_param_string(blkdev, blkdev, 80, 0400);
+MODULE_PARM_DESC(blkdev, "block device for pstore storage");
+
+/*
+ * All globals must only be accessed under the pstore_blk_lock
+ * during the register/unregister functions.
+ */
+static DEFINE_MUTEX(pstore_blk_lock);
+static struct block_device *psblk_bdev;
+static struct pstore_zone_info *pstore_zone_info;
+static pstore_blk_panic_write_op blkdev_panic_write;
+static struct bdev_info {
+ dev_t devt;
+ sector_t nr_sects;
+ sector_t start_sect;
+} g_bdev_info;
+
+/**
+ * struct pstore_device_info - back-end pstore/blk driver structure.
+ *
+ * @total_size: The total size in bytes pstore/blk can use. It must be greater
+ * than 4096 and be multiple of 4096.
+ * @flags: Refer to macro starting with PSTORE_FLAGS defined in
+ * linux/pstore.h. It means what front-ends this device support.
+ * Zero means all backends for compatible.
+ * @read: The general read operation. Both of the function parameters
+ * @size and @offset are relative value to bock device (not the
+ * whole disk).
+ * On success, the number of bytes should be returned, others
+ * means error.
+ * @write: The same as @read.
+ * @panic_write:The write operation only used for panic case. It's optional
+ * if you do not care panic log. The parameters and return value
+ * are the same as @read.
+ */
+struct pstore_device_info {
+ unsigned long total_size;
+ unsigned int flags;
+ pstore_zone_read_op read;
+ pstore_zone_write_op write;
+ pstore_zone_write_op panic_write;
+};
+
+static int psblk_register_do(struct pstore_device_info *dev)
+{
+ int ret;
+
+ if (!dev || !dev->total_size || !dev->read || !dev->write)
+ return -EINVAL;
+
+ mutex_lock(&pstore_blk_lock);
+
+ /* someone already registered before */
+ if (pstore_zone_info) {
+ mutex_unlock(&pstore_blk_lock);
+ return -EBUSY;
+ }
+ pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
+ if (!pstore_zone_info) {
+ mutex_unlock(&pstore_blk_lock);
+ return -ENOMEM;
+ }
+
+ /* zero means not limit on which backends to attempt to store. */
+ if (!dev->flags)
+ dev->flags = UINT_MAX;
+
+#define verify_size(name, alignsize, enabled) { \
+ long _##name_ = (enabled) ? (name) : 0; \
+ _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024); \
+ if (_##name_ & ((alignsize) - 1)) { \
+ pr_info(#name " must align to %d\n", \
+ (alignsize)); \
+ _##name_ = ALIGN(name, (alignsize)); \
+ } \
+ name = _##name_ / 1024; \
+ pstore_zone_info->name = _##name_; \
+ }
+
+ verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
+#undef verify_size
+
+ pstore_zone_info->total_size = dev->total_size;
+ pstore_zone_info->max_reason = max_reason;
+ pstore_zone_info->read = dev->read;
+ pstore_zone_info->write = dev->write;
+ pstore_zone_info->panic_write = dev->panic_write;
+ pstore_zone_info->name = KBUILD_MODNAME;
+ pstore_zone_info->owner = THIS_MODULE;
+
+ ret = register_pstore_zone(pstore_zone_info);
+ if (ret) {
+ kfree(pstore_zone_info);
+ pstore_zone_info = NULL;
+ }
+ mutex_unlock(&pstore_blk_lock);
+ return ret;
+}
+
+static void psblk_unregister_do(struct pstore_device_info *dev)
+{
+ mutex_lock(&pstore_blk_lock);
+ if (pstore_zone_info && pstore_zone_info->read == dev->read) {
+ unregister_pstore_zone(pstore_zone_info);
+ kfree(pstore_zone_info);
+ pstore_zone_info = NULL;
+ }
+ mutex_unlock(&pstore_blk_lock);
+}
+
+/**
+ * psblk_get_bdev() - open block device
+ *
+ * @holder: Exclusive holder identifier
+ * @info: Information about bdev to fill in
+ *
+ * Return: pointer to block device on success and others on error.
+ *
+ * On success, the returned block_device has reference count of one.
+ */
+static struct block_device *psblk_get_bdev(void *holder,
+ struct bdev_info *info)
+{
+ struct block_device *bdev = ERR_PTR(-ENODEV);
+ fmode_t mode = FMODE_READ | FMODE_WRITE;
+ sector_t nr_sects;
+
+ if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
+ return ERR_PTR(-EINVAL);
+
+ if (pstore_zone_info)
+ return ERR_PTR(-EBUSY);
+
+ if (!blkdev[0])
+ return ERR_PTR(-ENODEV);
+
+ if (holder)
+ mode |= FMODE_EXCL;
+ bdev = blkdev_get_by_path(blkdev, mode, holder);
+ if (IS_ERR(bdev)) {
+ dev_t devt;
+
+ devt = name_to_dev_t(blkdev);
+ if (devt == 0)
+ return ERR_PTR(-ENODEV);
+ bdev = blkdev_get_by_dev(devt, mode, holder);
+ }
+
+ nr_sects = part_nr_sects_read(bdev->bd_part);
+ if (!nr_sects) {
+ pr_err("not enough space for '%s'\n", blkdev);
+ blkdev_put(bdev, mode);
+ return ERR_PTR(-ENOSPC);
+ }
+
+ if (info) {
+ info->devt = bdev->bd_dev;
+ info->nr_sects = nr_sects;
+ info->start_sect = get_start_sect(bdev);
+ }
+
+ return bdev;
+}
+
+static void psblk_put_bdev(struct block_device *bdev, void *holder)
+{
+ fmode_t mode = FMODE_READ | FMODE_WRITE;
+
+ if (!bdev)
+ return;
+
+ if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
+ return;
+
+ if (holder)
+ mode |= FMODE_EXCL;
+ blkdev_put(bdev, mode);
+}
+
+static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)
+{
+ struct block_device *bdev = psblk_bdev;
+ struct file file;
+ struct kiocb kiocb;
+ struct iov_iter iter;
+ struct kvec iov = {.iov_base = buf, .iov_len = bytes};
+
+ if (!bdev)
+ return -ENODEV;
+
+ memset(&file, 0, sizeof(struct file));
+ file.f_mapping = bdev->bd_inode->i_mapping;
+ file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
+ file.f_inode = bdev->bd_inode;
+ file_ra_state_init(&file.f_ra, file.f_mapping);
+
+ init_sync_kiocb(&kiocb, &file);
+ kiocb.ki_pos = pos;
+ iov_iter_kvec(&iter, READ, &iov, 1, bytes);
+
+ return generic_file_read_iter(&kiocb, &iter);
+}
+
+static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,
+ loff_t pos)
+{
+ struct block_device *bdev = psblk_bdev;
+ struct iov_iter iter;
+ struct kiocb kiocb;
+ struct file file;
+ ssize_t ret;
+ struct kvec iov = {.iov_base = (void *)buf, .iov_len = bytes};
+
+ if (!bdev)
+ return -ENODEV;
+
+ /* Console/Ftrace backend may handle buffer until flush dirty zones */
+ if (in_interrupt() || irqs_disabled())
+ return -EBUSY;
+
+ memset(&file, 0, sizeof(struct file));
+ file.f_mapping = bdev->bd_inode->i_mapping;
+ file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
+ file.f_inode = bdev->bd_inode;
+
+ init_sync_kiocb(&kiocb, &file);
+ kiocb.ki_pos = pos;
+ iov_iter_kvec(&iter, WRITE, &iov, 1, bytes);
+
+ inode_lock(bdev->bd_inode);
+ ret = generic_write_checks(&kiocb, &iter);
+ if (ret > 0)
+ ret = generic_perform_write(&file, &iter, pos);
+ inode_unlock(bdev->bd_inode);
+
+ if (likely(ret > 0)) {
+ const struct file_operations f_op = {.fsync = blkdev_fsync};
+
+ file.f_op = &f_op;
+ kiocb.ki_pos += ret;
+ ret = generic_write_sync(&kiocb, ret);
+ }
+ return ret;
+}
+
+static ssize_t psblk_blk_panic_write(const char *buf, size_t size,
+ loff_t off)
+{
+ int ret;
+
+ if (!blkdev_panic_write)
+ return -EOPNOTSUPP;
+
+ /* size and off must align to SECTOR_SIZE for block device */
+ ret = blkdev_panic_write(buf, off >> SECTOR_SHIFT,
+ size >> SECTOR_SHIFT);
+ return ret ? -EIO : size;
+}
+
+static int __register_pstore_blk(struct pstore_blk_info *info)
+{
+ char bdev_name[BDEVNAME_SIZE];
+ struct block_device *bdev;
+ struct pstore_device_info dev;
+ struct bdev_info binfo;
+ void *holder = blkdev;
+ int ret = -ENODEV;
+
+ if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
+ return -EINVAL;
+
+ /* hold bdev exclusively */
+ memset(&binfo, 0, sizeof(binfo));
+ bdev = psblk_get_bdev(holder, &binfo);
+ if (IS_ERR(bdev)) {
+ pr_err("failed to open '%s'!\n", blkdev);
+ ret = PTR_ERR(bdev);
+ goto err_put_bdev;
+ }
+
+ /* only allow driver matching the @blkdev */
+ if (!binfo.devt || MAJOR(binfo.devt) != info->major) {
+ pr_debug("invalid major %u (expect %u)\n",
+ info->major, MAJOR(binfo.devt));
+ ret = -ENODEV;
+ goto err_put_bdev;
+ }
+
+ /* psblk_bdev must be assigned before register to pstore/blk */
+ psblk_bdev = bdev;
+ blkdev_panic_write = info->panic_write;
+
+ /* Copy back block device details. */
+ info->devt = binfo.devt;
+ info->nr_sects = binfo.nr_sects;
+ info->start_sect = binfo.start_sect;
+
+ memset(&dev, 0, sizeof(dev));
+ dev.total_size = info->nr_sects << SECTOR_SHIFT;
+ dev.flags = info->flags;
+ dev.read = psblk_generic_blk_read;
+ dev.write = psblk_generic_blk_write;
+ dev.panic_write = info->panic_write ? psblk_blk_panic_write : NULL;
+
+ ret = psblk_register_do(&dev);
+ if (ret)
+ goto err_put_bdev;
+
+ bdevname(bdev, bdev_name);
+ pr_info("attached %s%s\n", bdev_name,
+ info->panic_write ? "" : " (no dedicated panic_write!)");
+ return 0;
+
+err_put_bdev:
+ psblk_bdev = NULL;
+ blkdev_panic_write = NULL;
+ psblk_put_bdev(bdev, holder);
+ return ret;
+}
+
+/**
+ * register_pstore_blk() - register block device to pstore/blk
+ *
+ * @info: details on the desired block device interface
+ *
+ * Return:
+ * * 0 - OK
+ * * Others - something error.
+ */
+int register_pstore_blk(struct pstore_blk_info *info)
+{
+ int ret;
+
+ mutex_lock(&pstore_blk_lock);
+ ret = __register_pstore_blk(info);
+ mutex_unlock(&pstore_blk_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(register_pstore_blk);
+
+static void __unregister_pstore_blk(unsigned int major)
+{
+ struct pstore_device_info dev = { .read = psblk_generic_blk_read };
+ void *holder = blkdev;
+
+ WARN_ON(!mutex_is_locked(&pstore_blk_lock));
+ if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
+ psblk_unregister_do(&dev);
+ psblk_put_bdev(psblk_bdev, holder);
+ blkdev_panic_write = NULL;
+ psblk_bdev = NULL;
+ memset(&g_bdev_info, 0, sizeof(g_bdev_info));
+ }
+}
+
+/**
+ * unregister_pstore_blk() - unregister block device from pstore/blk
+ *
+ * @major: the major device number of device
+ */
+void unregister_pstore_blk(unsigned int major)
+{
+ mutex_lock(&pstore_blk_lock);
+ __unregister_pstore_blk(major);
+ mutex_unlock(&pstore_blk_lock);
+}
+EXPORT_SYMBOL_GPL(unregister_pstore_blk);
+
+static void __exit pstore_blk_exit(void)
+{
+ mutex_lock(&pstore_blk_lock);
+ if (psblk_bdev)
+ __unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
+ mutex_unlock(&pstore_blk_lock);
+}
+module_exit(pstore_blk_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
+MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
+MODULE_DESCRIPTION("pstore backend for block devices");
diff --git a/include/linux/pstore_blk.h b/include/linux/pstore_blk.h
new file mode 100644
index 000000000000..4501977b1336
--- /dev/null
+++ b/include/linux/pstore_blk.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __PSTORE_BLK_H_
+#define __PSTORE_BLK_H_
+
+#include <linux/types.h>
+#include <linux/pstore.h>
+#include <linux/pstore_zone.h>
+
+/**
+ * typedef pstore_blk_panic_write_op - panic write operation to block device
+ *
+ * @buf: the data to write
+ * @start_sect: start sector to block device
+ * @sects: sectors count on buf
+ *
+ * Return: On success, zero should be returned. Others mean error.
+ *
+ * Panic write to block device must be aligned to SECTOR_SIZE.
+ */
+typedef int (*pstore_blk_panic_write_op)(const char *buf, sector_t start_sect,
+ sector_t sects);
+
+/**
+ * struct pstore_blk_info - pstore/blk registration details
+ *
+ * @major: Which major device number to support with pstore/blk
+ * @flags: The supported PSTORE_FLAGS_* from linux/pstore.h.
+ * @panic_write:The write operation only used for the panic case.
+ * This can be NULL, but is recommended to avoid losing
+ * crash data if the kernel's IO path or work queues are
+ * broken during a panic.
+ * @devt: The dev_t that pstore/blk has attached to.
+ * @nr_sects: Number of sectors on @devt.
+ * @start_sect: Starting sector on @devt.
+ */
+struct pstore_blk_info {
+ unsigned int major;
+ unsigned int flags;
+ pstore_blk_panic_write_op panic_write;
+
+ /* Filled in by pstore/blk after registration. */
+ dev_t devt;
+ sector_t nr_sects;
+ sector_t start_sect;
+};
+
+int register_pstore_blk(struct pstore_blk_info *info);
+void unregister_pstore_blk(unsigned int major);
+
+#endif
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 09/18] pstore/blk: Introduce backend for block devices
2020-05-10 20:24 ` [PATCH v7 09/18] pstore/blk: Introduce backend for block devices Kees Cook
@ 2020-05-11 8:36 ` WeiXiong Liao
2020-05-11 23:08 ` Kees Cook
2020-05-11 15:36 ` Randy Dunlap
1 sibling, 1 reply; 37+ messages in thread
From: WeiXiong Liao @ 2020-05-11 8:36 UTC (permalink / raw)
To: Kees Cook
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
hi Kees Cook,
On 2020/5/11 AM 4:24, Kees Cook wrote:
> From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
>
> pstore/blk is similar to pstore/ram, but uses a block device as the
> storage rather than persistent ram.
>
> The pstore/blk backend solves two common use-cases that used to preclude
> using pstore/ram:
> - not all devices have a battery that could be used to persist
> regular RAM across power failures.
> - most embedded intelligent equipment have no persistent ram, which
> increases costs, instead preferring cheaper solutions, like block
> devices.
>
> pstore/blk provides separate configurations for the end user and for the
> block drivers. User configuration determines how pstore/blk operates, such
> as record sizes, max kmsg dump reasons, etc. These can be set by Kconfig
> and/or module parameters, but module parameter have priority over Kconfig.
> Driver configuration covers all the details about the target block device,
> such as total size of the device and how to perform read/write operations.
> These are provided by block drivers, calling pstore_register_blkdev(),
> including an optional panic_write callback used to bypass regular IO
> APIs in an effort to avoid potentially destabilized kernel code during
> a panic.
>
> Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
> Link: https://lore.kernel.org/r/1585126506-18635-3-git-send-email-liaoweixiong@allwinnertech.com
> Co-developed-by: Kees Cook <keescook@chromium.org>
> Signed-off-by: Kees Cook <keescook@chromium.org>
> ---
> fs/pstore/Kconfig | 64 ++++++
> fs/pstore/Makefile | 3 +
> fs/pstore/blk.c | 436 +++++++++++++++++++++++++++++++++++++
> include/linux/pstore_blk.h | 51 +++++
> 4 files changed, 554 insertions(+)
> create mode 100644 fs/pstore/blk.c
> create mode 100644 include/linux/pstore_blk.h
>
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index 98d2457bdd9f..92ba73bd0b62 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -160,3 +160,67 @@ config PSTORE_ZONE
> help
> The common layer for pstore/blk (and pstore/ram in the future)
> to manage storage in zones.
> +
> +config PSTORE_BLK
> + tristate "Log panic/oops to a block device"
> + depends on PSTORE
> + depends on BLOCK
> + select PSTORE_ZONE
> + default n
> + help
> + This enables panic and oops message to be logged to a block dev
> + where it can be read back at some later point.
> +
> + If unsure, say N.
> +
> +config PSTORE_BLK_BLKDEV
> + string "block device identifier"
> + depends on PSTORE_BLK
> + default ""
> + help
> + Which block device should be used for pstore/blk.
> +
> + It accept the following variants:
> + 1) <hex_major><hex_minor> device number in hexadecimal represents
> + itself no leading 0x, for example b302.
> + 2) /dev/<disk_name> represents the device number of disk
> + 3) /dev/<disk_name><decimal> represents the device number
> + of partition - device number of disk plus the partition number
> + 4) /dev/<disk_name>p<decimal> - same as the above, this form is
> + used when disk name of partitioned disk ends with a digit.
> + 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
> + unique id of a partition if the partition table provides it.
> + The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
> + partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
> + filled hex representation of the 32-bit "NT disk signature", and PP
> + is a zero-filled hex representation of the 1-based partition number.
> + 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation
> + to a partition with a known unique id.
> + 7) <major>:<minor> major and minor number of the device separated by
> + a colon.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
> +
> +config PSTORE_BLK_KMSG_SIZE
> + int "Size in Kbytes of kmsg dump log to store"
> + depends on PSTORE_BLK
> + default 64
> + help
> + This just sets size of kmsg dump (oops, panic, etc) log for
> + pstore/blk. The size is in KB and must be a multiple of 4.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
> +
> +config PSTORE_BLK_MAX_REASON
> + int "Maximum kmsg dump reason to store"
> + depends on PSTORE_BLK
> + default 2
> + help
> + The maximum reason for kmsg dumps to store. The default is
> + 2 (KMSG_DUMP_OOPS), see include/linux/kmsg_dump.h's
> + enum kmsg_dump_reason for more details.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
> diff --git a/fs/pstore/Makefile b/fs/pstore/Makefile
> index 58a967cbe4af..c270467aeece 100644
> --- a/fs/pstore/Makefile
> +++ b/fs/pstore/Makefile
> @@ -15,3 +15,6 @@ obj-$(CONFIG_PSTORE_RAM) += ramoops.o
>
> pstore_zone-objs += zone.o
> obj-$(CONFIG_PSTORE_ZONE) += pstore_zone.o
> +
> +pstore_blk-objs += blk.o
> +obj-$(CONFIG_PSTORE_BLK) += pstore_blk.o
> diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
> new file mode 100644
> index 000000000000..cec1fa261d1b
> --- /dev/null
> +++ b/fs/pstore/blk.c
> @@ -0,0 +1,436 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Implements pstore backend driver that write to block (or non-block) storage
> + * devices, using the pstore/zone API.
> + */
> +
> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include "../../block/blk.h"
> +#include <linux/blkdev.h>
> +#include <linux/string.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
> +#include <linux/platform_device.h>
> +#include <linux/pstore_blk.h>
> +#include <linux/mount.h>
> +#include <linux/uio.h>
> +
> +static long kmsg_size = CONFIG_PSTORE_BLK_KMSG_SIZE;
> +module_param(kmsg_size, long, 0400);
> +MODULE_PARM_DESC(kmsg_size, "kmsg dump record size in kbytes");
> +
> +static int max_reason = CONFIG_PSTORE_BLK_MAX_REASON;
> +module_param(max_reason, int, 0400);
> +MODULE_PARM_DESC(max_reason,
> + "maximum reason for kmsg dump (default 2: Oops and Panic)");
> +
> +/*
> + * blkdev - the block device to use for pstore storage
> + *
> + * Usually, this will be a partition of a block device.
> + *
> + * blkdev accepts the following variants:
> + * 1) <hex_major><hex_minor> device number in hexadecimal represents itself
> + * no leading 0x, for example b302.
> + * 2) /dev/<disk_name> represents the device number of disk
> + * 3) /dev/<disk_name><decimal> represents the device number
> + * of partition - device number of disk plus the partition number
> + * 4) /dev/<disk_name>p<decimal> - same as the above, that form is
> + * used when disk name of partitioned disk ends on a digit.
> + * 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
> + * unique id of a partition if the partition table provides it.
> + * The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
> + * partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
> + * filled hex representation of the 32-bit "NT disk signature", and PP
> + * is a zero-filled hex representation of the 1-based partition number.
> + * 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
> + * a partition with a known unique id.
> + * 7) <major>:<minor> major and minor number of the device separated by
> + * a colon.
> + */
> +static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
> +module_param_string(blkdev, blkdev, 80, 0400);
> +MODULE_PARM_DESC(blkdev, "block device for pstore storage");
> +
> +/*
> + * All globals must only be accessed under the pstore_blk_lock
> + * during the register/unregister functions.
> + */
> +static DEFINE_MUTEX(pstore_blk_lock);
> +static struct block_device *psblk_bdev;
> +static struct pstore_zone_info *pstore_zone_info;
> +static pstore_blk_panic_write_op blkdev_panic_write;
> +static struct bdev_info {
> + dev_t devt;
> + sector_t nr_sects;
> + sector_t start_sect;
> +} g_bdev_info;
> +
> +/**
> + * struct pstore_device_info - back-end pstore/blk driver structure.
> + *
> + * @total_size: The total size in bytes pstore/blk can use. It must be greater
> + * than 4096 and be multiple of 4096.
> + * @flags: Refer to macro starting with PSTORE_FLAGS defined in
> + * linux/pstore.h. It means what front-ends this device support.
> + * Zero means all backends for compatible.
> + * @read: The general read operation. Both of the function parameters
> + * @size and @offset are relative value to bock device (not the
> + * whole disk).
> + * On success, the number of bytes should be returned, others
> + * means error.
> + * @write: The same as @read.
> + * @panic_write:The write operation only used for panic case. It's optional
> + * if you do not care panic log. The parameters and return value
> + * are the same as @read.
> + */
> +struct pstore_device_info {
> + unsigned long total_size;
> + unsigned int flags;
> + pstore_zone_read_op read;
> + pstore_zone_write_op write;
> + pstore_zone_write_op panic_write;
> +};
> +
> +static int psblk_register_do(struct pstore_device_info *dev)
> +{
> + int ret;
> +
> + if (!dev || !dev->total_size || !dev->read || !dev->write)
> + return -EINVAL;
> +
> + mutex_lock(&pstore_blk_lock);
> +
> + /* someone already registered before */
> + if (pstore_zone_info) {
> + mutex_unlock(&pstore_blk_lock);
> + return -EBUSY;
> + }
> + pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
> + if (!pstore_zone_info) {
> + mutex_unlock(&pstore_blk_lock);
> + return -ENOMEM;
> + }
> +
> + /* zero means not limit on which backends to attempt to store. */
> + if (!dev->flags)
> + dev->flags = UINT_MAX;
> +
> +#define verify_size(name, alignsize, enabled) { \
> + long _##name_ = (enabled) ? (name) : 0; \
> + _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024); \
> + if (_##name_ & ((alignsize) - 1)) { \
> + pr_info(#name " must align to %d\n", \
> + (alignsize)); \
> + _##name_ = ALIGN(name, (alignsize)); \
> + } \
> + name = _##name_ / 1024; \
> + pstore_zone_info->name = _##name_; \
> + }
> +
> + verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
> +#undef verify_size
> +
> + pstore_zone_info->total_size = dev->total_size;
> + pstore_zone_info->max_reason = max_reason;
> + pstore_zone_info->read = dev->read;
> + pstore_zone_info->write = dev->write;
> + pstore_zone_info->panic_write = dev->panic_write;
> + pstore_zone_info->name = KBUILD_MODNAME;
> + pstore_zone_info->owner = THIS_MODULE;
> +
> + ret = register_pstore_zone(pstore_zone_info);
> + if (ret) {
> + kfree(pstore_zone_info);
> + pstore_zone_info = NULL;
> + }
> + mutex_unlock(&pstore_blk_lock);
> + return ret;
> +}
> +
> +static void psblk_unregister_do(struct pstore_device_info *dev)
> +{
> + mutex_lock(&pstore_blk_lock);
> + if (pstore_zone_info && pstore_zone_info->read == dev->read) {
> + unregister_pstore_zone(pstore_zone_info);
> + kfree(pstore_zone_info);
> + pstore_zone_info = NULL;
> + }
> + mutex_unlock(&pstore_blk_lock);
> +}
> +
> +/**
> + * psblk_get_bdev() - open block device
> + *
> + * @holder: Exclusive holder identifier
> + * @info: Information about bdev to fill in
> + *
> + * Return: pointer to block device on success and others on error.
> + *
> + * On success, the returned block_device has reference count of one.
> + */
> +static struct block_device *psblk_get_bdev(void *holder,
> + struct bdev_info *info)
Well. That's pretty a good idea to get information about block device
after registering. And after your codes, the global variable g_bdev_info is
useless. It's time to drop it.
> +{
> + struct block_device *bdev = ERR_PTR(-ENODEV);
> + fmode_t mode = FMODE_READ | FMODE_WRITE;
> + sector_t nr_sects;
> +
> + if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
> + return ERR_PTR(-EINVAL);
> +
> + if (pstore_zone_info)
> + return ERR_PTR(-EBUSY);
> +
> + if (!blkdev[0])
> + return ERR_PTR(-ENODEV);
> +
> + if (holder)
> + mode |= FMODE_EXCL;
> + bdev = blkdev_get_by_path(blkdev, mode, holder);
> + if (IS_ERR(bdev)) {
> + dev_t devt;
> +
> + devt = name_to_dev_t(blkdev);
> + if (devt == 0)
> + return ERR_PTR(-ENODEV);
> + bdev = blkdev_get_by_dev(devt, mode, holder);
> + }
We should check bdev here. Otherwise, part_nr_sects_read()
may catch segment error.
if (IS_ERR(bdev))
return bdev;
> +
> + nr_sects = part_nr_sects_read(bdev->bd_part);
> + if (!nr_sects) {
> + pr_err("not enough space for '%s'\n", blkdev);
> + blkdev_put(bdev, mode);
> + return ERR_PTR(-ENOSPC);
> + }
> +
> + if (info) {
> + info->devt = bdev->bd_dev;
> + info->nr_sects = nr_sects;
> + info->start_sect = get_start_sect(bdev);
> + }
> +
> + return bdev;
> +}
> +
> +static void psblk_put_bdev(struct block_device *bdev, void *holder)
> +{
> + fmode_t mode = FMODE_READ | FMODE_WRITE;
> +
> + if (!bdev)
> + return;
> +
> + if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
> + return;
> +
> + if (holder)
> + mode |= FMODE_EXCL;
> + blkdev_put(bdev, mode);
> +}
> +
> +static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)
> +{
> + struct block_device *bdev = psblk_bdev;
> + struct file file;
> + struct kiocb kiocb;
> + struct iov_iter iter;
> + struct kvec iov = {.iov_base = buf, .iov_len = bytes};
> +
> + if (!bdev)
> + return -ENODEV;
> +
> + memset(&file, 0, sizeof(struct file));
> + file.f_mapping = bdev->bd_inode->i_mapping;
> + file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
> + file.f_inode = bdev->bd_inode;
> + file_ra_state_init(&file.f_ra, file.f_mapping);
> +
> + init_sync_kiocb(&kiocb, &file);
> + kiocb.ki_pos = pos;
> + iov_iter_kvec(&iter, READ, &iov, 1, bytes);
> +
> + return generic_file_read_iter(&kiocb, &iter);
> +}
> +
> +static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,
> + loff_t pos)
> +{
> + struct block_device *bdev = psblk_bdev;
> + struct iov_iter iter;
> + struct kiocb kiocb;
> + struct file file;
> + ssize_t ret;
> + struct kvec iov = {.iov_base = (void *)buf, .iov_len = bytes};
> +
> + if (!bdev)
> + return -ENODEV;
> +
> + /* Console/Ftrace backend may handle buffer until flush dirty zones */
> + if (in_interrupt() || irqs_disabled())
> + return -EBUSY;
> +
> + memset(&file, 0, sizeof(struct file));
> + file.f_mapping = bdev->bd_inode->i_mapping;
> + file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
> + file.f_inode = bdev->bd_inode;
> +
> + init_sync_kiocb(&kiocb, &file);
> + kiocb.ki_pos = pos;
> + iov_iter_kvec(&iter, WRITE, &iov, 1, bytes);
> +
> + inode_lock(bdev->bd_inode);
> + ret = generic_write_checks(&kiocb, &iter);
> + if (ret > 0)
> + ret = generic_perform_write(&file, &iter, pos);
> + inode_unlock(bdev->bd_inode);
> +
> + if (likely(ret > 0)) {
> + const struct file_operations f_op = {.fsync = blkdev_fsync};
> +
> + file.f_op = &f_op;
> + kiocb.ki_pos += ret;
> + ret = generic_write_sync(&kiocb, ret);
> + }
> + return ret;
> +}
> +
> +static ssize_t psblk_blk_panic_write(const char *buf, size_t size,
> + loff_t off)
> +{
> + int ret;
> +
> + if (!blkdev_panic_write)
> + return -EOPNOTSUPP;
> +
> + /* size and off must align to SECTOR_SIZE for block device */
> + ret = blkdev_panic_write(buf, off >> SECTOR_SHIFT,
> + size >> SECTOR_SHIFT);
> + return ret ? -EIO : size;
> +}
> +
> +static int __register_pstore_blk(struct pstore_blk_info *info)
> +{
> + char bdev_name[BDEVNAME_SIZE];
> + struct block_device *bdev;
> + struct pstore_device_info dev;
> + struct bdev_info binfo;
> + void *holder = blkdev;
> + int ret = -ENODEV;
> +
> + if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
> + return -EINVAL;
> +
> + /* hold bdev exclusively */
> + memset(&binfo, 0, sizeof(binfo));
> + bdev = psblk_get_bdev(holder, &binfo);
> + if (IS_ERR(bdev)) {
> + pr_err("failed to open '%s'!\n", blkdev);
> + ret = PTR_ERR(bdev);
> + goto err_put_bdev;
It should not goto err_put_bdev since bdev already be put if get_bdev()
fail.
> + }
> +
> + /* only allow driver matching the @blkdev */
> + if (!binfo.devt || MAJOR(binfo.devt) != info->major) {
> + pr_debug("invalid major %u (expect %u)\n",
> + info->major, MAJOR(binfo.devt));
> + ret = -ENODEV;
> + goto err_put_bdev;
> + }
> +
> + /* psblk_bdev must be assigned before register to pstore/blk */
> + psblk_bdev = bdev;
> + blkdev_panic_write = info->panic_write;
> +
> + /* Copy back block device details. */
> + info->devt = binfo.devt;
> + info->nr_sects = binfo.nr_sects;
> + info->start_sect = binfo.start_sect;
> +
> + memset(&dev, 0, sizeof(dev));
> + dev.total_size = info->nr_sects << SECTOR_SHIFT;
> + dev.flags = info->flags;
> + dev.read = psblk_generic_blk_read;
> + dev.write = psblk_generic_blk_write;
> + dev.panic_write = info->panic_write ? psblk_blk_panic_write : NULL;
> +
> + ret = psblk_register_do(&dev);
> + if (ret)
> + goto err_put_bdev;
> +
> + bdevname(bdev, bdev_name);
> + pr_info("attached %s%s\n", bdev_name,
> + info->panic_write ? "" : " (no dedicated panic_write!)");
> + return 0;
> +
> +err_put_bdev:
> + psblk_bdev = NULL;
> + blkdev_panic_write = NULL;
> + psblk_put_bdev(bdev, holder);
> + return ret;
> +}
> +
> +/**
> + * register_pstore_blk() - register block device to pstore/blk
> + *
> + * @info: details on the desired block device interface
> + *
> + * Return:
> + * * 0 - OK
> + * * Others - something error.
> + */
> +int register_pstore_blk(struct pstore_blk_info *info)
> +{
> + int ret;
> +
> + mutex_lock(&pstore_blk_lock);
> + ret = __register_pstore_blk(info);
> + mutex_unlock(&pstore_blk_lock);
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(register_pstore_blk);
> +
> +static void __unregister_pstore_blk(unsigned int major)
> +{
> + struct pstore_device_info dev = { .read = psblk_generic_blk_read };
> + void *holder = blkdev;
> +
> + WARN_ON(!mutex_is_locked(&pstore_blk_lock));
> + if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
> + psblk_unregister_do(&dev);
> + psblk_put_bdev(psblk_bdev, holder);
> + blkdev_panic_write = NULL;
> + psblk_bdev = NULL;
> + memset(&g_bdev_info, 0, sizeof(g_bdev_info));
Also here.
> + }
> +}
> +
> +/**
> + * unregister_pstore_blk() - unregister block device from pstore/blk
> + *
> + * @major: the major device number of device
> + */
> +void unregister_pstore_blk(unsigned int major)
> +{
> + mutex_lock(&pstore_blk_lock);
> + __unregister_pstore_blk(major);
> + mutex_unlock(&pstore_blk_lock);
> +}
> +EXPORT_SYMBOL_GPL(unregister_pstore_blk);
> +
> +static void __exit pstore_blk_exit(void)
> +{
> + mutex_lock(&pstore_blk_lock);
> + if (psblk_bdev)
> + __unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
> + mutex_unlock(&pstore_blk_lock);
> +}
> +module_exit(pstore_blk_exit);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
> +MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
> +MODULE_DESCRIPTION("pstore backend for block devices");
> diff --git a/include/linux/pstore_blk.h b/include/linux/pstore_blk.h
> new file mode 100644
> index 000000000000..4501977b1336
> --- /dev/null
> +++ b/include/linux/pstore_blk.h
> @@ -0,0 +1,51 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +
> +#ifndef __PSTORE_BLK_H_
> +#define __PSTORE_BLK_H_
> +
> +#include <linux/types.h>
> +#include <linux/pstore.h>
> +#include <linux/pstore_zone.h>
> +
> +/**
> + * typedef pstore_blk_panic_write_op - panic write operation to block device
> + *
> + * @buf: the data to write
> + * @start_sect: start sector to block device
> + * @sects: sectors count on buf
> + *
> + * Return: On success, zero should be returned. Others mean error.
> + *
> + * Panic write to block device must be aligned to SECTOR_SIZE.
> + */
> +typedef int (*pstore_blk_panic_write_op)(const char *buf, sector_t start_sect,
> + sector_t sects);
> +
> +/**
> + * struct pstore_blk_info - pstore/blk registration details
> + *
> + * @major: Which major device number to support with pstore/blk
> + * @flags: The supported PSTORE_FLAGS_* from linux/pstore.h.
> + * @panic_write:The write operation only used for the panic case.
> + * This can be NULL, but is recommended to avoid losing
> + * crash data if the kernel's IO path or work queues are
> + * broken during a panic.
> + * @devt: The dev_t that pstore/blk has attached to.
> + * @nr_sects: Number of sectors on @devt.
> + * @start_sect: Starting sector on @devt.
> + */
> +struct pstore_blk_info {
> + unsigned int major;
> + unsigned int flags;
> + pstore_blk_panic_write_op panic_write;
> +
> + /* Filled in by pstore/blk after registration. */
> + dev_t devt;
> + sector_t nr_sects;
> + sector_t start_sect;
> +};
> +
> +int register_pstore_blk(struct pstore_blk_info *info);
> +void unregister_pstore_blk(unsigned int major);
> +
> +#endif
>
--
WeiXiong Liao
^ permalink raw reply [flat|nested] 37+ messages in thread* Re: [PATCH v7 09/18] pstore/blk: Introduce backend for block devices
2020-05-11 8:36 ` WeiXiong Liao
@ 2020-05-11 23:08 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:08 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Mon, May 11, 2020 at 04:36:51PM +0800, WeiXiong Liao wrote:
> On 2020/5/11 AM 4:24, Kees Cook wrote:
> > [...]
> > +static struct block_device *psblk_get_bdev(void *holder,
> > + struct bdev_info *info)
>
> Well. That's pretty a good idea to get information about block device
> after registering. And after your codes, the global variable g_bdev_info is
> useless. It's time to drop it.
Ah yes! I meant to clean that up and forgot. Fixed now.
> > [...]
> > + bdev = blkdev_get_by_path(blkdev, mode, holder);
> > + if (IS_ERR(bdev)) {
> > + dev_t devt;
> > +
> > + devt = name_to_dev_t(blkdev);
> > + if (devt == 0)
> > + return ERR_PTR(-ENODEV);
> > + bdev = blkdev_get_by_dev(devt, mode, holder);
> > + }
>
> We should check bdev here. Otherwise, part_nr_sects_read()
> may catch segment error.
>
> if (IS_ERR(bdev))
> return bdev;
Whoops, yes. Fixed.
> > + bdev = psblk_get_bdev(holder, &binfo);
> > + if (IS_ERR(bdev)) {
> > + pr_err("failed to open '%s'!\n", blkdev);
> > + ret = PTR_ERR(bdev);
> > + goto err_put_bdev;
>
> It should not goto err_put_bdev since bdev already be put if get_bdev()
> fail.
Ah yes, good point. Fixed.
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 09/18] pstore/blk: Introduce backend for block devices
2020-05-10 20:24 ` [PATCH v7 09/18] pstore/blk: Introduce backend for block devices Kees Cook
2020-05-11 8:36 ` WeiXiong Liao
@ 2020-05-11 15:36 ` Randy Dunlap
2020-05-11 23:11 ` Kees Cook
1 sibling, 1 reply; 37+ messages in thread
From: Randy Dunlap @ 2020-05-11 15:36 UTC (permalink / raw)
To: Kees Cook, WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On 5/10/20 1:24 PM, Kees Cook wrote:
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index 98d2457bdd9f..92ba73bd0b62 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -160,3 +160,67 @@ config PSTORE_ZONE
> help
> The common layer for pstore/blk (and pstore/ram in the future)
> to manage storage in zones.
> +
> +config PSTORE_BLK
> + tristate "Log panic/oops to a block device"
> + depends on PSTORE
> + depends on BLOCK
> + select PSTORE_ZONE
> + default n
> + help
> + This enables panic and oops message to be logged to a block dev
> + where it can be read back at some later point.
> +
> + If unsure, say N.
> +
> +config PSTORE_BLK_BLKDEV
> + string "block device identifier"
> + depends on PSTORE_BLK
> + default ""
> + help
> + Which block device should be used for pstore/blk.
> +
> + It accept the following variants:
> + 1) <hex_major><hex_minor> device number in hexadecimal represents
> + itself no leading 0x, for example b302.
itself with no leading 0x,
> + 2) /dev/<disk_name> represents the device number of disk
> + 3) /dev/<disk_name><decimal> represents the device number
> + of partition - device number of disk plus the partition number
> + 4) /dev/<disk_name>p<decimal> - same as the above, this form is
> + used when disk name of partitioned disk ends with a digit.
> + 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
> + unique id of a partition if the partition table provides it.
> + The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
> + partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
> + filled hex representation of the 32-bit "NT disk signature", and PP
> + is a zero-filled hex representation of the 1-based partition number.
> + 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation
> + to a partition with a known unique id.
> + 7) <major>:<minor> major and minor number of the device separated by
> + a colon.
--
~Randy
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 09/18] pstore/blk: Introduce backend for block devices
2020-05-11 15:36 ` Randy Dunlap
@ 2020-05-11 23:11 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:11 UTC (permalink / raw)
To: Randy Dunlap
Cc: WeiXiong Liao, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
On Mon, May 11, 2020 at 08:36:49AM -0700, Randy Dunlap wrote:
> On 5/10/20 1:24 PM, Kees Cook wrote:
> > diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> > index 98d2457bdd9f..92ba73bd0b62 100644
> > --- a/fs/pstore/Kconfig
> > +++ b/fs/pstore/Kconfig
> > @@ -160,3 +160,67 @@ config PSTORE_ZONE
> > help
> > The common layer for pstore/blk (and pstore/ram in the future)
> > to manage storage in zones.
> > +
> > +config PSTORE_BLK
> > + tristate "Log panic/oops to a block device"
> > + depends on PSTORE
> > + depends on BLOCK
> > + select PSTORE_ZONE
> > + default n
> > + help
> > + This enables panic and oops message to be logged to a block dev
> > + where it can be read back at some later point.
> > +
> > + If unsure, say N.
> > +
> > +config PSTORE_BLK_BLKDEV
> > + string "block device identifier"
> > + depends on PSTORE_BLK
> > + default ""
> > + help
> > + Which block device should be used for pstore/blk.
> > +
> > + It accept the following variants:
> > + 1) <hex_major><hex_minor> device number in hexadecimal represents
> > + itself no leading 0x, for example b302.
>
> itself with no leading 0x,
Yes, I've reworked the language here. Thanks!
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 10/18] pstore/zone,blk: Add support for pmsg frontend
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (8 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 09/18] pstore/blk: Introduce backend for block devices Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 8:36 ` WeiXiong Liao
2020-05-10 20:24 ` [PATCH v7 11/18] pstore/zone,blk: Add console frontend support Kees Cook
` (9 subsequent siblings)
19 siblings, 1 reply; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Add pmsg support to pstore/blk (through pstore/zone). To enable, pmsg_size
must be greater than 0 and a multiple of 4096.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-5-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/Kconfig | 12 ++
fs/pstore/blk.c | 9 ++
fs/pstore/zone.c | 269 ++++++++++++++++++++++++++++++++++--
include/linux/pstore_zone.h | 2 +
4 files changed, 282 insertions(+), 10 deletions(-)
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index 92ba73bd0b62..f18cd126d83f 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -224,3 +224,15 @@ config PSTORE_BLK_MAX_REASON
NOTE that, both Kconfig and module parameters can configure
pstore/blk, but module parameters have priority over Kconfig.
+
+config PSTORE_BLK_PMSG_SIZE
+ int "Size in Kbytes of pmsg to store"
+ depends on PSTORE_BLK
+ depends on PSTORE_PMSG
+ default 64
+ help
+ This just sets size of pmsg (pmsg_size) for pstore/blk. The size is
+ in KB and must be a multiple of 4.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index cec1fa261d1b..516a5f80d627 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -27,6 +27,14 @@ module_param(max_reason, int, 0400);
MODULE_PARM_DESC(max_reason,
"maximum reason for kmsg dump (default 2: Oops and Panic)");
+#if IS_ENABLED(CONFIG_PSTORE_PMSG)
+static long pmsg_size = CONFIG_PSTORE_BLK_PMSG_SIZE;
+#else
+static long pmsg_size = -1;
+#endif
+module_param(pmsg_size, long, 0400);
+MODULE_PARM_DESC(pmsg_size, "pmsg size in kbytes");
+
/*
* blkdev - the block device to use for pstore storage
*
@@ -132,6 +140,7 @@ static int psblk_register_do(struct pstore_device_info *dev)
}
verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
+ verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
#undef verify_size
pstore_zone_info->total_size = dev->total_size;
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
index a388c299ebb1..03dc87791c24 100644
--- a/fs/pstore/zone.c
+++ b/fs/pstore/zone.c
@@ -27,12 +27,14 @@
*
* @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value)
* @datalen: length of data in @data
+ * @start: offset into @data where the beginning of the stored bytes begin
* @data: zone data.
*/
struct psz_buffer {
#define PSZ_SIG (0x43474244) /* DBGC */
uint32_t sig;
atomic_t datalen;
+ atomic_t start;
uint8_t data[];
};
@@ -88,9 +90,11 @@ struct pstore_zone {
* struct psz_context - all about running state of pstore/zone
*
* @opszs: oops/panic storage zones
+ * @ppsz: pmsg storage zone
* @kmsg_max_cnt: max count of @opszs
* @kmsg_read_cnt: counter to read oops zone
* @kmsg_write_cnt: counter to write
+ * @pmsg_read_cnt: counter to read pmsg zone
* @oops_counter: counter to oops
* @panic_counter: counter to panic
* @recovered: whether finish recovering data from storage
@@ -101,9 +105,11 @@ struct pstore_zone {
*/
struct psz_context {
struct pstore_zone **opszs;
+ struct pstore_zone *ppsz;
unsigned int kmsg_max_cnt;
unsigned int kmsg_read_cnt;
unsigned int kmsg_write_cnt;
+ unsigned int pmsg_read_cnt;
/*
* the counter should be recovered when recover.
* It records the oops/panic times after burning rather than booting.
@@ -143,15 +149,20 @@ static inline int buffer_datalen(struct pstore_zone *zone)
return atomic_read(&zone->buffer->datalen);
}
+static inline int buffer_start(struct pstore_zone *zone)
+{
+ return atomic_read(&zone->buffer->start);
+}
+
static inline bool is_on_panic(void)
{
return atomic_read(&pstore_zone_cxt.on_panic);
}
-static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
+static ssize_t psz_zone_read_buffer(struct pstore_zone *zone, char *buf,
size_t len, unsigned long off)
{
- if (!buf || !zone->buffer)
+ if (!buf || !zone || !zone->buffer)
return -EINVAL;
if (off > zone->buffer_size)
return -EINVAL;
@@ -160,6 +171,18 @@ static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
return len;
}
+static int psz_zone_read_oldbuf(struct pstore_zone *zone, char *buf,
+ size_t len, unsigned long off)
+{
+ if (!buf || !zone || !zone->oldbuf)
+ return -EINVAL;
+ if (off > zone->buffer_size)
+ return -EINVAL;
+ len = min_t(size_t, len, zone->buffer_size - off);
+ memcpy(buf, zone->oldbuf->data + off, len);
+ return 0;
+}
+
static int psz_zone_write(struct pstore_zone *zone,
enum psz_flush_mode flush_mode, const char *buf,
size_t len, unsigned long off)
@@ -415,6 +438,93 @@ static int psz_kmsg_recover(struct psz_context *cxt)
return ret;
}
+static int psz_recover_zone(struct psz_context *cxt, struct pstore_zone *zone)
+{
+ struct pstore_zone_info *info = cxt->pstore_zone_info;
+ struct psz_buffer *oldbuf, tmpbuf;
+ int ret = 0;
+ char *buf;
+ ssize_t rcnt, len, start, off;
+
+ if (!zone || zone->oldbuf)
+ return 0;
+
+ if (is_on_panic()) {
+ /* save data as much as possible */
+ psz_flush_dirty_zone(zone);
+ return 0;
+ }
+
+ if (unlikely(!info->read))
+ return -EINVAL;
+
+ len = sizeof(struct psz_buffer);
+ rcnt = info->read((char *)&tmpbuf, len, zone->off);
+ if (rcnt != len) {
+ pr_debug("read zone %s failed\n", zone->name);
+ return (int)rcnt < 0 ? (int)rcnt : -EIO;
+ }
+
+ if (tmpbuf.sig != zone->buffer->sig) {
+ pr_debug("no valid data in zone %s\n", zone->name);
+ return 0;
+ }
+
+ if (zone->buffer_size < atomic_read(&tmpbuf.datalen) ||
+ zone->buffer_size < atomic_read(&tmpbuf.start)) {
+ pr_info("found overtop zone: %s: off %lld, size %zu\n",
+ zone->name, zone->off, zone->buffer_size);
+ /* just keep going */
+ return 0;
+ }
+
+ if (!atomic_read(&tmpbuf.datalen)) {
+ pr_debug("found erased zone: %s: off %lld, size %zu, datalen %d\n",
+ zone->name, zone->off, zone->buffer_size,
+ atomic_read(&tmpbuf.datalen));
+ return 0;
+ }
+
+ pr_debug("found nice zone: %s: off %lld, size %zu, datalen %d\n",
+ zone->name, zone->off, zone->buffer_size,
+ atomic_read(&tmpbuf.datalen));
+
+ len = atomic_read(&tmpbuf.datalen) + sizeof(*oldbuf);
+ oldbuf = kzalloc(len, GFP_KERNEL);
+ if (!oldbuf)
+ return -ENOMEM;
+
+ memcpy(oldbuf, &tmpbuf, sizeof(*oldbuf));
+ buf = (char *)oldbuf + sizeof(*oldbuf);
+ len = atomic_read(&oldbuf->datalen);
+ start = atomic_read(&oldbuf->start);
+ off = zone->off + sizeof(*oldbuf);
+
+ /* get part of data */
+ rcnt = info->read(buf, len - start, off + start);
+ if (rcnt != len - start) {
+ pr_err("read zone %s failed\n", zone->name);
+ ret = (int)rcnt < 0 ? (int)rcnt : -EIO;
+ goto free_oldbuf;
+ }
+
+ /* get the rest of data */
+ rcnt = info->read(buf + len - start, start, off);
+ if (rcnt != start) {
+ pr_err("read zone %s failed\n", zone->name);
+ ret = (int)rcnt < 0 ? (int)rcnt : -EIO;
+ goto free_oldbuf;
+ }
+
+ zone->oldbuf = oldbuf;
+ psz_flush_dirty_zone(zone);
+ return 0;
+
+free_oldbuf:
+ kfree(oldbuf);
+ return ret;
+}
+
/**
* psz_recovery() - recover data from storage
* @cxt: the context of pstore/zone
@@ -434,6 +544,10 @@ static inline int psz_recovery(struct psz_context *cxt)
if (ret)
goto recover_fail;
+ ret = psz_recover_zone(cxt, cxt->ppsz);
+ if (ret)
+ goto recover_fail;
+
pr_debug("recover end!\n");
atomic_set(&cxt->recovered, 1);
return 0;
@@ -448,9 +562,17 @@ static int psz_pstore_open(struct pstore_info *psi)
struct psz_context *cxt = psi->data;
cxt->kmsg_read_cnt = 0;
+ cxt->pmsg_read_cnt = 0;
return 0;
}
+static inline bool psz_old_ok(struct pstore_zone *zone)
+{
+ if (zone && zone->oldbuf && atomic_read(&zone->oldbuf->datalen))
+ return true;
+ return false;
+}
+
static inline bool psz_ok(struct pstore_zone *zone)
{
if (zone && zone->buffer && buffer_datalen(zone))
@@ -475,6 +597,25 @@ static inline int psz_kmsg_erase(struct psz_context *cxt,
return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
}
+static inline int psz_record_erase(struct psz_context *cxt,
+ struct pstore_zone *zone)
+{
+ if (unlikely(!psz_old_ok(zone)))
+ return 0;
+
+ kfree(zone->oldbuf);
+ zone->oldbuf = NULL;
+ /*
+ * if there are new data in zone buffer, that means the old data
+ * are already invalid. It is no need to flush 0 (erase) to
+ * block device.
+ */
+ if (!buffer_datalen(zone))
+ return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
+ psz_flush_dirty_zone(zone);
+ return 0;
+}
+
static int psz_pstore_erase(struct pstore_record *record)
{
struct psz_context *cxt = record->psi->data;
@@ -484,6 +625,8 @@ static int psz_pstore_erase(struct pstore_record *record)
if (record->id >= cxt->kmsg_max_cnt)
return -EINVAL;
return psz_kmsg_erase(cxt, cxt->opszs[record->id], record);
+ case PSTORE_TYPE_PMSG:
+ return psz_record_erase(cxt, cxt->ppsz);
default:
return -EINVAL;
}
@@ -504,8 +647,10 @@ static void psz_write_kmsg_hdr(struct pstore_zone *zone,
hdr->reason = record->reason;
if (hdr->reason == KMSG_DUMP_OOPS)
hdr->counter = ++cxt->oops_counter;
- else
+ else if (hdr->reason == KMSG_DUMP_PANIC)
hdr->counter = ++cxt->panic_counter;
+ else
+ hdr->counter = 0;
}
static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,
@@ -555,6 +700,53 @@ static int notrace psz_kmsg_write(struct psz_context *cxt,
return 0;
}
+static int notrace psz_record_write(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ size_t start, rem;
+ int cnt = record->size;
+ bool is_full_data = false;
+ char *buf = record->buf;
+
+ if (!zone || !record)
+ return -ENOSPC;
+
+ if (atomic_read(&zone->buffer->datalen) >= zone->buffer_size)
+ is_full_data = true;
+
+ if (unlikely(cnt > zone->buffer_size)) {
+ buf += cnt - zone->buffer_size;
+ cnt = zone->buffer_size;
+ }
+
+ start = buffer_start(zone);
+ rem = zone->buffer_size - start;
+ if (unlikely(rem < cnt)) {
+ psz_zone_write(zone, FLUSH_PART, buf, rem, start);
+ buf += rem;
+ cnt -= rem;
+ start = 0;
+ is_full_data = true;
+ }
+
+ atomic_set(&zone->buffer->start, cnt + start);
+ psz_zone_write(zone, FLUSH_PART, buf, cnt, start);
+
+ /**
+ * psz_zone_write will set datalen as start + cnt.
+ * It work if actual data length lesser than buffer size.
+ * If data length greater than buffer size, pmsg will rewrite to
+ * beginning of zone, which make buffer->datalen wrongly.
+ * So we should reset datalen as buffer size once actual data length
+ * greater than buffer size.
+ */
+ if (is_full_data) {
+ atomic_set(&zone->buffer->datalen, zone->buffer_size);
+ psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
+ }
+ return 0;
+}
+
static int notrace psz_pstore_write(struct pstore_record *record)
{
struct psz_context *cxt = record->psi->data;
@@ -566,6 +758,8 @@ static int notrace psz_pstore_write(struct pstore_record *record)
switch (record->type) {
case PSTORE_TYPE_DMESG:
return psz_kmsg_write(cxt, record);
+ case PSTORE_TYPE_PMSG:
+ return psz_record_write(cxt->ppsz, record);
default:
return -EINVAL;
}
@@ -581,6 +775,13 @@ static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
return zone;
}
+ if (cxt->pmsg_read_cnt == 0) {
+ cxt->pmsg_read_cnt++;
+ zone = cxt->ppsz;
+ if (psz_old_ok(zone))
+ return zone;
+ }
+
return NULL;
}
@@ -631,7 +832,7 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone,
return -ENOMEM;
}
- size = psz_zone_read(zone, record->buf + hlen, size,
+ size = psz_zone_read_buffer(zone, record->buf + hlen, size,
sizeof(struct psz_kmsg_header));
if (unlikely(size < 0)) {
kfree(record->buf);
@@ -641,6 +842,32 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone,
return size + hlen;
}
+static ssize_t psz_record_read(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ size_t len;
+ struct psz_buffer *buf;
+
+ if (!zone || !record)
+ return -ENOSPC;
+
+ buf = (struct psz_buffer *)zone->oldbuf;
+ if (!buf)
+ return -ENOMSG;
+
+ len = atomic_read(&buf->datalen);
+ record->buf = kmalloc(len, GFP_KERNEL);
+ if (!record->buf)
+ return -ENOMEM;
+
+ if (unlikely(psz_zone_read_oldbuf(zone, record->buf, len, 0))) {
+ kfree(record->buf);
+ return -ENOMSG;
+ }
+
+ return len;
+}
+
static ssize_t psz_pstore_read(struct pstore_record *record)
{
struct psz_context *cxt = record->psi->data;
@@ -665,6 +892,9 @@ static ssize_t psz_pstore_read(struct pstore_record *record)
readop = psz_kmsg_read;
record->id = cxt->kmsg_read_cnt - 1;
break;
+ case PSTORE_TYPE_PMSG:
+ readop = psz_record_read;
+ break;
default:
goto next_zone;
}
@@ -720,6 +950,8 @@ static void psz_free_all_zones(struct psz_context *cxt)
{
if (cxt->opszs)
psz_free_zones(&cxt->opszs, &cxt->kmsg_max_cnt);
+ if (cxt->ppsz)
+ psz_free_zone(&cxt->ppsz);
}
static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
@@ -753,8 +985,10 @@ static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
zone->type = type;
zone->buffer_size = size - sizeof(struct psz_buffer);
zone->buffer->sig = type ^ PSZ_SIG;
+ zone->oldbuf = NULL;
atomic_set(&zone->dirty, 0);
atomic_set(&zone->buffer->datalen, 0);
+ atomic_set(&zone->buffer->start, 0);
*off += size;
@@ -809,19 +1043,28 @@ static int psz_alloc_zones(struct psz_context *cxt)
struct pstore_zone_info *info = cxt->pstore_zone_info;
loff_t off = 0;
int err;
- size_t size;
+ size_t off_size = 0;
+
+ off_size += info->pmsg_size;
+ cxt->ppsz = psz_init_zone(PSTORE_TYPE_PMSG, &off, info->pmsg_size);
+ if (IS_ERR(cxt->ppsz)) {
+ err = PTR_ERR(cxt->ppsz);
+ cxt->ppsz = NULL;
+ goto free_out;
+ }
- size = info->total_size;
- cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, size,
+ cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off,
+ info->total_size - off_size,
info->kmsg_size, &cxt->kmsg_max_cnt);
if (IS_ERR(cxt->opszs)) {
err = PTR_ERR(cxt->opszs);
cxt->opszs = NULL;
- goto fail_out;
+ goto free_out;
}
return 0;
-fail_out:
+free_out:
+ psz_free_all_zones(cxt);
return err;
}
@@ -844,7 +1087,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
return -EINVAL;
}
- if (!info->kmsg_size) {
+ if (!info->kmsg_size && !info->pmsg_size) {
pr_warn("at least one record size must be non-zero\n");
return -EINVAL;
}
@@ -866,6 +1109,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
check_size(total_size, 4096);
check_size(kmsg_size, SECTOR_SIZE);
+ check_size(pmsg_size, SECTOR_SIZE);
#undef check_size
@@ -891,6 +1135,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
pr_debug("register %s with properties:\n", info->name);
pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
+ pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size);
err = psz_alloc_zones(cxt);
if (err) {
@@ -920,6 +1165,10 @@ int register_pstore_zone(struct pstore_zone_info *info)
pr_cont(",panic_write");
pr_cont(")");
}
+ if (info->pmsg_size) {
+ cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
+ pr_cont(" pmsg");
+ }
pr_cont("\n");
err = pstore_register(&cxt->pstore);
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
index eb005d9ae40c..29c367a3bd80 100644
--- a/include/linux/pstore_zone.h
+++ b/include/linux/pstore_zone.h
@@ -17,6 +17,7 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
* @kmsg_size: The size of oops/panic zone. Zero means disabled, otherwise,
* it must be multiple of SECTOR_SIZE(512 Bytes).
* @max_reason: Maximum kmsg dump reason to store.
+ * @pmsg_size: The size of pmsg zone which is the same as @kmsg_size.
* @read: The general read operation. Both of the function parameters
* @size and @offset are relative value to storage.
* On success, the number of bytes should be returned, others
@@ -33,6 +34,7 @@ struct pstore_zone_info {
unsigned long total_size;
unsigned long kmsg_size;
int max_reason;
+ unsigned long pmsg_size;
pstore_zone_read_op read;
pstore_zone_write_op write;
pstore_zone_write_op panic_write;
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 10/18] pstore/zone,blk: Add support for pmsg frontend
2020-05-10 20:24 ` [PATCH v7 10/18] pstore/zone,blk: Add support for pmsg frontend Kees Cook
@ 2020-05-11 8:36 ` WeiXiong Liao
0 siblings, 0 replies; 37+ messages in thread
From: WeiXiong Liao @ 2020-05-11 8:36 UTC (permalink / raw)
To: Kees Cook
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
hi Kees Cook,
On 2020/5/11 AM 4:24, Kees Cook wrote:
> From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
>
> Add pmsg support to pstore/blk (through pstore/zone). To enable, pmsg_size
> must be greater than 0 and a multiple of 4096.
>
> Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
> Link: https://lore.kernel.org/r/1585126506-18635-5-git-send-email-liaoweixiong@allwinnertech.com
> Signed-off-by: Kees Cook <keescook@chromium.org>
> ---
> fs/pstore/Kconfig | 12 ++
> fs/pstore/blk.c | 9 ++
> fs/pstore/zone.c | 269 ++++++++++++++++++++++++++++++++++--
> include/linux/pstore_zone.h | 2 +
> 4 files changed, 282 insertions(+), 10 deletions(-)
>
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index 92ba73bd0b62..f18cd126d83f 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -224,3 +224,15 @@ config PSTORE_BLK_MAX_REASON
>
> NOTE that, both Kconfig and module parameters can configure
> pstore/blk, but module parameters have priority over Kconfig.
> +
> +config PSTORE_BLK_PMSG_SIZE
> + int "Size in Kbytes of pmsg to store"
> + depends on PSTORE_BLK
> + depends on PSTORE_PMSG
> + default 64
> + help
> + This just sets size of pmsg (pmsg_size) for pstore/blk. The size is
> + in KB and must be a multiple of 4.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
> diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
> index cec1fa261d1b..516a5f80d627 100644
> --- a/fs/pstore/blk.c
> +++ b/fs/pstore/blk.c
> @@ -27,6 +27,14 @@ module_param(max_reason, int, 0400);
> MODULE_PARM_DESC(max_reason,
> "maximum reason for kmsg dump (default 2: Oops and Panic)");
>
> +#if IS_ENABLED(CONFIG_PSTORE_PMSG)
> +static long pmsg_size = CONFIG_PSTORE_BLK_PMSG_SIZE;
> +#else
> +static long pmsg_size = -1;
> +#endif
> +module_param(pmsg_size, long, 0400);
> +MODULE_PARM_DESC(pmsg_size, "pmsg size in kbytes");
> +
> /*
> * blkdev - the block device to use for pstore storage
> *
> @@ -132,6 +140,7 @@ static int psblk_register_do(struct pstore_device_info *dev)
> }
>
> verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
> + verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
> #undef verify_size
>
> pstore_zone_info->total_size = dev->total_size;
> diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
> index a388c299ebb1..03dc87791c24 100644
> --- a/fs/pstore/zone.c
> +++ b/fs/pstore/zone.c
> @@ -27,12 +27,14 @@
> *
> * @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value)
> * @datalen: length of data in @data
> + * @start: offset into @data where the beginning of the stored bytes begin
> * @data: zone data.
> */
> struct psz_buffer {
> #define PSZ_SIG (0x43474244) /* DBGC */
> uint32_t sig;
> atomic_t datalen;
> + atomic_t start;
> uint8_t data[];
> };
>
> @@ -88,9 +90,11 @@ struct pstore_zone {
> * struct psz_context - all about running state of pstore/zone
> *
> * @opszs: oops/panic storage zones
> + * @ppsz: pmsg storage zone
> * @kmsg_max_cnt: max count of @opszs
> * @kmsg_read_cnt: counter to read oops zone
> * @kmsg_write_cnt: counter to write
> + * @pmsg_read_cnt: counter to read pmsg zone
> * @oops_counter: counter to oops
> * @panic_counter: counter to panic
> * @recovered: whether finish recovering data from storage
> @@ -101,9 +105,11 @@ struct pstore_zone {
> */
> struct psz_context {
> struct pstore_zone **opszs;
> + struct pstore_zone *ppsz;
> unsigned int kmsg_max_cnt;
> unsigned int kmsg_read_cnt;
> unsigned int kmsg_write_cnt;
> + unsigned int pmsg_read_cnt;
> /*
> * the counter should be recovered when recover.
> * It records the oops/panic times after burning rather than booting.
> @@ -143,15 +149,20 @@ static inline int buffer_datalen(struct pstore_zone *zone)
> return atomic_read(&zone->buffer->datalen);
> }
>
> +static inline int buffer_start(struct pstore_zone *zone)
> +{
> + return atomic_read(&zone->buffer->start);
> +}
> +
> static inline bool is_on_panic(void)
> {
> return atomic_read(&pstore_zone_cxt.on_panic);
> }
>
> -static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
> +static ssize_t psz_zone_read_buffer(struct pstore_zone *zone, char *buf,
> size_t len, unsigned long off)
> {
> - if (!buf || !zone->buffer)
> + if (!buf || !zone || !zone->buffer)
> return -EINVAL;
> if (off > zone->buffer_size)
> return -EINVAL;
> @@ -160,6 +171,18 @@ static ssize_t psz_zone_read(struct pstore_zone *zone, char *buf,
> return len;
> }
>
> +static int psz_zone_read_oldbuf(struct pstore_zone *zone, char *buf,
> + size_t len, unsigned long off)
> +{
> + if (!buf || !zone || !zone->oldbuf)
> + return -EINVAL;
> + if (off > zone->buffer_size)
> + return -EINVAL;
> + len = min_t(size_t, len, zone->buffer_size - off);
> + memcpy(buf, zone->oldbuf->data + off, len);
> + return 0;
> +}
> +
> static int psz_zone_write(struct pstore_zone *zone,
> enum psz_flush_mode flush_mode, const char *buf,
> size_t len, unsigned long off)
> @@ -415,6 +438,93 @@ static int psz_kmsg_recover(struct psz_context *cxt)
> return ret;
> }
>
> +static int psz_recover_zone(struct psz_context *cxt, struct pstore_zone *zone)
> +{
> + struct pstore_zone_info *info = cxt->pstore_zone_info;
> + struct psz_buffer *oldbuf, tmpbuf;
> + int ret = 0;
> + char *buf;
> + ssize_t rcnt, len, start, off;
> +
> + if (!zone || zone->oldbuf)
> + return 0;
> +
> + if (is_on_panic()) {
> + /* save data as much as possible */
> + psz_flush_dirty_zone(zone);
> + return 0;
> + }
> +
> + if (unlikely(!info->read))
> + return -EINVAL;
> +
> + len = sizeof(struct psz_buffer);
> + rcnt = info->read((char *)&tmpbuf, len, zone->off);
> + if (rcnt != len) {
> + pr_debug("read zone %s failed\n", zone->name);
> + return (int)rcnt < 0 ? (int)rcnt : -EIO;
> + }
> +
> + if (tmpbuf.sig != zone->buffer->sig) {
> + pr_debug("no valid data in zone %s\n", zone->name);
> + return 0;
> + }
> +
> + if (zone->buffer_size < atomic_read(&tmpbuf.datalen) ||
> + zone->buffer_size < atomic_read(&tmpbuf.start)) {
> + pr_info("found overtop zone: %s: off %lld, size %zu\n",
> + zone->name, zone->off, zone->buffer_size);
> + /* just keep going */
> + return 0;
> + }
> +
> + if (!atomic_read(&tmpbuf.datalen)) {
> + pr_debug("found erased zone: %s: off %lld, size %zu, datalen %d\n",
> + zone->name, zone->off, zone->buffer_size,
> + atomic_read(&tmpbuf.datalen));
> + return 0;
> + }
> +
> + pr_debug("found nice zone: %s: off %lld, size %zu, datalen %d\n",
> + zone->name, zone->off, zone->buffer_size,
> + atomic_read(&tmpbuf.datalen));
> +
> + len = atomic_read(&tmpbuf.datalen) + sizeof(*oldbuf);
> + oldbuf = kzalloc(len, GFP_KERNEL);
> + if (!oldbuf)
> + return -ENOMEM;
> +
> + memcpy(oldbuf, &tmpbuf, sizeof(*oldbuf));
> + buf = (char *)oldbuf + sizeof(*oldbuf);
> + len = atomic_read(&oldbuf->datalen);
> + start = atomic_read(&oldbuf->start);
> + off = zone->off + sizeof(*oldbuf);
> +
> + /* get part of data */
> + rcnt = info->read(buf, len - start, off + start);
> + if (rcnt != len - start) {
> + pr_err("read zone %s failed\n", zone->name);
> + ret = (int)rcnt < 0 ? (int)rcnt : -EIO;
> + goto free_oldbuf;
> + }
> +
> + /* get the rest of data */
> + rcnt = info->read(buf + len - start, start, off);
> + if (rcnt != start) {
> + pr_err("read zone %s failed\n", zone->name);
> + ret = (int)rcnt < 0 ? (int)rcnt : -EIO;
> + goto free_oldbuf;
> + }
> +
> + zone->oldbuf = oldbuf;
> + psz_flush_dirty_zone(zone);
> + return 0;
> +
> +free_oldbuf:
> + kfree(oldbuf);
> + return ret;
> +}
> +
> /**
> * psz_recovery() - recover data from storage
> * @cxt: the context of pstore/zone
> @@ -434,6 +544,10 @@ static inline int psz_recovery(struct psz_context *cxt)
> if (ret)
> goto recover_fail;
>
> + ret = psz_recover_zone(cxt, cxt->ppsz);
> + if (ret)
> + goto recover_fail;
> +
> pr_debug("recover end!\n");
> atomic_set(&cxt->recovered, 1);
> return 0;
> @@ -448,9 +562,17 @@ static int psz_pstore_open(struct pstore_info *psi)
> struct psz_context *cxt = psi->data;
>
> cxt->kmsg_read_cnt = 0;
> + cxt->pmsg_read_cnt = 0;
> return 0;
> }
>
> +static inline bool psz_old_ok(struct pstore_zone *zone)
> +{
> + if (zone && zone->oldbuf && atomic_read(&zone->oldbuf->datalen))
> + return true;
> + return false;
> +}
> +
> static inline bool psz_ok(struct pstore_zone *zone)
> {
> if (zone && zone->buffer && buffer_datalen(zone))
> @@ -475,6 +597,25 @@ static inline int psz_kmsg_erase(struct psz_context *cxt,
> return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
> }
>
> +static inline int psz_record_erase(struct psz_context *cxt,
> + struct pstore_zone *zone)
> +{
> + if (unlikely(!psz_old_ok(zone)))
> + return 0;
> +
> + kfree(zone->oldbuf);
> + zone->oldbuf = NULL;
> + /*
> + * if there are new data in zone buffer, that means the old data
> + * are already invalid. It is no need to flush 0 (erase) to
> + * block device.
> + */
> + if (!buffer_datalen(zone))
> + return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
> + psz_flush_dirty_zone(zone);
> + return 0;
> +}
> +
> static int psz_pstore_erase(struct pstore_record *record)
> {
> struct psz_context *cxt = record->psi->data;
> @@ -484,6 +625,8 @@ static int psz_pstore_erase(struct pstore_record *record)
> if (record->id >= cxt->kmsg_max_cnt)
> return -EINVAL;
> return psz_kmsg_erase(cxt, cxt->opszs[record->id], record);
> + case PSTORE_TYPE_PMSG:
> + return psz_record_erase(cxt, cxt->ppsz);
> default:
> return -EINVAL;
> }
> @@ -504,8 +647,10 @@ static void psz_write_kmsg_hdr(struct pstore_zone *zone,
> hdr->reason = record->reason;
> if (hdr->reason == KMSG_DUMP_OOPS)
> hdr->counter = ++cxt->oops_counter;
> - else
> + else if (hdr->reason == KMSG_DUMP_PANIC)
> hdr->counter = ++cxt->panic_counter;
> + else
> + hdr->counter = 0;
I think
This difference should move to first patch to support
> }
>
> static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,
> @@ -555,6 +700,53 @@ static int notrace psz_kmsg_write(struct psz_context *cxt,
> return 0;
> }
>
> +static int notrace psz_record_write(struct pstore_zone *zone,
> + struct pstore_record *record)
> +{
> + size_t start, rem;
> + int cnt = record->size;
> + bool is_full_data = false;
> + char *buf = record->buf;
> +
> + if (!zone || !record)
> + return -ENOSPC;
> +
> + if (atomic_read(&zone->buffer->datalen) >= zone->buffer_size)
> + is_full_data = true;
> +
> + if (unlikely(cnt > zone->buffer_size)) {
> + buf += cnt - zone->buffer_size;
> + cnt = zone->buffer_size;
> + }
> +
> + start = buffer_start(zone);
> + rem = zone->buffer_size - start;
> + if (unlikely(rem < cnt)) {
> + psz_zone_write(zone, FLUSH_PART, buf, rem, start);
> + buf += rem;
> + cnt -= rem;
> + start = 0;
> + is_full_data = true;
> + }
> +
> + atomic_set(&zone->buffer->start, cnt + start);
> + psz_zone_write(zone, FLUSH_PART, buf, cnt, start);
> +
> + /**
> + * psz_zone_write will set datalen as start + cnt.
> + * It work if actual data length lesser than buffer size.
> + * If data length greater than buffer size, pmsg will rewrite to
> + * beginning of zone, which make buffer->datalen wrongly.
> + * So we should reset datalen as buffer size once actual data length
> + * greater than buffer size.
> + */
> + if (is_full_data) {
> + atomic_set(&zone->buffer->datalen, zone->buffer_size);
> + psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
> + }
> + return 0;
> +}
> +
> static int notrace psz_pstore_write(struct pstore_record *record)
> {
> struct psz_context *cxt = record->psi->data;
> @@ -566,6 +758,8 @@ static int notrace psz_pstore_write(struct pstore_record *record)
> switch (record->type) {
> case PSTORE_TYPE_DMESG:
> return psz_kmsg_write(cxt, record);
> + case PSTORE_TYPE_PMSG:
> + return psz_record_write(cxt->ppsz, record);
> default:
> return -EINVAL;
> }
> @@ -581,6 +775,13 @@ static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
> return zone;
> }
>
> + if (cxt->pmsg_read_cnt == 0) {
> + cxt->pmsg_read_cnt++;
> + zone = cxt->ppsz;
> + if (psz_old_ok(zone))
> + return zone;
> + }
> +
> return NULL;
> }
>
> @@ -631,7 +832,7 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone,
> return -ENOMEM;
> }
>
> - size = psz_zone_read(zone, record->buf + hlen, size,
> + size = psz_zone_read_buffer(zone, record->buf + hlen, size,
> sizeof(struct psz_kmsg_header));
> if (unlikely(size < 0)) {
> kfree(record->buf);
> @@ -641,6 +842,32 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone,
> return size + hlen;
> }
>
> +static ssize_t psz_record_read(struct pstore_zone *zone,
> + struct pstore_record *record)
> +{
> + size_t len;
> + struct psz_buffer *buf;
> +
> + if (!zone || !record)
> + return -ENOSPC;
> +
> + buf = (struct psz_buffer *)zone->oldbuf;
> + if (!buf)
> + return -ENOMSG;
> +
> + len = atomic_read(&buf->datalen);
> + record->buf = kmalloc(len, GFP_KERNEL);
> + if (!record->buf)
> + return -ENOMEM;
> +
> + if (unlikely(psz_zone_read_oldbuf(zone, record->buf, len, 0))) {
> + kfree(record->buf);
> + return -ENOMSG;
> + }
> +
> + return len;
> +}
> +
> static ssize_t psz_pstore_read(struct pstore_record *record)
> {
> struct psz_context *cxt = record->psi->data;
> @@ -665,6 +892,9 @@ static ssize_t psz_pstore_read(struct pstore_record *record)
> readop = psz_kmsg_read;
> record->id = cxt->kmsg_read_cnt - 1;
> break;
> + case PSTORE_TYPE_PMSG:
> + readop = psz_record_read;
> + break;
> default:
> goto next_zone;
> }
> @@ -720,6 +950,8 @@ static void psz_free_all_zones(struct psz_context *cxt)
> {
> if (cxt->opszs)
> psz_free_zones(&cxt->opszs, &cxt->kmsg_max_cnt);
> + if (cxt->ppsz)
> + psz_free_zone(&cxt->ppsz);
> }
>
> static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
> @@ -753,8 +985,10 @@ static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
> zone->type = type;
> zone->buffer_size = size - sizeof(struct psz_buffer);
> zone->buffer->sig = type ^ PSZ_SIG;
> + zone->oldbuf = NULL;
> atomic_set(&zone->dirty, 0);
> atomic_set(&zone->buffer->datalen, 0);
> + atomic_set(&zone->buffer->start, 0);
>
> *off += size;
>
> @@ -809,19 +1043,28 @@ static int psz_alloc_zones(struct psz_context *cxt)
> struct pstore_zone_info *info = cxt->pstore_zone_info;
> loff_t off = 0;
> int err;
> - size_t size;
> + size_t off_size = 0;
> +
> + off_size += info->pmsg_size;
> + cxt->ppsz = psz_init_zone(PSTORE_TYPE_PMSG, &off, info->pmsg_size);
> + if (IS_ERR(cxt->ppsz)) {
> + err = PTR_ERR(cxt->ppsz);
> + cxt->ppsz = NULL;
> + goto free_out;
> + }
>
> - size = info->total_size;
> - cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, size,
> + cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off,
> + info->total_size - off_size,
> info->kmsg_size, &cxt->kmsg_max_cnt);
> if (IS_ERR(cxt->opszs)) {
> err = PTR_ERR(cxt->opszs);
> cxt->opszs = NULL;
> - goto fail_out;
> + goto free_out;
> }
>
> return 0;
> -fail_out:
> +free_out:
> + psz_free_all_zones(cxt);
> return err;
> }
>
> @@ -844,7 +1087,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
> return -EINVAL;
> }
>
> - if (!info->kmsg_size) {
> + if (!info->kmsg_size && !info->pmsg_size) {
> pr_warn("at least one record size must be non-zero\n");
> return -EINVAL;
> }
> @@ -866,6 +1109,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
>
> check_size(total_size, 4096);
> check_size(kmsg_size, SECTOR_SIZE);
> + check_size(pmsg_size, SECTOR_SIZE);
>
> #undef check_size
>
> @@ -891,6 +1135,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
> pr_debug("register %s with properties:\n", info->name);
> pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
> pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
> + pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size);
>
> err = psz_alloc_zones(cxt);
> if (err) {
> @@ -920,6 +1165,10 @@ int register_pstore_zone(struct pstore_zone_info *info)
> pr_cont(",panic_write");
> pr_cont(")");
> }
> + if (info->pmsg_size) {
> + cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
> + pr_cont(" pmsg");
> + }
> pr_cont("\n");
>
> err = pstore_register(&cxt->pstore);
> diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
> index eb005d9ae40c..29c367a3bd80 100644
> --- a/include/linux/pstore_zone.h
> +++ b/include/linux/pstore_zone.h
> @@ -17,6 +17,7 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
> * @kmsg_size: The size of oops/panic zone. Zero means disabled, otherwise,
> * it must be multiple of SECTOR_SIZE(512 Bytes).
> * @max_reason: Maximum kmsg dump reason to store.
> + * @pmsg_size: The size of pmsg zone which is the same as @kmsg_size.
> * @read: The general read operation. Both of the function parameters
> * @size and @offset are relative value to storage.
> * On success, the number of bytes should be returned, others
> @@ -33,6 +34,7 @@ struct pstore_zone_info {
> unsigned long total_size;
> unsigned long kmsg_size;
> int max_reason;
> + unsigned long pmsg_size;
> pstore_zone_read_op read;
> pstore_zone_write_op write;
> pstore_zone_write_op panic_write;
>
--
WeiXiong Liao
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 11/18] pstore/zone,blk: Add console frontend support
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (9 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 10/18] pstore/zone,blk: Add support for pmsg frontend Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 15:38 ` Randy Dunlap
2020-05-10 20:24 ` [PATCH v7 12/18] pstore/zone,blk: Add ftrace " Kees Cook
` (8 subsequent siblings)
19 siblings, 1 reply; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Support backend for console. To enable console backend, just make
console_size be greater than 0 and a multiple of 4096.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-6-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/Kconfig | 12 ++++++
fs/pstore/blk.c | 12 +++++-
fs/pstore/zone.c | 83 ++++++++++++++++++++++++++++++++++---
include/linux/pstore_zone.h | 4 +-
4 files changed, 103 insertions(+), 8 deletions(-)
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index f18cd126d83f..f1484f751c5e 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -236,3 +236,15 @@ config PSTORE_BLK_PMSG_SIZE
NOTE that, both Kconfig and module parameters can configure
pstore/blk, but module parameters have priority over Kconfig.
+
+config PSTORE_BLK_CONSOLE_SIZE
+ int "Size in Kbytes of console to store"
+ depends on PSTORE_BLK
+ depends on PSTORE_CONSOLE
+ default 64
+ help
+ This just sets size of console (console_size) for pstore/blk. The
+ size is in KB and must be a multiple of 4.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index 516a5f80d627..145e00bd7de9 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -35,6 +35,14 @@ static long pmsg_size = -1;
module_param(pmsg_size, long, 0400);
MODULE_PARM_DESC(pmsg_size, "pmsg size in kbytes");
+#if IS_ENABLED(CONFIG_PSTORE_CONSOLE)
+static long console_size = CONFIG_PSTORE_BLK_CONSOLE_SIZE;
+#else
+static long console_size = -1;
+#endif
+module_param(console_size, long, 0400);
+MODULE_PARM_DESC(console_size, "console size in kbytes");
+
/*
* blkdev - the block device to use for pstore storage
*
@@ -90,7 +98,8 @@ static struct bdev_info {
* whole disk).
* On success, the number of bytes should be returned, others
* means error.
- * @write: The same as @read.
+ * @write: The same as @read, but the following error number:
+ * -EBUSY means try to write again later.
* @panic_write:The write operation only used for panic case. It's optional
* if you do not care panic log. The parameters and return value
* are the same as @read.
@@ -141,6 +150,7 @@ static int psblk_register_do(struct pstore_device_info *dev)
verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
+ verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
#undef verify_size
pstore_zone_info->total_size = dev->total_size;
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
index 03dc87791c24..f3bd6a7dc06d 100644
--- a/fs/pstore/zone.c
+++ b/fs/pstore/zone.c
@@ -91,10 +91,12 @@ struct pstore_zone {
*
* @opszs: oops/panic storage zones
* @ppsz: pmsg storage zone
+ * @cpsz: console storage zone
* @kmsg_max_cnt: max count of @opszs
* @kmsg_read_cnt: counter to read oops zone
* @kmsg_write_cnt: counter to write
* @pmsg_read_cnt: counter to read pmsg zone
+ * @console_read_cnt: counter to read console zone
* @oops_counter: counter to oops
* @panic_counter: counter to panic
* @recovered: whether finish recovering data from storage
@@ -106,10 +108,12 @@ struct pstore_zone {
struct psz_context {
struct pstore_zone **opszs;
struct pstore_zone *ppsz;
+ struct pstore_zone *cpsz;
unsigned int kmsg_max_cnt;
unsigned int kmsg_read_cnt;
unsigned int kmsg_write_cnt;
unsigned int pmsg_read_cnt;
+ unsigned int console_read_cnt;
/*
* the counter should be recovered when recover.
* It records the oops/panic times after burning rather than booting.
@@ -129,6 +133,9 @@ struct psz_context {
};
static struct psz_context pstore_zone_cxt;
+static void psz_flush_all_dirty_zones(struct work_struct *);
+static DECLARE_DELAYED_WORK(psz_cleaner, psz_flush_all_dirty_zones);
+
/**
* enum psz_flush_mode - flush mode for psz_zone_write()
*
@@ -237,6 +244,9 @@ static int psz_zone_write(struct pstore_zone *zone,
return 0;
dirty:
atomic_set(&zone->dirty, true);
+ /* flush dirty zones nicely */
+ if (wcnt == -EBUSY && !is_on_panic())
+ schedule_delayed_work(&psz_cleaner, msecs_to_jiffies(500));
return -EBUSY;
}
@@ -293,6 +303,21 @@ static int psz_move_zone(struct pstore_zone *old, struct pstore_zone *new)
return 0;
}
+static void psz_flush_all_dirty_zones(struct work_struct *work)
+{
+ struct psz_context *cxt = &pstore_zone_cxt;
+ int ret = 0;
+
+ if (cxt->ppsz)
+ ret |= psz_flush_dirty_zone(cxt->ppsz);
+ if (cxt->cpsz)
+ ret |= psz_flush_dirty_zone(cxt->cpsz);
+ if (cxt->opszs)
+ ret |= psz_flush_dirty_zones(cxt->opszs, cxt->kmsg_max_cnt);
+ if (ret && cxt->pstore_zone_info)
+ schedule_delayed_work(&psz_cleaner, msecs_to_jiffies(1000));
+}
+
static int psz_kmsg_recover_data(struct psz_context *cxt)
{
struct pstore_zone_info *info = cxt->pstore_zone_info;
@@ -548,6 +573,10 @@ static inline int psz_recovery(struct psz_context *cxt)
if (ret)
goto recover_fail;
+ ret = psz_recover_zone(cxt, cxt->cpsz);
+ if (ret)
+ goto recover_fail;
+
pr_debug("recover end!\n");
atomic_set(&cxt->recovered, 1);
return 0;
@@ -563,6 +592,7 @@ static int psz_pstore_open(struct pstore_info *psi)
cxt->kmsg_read_cnt = 0;
cxt->pmsg_read_cnt = 0;
+ cxt->console_read_cnt = 0;
return 0;
}
@@ -627,8 +657,9 @@ static int psz_pstore_erase(struct pstore_record *record)
return psz_kmsg_erase(cxt, cxt->opszs[record->id], record);
case PSTORE_TYPE_PMSG:
return psz_record_erase(cxt, cxt->ppsz);
- default:
- return -EINVAL;
+ case PSTORE_TYPE_CONSOLE:
+ return psz_record_erase(cxt, cxt->cpsz);
+ default: return -EINVAL;
}
}
@@ -691,9 +722,10 @@ static int notrace psz_kmsg_write(struct psz_context *cxt,
return -ENOSPC;
ret = psz_kmsg_write_record(cxt, record);
- if (!ret) {
- pr_debug("try to flush other dirty oops zones\n");
- psz_flush_dirty_zones(cxt->opszs, cxt->kmsg_max_cnt);
+ if (!ret && is_on_panic()) {
+ /* ensure all data are flushed to storage when panic */
+ pr_debug("try to flush other dirty zones\n");
+ psz_flush_all_dirty_zones(NULL);
}
/* always return 0 as we had handled it on buffer */
@@ -755,9 +787,18 @@ static int notrace psz_pstore_write(struct pstore_record *record)
record->reason == KMSG_DUMP_PANIC)
atomic_set(&cxt->on_panic, 1);
+ /*
+ * if on panic, do not write except panic records
+ * Fix case that panic_write prints log which wakes up console backend.
+ */
+ if (is_on_panic() && record->type != PSTORE_TYPE_DMESG)
+ return -EBUSY;
+
switch (record->type) {
case PSTORE_TYPE_DMESG:
return psz_kmsg_write(cxt, record);
+ case PSTORE_TYPE_CONSOLE:
+ return psz_record_write(cxt->cpsz, record);
case PSTORE_TYPE_PMSG:
return psz_record_write(cxt->ppsz, record);
default:
@@ -782,6 +823,13 @@ static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
return zone;
}
+ if (cxt->console_read_cnt == 0) {
+ cxt->console_read_cnt++;
+ zone = cxt->cpsz;
+ if (psz_old_ok(zone))
+ return zone;
+ }
+
return NULL;
}
@@ -892,6 +940,8 @@ static ssize_t psz_pstore_read(struct pstore_record *record)
readop = psz_kmsg_read;
record->id = cxt->kmsg_read_cnt - 1;
break;
+ case PSTORE_TYPE_CONSOLE:
+ fallthrough;
case PSTORE_TYPE_PMSG:
readop = psz_record_read;
break;
@@ -952,6 +1002,8 @@ static void psz_free_all_zones(struct psz_context *cxt)
psz_free_zones(&cxt->opszs, &cxt->kmsg_max_cnt);
if (cxt->ppsz)
psz_free_zone(&cxt->ppsz);
+ if (cxt->cpsz)
+ psz_free_zone(&cxt->cpsz);
}
static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
@@ -1053,6 +1105,15 @@ static int psz_alloc_zones(struct psz_context *cxt)
goto free_out;
}
+ off_size += info->console_size;
+ cxt->cpsz = psz_init_zone(PSTORE_TYPE_CONSOLE, &off,
+ info->console_size);
+ if (IS_ERR(cxt->cpsz)) {
+ err = PTR_ERR(cxt->cpsz);
+ cxt->cpsz = NULL;
+ goto free_out;
+ }
+
cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off,
info->total_size - off_size,
info->kmsg_size, &cxt->kmsg_max_cnt);
@@ -1087,7 +1148,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
return -EINVAL;
}
- if (!info->kmsg_size && !info->pmsg_size) {
+ if (!info->kmsg_size && !info->pmsg_size && !info->console_size) {
pr_warn("at least one record size must be non-zero\n");
return -EINVAL;
}
@@ -1110,6 +1171,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
check_size(total_size, 4096);
check_size(kmsg_size, SECTOR_SIZE);
check_size(pmsg_size, SECTOR_SIZE);
+ check_size(console_size, SECTOR_SIZE);
#undef check_size
@@ -1136,6 +1198,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size);
+ pr_debug("\tconsole size : %ld Bytes\n", info->console_size);
err = psz_alloc_zones(cxt);
if (err) {
@@ -1169,6 +1232,10 @@ int register_pstore_zone(struct pstore_zone_info *info)
cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
pr_cont(" pmsg");
}
+ if (info->console_size) {
+ cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE;
+ pr_cont(" console");
+ }
pr_cont("\n");
err = pstore_register(&cxt->pstore);
@@ -1210,6 +1277,10 @@ void unregister_pstore_zone(struct pstore_zone_info *info)
/* Stop incoming writes from pstore. */
pstore_unregister(&cxt->pstore);
+ /* Flush any pending writes. */
+ psz_flush_all_dirty_zones(NULL);
+ flush_delayed_work(&psz_cleaner);
+
/* Clean up allocations. */
kfree(cxt->pstore.buf);
cxt->pstore.buf = NULL;
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
index 29c367a3bd80..904ee67f4ba2 100644
--- a/include/linux/pstore_zone.h
+++ b/include/linux/pstore_zone.h
@@ -18,11 +18,12 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
* it must be multiple of SECTOR_SIZE(512 Bytes).
* @max_reason: Maximum kmsg dump reason to store.
* @pmsg_size: The size of pmsg zone which is the same as @kmsg_size.
+ * @console_size:The size of console zone which is the same as @kmsg_size.
* @read: The general read operation. Both of the function parameters
* @size and @offset are relative value to storage.
* On success, the number of bytes should be returned, others
* means error.
- * @write: The same as @read.
+ * @write: The same as @read, but -EBUSY means try to write again later.
* @panic_write:The write operation only used for panic case. It's optional
* if you do not care panic log. The parameters and return value
* are the same as @read.
@@ -35,6 +36,7 @@ struct pstore_zone_info {
unsigned long kmsg_size;
int max_reason;
unsigned long pmsg_size;
+ unsigned long console_size;
pstore_zone_read_op read;
pstore_zone_write_op write;
pstore_zone_write_op panic_write;
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 11/18] pstore/zone,blk: Add console frontend support
2020-05-10 20:24 ` [PATCH v7 11/18] pstore/zone,blk: Add console frontend support Kees Cook
@ 2020-05-11 15:38 ` Randy Dunlap
2020-05-11 23:14 ` Kees Cook
0 siblings, 1 reply; 37+ messages in thread
From: Randy Dunlap @ 2020-05-11 15:38 UTC (permalink / raw)
To: Kees Cook, WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On 5/10/20 1:24 PM, Kees Cook wrote:
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index f18cd126d83f..f1484f751c5e 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -236,3 +236,15 @@ config PSTORE_BLK_PMSG_SIZE
>
> NOTE that, both Kconfig and module parameters can configure
> pstore/blk, but module parameters have priority over Kconfig.
> +
> +config PSTORE_BLK_CONSOLE_SIZE
> + int "Size in Kbytes of console to store"
maybe of console log to store"
since my console size is not measured in Kbytes.
> + depends on PSTORE_BLK
> + depends on PSTORE_CONSOLE
> + default 64
> + help
> + This just sets size of console (console_size) for pstore/blk. The
console log
> + size is in KB and must be a multiple of 4.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
--
~Randy
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 11/18] pstore/zone,blk: Add console frontend support
2020-05-11 15:38 ` Randy Dunlap
@ 2020-05-11 23:14 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:14 UTC (permalink / raw)
To: Randy Dunlap
Cc: WeiXiong Liao, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
On Mon, May 11, 2020 at 08:38:32AM -0700, Randy Dunlap wrote:
> On 5/10/20 1:24 PM, Kees Cook wrote:
> > diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> > index f18cd126d83f..f1484f751c5e 100644
> > --- a/fs/pstore/Kconfig
> > +++ b/fs/pstore/Kconfig
> > @@ -236,3 +236,15 @@ config PSTORE_BLK_PMSG_SIZE
> >
> > NOTE that, both Kconfig and module parameters can configure
> > pstore/blk, but module parameters have priority over Kconfig.
> > +
> > +config PSTORE_BLK_CONSOLE_SIZE
> > + int "Size in Kbytes of console to store"
>
> maybe of console log to store"
>
> since my console size is not measured in Kbytes.
>
> > + depends on PSTORE_BLK
> > + depends on PSTORE_CONSOLE
> > + default 64
> > + help
> > + This just sets size of console (console_size) for pstore/blk. The
>
> console log
>
> > + size is in KB and must be a multiple of 4.
> > +
> > + NOTE that, both Kconfig and module parameters can configure
> > + pstore/blk, but module parameters have priority over Kconfig.
Good points! I've fixed this and a typo in the ftrace Kconfig help.
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 12/18] pstore/zone,blk: Add ftrace frontend support
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (10 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 11/18] pstore/zone,blk: Add console frontend support Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 15:37 ` Randy Dunlap
2020-05-10 20:24 ` [PATCH v7 13/18] Documentation: Add details for pstore/blk Kees Cook
` (7 subsequent siblings)
19 siblings, 1 reply; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Support backend for ftrace. To enable ftrace backend, just make
ftrace_size be greater than 0 and a multiple of 4096.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-7-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/Kconfig | 12 ++++
fs/pstore/blk.c | 9 +++
fs/pstore/zone.c | 113 +++++++++++++++++++++++++++++++++++-
include/linux/pstore_zone.h | 2 +
4 files changed, 135 insertions(+), 1 deletion(-)
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index f1484f751c5e..16a0440d8d5a 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -248,3 +248,15 @@ config PSTORE_BLK_CONSOLE_SIZE
NOTE that, both Kconfig and module parameters can configure
pstore/blk, but module parameters have priority over Kconfig.
+
+config PSTORE_BLK_FTRACE_SIZE
+ int "Size in Kbytes of ftarce to store"
+ depends on PSTORE_BLK
+ depends on PSTORE_FTRACE
+ default 64
+ help
+ This just sets size of ftrace (ftrace_size) for pstore/blk. The
+ size is in KB and must be a multiple of 4.
+
+ NOTE that, both Kconfig and module parameters can configure
+ pstore/blk, but module parameters have priority over Kconfig.
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index 145e00bd7de9..e45937e3517c 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -43,6 +43,14 @@ static long console_size = -1;
module_param(console_size, long, 0400);
MODULE_PARM_DESC(console_size, "console size in kbytes");
+#if IS_ENABLED(CONFIG_PSTORE_FTRACE)
+static long ftrace_size = CONFIG_PSTORE_BLK_FTRACE_SIZE;
+#else
+static long ftrace_size = -1;
+#endif
+module_param(ftrace_size, long, 0400);
+MODULE_PARM_DESC(ftrace_size, "ftrace size in kbytes");
+
/*
* blkdev - the block device to use for pstore storage
*
@@ -151,6 +159,7 @@ static int psblk_register_do(struct pstore_device_info *dev)
verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
+ verify_size(ftrace_size, 4096, dev->flags & PSTORE_FLAGS_FTRACE);
#undef verify_size
pstore_zone_info->total_size = dev->total_size;
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
index f3bd6a7dc06d..45c0a422f1de 100644
--- a/fs/pstore/zone.c
+++ b/fs/pstore/zone.c
@@ -92,11 +92,14 @@ struct pstore_zone {
* @opszs: oops/panic storage zones
* @ppsz: pmsg storage zone
* @cpsz: console storage zone
+ * @fpszs: ftrace storage zones
* @kmsg_max_cnt: max count of @opszs
* @kmsg_read_cnt: counter to read oops zone
* @kmsg_write_cnt: counter to write
* @pmsg_read_cnt: counter to read pmsg zone
* @console_read_cnt: counter to read console zone
+ * @ftrace_max_cnt: max count of @fpszs
+ * @ftrace_read_cnt: counter to read ftrace zone
* @oops_counter: counter to oops
* @panic_counter: counter to panic
* @recovered: whether finish recovering data from storage
@@ -109,11 +112,14 @@ struct psz_context {
struct pstore_zone **opszs;
struct pstore_zone *ppsz;
struct pstore_zone *cpsz;
+ struct pstore_zone **fpszs;
unsigned int kmsg_max_cnt;
unsigned int kmsg_read_cnt;
unsigned int kmsg_write_cnt;
unsigned int pmsg_read_cnt;
unsigned int console_read_cnt;
+ unsigned int ftrace_max_cnt;
+ unsigned int ftrace_read_cnt;
/*
* the counter should be recovered when recover.
* It records the oops/panic times after burning rather than booting.
@@ -314,6 +320,8 @@ static void psz_flush_all_dirty_zones(struct work_struct *work)
ret |= psz_flush_dirty_zone(cxt->cpsz);
if (cxt->opszs)
ret |= psz_flush_dirty_zones(cxt->opszs, cxt->kmsg_max_cnt);
+ if (cxt->fpszs)
+ ret |= psz_flush_dirty_zones(cxt->fpszs, cxt->ftrace_max_cnt);
if (ret && cxt->pstore_zone_info)
schedule_delayed_work(&psz_cleaner, msecs_to_jiffies(1000));
}
@@ -550,6 +558,31 @@ static int psz_recover_zone(struct psz_context *cxt, struct pstore_zone *zone)
return ret;
}
+static int psz_recover_zones(struct psz_context *cxt,
+ struct pstore_zone **zones, unsigned int cnt)
+{
+ int ret;
+ unsigned int i;
+ struct pstore_zone *zone;
+
+ if (!zones)
+ return 0;
+
+ for (i = 0; i < cnt; i++) {
+ zone = zones[i];
+ if (unlikely(!zone))
+ continue;
+ ret = psz_recover_zone(cxt, zone);
+ if (ret)
+ goto recover_fail;
+ }
+
+ return 0;
+recover_fail:
+ pr_debug("recover %s[%u] failed\n", zone->name, i);
+ return ret;
+}
+
/**
* psz_recovery() - recover data from storage
* @cxt: the context of pstore/zone
@@ -577,6 +610,10 @@ static inline int psz_recovery(struct psz_context *cxt)
if (ret)
goto recover_fail;
+ ret = psz_recover_zones(cxt, cxt->fpszs, cxt->ftrace_max_cnt);
+ if (ret)
+ goto recover_fail;
+
pr_debug("recover end!\n");
atomic_set(&cxt->recovered, 1);
return 0;
@@ -593,6 +630,7 @@ static int psz_pstore_open(struct pstore_info *psi)
cxt->kmsg_read_cnt = 0;
cxt->pmsg_read_cnt = 0;
cxt->console_read_cnt = 0;
+ cxt->ftrace_read_cnt = 0;
return 0;
}
@@ -659,6 +697,10 @@ static int psz_pstore_erase(struct pstore_record *record)
return psz_record_erase(cxt, cxt->ppsz);
case PSTORE_TYPE_CONSOLE:
return psz_record_erase(cxt, cxt->cpsz);
+ case PSTORE_TYPE_FTRACE:
+ if (record->id >= cxt->ftrace_max_cnt)
+ return -EINVAL;
+ return psz_record_erase(cxt, cxt->fpszs[record->id]);
default: return -EINVAL;
}
}
@@ -801,6 +843,13 @@ static int notrace psz_pstore_write(struct pstore_record *record)
return psz_record_write(cxt->cpsz, record);
case PSTORE_TYPE_PMSG:
return psz_record_write(cxt->ppsz, record);
+ case PSTORE_TYPE_FTRACE: {
+ int zonenum = smp_processor_id();
+
+ if (!cxt->fpszs)
+ return -ENOSPC;
+ return psz_record_write(cxt->fpszs[zonenum], record);
+ }
default:
return -EINVAL;
}
@@ -816,6 +865,14 @@ static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt)
return zone;
}
+ if (cxt->ftrace_read_cnt < cxt->ftrace_max_cnt)
+ /*
+ * No need psz_old_ok(). Let psz_ftrace_read() do so for
+ * combination. psz_ftrace_read() should traverse over
+ * all zones in case of some zone without data.
+ */
+ return cxt->fpszs[cxt->ftrace_read_cnt++];
+
if (cxt->pmsg_read_cnt == 0) {
cxt->pmsg_read_cnt++;
zone = cxt->ppsz;
@@ -890,6 +947,37 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone,
return size + hlen;
}
+/* try to combine all ftrace zones */
+static ssize_t psz_ftrace_read(struct pstore_zone *zone,
+ struct pstore_record *record)
+{
+ struct psz_context *cxt = record->psi->data;
+ struct psz_buffer *buf;
+ int ret;
+
+ if (!zone || !record)
+ return -ENOSPC;
+
+ if (!psz_old_ok(zone))
+ goto out;
+
+ buf = (struct psz_buffer *)zone->oldbuf;
+ if (!buf)
+ return -ENOMSG;
+
+ ret = pstore_ftrace_combine_log(&record->buf, &record->size,
+ (char *)buf->data, atomic_read(&buf->datalen));
+ if (unlikely(ret))
+ return ret;
+
+out:
+ if (cxt->ftrace_read_cnt < cxt->ftrace_max_cnt)
+ /* then, read next ftrace zone */
+ return -ENOMSG;
+ record->id = 0;
+ return record->size ? record->size : -ENOMSG;
+}
+
static ssize_t psz_record_read(struct pstore_zone *zone,
struct pstore_record *record)
{
@@ -940,6 +1028,9 @@ static ssize_t psz_pstore_read(struct pstore_record *record)
readop = psz_kmsg_read;
record->id = cxt->kmsg_read_cnt - 1;
break;
+ case PSTORE_TYPE_FTRACE:
+ readop = psz_ftrace_read;
+ break;
case PSTORE_TYPE_CONSOLE:
fallthrough;
case PSTORE_TYPE_PMSG:
@@ -1004,6 +1095,8 @@ static void psz_free_all_zones(struct psz_context *cxt)
psz_free_zone(&cxt->ppsz);
if (cxt->cpsz)
psz_free_zone(&cxt->cpsz);
+ if (cxt->fpszs)
+ psz_free_zones(&cxt->fpszs, &cxt->ftrace_max_cnt);
}
static struct pstore_zone *psz_init_zone(enum pstore_type_id type,
@@ -1114,6 +1207,17 @@ static int psz_alloc_zones(struct psz_context *cxt)
goto free_out;
}
+ off_size += info->ftrace_size;
+ cxt->fpszs = psz_init_zones(PSTORE_TYPE_FTRACE, &off,
+ info->ftrace_size,
+ info->ftrace_size / nr_cpu_ids,
+ &cxt->ftrace_max_cnt);
+ if (IS_ERR(cxt->fpszs)) {
+ err = PTR_ERR(cxt->fpszs);
+ cxt->fpszs = NULL;
+ goto free_out;
+ }
+
cxt->opszs = psz_init_zones(PSTORE_TYPE_DMESG, &off,
info->total_size - off_size,
info->kmsg_size, &cxt->kmsg_max_cnt);
@@ -1148,7 +1252,8 @@ int register_pstore_zone(struct pstore_zone_info *info)
return -EINVAL;
}
- if (!info->kmsg_size && !info->pmsg_size && !info->console_size) {
+ if (!info->kmsg_size && !info->pmsg_size && !info->console_size &&
+ !info->ftrace_size) {
pr_warn("at least one record size must be non-zero\n");
return -EINVAL;
}
@@ -1172,6 +1277,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
check_size(kmsg_size, SECTOR_SIZE);
check_size(pmsg_size, SECTOR_SIZE);
check_size(console_size, SECTOR_SIZE);
+ check_size(ftrace_size, SECTOR_SIZE);
#undef check_size
@@ -1199,6 +1305,7 @@ int register_pstore_zone(struct pstore_zone_info *info)
pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size);
pr_debug("\tconsole size : %ld Bytes\n", info->console_size);
+ pr_debug("\tftrace size : %ld Bytes\n", info->ftrace_size);
err = psz_alloc_zones(cxt);
if (err) {
@@ -1236,6 +1343,10 @@ int register_pstore_zone(struct pstore_zone_info *info)
cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE;
pr_cont(" console");
}
+ if (info->ftrace_size) {
+ cxt->pstore.flags |= PSTORE_FLAGS_FTRACE;
+ pr_cont(" ftrace");
+ }
pr_cont("\n");
err = pstore_register(&cxt->pstore);
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
index 904ee67f4ba2..6f16b0dd834a 100644
--- a/include/linux/pstore_zone.h
+++ b/include/linux/pstore_zone.h
@@ -19,6 +19,7 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
* @max_reason: Maximum kmsg dump reason to store.
* @pmsg_size: The size of pmsg zone which is the same as @kmsg_size.
* @console_size:The size of console zone which is the same as @kmsg_size.
+ * @ftrace_size:The size of ftrace zone which is the same as @kmsg_size.
* @read: The general read operation. Both of the function parameters
* @size and @offset are relative value to storage.
* On success, the number of bytes should be returned, others
@@ -37,6 +38,7 @@ struct pstore_zone_info {
int max_reason;
unsigned long pmsg_size;
unsigned long console_size;
+ unsigned long ftrace_size;
pstore_zone_read_op read;
pstore_zone_write_op write;
pstore_zone_write_op panic_write;
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 12/18] pstore/zone,blk: Add ftrace frontend support
2020-05-10 20:24 ` [PATCH v7 12/18] pstore/zone,blk: Add ftrace " Kees Cook
@ 2020-05-11 15:37 ` Randy Dunlap
0 siblings, 0 replies; 37+ messages in thread
From: Randy Dunlap @ 2020-05-11 15:37 UTC (permalink / raw)
To: Kees Cook, WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On 5/10/20 1:24 PM, Kees Cook wrote:
> diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
> index f1484f751c5e..16a0440d8d5a 100644
> --- a/fs/pstore/Kconfig
> +++ b/fs/pstore/Kconfig
> @@ -248,3 +248,15 @@ config PSTORE_BLK_CONSOLE_SIZE
>
> NOTE that, both Kconfig and module parameters can configure
> pstore/blk, but module parameters have priority over Kconfig.
> +
> +config PSTORE_BLK_FTRACE_SIZE
> + int "Size in Kbytes of ftarce to store"
ftrace
but I don't know what this prompt string means.
Could it possibly be "Size in Kbytes of ftrace log to store"?
> + depends on PSTORE_BLK
> + depends on PSTORE_FTRACE
> + default 64
> + help
> + This just sets size of ftrace (ftrace_size) for pstore/blk. The
> + size is in KB and must be a multiple of 4.
> +
> + NOTE that, both Kconfig and module parameters can configure
> + pstore/blk, but module parameters have priority over Kconfig.
--
~Randy
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 13/18] Documentation: Add details for pstore/blk
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (11 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 12/18] pstore/zone,blk: Add ftrace " Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 14/18] pstore/zone: Provide way to skip "broken" zone for MTD devices Kees Cook
` (6 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Add details on using pstore/blk, the new backend of pstore to record
dumps to block devices, in Documentation/admin-guide/pstore-blk.rst
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-8-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
Documentation/admin-guide/pstore-blk.rst | 229 +++++++++++++++++++++++
MAINTAINERS | 1 +
fs/pstore/Kconfig | 2 +
3 files changed, 232 insertions(+)
create mode 100644 Documentation/admin-guide/pstore-blk.rst
diff --git a/Documentation/admin-guide/pstore-blk.rst b/Documentation/admin-guide/pstore-blk.rst
new file mode 100644
index 000000000000..bef8c7436721
--- /dev/null
+++ b/Documentation/admin-guide/pstore-blk.rst
@@ -0,0 +1,229 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+pstore block oops/panic logger
+==============================
+
+Introduction
+------------
+
+pstore block (pstore/blk) is an oops/panic logger that writes its logs to a
+block device before the system crashes. You can get these log files by
+mounting pstore filesystem like::
+
+ mount -t pstore pstore /sys/fs/pstore
+
+
+pstore block concepts
+---------------------
+
+pstore/blk provides efficient configuration method for pstore/blk, which
+divides all configurations into two parts, configurations for user and
+configurations for driver.
+
+Configurations for user determine how pstore/blk works, such as pmsg_size,
+kmsg_size and so on. All of them support both Kconfig and module parameters,
+but module parameters have priority over Kconfig.
+
+Configurations for driver are all about block device, such as total_size
+of block device and read/write operations.
+
+Configurations for user
+-----------------------
+
+All of these configurations support both Kconfig and module parameters, but
+module parameters have priority over Kconfig.
+
+Here is an example for module parameters::
+
+ pstore_blk.blkdev=179:7 pstore_blk.kmsg_size=64
+
+The detail of each configurations may be of interest to you.
+
+blkdev
+~~~~~~
+
+The block device to use. Most of the time, it is a partition of block device.
+It's required for pstore/blk.
+
+It accepts the following variants:
+
+1. <hex_major><hex_minor> device number in hexadecimal represents itself; no
+ leading 0x, for example b302.
+#. /dev/<disk_name> represents the device number of disk
+#. /dev/<disk_name><decimal> represents the device number of partition - device
+ number of disk plus the partition number
+#. /dev/<disk_name>p<decimal> - same as the above; this form is used when disk
+ name of partitioned disk ends with a digit.
+#. PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF represents the unique id of
+ a partition if the partition table provides it. The UUID may be either an
+ EFI/GPT UUID, or refer to an MSDOS partition using the format SSSSSSSS-PP,
+ where SSSSSSSS is a zero-filled hex representation of the 32-bit
+ "NT disk signature", and PP is a zero-filled hex representation of the
+ 1-based partition number.
+#. PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to a
+ partition with a known unique id.
+#. <major>:<minor> major and minor number of the device separated by a colon.
+
+kmsg_size
+~~~~~~~~~
+
+The chunk size in KB for oops/panic front-end. It **MUST** be a multiple of 4.
+It's optional if you do not care oops/panic log.
+
+There are multiple chunks for oops/panic front-end depending on the remaining
+space except other pstore front-ends.
+
+pstore/blk will log to oops/panic chunks one by one, and always overwrite the
+oldest chunk if there is no more free chunk.
+
+pmsg_size
+~~~~~~~~~
+
+The chunk size in KB for pmsg front-end. It **MUST** be a multiple of 4.
+It's optional if you do not care pmsg log.
+
+Unlike oops/panic front-end, there is only one chunk for pmsg front-end.
+
+Pmsg is a user space accessible pstore object. Writes to */dev/pmsg0* are
+appended to the chunk. On reboot the contents are available in
+*/sys/fs/pstore/pmsg-pstore-blk-0*.
+
+console_size
+~~~~~~~~~~~~
+
+The chunk size in KB for console front-end. It **MUST** be a multiple of 4.
+It's optional if you do not care console log.
+
+Similar to pmsg front-end, there is only one chunk for console front-end.
+
+All log of console will be appended to the chunk. On reboot the contents are
+available in */sys/fs/pstore/console-pstore-blk-0*.
+
+ftrace_size
+~~~~~~~~~~~
+
+The chunk size in KB for ftrace front-end. It **MUST** be a multiple of 4.
+It's optional if you do not care console log.
+
+Similar to oops front-end, there are multiple chunks for ftrace front-end
+depending on the count of cpu processors. Each chunk size is equal to
+ftrace_size / processors_count.
+
+All log of ftrace will be appended to the chunk. On reboot the contents are
+combined and available in */sys/fs/pstore/ftrace-pstore-blk-0*.
+
+Persistent function tracing might be useful for debugging software or hardware
+related hangs. Here is an example of usage::
+
+ # mount -t pstore pstore /sys/fs/pstore
+ # mount -t debugfs debugfs /sys/kernel/debug/
+ # echo 1 > /sys/kernel/debug/pstore/record_ftrace
+ # reboot -f
+ [...]
+ # mount -t pstore pstore /sys/fs/pstore
+ # tail /sys/fs/pstore/ftrace-pstore-blk-0
+ CPU:0 ts:5914676 c0063828 c0063b94 call_cpuidle <- cpu_startup_entry+0x1b8/0x1e0
+ CPU:0 ts:5914678 c039ecdc c006385c cpuidle_enter_state <- call_cpuidle+0x44/0x48
+ CPU:0 ts:5914680 c039e9a0 c039ecf0 cpuidle_enter_freeze <- cpuidle_enter_state+0x304/0x314
+ CPU:0 ts:5914681 c0063870 c039ea30 sched_idle_set_state <- cpuidle_enter_state+0x44/0x314
+ CPU:1 ts:5916720 c0160f59 c015ee04 kernfs_unmap_bin_file <- __kernfs_remove+0x140/0x204
+ CPU:1 ts:5916721 c05ca625 c015ee0c __mutex_lock_slowpath <- __kernfs_remove+0x148/0x204
+ CPU:1 ts:5916723 c05c813d c05ca630 yield_to <- __mutex_lock_slowpath+0x314/0x358
+ CPU:1 ts:5916724 c05ca2d1 c05ca638 __ww_mutex_lock <- __mutex_lock_slowpath+0x31c/0x358
+
+max_reason
+~~~~~~~~~~
+
+Limiting which kinds of kmsg dumps are stored can be controlled via
+the ``max_reason`` value, as defined in include/linux/kmsg_dump.h's
+``enum kmsg_dump_reason``. For example, to store both Oopses and Panics,
+``max_reason`` should be set to 2 (KMSG_DUMP_OOPS), to store only Panics
+``max_reason`` should be set to 1 (KMSG_DUMP_PANIC). Setting this to 0
+(KMSG_DUMP_UNDEF), means the reason filtering will be controlled by the
+``printk.always_kmsg_dump`` boot param: if unset, it'll be KMSG_DUMP_OOPS,
+otherwise KMSG_DUMP_MAX.
+
+Configurations for driver
+-------------------------
+
+Only a block device driver cares about these configurations. A block device
+driver uses ``register_pstore_blk`` to register to pstore/blk.
+
+.. kernel-doc:: fs/pstore/blk.c
+ :identifiers: register_pstore_blk
+
+Compression and header
+----------------------
+
+Block device is large enough for uncompressed oops data. Actually we do not
+recommend data compression because pstore/blk will insert some information into
+the first line of oops/panic data. For example::
+
+ Panic: Total 16 times
+
+It means that it's OOPS|Panic for the 16th time since the first booting.
+Sometimes the number of occurrences of oops|panic since the first booting is
+important to judge whether the system is stable.
+
+The following line is inserted by pstore filesystem. For example::
+
+ Oops#2 Part1
+
+It means that it's OOPS for the 2nd time on the last boot.
+
+Reading the data
+----------------
+
+The dump data can be read from the pstore filesystem. The format for these
+files is ``dmesg-pstore-blk-[N]`` for oops/panic front-end,
+``pmsg-pstore-blk-0`` for pmsg front-end and so on. The timestamp of the
+dump file records the trigger time. To delete a stored record from block
+device, simply unlink the respective pstore file.
+
+Attentions in panic read/write APIs
+-----------------------------------
+
+If on panic, the kernel is not going to run for much longer, the tasks will not
+be scheduled and most kernel resources will be out of service. It
+looks like a single-threaded program running on a single-core computer.
+
+The following points require special attention for panic read/write APIs:
+
+1. Can **NOT** allocate any memory.
+ If you need memory, just allocate while the block driver is initializing
+ rather than waiting until the panic.
+#. Must be polled, **NOT** interrupt driven.
+ No task schedule any more. The block driver should delay to ensure the write
+ succeeds, but NOT sleep.
+#. Can **NOT** take any lock.
+ There is no other task, nor any shared resource; you are safe to break all
+ locks.
+#. Just use CPU to transfer.
+ Do not use DMA to transfer unless you are sure that DMA will not keep lock.
+#. Control registers directly.
+ Please control registers directly rather than use Linux kernel resources.
+ Do I/O map while initializing rather than wait until a panic occurs.
+#. Reset your block device and controller if necessary.
+ If you are not sure of the state of your block device and controller when
+ a panic occurs, you are safe to stop and reset them.
+
+pstore/blk supports psblk_blkdev_info(), which is defined in
+*linux/pstore_blk.h*, to get information of using block device, such as the
+device number, sector count and start sector of the whole disk.
+
+pstore block internals
+----------------------
+
+For developer reference, here are all the important structures and APIs:
+
+.. kernel-doc:: fs/pstore/zone.c
+ :internal:
+
+.. kernel-doc:: include/linux/pstore_zone.h
+ :internal:
+
+.. kernel-doc:: fs/pstore/blk.c
+ :export:
+
+.. kernel-doc:: include/linux/pstore_blk.h
+ :internal:
diff --git a/MAINTAINERS b/MAINTAINERS
index e64e5db31497..9c1f4feff418 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -13660,6 +13660,7 @@ M: Tony Luck <tony.luck@intel.com>
S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/pstore
F: Documentation/admin-guide/ramoops.rst
+F: Documentation/admin-guide/pstore-blk.rst
F: Documentation/devicetree/bindings/reserved-memory/ramoops.txt
F: drivers/acpi/apei/erst.c
F: drivers/firmware/efi/efi-pstore.c
diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index 16a0440d8d5a..8371d29651a6 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -171,6 +171,8 @@ config PSTORE_BLK
This enables panic and oops message to be logged to a block dev
where it can be read back at some later point.
+ For more information, see Documentation/admin-guide/pstore-blk.rst
+
If unsure, say N.
config PSTORE_BLK_BLKDEV
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 14/18] pstore/zone: Provide way to skip "broken" zone for MTD devices
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (12 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 13/18] Documentation: Add details for pstore/blk Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 15/18] pstore/blk: Provide way to query pstore configuration Kees Cook
` (5 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
One requirement to support MTD devices in pstore/zone is having a
way to declare certain regions as broken. Add this support to
pstore/zone.
The MTD driver should return -ENOMSG when encountering a bad region,
which tells pstore/zone to skip and try the next one.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-9-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/blk.c | 10 ++++--
fs/pstore/zone.c | 65 ++++++++++++++++++++++++++++++-------
include/linux/pstore_blk.h | 3 +-
include/linux/pstore_zone.h | 12 ++++---
4 files changed, 71 insertions(+), 19 deletions(-)
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index e45937e3517c..cf11094e6b3a 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -108,9 +108,12 @@ static struct bdev_info {
* means error.
* @write: The same as @read, but the following error number:
* -EBUSY means try to write again later.
+ * -ENOMSG means to try next zone.
* @panic_write:The write operation only used for panic case. It's optional
- * if you do not care panic log. The parameters and return value
- * are the same as @read.
+ * if you do not care panic log. The parameters are relative
+ * value to storage.
+ * On success, the number of bytes should be returned, others
+ * excluding -ENOMSG mean error. -ENOMSG means to try next zone.
*/
struct pstore_device_info {
unsigned long total_size;
@@ -336,6 +339,9 @@ static ssize_t psblk_blk_panic_write(const char *buf, size_t size,
/* size and off must align to SECTOR_SIZE for block device */
ret = blkdev_panic_write(buf, off >> SECTOR_SHIFT,
size >> SECTOR_SHIFT);
+ /* try next zone */
+ if (ret == -ENOMSG)
+ return ret;
return ret ? -EIO : size;
}
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
index 45c0a422f1de..17c9a0439d6e 100644
--- a/fs/pstore/zone.c
+++ b/fs/pstore/zone.c
@@ -249,6 +249,9 @@ static int psz_zone_write(struct pstore_zone *zone,
return 0;
dirty:
+ /* no need to mark dirty if going to try next zone */
+ if (wcnt == -ENOMSG)
+ return -ENOMSG;
atomic_set(&zone->dirty, true);
/* flush dirty zones nicely */
if (wcnt == -EBUSY && !is_on_panic())
@@ -391,7 +394,11 @@ static int psz_kmsg_recover_meta(struct psz_context *cxt)
return -EINVAL;
rcnt = info->read((char *)buf, len, zone->off);
- if (rcnt != len) {
+ if (rcnt == -ENOMSG) {
+ pr_debug("%s with id %lu may be broken, skip\n",
+ zone->name, i);
+ continue;
+ } else if (rcnt != len) {
pr_err("read %s with id %lu failed\n", zone->name, i);
return (int)rcnt < 0 ? (int)rcnt : -EIO;
}
@@ -726,24 +733,58 @@ static void psz_write_kmsg_hdr(struct pstore_zone *zone,
hdr->counter = 0;
}
+/*
+ * In case zone is broken, which may occur to MTD device, we try each zones,
+ * start at cxt->kmsg_write_cnt.
+ */
static inline int notrace psz_kmsg_write_record(struct psz_context *cxt,
struct pstore_record *record)
{
+ int ret = -EBUSY;
size_t size, hlen;
struct pstore_zone *zone;
- unsigned int zonenum;
+ unsigned int i;
- zonenum = cxt->kmsg_write_cnt;
- zone = cxt->opszs[zonenum];
- if (unlikely(!zone))
- return -ENOSPC;
- cxt->kmsg_write_cnt = (zonenum + 1) % cxt->kmsg_max_cnt;
+ for (i = 0; i < cxt->kmsg_max_cnt; i++) {
+ unsigned int zonenum, len;
+
+ zonenum = (cxt->kmsg_write_cnt + i) % cxt->kmsg_max_cnt;
+ zone = cxt->opszs[zonenum];
+ if (unlikely(!zone))
+ return -ENOSPC;
+
+ /* avoid destroying old data, allocate a new one */
+ len = zone->buffer_size + sizeof(*zone->buffer);
+ zone->oldbuf = zone->buffer;
+ zone->buffer = kzalloc(len, GFP_KERNEL);
+ if (!zone->buffer) {
+ zone->buffer = zone->oldbuf;
+ return -ENOMEM;
+ }
+ zone->buffer->sig = zone->oldbuf->sig;
+
+ pr_debug("write %s to zone id %d\n", zone->name, zonenum);
+ psz_write_kmsg_hdr(zone, record);
+ hlen = sizeof(struct psz_kmsg_header);
+ size = min_t(size_t, record->size, zone->buffer_size - hlen);
+ ret = psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen);
+ if (likely(!ret || ret != -ENOMSG)) {
+ cxt->kmsg_write_cnt = zonenum + 1;
+ cxt->kmsg_write_cnt %= cxt->kmsg_max_cnt;
+ /* no need to try next zone, free last zone buffer */
+ kfree(zone->oldbuf);
+ zone->oldbuf = NULL;
+ return ret;
+ }
- pr_debug("write %s to zone id %d\n", zone->name, zonenum);
- psz_write_kmsg_hdr(zone, record);
- hlen = sizeof(struct psz_kmsg_header);
- size = min_t(size_t, record->size, zone->buffer_size - hlen);
- return psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen);
+ pr_debug("zone %u may be broken, try next dmesg zone\n",
+ zonenum);
+ kfree(zone->buffer);
+ zone->buffer = zone->oldbuf;
+ zone->oldbuf = NULL;
+ }
+
+ return -EBUSY;
}
static int notrace psz_kmsg_write(struct psz_context *cxt,
diff --git a/include/linux/pstore_blk.h b/include/linux/pstore_blk.h
index 4501977b1336..ccba8c068752 100644
--- a/include/linux/pstore_blk.h
+++ b/include/linux/pstore_blk.h
@@ -14,7 +14,8 @@
* @start_sect: start sector to block device
* @sects: sectors count on buf
*
- * Return: On success, zero should be returned. Others mean error.
+ * Return: On success, zero should be returned. Others excluding -ENOMSG
+ * mean error. -ENOMSG means to try next zone.
*
* Panic write to block device must be aligned to SECTOR_SIZE.
*/
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
index 6f16b0dd834a..e79a18e41064 100644
--- a/include/linux/pstore_zone.h
+++ b/include/linux/pstore_zone.h
@@ -23,11 +23,15 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
* @read: The general read operation. Both of the function parameters
* @size and @offset are relative value to storage.
* On success, the number of bytes should be returned, others
- * means error.
- * @write: The same as @read, but -EBUSY means try to write again later.
+ * mean error.
+ * @write: The same as @read, but the following error number:
+ * -EBUSY means try to write again later.
+ * -ENOMSG means to try next zone.
* @panic_write:The write operation only used for panic case. It's optional
- * if you do not care panic log. The parameters and return value
- * are the same as @read.
+ * if you do not care panic log. The parameters are relative
+ * value to storage.
+ * On success, the number of bytes should be returned, others
+ * excluding -ENOMSG mean error. -ENOMSG means to try next zone.
*/
struct pstore_zone_info {
struct module *owner;
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 15/18] pstore/blk: Provide way to query pstore configuration
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (13 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 14/18] pstore/zone: Provide way to skip "broken" zone for MTD devices Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 16/18] pstore/blk: Support non-block storage devices Kees Cook
` (4 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
In order to configure itself, the MTD backend needs to be able to query
the current pstore configuration. Introduce pstore_blk_get_config() for
this purpose.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-10-git-send-email-liaoweixiong@allwinnertech.com
Co-developed-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/blk.c | 37 ++++++++++++++++++++++++++++++-------
include/linux/pstore_blk.h | 28 ++++++++++++++++++++++++++++
2 files changed, 58 insertions(+), 7 deletions(-)
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index cf11094e6b3a..e8e907ea8b03 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -93,6 +93,17 @@ static struct bdev_info {
sector_t start_sect;
} g_bdev_info;
+#define check_size(name, alignsize) ({ \
+ long _##name_ = (name); \
+ _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024); \
+ if (_##name_ & ((alignsize) - 1)) { \
+ pr_info(#name " must align to %d\n", \
+ (alignsize)); \
+ _##name_ = ALIGN(name, (alignsize)); \
+ } \
+ _##name_; \
+})
+
/**
* struct pstore_device_info - back-end pstore/blk driver structure.
*
@@ -148,13 +159,11 @@ static int psblk_register_do(struct pstore_device_info *dev)
dev->flags = UINT_MAX;
#define verify_size(name, alignsize, enabled) { \
- long _##name_ = (enabled) ? (name) : 0; \
- _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024); \
- if (_##name_ & ((alignsize) - 1)) { \
- pr_info(#name " must align to %d\n", \
- (alignsize)); \
- _##name_ = ALIGN(name, (alignsize)); \
- } \
+ long _##name_; \
+ if (enabled) \
+ _##name_ = check_size(name, alignsize); \
+ else \
+ _##name_ = 0; \
name = _##name_ / 1024; \
pstore_zone_info->name = _##name_; \
}
@@ -455,6 +464,20 @@ void unregister_pstore_blk(unsigned int major)
}
EXPORT_SYMBOL_GPL(unregister_pstore_blk);
+/* get information of pstore/blk */
+int pstore_blk_get_config(struct pstore_blk_config *info)
+{
+ strncpy(info->device, blkdev, 80);
+ info->max_reason = max_reason;
+ info->kmsg_size = check_size(kmsg_size, 4096);
+ info->pmsg_size = check_size(pmsg_size, 4096);
+ info->ftrace_size = check_size(ftrace_size, 4096);
+ info->console_size = check_size(console_size, 4096);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(pstore_blk_get_config);
+
static void __exit pstore_blk_exit(void)
{
mutex_lock(&pstore_blk_lock);
diff --git a/include/linux/pstore_blk.h b/include/linux/pstore_blk.h
index ccba8c068752..0c40774e71e0 100644
--- a/include/linux/pstore_blk.h
+++ b/include/linux/pstore_blk.h
@@ -49,4 +49,32 @@ struct pstore_blk_info {
int register_pstore_blk(struct pstore_blk_info *info);
void unregister_pstore_blk(unsigned int major);
+/**
+ * struct pstore_blk_config - the pstore_blk backend configuration
+ *
+ * @device: Name of the desired block device
+ * @max_reason: Maximum kmsg dump reason to store to block device
+ * @kmsg_size: Total size of for kmsg dumps
+ * @pmsg_size: Total size of the pmsg storage area
+ * @console_size: Total size of the console storage area
+ * @ftrace_size: Total size for ftrace logging data (for all CPUs)
+ */
+struct pstore_blk_config {
+ char device[80];
+ enum kmsg_dump_reason max_reason;
+ unsigned long kmsg_size;
+ unsigned long pmsg_size;
+ unsigned long console_size;
+ unsigned long ftrace_size;
+};
+
+/**
+ * pstore_blk_get_config - get a copy of the pstore_blk backend configuration
+ *
+ * @info: The sturct pstore_blk_config to be filled in
+ *
+ * Failure returns negative error code, and success returns 0.
+ */
+int pstore_blk_get_config(struct pstore_blk_config *info);
+
#endif
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 16/18] pstore/blk: Support non-block storage devices
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (14 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 15/18] pstore/blk: Provide way to query pstore configuration Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-10 20:24 ` [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk Kees Cook
` (3 subsequent siblings)
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Add support for non-block devices (e.g. MTD). A non-block driver calls
pstore_blk_register_device() to register iself.
In addition, pstore/zone is updated to handle non-block devices,
where an erase must be done before a write. Without this, there is no
way to remove records stored to an MTD.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-11-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
Documentation/admin-guide/pstore-blk.rst | 17 ++++-
fs/pstore/blk.c | 94 +++++++++++++-----------
fs/pstore/zone.c | 8 +-
include/linux/pstore_blk.h | 38 ++++++++++
include/linux/pstore_zone.h | 6 ++
5 files changed, 115 insertions(+), 48 deletions(-)
diff --git a/Documentation/admin-guide/pstore-blk.rst b/Documentation/admin-guide/pstore-blk.rst
index bef8c7436721..d45341e55e82 100644
--- a/Documentation/admin-guide/pstore-blk.rst
+++ b/Documentation/admin-guide/pstore-blk.rst
@@ -7,8 +7,8 @@ Introduction
------------
pstore block (pstore/blk) is an oops/panic logger that writes its logs to a
-block device before the system crashes. You can get these log files by
-mounting pstore filesystem like::
+block device and non-block device before the system crashes. You can get
+these log files by mounting pstore filesystem like::
mount -t pstore pstore /sys/fs/pstore
@@ -24,8 +24,8 @@ Configurations for user determine how pstore/blk works, such as pmsg_size,
kmsg_size and so on. All of them support both Kconfig and module parameters,
but module parameters have priority over Kconfig.
-Configurations for driver are all about block device, such as total_size
-of block device and read/write operations.
+Configurations for driver are all about block device and non-block device,
+such as total_size of block device and read/write operations.
Configurations for user
-----------------------
@@ -152,6 +152,15 @@ driver uses ``register_pstore_blk`` to register to pstore/blk.
.. kernel-doc:: fs/pstore/blk.c
:identifiers: register_pstore_blk
+A non-block device driver uses ``register_pstore_device`` with
+``struct pstore_device_info`` to register to pstore/blk.
+
+.. kernel-doc:: fs/pstore/blk.c
+ :identifiers: register_pstore_device
+
+.. kernel-doc:: include/linux/pstore_blk.h
+ :identifiers: pstore_device_info
+
Compression and header
----------------------
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index e8e907ea8b03..0dea8ded2de2 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -104,55 +104,23 @@ static struct bdev_info {
_##name_; \
})
-/**
- * struct pstore_device_info - back-end pstore/blk driver structure.
- *
- * @total_size: The total size in bytes pstore/blk can use. It must be greater
- * than 4096 and be multiple of 4096.
- * @flags: Refer to macro starting with PSTORE_FLAGS defined in
- * linux/pstore.h. It means what front-ends this device support.
- * Zero means all backends for compatible.
- * @read: The general read operation. Both of the function parameters
- * @size and @offset are relative value to bock device (not the
- * whole disk).
- * On success, the number of bytes should be returned, others
- * means error.
- * @write: The same as @read, but the following error number:
- * -EBUSY means try to write again later.
- * -ENOMSG means to try next zone.
- * @panic_write:The write operation only used for panic case. It's optional
- * if you do not care panic log. The parameters are relative
- * value to storage.
- * On success, the number of bytes should be returned, others
- * excluding -ENOMSG mean error. -ENOMSG means to try next zone.
- */
-struct pstore_device_info {
- unsigned long total_size;
- unsigned int flags;
- pstore_zone_read_op read;
- pstore_zone_write_op write;
- pstore_zone_write_op panic_write;
-};
-
-static int psblk_register_do(struct pstore_device_info *dev)
+static int __register_pstore_device(struct pstore_device_info *dev)
{
int ret;
- if (!dev || !dev->total_size || !dev->read || !dev->write)
+ if (WARN_ON(!mutex_is_locked(&pstore_blk_lock)))
return -EINVAL;
- mutex_lock(&pstore_blk_lock);
+ if (!dev || !dev->total_size || !dev->read || !dev->write)
+ return -EINVAL;
/* someone already registered before */
- if (pstore_zone_info) {
- mutex_unlock(&pstore_blk_lock);
+ if (pstore_zone_info)
return -EBUSY;
- }
+
pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
- if (!pstore_zone_info) {
- mutex_unlock(&pstore_blk_lock);
+ if (!pstore_zone_info)
return -ENOMEM;
- }
/* zero means not limit on which backends to attempt to store. */
if (!dev->flags)
@@ -178,6 +146,7 @@ static int psblk_register_do(struct pstore_device_info *dev)
pstore_zone_info->max_reason = max_reason;
pstore_zone_info->read = dev->read;
pstore_zone_info->write = dev->write;
+ pstore_zone_info->erase = dev->erase;
pstore_zone_info->panic_write = dev->panic_write;
pstore_zone_info->name = KBUILD_MODNAME;
pstore_zone_info->owner = THIS_MODULE;
@@ -187,20 +156,51 @@ static int psblk_register_do(struct pstore_device_info *dev)
kfree(pstore_zone_info);
pstore_zone_info = NULL;
}
+ return ret;
+}
+/**
+ * register_pstore_device() - register non-block device to pstore/blk
+ *
+ * @dev: non-block device information
+ *
+ * Return:
+ * * 0 - OK
+ * * Others - something error.
+ */
+int register_pstore_device(struct pstore_device_info *dev)
+{
+ int ret;
+
+ mutex_lock(&pstore_blk_lock);
+ ret = __register_pstore_device(dev);
mutex_unlock(&pstore_blk_lock);
+
return ret;
}
+EXPORT_SYMBOL_GPL(register_pstore_device);
-static void psblk_unregister_do(struct pstore_device_info *dev)
+static void __unregister_pstore_device(struct pstore_device_info *dev)
{
- mutex_lock(&pstore_blk_lock);
+ WARN_ON(!mutex_is_locked(&pstore_blk_lock));
if (pstore_zone_info && pstore_zone_info->read == dev->read) {
unregister_pstore_zone(pstore_zone_info);
kfree(pstore_zone_info);
pstore_zone_info = NULL;
}
+}
+
+/**
+ * unregister_pstore_device() - unregister non-block device from pstore/blk
+ *
+ * @dev: non-block device information
+ */
+void unregister_pstore_device(struct pstore_device_info *dev)
+{
+ mutex_lock(&pstore_blk_lock);
+ __unregister_pstore_device(dev);
mutex_unlock(&pstore_blk_lock);
}
+EXPORT_SYMBOL_GPL(unregister_pstore_device);
/**
* psblk_get_bdev() - open block device
@@ -397,9 +397,10 @@ static int __register_pstore_blk(struct pstore_blk_info *info)
dev.flags = info->flags;
dev.read = psblk_generic_blk_read;
dev.write = psblk_generic_blk_write;
+ dev.erase = NULL;
dev.panic_write = info->panic_write ? psblk_blk_panic_write : NULL;
- ret = psblk_register_do(&dev);
+ ret = __register_pstore_device(&dev);
if (ret)
goto err_put_bdev;
@@ -443,7 +444,7 @@ static void __unregister_pstore_blk(unsigned int major)
WARN_ON(!mutex_is_locked(&pstore_blk_lock));
if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
- psblk_unregister_do(&dev);
+ __unregister_pstore_device(&dev);
psblk_put_bdev(psblk_bdev, holder);
blkdev_panic_write = NULL;
psblk_bdev = NULL;
@@ -483,6 +484,13 @@ static void __exit pstore_blk_exit(void)
mutex_lock(&pstore_blk_lock);
if (psblk_bdev)
__unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
+ else {
+ struct pstore_device_info dev = { };
+
+ if (pstore_zone_info)
+ dev.read = pstore_zone_info->read;
+ __unregister_pstore_device(&dev);
+ }
mutex_unlock(&pstore_blk_lock);
}
module_exit(pstore_blk_exit);
diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c
index 17c9a0439d6e..b04257f8420f 100644
--- a/fs/pstore/zone.c
+++ b/fs/pstore/zone.c
@@ -661,15 +661,21 @@ static inline int psz_kmsg_erase(struct psz_context *cxt,
struct psz_buffer *buffer = zone->buffer;
struct psz_kmsg_header *hdr =
(struct psz_kmsg_header *)buffer->data;
+ size_t size;
if (unlikely(!psz_ok(zone)))
return 0;
+
/* this zone is already updated, no need to erase */
if (record->count != hdr->counter)
return 0;
+ size = buffer_datalen(zone) + sizeof(*zone->buffer);
atomic_set(&zone->buffer->datalen, 0);
- return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
+ if (cxt->pstore_zone_info->erase)
+ return cxt->pstore_zone_info->erase(size, zone->off);
+ else
+ return psz_zone_write(zone, FLUSH_META, NULL, 0, 0);
}
static inline int psz_record_erase(struct psz_context *cxt,
diff --git a/include/linux/pstore_blk.h b/include/linux/pstore_blk.h
index 0c40774e71e0..61e914522b01 100644
--- a/include/linux/pstore_blk.h
+++ b/include/linux/pstore_blk.h
@@ -49,6 +49,44 @@ struct pstore_blk_info {
int register_pstore_blk(struct pstore_blk_info *info);
void unregister_pstore_blk(unsigned int major);
+/**
+ * struct pstore_device_info - back-end pstore/blk driver structure.
+ *
+ * @total_size: The total size in bytes pstore/blk can use. It must be greater
+ * than 4096 and be multiple of 4096.
+ * @flags: Refer to macro starting with PSTORE_FLAGS defined in
+ * linux/pstore.h. It means what front-ends this device support.
+ * Zero means all backends for compatible.
+ * @read: The general read operation. Both of the function parameters
+ * @size and @offset are relative value to bock device (not the
+ * whole disk).
+ * On success, the number of bytes should be returned, others
+ * means error.
+ * @write: The same as @read, but the following error number:
+ * -EBUSY means try to write again later.
+ * -ENOMSG means to try next zone.
+ * @erase: The general erase operation for device with special removing
+ * job. Both of the function parameters @size and @offset are
+ * relative value to storage.
+ * Return 0 on success and others on failure.
+ * @panic_write:The write operation only used for panic case. It's optional
+ * if you do not care panic log. The parameters are relative
+ * value to storage.
+ * On success, the number of bytes should be returned, others
+ * excluding -ENOMSG mean error. -ENOMSG means to try next zone.
+ */
+struct pstore_device_info {
+ unsigned long total_size;
+ unsigned int flags;
+ pstore_zone_read_op read;
+ pstore_zone_write_op write;
+ pstore_zone_erase_op erase;
+ pstore_zone_write_op panic_write;
+};
+
+int register_pstore_device(struct pstore_device_info *dev);
+void unregister_pstore_device(struct pstore_device_info *dev);
+
/**
* struct pstore_blk_config - the pstore_blk backend configuration
*
diff --git a/include/linux/pstore_zone.h b/include/linux/pstore_zone.h
index e79a18e41064..1e35eaa33e5e 100644
--- a/include/linux/pstore_zone.h
+++ b/include/linux/pstore_zone.h
@@ -7,6 +7,7 @@
typedef ssize_t (*pstore_zone_read_op)(char *, size_t, loff_t);
typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
+typedef ssize_t (*pstore_zone_erase_op)(size_t, loff_t);
/**
* struct pstore_zone_info - pstore/zone back-end driver structure
*
@@ -27,6 +28,10 @@ typedef ssize_t (*pstore_zone_write_op)(const char *, size_t, loff_t);
* @write: The same as @read, but the following error number:
* -EBUSY means try to write again later.
* -ENOMSG means to try next zone.
+ * @erase: The general erase operation for device with special removing
+ * job. Both of the function parameters @size and @offset are
+ * relative value to storage.
+ * Return 0 on success and others on failure.
* @panic_write:The write operation only used for panic case. It's optional
* if you do not care panic log. The parameters are relative
* value to storage.
@@ -45,6 +50,7 @@ struct pstore_zone_info {
unsigned long ftrace_size;
pstore_zone_read_op read;
pstore_zone_write_op write;
+ pstore_zone_erase_op erase;
pstore_zone_write_op panic_write;
};
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (15 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 16/18] pstore/blk: Support non-block storage devices Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 9:01 ` WeiXiong Liao
2020-05-10 20:24 ` [PATCH v7 18/18] pstore/blk: Introduce "best_effort" mode Kees Cook
` (2 subsequent siblings)
19 siblings, 1 reply; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
This introduces mtdpstore, which is similar to mtdoops but more
powerful. It uses pstore/blk, and aims to store panic and oops logs to
a flash partition, where pstore can later read back and present as files
in the mounted pstore filesystem.
To make mtdpstore work, the "blkdev" of pstore/blk should be set
as MTD device name or MTD device number. For more details, see
Documentation/admin-guide/pstore-blk.rst
This solves a number of issues:
- Work duplication: both of pstore and mtdoops do the same job storing
panic/oops log. They have very similar logic, registering to kmsg
dumper and storing logs to several chunks one by one.
- Layer violations: drivers should provides methods instead of polices.
MTD should provide read/write/erase operations, and allow a higher
level drivers to provide the chunk management, kmsg dump
configuration, etc.
- Missing features: pstore provides many additional features, including
presenting the logs as files, logging dump time and count, and
supporting other frontends like pmsg, console, etc.
Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
Link: https://lore.kernel.org/r/1585126506-18635-12-git-send-email-liaoweixiong@allwinnertech.com
Signed-off-by: Kees Cook <keescook@chromium.org>
---
Documentation/admin-guide/pstore-blk.rst | 9 +-
drivers/mtd/Kconfig | 10 +
drivers/mtd/Makefile | 1 +
drivers/mtd/mtdpstore.c | 564 +++++++++++++++++++++++
4 files changed, 582 insertions(+), 2 deletions(-)
create mode 100644 drivers/mtd/mtdpstore.c
diff --git a/Documentation/admin-guide/pstore-blk.rst b/Documentation/admin-guide/pstore-blk.rst
index d45341e55e82..296d5027787a 100644
--- a/Documentation/admin-guide/pstore-blk.rst
+++ b/Documentation/admin-guide/pstore-blk.rst
@@ -43,9 +43,9 @@ blkdev
~~~~~~
The block device to use. Most of the time, it is a partition of block device.
-It's required for pstore/blk.
+It's required for pstore/blk. It is also used for MTD device.
-It accepts the following variants:
+It accepts the following variants for block device:
1. <hex_major><hex_minor> device number in hexadecimal represents itself; no
leading 0x, for example b302.
@@ -64,6 +64,11 @@ It accepts the following variants:
partition with a known unique id.
#. <major>:<minor> major and minor number of the device separated by a colon.
+It accepts the following variants for MTD device:
+
+1. <device name> MTD device name. "pstore" is recommended.
+#. <device number> MTD device number.
+
kmsg_size
~~~~~~~~~
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 42d401ea60ee..6ddab796216d 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -170,6 +170,16 @@ config MTD_OOPS
buffer in a flash partition where it can be read back at some
later point.
+config MTD_PSTORE
+ tristate "Log panic/oops to an MTD buffer based on pstore"
+ depends on PSTORE_BLK
+ help
+ This enables panic and oops messages to be logged to a circular
+ buffer in a flash partition where it can be read back as files after
+ mounting pstore filesystem.
+
+ If unsure, say N.
+
config MTD_SWAP
tristate "Swap on MTD device support"
depends on MTD && SWAP
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index 56cc60ccc477..593d0593a038 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_RFD_FTL) += rfd_ftl.o
obj-$(CONFIG_SSFDC) += ssfdc.o
obj-$(CONFIG_SM_FTL) += sm_ftl.o
obj-$(CONFIG_MTD_OOPS) += mtdoops.o
+obj-$(CONFIG_MTD_PSTORE) += mtdpstore.o
obj-$(CONFIG_MTD_SWAP) += mtdswap.o
nftl-objs := nftlcore.o nftlmount.o
diff --git a/drivers/mtd/mtdpstore.c b/drivers/mtd/mtdpstore.c
new file mode 100644
index 000000000000..ce6da4d04864
--- /dev/null
+++ b/drivers/mtd/mtdpstore.c
@@ -0,0 +1,564 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#define dev_fmt(fmt) "mtdoops-pstore: " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pstore_blk.h>
+#include <linux/mtd/mtd.h>
+#include <linux/bitops.h>
+
+static struct mtdpstore_context {
+ int index;
+ struct pstore_blk_config info;
+ struct pstore_device_info dev;
+ struct mtd_info *mtd;
+ unsigned long *rmmap; /* removed bit map */
+ unsigned long *usedmap; /* used bit map */
+ /*
+ * used for panic write
+ * As there are no block_isbad for panic case, we should keep this
+ * status before panic to ensure panic_write not failed.
+ */
+ unsigned long *badmap; /* bad block bit map */
+} oops_cxt;
+
+static int mtdpstore_block_isbad(struct mtdpstore_context *cxt, loff_t off)
+{
+ int ret;
+ struct mtd_info *mtd = cxt->mtd;
+ u64 blknum = div_u64(off, mtd->erasesize);
+
+ if (test_bit(blknum, cxt->badmap))
+ return true;
+ ret = mtd_block_isbad(mtd, off);
+ if (ret < 0) {
+ dev_err(&mtd->dev, "mtd_block_isbad failed, aborting\n");
+ return ret;
+ } else if (ret > 0) {
+ set_bit(blknum, cxt->badmap);
+ return true;
+ }
+ return false;
+}
+
+static inline int mtdpstore_panic_block_isbad(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u64 blknum = div_u64(off, mtd->erasesize);
+
+ return test_bit(blknum, cxt->badmap);
+}
+
+static inline void mtdpstore_mark_used(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+
+ dev_dbg(&mtd->dev, "mark zone %llu used\n", zonenum);
+ set_bit(zonenum, cxt->usedmap);
+}
+
+static inline void mtdpstore_mark_unused(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+
+ dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
+ clear_bit(zonenum, cxt->usedmap);
+}
+
+static inline void mtdpstore_block_mark_unused(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+ u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
+
+ while (zonecnt > 0) {
+ dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
+ clear_bit(zonenum, cxt->usedmap);
+ zonenum++;
+ zonecnt--;
+ }
+}
+
+static inline int mtdpstore_is_used(struct mtdpstore_context *cxt, loff_t off)
+{
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+ u64 blknum = div_u64(off, cxt->mtd->erasesize);
+
+ if (test_bit(blknum, cxt->badmap))
+ return true;
+ return test_bit(zonenum, cxt->usedmap);
+}
+
+static int mtdpstore_block_is_used(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+ u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
+
+ while (zonecnt > 0) {
+ if (test_bit(zonenum, cxt->usedmap))
+ return true;
+ zonenum++;
+ zonecnt--;
+ }
+ return false;
+}
+
+static int mtdpstore_is_empty(struct mtdpstore_context *cxt, char *buf,
+ size_t size)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ size_t sz;
+ int i;
+
+ sz = min_t(uint32_t, size, mtd->writesize / 4);
+ for (i = 0; i < sz; i++) {
+ if (buf[i] != (char)0xFF)
+ return false;
+ }
+ return true;
+}
+
+static void mtdpstore_mark_removed(struct mtdpstore_context *cxt, loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+
+ dev_dbg(&mtd->dev, "mark zone %llu removed\n", zonenum);
+ set_bit(zonenum, cxt->rmmap);
+}
+
+static void mtdpstore_block_clear_removed(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+ u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
+
+ while (zonecnt > 0) {
+ clear_bit(zonenum, cxt->rmmap);
+ zonenum++;
+ zonecnt--;
+ }
+}
+
+static int mtdpstore_block_is_removed(struct mtdpstore_context *cxt,
+ loff_t off)
+{
+ u64 zonenum = div_u64(off, cxt->info.kmsg_size);
+ u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
+
+ while (zonecnt > 0) {
+ if (test_bit(zonenum, cxt->rmmap))
+ return true;
+ zonenum++;
+ zonecnt--;
+ }
+ return false;
+}
+
+static int mtdpstore_erase_do(struct mtdpstore_context *cxt, loff_t off)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ struct erase_info erase;
+ int ret;
+
+ dev_dbg(&mtd->dev, "try to erase off 0x%llx\n", off);
+ erase.len = cxt->mtd->erasesize;
+ erase.addr = off;
+ ret = mtd_erase(cxt->mtd, &erase);
+ if (!ret)
+ mtdpstore_block_clear_removed(cxt, off);
+ else
+ dev_err(&mtd->dev, "erase of region [0x%llx, 0x%llx] on \"%s\" failed\n",
+ (unsigned long long)erase.addr,
+ (unsigned long long)erase.len, cxt->info.device);
+ return ret;
+}
+
+/*
+ * called while removing file
+ *
+ * Avoiding over erasing, do erase block only when the whole block is unused.
+ * If the block contains valid log, do erase lazily on flush_removed() when
+ * unregister.
+ */
+static ssize_t mtdpstore_erase(size_t size, loff_t off)
+{
+ struct mtdpstore_context *cxt = &oops_cxt;
+
+ if (mtdpstore_block_isbad(cxt, off))
+ return -EIO;
+
+ mtdpstore_mark_unused(cxt, off);
+
+ /* If the block still has valid data, mtdpstore do erase lazily */
+ if (likely(mtdpstore_block_is_used(cxt, off))) {
+ mtdpstore_mark_removed(cxt, off);
+ return 0;
+ }
+
+ /* all zones are unused, erase it */
+ off = ALIGN_DOWN(off, cxt->mtd->erasesize);
+ return mtdpstore_erase_do(cxt, off);
+}
+
+/*
+ * What is security for mtdpstore?
+ * As there is no erase for panic case, we should ensure at least one zone
+ * is writable. Otherwise, panic write will fail.
+ * If zone is used, write operation will return -ENOMSG, which means that
+ * pstore/blk will try one by one until gets an empty zone. So, it is not
+ * needed to ensure the next zone is empty, but at least one.
+ */
+static int mtdpstore_security(struct mtdpstore_context *cxt, loff_t off)
+{
+ int ret = 0, i;
+ struct mtd_info *mtd = cxt->mtd;
+ u32 zonenum = (u32)div_u64(off, cxt->info.kmsg_size);
+ u32 zonecnt = (u32)div_u64(cxt->mtd->size, cxt->info.kmsg_size);
+ u32 blkcnt = (u32)div_u64(cxt->mtd->size, cxt->mtd->erasesize);
+ u32 erasesize = cxt->mtd->erasesize;
+
+ for (i = 0; i < zonecnt; i++) {
+ u32 num = (zonenum + i) % zonecnt;
+
+ /* found empty zone */
+ if (!test_bit(num, cxt->usedmap))
+ return 0;
+ }
+
+ /* If there is no any empty zone, we have no way but to do erase */
+ off = ALIGN_DOWN(off, erasesize);
+ while (blkcnt--) {
+ div64_u64_rem(off + erasesize, cxt->mtd->size, (u64 *)&off);
+
+ if (mtdpstore_block_isbad(cxt, off))
+ continue;
+
+ ret = mtdpstore_erase_do(cxt, off);
+ if (!ret) {
+ mtdpstore_block_mark_unused(cxt, off);
+ break;
+ }
+ }
+
+ if (ret)
+ dev_err(&mtd->dev, "all blocks bad!\n");
+ dev_dbg(&mtd->dev, "end security\n");
+ return ret;
+}
+
+static ssize_t mtdpstore_write(const char *buf, size_t size, loff_t off)
+{
+ struct mtdpstore_context *cxt = &oops_cxt;
+ struct mtd_info *mtd = cxt->mtd;
+ size_t retlen;
+ int ret;
+
+ if (mtdpstore_block_isbad(cxt, off))
+ return -ENOMSG;
+
+ /* zone is used, please try next one */
+ if (mtdpstore_is_used(cxt, off))
+ return -ENOMSG;
+
+ dev_dbg(&mtd->dev, "try to write off 0x%llx size %zu\n", off, size);
+ ret = mtd_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
+ if (ret < 0 || retlen != size) {
+ dev_err(&mtd->dev, "write failure at %lld (%zu of %zu written), err %d\n",
+ off, retlen, size, ret);
+ return -EIO;
+ }
+ mtdpstore_mark_used(cxt, off);
+
+ mtdpstore_security(cxt, off);
+ return retlen;
+}
+
+static inline bool mtdpstore_is_io_error(int ret)
+{
+ return ret < 0 && !mtd_is_bitflip(ret) && !mtd_is_eccerr(ret);
+}
+
+/*
+ * All zones will be read as pstore/blk will read zone one by one when do
+ * recover.
+ */
+static ssize_t mtdpstore_read(char *buf, size_t size, loff_t off)
+{
+ struct mtdpstore_context *cxt = &oops_cxt;
+ struct mtd_info *mtd = cxt->mtd;
+ size_t retlen, done;
+ int ret;
+
+ if (mtdpstore_block_isbad(cxt, off))
+ return -ENOMSG;
+
+ dev_dbg(&mtd->dev, "try to read off 0x%llx size %zu\n", off, size);
+ for (done = 0, retlen = 0; done < size; done += retlen) {
+ retlen = 0;
+
+ ret = mtd_read(cxt->mtd, off + done, size - done, &retlen,
+ (u_char *)buf + done);
+ if (mtdpstore_is_io_error(ret)) {
+ dev_err(&mtd->dev, "read failure at %lld (%zu of %zu read), err %d\n",
+ off + done, retlen, size - done, ret);
+ /* the zone may be broken, try next one */
+ return -ENOMSG;
+ }
+
+ /*
+ * ECC error. The impact on log data is so small. Maybe we can
+ * still read it and try to understand. So mtdpstore just hands
+ * over what it gets and user can judge whether the data is
+ * valid or not.
+ */
+ if (mtd_is_eccerr(ret)) {
+ dev_err(&mtd->dev, "ecc error at %lld (%zu of %zu read), err %d\n",
+ off + done, retlen, size - done, ret);
+ /* driver may not set retlen when ecc error */
+ retlen = retlen == 0 ? size - done : retlen;
+ }
+ }
+
+ if (mtdpstore_is_empty(cxt, buf, size))
+ mtdpstore_mark_unused(cxt, off);
+ else
+ mtdpstore_mark_used(cxt, off);
+
+ mtdpstore_security(cxt, off);
+ return retlen;
+}
+
+static ssize_t mtdpstore_panic_write(const char *buf, size_t size, loff_t off)
+{
+ struct mtdpstore_context *cxt = &oops_cxt;
+ struct mtd_info *mtd = cxt->mtd;
+ size_t retlen;
+ int ret;
+
+ if (mtdpstore_panic_block_isbad(cxt, off))
+ return -ENOMSG;
+
+ /* zone is used, please try next one */
+ if (mtdpstore_is_used(cxt, off))
+ return -ENOMSG;
+
+ ret = mtd_panic_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
+ if (ret < 0 || size != retlen) {
+ dev_err(&mtd->dev, "panic write failure at %lld (%zu of %zu read), err %d\n",
+ off, retlen, size, ret);
+ return -EIO;
+ }
+ mtdpstore_mark_used(cxt, off);
+
+ return retlen;
+}
+
+static void mtdpstore_notify_add(struct mtd_info *mtd)
+{
+ int ret;
+ struct mtdpstore_context *cxt = &oops_cxt;
+ struct pstore_blk_config *info = &cxt->info;
+ unsigned long longcnt;
+
+ if (!strcmp(mtd->name, info->device))
+ cxt->index = mtd->index;
+
+ if (mtd->index != cxt->index || cxt->index < 0)
+ return;
+
+ dev_dbg(&mtd->dev, "found matching MTD device %s\n", mtd->name);
+
+ if (mtd->size < info->kmsg_size * 2) {
+ dev_err(&mtd->dev, "MTD partition %d not big enough\n",
+ mtd->index);
+ return;
+ }
+ /*
+ * kmsg_size must be aligned to 4096 Bytes, which is limited by
+ * psblk. The default value of kmsg_size is 64KB. If kmsg_size
+ * is larger than erasesize, some errors will occur since mtdpsotre
+ * is designed on it.
+ */
+ if (mtd->erasesize < info->kmsg_size) {
+ dev_err(&mtd->dev, "eraseblock size of MTD partition %d too small\n",
+ mtd->index);
+ return;
+ }
+ if (unlikely(info->kmsg_size % mtd->writesize)) {
+ dev_err(&mtd->dev, "record size %lu KB must align to write size %d KB\n",
+ info->kmsg_size / 1024,
+ mtd->writesize / 1024);
+ return;
+ }
+
+ longcnt = BITS_TO_LONGS(div_u64(mtd->size, info->kmsg_size));
+ cxt->rmmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
+ cxt->usedmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
+
+ longcnt = BITS_TO_LONGS(div_u64(mtd->size, mtd->erasesize));
+ cxt->badmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
+
+ cxt->dev.total_size = mtd->size;
+ /* just support dmesg right now */
+ cxt->dev.flags = PSTORE_FLAGS_DMESG;
+ cxt->dev.read = mtdpstore_read;
+ cxt->dev.write = mtdpstore_write;
+ cxt->dev.erase = mtdpstore_erase;
+ cxt->dev.panic_write = mtdpstore_panic_write;
+
+ ret = register_pstore_device(&cxt->dev);
+ if (ret) {
+ dev_err(&mtd->dev, "mtd%d register to psblk failed\n",
+ mtd->index);
+ return;
+ }
+ cxt->mtd = mtd;
+ dev_info(&mtd->dev, "Attached to MTD device %d\n", mtd->index);
+}
+
+static int mtdpstore_flush_removed_do(struct mtdpstore_context *cxt,
+ loff_t off, size_t size)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ u_char *buf;
+ int ret;
+ size_t retlen;
+ struct erase_info erase;
+
+ buf = kmalloc(mtd->erasesize, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ /* 1st. read to cache */
+ ret = mtd_read(mtd, off, mtd->erasesize, &retlen, buf);
+ if (mtdpstore_is_io_error(ret))
+ goto free;
+
+ /* 2nd. erase block */
+ erase.len = mtd->erasesize;
+ erase.addr = off;
+ ret = mtd_erase(mtd, &erase);
+ if (ret)
+ goto free;
+
+ /* 3rd. write back */
+ while (size) {
+ unsigned int zonesize = cxt->info.kmsg_size;
+
+ /* there is valid data on block, write back */
+ if (mtdpstore_is_used(cxt, off)) {
+ ret = mtd_write(mtd, off, zonesize, &retlen, buf);
+ if (ret)
+ dev_err(&mtd->dev, "write failure at %lld (%zu of %u written), err %d\n",
+ off, retlen, zonesize, ret);
+ }
+
+ off += zonesize;
+ size -= min_t(unsigned int, zonesize, size);
+ }
+
+free:
+ kfree(buf);
+ return ret;
+}
+
+/*
+ * What does mtdpstore_flush_removed() do?
+ * When user remove any log file on pstore filesystem, mtdpstore should do
+ * something to ensure log file removed. If the whole block is no longer used,
+ * it's nice to erase the block. However if the block still contains valid log,
+ * what mtdpstore can do is to erase and write the valid log back.
+ */
+static int mtdpstore_flush_removed(struct mtdpstore_context *cxt)
+{
+ struct mtd_info *mtd = cxt->mtd;
+ int ret;
+ loff_t off;
+ u32 blkcnt = (u32)div_u64(mtd->size, mtd->erasesize);
+
+ for (off = 0; blkcnt > 0; blkcnt--, off += mtd->erasesize) {
+ ret = mtdpstore_block_isbad(cxt, off);
+ if (ret)
+ continue;
+
+ ret = mtdpstore_block_is_removed(cxt, off);
+ if (!ret)
+ continue;
+
+ ret = mtdpstore_flush_removed_do(cxt, off, mtd->erasesize);
+ if (ret)
+ return ret;
+ }
+ return 0;
+}
+
+static void mtdpstore_notify_remove(struct mtd_info *mtd)
+{
+ struct mtdpstore_context *cxt = &oops_cxt;
+
+ if (mtd->index != cxt->index || cxt->index < 0)
+ return;
+
+ mtdpstore_flush_removed(cxt);
+
+ unregister_pstore_device(&cxt->dev);
+ kfree(cxt->badmap);
+ kfree(cxt->usedmap);
+ kfree(cxt->rmmap);
+ cxt->mtd = NULL;
+ cxt->index = -1;
+}
+
+static struct mtd_notifier mtdpstore_notifier = {
+ .add = mtdpstore_notify_add,
+ .remove = mtdpstore_notify_remove,
+};
+
+static int __init mtdpstore_init(void)
+{
+ int ret;
+ struct mtdpstore_context *cxt = &oops_cxt;
+ struct mtd_info *mtd = cxt->mtd;
+ struct pstore_blk_config *info = &cxt->info;
+
+ ret = pstore_blk_get_config(info);
+ if (unlikely(ret))
+ return ret;
+
+ if (strlen(info->device) == 0) {
+ dev_err(&mtd->dev, "mtd device must be supplied\n");
+ return -EINVAL;
+ }
+ if (!info->kmsg_size) {
+ dev_err(&mtd->dev, "no backend enabled\n");
+ return -EINVAL;
+ }
+
+ /* Setup the MTD device to use */
+ ret = kstrtoint((char *)info->device, 0, &cxt->index);
+ if (ret)
+ cxt->index = -1;
+
+ register_mtd_user(&mtdpstore_notifier);
+ return 0;
+}
+module_init(mtdpstore_init);
+
+static void __exit mtdpstore_exit(void)
+{
+ unregister_mtd_user(&mtdpstore_notifier);
+}
+module_exit(mtdpstore_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
+MODULE_DESCRIPTION("MTD backend for pstore/blk");
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk
2020-05-10 20:24 ` [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk Kees Cook
@ 2020-05-11 9:01 ` WeiXiong Liao
2020-05-11 23:16 ` Kees Cook
0 siblings, 1 reply; 37+ messages in thread
From: WeiXiong Liao @ 2020-05-11 9:01 UTC (permalink / raw)
To: Kees Cook
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
hi Kees Cook,
On 2020/5/11 AM 4:24, Kees Cook wrote:
> From: WeiXiong Liao <liaoweixiong@allwinnertech.com>
>
> This introduces mtdpstore, which is similar to mtdoops but more
> powerful. It uses pstore/blk, and aims to store panic and oops logs to
> a flash partition, where pstore can later read back and present as files
> in the mounted pstore filesystem.
>
> To make mtdpstore work, the "blkdev" of pstore/blk should be set
> as MTD device name or MTD device number. For more details, see
> Documentation/admin-guide/pstore-blk.rst
>
> This solves a number of issues:
> - Work duplication: both of pstore and mtdoops do the same job storing
> panic/oops log. They have very similar logic, registering to kmsg
> dumper and storing logs to several chunks one by one.
> - Layer violations: drivers should provides methods instead of polices.
> MTD should provide read/write/erase operations, and allow a higher
> level drivers to provide the chunk management, kmsg dump
> configuration, etc.
> - Missing features: pstore provides many additional features, including
> presenting the logs as files, logging dump time and count, and
> supporting other frontends like pmsg, console, etc.
>
> Signed-off-by: WeiXiong Liao <liaoweixiong@allwinnertech.com>
> Link: https://lore.kernel.org/r/1585126506-18635-12-git-send-email-liaoweixiong@allwinnertech.com
> Signed-off-by: Kees Cook <keescook@chromium.org>
> ---
> Documentation/admin-guide/pstore-blk.rst | 9 +-
> drivers/mtd/Kconfig | 10 +
> drivers/mtd/Makefile | 1 +
> drivers/mtd/mtdpstore.c | 564 +++++++++++++++++++++++
> 4 files changed, 582 insertions(+), 2 deletions(-)
> create mode 100644 drivers/mtd/mtdpstore.c
>
> diff --git a/Documentation/admin-guide/pstore-blk.rst b/Documentation/admin-guide/pstore-blk.rst
> index d45341e55e82..296d5027787a 100644
> --- a/Documentation/admin-guide/pstore-blk.rst
> +++ b/Documentation/admin-guide/pstore-blk.rst
> @@ -43,9 +43,9 @@ blkdev
> ~~~~~~
>
> The block device to use. Most of the time, it is a partition of block device.
> -It's required for pstore/blk.
> +It's required for pstore/blk. It is also used for MTD device.
>
> -It accepts the following variants:
> +It accepts the following variants for block device:
>
> 1. <hex_major><hex_minor> device number in hexadecimal represents itself; no
> leading 0x, for example b302.
> @@ -64,6 +64,11 @@ It accepts the following variants:
> partition with a known unique id.
> #. <major>:<minor> major and minor number of the device separated by a colon.
>
> +It accepts the following variants for MTD device:
> +
> +1. <device name> MTD device name. "pstore" is recommended.
> +#. <device number> MTD device number.
> +
> kmsg_size
> ~~~~~~~~~
>
> diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
> index 42d401ea60ee..6ddab796216d 100644
> --- a/drivers/mtd/Kconfig
> +++ b/drivers/mtd/Kconfig
> @@ -170,6 +170,16 @@ config MTD_OOPS
> buffer in a flash partition where it can be read back at some
> later point.
>
> +config MTD_PSTORE
> + tristate "Log panic/oops to an MTD buffer based on pstore"
> + depends on PSTORE_BLK
> + help
> + This enables panic and oops messages to be logged to a circular
> + buffer in a flash partition where it can be read back as files after
> + mounting pstore filesystem.
> +
> + If unsure, say N.
> +
> config MTD_SWAP
> tristate "Swap on MTD device support"
> depends on MTD && SWAP
> diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
> index 56cc60ccc477..593d0593a038 100644
> --- a/drivers/mtd/Makefile
> +++ b/drivers/mtd/Makefile
> @@ -20,6 +20,7 @@ obj-$(CONFIG_RFD_FTL) += rfd_ftl.o
> obj-$(CONFIG_SSFDC) += ssfdc.o
> obj-$(CONFIG_SM_FTL) += sm_ftl.o
> obj-$(CONFIG_MTD_OOPS) += mtdoops.o
> +obj-$(CONFIG_MTD_PSTORE) += mtdpstore.o
> obj-$(CONFIG_MTD_SWAP) += mtdswap.o
>
> nftl-objs := nftlcore.o nftlmount.o
> diff --git a/drivers/mtd/mtdpstore.c b/drivers/mtd/mtdpstore.c
> new file mode 100644
> index 000000000000..ce6da4d04864
> --- /dev/null
> +++ b/drivers/mtd/mtdpstore.c
> @@ -0,0 +1,564 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#define dev_fmt(fmt) "mtdoops-pstore: " fmt
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/pstore_blk.h>
> +#include <linux/mtd/mtd.h>
> +#include <linux/bitops.h>
> +
> +static struct mtdpstore_context {
> + int index;
> + struct pstore_blk_config info;
> + struct pstore_device_info dev;
> + struct mtd_info *mtd;
> + unsigned long *rmmap; /* removed bit map */
> + unsigned long *usedmap; /* used bit map */
> + /*
> + * used for panic write
> + * As there are no block_isbad for panic case, we should keep this
> + * status before panic to ensure panic_write not failed.
> + */
> + unsigned long *badmap; /* bad block bit map */
> +} oops_cxt;
> +
> +static int mtdpstore_block_isbad(struct mtdpstore_context *cxt, loff_t off)
> +{
> + int ret;
> + struct mtd_info *mtd = cxt->mtd;
> + u64 blknum = div_u64(off, mtd->erasesize);
> +
> + if (test_bit(blknum, cxt->badmap))
> + return true;
> + ret = mtd_block_isbad(mtd, off);
> + if (ret < 0) {
> + dev_err(&mtd->dev, "mtd_block_isbad failed, aborting\n");
> + return ret;
> + } else if (ret > 0) {
> + set_bit(blknum, cxt->badmap);
> + return true;
> + }
> + return false;
> +}
> +
> +static inline int mtdpstore_panic_block_isbad(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u64 blknum = div_u64(off, mtd->erasesize);
> +
> + return test_bit(blknum, cxt->badmap);
> +}
> +
> +static inline void mtdpstore_mark_used(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> +
> + dev_dbg(&mtd->dev, "mark zone %llu used\n", zonenum);
> + set_bit(zonenum, cxt->usedmap);
> +}
> +
> +static inline void mtdpstore_mark_unused(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> +
> + dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
> + clear_bit(zonenum, cxt->usedmap);
> +}
> +
> +static inline void mtdpstore_block_mark_unused(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> + u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
> +
> + while (zonecnt > 0) {
> + dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
> + clear_bit(zonenum, cxt->usedmap);
> + zonenum++;
> + zonecnt--;
> + }
> +}
> +
> +static inline int mtdpstore_is_used(struct mtdpstore_context *cxt, loff_t off)
> +{
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> + u64 blknum = div_u64(off, cxt->mtd->erasesize);
> +
> + if (test_bit(blknum, cxt->badmap))
> + return true;
> + return test_bit(zonenum, cxt->usedmap);
> +}
> +
> +static int mtdpstore_block_is_used(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> + u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
> +
> + while (zonecnt > 0) {
> + if (test_bit(zonenum, cxt->usedmap))
> + return true;
> + zonenum++;
> + zonecnt--;
> + }
> + return false;
> +}
> +
> +static int mtdpstore_is_empty(struct mtdpstore_context *cxt, char *buf,
> + size_t size)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + size_t sz;
> + int i;
> +
> + sz = min_t(uint32_t, size, mtd->writesize / 4);
> + for (i = 0; i < sz; i++) {
> + if (buf[i] != (char)0xFF)
> + return false;
> + }
> + return true;
> +}
> +
> +static void mtdpstore_mark_removed(struct mtdpstore_context *cxt, loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> +
> + dev_dbg(&mtd->dev, "mark zone %llu removed\n", zonenum);
> + set_bit(zonenum, cxt->rmmap);
> +}
> +
> +static void mtdpstore_block_clear_removed(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> + u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
> +
> + while (zonecnt > 0) {
> + clear_bit(zonenum, cxt->rmmap);
> + zonenum++;
> + zonecnt--;
> + }
> +}
> +
> +static int mtdpstore_block_is_removed(struct mtdpstore_context *cxt,
> + loff_t off)
> +{
> + u64 zonenum = div_u64(off, cxt->info.kmsg_size);
> + u32 zonecnt = cxt->mtd->erasesize / cxt->info.kmsg_size;
> +
> + while (zonecnt > 0) {
> + if (test_bit(zonenum, cxt->rmmap))
> + return true;
> + zonenum++;
> + zonecnt--;
> + }
> + return false;
> +}
> +
> +static int mtdpstore_erase_do(struct mtdpstore_context *cxt, loff_t off)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + struct erase_info erase;
> + int ret;
> +
> + dev_dbg(&mtd->dev, "try to erase off 0x%llx\n", off);
> + erase.len = cxt->mtd->erasesize;
> + erase.addr = off;
> + ret = mtd_erase(cxt->mtd, &erase);
> + if (!ret)
> + mtdpstore_block_clear_removed(cxt, off);
> + else
> + dev_err(&mtd->dev, "erase of region [0x%llx, 0x%llx] on \"%s\" failed\n",
> + (unsigned long long)erase.addr,
> + (unsigned long long)erase.len, cxt->info.device);
> + return ret;
> +}
> +
> +/*
> + * called while removing file
> + *
> + * Avoiding over erasing, do erase block only when the whole block is unused.
> + * If the block contains valid log, do erase lazily on flush_removed() when
> + * unregister.
> + */
> +static ssize_t mtdpstore_erase(size_t size, loff_t off)
> +{
> + struct mtdpstore_context *cxt = &oops_cxt;
> +
> + if (mtdpstore_block_isbad(cxt, off))
> + return -EIO;
> +
> + mtdpstore_mark_unused(cxt, off);
> +
> + /* If the block still has valid data, mtdpstore do erase lazily */
> + if (likely(mtdpstore_block_is_used(cxt, off))) {
> + mtdpstore_mark_removed(cxt, off);
> + return 0;
> + }
> +
> + /* all zones are unused, erase it */
> + off = ALIGN_DOWN(off, cxt->mtd->erasesize);
> + return mtdpstore_erase_do(cxt, off);
> +}
> +
> +/*
> + * What is security for mtdpstore?
> + * As there is no erase for panic case, we should ensure at least one zone
> + * is writable. Otherwise, panic write will fail.
> + * If zone is used, write operation will return -ENOMSG, which means that
> + * pstore/blk will try one by one until gets an empty zone. So, it is not
> + * needed to ensure the next zone is empty, but at least one.
> + */
> +static int mtdpstore_security(struct mtdpstore_context *cxt, loff_t off)
> +{
> + int ret = 0, i;
> + struct mtd_info *mtd = cxt->mtd;
> + u32 zonenum = (u32)div_u64(off, cxt->info.kmsg_size);
> + u32 zonecnt = (u32)div_u64(cxt->mtd->size, cxt->info.kmsg_size);
> + u32 blkcnt = (u32)div_u64(cxt->mtd->size, cxt->mtd->erasesize);
> + u32 erasesize = cxt->mtd->erasesize;
> +
> + for (i = 0; i < zonecnt; i++) {
> + u32 num = (zonenum + i) % zonecnt;
> +
> + /* found empty zone */
> + if (!test_bit(num, cxt->usedmap))
> + return 0;
> + }
> +
> + /* If there is no any empty zone, we have no way but to do erase */
> + off = ALIGN_DOWN(off, erasesize);
> + while (blkcnt--) {
> + div64_u64_rem(off + erasesize, cxt->mtd->size, (u64 *)&off);
> +
> + if (mtdpstore_block_isbad(cxt, off))
> + continue;
> +
> + ret = mtdpstore_erase_do(cxt, off);
> + if (!ret) {
> + mtdpstore_block_mark_unused(cxt, off);
> + break;
> + }
> + }
> +
> + if (ret)
> + dev_err(&mtd->dev, "all blocks bad!\n");
> + dev_dbg(&mtd->dev, "end security\n");
> + return ret;
> +}
> +
> +static ssize_t mtdpstore_write(const char *buf, size_t size, loff_t off)
> +{
> + struct mtdpstore_context *cxt = &oops_cxt;
> + struct mtd_info *mtd = cxt->mtd;
> + size_t retlen;
> + int ret;
> +
> + if (mtdpstore_block_isbad(cxt, off))
> + return -ENOMSG;
> +
> + /* zone is used, please try next one */
> + if (mtdpstore_is_used(cxt, off))
> + return -ENOMSG;
> +
> + dev_dbg(&mtd->dev, "try to write off 0x%llx size %zu\n", off, size);
> + ret = mtd_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
> + if (ret < 0 || retlen != size) {
> + dev_err(&mtd->dev, "write failure at %lld (%zu of %zu written), err %d\n",
> + off, retlen, size, ret);
> + return -EIO;
> + }
> + mtdpstore_mark_used(cxt, off);
> +
> + mtdpstore_security(cxt, off);
> + return retlen;
> +}
> +
> +static inline bool mtdpstore_is_io_error(int ret)
> +{
> + return ret < 0 && !mtd_is_bitflip(ret) && !mtd_is_eccerr(ret);
> +}
> +
> +/*
> + * All zones will be read as pstore/blk will read zone one by one when do
> + * recover.
> + */
> +static ssize_t mtdpstore_read(char *buf, size_t size, loff_t off)
> +{
> + struct mtdpstore_context *cxt = &oops_cxt;
> + struct mtd_info *mtd = cxt->mtd;
> + size_t retlen, done;
> + int ret;
> +
> + if (mtdpstore_block_isbad(cxt, off))
> + return -ENOMSG;
> +
> + dev_dbg(&mtd->dev, "try to read off 0x%llx size %zu\n", off, size);
> + for (done = 0, retlen = 0; done < size; done += retlen) {
> + retlen = 0;
> +
> + ret = mtd_read(cxt->mtd, off + done, size - done, &retlen,
> + (u_char *)buf + done);
> + if (mtdpstore_is_io_error(ret)) {
> + dev_err(&mtd->dev, "read failure at %lld (%zu of %zu read), err %d\n",
> + off + done, retlen, size - done, ret);
> + /* the zone may be broken, try next one */
> + return -ENOMSG;
> + }
> +
> + /*
> + * ECC error. The impact on log data is so small. Maybe we can
> + * still read it and try to understand. So mtdpstore just hands
> + * over what it gets and user can judge whether the data is
> + * valid or not.
> + */
> + if (mtd_is_eccerr(ret)) {
> + dev_err(&mtd->dev, "ecc error at %lld (%zu of %zu read), err %d\n",
> + off + done, retlen, size - done, ret);
> + /* driver may not set retlen when ecc error */
> + retlen = retlen == 0 ? size - done : retlen;
> + }
> + }
> +
> + if (mtdpstore_is_empty(cxt, buf, size))
> + mtdpstore_mark_unused(cxt, off);
> + else
> + mtdpstore_mark_used(cxt, off);
> +
> + mtdpstore_security(cxt, off);
> + return retlen;
> +}
> +
> +static ssize_t mtdpstore_panic_write(const char *buf, size_t size, loff_t off)
> +{
> + struct mtdpstore_context *cxt = &oops_cxt;
> + struct mtd_info *mtd = cxt->mtd;
> + size_t retlen;
> + int ret;
> +
> + if (mtdpstore_panic_block_isbad(cxt, off))
> + return -ENOMSG;
> +
> + /* zone is used, please try next one */
> + if (mtdpstore_is_used(cxt, off))
> + return -ENOMSG;
> +
> + ret = mtd_panic_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
> + if (ret < 0 || size != retlen) {
> + dev_err(&mtd->dev, "panic write failure at %lld (%zu of %zu read), err %d\n",
> + off, retlen, size, ret);
> + return -EIO;
> + }
> + mtdpstore_mark_used(cxt, off);
> +
> + return retlen;
> +}
> +
> +static void mtdpstore_notify_add(struct mtd_info *mtd)
> +{
> + int ret;
> + struct mtdpstore_context *cxt = &oops_cxt;
> + struct pstore_blk_config *info = &cxt->info;
> + unsigned long longcnt;
> +
> + if (!strcmp(mtd->name, info->device))
> + cxt->index = mtd->index;
> +
> + if (mtd->index != cxt->index || cxt->index < 0)
> + return;
> +
> + dev_dbg(&mtd->dev, "found matching MTD device %s\n", mtd->name);
> +
> + if (mtd->size < info->kmsg_size * 2) {
> + dev_err(&mtd->dev, "MTD partition %d not big enough\n",
> + mtd->index);
> + return;
> + }
> + /*
> + * kmsg_size must be aligned to 4096 Bytes, which is limited by
> + * psblk. The default value of kmsg_size is 64KB. If kmsg_size
> + * is larger than erasesize, some errors will occur since mtdpsotre
> + * is designed on it.
> + */
> + if (mtd->erasesize < info->kmsg_size) {
> + dev_err(&mtd->dev, "eraseblock size of MTD partition %d too small\n",
> + mtd->index);
> + return;
> + }
> + if (unlikely(info->kmsg_size % mtd->writesize)) {
> + dev_err(&mtd->dev, "record size %lu KB must align to write size %d KB\n",
> + info->kmsg_size / 1024,
> + mtd->writesize / 1024);
> + return;
> + }
> +
> + longcnt = BITS_TO_LONGS(div_u64(mtd->size, info->kmsg_size));
> + cxt->rmmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
> + cxt->usedmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
> +
> + longcnt = BITS_TO_LONGS(div_u64(mtd->size, mtd->erasesize));
> + cxt->badmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
> +
> + cxt->dev.total_size = mtd->size;
> + /* just support dmesg right now */
> + cxt->dev.flags = PSTORE_FLAGS_DMESG;
> + cxt->dev.read = mtdpstore_read;
> + cxt->dev.write = mtdpstore_write;
> + cxt->dev.erase = mtdpstore_erase;
> + cxt->dev.panic_write = mtdpstore_panic_write;
> +
> + ret = register_pstore_device(&cxt->dev);
> + if (ret) {
> + dev_err(&mtd->dev, "mtd%d register to psblk failed\n",
> + mtd->index);
> + return;
> + }
> + cxt->mtd = mtd;
> + dev_info(&mtd->dev, "Attached to MTD device %d\n", mtd->index);
> +}
> +
> +static int mtdpstore_flush_removed_do(struct mtdpstore_context *cxt,
> + loff_t off, size_t size)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + u_char *buf;
> + int ret;
> + size_t retlen;
> + struct erase_info erase;
> +
> + buf = kmalloc(mtd->erasesize, GFP_KERNEL);
> + if (!buf)
> + return -ENOMEM;
> +
> + /* 1st. read to cache */
> + ret = mtd_read(mtd, off, mtd->erasesize, &retlen, buf);
> + if (mtdpstore_is_io_error(ret))
> + goto free;
> +
> + /* 2nd. erase block */
> + erase.len = mtd->erasesize;
> + erase.addr = off;
> + ret = mtd_erase(mtd, &erase);
> + if (ret)
> + goto free;
> +
> + /* 3rd. write back */
> + while (size) {
> + unsigned int zonesize = cxt->info.kmsg_size;
> +
> + /* there is valid data on block, write back */
> + if (mtdpstore_is_used(cxt, off)) {
> + ret = mtd_write(mtd, off, zonesize, &retlen, buf);
> + if (ret)
> + dev_err(&mtd->dev, "write failure at %lld (%zu of %u written), err %d\n",
> + off, retlen, zonesize, ret);
> + }
> +
> + off += zonesize;
> + size -= min_t(unsigned int, zonesize, size);
> + }
> +
> +free:
> + kfree(buf);
> + return ret;
> +}
> +
> +/*
> + * What does mtdpstore_flush_removed() do?
> + * When user remove any log file on pstore filesystem, mtdpstore should do
> + * something to ensure log file removed. If the whole block is no longer used,
> + * it's nice to erase the block. However if the block still contains valid log,
> + * what mtdpstore can do is to erase and write the valid log back.
> + */
> +static int mtdpstore_flush_removed(struct mtdpstore_context *cxt)
> +{
> + struct mtd_info *mtd = cxt->mtd;
> + int ret;
> + loff_t off;
> + u32 blkcnt = (u32)div_u64(mtd->size, mtd->erasesize);
> +
> + for (off = 0; blkcnt > 0; blkcnt--, off += mtd->erasesize) {
> + ret = mtdpstore_block_isbad(cxt, off);
> + if (ret)
> + continue;
> +
> + ret = mtdpstore_block_is_removed(cxt, off);
> + if (!ret)
> + continue;
> +
> + ret = mtdpstore_flush_removed_do(cxt, off, mtd->erasesize);
> + if (ret)
> + return ret;
> + }
> + return 0;
> +}
> +
> +static void mtdpstore_notify_remove(struct mtd_info *mtd)
> +{
> + struct mtdpstore_context *cxt = &oops_cxt;
> +
> + if (mtd->index != cxt->index || cxt->index < 0)
> + return;
> +
> + mtdpstore_flush_removed(cxt);
> +
> + unregister_pstore_device(&cxt->dev);
> + kfree(cxt->badmap);
> + kfree(cxt->usedmap);
> + kfree(cxt->rmmap);
> + cxt->mtd = NULL;
> + cxt->index = -1;
> +}
> +
> +static struct mtd_notifier mtdpstore_notifier = {
> + .add = mtdpstore_notify_add,
> + .remove = mtdpstore_notify_remove,
> +};
> +
> +static int __init mtdpstore_init(void)
> +{
> + int ret;
> + struct mtdpstore_context *cxt = &oops_cxt;
> + struct mtd_info *mtd = cxt->mtd;
> + struct pstore_blk_config *info = &cxt->info;
> +
> + ret = pstore_blk_get_config(info);
> + if (unlikely(ret))
> + return ret;
> +
> + if (strlen(info->device) == 0) {
> + dev_err(&mtd->dev, "mtd device must be supplied\n");
mtd is NULL here, "mtd->dev" leads to error.
> + return -EINVAL;
> + }
> + if (!info->kmsg_size) {
> + dev_err(&mtd->dev, "no backend enabled\n");
Also here.
> + return -EINVAL;
> + }
> +
> + /* Setup the MTD device to use */
> + ret = kstrtoint((char *)info->device, 0, &cxt->index);
> + if (ret)
> + cxt->index = -1;
> +
> + register_mtd_user(&mtdpstore_notifier);
> + return 0;
> +}
> +module_init(mtdpstore_init);
> +
> +static void __exit mtdpstore_exit(void)
> +{
> + unregister_mtd_user(&mtdpstore_notifier);
> +}
> +module_exit(mtdpstore_exit);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
> +MODULE_DESCRIPTION("MTD backend for pstore/blk");
>
--
WeiXiong Liao
^ permalink raw reply [flat|nested] 37+ messages in thread* Re: [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk
2020-05-11 9:01 ` WeiXiong Liao
@ 2020-05-11 23:16 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:16 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Mon, May 11, 2020 at 05:01:26PM +0800, WeiXiong Liao wrote:
> On 2020/5/11 AM 4:24, Kees Cook wrote:
> > [...]
> > + if (strlen(info->device) == 0) {
> > + dev_err(&mtd->dev, "mtd device must be supplied\n");
>
> mtd is NULL here, "mtd->dev" leads to error.
>
> > + return -EINVAL;
> > + }
> > + if (!info->kmsg_size) {
> > + dev_err(&mtd->dev, "no backend enabled\n");
>
> Also here.
Thanks! Fixed.
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* [PATCH v7 18/18] pstore/blk: Introduce "best_effort" mode
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (16 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 17/18] mtd: Support kmsg dumper based on pstore/blk Kees Cook
@ 2020-05-10 20:24 ` Kees Cook
2020-05-11 10:54 ` [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device WeiXiong Liao
2020-05-11 22:39 ` Kees Cook
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-10 20:24 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Kees Cook, Anton Vorontsov, Colin Cross, Tony Luck,
Jonathan Corbet, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Petr Mladek, Sergey Senozhatsky,
Steven Rostedt, Rob Herring, Pavel Tatashin, linux-doc,
linux-kernel, linux-mtd
In order to use arbitrary block devices as a pstore backend, provide a
new module param named "best_effort", which will allow using any block
device, even if it has not provided a panic_write callback.
Signed-off-by: Kees Cook <keescook@chromium.org>
---
fs/pstore/blk.c | 21 ++++++++++++++++++++-
1 file changed, 20 insertions(+), 1 deletion(-)
diff --git a/fs/pstore/blk.c b/fs/pstore/blk.c
index 0dea8ded2de2..ad46860d5a78 100644
--- a/fs/pstore/blk.c
+++ b/fs/pstore/blk.c
@@ -51,6 +51,10 @@ static long ftrace_size = -1;
module_param(ftrace_size, long, 0400);
MODULE_PARM_DESC(ftrace_size, "ftrace size in kbytes");
+static bool best_effort;
+module_param(best_effort, bool, 0400);
+MODULE_PARM_DESC(best_effort, "use best effort to write (i.e. do not require storage driver pstore support, default: off)");
+
/*
* blkdev - the block device to use for pstore storage
*
@@ -376,7 +380,8 @@ static int __register_pstore_blk(struct pstore_blk_info *info)
}
/* only allow driver matching the @blkdev */
- if (!binfo.devt || MAJOR(binfo.devt) != info->major) {
+ if (!binfo.devt || (!best_effort &&
+ MAJOR(binfo.devt) != info->major)) {
pr_debug("invalid major %u (expect %u)\n",
info->major, MAJOR(binfo.devt));
ret = -ENODEV;
@@ -479,6 +484,20 @@ int pstore_blk_get_config(struct pstore_blk_config *info)
}
EXPORT_SYMBOL_GPL(pstore_blk_get_config);
+static int __init pstore_blk_init(void)
+{
+ struct pstore_blk_info info = { };
+ int ret = 0;
+
+ mutex_lock(&pstore_blk_lock);
+ if (!pstore_zone_info && best_effort && blkdev[0])
+ ret = __register_pstore_blk(&info);
+ mutex_unlock(&pstore_blk_lock);
+
+ return ret;
+}
+late_initcall(pstore_blk_init);
+
static void __exit pstore_blk_exit(void)
{
mutex_lock(&pstore_blk_lock);
--
2.20.1
^ permalink raw reply related [flat|nested] 37+ messages in thread* Re: [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (17 preceding siblings ...)
2020-05-10 20:24 ` [PATCH v7 18/18] pstore/blk: Introduce "best_effort" mode Kees Cook
@ 2020-05-11 10:54 ` WeiXiong Liao
2020-05-11 23:17 ` Kees Cook
2020-05-11 22:39 ` Kees Cook
19 siblings, 1 reply; 37+ messages in thread
From: WeiXiong Liao @ 2020-05-11 10:54 UTC (permalink / raw)
To: Kees Cook
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
Hi Kees Cook,
On 2020/5/11 AM 4:24, Kees Cook wrote:
> Hi!
>
> Well, I guess I spoke too soon. :) Here is v7. Hopefully this is
> it. WeiXiong, can you test this and make sure you're happy with the
> results?
I tested it on Allwinner board for all frontends, including panic.
All of them work well! That's a very good news.
>
> Take care!
>
> -Kees
>
> v7:
> - more renamings in the exported APIs and structs
> - fix mtd build
> - replace psblk_blkdev_info with passing in a struct to fill
> - consolidate bdev opening/checking
> - rename psblk_device -> pstore_device_info
> - kerndoc for pstore_blk_get_config
> - fix hunks in wrong patch
> - add missing "static"s for local functions (0day)
>
> v6: https://lore.kernel.org/lkml/20200509234103.46544-1-keescook@chromium.org/
> v5: https://lore.kernel.org/lkml/1589022854-19821-1-git-send-email-liaoweixiong@allwinnertech.com/
> v4: https://lore.kernel.org/lkml/20200508064004.57898-1-keescook@chromium.org/
> v3: https://lore.kernel.org/lkml/1585126506-18635-1-git-send-email-liaoweixiong@allwinnertech.com/
> v2: https://lore.kernel.org/lkml/1581078355-19647-1-git-send-email-liaoweixiong@allwinnertech.com/
> v1: https://lore.kernel.org/lkml/1579482233-2672-1-git-send-email-liaoweixiong@allwinnertech.com/
>
>
> Kees Cook (8):
> pstore/ram: Move dump_oops to end of module_param list
> pstore/platform: Switch pstore_info::name to const
> pstore/platform: Move module params after declarations
> pstore/platform: Use backend name for console registration
> pstore/ram: Refactor ftrace buffer merging
> pstore/ftrace: Provide ftrace log merging routine
> printk: Introduce kmsg_dump_reason_str()
> pstore/blk: Introduce "best_effort" mode
>
> WeiXiong Liao (10):
> pstore/zone: Introduce common layer to manage storage zones
> pstore/blk: Introduce backend for block devices
> pstore/zone,blk: Add support for pmsg frontend
> pstore/zone,blk: Add console frontend support
> pstore/zone,blk: Add ftrace frontend support
> Documentation: Add details for pstore/blk
> pstore/zone: Provide way to skip "broken" zone for MTD devices
> pstore/blk: Provide way to query pstore configuration
> pstore/blk: Support non-block storage devices
> mtd: Support kmsg dumper based on pstore/blk
>
> Documentation/admin-guide/pstore-blk.rst | 243 ++++
> MAINTAINERS | 1 +
> drivers/mtd/Kconfig | 10 +
> drivers/mtd/Makefile | 1 +
> drivers/mtd/mtdpstore.c | 564 +++++++++
> fs/pstore/Kconfig | 109 ++
> fs/pstore/Makefile | 6 +
> fs/pstore/blk.c | 520 ++++++++
> fs/pstore/ftrace.c | 54 +
> fs/pstore/internal.h | 9 +
> fs/pstore/platform.c | 40 +-
> fs/pstore/ram.c | 70 +-
> fs/pstore/zone.c | 1463 ++++++++++++++++++++++
> include/linux/kmsg_dump.h | 7 +
> include/linux/pstore.h | 2 +-
> include/linux/pstore_blk.h | 118 ++
> include/linux/pstore_zone.h | 60 +
> kernel/printk/printk.c | 21 +
> 18 files changed, 3210 insertions(+), 88 deletions(-)
> create mode 100644 Documentation/admin-guide/pstore-blk.rst
> create mode 100644 drivers/mtd/mtdpstore.c
> create mode 100644 fs/pstore/blk.c
> create mode 100644 fs/pstore/zone.c
> create mode 100644 include/linux/pstore_blk.h
> create mode 100644 include/linux/pstore_zone.h
>
--
WeiXiong Liao
^ permalink raw reply [flat|nested] 37+ messages in thread* Re: [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device
2020-05-11 10:54 ` [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device WeiXiong Liao
@ 2020-05-11 23:17 ` Kees Cook
0 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 23:17 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Mon, May 11, 2020 at 06:54:11PM +0800, WeiXiong Liao wrote:
> On 2020/5/11 AM 4:24, Kees Cook wrote:
> > Hi!
> >
> > Well, I guess I spoke too soon. :) Here is v7. Hopefully this is
> > it. WeiXiong, can you test this and make sure you're happy with the
> > results?
>
> I tested it on Allwinner board for all frontends, including panic.
> All of them work well! That's a very good news.
Great! I'll get v8 sent out. :) Thanks!
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread
* Re: [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device
2020-05-10 20:24 [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device Kees Cook
` (18 preceding siblings ...)
2020-05-11 10:54 ` [PATCH v7 00/18] pstore: mtd: support crash log to block and mtd device WeiXiong Liao
@ 2020-05-11 22:39 ` Kees Cook
19 siblings, 0 replies; 37+ messages in thread
From: Kees Cook @ 2020-05-11 22:39 UTC (permalink / raw)
To: WeiXiong Liao
Cc: Anton Vorontsov, Colin Cross, Tony Luck, Jonathan Corbet,
Miquel Raynal, Richard Weinberger, Vignesh Raghavendra,
Petr Mladek, Sergey Senozhatsky, Steven Rostedt, Rob Herring,
Pavel Tatashin, linux-doc, linux-kernel, linux-mtd
On Sun, May 10, 2020 at 01:24:18PM -0700, Kees Cook wrote:
> pstore/ram: Move dump_oops to end of module_param list
> pstore/platform: Switch pstore_info::name to const
> pstore/platform: Move module params after declarations
> pstore/platform: Use backend name for console registration
> pstore/ram: Refactor ftrace buffer merging
> pstore/ftrace: Provide ftrace log merging routine
> printk: Introduce kmsg_dump_reason_str()
For those following along, I've added these to for-next/pstore, as
they're all prep patches for the rest of this series.
--
Kees Cook
^ permalink raw reply [flat|nested] 37+ messages in thread