zram: switch to crypto compress API

author Sergey Senozhatsky <sergey.senozhatsky@gmail.com>

Tue, 26 Jul 2016 22:22:45 +0000 (15:22 -0700)

committer Linus Torvalds <torvalds@linux-foundation.org>

Tue, 26 Jul 2016 23:19:19 +0000 (16:19 -0700)
author Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Tue, 26 Jul 2016 22:22:45 +0000 (15:22 -0700)
committer Linus Torvalds <torvalds@linux-foundation.org>
Tue, 26 Jul 2016 23:19:19 +0000 (16:19 -0700)
diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig

index 386ba3d1a6ee8aed4a9c9885f07c408dfa3bff4b..2252cd7d0e89d90db7fe6dd827b7cfcbd4b4862c 100644 (file)
--- a/drivers/block/zram/Kconfig
+++ b/drivers/block/zram/Kconfig
@@ -1,8 +1,7 @@
  config ZRAM
         tristate "Compressed RAM block device support"
-       depends on BLOCK && SYSFS && ZSMALLOC
-       select LZO_COMPRESS
-       select LZO_DECOMPRESS
+       depends on BLOCK && SYSFS && ZSMALLOC && CRYPTO
+       select CRYPTO_LZO
         default n
         help
           Creates virtual block devices called /dev/zramX (X = 0, 1, ...).
@@ -18,9 +17,8 @@ config ZRAM
  config ZRAM_LZ4_COMPRESS
         bool "Enable LZ4 algorithm support"
         depends on ZRAM
-       select LZ4_COMPRESS
-       select LZ4_DECOMPRESS
+       select CRYPTO_LZ4
         default n
         help
           This option enables LZ4 compression algorithm support. Compression
-         algorithm can be changed using `comp_algorithm' device attribute.
-\ No newline at end of file
+         algorithm can be changed using `comp_algorithm' device attribute.
diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c

index 400f8267337e9c244202a0b756534e30e26ec70f..f35726860a1ba85e1824c6e21047317958fa2ecb 100644 (file)
--- a/drivers/block/zram/zcomp.c
+++ b/drivers/block/zram/zcomp.c
@@ -14,42 +14,39 @@
  #include <linux/wait.h>
  #include <linux/sched.h>
  #include <linux/cpu.h>
+#include <linux/crypto.h>
  
  #include "zcomp.h"
-#include "zcomp_lzo.h"
-#ifdef CONFIG_ZRAM_LZ4_COMPRESS
-#include "zcomp_lz4.h"
-#endif
  
-static struct zcomp_backend *backends[] = {
-       &zcomp_lzo,
+static const char * const backends[] = {
+       "lzo",
  #ifdef CONFIG_ZRAM_LZ4_COMPRESS
-       &zcomp_lz4,
+       "lz4",
  #endif
         NULL
  };
  
-static struct zcomp_backend *find_backend(const char *compress)
+static const char *find_backend(const char *compress)
  {
         int i = 0;
         while (backends[i]) {
-               if (sysfs_streq(compress, backends[i]->name))
+               if (sysfs_streq(compress, backends[i]))
                         break;
                 i++;
         }
         return backends[i];
  }
  
-static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm)
+static void zcomp_strm_free(struct zcomp_strm *zstrm)
  {
-       if (zstrm->private)
-               comp->backend->destroy(zstrm->private);
+       if (!IS_ERR_OR_NULL(zstrm->tfm))
+               crypto_free_comp(zstrm->tfm);
         free_pages((unsigned long)zstrm->buffer, 1);
         kfree(zstrm);
  }
  
  /*
- * allocate new zcomp_strm structure with ->private initialized by
+ * allocate new zcomp_strm structure with ->tfm initialized by
   * backend, return NULL on error
   */
  static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp, gfp_t flags)
@@ -58,14 +55,14 @@ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp, gfp_t flags)
         if (!zstrm)
                 return NULL;
  
