lib/lzo: separate lzo-rle from lzo (45ec975e) · Commits · 戴 / test

Documentation/lzo.txt

+8 −4

Original line number	Diff line number	Diff line
		@@ -88,6 +88,10 @@ length encoding. This improves speed for data with many zeros, which is a
		common case for zram. This modifies the bitstream in a backwards compatible way
		(v1 can correctly decompress v0 compressed data, but v0 cannot read v1 data).

		For maximum compatibility, both versions are available under different names
		(lzo and lzo-rle). Differences in the encoding are noted in this document with
		e.g.: version 1 only.

		Byte sequences
		==============

		@@ -99,8 +103,8 @@ Byte sequences
		invalid at this place.

		17 : bitstream version. If the first byte is 17, the next byte
		gives the bitstream version. If the first byte is not 17,
		the bitstream version is 0.
		gives the bitstream version (version 1 only). If the first byte
		is not 17, the bitstream version is 0.

		18..21 : copy 0..3 literals
		state = (byte - 17) = 0..3 [ copy <state> literals ]
		@@ -154,8 +158,8 @@ Byte sequences
		state = S (copy S literals after this block)
		End of stream is reached if distance == 16384

		In version 1, this instruction is also used to encode a run of zeros if
		distance = 0xbfff, i.e. H = 1 and the D bits are all 1.
		In version 1 only, this instruction is also used to encode a run of
		zeros if distance = 0xbfff, i.e. H = 1 and the D bits are all 1.
		In this case, it is followed by a fourth byte, X.
		run length = ((X << 3) \| (0 0 0 0 0 L L L)) + 4.

crypto/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -128,7 +128,7 @@ obj-$(CONFIG_CRYPTO_CRC32C) += crc32c_generic.o
		obj-$(CONFIG_CRYPTO_CRC32) += crc32_generic.o
		obj-$(CONFIG_CRYPTO_CRCT10DIF) += crct10dif_common.o crct10dif_generic.o
		obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o
		obj-$(CONFIG_CRYPTO_LZO) += lzo.o
		obj-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o
		obj-$(CONFIG_CRYPTO_LZ4) += lz4.o
		obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o
		obj-$(CONFIG_CRYPTO_842) += 842.o

crypto/lzo-rle.c

0 → 100644

+175 −0

Original line number	Diff line number	Diff line
		/*
		* Cryptographic API.
		*
		* This program is free software; you can redistribute it and/or modify it
		* under the terms of the GNU General Public License version 2 as published by
		* the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful, but WITHOUT
		* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
		* more details.
		*
		* You should have received a copy of the GNU General Public License along with
		* this program; if not, write to the Free Software Foundation, Inc., 51
		* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
		*
		*/

		#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 lzorle_ctx {
		void *lzorle_comp_mem;
		};

		static void lzorle_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 lzorle_init(struct crypto_tfm *tfm)
		{
		struct lzorle_ctx *ctx = crypto_tfm_ctx(tfm);

		ctx->lzorle_comp_mem = lzorle_alloc_ctx(NULL);
		if (IS_ERR(ctx->lzorle_comp_mem))
		return -ENOMEM;

		return 0;
		}

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

		static void lzorle_exit(struct crypto_tfm *tfm)
		{
		struct lzorle_ctx *ctx = crypto_tfm_ctx(tfm);

		lzorle_free_ctx(NULL, ctx->lzorle_comp_mem);
		}

		static int __lzorle_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 = lzorle1x_1_compress(src, slen, dst, &tmp_len, ctx);

		if (err != LZO_E_OK)
		return -EINVAL;

		*dlen = tmp_len;
		return 0;
		}

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

		return __lzorle_compress(src, slen, dst, dlen, ctx->lzorle_comp_mem);
		}

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

		static int __lzorle_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 lzorle_decompress(struct crypto_tfm tfm, const u8 src,
		unsigned int slen, u8 dst, unsigned int dlen)
		{
		return __lzorle_decompress(src, slen, dst, dlen);
		}

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

		static struct crypto_alg alg = {
		.cra_name = "lzo-rle",
		.cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
		.cra_ctxsize = sizeof(struct lzorle_ctx),
		.cra_module = THIS_MODULE,
		.cra_init = lzorle_init,
		.cra_exit = lzorle_exit,
		.cra_u = { .compress = {
		.coa_compress = lzorle_compress,
		.coa_decompress = lzorle_decompress } }
		};

		static struct scomp_alg scomp = {
		.alloc_ctx = lzorle_alloc_ctx,
		.free_ctx = lzorle_free_ctx,
		.compress = lzorle_scompress,
		.decompress = lzorle_sdecompress,
		.base = {
		.cra_name = "lzo-rle",
		.cra_driver_name = "lzo-rle-scomp",
		.cra_module = THIS_MODULE,
		}
		};

		static int __init lzorle_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 lzorle_mod_fini(void)
		{
		crypto_unregister_alg(&alg);
		crypto_unregister_scomp(&scomp);
		}

		module_init(lzorle_mod_init);
		module_exit(lzorle_mod_fini);

		MODULE_LICENSE("GPL");
		MODULE_DESCRIPTION("LZO-RLE Compression Algorithm");
		MODULE_ALIAS_CRYPTO("lzo-rle");

crypto/tcrypt.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -76,8 +76,8 @@ static char *check[] = {
		"cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
		"khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
		"camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
		"lzo", "cts", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
		"streebog256", "streebog512",
		"lzo", "lzo-rle", "cts", "sha3-224", "sha3-256", "sha3-384",
		"sha3-512", "streebog256", "streebog512",
		NULL
		};

drivers/block/zram/zcomp.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@

		static const char * const backends[] = {
		"lzo",
		"lzo-rle",
		#if IS_ENABLED(CONFIG_CRYPTO_LZ4)
		"lz4",
		#endif

Admin message