Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-25 21:51:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

zram: introduce zcomp_req structure

Browse Source 
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>
This commit is contained in:
Sergey Senozhatsky 2024-09-02 19:56:05 +09:00 committed by Andrew Morton
parent dea77d7aea
commit 52c7b4e2ba
9 changed files with 77 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
drivers/block/zram/backend_842.c
View File

@ -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 = {

26
drivers/block/zram/backend_deflate.c
View File

@ -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)

15
drivers/block/zram/backend_lz4.c
View File

@ -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;

13
drivers/block/zram/backend_lz4hc.c
View File

@ -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;

12
drivers/block/zram/backend_lzo.c
View File

@ -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;
}

13
drivers/block/zram/backend_lzorle.c
View File

@ -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;
}

15
drivers/block/zram/backend_zstd.c
View File

@ -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;

23
drivers/block/zram/zcomp.c
View File

@ -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)

15
drivers/block/zram/zcomp.h
View File

@ -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;
int (*decompress)(void *ctx, const unsigned char *src, size_t src_len,
unsigned char *dst, size_t dst_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);