Merge tag 'please-pull-pstore' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux

Pull pstore changes from Tony Luck:
 "A big part of this is the addition of compression to the generic
  pstore layer so that all backends can use the pitiful amounts of
  storage they control more effectively.  Three other small
  fixes/cleanups too.

* tag 'please-pull-pstore' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux:
  pstore/ram: (really) fix undefined usage of rounddown_pow_of_two
  pstore/ram: Read and write to the 'compressed' flag of pstore
  efi-pstore: Read and write to the 'compressed' flag of pstore
  erst: Read and write to the 'compressed' flag of pstore
  powerpc/pseries: Read and write to the 'compressed' flag of pstore
  pstore: Add file extension to pstore file if compressed
  pstore: Add decompression support to pstore
  pstore: Introduce new argument 'compressed' in the read callback
  pstore: Add compression support to pstore
  pstore/Kconfig: Select ZLIB_DEFLATE and ZLIB_INFLATE when PSTORE is selected
  pstore: Add new argument 'compressed' in pstore write callback
  powerpc/pseries: Remove (de)compression in nvram with pstore enabled
  pstore: d_alloc_name() doesn't return an ERR_PTR
  acpi/apei/erst: Add missing iounmap() on error in erst_exec_move_data()

5 files changed, 242 insertions, 34 deletions

diff --git a/fs/pstore/Kconfig b/fs/pstore/Kconfig
index ca71db69da07..983d9510becc 100644
--- a/fs/pstore/Kconfig
+++ b/fs/pstore/Kconfig
@@ -1,6 +1,8 @@
 config PSTORE
         bool "Persistent store support"
         default n
+        select ZLIB_DEFLATE
+        select ZLIB_INFLATE
         help
            This option enables generic access to platform level
            persistent storage via "pstore" filesystem that can
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index 71bf5f4ae84c..12823845d324 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -275,8 +275,8 @@ int pstore_is_mounted(void)
  * Set the mtime & ctime to the date that this record was originally stored.
  */
 int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
-                  char *data, size_t size, struct timespec time,
-                  struct pstore_info *psi)
+                  char *data, bool compressed, size_t size,
+                  struct timespec time, struct pstore_info *psi)
 {
         struct dentry           *root = pstore_sb->s_root;
         struct dentry           *dentry;
@@ -315,7 +315,8 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
 
         switch (type) {
         case PSTORE_TYPE_DMESG:
-                sprintf(name, "dmesg-%s-%lld", psname, id);
+                sprintf(name, "dmesg-%s-%lld%s", psname, id,
+                                                compressed ? ".enc.z" : "");
                 break;
         case PSTORE_TYPE_CONSOLE:
                 sprintf(name, "console-%s", psname);
@@ -345,9 +346,8 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
 
         mutex_lock(&root->d_inode->i_mutex);
 
-        rc = -ENOSPC;
         dentry = d_alloc_name(root, name);
-        if (IS_ERR(dentry))
+        if (!dentry)
                 goto fail_lockedalloc;
 
         memcpy(private->data, data, size);
diff --git a/fs/pstore/internal.h b/fs/pstore/internal.h
index 937d820f273c..3b3d305277c4 100644
--- a/fs/pstore/internal.h
+++ b/fs/pstore/internal.h
@@ -50,8 +50,9 @@ extern struct pstore_info *psinfo;
 extern void     pstore_set_kmsg_bytes(int);
 extern void     pstore_get_records(int);
 extern int      pstore_mkfile(enum pstore_type_id, char *psname, u64 id,
-                              int count, char *data, size_t size,
-                              struct timespec time, struct pstore_info *psi);
+                              int count, char *data, bool compressed,
+                              size_t size, struct timespec time,
+                              struct pstore_info *psi);
 extern int      pstore_is_mounted(void);
 
 #endif
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 422962ae9fc2..4ffb7ab5e397 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -26,6 +26,7 @@
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/pstore.h>
+#include <linux/zlib.h>
 #include <linux/string.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
@@ -65,6 +66,15 @@ struct pstore_info *psinfo;
 
 static char *backend;
 
+/* Compression parameters */
+#define COMPR_LEVEL 6
+#define WINDOW_BITS 12
+#define MEM_LEVEL 4
+static struct z_stream_s stream;
+
+static char *big_oops_buf;
+static size_t big_oops_buf_sz;
+
 /* How much of the console log to snapshot */
 static unsigned long kmsg_bytes = 10240;
 
@@ -117,6 +127,121 @@ bool pstore_cannot_block_path(enum kmsg_dump_reason reason)
 }
 EXPORT_SYMBOL_GPL(pstore_cannot_block_path);
 