-       zstrm->private = comp->backend->create(flags);
+       zstrm->tfm = crypto_alloc_comp(comp->name, 0, 0);
         /*
          * 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(flags | __GFP_ZERO, 1);
-       if (!zstrm->private || !zstrm->buffer) {
-               zcomp_strm_free(comp, zstrm);
+       if (IS_ERR_OR_NULL(zstrm->tfm) || !zstrm->buffer) {
+               zcomp_strm_free(zstrm);
                 zstrm = NULL;
         }
         return zstrm;
@@ -78,12 +75,12 @@ ssize_t zcomp_available_show(const char *comp, char *buf)
         int i = 0;
  
         while (backends[i]) {
-               if (!strcmp(comp, backends[i]->name))
+               if (!strcmp(comp, backends[i]))
                         sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
-                                       "[%s] ", backends[i]->name);
+                                       "[%s] ", backends[i]);
                 else
                         sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
-                                       "%s ", backends[i]->name);
+                                       "%s ", backends[i]);
                 i++;
         }
         sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n");
@@ -105,17 +102,38 @@ void zcomp_stream_put(struct zcomp *comp)
         put_cpu_ptr(comp->stream);
  }
  
-int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
-               const unsigned char *src, size_t *dst_len)
+int zcomp_compress(struct zcomp_strm *zstrm,
+               const void *src, unsigned int *dst_len)
  {
-       return comp->backend->compress(src, zstrm->buffer, dst_len,
-                       zstrm->private);
+       /*
+        * Our dst memory (zstrm->buffer) is always `2 * PAGE_SIZE' sized
+        * because sometimes we can endup having a bigger compressed data
+        * due to various reasons: for example compression algorithms tend
+        * to add some padding to the compressed buffer. Speaking of padding,
+        * comp algorithm `842' pads the compressed length to multiple of 8
+        * and returns -ENOSP when the dst memory is not big enough, which
+        * is not something that ZRAM wants to see. We can handle the
+        * `compressed_size > PAGE_SIZE' case easily in ZRAM, but when we
+        * receive -ERRNO from the compressing backend we can't help it
+        * anymore. To make `842' happy we need to tell the exact size of
+        * the dst buffer, zram_drv will take care of the fact that
+        * compressed buffer is too big.
+        */
+       *dst_len = PAGE_SIZE * 2;
+
+       return crypto_comp_compress(zstrm->tfm,
+                       src, PAGE_SIZE,
+                       zstrm->buffer, dst_len);
  }
  
