zram: introduce zcomp_req structure

Encapsulate compression/decompression data in zcomp_req structure.

Link: https://lkml.kernel.org/r/20240902105656.1383858-18-senozhatsky@chromium.org
Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nick Terrell <terrelln@fb.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/drivers/block/zram/backend_842.c b/drivers/block/zram/backend_842.c
index e14dba30b0a2a68937cea6f11f904ae73c155391..1597dc4d4f1c5653d7395b9deafffccddc260163 100644 (file)
--- a/drivers/block/zram/backend_842.c
+++ b/drivers/block/zram/backend_842.c
@@ -38,25 +38,24 @@ error:
        return NULL;
 }
 
-static int compress_842(void *ctx, const unsigned char *src, size_t src_len,
-                       unsigned char *dst, size_t *dst_len)
+static int compress_842(void *ctx, struct zcomp_req *req)
 {
        struct sw842_ctx *zctx = ctx;
-       unsigned int dlen = *dst_len;
+       unsigned int dlen = req->dst_len;
        int ret;
 
-       ret = sw842_compress(src, src_len, dst, &dlen, zctx->mem);
+       ret = sw842_compress(req->src, req->src_len, req->dst, &dlen,
+                            zctx->mem);
        if (ret == 0)
-               *dst_len = dlen;
+               req->dst_len = dlen;
        return ret;
 }
 
-static int decompress_842(void *ctx, const unsigned char *src, size_t src_len,
-                         unsigned char *dst, size_t dst_len)
+static int decompress_842(void *ctx, struct zcomp_req *req)
 {
-       unsigned int dlen = dst_len;
+       unsigned int dlen = req->dst_len;
 
-       return sw842_decompress(src, src_len, dst, &dlen);
+       return sw842_decompress(req->src, req->src_len, req->dst, &dlen);
 }
 
 const struct zcomp_ops backend_842 = {

diff --git a/drivers/block/zram/backend_deflate.c b/drivers/block/zram/backend_deflate.c
index ec662ce468971cc8733109026e7b8696d12a52c6..117852d45aa4aa254afdde4cbe8230209f078934 100644 (file)
--- a/drivers/block/zram/backend_deflate.c
+++ b/drivers/block/zram/backend_deflate.c
@@ -74,9 +74,7 @@ error:
        return NULL;
 }
 
