Merge branch 'akpm' (incoming from Andrew)

Merge second patch-bomb from Andrew Morton:
 - the rest of MM
 - zram updates
 - zswap updates
 - exit
 - procfs
 - exec
 - wait
 - crash dump
 - lib/idr
 - rapidio
 - adfs, affs, bfs, ufs
 - cris
 - Kconfig things
 - initramfs
 - small amount of IPC material
 - percpu enhancements
 - early ioremap support
 - various other misc things

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (156 commits)
  MAINTAINERS: update Intel C600 SAS driver maintainers
  fs/ufs: remove unused ufs_super_block_third pointer
  fs/ufs: remove unused ufs_super_block_second pointer
  fs/ufs: remove unused ufs_super_block_first pointer
  fs/ufs/super.c: add __init to init_inodecache()
  doc/kernel-parameters.txt: add early_ioremap_debug
  arm64: add early_ioremap support
  arm64: initialize pgprot info earlier in boot
  x86: use generic early_ioremap
  mm: create generic early_ioremap() support
  x86/mm: sparse warning fix for early_memremap
  lglock: map to spinlock when !CONFIG_SMP
  percpu: add preemption checks to __this_cpu ops
  vmstat: use raw_cpu_ops to avoid false positives on preemption checks
  slub: use raw_cpu_inc for incrementing statistics
  net: replace __this_cpu_inc in route.c with raw_cpu_inc
  modules: use raw_cpu_write for initialization of per cpu refcount.
  mm: use raw_cpu ops for determining current NUMA node
  percpu: add raw_cpu_ops
  slub: fix leak of 'name' in sysfs_slab_add
  ...

10 files changed, 797 insertions, 170 deletions

diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig
index 3450be850399..6489c0fd0ea6 100644
--- a/drivers/block/zram/Kconfig
+++ b/drivers/block/zram/Kconfig
@@ -15,6 +15,16 @@ config ZRAM
 
           See zram.txt for more information.
 
