zram: use common zpool interface

Update zram driver to use common zpool API instead of calling
zsmalloc functions directly. This patch also adds a parameter
that allows for changing underlying compressor storage to zbud.

Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
[ab123321]
Updated from Sony 51.1.A.3.159 copyleft release.

Signed-off-by: Artem Labazov <123321artyom@gmail.com>
Change-Id: I11ef21b06a155fe7b30962a2f2e5c063a60c9e4c
Signed-off-by: Vol Zhdanov <wight554@gmail.com>
[v4.4 backport]

diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig
index 9347cc9..33cb9b0 100644 (file)
--- a/drivers/block/zram/Kconfig
+++ b/drivers/block/zram/Kconfig
@@ -1,7 +1,8 @@
 config ZRAM
        tristate "Compressed RAM block device support"
-       depends on BLOCK && SYSFS && ZSMALLOC && CRYPTO
+       depends on BLOCK && SYSFS && CRYPTO
        select CRYPTO_LZ4
+       select ZPOOL
        default n
        help
          Creates virtual block devices called /dev/zramX (X = 0, 1, ...).

diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index c7d32b2..c77d233 100644 (file)
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -41,6 +41,8 @@ static DEFINE_MUTEX(zram_index_mutex);
 
 static int zram_major;
 static const char *default_compressor = "lz4";
+#define BACKEND_PAR_BUF_SIZE   32
+static char backend_par_buf[BACKEND_PAR_BUF_SIZE];
 
 /* Module params (documentation at end) */
 static unsigned int num_devices = 1;
@@ -282,7 +284,7 @@ static ssize_t mem_used_max_store(struct device *dev,
        down_read(&zram->init_lock);
        if (init_done(zram)) {
                atomic_long_set(&zram->stats.max_used_pages,
-                               zs_get_total_pages(zram->mem_pool));
+                       zpool_get_total_size(zram->mem_pool) >> PAGE_SHIFT);
        }
        up_read(&zram->init_lock);
 
@@ -827,7 +829,7 @@ static ssize_t compact_store(struct device *dev,
                return -EINVAL;
        }
 
-       zs_compact(zram->mem_pool);
+       zpool_compact(zram->mem_pool);
        up_read(&zram->init_lock);
 
        return len;
