4 files changed, 167 insertions, 5 deletions

diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c
index 72e8071f9d73..c06f75f54718 100644
--- a/drivers/block/zram/zcomp.c
+++ b/drivers/block/zram/zcomp.c
@@ -24,6 +24,21 @@ struct zcomp_strm_single {
         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 *find_backend(const char *compress)
 {
         if (strncmp(compress, "lzo", 3) == 0)
@@ -62,6 +77,107 @@ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp)
         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);
+}
+
+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;
+        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;
@@ -139,7 +255,7 @@ void zcomp_destroy(struct zcomp *comp)
  * if requested algorithm is not supported or in case
  * of init error
  */
-struct zcomp *zcomp_create(const char *compress)
+struct zcomp *zcomp_create(const char *compress, int max_strm)
 {
         struct zcomp *comp;
         struct zcomp_backend *backend;
@@ -153,7 +269,11 @@ struct zcomp *zcomp_create(const char *compress)
                 return NULL;
 
         comp->backend = backend;
-        if (zcomp_strm_single_create(comp) != 0) {
+        if (max_strm > 1)
+                zcomp_strm_multi_create(comp, max_strm);
+        else
+                zcomp_strm_single_create(comp);
+        if (!comp->stream) {
                 kfree(comp);
                 return NULL;
         }
diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h
index dc3500d842a3..2a3684446160 100644
--- a/drivers/block/zram/zcomp.h
+++ b/drivers/block/zram/zcomp.h
@@ -21,6 +21,8 @@ struct zcomp_strm {
          * working memory)
          */
         void *private;
+        /* used in multi stream backend, protected by backend strm_lock */
+        struct list_head list;
 };
 
 /* static compression backend */
@@ -47,7 +49,7 @@ struct zcomp {
         void (*destroy)(struct zcomp *comp);
 };
 
-struct zcomp *zcomp_create(const char *comp);
+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);
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 98823f9ca8b1..bdc7eb8c6df7 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -108,6 +108,40 @@ static ssize_t mem_used_total_show(struct device *dev,
         return sprintf(buf, "%llu\n", val);
 }
 
+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);
+
+        down_read(&zram->init_lock);
+        val = zram->max_comp_streams;
+        up_read(&zram->init_lock);
+
+        return sprintf(buf, "%d\n", val);
+}
+
+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);
+
+        if (kstrtoint(buf, 0, &num))
+                return -EINVAL;
+        if (num < 1)
+                return -EINVAL;
+        down_write(&zram->init_lock);
+        if (init_done(zram)) {
+                up_write(&zram->init_lock);
+                pr_info("Can't set max_comp_streams for initialized device\n");
+                return -EBUSY;
+        }
+        zram->max_comp_streams = num;
+        up_write(&zram->init_lock);
+        return len;
+}
+
 /* flag operations needs meta->tb_lock */
 static int zram_test_flag(struct zram_meta *meta, u32 index,
                         enum zram_pageflags flag)
@@ -502,6 +536,8 @@ static void zram_reset_device(struct zram *zram, bool reset_capacity)
         }
 
         zcomp_destroy(zram->comp);
+        zram->max_comp_streams = 1;
+
         zram_meta_free(zram->meta);
         zram->meta = NULL;
         /* Reset stats */
@@ -537,7 +573,7 @@ static ssize_t disksize_store(struct device *dev,
                 goto out_free_meta;
         }
 
-        zram->comp = zcomp_create(default_compressor);
+        zram->comp = zcomp_create(default_compressor, zram->max_comp_streams);
         if (!zram->comp) {
                 pr_info("Cannot initialise %s compressing backend\n",
                                 default_compressor);
@@ -698,6 +734,8 @@ static DEVICE_ATTR(initstate, S_IRUGO, initstate_show, NULL);
 static DEVICE_ATTR(reset, S_IWUSR, NULL, reset_store);
 static DEVICE_ATTR(orig_data_size, S_IRUGO, orig_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);
 
 ZRAM_ATTR_RO(num_reads);
 ZRAM_ATTR_RO(num_writes);
@@ -722,6 +760,7 @@ static struct attribute *zram_disk_attrs[] = {
         &dev_attr_orig_data_size.attr,
         &dev_attr_compr_data_size.attr,
         &dev_attr_mem_used_total.attr,
+        &dev_attr_max_comp_streams.attr,
         NULL,
 };
 
@@ -784,6 +823,7 @@ static int create_device(struct zram *zram, int device_id)
         }
 
         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 45e04f7b713f..ccf36d11755a 100644
--- a/drivers/block/zram/zram_drv.h
+++ b/drivers/block/zram/zram_drv.h
@@ -99,7 +99,7 @@ struct zram {
          * we can store in a disk.
          */
         u64 disksize;   /* bytes */
-
+        int max_comp_streams;
         struct zram_stats stats;
 };
 #endif