+/* Derived from logfs_compress() */
+static int pstore_compress(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 pstore_decompress(void *in, void *out, size_t inlen, size_t outlen)
+{
+        int err, ret;
+
+        ret = -EIO;
+        err = zlib_inflateInit(&stream);
+        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_buf_for_compression(void)
+{
+        size_t size;
+
+        big_oops_buf_sz = (psinfo->bufsize * 100) / 45;
+        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("pstore: 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;
+        }
+
+}
+
+/*
+ * Called when compression fails, since the printk buffer
+ * would be fetched for compression calling it again when
+ * compression fails would have moved the iterator of
+ * printk buffer which results in fetching old contents.
+ * Copy the recent messages from big_oops_buf to psinfo->buf
+ */
+static size_t copy_kmsg_to_buffer(int hsize, size_t len)
+{
+        size_t total_len;
+        size_t diff;
+
+        total_len = hsize + len;
+
+        if (total_len > psinfo->bufsize) {
+                diff = total_len - psinfo->bufsize + hsize;
+                memcpy(psinfo->buf, big_oops_buf, hsize);
+                memcpy(psinfo->buf + hsize, big_oops_buf + diff,
+                                        psinfo->bufsize - hsize);
+                total_len = psinfo->bufsize;
+        } else
+                memcpy(psinfo->buf, big_oops_buf, total_len);
+
+        return total_len;
+}
+
 /*
  * callback from kmsg_dump. (s2,l2) has the most recently
  * written bytes, older bytes are in (s1,l1). Save as much
@@ -148,22 +273,56 @@ static void pstore_dump(struct kmsg_dumper *dumper,
                 char *dst;
                 unsigned long size;
                 int hsize;
+                int zipped_len = -1;
                 size_t len;
+                bool compressed;
+                size_t total_len;
 
-                dst = psinfo->buf;
-                hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part);
-                size = psinfo->bufsize - hsize;
-                dst += hsize;
+                if (big_oops_buf) {
+                        dst = big_oops_buf;
+                        hsize = sprintf(dst, "%s#%d Part%d\n", why,
+                                                        oopscount, part);
+                        size = big_oops_buf_sz - hsize;
 
-                if (!kmsg_dump_get_buffer(dumper, true, dst, size, &len))
-                        break;
+                        if (!kmsg_dump_get_buffer(dumper, true, dst + hsize,
+                                                                size, &len))
+                                break;
+
+                        zipped_len = pstore_compress(dst, psinfo->buf,
+                                                hsize + len, psinfo->bufsize);
+
+                        if (zipped_len > 0) {
+                                compressed = true;
+                                total_len = zipped_len;
+                        } else {
+                                pr_err("pstore: compression failed for Part %d"
+                                        " returned %d\n", part, zipped_len);
+                                pr_err("pstore: Capture uncompressed"
+                                        " oops/panic report of Part %d\n", part);
+                                compressed = false;
+                                total_len = copy_kmsg_to_buffer(hsize, len);
+                        }
+                } else {
+                        dst = psinfo->buf;
+                        hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount,
+                                                                        part);
+                        size = psinfo->bufsize - hsize;
+                        dst += hsize;
+
+                        if (!kmsg_dump_get_buffer(dumper, true, dst,
+                                                                size, &len))
+                                break;
+
+                        compressed = false;
+                        total_len = hsize + len;
+                }
 
                 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part,
-                                    oopscount, hsize, hsize + len, psinfo);
+                                    oopscount, compressed, total_len, psinfo);
                 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted())
                         pstore_new_entry = 1;
 
-                total += hsize + len;
+                total += total_len;
                 part++;
         }
         if (pstore_cannot_block_path(reason)) {
@@ -221,10 +380,10 @@ static void pstore_register_console(void) {}
 static int pstore_write_compat(enum pstore_type_id type,
                                enum kmsg_dump_reason reason,
                                u64 *id, unsigned int part, int count,
-                               size_t hsize, size_t size,
+                               bool compressed, size_t size,
                                struct pstore_info *psi)
 {
-        return psi->write_buf(type, reason, id, part, psinfo->buf, hsize,
+        return psi->write_buf(type, reason, id, part, psinfo->buf, compressed,
                              size, psi);
 }
 
@@ -261,6 +420,8 @@ int pstore_register(struct pstore_info *psi)
                 return -EINVAL;
         }
 
+        allocate_buf_for_compression();
+
         if (pstore_is_mounted())
                 pstore_get_records(0);
 
@@ -297,6 +458,8 @@ void pstore_get_records(int quiet)
         enum pstore_type_id     type;
         struct timespec         time;
         int                     failed = 0, rc;
+        bool                    compressed;
+        int                     unzipped_len = -1;
 
         if (!psi)
                 return;
@@ -305,11 +468,32 @@ void pstore_get_records(int quiet)
         if (psi->open && psi->open(psi))
                 goto out;
 
-        while ((size = psi->read(&id, &type, &count, &time, &buf, psi)) > 0) {
+        while ((size = psi->read(&id, &type, &count, &time, &buf, &compressed,
+                                psi)) > 0) {
+                if (compressed && (type == PSTORE_TYPE_DMESG)) {
+                        if (big_oops_buf)
+                                unzipped_len = pstore_decompress(buf,
+                                                        big_oops_buf, size,
+                                                        big_oops_buf_sz);
+
+                        if (unzipped_len > 0) {
+                                buf = big_oops_buf;
+                                size = unzipped_len;
+                                compressed = false;
+                        } else {
+                                pr_err("pstore: decompression failed;"
+                                        "returned %d\n", unzipped_len);
+                                compressed = true;
+                        }
+                }
                 rc = pstore_mkfile(type, psi->name, id, count, buf,
-                                  (size_t)size, time, psi);
-                kfree(buf);
-                buf = NULL;
+                                  compressed, (size_t)size, time, psi);
+                if (unzipped_len < 0) {
+                        /* Free buffer other than big oops */
+                        kfree(buf);
+                        buf = NULL;
+                } else
+                        unzipped_len = -1;
                 if (rc && (rc != -EEXIST || !quiet))
                         failed++;
         }
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index a6119f9469e2..fa8cef2cca3a 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -131,9 +131,31 @@ ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max,
         return prz;
 }
 
