[linux-block.git] / crypto / lzo.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Cryptographic API.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/crypto.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/lzo.h>
#include <crypto/internal/scompress.h>

struct lzo_ctx {
	void *lzo_comp_mem;
};

static void *lzo_alloc_ctx(struct crypto_scomp *tfm)
{
	void *ctx;

	ctx = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
	if (!ctx)
		return ERR_PTR(-ENOMEM);

	return ctx;
}

static int lzo_init(struct crypto_tfm *tfm)
{
	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);

	ctx->lzo_comp_mem = lzo_alloc_ctx(NULL);
	if (IS_ERR(ctx->lzo_comp_mem))
		return -ENOMEM;

	return 0;
}

static void lzo_free_ctx(struct crypto_scomp *tfm, void *ctx)
{
	kvfree(ctx);
}

static void lzo_exit(struct crypto_tfm *tfm)
{
	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);

	lzo_free_ctx(NULL, ctx->lzo_comp_mem);
}

static int __lzo_compress(const u8 *src, unsigned int slen,
			  u8 *dst, unsigned int *dlen, void *ctx)
{
	size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
	int err;

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

	if (err != LZO_E_OK)
		return -EINVAL;

	*dlen = tmp_len;
	return 0;
}

static int lzo_compress(struct crypto_tfm *tfm, const u8 *src,
			unsigned int slen, u8 *dst, unsigned int *dlen)
{
	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);

	return __lzo_compress(src, slen, dst, dlen, ctx->lzo_comp_mem);
}

static int lzo_scompress(struct crypto_scomp *tfm, const u8 *src,
			 unsigned int slen, u8 *dst, unsigned int *dlen,
			 void *ctx)
{
	return __lzo_compress(src, slen, dst, dlen, ctx);
}

static int __lzo_decompress(const u8 *src, unsigned int slen,
			    u8 *dst, unsigned int *dlen)
{
	int err;
	size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */

	err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);

	if (err != LZO_E_OK)
		return -EINVAL;

	*dlen = tmp_len;
	return 0;
}

static int lzo_decompress(struct crypto_tfm *tfm, const u8 *src,
			  unsigned int slen, u8 *dst, unsigned int *dlen)
{
	return __lzo_decompress(src, slen, dst, dlen);
}

static int lzo_sdecompress(struct crypto_scomp *tfm, const u8 *src,
			   unsigned int slen, u8 *dst, unsigned int *dlen,
			   void *ctx)
{
	return __lzo_decompress(src, slen, dst, dlen);
}

static struct crypto_alg alg = {
	.cra_name		= "lzo",
	.cra_driver_name	= "lzo-generic",
	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
	.cra_ctxsize		= sizeof(struct lzo_ctx),
	.cra_module		= THIS_MODULE,
	.cra_init		= lzo_init,
	.cra_exit		= lzo_exit,
	.cra_u			= { .compress = {
	.coa_compress		= lzo_compress,
	.coa_decompress		= lzo_decompress } }
};

static struct scomp_alg scomp = {
	.alloc_ctx		= lzo_alloc_ctx,
	.free_ctx		= lzo_free_ctx,
	.compress		= lzo_scompress,
	.decompress		= lzo_sdecompress,
	.base			= {
		.cra_name	= "lzo",
		.cra_driver_name = "lzo-scomp",
		.cra_module	 = THIS_MODULE,
	}
};

static int __init lzo_mod_init(void)
{
	int ret;

	ret = crypto_register_alg(&alg);
	if (ret)
		return ret;

	ret = crypto_register_scomp(&scomp);
	if (ret) {
		crypto_unregister_alg(&alg);
		return ret;
	}

	return ret;
}

static void __exit lzo_mod_fini(void)
{
	crypto_unregister_alg(&alg);
	crypto_unregister_scomp(&scomp);
}