@@ -855,17 +857,14 @@ static ssize_t mm_stat_show(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
        struct zram *zram = dev_to_zram(dev);
-       struct zs_pool_stats pool_stats;
        u64 orig_size, mem_used = 0;
-       long max_used;
+       long max_used, num_compacted = 0;
        ssize_t ret;
 
-       memset(&pool_stats, 0x00, sizeof(struct zs_pool_stats));
-
        down_read(&zram->init_lock);
        if (init_done(zram)) {
-               mem_used = zs_get_total_pages(zram->mem_pool);
-               zs_pool_stats(zram->mem_pool, &pool_stats);
+               mem_used = zpool_get_total_size(zram->mem_pool);
+               num_compacted = zpool_get_num_compacted(zram->mem_pool);
        }
 
        orig_size = atomic64_read(&zram->stats.pages_stored);
@@ -875,11 +874,11 @@ static ssize_t mm_stat_show(struct device *dev,
                        "%8llu %8llu %8llu %8lu %8ld %8llu %8lu %8llu\n",
                        orig_size << PAGE_SHIFT,
                        (u64)atomic64_read(&zram->stats.compr_data_size),
-                       mem_used << PAGE_SHIFT,
+                       mem_used,
                        zram->limit_pages << PAGE_SHIFT,
                        max_used << PAGE_SHIFT,
                        (u64)atomic64_read(&zram->stats.same_pages),
-                       pool_stats.pages_compacted,
+                       num_compacted,
                        (u64)atomic64_read(&zram->stats.huge_pages));
        up_read(&zram->init_lock);
 
@@ -917,20 +916,23 @@ static void zram_meta_free(struct zram *zram, u64 disksize)
        for (index = 0; index < num_pages; index++)
                zram_free_page(zram, index);
 
-       zs_destroy_pool(zram->mem_pool);
+       zpool_destroy_pool(zram->mem_pool);
        vfree(zram->table);
 }
 
 static bool zram_meta_alloc(struct zram *zram, u64 disksize)
 {
        size_t num_pages;
+       char *backend;
 
        num_pages = disksize >> PAGE_SHIFT;
        zram->table = vzalloc(num_pages * sizeof(*zram->table));
        if (!zram->table)
                return false;
 
-       zram->mem_pool = zs_create_pool(zram->disk->disk_name);
+       backend = strlen(backend_par_buf) ? backend_par_buf : "zsmalloc";
+       zram->mem_pool = zpool_create_pool(backend, zram->disk->disk_name,
+                       GFP_NOIO, NULL);
        if (!zram->mem_pool) {
                vfree(zram->table);
                return false;
@@ -979,7 +981,7 @@ static void zram_free_page(struct zram *zram, size_t index)
        if (!handle)
                return;
 
-       zs_free(zram->mem_pool, handle);
+       zpool_free(zram->mem_pool, handle);
 
        atomic64_sub(zram_get_obj_size(zram, index),
                        &zram->stats.compr_data_size);
@@ -1030,7 +1032,7 @@ static int __zram_bvec_read(struct zram *zram, struct page *page, u32 index,
 
        size = zram_get_obj_size(zram, index);
 
-       src = zs_map_object(zram->mem_pool, handle, ZS_MM_RO);
+       src = zpool_map_handle(zram->mem_pool, handle, ZPOOL_MM_RO);
        if (size == PAGE_SIZE) {
                dst = kmap_atomic(page);
                memcpy(dst, src, PAGE_SIZE);
@@ -1044,7 +1046,7 @@ static int __zram_bvec_read(struct zram *zram, struct page *page, u32 index,
                kunmap_atomic(dst);
                zcomp_stream_put(zram->comp);
        }
-       zs_unmap_object(zram->mem_pool, handle);
+       zpool_unmap_handle(zram->mem_pool, handle);
        zram_slot_unlock(zram, index);
 
        /* Should NEVER happen. Return bio error if it does. */
@@ -1120,7 +1122,7 @@ compress_again:
        if (unlikely(ret)) {
                zcomp_stream_put(zram->comp);
                pr_err("Compression failed! err=%d\n", ret);
-               zs_free(zram->mem_pool, handle);
+               zpool_free(zram->mem_pool, handle);
                return ret;
        }
 
@@ -1153,32 +1155,33 @@ compress_again:
         * from the slow path and handle has already been allocated.
         */
        if (!handle)
-               handle = zs_malloc(zram->mem_pool, comp_len,
+               ret = zpool_malloc(zram->mem_pool, comp_len,
                                __GFP_KSWAPD_RECLAIM |
                                __GFP_NOWARN |
                                __GFP_HIGHMEM |
-                               __GFP_MOVABLE);
-       if (!handle) {
+                               __GFP_MOVABLE,
+                               &handle);
+       if (ret < 0) {
                zcomp_stream_put(zram->comp);
                atomic64_inc(&zram->stats.writestall);
-               handle = zs_malloc(zram->mem_pool, comp_len,
-                               GFP_NOIO | __GFP_HIGHMEM |
-                               __GFP_MOVABLE);
-               if (handle)
+               ret = zpool_malloc(zram->mem_pool, comp_len,
+                               GFP_NOIO | __GFP_HIGHMEM | __GFP_MOVABLE,
+                               &handle);
+               if (ret == 0)
                        goto compress_again;
                return -ENOMEM;
        }
 
-       alloced_pages = zs_get_total_pages(zram->mem_pool);
+       alloced_pages = zpool_get_total_size(zram->mem_pool) >> PAGE_SHIFT;
        update_used_max(zram, alloced_pages);
 
        if (zram->limit_pages && alloced_pages > zram->limit_pages) {
                zcomp_stream_put(zram->comp);
-               zs_free(zram->mem_pool, handle);
+               zpool_free(zram->mem_pool, handle);
                return -ENOMEM;
        }
 
-       dst = zs_map_object(zram->mem_pool, handle, ZS_MM_WO);
+       dst = zpool_map_handle(zram->mem_pool, handle, ZPOOL_MM_WO);
 
        src = zstrm->buffer;
        if (comp_len == PAGE_SIZE)
@@ -1188,7 +1191,7 @@ compress_again:
                kunmap_atomic(src);
 
        zcomp_stream_put(zram->comp);
-       zs_unmap_object(zram->mem_pool, handle);
+       zpool_unmap_handle(zram->mem_pool, handle);
        atomic64_add(comp_len, &zram->stats.compr_data_size);
 out:
        /*
@@ -1910,6 +1913,8 @@ module_exit(zram_exit);
 
 module_param(num_devices, uint, 0);
 MODULE_PARM_DESC(num_devices, "Number of pre-created zram devices");
+module_param_string(backend, backend_par_buf, BACKEND_PAR_BUF_SIZE, S_IRUGO);
+MODULE_PARM_DESC(backend, "Compression storage (backend) name");
 
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");

diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h
index a6f96f3..62b0aa3 100644 (file)
--- a/drivers/block/zram/zram_drv.h
+++ b/drivers/block/zram/zram_drv.h
@@ -16,7 +16,7 @@
 #define _ZRAM_DRV_H_
 
 #include <linux/rwsem.h>
-#include <linux/zsmalloc.h>
+#include <linux/zpool.h>
 #include <linux/crypto.h>
 
 #include "zcomp.h"
@@ -85,7 +85,7 @@ struct zram_stats {
 
 struct zram {
        struct zram_table_entry *table;
-       struct zs_pool *mem_pool;
+       struct zpool *mem_pool;
        struct zcomp *comp;
        struct gendisk *disk;
        /* Prevent concurrent execution of device init */