-int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
-               size_t src_len, unsigned char *dst)
+int zcomp_decompress(struct zcomp_strm *zstrm,
+               const void *src, unsigned int src_len, void *dst)
  {
-       return comp->backend->decompress(src, src_len, dst);
+       unsigned int dst_len = PAGE_SIZE;
+
+       return crypto_comp_decompress(zstrm->tfm,
+                       src, src_len,
+                       dst, &dst_len);
  }
  
  static int __zcomp_cpu_notifier(struct zcomp *comp,
@@ -138,7 +156,7 @@ static int __zcomp_cpu_notifier(struct zcomp *comp,
         case CPU_UP_CANCELED:
                 zstrm = *per_cpu_ptr(comp->stream, cpu);
                 if (!IS_ERR_OR_NULL(zstrm))
-                       zcomp_strm_free(comp, zstrm);
+                       zcomp_strm_free(zstrm);
                 *per_cpu_ptr(comp->stream, cpu) = NULL;
                 break;
         default:
@@ -209,7 +227,7 @@ void zcomp_destroy(struct zcomp *comp)
  struct zcomp *zcomp_create(const char *compress)
  {
         struct zcomp *comp;
-       struct zcomp_backend *backend;
+       const char *backend;
         int error;
  
         backend = find_backend(compress);
@@ -220,7 +238,7 @@ struct zcomp *zcomp_create(const char *compress)
         if (!comp)
                 return ERR_PTR(-ENOMEM);
  
-       comp->backend = backend;
+       comp->name = backend;
         error = zcomp_init(comp);
         if (error) {
                 kfree(comp);
diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h

index 944b8e60dd82ba75fbb0fb31c179323986559a2c..c914ab7972ef7374e0adf9474afafb32841514fd 100644 (file)
--- a/drivers/block/zram/zcomp.h
+++ b/drivers/block/zram/zcomp.h
@@ -13,12 +13,7 @@
  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;
+       struct crypto_comp *tfm;
  };
  
  /* static compression backend */
@@ -40,6 +35,8 @@ struct zcomp {
         struct zcomp_strm * __percpu *stream;
         struct zcomp_backend *backend;
         struct notifier_block notifier;
+
+       const char *name;
  };
  
  ssize_t zcomp_available_show(const char *comp, char *buf);
@@ -51,11 +48,11 @@ void zcomp_destroy(struct zcomp *comp);
  struct zcomp_strm *zcomp_stream_get(struct zcomp *comp);
  void zcomp_stream_put(struct zcomp *comp);
  
-int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
-               const unsigned char *src, size_t *dst_len);
+int zcomp_compress(struct zcomp_strm *zstrm,
+               const void *src, unsigned int *dst_len);
  
-int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
-               size_t src_len, unsigned char *dst);
+int zcomp_decompress(struct zcomp_strm *zstrm,
+               const void *src, unsigned int src_len, void *dst);
  
  bool zcomp_set_max_streams(struct zcomp *comp, int num_strm);
  #endif /* _ZCOMP_H_ */
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c

index 9361a5db7de89792d973e4c458adbad14ebe9aeb..65d140336289d454d592d336e3495fbb9072f06b 100644 (file)
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -563,7 +563,7 @@ static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
         unsigned char *cmem;
         struct zram_meta *meta = zram->meta;
         unsigned long handle;
-       size_t size;
+       unsigned int size;
  
         bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
         handle = meta->table[index].handle;
@@ -576,10 +576,14 @@ static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
         }
  
         cmem = zs_map_object(meta->mem_pool, handle, ZS_MM_RO);
-       if (size == PAGE_SIZE)
+       if (size == PAGE_SIZE) {
                 copy_page(mem, cmem);
-       else
-               ret = zcomp_decompress(zram->comp, cmem, size, mem);
+       } else {
+               struct zcomp_strm *zstrm = zcomp_stream_get(zram->comp);
+
+               ret = zcomp_decompress(zstrm, cmem, size, mem);
+               zcomp_stream_put(zram->comp);
+       }
         zs_unmap_object(meta->mem_pool, handle);
         bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
  
@@ -646,7 +650,7 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
                            int offset)
  {
         int ret = 0;
-       size_t clen;
+       unsigned int clen;
         unsigned long handle = 0;
         struct page *page;
         unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
@@ -696,7 +700,7 @@ compress_again:
         }
  
         zstrm = zcomp_stream_get(zram->comp);
-       ret = zcomp_compress(zram->comp, zstrm, uncmem, &clen);
+       ret = zcomp_compress(zstrm, uncmem, &clen);
         if (!is_partial_io(bvec)) {
                 kunmap_atomic(user_mem);
                 user_mem = NULL;
@@ -744,7 +748,7 @@ compress_again:
                 if (handle)
                         goto compress_again;
  
-               pr_err("Error allocating memory for compressed page: %u, size=%zu\n",
+               pr_err("Error allocating memory for compressed page: %u, size=%u\n",
                         index, clen);
                 ret = -ENOMEM;
                 goto out;
author	Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
	Tue, 26 Jul 2016 22:22:45 +0000 (15:22 -0700)
committer	Linus Torvalds <torvalds@linux-foundation.org>
	Tue, 26 Jul 2016 23:19:19 +0000 (16:19 -0700)
drivers/block/zram/Kconfig		patch \| blob \| blame \| history
drivers/block/zram/zcomp.c		patch \| blob \| blame \| history
drivers/block/zram/zcomp.h		patch \| blob \| blame \| history
drivers/block/zram/zram_drv.c		patch \| blob \| blame \| history