From 0e1e7afdf9c71862b640c7a8502ac9b8351ee44e Mon Sep 17 00:00:00 2001 From: Gabriel2392 Date: Sat, 8 Jun 2024 16:08:41 -0300 Subject: [PATCH] crypto/zram: Add lz4fast algorithm > Up to 3 times faster than default lz4 > Uses LZ4_compress_fast level 32 --- arch/arm64/configs/a53x_defconfig | 1 + crypto/Kconfig | 9 ++ crypto/Makefile | 1 + crypto/lz4fast.c | 160 ++++++++++++++++++++++++++++++ drivers/block/zram/zcomp.c | 3 + include/linux/lz4.h | 2 + 6 files changed, 176 insertions(+) create mode 100644 crypto/lz4fast.c diff --git a/arch/arm64/configs/a53x_defconfig b/arch/arm64/configs/a53x_defconfig index 8cd58f68f..5558c3c41 100755 --- a/arch/arm64/configs/a53x_defconfig +++ b/arch/arm64/configs/a53x_defconfig @@ -7827,6 +7827,7 @@ CONFIG_CRYPTO_DEFLATE=y CONFIG_CRYPTO_LZO=m # CONFIG_CRYPTO_842 is not set CONFIG_CRYPTO_LZ4=y +CONFIG_CRYPTO_LZ4FAST=y # CONFIG_CRYPTO_LZ4HC is not set CONFIG_CRYPTO_ZSTD=y diff --git a/crypto/Kconfig b/crypto/Kconfig index f28423575..c15e412f8 100755 --- a/crypto/Kconfig +++ b/crypto/Kconfig @@ -1830,6 +1830,15 @@ config CRYPTO_LZ4 help This is the LZ4 algorithm. +config CRYPTO_LZ4FAST + tristate "LZ4FAST compression algorithm" + select CRYPTO_ALGAPI + select CRYPTO_ACOMP2 + select LZ4_COMPRESS + select LZ4_DECOMPRESS + help + This is the LZ4 fast mode algorithm. + config CRYPTO_LZ4HC tristate "LZ4HC compression algorithm" select CRYPTO_ALGAPI diff --git a/crypto/Makefile b/crypto/Makefile index c295ed047..30635078a 100755 --- a/crypto/Makefile +++ b/crypto/Makefile @@ -159,6 +159,7 @@ obj-$(CONFIG_CRYPTO_CRCT10DIF) += crct10dif_common.o crct10dif_generic.o obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o obj-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o obj-$(CONFIG_CRYPTO_LZ4) += lz4.o +obj-$(CONFIG_CRYPTO_LZ4FAST) += lz4fast.o obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o diff --git a/crypto/lz4fast.c b/crypto/lz4fast.c new file mode 100644 index 000000000..fe4e414f5 --- /dev/null +++ b/crypto/lz4fast.c @@ -0,0 +1,160 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Cryptographic API. + * + * Copyright (c) 2013 Chanho Min + */ + +#include +#include +#include +#include +#include +#include + +struct lz4fast_ctx { + void *lz4fast_comp_mem; +}; + +static void *lz4fast_alloc_ctx(struct crypto_scomp *tfm) +{ + void *ctx; + + ctx = vmalloc(LZ4_MEM_COMPRESS); + if (!ctx) + return ERR_PTR(-ENOMEM); + + return ctx; +} + +static int lz4fast_init(struct crypto_tfm *tfm) +{ + struct lz4fast_ctx *ctx = crypto_tfm_ctx(tfm); + + ctx->lz4fast_comp_mem = lz4fast_alloc_ctx(NULL); + if (IS_ERR(ctx->lz4fast_comp_mem)) + return -ENOMEM; + + return 0; +} + +static void lz4fast_free_ctx(struct crypto_scomp *tfm, void *ctx) +{ + vfree(ctx); +} + +static void lz4fast_exit(struct crypto_tfm *tfm) +{ + struct lz4fast_ctx *ctx = crypto_tfm_ctx(tfm); + + lz4fast_free_ctx(NULL, ctx->lz4fast_comp_mem); +} + +static int __lz4fast_compress_crypto(const u8 *src, unsigned int slen, + u8 *dst, unsigned int *dlen, void *ctx) +{ + int out_len = LZ4_compress_fast(src, dst, + slen, *dlen, LZ4FAST_DEFAULT_CLEVEL, ctx); + + if (!out_len) + return -EINVAL; + + *dlen = out_len; + return 0; +} + +static int lz4fast_scompress(struct crypto_scomp *tfm, const u8 *src, + unsigned int slen, u8 *dst, unsigned int *dlen, + void *ctx) +{ + return __lz4fast_compress_crypto(src, slen, dst, dlen, ctx); +} + +static int lz4fast_compress_crypto(struct crypto_tfm *tfm, const u8 *src, + unsigned int slen, u8 *dst, unsigned int *dlen) +{ + struct lz4fast_ctx *ctx = crypto_tfm_ctx(tfm); + + return __lz4fast_compress_crypto(src, slen, dst, dlen, ctx->lz4fast_comp_mem); +} + +static int __lz4fast_decompress_crypto(const u8 *src, unsigned int slen, + u8 *dst, unsigned int *dlen, void *ctx) +{ + int out_len = LZ4_decompress_safe(src, dst, slen, *dlen); + + if (out_len < 0) + return -EINVAL; + + *dlen = out_len; + return 0; +} + +static int lz4fast_sdecompress(struct crypto_scomp *tfm, const u8 *src, + unsigned int slen, u8 *dst, unsigned int *dlen, + void *ctx) +{ + return __lz4fast_decompress_crypto(src, slen, dst, dlen, NULL); +} + +static int lz4fast_decompress_crypto(struct crypto_tfm *tfm, const u8 *src, + unsigned int slen, u8 *dst, + unsigned int *dlen) +{ + return __lz4fast_decompress_crypto(src, slen, dst, dlen, NULL); +} + +static struct crypto_alg alg_lz4fast = { + .cra_name = "lz4fast", + .cra_driver_name = "lz4fast-generic", + .cra_flags = CRYPTO_ALG_TYPE_COMPRESS, + .cra_ctxsize = sizeof(struct lz4fast_ctx), + .cra_module = THIS_MODULE, + .cra_init = lz4fast_init, + .cra_exit = lz4fast_exit, + .cra_u = { .compress = { + .coa_compress = lz4fast_compress_crypto, + .coa_decompress = lz4fast_decompress_crypto } } +}; + +static struct scomp_alg scomp = { + .alloc_ctx = lz4fast_alloc_ctx, + .free_ctx = lz4fast_free_ctx, + .compress = lz4fast_scompress, + .decompress = lz4fast_sdecompress, + .base = { + .cra_name = "lz4fast", + .cra_driver_name = "lz4fast-scomp", + .cra_module = THIS_MODULE, + } +}; + +static int __init lz4fast_mod_init(void) +{ + int ret; + + ret = crypto_register_alg(&alg_lz4fast); + if (ret) + return ret; + + ret = crypto_register_scomp(&scomp); + if (ret) { + crypto_unregister_alg(&alg_lz4fast); + return ret; + } + + return ret; +} + +static void __exit lz4fast_mod_fini(void) +{ + crypto_unregister_alg(&alg_lz4fast); + crypto_unregister_scomp(&scomp); +} + +subsys_initcall(lz4fast_mod_init); +module_exit(lz4fast_mod_fini); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("LZ4FAST Compression Algorithm"); +MODULE_ALIAS_CRYPTO("lz4fast"); diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c index b684cb666..95ea5b591 100755 --- a/drivers/block/zram/zcomp.c +++ b/drivers/block/zram/zcomp.c @@ -23,6 +23,9 @@ static const char * const backends[] = { #if IS_ENABLED(CONFIG_CRYPTO_LZ4HC) "lz4hc", #endif +#if IS_ENABLED(CONFIG_CRYPTO_LZ4FAST) + "lz4fast", +#endif #if IS_ENABLED(CONFIG_CRYPTO_842) "842", #endif diff --git a/include/linux/lz4.h b/include/linux/lz4.h index b16e15b95..97ae77c47 100755 --- a/include/linux/lz4.h +++ b/include/linux/lz4.h @@ -79,6 +79,8 @@ #define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG) #define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1) +#define LZ4FAST_DEFAULT_CLEVEL 32 + /*-************************************************************************ * STREAMING CONSTANTS AND STRUCTURES **************************************************************************/