-static int deflate_compress(void *ctx, const unsigned char *src,
-                           size_t src_len, unsigned char *dst,
-                           size_t *dst_len)
+static int deflate_compress(void *ctx, struct zcomp_req *req)
 {
        struct deflate_ctx *zctx = ctx;
        struct z_stream_s *deflate;
@@ -87,22 +85,20 @@ static int deflate_compress(void *ctx, const unsigned char *src,
        if (ret != Z_OK)
                return -EINVAL;
 
-       deflate->next_in = (u8 *)src;
-       deflate->avail_in = src_len;
-       deflate->next_out = (u8 *)dst;
-       deflate->avail_out = *dst_len;
+       deflate->next_in = (u8 *)req->src;
+       deflate->avail_in = req->src_len;
+       deflate->next_out = (u8 *)req->dst;
+       deflate->avail_out = req->dst_len;
 
        ret = zlib_deflate(deflate, Z_FINISH);
        if (ret != Z_STREAM_END)
                return -EINVAL;
 
-       *dst_len = deflate->total_out;
+       req->dst_len = deflate->total_out;
        return 0;
 }
 
-static int deflate_decompress(void *ctx, const unsigned char *src,
-                             size_t src_len, unsigned char *dst,
-                             size_t dst_len)
+static int deflate_decompress(void *ctx, struct zcomp_req *req)
 {
        struct deflate_ctx *zctx = ctx;
        struct z_stream_s *inflate;
@@ -114,10 +110,10 @@ static int deflate_decompress(void *ctx, const unsigned char *src,
        if (ret != Z_OK)
                return -EINVAL;
 
-       inflate->next_in = (u8 *)src;
-       inflate->avail_in = src_len;
-       inflate->next_out = (u8 *)dst;
-       inflate->avail_out = dst_len;
+       inflate->next_in = (u8 *)req->src;
+       inflate->avail_in = req->src_len;
+       inflate->next_out = (u8 *)req->dst;
+       inflate->avail_out = req->dst_len;
 
        ret = zlib_inflate(inflate, Z_SYNC_FLUSH);
        if (ret != Z_STREAM_END)

diff --git a/drivers/block/zram/backend_lz4.c b/drivers/block/zram/backend_lz4.c
index ec57b5acbd390bf1acfcc91c948a465c12e98301..cc4ae409787033c80056dbcd6cf06849520a51fd 100644 (file)
--- a/drivers/block/zram/backend_lz4.c
+++ b/drivers/block/zram/backend_lz4.c
@@ -41,26 +41,25 @@ error:
        return NULL;
 }
 
-static int lz4_compress(void *ctx, const unsigned char *src, size_t src_len,
-                       unsigned char *dst, size_t *dst_len)
+static int lz4_compress(void *ctx, struct zcomp_req *req)
 {
        struct lz4_ctx *zctx = ctx;
        int ret;
 
-       ret = LZ4_compress_fast(src, dst, src_len, *dst_len,
-                               zctx->level, zctx->mem);
+       ret = LZ4_compress_fast(req->src, req->dst, req->src_len,
+                               req->dst_len, zctx->level, zctx->mem);
        if (!ret)
                return -EINVAL;
-       *dst_len = ret;
+       req->dst_len = ret;
        return 0;
 }
 
-static int lz4_decompress(void *ctx, const unsigned char *src,
-                         size_t src_len, unsigned char *dst, size_t dst_len)
+static int lz4_decompress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = LZ4_decompress_safe(src, dst, src_len, dst_len);
+       ret = LZ4_decompress_safe(req->src, req->dst, req->src_len,
+                                 req->dst_len);
        if (ret < 0)
                return -EINVAL;
        return 0;

diff --git a/drivers/block/zram/backend_lz4hc.c b/drivers/block/zram/backend_lz4hc.c
index 80733fead595d4a2f0d4f1677e89cfdbdd61942f..610dadc09751657c1037f2121fd707d3ab3e6da5 100644 (file)
--- a/drivers/block/zram/backend_lz4hc.c
+++ b/drivers/block/zram/backend_lz4hc.c
@@ -41,26 +41,25 @@ error:
        return NULL;
 }
 
-static int lz4hc_compress(void *ctx, const unsigned char *src, size_t src_len,
-                         unsigned char *dst, size_t *dst_len)
+static int lz4hc_compress(void *ctx, struct zcomp_req *req)
 {
        struct lz4hc_ctx *zctx = ctx;
        int ret;
 
-       ret = LZ4_compress_HC(src, dst, src_len, *dst_len,
+       ret = LZ4_compress_HC(req->src, req->dst, req->src_len, req->dst_len,
                              zctx->level, zctx->mem);
        if (!ret)
                return -EINVAL;
-       *dst_len = ret;
+       req->dst_len = ret;
        return 0;
 }
 
-static int lz4hc_decompress(void *ctx, const unsigned char *src,
-                           size_t src_len, unsigned char *dst, size_t dst_len)
+static int lz4hc_decompress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = LZ4_decompress_safe(src, dst, src_len, dst_len);
+       ret = LZ4_decompress_safe(req->src, req->dst, req->src_len,
+                                 req->dst_len);
        if (ret < 0)
                return -EINVAL;
        return 0;

diff --git a/drivers/block/zram/backend_lzo.c b/drivers/block/zram/backend_lzo.c
index 8e4aabd04bf34a272920f7826c11d4a57d45f40e..88f1aa5683f3fe1fe5a50e9dffd098b3c1b9c926 100644 (file)
--- a/drivers/block/zram/backend_lzo.c
+++ b/drivers/block/zram/backend_lzo.c
@@ -16,21 +16,21 @@ static void lzo_destroy(void *ctx)
        kfree(ctx);
 }
 
-static int lzo_compress(void *ctx, const unsigned char *src, size_t src_len,
-                       unsigned char *dst, size_t *dst_len)
+static int lzo_compress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = lzo1x_1_compress(src, src_len, dst, dst_len, ctx);
+       ret = lzo1x_1_compress(req->src, req->src_len, req->dst,
+                              &req->dst_len, ctx);
        return ret == LZO_E_OK ? 0 : ret;
 }
 
-static int lzo_decompress(void *ctx, const unsigned char *src, size_t src_len,
-                         unsigned char *dst, size_t dst_len)
+static int lzo_decompress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = lzo1x_decompress_safe(src, src_len, dst, &dst_len);
+       ret = lzo1x_decompress_safe(req->src, req->src_len,
+                                   req->dst, &req->dst_len);
        return ret == LZO_E_OK ? 0 : ret;
 }
 

diff --git a/drivers/block/zram/backend_lzorle.c b/drivers/block/zram/backend_lzorle.c
index cb01eb8b04f4b9f1ecadcdfacb9c00d0eb8736f4..f05820929a74053ddda86aa7e8a1a3e7b4ac4adb 100644 (file)
--- a/drivers/block/zram/backend_lzorle.c
+++ b/drivers/block/zram/backend_lzorle.c
@@ -16,22 +16,21 @@ static void lzorle_destroy(void *ctx)
        kfree(ctx);
 }
 
-static int lzorle_compress(void *ctx, const unsigned char *src, size_t src_len,
-                          unsigned char *dst, size_t *dst_len)
+static int lzorle_compress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = lzorle1x_1_compress(src, src_len, dst, dst_len, ctx);
+       ret = lzorle1x_1_compress(req->src, req->src_len, req->dst,
+                                 &req->dst_len, ctx);
        return ret == LZO_E_OK ? 0 : ret;
 }
 
