Commit 91d53d96 authored by Giovanni Cabiddu's avatar Giovanni Cabiddu Committed by Herbert Xu
Browse files

crypto: acomp - add support for lz4hc via scomp 



Add scomp backend for lz4hc compression algorithm.

Signed-off-by: default avatarGiovanni Cabiddu <giovanni.cabiddu@intel.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 8cd9330e

crypto/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -1615,6 +1615,7 @@ config CRYPTO_LZ4 
config CRYPTO_LZ4HC

	tristate "LZ4HC compression algorithm"

	select CRYPTO_ALGAPI

	select CRYPTO_ACOMP2

	select LZ4HC_COMPRESS

	select LZ4_DECOMPRESS

	help

crypto/lz4hc.c

+82 −10
Original line number Diff line number Diff line
@@ -22,37 +22,53 @@ 
#include <linux/crypto.h>

#include <linux/vmalloc.h>

#include <linux/lz4.h>

#include <crypto/internal/scompress.h>



struct lz4hc_ctx {

	void *lz4hc_comp_mem;

};



static void *lz4hc_alloc_ctx(struct crypto_scomp *tfm)

{

	void *ctx;



	ctx = vmalloc(LZ4HC_MEM_COMPRESS);

	if (!ctx)

		return ERR_PTR(-ENOMEM);



	return ctx;

}



static int lz4hc_init(struct crypto_tfm *tfm)

{

	struct lz4hc_ctx *ctx = crypto_tfm_ctx(tfm);



	ctx->lz4hc_comp_mem = vmalloc(LZ4HC_MEM_COMPRESS);

	if (!ctx->lz4hc_comp_mem)

	ctx->lz4hc_comp_mem = lz4hc_alloc_ctx(NULL);

	if (IS_ERR(ctx->lz4hc_comp_mem))

		return -ENOMEM;



	return 0;

}



static void lz4hc_free_ctx(struct crypto_scomp *tfm, void *ctx)

{

	vfree(ctx);

}



static void lz4hc_exit(struct crypto_tfm *tfm)

{

	struct lz4hc_ctx *ctx = crypto_tfm_ctx(tfm);



	vfree(ctx->lz4hc_comp_mem);

	lz4hc_free_ctx(NULL, ctx->lz4hc_comp_mem);

}



static int lz4hc_compress_crypto(struct crypto_tfm *tfm, const u8 *src,

			    unsigned int slen, u8 *dst, unsigned int *dlen)

static int __lz4hc_compress_crypto(const u8 *src, unsigned int slen,

				   u8 *dst, unsigned int *dlen, void *ctx)

{

	struct lz4hc_ctx *ctx = crypto_tfm_ctx(tfm);

	size_t tmp_len = *dlen;

	int err;



	err = lz4hc_compress(src, slen, dst, &tmp_len, ctx->lz4hc_comp_mem);

	err = lz4hc_compress(src, slen, dst, &tmp_len, ctx);



	if (err < 0)

		return -EINVAL;
@@ -61,8 +77,25 @@ static int lz4hc_compress_crypto(struct crypto_tfm *tfm, const u8 *src, 
	return 0;

}



static int lz4hc_decompress_crypto(struct crypto_tfm *tfm, const u8 *src,

			      unsigned int slen, u8 *dst, unsigned int *dlen)

static int lz4hc_scompress(struct crypto_scomp *tfm, const u8 *src,

			   unsigned int slen, u8 *dst, unsigned int *dlen,

			   void *ctx)

{

	return __lz4hc_compress_crypto(src, slen, dst, dlen, ctx);

}



static int lz4hc_compress_crypto(struct crypto_tfm *tfm, const u8 *src,

				 unsigned int slen, u8 *dst,

				 unsigned int *dlen)

{

	struct lz4hc_ctx *ctx = crypto_tfm_ctx(tfm);



	return __lz4hc_compress_crypto(src, slen, dst, dlen,

					ctx->lz4hc_comp_mem);

}



static int __lz4hc_decompress_crypto(const u8 *src, unsigned int slen,

				     u8 *dst, unsigned int *dlen, void *ctx)

{

	int err;

	size_t tmp_len = *dlen;
@@ -76,6 +109,20 @@ static int lz4hc_decompress_crypto(struct crypto_tfm *tfm, const u8 *src, 
	return err;

}



static int lz4hc_sdecompress(struct crypto_scomp *tfm, const u8 *src,

			     unsigned int slen, u8 *dst, unsigned int *dlen,

			     void *ctx)

{

	return __lz4hc_decompress_crypto(src, slen, dst, dlen, NULL);

}



static int lz4hc_decompress_crypto(struct crypto_tfm *tfm, const u8 *src,

				   unsigned int slen, u8 *dst,

				   unsigned int *dlen)

{

	return __lz4hc_decompress_crypto(src, slen, dst, dlen, NULL);

}



static struct crypto_alg alg_lz4hc = {

	.cra_name		= "lz4hc",

	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
@@ -89,14 +136,39 @@ static struct crypto_alg alg_lz4hc = { 
	.coa_decompress		= lz4hc_decompress_crypto } }

};



static struct scomp_alg scomp = {

	.alloc_ctx		= lz4hc_alloc_ctx,

	.free_ctx		= lz4hc_free_ctx,

	.compress		= lz4hc_scompress,

	.decompress		= lz4hc_sdecompress,

	.base			= {

		.cra_name	= "lz4hc",

		.cra_driver_name = "lz4hc-scomp",

		.cra_module	 = THIS_MODULE,

	}

};



static int __init lz4hc_mod_init(void)

{

	return crypto_register_alg(&alg_lz4hc);

	int ret;



	ret = crypto_register_alg(&alg_lz4hc);

	if (ret)

		return ret;



	ret = crypto_register_scomp(&scomp);

	if (ret) {

		crypto_unregister_alg(&alg_lz4hc);

		return ret;

	}



	return ret;

}



static void __exit lz4hc_mod_fini(void)

{

	crypto_unregister_alg(&alg_lz4hc);

	crypto_unregister_scomp(&scomp);

}



module_init(lz4hc_mod_init);