diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig index b42e5bd6d8ffdd124cdadbbaa05c267510cbca09..09c19ef91526ccc41cd84edcd87c27915fafb8b7 100644 --- a/fs/pstore/Kconfig +++ b/fs/pstore/Kconfig @@ -1,5 +1,6 @@ config PSTORE tristate "Persistent store support" + select CRYPTO if PSTORE_COMPRESS default n help This option enables generic access to platform level @@ -12,35 +13,89 @@ config PSTORE If you don't have a platform persistent store driver, say N. -choice - prompt "Choose compression algorithm" - depends on PSTORE - default PSTORE_ZLIB_COMPRESS - help - This option chooses compression algorithm. - -config PSTORE_ZLIB_COMPRESS - bool "ZLIB" - select ZLIB_DEFLATE - select ZLIB_INFLATE - help - This option enables ZLIB compression algorithm support. +config PSTORE_DEFLATE_COMPRESS + tristate "DEFLATE (ZLIB) compression" + default y + depends on PSTORE + select CRYPTO_DEFLATE + help + This option enables DEFLATE (also known as ZLIB) compression + algorithm support. config PSTORE_LZO_COMPRESS - bool "LZO" - select LZO_COMPRESS - select LZO_DECOMPRESS - help - This option enables LZO compression algorithm support. + tristate "LZO compression" + depends on PSTORE + select CRYPTO_LZO + help + This option enables LZO compression algorithm support. config PSTORE_LZ4_COMPRESS - bool "LZ4" - select LZ4_COMPRESS - select LZ4_DECOMPRESS - help - This option enables LZ4 compression algorithm support. + tristate "LZ4 compression" + depends on PSTORE + select CRYPTO_LZ4 + help + This option enables LZ4 compression algorithm support. + +config PSTORE_LZ4HC_COMPRESS + tristate "LZ4HC compression" + depends on PSTORE + select CRYPTO_LZ4HC + help + This option enables LZ4HC (high compression) mode algorithm. + +config PSTORE_842_COMPRESS + bool "842 compression" + depends on PSTORE + select CRYPTO_842 + help + This option enables 842 compression algorithm support. + +config PSTORE_COMPRESS + def_bool y + depends on PSTORE + depends on PSTORE_DEFLATE_COMPRESS || PSTORE_LZO_COMPRESS || \ + PSTORE_LZ4_COMPRESS || PSTORE_LZ4HC_COMPRESS || \ + PSTORE_842_COMPRESS + +choice + prompt "Default pstore compression algorithm" + depends on PSTORE_COMPRESS + help + This option chooses the default active compression algorithm. + This change be changed at boot with "pstore.compress=..." on + the kernel command line. + + Currently, pstore has support for 5 compression algorithms: + deflate, lzo, lz4, lz4hc and 842. + + The default compression algorithm is deflate. + + config PSTORE_DEFLATE_COMPRESS_DEFAULT + bool "deflate" if PSTORE_DEFLATE_COMPRESS + + config PSTORE_LZO_COMPRESS_DEFAULT + bool "lzo" if PSTORE_LZO_COMPRESS + + config PSTORE_LZ4_COMPRESS_DEFAULT + bool "lz4" if PSTORE_LZ4_COMPRESS + + config PSTORE_LZ4HC_COMPRESS_DEFAULT + bool "lz4hc" if PSTORE_LZ4HC_COMPRESS + + config PSTORE_842_COMPRESS_DEFAULT + bool "842" if PSTORE_842_COMPRESS + endchoice +config PSTORE_COMPRESS_DEFAULT + string + depends on PSTORE_COMPRESS + default "deflate" if PSTORE_DEFLATE_COMPRESS_DEFAULT + default "lzo" if PSTORE_LZO_COMPRESS_DEFAULT + default "lz4" if PSTORE_LZ4_COMPRESS_DEFAULT + default "lz4hc" if PSTORE_LZ4HC_COMPRESS_DEFAULT + default "842" if PSTORE_842_COMPRESS_DEFAULT + config PSTORE_CONSOLE bool "Log kernel console messages" depends on PSTORE diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c index d814723fb27dcdfc80168bf97a5c10ab20fcc0c2..5fcb845b9fec1295c1a3a894acf8c2ce042d3f17 100644 --- a/fs/pstore/inode.c +++ b/fs/pstore/inode.c @@ -486,6 +486,8 @@ static int __init init_pstore_fs(void) { int err; + pstore_choose_compression(); + /* Create a convenient mount point for people to access pstore */ err = sysfs_create_mount_point(fs_kobj, "pstore"); if (err) diff --git a/fs/pstore/internal.h b/fs/pstore/internal.h index c029314478fad020a46e27562ee5936d0e3b407b..fb767e28aeb28333ffbc2446b94ad5167234e3ba 100644 --- a/fs/pstore/internal.h +++ b/fs/pstore/internal.h @@ -37,4 +37,7 @@ extern bool pstore_is_mounted(void); extern void pstore_record_init(struct pstore_record *record, struct pstore_info *psi); +/* Called during module_init() */ +extern void __init pstore_choose_compression(void); + #endif diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c index c3129b131e4d7ac8515459523aadcb32963e937d..1143ef351c58a313e9e5681154ae8499009bca9a 100644 --- a/fs/pstore/platform.c +++ b/fs/pstore/platform.c @@ -28,15 +28,13 @@ #include #include #include -#ifdef CONFIG_PSTORE_ZLIB_COMPRESS -#include -#endif -#ifdef CONFIG_PSTORE_LZO_COMPRESS +#if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) #include #endif -#ifdef CONFIG_PSTORE_LZ4_COMPRESS +#if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) #include #endif +#include #include #include #include @@ -74,23 +72,18 @@ static DEFINE_SPINLOCK(pstore_lock); struct pstore_info *psinfo; static char *backend; - -/* Compression parameters */ -#ifdef CONFIG_PSTORE_ZLIB_COMPRESS -#define COMPR_LEVEL 6 -#define WINDOW_BITS 12 -#define MEM_LEVEL 4 -static struct z_stream_s stream; +static char *compress = +#ifdef CONFIG_PSTORE_COMPRESS_DEFAULT + CONFIG_PSTORE_COMPRESS_DEFAULT; #else -static unsigned char *workspace; + NULL; #endif -struct pstore_zbackend { - int (*compress)(const void *in, void *out, size_t inlen, size_t outlen); - int (*decompress)(void *in, void *out, size_t inlen, size_t outlen); - void (*allocate)(void); - void (*free)(void); +/* Compression parameters */ +static struct crypto_comp *tfm; +struct pstore_zbackend { + int (*zbufsize)(size_t size); const char *name; }; @@ -149,77 +142,12 @@ bool pstore_cannot_block_path(enum kmsg_dump_reason reason) } EXPORT_SYMBOL_GPL(pstore_cannot_block_path); -#ifdef CONFIG_PSTORE_ZLIB_COMPRESS -/* Derived from logfs_compress() */ -static int compress_zlib(const void *in, void *out, size_t inlen, size_t outlen) -{ - int err, ret; - - ret = -EIO; - err = zlib_deflateInit2(&stream, COMPR_LEVEL, Z_DEFLATED, WINDOW_BITS, - MEM_LEVEL, Z_DEFAULT_STRATEGY); - if (err != Z_OK) - goto error; - - stream.next_in = in; - stream.avail_in = inlen; - stream.total_in = 0; - stream.next_out = out; - stream.avail_out = outlen; - stream.total_out = 0; - - err = zlib_deflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) - goto error; - - err = zlib_deflateEnd(&stream); - if (err != Z_OK) - goto error; - - if (stream.total_out >= stream.total_in) - goto error; - - ret = stream.total_out; -error: - return ret; -} - -/* Derived from logfs_uncompress */ -static int decompress_zlib(void *in, void *out, size_t inlen, size_t outlen) +#if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) +static int zbufsize_deflate(size_t size) { - int err, ret; - - ret = -EIO; - err = zlib_inflateInit2(&stream, WINDOW_BITS); - if (err != Z_OK) - goto error; - - stream.next_in = in; - stream.avail_in = inlen; - stream.total_in = 0; - stream.next_out = out; - stream.avail_out = outlen; - stream.total_out = 0; - - err = zlib_inflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) - goto error; - - err = zlib_inflateEnd(&stream); - if (err != Z_OK) - goto error; - - ret = stream.total_out; -error: - return ret; -} - -static void allocate_zlib(void) -{ - size_t size; size_t cmpr; - switch (psinfo->bufsize) { + switch (size) { /* buffer range for efivars */ case 1000 ... 2000: cmpr = 56; @@ -239,212 +167,131 @@ static void allocate_zlib(void) break; } - big_oops_buf_sz = (psinfo->bufsize * 100) / cmpr; - big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); - if (big_oops_buf) { - size = max(zlib_deflate_workspacesize(WINDOW_BITS, MEM_LEVEL), - zlib_inflate_workspacesize()); - stream.workspace = kmalloc(size, GFP_KERNEL); - if (!stream.workspace) { - pr_err("No memory for compression workspace; skipping compression\n"); - kfree(big_oops_buf); - big_oops_buf = NULL; - } - } else { - pr_err("No memory for uncompressed data; skipping compression\n"); - stream.workspace = NULL; - } - + return (size * 100) / cmpr; } - -static void free_zlib(void) -{ - kfree(stream.workspace); - stream.workspace = NULL; - kfree(big_oops_buf); - big_oops_buf = NULL; - big_oops_buf_sz = 0; -} - -static const struct pstore_zbackend backend_zlib = { - .compress = compress_zlib, - .decompress = decompress_zlib, - .allocate = allocate_zlib, - .free = free_zlib, - .name = "zlib", -}; #endif -#ifdef CONFIG_PSTORE_LZO_COMPRESS -static int compress_lzo(const void *in, void *out, size_t inlen, size_t outlen) +#if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) +static int zbufsize_lzo(size_t size) { - int ret; - - ret = lzo1x_1_compress(in, inlen, out, &outlen, workspace); - if (ret != LZO_E_OK) { - pr_err("lzo_compress error, ret = %d!\n", ret); - return -EIO; - } - - return outlen; + return lzo1x_worst_compress(size); } +#endif -static int decompress_lzo(void *in, void *out, size_t inlen, size_t outlen) +#if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) || IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) +static int zbufsize_lz4(size_t size) { - int ret; - - ret = lzo1x_decompress_safe(in, inlen, out, &outlen); - if (ret != LZO_E_OK) { - pr_err("lzo_decompress error, ret = %d!\n", ret); - return -EIO; - } - - return outlen; + return LZ4_compressBound(size); } +#endif -static void allocate_lzo(void) +#if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) +static int zbufsize_842(size_t size) { - big_oops_buf_sz = lzo1x_worst_compress(psinfo->bufsize); - big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); - if (big_oops_buf) { - workspace = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL); - if (!workspace) { - pr_err("No memory for compression workspace; skipping compression\n"); - kfree(big_oops_buf); - big_oops_buf = NULL; - } - } else { - pr_err("No memory for uncompressed data; skipping compression\n"); - workspace = NULL; - } + return size; } +#endif -static void free_lzo(void) -{ - kfree(workspace); - kfree(big_oops_buf); - big_oops_buf = NULL; - big_oops_buf_sz = 0; -} +static const struct pstore_zbackend *zbackend __ro_after_init; -static const struct pstore_zbackend backend_lzo = { - .compress = compress_lzo, - .decompress = decompress_lzo, - .allocate = allocate_lzo, - .free = free_lzo, - .name = "lzo", -}; +static const struct pstore_zbackend zbackends[] = { +#if IS_ENABLED(CONFIG_PSTORE_DEFLATE_COMPRESS) + { + .zbufsize = zbufsize_deflate, + .name = "deflate", + }, +#endif +#if IS_ENABLED(CONFIG_PSTORE_LZO_COMPRESS) + { + .zbufsize = zbufsize_lzo, + .name = "lzo", + }, +#endif +#if IS_ENABLED(CONFIG_PSTORE_LZ4_COMPRESS) + { + .zbufsize = zbufsize_lz4, + .name = "lz4", + }, #endif +#if IS_ENABLED(CONFIG_PSTORE_LZ4HC_COMPRESS) + { + .zbufsize = zbufsize_lz4, + .name = "lz4hc", + }, +#endif +#if IS_ENABLED(CONFIG_PSTORE_842_COMPRESS) + { + .zbufsize = zbufsize_842, + .name = "842", + }, +#endif + { } +}; -#ifdef CONFIG_PSTORE_LZ4_COMPRESS -static int compress_lz4(const void *in, void *out, size_t inlen, size_t outlen) +static int pstore_compress(const void *in, void *out, + unsigned int inlen, unsigned int outlen) { int ret; - ret = LZ4_compress_default(in, out, inlen, outlen, workspace); - if (!ret) { - pr_err("LZ4_compress_default error; compression failed!\n"); - return -EIO; + ret = crypto_comp_compress(tfm, in, inlen, out, &outlen); + if (ret) { + pr_err("crypto_comp_compress failed, ret = %d!\n", ret); + return ret; } - return ret; + return outlen; } -static int decompress_lz4(void *in, void *out, size_t inlen, size_t outlen) +static int pstore_decompress(void *in, void *out, + unsigned int inlen, unsigned int outlen) { int ret; - ret = LZ4_decompress_safe(in, out, inlen, outlen); - if (ret < 0) { - /* - * LZ4_decompress_safe will return an error code - * (< 0) if decompression failed - */ - pr_err("LZ4_decompress_safe error, ret = %d!\n", ret); - return -EIO; + ret = crypto_comp_decompress(tfm, in, inlen, out, &outlen); + if (ret) { + pr_err("crypto_comp_decompress failed, ret = %d!\n", ret); + return ret; } - return ret; -} - -static void allocate_lz4(void) -{ - big_oops_buf_sz = LZ4_compressBound(psinfo->bufsize); - big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); - if (big_oops_buf) { - workspace = kmalloc(LZ4_MEM_COMPRESS, GFP_KERNEL); - if (!workspace) { - pr_err("No memory for compression workspace; skipping compression\n"); - kfree(big_oops_buf); - big_oops_buf = NULL; - } - } else { - pr_err("No memory for uncompressed data; skipping compression\n"); - workspace = NULL; - } + return outlen; } -static void free_lz4(void) +static void allocate_buf_for_compression(void) { - kfree(workspace); - kfree(big_oops_buf); - big_oops_buf = NULL; - big_oops_buf_sz = 0; -} - -static const struct pstore_zbackend backend_lz4 = { - .compress = compress_lz4, - .decompress = decompress_lz4, - .allocate = allocate_lz4, - .free = free_lz4, - .name = "lz4", -}; -#endif - -static const struct pstore_zbackend *zbackend = -#if defined(CONFIG_PSTORE_ZLIB_COMPRESS) - &backend_zlib; -#elif defined(CONFIG_PSTORE_LZO_COMPRESS) - &backend_lzo; -#elif defined(CONFIG_PSTORE_LZ4_COMPRESS) - &backend_lz4; -#else - NULL; -#endif + if (!zbackend) + return; -static int pstore_compress(const void *in, void *out, - size_t inlen, size_t outlen) -{ - if (zbackend) - return zbackend->compress(in, out, inlen, outlen); - else - return -EIO; -} + if (!crypto_has_comp(zbackend->name, 0, 0)) { + pr_err("No %s compression\n", zbackend->name); + return; + } -static int pstore_decompress(void *in, void *out, size_t inlen, size_t outlen) -{ - if (zbackend) - return zbackend->decompress(in, out, inlen, outlen); - else - return -EIO; -} + big_oops_buf_sz = zbackend->zbufsize(psinfo->bufsize); + if (big_oops_buf_sz <= 0) + return; -static void allocate_buf_for_compression(void) -{ - if (zbackend) { - pr_info("using %s compression\n", zbackend->name); - zbackend->allocate(); - } else { + big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); + if (!big_oops_buf) { pr_err("allocate compression buffer error!\n"); + return; + } + + tfm = crypto_alloc_comp(zbackend->name, 0, 0); + if (IS_ERR_OR_NULL(tfm)) { + kfree(big_oops_buf); + big_oops_buf = NULL; + pr_err("crypto_alloc_comp() failed!\n"); + return; } } static void free_buf_for_compression(void) { - if (zbackend) - zbackend->free(); - else - pr_err("free compression buffer error!\n"); + if (!IS_ERR_OR_NULL(tfm)) + crypto_free_comp(tfm); + kfree(big_oops_buf); + big_oops_buf = NULL; + big_oops_buf_sz = 0; } /* @@ -901,5 +748,24 @@ static void pstore_timefunc(struct timer_list *unused) jiffies + msecs_to_jiffies(pstore_update_ms)); } +void __init pstore_choose_compression(void) +{ + const struct pstore_zbackend *step; + + if (!compress) + return; + + for (step = zbackends; step->name; step++) { + if (!strcmp(compress, step->name)) { + zbackend = step; + pr_info("using %s compression\n", zbackend->name); + return; + } + } +} + +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"); diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c index 7125b398d312e71714d96d4ed51baeff2e149601..49b2bc1148683bd0a986e74e17bfb101fbd59b33 100644 --- a/fs/pstore/ram.c +++ b/fs/pstore/ram.c @@ -938,7 +938,7 @@ static int __init ramoops_init(void) ramoops_register_dummy(); return platform_driver_register(&ramoops_driver); } -postcore_initcall(ramoops_init); +late_initcall(ramoops_init); static void __exit ramoops_exit(void) { diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c index e11672aa457514b8d84695688edc342f80a57b20..951a14edcf518bb95a5ec01c9e98ae678cb1e67f 100644 --- a/fs/pstore/ram_core.c +++ b/fs/pstore/ram_core.c @@ -98,24 +98,23 @@ static void notrace persistent_ram_encode_rs8(struct persistent_ram_zone *prz, uint8_t *data, size_t len, uint8_t *ecc) { int i; - uint16_t par[prz->ecc_info.ecc_size]; /* Initialize the parity buffer */ - memset(par, 0, sizeof(par)); - encode_rs8(prz->rs_decoder, data, len, par, 0); + memset(prz->ecc_info.par, 0, + prz->ecc_info.ecc_size * sizeof(prz->ecc_info.par[0])); + encode_rs8(prz->rs_decoder, data, len, prz->ecc_info.par, 0); for (i = 0; i < prz->ecc_info.ecc_size; i++) - ecc[i] = par[i]; + ecc[i] = prz->ecc_info.par[i]; } static int persistent_ram_decode_rs8(struct persistent_ram_zone *prz, void *data, size_t len, uint8_t *ecc) { int i; - uint16_t par[prz->ecc_info.ecc_size]; for (i = 0; i < prz->ecc_info.ecc_size; i++) - par[i] = ecc[i]; - return decode_rs8(prz->rs_decoder, data, par, len, + prz->ecc_info.par[i] = ecc[i]; + return decode_rs8(prz->rs_decoder, data, prz->ecc_info.par, len, NULL, 0, NULL, 0, NULL); } @@ -228,6 +227,15 @@ static int persistent_ram_init_ecc(struct persistent_ram_zone *prz, return -EINVAL; } + /* allocate workspace instead of using stack VLA */ + prz->ecc_info.par = kmalloc_array(prz->ecc_info.ecc_size, + sizeof(*prz->ecc_info.par), + GFP_KERNEL); + if (!prz->ecc_info.par) { + pr_err("cannot allocate ECC parity workspace\n"); + return -ENOMEM; + } + prz->corrected_bytes = 0; prz->bad_blocks = 0; @@ -514,6 +522,13 @@ void persistent_ram_free(struct persistent_ram_zone *prz) } prz->vaddr = NULL; } + if (prz->rs_decoder) { + free_rs(prz->rs_decoder); + prz->rs_decoder = NULL; + } + kfree(prz->ecc_info.par); + prz->ecc_info.par = NULL; + persistent_ram_free_old(prz); kfree(prz); } diff --git a/include/linux/pstore_ram.h b/include/linux/pstore_ram.h index 9395f06e837217f05d039eab57c39d71ae0fd9cb..e6d226464838a1e2b67c77145207ae5e27cb589b 100644 --- a/include/linux/pstore_ram.h +++ b/include/linux/pstore_ram.h @@ -39,6 +39,7 @@ struct persistent_ram_ecc_info { int ecc_size; int symsize; int poly; + uint16_t *par; }; struct persistent_ram_zone {