-static int lzorle_decompress(void *ctx, const unsigned char *src,
-                            size_t src_len, unsigned char *dst,
-                            size_t dst_len)
+static int lzorle_decompress(void *ctx, struct zcomp_req *req)
 {
        int ret;
 
-       ret = lzo1x_decompress_safe(src, src_len, dst, &dst_len);
+       ret = lzo1x_decompress_safe(req->src, req->src_len,
+                                   req->dst, &req->dst_len);
        return ret == LZO_E_OK ? 0 : ret;
 }
 

diff --git a/drivers/block/zram/backend_zstd.c b/drivers/block/zram/backend_zstd.c
index 7c6798f0c912b5b01d65499688567479330244ac..19eba65f44c9f56f1965d5da9caea27959ae4854 100644 (file)
--- a/drivers/block/zram/backend_zstd.c
+++ b/drivers/block/zram/backend_zstd.c
@@ -67,27 +67,26 @@ error:
        return NULL;
 }
 
-static int zstd_compress(void *ctx, const unsigned char *src, size_t src_len,
-                        unsigned char *dst, size_t *dst_len)
+static int zstd_compress(void *ctx, struct zcomp_req *req)
 {
        struct zstd_ctx *zctx = ctx;
        size_t ret;
 
-       ret = zstd_compress_cctx(zctx->cctx, dst, *dst_len,
-                                src, src_len, &zctx->cprm);
+       ret = zstd_compress_cctx(zctx->cctx, req->dst, req->dst_len,
+                                req->src, req->src_len, &zctx->cprm);
        if (zstd_is_error(ret))
                return -EINVAL;
-       *dst_len = ret;
+       req->dst_len = ret;
        return 0;
 }
 
-static int zstd_decompress(void *ctx, const unsigned char *src, size_t src_len,
-                          unsigned char *dst, size_t dst_len)
+static int zstd_decompress(void *ctx, struct zcomp_req *req)
 {
        struct zstd_ctx *zctx = ctx;
        size_t ret;
 
-       ret = zstd_decompress_dctx(zctx->dctx, dst, dst_len, src, src_len);
+       ret = zstd_decompress_dctx(zctx->dctx, req->dst, req->dst_len,
+                                  req->src, req->src_len);
        if (zstd_is_error(ret))
                return -EINVAL;
        return 0;

diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c
index 173ee2b79442f842b985fd6b0b78a0a1b24b430d..20ad7b6fe62f39de67b41c0118504610ac0458d2 100644 (file)
--- a/drivers/block/zram/zcomp.c
+++ b/drivers/block/zram/zcomp.c
@@ -119,22 +119,31 @@ void zcomp_stream_put(struct zcomp *comp)
 int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
                   const void *src, unsigned int *dst_len)
 {
-       /* The dst buffer should always be 2 * PAGE_SIZE */
-       size_t dlen = 2 * PAGE_SIZE;
+       struct zcomp_req req = {
+               .src = src,
+               .dst = zstrm->buffer,
+               .src_len = PAGE_SIZE,
+               .dst_len = 2 * PAGE_SIZE,
+       };
        int ret;
 
-       ret = comp->ops->compress(zstrm->ctx, src, PAGE_SIZE,
-                                 zstrm->buffer, &dlen);
+       ret = comp->ops->compress(zstrm->ctx, &req);
        if (!ret)
-               *dst_len = dlen;
+               *dst_len = req.dst_len;
        return ret;
 }
 
 int zcomp_decompress(struct zcomp *comp, struct zcomp_strm *zstrm,
                     const void *src, unsigned int src_len, void *dst)
 {
-       return comp->ops->decompress(zstrm->ctx, src, src_len,
-                                    dst, PAGE_SIZE);
+       struct zcomp_req req = {
+               .src = src,
+               .dst = dst,
+               .src_len = src_len,
+               .dst_len = PAGE_SIZE,
+       };
+
+       return comp->ops->decompress(zstrm->ctx, &req);
 }
 
 int zcomp_cpu_up_prepare(unsigned int cpu, struct hlist_node *node)

diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h
index 217a750fa908f87f696a0db3aa0306c72ec39bed..bbc48094f826213641aeff8646aba7057ef3ae93 100644 (file)
--- a/drivers/block/zram/zcomp.h
+++ b/drivers/block/zram/zcomp.h
@@ -21,12 +21,17 @@ struct zcomp_strm {
        void *ctx;
 };
 
-struct zcomp_ops {
-       int (*compress)(void *ctx, const unsigned char *src, size_t src_len,
-                       unsigned char *dst, size_t *dst_len);
+struct zcomp_req {
+       const unsigned char *src;
+       const size_t src_len;
+
+       unsigned char *dst;
+       size_t dst_len;
+};
 
-       int (*decompress)(void *ctx, const unsigned char *src, size_t src_len,
-                         unsigned char *dst, size_t dst_len);
+struct zcomp_ops {
+       int (*compress)(void *ctx, struct zcomp_req *req);
+       int (*decompress)(void *ctx, struct zcomp_req *req);
 
        void *(*create_ctx)(struct zcomp_params *params);
        void (*destroy_ctx)(void *ctx);