+config ZRAM_LZ4_COMPRESS
+        bool "Enable LZ4 algorithm support"
+        depends on ZRAM
+        select LZ4_COMPRESS
+        select LZ4_DECOMPRESS
+        default n
+        help
+          This option enables LZ4 compression algorithm support. Compression
+          algorithm can be changed using `comp_algorithm' device attribute.
+
 config ZRAM_DEBUG
         bool "Compressed RAM block device debug support"
         depends on ZRAM
diff --git a/drivers/block/zram/Makefile b/drivers/block/zram/Makefile
index cb0f9ced6a93..be0763ff57a2 100644
--- a/drivers/block/zram/Makefile
+++ b/drivers/block/zram/Makefile
@@ -1,3 +1,5 @@
-zram-y  :=      zram_drv.o
+zram-y  :=      zcomp_lzo.o zcomp.o zram_drv.o
+
+zram-$(CONFIG_ZRAM_LZ4_COMPRESS) += zcomp_lz4.o
 
 obj-$(CONFIG_ZRAM)      +=      zram.o
diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c
new file mode 100644
index 000000000000..f1ff39a3d1c1
--- /dev/null
+++ b/drivers/block/zram/zcomp.c
@@ -0,0 +1,353 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+
+#include "zcomp.h"
+#include "zcomp_lzo.h"
+#ifdef CONFIG_ZRAM_LZ4_COMPRESS
+#include "zcomp_lz4.h"
+#endif
+
+/*
+ * single zcomp_strm backend
+ */
+struct zcomp_strm_single {
+        struct mutex strm_lock;
+        struct zcomp_strm *zstrm;
+};
+
+/*
+ * multi zcomp_strm backend
+ */
+struct zcomp_strm_multi {
+        /* protect strm list */
+        spinlock_t strm_lock;
+        /* max possible number of zstrm streams */
+        int max_strm;
+        /* number of available zstrm streams */
+        int avail_strm;
+        /* list of available strms */
+        struct list_head idle_strm;
+        wait_queue_head_t strm_wait;
+};
+
+static struct zcomp_backend *backends[] = {
+        &zcomp_lzo,
+#ifdef CONFIG_ZRAM_LZ4_COMPRESS
+        &zcomp_lz4,
+#endif
+        NULL
+};
+
+static struct zcomp_backend *find_backend(const char *compress)
+{
+        int i = 0;
+        while (backends[i]) {
+                if (sysfs_streq(compress, backends[i]->name))
+                        break;
+                i++;
+        }
+        return backends[i];
+}
+
+static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm)
+{
+        if (zstrm->private)
+                comp->backend->destroy(zstrm->private);
+        free_pages((unsigned long)zstrm->buffer, 1);
+        kfree(zstrm);
+}
+
+/*
+ * allocate new zcomp_strm structure with ->private initialized by
+ * backend, return NULL on error
+ */
+static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp)
+{
+        struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_KERNEL);
+        if (!zstrm)
+                return NULL;
+
+        zstrm->private = comp->backend->create();
+        /*
+         * allocate 2 pages. 1 for compressed data, plus 1 extra for the
+         * case when compressed size is larger than the original one
+         */
+        zstrm->buffer = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1);
+        if (!zstrm->private || !zstrm->buffer) {
+                zcomp_strm_free(comp, zstrm);
+                zstrm = NULL;
+        }
+        return zstrm;
+}
+
+/*
+ * get idle zcomp_strm or wait until other process release
+ * (zcomp_strm_release()) one for us
+ */
+static struct zcomp_strm *zcomp_strm_multi_find(struct zcomp *comp)
+{
+        struct zcomp_strm_multi *zs = comp->stream;
+        struct zcomp_strm *zstrm;
+
+        while (1) {
+                spin_lock(&zs->strm_lock);
+                if (!list_empty(&zs->idle_strm)) {
+                        zstrm = list_entry(zs->idle_strm.next,
+                                        struct zcomp_strm, list);
+                        list_del(&zstrm->list);
+                        spin_unlock(&zs->strm_lock);
+                        return zstrm;
+                }
+                /* zstrm streams limit reached, wait for idle stream */
+                if (zs->avail_strm >= zs->max_strm) {
+                        spin_unlock(&zs->strm_lock);
+                        wait_event(zs->strm_wait, !list_empty(&zs->idle_strm));
+                        continue;
+                }
+                /* allocate new zstrm stream */
+                zs->avail_strm++;
+                spin_unlock(&zs->strm_lock);
+
+                zstrm = zcomp_strm_alloc(comp);
+                if (!zstrm) {
+                        spin_lock(&zs->strm_lock);
+                        zs->avail_strm--;
+                        spin_unlock(&zs->strm_lock);
+                        wait_event(zs->strm_wait, !list_empty(&zs->idle_strm));
+                        continue;
+                }
+                break;
+        }
+        return zstrm;
+}
+
+/* add stream back to idle list and wake up waiter or free the stream */
+static void zcomp_strm_multi_release(struct zcomp *comp, struct zcomp_strm *zstrm)
+{
+        struct zcomp_strm_multi *zs = comp->stream;
+
+        spin_lock(&zs->strm_lock);
+        if (zs->avail_strm <= zs->max_strm) {
+                list_add(&zstrm->list, &zs->idle_strm);
+                spin_unlock(&zs->strm_lock);
+                wake_up(&zs->strm_wait);
+                return;
+        }
+
+        zs->avail_strm--;
+        spin_unlock(&zs->strm_lock);
+        zcomp_strm_free(comp, zstrm);
+}
+
+/* change max_strm limit */
+static bool zcomp_strm_multi_set_max_streams(struct zcomp *comp, int num_strm)
+{
+        struct zcomp_strm_multi *zs = comp->stream;
+        struct zcomp_strm *zstrm;
+
+        spin_lock(&zs->strm_lock);
+        zs->max_strm = num_strm;
+        /*
+         * if user has lowered the limit and there are idle streams,
+         * immediately free as much streams (and memory) as we can.
+         */
+        while (zs->avail_strm > num_strm && !list_empty(&zs->idle_strm)) {
+                zstrm = list_entry(zs->idle_strm.next,
+                                struct zcomp_strm, list);
+                list_del(&zstrm->list);
+                zcomp_strm_free(comp, zstrm);
+                zs->avail_strm--;
+        }
+        spin_unlock(&zs->strm_lock);
+        return true;
+}
+
+static void zcomp_strm_multi_destroy(struct zcomp *comp)
+{
+        struct zcomp_strm_multi *zs = comp->stream;
+        struct zcomp_strm *zstrm;
+
+        while (!list_empty(&zs->idle_strm)) {
+                zstrm = list_entry(zs->idle_strm.next,
+                                struct zcomp_strm, list);
+                list_del(&zstrm->list);
+                zcomp_strm_free(comp, zstrm);
+        }
+        kfree(zs);
+}
+
+static int zcomp_strm_multi_create(struct zcomp *comp, int max_strm)
+{
+        struct zcomp_strm *zstrm;
+        struct zcomp_strm_multi *zs;
+
+        comp->destroy = zcomp_strm_multi_destroy;
+        comp->strm_find = zcomp_strm_multi_find;
+        comp->strm_release = zcomp_strm_multi_release;
+        comp->set_max_streams = zcomp_strm_multi_set_max_streams;
+        zs = kmalloc(sizeof(struct zcomp_strm_multi), GFP_KERNEL);
+        if (!zs)
+                return -ENOMEM;
+
+        comp->stream = zs;
+        spin_lock_init(&zs->strm_lock);
+        INIT_LIST_HEAD(&zs->idle_strm);
+        init_waitqueue_head(&zs->strm_wait);
+        zs->max_strm = max_strm;
+        zs->avail_strm = 1;
+
+        zstrm = zcomp_strm_alloc(comp);
+        if (!zstrm) {
+                kfree(zs);
+                return -ENOMEM;
+        }
+        list_add(&zstrm->list, &zs->idle_strm);
+        return 0;
+}
+
+static struct zcomp_strm *zcomp_strm_single_find(struct zcomp *comp)
+{
+        struct zcomp_strm_single *zs = comp->stream;
+        mutex_lock(&zs->strm_lock);
+        return zs->zstrm;
+}
+
+static void zcomp_strm_single_release(struct zcomp *comp,
+                struct zcomp_strm *zstrm)
+{
+        struct zcomp_strm_single *zs = comp->stream;
+        mutex_unlock(&zs->strm_lock);
+}
+
+static bool zcomp_strm_single_set_max_streams(struct zcomp *comp, int num_strm)
+{
+        /* zcomp_strm_single support only max_comp_streams == 1 */
+        return false;
+}
+
+static void zcomp_strm_single_destroy(struct zcomp *comp)
+{
+        struct zcomp_strm_single *zs = comp->stream;
+        zcomp_strm_free(comp, zs->zstrm);
+        kfree(zs);
+}
+
+static int zcomp_strm_single_create(struct zcomp *comp)
+{
+        struct zcomp_strm_single *zs;
+
+        comp->destroy = zcomp_strm_single_destroy;
+        comp->strm_find = zcomp_strm_single_find;
+        comp->strm_release = zcomp_strm_single_release;
+        comp->set_max_streams = zcomp_strm_single_set_max_streams;
+        zs = kmalloc(sizeof(struct zcomp_strm_single), GFP_KERNEL);
+        if (!zs)
+                return -ENOMEM;
+
+        comp->stream = zs;
+        mutex_init(&zs->strm_lock);
+        zs->zstrm = zcomp_strm_alloc(comp);
+        if (!zs->zstrm) {
+                kfree(zs);
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+/* show available compressors */
+ssize_t zcomp_available_show(const char *comp, char *buf)
+{
+        ssize_t sz = 0;
+        int i = 0;
+
+        while (backends[i]) {
+                if (sysfs_streq(comp, backends[i]->name))
+                        sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
+                                        "[%s] ", backends[i]->name);
+                else
+                        sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
+                                        "%s ", backends[i]->name);
+                i++;
+        }
+        sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n");
+        return sz;
+}
+
+bool zcomp_set_max_streams(struct zcomp *comp, int num_strm)
+{
+        return comp->set_max_streams(comp, num_strm);
+}
+
+struct zcomp_strm *zcomp_strm_find(struct zcomp *comp)
+{
+        return comp->strm_find(comp);
+}
+
+void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm)
+{
+        comp->strm_release(comp, zstrm);
+}
+
+int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
+                const unsigned char *src, size_t *dst_len)
+{
+        return comp->backend->compress(src, zstrm->buffer, dst_len,
+                        zstrm->private);
+}
+
+int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
+                size_t src_len, unsigned char *dst)
+{
+        return comp->backend->decompress(src, src_len, dst);
+}
+
+void zcomp_destroy(struct zcomp *comp)
+{
+        comp->destroy(comp);
+        kfree(comp);
+}
+
+/*
+ * search available compressors for requested algorithm.
+ * allocate new zcomp and initialize it. return compressing
+ * backend pointer or ERR_PTR if things went bad. ERR_PTR(-EINVAL)
+ * if requested algorithm is not supported, ERR_PTR(-ENOMEM) in
+ * case of allocation error.
+ */
+struct zcomp *zcomp_create(const char *compress, int max_strm)
+{
+        struct zcomp *comp;
+        struct zcomp_backend *backend;
+
+        backend = find_backend(compress);
+        if (!backend)
+                return ERR_PTR(-EINVAL);
+
+        comp = kzalloc(sizeof(struct zcomp), GFP_KERNEL);
+        if (!comp)
+                return ERR_PTR(-ENOMEM);
+
+        comp->backend = backend;
+        if (max_strm > 1)
+                zcomp_strm_multi_create(comp, max_strm);
+        else
+                zcomp_strm_single_create(comp);
+        if (!comp->stream) {
+                kfree(comp);
+                return ERR_PTR(-ENOMEM);
+        }
+        return comp;
+}
diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h
new file mode 100644
index 000000000000..c59d1fca72c0
--- /dev/null
+++ b/drivers/block/zram/zcomp.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _ZCOMP_H_
+#define _ZCOMP_H_
+
+#include <linux/mutex.h>
+
+struct zcomp_strm {
+        /* compression/decompression buffer */
+        void *buffer;
+        /*
+         * The private data of the compression stream, only compression
+         * stream backend can touch this (e.g. compression algorithm
+         * working memory)
+         */
+        void *private;
+        /* used in multi stream backend, protected by backend strm_lock */
+        struct list_head list;
+};
+
+/* static compression backend */
+struct zcomp_backend {
+        int (*compress)(const unsigned char *src, unsigned char *dst,
+                        size_t *dst_len, void *private);
+
+        int (*decompress)(const unsigned char *src, size_t src_len,
+                        unsigned char *dst);
+
+        void *(*create)(void);
+        void (*destroy)(void *private);
+
+        const char *name;
+};
+
+/* dynamic per-device compression frontend */
+struct zcomp {
+        void *stream;
+        struct zcomp_backend *backend;
+
+        struct zcomp_strm *(*strm_find)(struct zcomp *comp);
+        void (*strm_release)(struct zcomp *comp, struct zcomp_strm *zstrm);
+        bool (*set_max_streams)(struct zcomp *comp, int num_strm);
+        void (*destroy)(struct zcomp *comp);
+};
+
+ssize_t zcomp_available_show(const char *comp, char *buf);
+
+struct zcomp *zcomp_create(const char *comp, int max_strm);
+void zcomp_destroy(struct zcomp *comp);
+
+struct zcomp_strm *zcomp_strm_find(struct zcomp *comp);
+void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm);
+
+int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
+                const unsigned char *src, size_t *dst_len);
+
+int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
+                size_t src_len, unsigned char *dst);
+
+bool zcomp_set_max_streams(struct zcomp *comp, int num_strm);
+#endif /* _ZCOMP_H_ */
diff --git a/drivers/block/zram/zcomp_lz4.c b/drivers/block/zram/zcomp_lz4.c
new file mode 100644
index 000000000000..f2afb7e988c3
--- /dev/null
+++ b/drivers/block/zram/zcomp_lz4.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/lz4.h>
+
+#include "zcomp_lz4.h"
+
+static void *zcomp_lz4_create(void)
+{
+        return kzalloc(LZ4_MEM_COMPRESS, GFP_KERNEL);
+}
+
+static void zcomp_lz4_destroy(void *private)
+{
+        kfree(private);
+}
+
+static int zcomp_lz4_compress(const unsigned char *src, unsigned char *dst,
+                size_t *dst_len, void *private)
+{
+        /* return  : Success if return 0 */
+        return lz4_compress(src, PAGE_SIZE, dst, dst_len, private);
+}
+
+static int zcomp_lz4_decompress(const unsigned char *src, size_t src_len,
+                unsigned char *dst)
+{
+        size_t dst_len = PAGE_SIZE;
+        /* return  : Success if return 0 */
+        return lz4_decompress_unknownoutputsize(src, src_len, dst, &dst_len);
+}
+
+struct zcomp_backend zcomp_lz4 = {
+        .compress = zcomp_lz4_compress,
+        .decompress = zcomp_lz4_decompress,
+        .create = zcomp_lz4_create,
+        .destroy = zcomp_lz4_destroy,
+        .name = "lz4",
+};
diff --git a/drivers/block/zram/zcomp_lz4.h b/drivers/block/zram/zcomp_lz4.h
new file mode 100644
index 000000000000..60613fb29dd8
--- /dev/null
+++ b/drivers/block/zram/zcomp_lz4.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _ZCOMP_LZ4_H_
+#define _ZCOMP_LZ4_H_
+
+#include "zcomp.h"
+
+extern struct zcomp_backend zcomp_lz4;
+
+#endif /* _ZCOMP_LZ4_H_ */
diff --git a/drivers/block/zram/zcomp_lzo.c b/drivers/block/zram/zcomp_lzo.c
new file mode 100644
index 000000000000..da1bc47d588e
--- /dev/null
+++ b/drivers/block/zram/zcomp_lzo.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/lzo.h>
+
+#include "zcomp_lzo.h"
+
+static void *lzo_create(void)
+{
+        return kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
+}
+
+static void lzo_destroy(void *private)
+{
+        kfree(private);
+}
+
+static int lzo_compress(const unsigned char *src, unsigned char *dst,
+                size_t *dst_len, void *private)
+{
+        int ret = lzo1x_1_compress(src, PAGE_SIZE, dst, dst_len, private);
+        return ret == LZO_E_OK ? 0 : ret;
+}
+
+static int lzo_decompress(const unsigned char *src, size_t src_len,
+                unsigned char *dst)
+{
+        size_t dst_len = PAGE_SIZE;
+        int ret = lzo1x_decompress_safe(src, src_len, dst, &dst_len);
+        return ret == LZO_E_OK ? 0 : ret;
+}
+
+struct zcomp_backend zcomp_lzo = {
+        .compress = lzo_compress,
+        .decompress = lzo_decompress,
+        .create = lzo_create,
+        .destroy = lzo_destroy,
+        .name = "lzo",
+};
diff --git a/drivers/block/zram/zcomp_lzo.h b/drivers/block/zram/zcomp_lzo.h
new file mode 100644
index 000000000000..128c5807fa14
--- /dev/null
+++ b/drivers/block/zram/zcomp_lzo.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _ZCOMP_LZO_H_
+#define _ZCOMP_LZO_H_
+
+#include "zcomp.h"
+
+extern struct zcomp_backend zcomp_lzo;
+
+#endif /* _ZCOMP_LZO_H_ */
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 51c557cfd92b..9849b5233bf4 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -29,19 +29,36 @@
 #include <linux/genhd.h>
 #include <linux/highmem.h>
 #include <linux/slab.h>
-#include <linux/lzo.h>
 #include <linux/string.h>
 #include <linux/vmalloc.h>
+#include <linux/err.h>
 
 #include "zram_drv.h"
 
 /* Globals */
 static int zram_major;
 static struct zram *zram_devices;
+static const char *default_compressor = "lzo";
 
 /* Module params (documentation at end) */
 static unsigned int num_devices = 1;
 
+#define ZRAM_ATTR_RO(name)                                              \
+static ssize_t zram_attr_##name##_show(struct device *d,                \
+                                struct device_attribute *attr, char *b) \
+{                                                                       \
+        struct zram *zram = dev_to_zram(d);                             \
+        return scnprintf(b, PAGE_SIZE, "%llu\n",                        \
+                (u64)atomic64_read(&zram->stats.name));                 \
+}                                                                       \
+static struct device_attribute dev_attr_##name =                        \
+        __ATTR(name, S_IRUGO, zram_attr_##name##_show, NULL);
+
+static inline int init_done(struct zram *zram)
+{
+        return zram->meta != NULL;
+}
+
 static inline struct zram *dev_to_zram(struct device *dev)
 {
         return (struct zram *)dev_to_disk(dev)->private_data;
@@ -52,92 +69,114 @@ static ssize_t disksize_show(struct device *dev,
 {
         struct zram *zram = dev_to_zram(dev);
 
-        return sprintf(buf, "%llu\n", zram->disksize);
+        return scnprintf(buf, PAGE_SIZE, "%llu\n", zram->disksize);
 }
 
 static ssize_t initstate_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
+        u32 val;
         struct zram *zram = dev_to_zram(dev);
 
-        return sprintf(buf, "%u\n", zram->init_done);
-}
-
-static ssize_t num_reads_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct zram *zram = dev_to_zram(dev);
+        down_read(&zram->init_lock);
+        val = init_done(zram);
+        up_read(&zram->init_lock);
 
-        return sprintf(buf, "%llu\n",
-                        (u64)atomic64_read(&zram->stats.num_reads));
+        return scnprintf(buf, PAGE_SIZE, "%u\n", val);
 }
 
-static ssize_t num_writes_show(struct device *dev,
+static ssize_t orig_data_size_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         struct zram *zram = dev_to_zram(dev);
 
-        return sprintf(buf, "%llu\n",
-                        (u64)atomic64_read(&zram->stats.num_writes));
+        return scnprintf(buf, PAGE_SIZE, "%llu\n",
+                (u64)(atomic64_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
 }
 
-static ssize_t invalid_io_show(struct device *dev,
+static ssize_t mem_used_total_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
+        u64 val = 0;
         struct zram *zram = dev_to_zram(dev);
+        struct zram_meta *meta = zram->meta;
 
-        return sprintf(buf, "%llu\n",
-                        (u64)atomic64_read(&zram->stats.invalid_io));
-}
-
-static ssize_t notify_free_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct zram *zram = dev_to_zram(dev);
+        down_read(&zram->init_lock);
+        if (init_done(zram))
+                val = zs_get_total_size_bytes(meta->mem_pool);
+        up_read(&zram->init_lock);
 
-        return sprintf(buf, "%llu\n",
-                        (u64)atomic64_read(&zram->stats.notify_free));
+        return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
 }
 
-static ssize_t zero_pages_show(struct device *dev,
+static ssize_t max_comp_streams_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
+        int val;
         struct zram *zram = dev_to_zram(dev);
 
-        return sprintf(buf, "%u\n", atomic_read(&zram->stats.pages_zero));
+        down_read(&zram->init_lock);
+        val = zram->max_comp_streams;
+        up_read(&zram->init_lock);
+
+        return scnprintf(buf, PAGE_SIZE, "%d\n", val);
 }
 
-static ssize_t orig_data_size_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
+static ssize_t max_comp_streams_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
 {
+        int num;
         struct zram *zram = dev_to_zram(dev);
+        int ret;
 
-        return sprintf(buf, "%llu\n",
-                (u64)(atomic_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
-}
+        ret = kstrtoint(buf, 0, &num);
+        if (ret < 0)
+                return ret;
+        if (num < 1)
+                return -EINVAL;
 
-static ssize_t compr_data_size_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct zram *zram = dev_to_zram(dev);
+        down_write(&zram->init_lock);
+        if (init_done(zram)) {
+                if (!zcomp_set_max_streams(zram->comp, num)) {
+                        pr_info("Cannot change max compression streams\n");
+                        ret = -EINVAL;
+                        goto out;
+                }
+        }
 
-        return sprintf(buf, "%llu\n",
-                        (u64)atomic64_read(&zram->stats.compr_size));
+        zram->max_comp_streams = num;
+        ret = len;
+out:
+        up_write(&zram->init_lock);
+        return ret;
 }
 
-static ssize_t mem_used_total_show(struct device *dev,
+static ssize_t comp_algorithm_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
-        u64 val = 0;
+        size_t sz;
         struct zram *zram = dev_to_zram(dev);
-        struct zram_meta *meta = zram->meta;
 
         down_read(&zram->init_lock);
-        if (zram->init_done)
-                val = zs_get_total_size_bytes(meta->mem_pool);
+        sz = zcomp_available_show(zram->compressor, buf);
         up_read(&zram->init_lock);
 
-        return sprintf(buf, "%llu\n", val);
+        return sz;
+}
+
+static ssize_t comp_algorithm_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
+{
+        struct zram *zram = dev_to_zram(dev);
+        down_write(&zram->init_lock);
+        if (init_done(zram)) {
+                up_write(&zram->init_lock);
+                pr_info("Can't change algorithm for initialized device\n");
+                return -EBUSY;
+        }
+        strlcpy(zram->compressor, buf, sizeof(zram->compressor));
+        up_write(&zram->init_lock);
+        return len;
 }
 
 /* flag operations needs meta->tb_lock */
@@ -192,8 +231,6 @@ static inline int valid_io_request(struct zram *zram, struct bio *bio)
 static void zram_meta_free(struct zram_meta *meta)
 {
         zs_destroy_pool(meta->mem_pool);
-        kfree(meta->compress_workmem);
-        free_pages((unsigned long)meta->compress_buffer, 1);
         vfree(meta->table);
         kfree(meta);
 }
@@ -205,22 +242,11 @@ static struct zram_meta *zram_meta_alloc(u64 disksize)
         if (!meta)
                 goto out;
 
-        meta->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
-        if (!meta->compress_workmem)
-                goto free_meta;
-
-        meta->compress_buffer =
-                (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1);
-        if (!meta->compress_buffer) {
-                pr_err("Error allocating compressor buffer space\n");
-                goto free_workmem;
-        }
-
         num_pages = disksize >> PAGE_SHIFT;
         meta->table = vzalloc(num_pages * sizeof(*meta->table));
         if (!meta->table) {
                 pr_err("Error allocating zram address table\n");
-                goto free_buffer;
+                goto free_meta;
         }
 
         meta->mem_pool = zs_create_pool(GFP_NOIO | __GFP_HIGHMEM);
@@ -230,15 +256,10 @@ static struct zram_meta *zram_meta_alloc(u64 disksize)
         }
 
         rwlock_init(&meta->tb_lock);
-        mutex_init(&meta->buffer_lock);
         return meta;
 
 free_table:
         vfree(meta->table);
-free_buffer:
-        free_pages((unsigned long)meta->compress_buffer, 1);
-free_workmem:
-        kfree(meta->compress_workmem);
 free_meta:
         kfree(meta);
         meta = NULL;
@@ -288,7 +309,6 @@ static void zram_free_page(struct zram *zram, size_t index)
 {
         struct zram_meta *meta = zram->meta;
         unsigned long handle = meta->table[index].handle;
-        u16 size = meta->table[index].size;
 
         if (unlikely(!handle)) {
                 /*
@@ -297,21 +317,15 @@ static void zram_free_page(struct zram *zram, size_t index)
                  */
                 if (zram_test_flag(meta, index, ZRAM_ZERO)) {
                         zram_clear_flag(meta, index, ZRAM_ZERO);
-                        atomic_dec(&zram->stats.pages_zero);
+                        atomic64_dec(&zram->stats.zero_pages);
                 }
                 return;
         }
 
-        if (unlikely(size > max_zpage_size))
-                atomic_dec(&zram->stats.bad_compress);
-
         zs_free(meta->mem_pool, handle);
 
-        if (size <= PAGE_SIZE / 2)
-                atomic_dec(&zram->stats.good_compress);
-
-        atomic64_sub(meta->table[index].size, &zram->stats.compr_size);
-        atomic_dec(&zram->stats.pages_stored);
+        atomic64_sub(meta->table[index].size, &zram->stats.compr_data_size);
+        atomic64_dec(&zram->stats.pages_stored);
 
         meta->table[index].handle = 0;
         meta->table[index].size = 0;
@@ -319,8 +333,7 @@ static void zram_free_page(struct zram *zram, size_t index)
 
 static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
 {
-        int ret = LZO_E_OK;
-        size_t clen = PAGE_SIZE;
+        int ret = 0;
         unsigned char *cmem;
         struct zram_meta *meta = zram->meta;
         unsigned long handle;
@@ -340,12 +353,12 @@ static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
         if (size == PAGE_SIZE)
                 copy_page(mem, cmem);
         else
-                ret = lzo1x_decompress_safe(cmem, size, mem, &clen);
+                ret = zcomp_decompress(zram->comp, cmem, size, mem);
         zs_unmap_object(meta->mem_pool, handle);
         read_unlock(&meta->tb_lock);
 
         /* Should NEVER happen. Return bio error if it does. */
-        if (unlikely(ret != LZO_E_OK)) {
+        if (unlikely(ret)) {
                 pr_err("Decompression failed! err=%d, page=%u\n", ret, index);
                 atomic64_inc(&zram->stats.failed_reads);
                 return ret;
@@ -388,7 +401,7 @@ static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
 
         ret = zram_decompress_page(zram, uncmem, index);
         /* Should NEVER happen. Return bio error if it does. */
-        if (unlikely(ret != LZO_E_OK))
+        if (unlikely(ret))
                 goto out_cleanup;
 
         if (is_partial_io(bvec))
@@ -413,11 +426,10 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
         struct page *page;
         unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
         struct zram_meta *meta = zram->meta;
+        struct zcomp_strm *zstrm;
         bool locked = false;
 
         page = bvec->bv_page;
-        src = meta->compress_buffer;
-
         if (is_partial_io(bvec)) {
                 /*
                  * This is a partial IO. We need to read the full page
@@ -433,7 +445,7 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
                         goto out;
         }
 
-        mutex_lock(&meta->buffer_lock);
+        zstrm = zcomp_strm_find(zram->comp);
         locked = true;
         user_mem = kmap_atomic(page);
 
@@ -454,28 +466,25 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
                 zram_set_flag(meta, index, ZRAM_ZERO);
                 write_unlock(&zram->meta->tb_lock);
 
-                atomic_inc(&zram->stats.pages_zero);
+                atomic64_inc(&zram->stats.zero_pages);
                 ret = 0;
                 goto out;
         }
 
-        ret = lzo1x_1_compress(uncmem, PAGE_SIZE, src, &clen,
-                               meta->compress_workmem);
+        ret = zcomp_compress(zram->comp, zstrm, uncmem, &clen);
         if (!is_partial_io(bvec)) {
                 kunmap_atomic(user_mem);
                 user_mem = NULL;
                 uncmem = NULL;
         }
 
-        if (unlikely(ret != LZO_E_OK)) {
+        if (unlikely(ret)) {
                 pr_err("Compression failed! err=%d\n", ret);
                 goto out;
         }
-
+        src = zstrm->buffer;
         if (unlikely(clen > max_zpage_size)) {
-                atomic_inc(&zram->stats.bad_compress);
                 clen = PAGE_SIZE;
-                src = NULL;
                 if (is_partial_io(bvec))
                         src = uncmem;
         }
@@ -497,6 +506,8 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
                 memcpy(cmem, src, clen);
         }
 
+        zcomp_strm_release(zram->comp, zstrm);
+        locked = false;
         zs_unmap_object(meta->mem_pool, handle);
 
         /*
@@ -511,49 +522,88 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
         write_unlock(&zram->meta->tb_lock);
 
         /* Update stats */
-        atomic64_add(clen, &zram->stats.compr_size);
-        atomic_inc(&zram->stats.pages_stored);
-        if (clen <= PAGE_SIZE / 2)
-                atomic_inc(&zram->stats.good_compress);
-
+        atomic64_add(clen, &zram->stats.compr_data_size);
+        atomic64_inc(&zram->stats.pages_stored);
 out:
         if (locked)
-                mutex_unlock(&meta->buffer_lock);
+                zcomp_strm_release(zram->comp, zstrm);
         if (is_partial_io(bvec))
                 kfree(uncmem);
-
         if (ret)
                 atomic64_inc(&zram->stats.failed_writes);
         return ret;
 }
 
 static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
-                        int offset, struct bio *bio, int rw)
+                        int offset, struct bio *bio)
 {
         int ret;
+        int rw = bio_data_dir(bio);
 
-        if (rw == READ)
+        if (rw == READ) {
+                atomic64_inc(&zram->stats.num_reads);
                 ret = zram_bvec_read(zram, bvec, index, offset, bio);
-        else
+        } else {
+                atomic64_inc(&zram->stats.num_writes);
                 ret = zram_bvec_write(zram, bvec, index, offset);
+        }
 
         return ret;
 }
 
+/*
+ * zram_bio_discard - handler on discard request
+ * @index: physical block index in PAGE_SIZE units
+ * @offset: byte offset within physical block
+ */
+static void zram_bio_discard(struct zram *zram, u32 index,
+                             int offset, struct bio *bio)
+{
+        size_t n = bio->bi_iter.bi_size;
+
+        /*
+         * zram manages data in physical block size units. Because logical block
+         * size isn't identical with physical block size on some arch, we
+         * could get a discard request pointing to a specific offset within a
+         * certain physical block.  Although we can handle this request by
+         * reading that physiclal block and decompressing and partially zeroing
+         * and re-compressing and then re-storing it, this isn't reasonable
+         * because our intent with a discard request is to save memory.  So
+         * skipping this logical block is appropriate here.
+         */
+        if (offset) {
+                if (n < offset)
+                        return;
+
+                n -= offset;
+                index++;
+        }
+
+        while (n >= PAGE_SIZE) {
+                /*
+                 * Discard request can be large so the lock hold times could be
+                 * lengthy.  So take the lock once per page.
+                 */
+                write_lock(&zram->meta->tb_lock);
+                zram_free_page(zram, index);
+                write_unlock(&zram->meta->tb_lock);
+                index++;
+                n -= PAGE_SIZE;
+        }
+}
+
 static void zram_reset_device(struct zram *zram, bool reset_capacity)
 {
         size_t index;
         struct zram_meta *meta;
 
         down_write(&zram->init_lock);
-        if (!zram->init_done) {
+        if (!init_done(zram)) {
                 up_write(&zram->init_lock);
                 return;
         }
 
         meta = zram->meta;
-        zram->init_done = 0;
-
         /* Free all pages that are still in this zram device */
         for (index = 0; index < zram->disksize >> PAGE_SHIFT; index++) {
                 unsigned long handle = meta->table[index].handle;
@@ -563,6 +613,9 @@ static void zram_reset_device(struct zram *zram, bool reset_capacity)
                 zs_free(meta->mem_pool, handle);
         }
 
+        zcomp_destroy(zram->comp);
+        zram->max_comp_streams = 1;
+
         zram_meta_free(zram->meta);
         zram->meta = NULL;
         /* Reset stats */
@@ -574,37 +627,14 @@ static void zram_reset_device(struct zram *zram, bool reset_capacity)
         up_write(&zram->init_lock);
 }
 
-static void zram_init_device(struct zram *zram, struct zram_meta *meta)
-{
-        if (zram->disksize > 2 * (totalram_pages << PAGE_SHIFT)) {
-                pr_info(
-                "There is little point creating a zram of greater than "
-                "twice the size of memory since we expect a 2:1 compression "
-                "ratio. Note that zram uses about 0.1%% of the size of "
-                "the disk when not in use so a huge zram is "
-                "wasteful.\n"
-                "\tMemory Size: %lu kB\n"
-                "\tSize you selected: %llu kB\n"
-                "Continuing anyway ...\n",
-                (totalram_pages << PAGE_SHIFT) >> 10, zram->disksize >> 10
-                );
-        }
-
-        /* zram devices sort of resembles non-rotational disks */
-        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zram->disk->queue);
-
-        zram->meta = meta;
-        zram->init_done = 1;
-
-        pr_debug("Initialization done!\n");
-}
-
 static ssize_t disksize_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t len)
 {
         u64 disksize;
+        struct zcomp *comp;
         struct zram_meta *meta;
         struct zram *zram = dev_to_zram(dev);
+        int err;
 
         disksize = memparse(buf, NULL);
         if (!disksize)
@@ -614,20 +644,35 @@ static ssize_t disksize_store(struct device *dev,
         meta = zram_meta_alloc(disksize);
         if (!meta)
                 return -ENOMEM;
+
+        comp = zcomp_create(zram->compressor, zram->max_comp_streams);
+        if (IS_ERR(comp)) {
+                pr_info("Cannot initialise %s compressing backend\n",
+                                zram->compressor);
+                err = PTR_ERR(comp);
+                goto out_free_meta;
+        }
+
         down_write(&zram->init_lock);
-        if (zram->init_done) {
-                up_write(&zram->init_lock);
-                zram_meta_free(meta);
+        if (init_done(zram)) {
                 pr_info("Cannot change disksize for initialized device\n");
-                return -EBUSY;
+                err = -EBUSY;
+                goto out_destroy_comp;
         }
 
+        zram->meta = meta;
+        zram->comp = comp;
         zram->disksize = disksize;
         set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
-        zram_init_device(zram, meta);
         up_write(&zram->init_lock);
-
         return len;
+
+out_destroy_comp:
+        up_write(&zram->init_lock);
+        zcomp_destroy(comp);
+out_free_meta:
+        zram_meta_free(meta);
+        return err;
 }
 
 static ssize_t reset_store(struct device *dev,
@@ -671,26 +716,23 @@ out:
         return ret;
 }
 
-static void __zram_make_request(struct zram *zram, struct bio *bio, int rw)
+static void __zram_make_request(struct zram *zram, struct bio *bio)
 {
         int offset;
         u32 index;
         struct bio_vec bvec;
         struct bvec_iter iter;
 
-        switch (rw) {
-        case READ:
-                atomic64_inc(&zram->stats.num_reads);
-                break;
-        case WRITE:
-                atomic64_inc(&zram->stats.num_writes);
-                break;
-        }
-
         index = bio->bi_iter.bi_sector >> SECTORS_PER_PAGE_SHIFT;
         offset = (bio->bi_iter.bi_sector &
                   (SECTORS_PER_PAGE - 1)) << SECTOR_SHIFT;
 
+        if (unlikely(bio->bi_rw & REQ_DISCARD)) {
+                zram_bio_discard(zram, index, offset, bio);
+                bio_endio(bio, 0);
+                return;
+        }
+
         bio_for_each_segment(bvec, bio, iter) {
                 int max_transfer_size = PAGE_SIZE - offset;
 
@@ -705,16 +747,15 @@ static void __zram_make_request(struct zram *zram, struct bio *bio, int rw)
                         bv.bv_len = max_transfer_size;
                         bv.bv_offset = bvec.bv_offset;
 
-                        if (zram_bvec_rw(zram, &bv, index, offset, bio, rw) < 0)
+                        if (zram_bvec_rw(zram, &bv, index, offset, bio) < 0)
                                 goto out;
 
                         bv.bv_len = bvec.bv_len - max_transfer_size;
                         bv.bv_offset += max_transfer_size;
-                        if (zram_bvec_rw(zram, &bv, index+1, 0, bio, rw) < 0)
+                        if (zram_bvec_rw(zram, &bv, index + 1, 0, bio) < 0)
                                 goto out;
                 } else
-                        if (zram_bvec_rw(zram, &bvec, index, offset, bio, rw)
-                            < 0)
+                        if (zram_bvec_rw(zram, &bvec, index, offset, bio) < 0)
                                 goto out;
 
                 update_position(&index, &offset, &bvec);
@@ -736,7 +777,7 @@ static void zram_make_request(struct request_queue *queue, struct bio *bio)
         struct zram *zram = queue->queuedata;
 
         down_read(&zram->init_lock);
-        if (unlikely(!zram->init_done))
+        if (unlikely(!init_done(zram)))
                 goto error;
 
         if (!valid_io_request(zram, bio)) {
@@ -744,7 +785,7 @@ static void zram_make_request(struct request_queue *queue, struct bio *bio)
                 goto error;
         }
 
-        __zram_make_request(zram, bio, bio_data_dir(bio));
+        __zram_make_request(zram, bio);
         up_read(&zram->init_lock);
 
         return;
@@ -778,14 +819,21 @@ static DEVICE_ATTR(disksize, S_IRUGO | S_IWUSR,
                 disksize_show, disksize_store);
 static DEVICE_ATTR(initstate, S_IRUGO, initstate_show, NULL);
 static DEVICE_ATTR(reset, S_IWUSR, NULL, reset_store);
-static DEVICE_ATTR(num_reads, S_IRUGO, num_reads_show, NULL);
-static DEVICE_ATTR(num_writes, S_IRUGO, num_writes_show, NULL);
-static DEVICE_ATTR(invalid_io, S_IRUGO, invalid_io_show, NULL);
-static DEVICE_ATTR(notify_free, S_IRUGO, notify_free_show, NULL);
-static DEVICE_ATTR(zero_pages, S_IRUGO, zero_pages_show, NULL);
 static DEVICE_ATTR(orig_data_size, S_IRUGO, orig_data_size_show, NULL);
-static DEVICE_ATTR(compr_data_size, S_IRUGO, compr_data_size_show, NULL);
 static DEVICE_ATTR(mem_used_total, S_IRUGO, mem_used_total_show, NULL);
+static DEVICE_ATTR(max_comp_streams, S_IRUGO | S_IWUSR,
+                max_comp_streams_show, max_comp_streams_store);
+static DEVICE_ATTR(comp_algorithm, S_IRUGO | S_IWUSR,
+                comp_algorithm_show, comp_algorithm_store);
+
+ZRAM_ATTR_RO(num_reads);
+ZRAM_ATTR_RO(num_writes);
+ZRAM_ATTR_RO(failed_reads);
+ZRAM_ATTR_RO(failed_writes);
+ZRAM_ATTR_RO(invalid_io);
+ZRAM_ATTR_RO(notify_free);
+ZRAM_ATTR_RO(zero_pages);
+ZRAM_ATTR_RO(compr_data_size);
 
 static struct attribute *zram_disk_attrs[] = {
         &dev_attr_disksize.attr,
@@ -793,12 +841,16 @@ static struct attribute *zram_disk_attrs[] = {
         &dev_attr_reset.attr,
         &dev_attr_num_reads.attr,
         &dev_attr_num_writes.attr,
+        &dev_attr_failed_reads.attr,
+        &dev_attr_failed_writes.attr,
         &dev_attr_invalid_io.attr,
         &dev_attr_notify_free.attr,
         &dev_attr_zero_pages.attr,
         &dev_attr_orig_data_size.attr,
         &dev_attr_compr_data_size.attr,
         &dev_attr_mem_used_total.attr,
+        &dev_attr_max_comp_streams.attr,
+        &dev_attr_comp_algorithm.attr,
         NULL,
 };
 
@@ -839,7 +891,8 @@ static int create_device(struct zram *zram, int device_id)
 
         /* Actual capacity set using syfs (/sys/block/zram<id>/disksize */
         set_capacity(zram->disk, 0);
-
+        /* zram devices sort of resembles non-rotational disks */
+        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zram->disk->queue);
         /*
          * To ensure that we always get PAGE_SIZE aligned
          * and n*PAGE_SIZED sized I/O requests.
@@ -849,6 +902,21 @@ static int create_device(struct zram *zram, int device_id)
                                         ZRAM_LOGICAL_BLOCK_SIZE);
         blk_queue_io_min(zram->disk->queue, PAGE_SIZE);
         blk_queue_io_opt(zram->disk->queue, PAGE_SIZE);
+        zram->disk->queue->limits.discard_granularity = PAGE_SIZE;
+        zram->disk->queue->limits.max_discard_sectors = UINT_MAX;
+        /*
+         * zram_bio_discard() will clear all logical blocks if logical block
+         * size is identical with physical block size(PAGE_SIZE). But if it is
+         * different, we will skip discarding some parts of logical blocks in
+         * the part of the request range which isn't aligned to physical block
+         * size.  So we can't ensure that all discarded logical blocks are
+         * zeroed.
+         */
+        if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE)
+                zram->disk->queue->limits.discard_zeroes_data = 1;
+        else
+                zram->disk->queue->limits.discard_zeroes_data = 0;
+        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zram->disk->queue);
 
         add_disk(zram->disk);
 
@@ -858,8 +926,9 @@ static int create_device(struct zram *zram, int device_id)
                 pr_warn("Error creating sysfs group");
                 goto out_free_disk;
         }
-
-        zram->init_done = 0;
+        strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor));
+        zram->meta = NULL;
+        zram->max_comp_streams = 1;
         return 0;
 
 out_free_disk:
diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h
index ad8aa35bae00..7f21c145e317 100644
--- a/drivers/block/zram/zram_drv.h
+++ b/drivers/block/zram/zram_drv.h
@@ -16,9 +16,10 @@
 #define _ZRAM_DRV_H_
 
 #include <linux/spinlock.h>
-#include <linux/mutex.h>
 #include <linux/zsmalloc.h>
 
+#include "zcomp.h"
+
 /*
  * Some arbitrary value. This is just to catch
  * invalid value for num_devices module parameter.
@@ -64,38 +65,33 @@ enum zram_pageflags {
 struct table {
         unsigned long handle;
         u16 size;       /* object size (excluding header) */
-        u8 count;       /* object ref count (not yet used) */
         u8 flags;
 } __aligned(4);
 
 struct zram_stats {
-        atomic64_t compr_size;  /* compressed size of pages stored */
+        atomic64_t compr_data_size;     /* compressed size of pages stored */
         atomic64_t num_reads;   /* failed + successful */
         atomic64_t num_writes;  /* --do-- */
         atomic64_t failed_reads;        /* should NEVER! happen */
         atomic64_t failed_writes;       /* can happen when memory is too low */
         atomic64_t invalid_io;  /* non-page-aligned I/O requests */
         atomic64_t notify_free; /* no. of swap slot free notifications */
-        atomic_t pages_zero;            /* no. of zero filled pages */
-        atomic_t pages_stored;  /* no. of pages currently stored */
-        atomic_t good_compress; /* % of pages with compression ratio<=50% */
-        atomic_t bad_compress;  /* % of pages with compression ratio>=75% */
+        atomic64_t zero_pages;          /* no. of zero filled pages */
+        atomic64_t pages_stored;        /* no. of pages currently stored */
 };
 
 struct zram_meta {
         rwlock_t tb_lock;       /* protect table */
-        void *compress_workmem;
-        void *compress_buffer;
         struct table *table;
         struct zs_pool *mem_pool;
-        struct mutex buffer_lock; /* protect compress buffers */
 };
 
 struct zram {
         struct zram_meta *meta;
         struct request_queue *queue;
         struct gendisk *disk;
-        int init_done;
+        struct zcomp *comp;
+
         /* Prevent concurrent execution of device init, reset and R/W request */
         struct rw_semaphore init_lock;
         /*
@@ -103,7 +99,8 @@ struct zram {
          * we can store in a disk.
          */
         u64 disksize;   /* bytes */
-
+        int max_comp_streams;
         struct zram_stats stats;
+        char compressor[10];
 };
 #endif