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;