subsys_initcall(lzo_mod_init);
module_exit(lzo_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("LZO Compression Algorithm");
MODULE_ALIAS_CRYPTO("lzo");
Commit	Line	Data
2b27bdcc	1	// SPDX-License-Identifier: GPL-2.0-only
0b77abb3 ZS	2	/*
0b77abb3 ZS	3	* Cryptographic API.
0b77abb3 ZS	4	*/
	5
	6	#include <linux/init.h>
	7	#include <linux/module.h>
	8	#include <linux/crypto.h>
	9	#include <linux/vmalloc.h>
42614b05	10	#include <linux/mm.h>
0b77abb3	11	#include <linux/lzo.h>
ac9d2c4b	12	#include <crypto/internal/scompress.h>
0b77abb3 ZS	13
	14	struct lzo_ctx {
	15	void *lzo_comp_mem;
	16	};
	17
ac9d2c4b GC	18	static void lzo_alloc_ctx(struct crypto_scomp tfm)
	19	{
	20	void *ctx;
	21
752ade68	22	ctx = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
ac9d2c4b GC	23	if (!ctx)
	24	return ERR_PTR(-ENOMEM);
	25
	26	return ctx;
	27	}
	28
0b77abb3 ZS	29	static int lzo_init(struct crypto_tfm *tfm)
	30	{
	31	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
	32
ac9d2c4b GC	33	ctx->lzo_comp_mem = lzo_alloc_ctx(NULL);
ac9d2c4b GC	34	if (IS_ERR(ctx->lzo_comp_mem))
0b77abb3 ZS	35	return -ENOMEM;
	36
	37	return 0;
	38	}
	39
ac9d2c4b GC	40	static void lzo_free_ctx(struct crypto_scomp tfm, void ctx)
	41	{
	42	kvfree(ctx);
	43	}
	44
0b77abb3 ZS	45	static void lzo_exit(struct crypto_tfm *tfm)
	46	{
	47	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
	48
ac9d2c4b	49	lzo_free_ctx(NULL, ctx->lzo_comp_mem);
0b77abb3 ZS	50	}
0b77abb3 ZS	51
ac9d2c4b GC	52	static int __lzo_compress(const u8 *src, unsigned int slen,
ac9d2c4b GC	53	u8 dst, unsigned int dlen, void *ctx)
0b77abb3	54	{
0b77abb3 ZS	55	size_t tmp_len = dlen; / size_t(ulong) <-> uint on 64 bit */
	56	int err;
	57
ac9d2c4b	58	err = lzo1x_1_compress(src, slen, dst, &tmp_len, ctx);
0b77abb3 ZS	59
	60	if (err != LZO_E_OK)
	61	return -EINVAL;
	62
	63	*dlen = tmp_len;
	64	return 0;
	65	}
	66
ac9d2c4b GC	67	static int lzo_compress(struct crypto_tfm tfm, const u8 src,
	68	unsigned int slen, u8 dst, unsigned int dlen)
	69	{
	70	struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
	71
	72	return __lzo_compress(src, slen, dst, dlen, ctx->lzo_comp_mem);
	73	}
	74
	75	static int lzo_scompress(struct crypto_scomp tfm, const u8 src,
	76	unsigned int slen, u8 dst, unsigned int dlen,
	77	void *ctx)
	78	{
	79	return __lzo_compress(src, slen, dst, dlen, ctx);
	80	}
	81
	82	static int __lzo_decompress(const u8 *src, unsigned int slen,
	83	u8 dst, unsigned int dlen)
0b77abb3 ZS	84	{
	85	int err;
	86	size_t tmp_len = dlen; / size_t(ulong) <-> uint on 64 bit */
	87
	88	err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);
	89
	90	if (err != LZO_E_OK)
	91	return -EINVAL;
	92
	93	*dlen = tmp_len;
	94	return 0;
ac9d2c4b	95	}
0b77abb3	96
ac9d2c4b GC	97	static int lzo_decompress(struct crypto_tfm tfm, const u8 src,
	98	unsigned int slen, u8 dst, unsigned int dlen)
	99	{
	100	return __lzo_decompress(src, slen, dst, dlen);
	101	}
	102
	103	static int lzo_sdecompress(struct crypto_scomp tfm, const u8 src,
	104	unsigned int slen, u8 dst, unsigned int dlen,
	105	void *ctx)
	106	{
	107	return __lzo_decompress(src, slen, dst, dlen);
0b77abb3 ZS	108	}
	109
	110	static struct crypto_alg alg = {
	111	.cra_name = "lzo",
d6ebf528	112	.cra_driver_name = "lzo-generic",
0b77abb3 ZS	113	.cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
	114	.cra_ctxsize = sizeof(struct lzo_ctx),
	115	.cra_module = THIS_MODULE,
0b77abb3 ZS	116	.cra_init = lzo_init,
	117	.cra_exit = lzo_exit,
	118	.cra_u = { .compress = {
ac9d2c4b GC	119	.coa_compress = lzo_compress,
	120	.coa_decompress = lzo_decompress } }
	121	};
	122
	123	static struct scomp_alg scomp = {
	124	.alloc_ctx = lzo_alloc_ctx,
	125	.free_ctx = lzo_free_ctx,
	126	.compress = lzo_scompress,
	127	.decompress = lzo_sdecompress,
	128	.base = {
	129	.cra_name = "lzo",
	130	.cra_driver_name = "lzo-scomp",
	131	.cra_module = THIS_MODULE,
	132	}
0b77abb3 ZS	133	};
0b77abb3 ZS	134
3af5b90b	135	static int __init lzo_mod_init(void)
0b77abb3	136	{
ac9d2c4b GC	137	int ret;
	138
	139	ret = crypto_register_alg(&alg);
	140	if (ret)
	141	return ret;
	142
	143	ret = crypto_register_scomp(&scomp);
	144	if (ret) {
	145	crypto_unregister_alg(&alg);
	146	return ret;
	147	}
	148
	149	return ret;
0b77abb3 ZS	150	}
0b77abb3 ZS	151
3af5b90b	152	static void __exit lzo_mod_fini(void)
0b77abb3 ZS	153	{
0b77abb3 ZS	154	crypto_unregister_alg(&alg);
ac9d2c4b	155	crypto_unregister_scomp(&scomp);
0b77abb3 ZS	156	}
0b77abb3 ZS	157
c4741b23	158	subsys_initcall(lzo_mod_init);
3af5b90b	159	module_exit(lzo_mod_fini);
0b77abb3 ZS	160
	161	MODULE_LICENSE("GPL");
	162	MODULE_DESCRIPTION("LZO Compression Algorithm");
5d26a105	163	MODULE_ALIAS_CRYPTO("lzo");