+static void ramoops_read_kmsg_hdr(char *buffer, struct timespec *time,
+                                  bool *compressed)
+{
+        char data_type;
+
+        if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
+                        &time->tv_sec, &time->tv_nsec, &data_type) == 3) {
+                if (data_type == 'C')
+                        *compressed = true;
+                else
+                        *compressed = false;
+        } else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu\n",
+                        &time->tv_sec, &time->tv_nsec) == 2) {
+                        *compressed = false;
+        } else {
+                time->tv_sec = 0;
+                time->tv_nsec = 0;
+                *compressed = false;
+        }
+}
+
 static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
                                    int *count, struct timespec *time,
-                                   char **buf, struct pstore_info *psi)
+                                   char **buf, bool *compressed,
+                                   struct pstore_info *psi)
 {
         ssize_t size;
         ssize_t ecc_notice_size;
@@ -152,10 +174,6 @@ static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
         if (!prz)
                 return 0;
 
-        /* TODO(kees): Bogus time for the moment. */
-        time->tv_sec = 0;
-        time->tv_nsec = 0;
-
         size = persistent_ram_old_size(prz);
 
         /* ECC correction notice */
@@ -166,12 +184,14 @@ static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
                 return -ENOMEM;
 
         memcpy(*buf, persistent_ram_old(prz), size);
+        ramoops_read_kmsg_hdr(*buf, time, compressed);
         persistent_ram_ecc_string(prz, *buf + size, ecc_notice_size + 1);
 
         return size + ecc_notice_size;
 }
 
-static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz)
+static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
+                                     bool compressed)
 {
         char *hdr;
         struct timespec timestamp;
@@ -182,8 +202,9 @@ static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz)
                 timestamp.tv_sec = 0;
                 timestamp.tv_nsec = 0;
         }
-        hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu\n",
-                (long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000));
+        hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
+                (long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000),
+                compressed ? 'C' : 'D');
         WARN_ON_ONCE(!hdr);
         len = hdr ? strlen(hdr) : 0;
         persistent_ram_write(prz, hdr, len);
@@ -196,7 +217,7 @@ static int notrace ramoops_pstore_write_buf(enum pstore_type_id type,
                                             enum kmsg_dump_reason reason,
                                             u64 *id, unsigned int part,
                                             const char *buf,
-                                            size_t hsize, size_t size,
+                                            bool compressed, size_t size,
                                             struct pstore_info *psi)
 {
         struct ramoops_context *cxt = psi->data;
@@ -242,7 +263,7 @@ static int notrace ramoops_pstore_write_buf(enum pstore_type_id type,
 
         prz = cxt->przs[cxt->dump_write_cnt];
 
-        hlen = ramoops_write_kmsg_hdr(prz);
+        hlen = ramoops_write_kmsg_hdr(prz, compressed);
         if (size + hlen > prz->buffer_size)
                 size = prz->buffer_size - hlen;
         persistent_ram_write(prz, buf, size);
@@ -400,11 +421,11 @@ static int ramoops_probe(struct platform_device *pdev)
                 goto fail_out;
         }
 
-        if (!is_power_of_2(pdata->record_size))
+        if (pdata->record_size && !is_power_of_2(pdata->record_size))
                 pdata->record_size = rounddown_pow_of_two(pdata->record_size);
-        if (!is_power_of_2(pdata->console_size))
+        if (pdata->console_size && !is_power_of_2(pdata->console_size))
                 pdata->console_size = rounddown_pow_of_two(pdata->console_size);
-        if (!is_power_of_2(pdata->ftrace_size))
+        if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
                 pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
 
         cxt->dump_read_cnt = 0;