Commit c72ac7a1 authored by Chanho Min's avatar Chanho Min Committed by Linus Torvalds
Browse files

lib: add lz4 compressor module 

This patchset is for supporting LZ4 compression and the crypto API using
it.

As shown below, the size of data is a little bit bigger but compressing
speed is faster under the enabled unaligned memory access.  We can use
lz4 de/compression through crypto API as well.  Also, It will be useful
for another potential user of lz4 compression.

lz4 Compression Benchmark:
Compiler: ARM gcc 4.6.4
ARMv7, 1 GHz based board
   Kernel: linux 3.4
   Uncompressed data Size: 101 MB
         Compressed Size  compression Speed
   LZO   72.1MB		  32.1MB/s, 33.0MB/s(UA)
   LZ4   75.1MB		  30.4MB/s, 35.9MB/s(UA)
   LZ4HC 59.8MB		   2.4MB/s,  2.5MB/s(UA)
- UA: Unaligned memory Access support
- Latest patch set for LZO applied

This patch:

Add support for LZ4 compression in the Linux Kernel.  LZ4 Compression APIs
for kernel are based on LZ4 implementation by Yann Collet and were changed
for kernel coding style.

LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
LZ4 source repository : http://code.google.com/p/lz4/


svn revision : r90

Two APIs are added:

lz4_compress() support basic lz4 compression whereas lz4hc_compress()
support high compression or CPU performance get lower but compression
ratio get higher.  Also, we require the pre-allocated working memory with
the defined size and destination buffer must be allocated with the size of
lz4_compressbound.

[akpm@linux-foundation.org: make lz4_compresshcctx() static]
Signed-off-by: default avatarChanho Min <chanho.min@lge.com>
Cc: "Darrick J. Wong" <djwong@us.ibm.com>
Cc: Bob Pearson <rpearson@systemfabricworks.com>
Cc: Richard Weinberger <richard@nod.at>
Cc: Herbert Xu <herbert@gondor.hengli.com.au>
Cc: Yann Collet <yann.collet.73@gmail.com>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent f9b493ac

include/linux/lz4.h

+36 −0
Original line number Diff line number Diff line
@@ -9,6 +9,8 @@ 
 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#define LZ4_MEM_COMPRESS	(4096 * sizeof(unsigned char *))

#define LZ4HC_MEM_COMPRESS	(65538 * sizeof(unsigned char *))



/*

 * lz4_compressbound()
@@ -20,6 +22,40 @@ static inline size_t lz4_compressbound(size_t isize) 
	return isize + (isize / 255) + 16;

}



/*

 * lz4_compress()

 *	src     : source address of the original data

 *	src_len : size of the original data

 *	dst	: output buffer address of the compressed data

 *		This requires 'dst' of size LZ4_COMPRESSBOUND.

 *	dst_len : is the output size, which is returned after compress done

 *	workmem : address of the working memory.

 *		This requires 'workmem' of size LZ4_MEM_COMPRESS.

 *	return  : Success if return 0

 *		  Error if return (< 0)

 *	note :  Destination buffer and workmem must be already allocated with

 *		the defined size.

 */

int lz4_compress(const unsigned char *src, size_t src_len,

		unsigned char *dst, size_t *dst_len, void *wrkmem);



 /*

  * lz4hc_compress()

  *	 src	 : source address of the original data

  *	 src_len : size of the original data

  *	 dst	 : output buffer address of the compressed data

  *		This requires 'dst' of size LZ4_COMPRESSBOUND.

  *	 dst_len : is the output size, which is returned after compress done

  *	 workmem : address of the working memory.

  *		This requires 'workmem' of size LZ4HC_MEM_COMPRESS.

  *	 return  : Success if return 0

  *		   Error if return (< 0)

  *	 note :  Destination buffer and workmem must be already allocated with

  *		 the defined size.

  */

int lz4hc_compress(const unsigned char *src, size_t src_len,

		unsigned char *dst, size_t *dst_len, void *wrkmem);



/*

 * lz4_decompress()

 *	src     : source address of the compressed data

lib/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -194,6 +194,12 @@ config LZO_COMPRESS 
config LZO_DECOMPRESS

	tristate



config LZ4_COMPRESS

	tristate



config LZ4HC_COMPRESS

	tristate



config LZ4_DECOMPRESS

	tristate

lib/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -75,6 +75,8 @@ obj-$(CONFIG_REED_SOLOMON) += reed_solomon/ 
obj-$(CONFIG_BCH) += bch.o

obj-$(CONFIG_LZO_COMPRESS) += lzo/

obj-$(CONFIG_LZO_DECOMPRESS) += lzo/

obj-$(CONFIG_LZ4_COMPRESS) += lz4/

obj-$(CONFIG_LZ4HC_COMPRESS) += lz4/

obj-$(CONFIG_LZ4_DECOMPRESS) += lz4/

obj-$(CONFIG_XZ_DEC) += xz/

obj-$(CONFIG_RAID6_PQ) += raid6/

lib/lz4/Makefile

+2 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_LZ4_COMPRESS) += lz4_compress.o

obj-$(CONFIG_LZ4HC_COMPRESS) += lz4hc_compress.o

obj-$(CONFIG_LZ4_DECOMPRESS) += lz4_decompress.o

lib/lz4/lz4_compress.c

0 → 100644
+443 −0
Original line number Diff line number Diff line 
/*

 * LZ4 - Fast LZ compression algorithm

 * Copyright (C) 2011-2012, Yann Collet.

 * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)



 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * You can contact the author at :

 * - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html

 * - LZ4 source repository : http://code.google.com/p/lz4/

 *

 *  Changed for kernel use by:

 *  Chanho Min <chanho.min@lge.com>

 */



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/lz4.h>

#include <asm/unaligned.h>

#include "lz4defs.h"



/*

 * LZ4_compressCtx :

 * -----------------

 * Compress 'isize' bytes from 'source' into an output buffer 'dest' of

 * maximum size 'maxOutputSize'.  * If it cannot achieve it, compression

 * will stop, and result of the function will be zero.

 * return : the number of bytes written in buffer 'dest', or 0 if the

 * compression fails

 */

static inline int lz4_compressctx(void *ctx,

		const char *source,

		char *dest,

		int isize,

		int maxoutputsize)

{

	HTYPE *hashtable = (HTYPE *)ctx;

	const u8 *ip = (u8 *)source;

#if LZ4_ARCH64

	const BYTE * const base = ip;

#else

	const int base = 0;

#endif

	const u8 *anchor = ip;

	const u8 *const iend = ip + isize;

	const u8 *const mflimit = iend - MFLIMIT;

	#define MATCHLIMIT (iend - LASTLITERALS)



	u8 *op = (u8 *) dest;

	u8 *const oend = op + maxoutputsize;

	int length;

	const int skipstrength = SKIPSTRENGTH;

	u32 forwardh;

	int lastrun;



	/* Init */

	if (isize < MINLENGTH)

		goto _last_literals;



	memset((void *)hashtable, 0, LZ4_MEM_COMPRESS);



	/* First Byte */

	hashtable[LZ4_HASH_VALUE(ip)] = ip - base;

	ip++;

	forwardh = LZ4_HASH_VALUE(ip);



	/* Main Loop */

	for (;;) {

		int findmatchattempts = (1U << skipstrength) + 3;

		const u8 *forwardip = ip;

		const u8 *ref;

		u8 *token;



		/* Find a match */

		do {

			u32 h = forwardh;

			int step = findmatchattempts++ >> skipstrength;

			ip = forwardip;

			forwardip = ip + step;



			if (unlikely(forwardip > mflimit))

				goto _last_literals;



			forwardh = LZ4_HASH_VALUE(forwardip);

			ref = base + hashtable[h];

			hashtable[h] = ip - base;

		} while ((ref < ip - MAX_DISTANCE) || (A32(ref) != A32(ip)));



		/* Catch up */

		while ((ip > anchor) && (ref > (u8 *)source) &&

			unlikely(ip[-1] == ref[-1])) {

			ip--;

			ref--;

		}



		/* Encode Literal length */

		length = (int)(ip - anchor);

		token = op++;

		/* check output limit */

		if (unlikely(op + length + (2 + 1 + LASTLITERALS) +

			(length >> 8) > oend))

			return 0;



		if (length >= (int)RUN_MASK) {

			int len;

			*token = (RUN_MASK << ML_BITS);

			len = length - RUN_MASK;

			for (; len > 254 ; len -= 255)

				*op++ = 255;

			*op++ = (u8)len;

		} else

			*token = (length << ML_BITS);



		/* Copy Literals */

		LZ4_BLINDCOPY(anchor, op, length);

_next_match:

		/* Encode Offset */

		LZ4_WRITE_LITTLEENDIAN_16(op, (u16)(ip - ref));



		/* Start Counting */

		ip += MINMATCH;

		/* MinMatch verified */

		ref += MINMATCH;

		anchor = ip;

		while (likely(ip < MATCHLIMIT - (STEPSIZE - 1))) {

			#if LZ4_ARCH64

			u64 diff = A64(ref) ^ A64(ip);

			#else

			u32 diff = A32(ref) ^ A32(ip);

			#endif

			if (!diff) {

				ip += STEPSIZE;

				ref += STEPSIZE;

				continue;

			}

			ip += LZ4_NBCOMMONBYTES(diff);

			goto _endcount;

		}

		#if LZ4_ARCH64

		if ((ip < (MATCHLIMIT - 3)) && (A32(ref) == A32(ip))) {

			ip += 4;

			ref += 4;

		}

		#endif

		if ((ip < (MATCHLIMIT - 1)) && (A16(ref) == A16(ip))) {

			ip += 2;

			ref += 2;

		}

		if ((ip < MATCHLIMIT) && (*ref == *ip))

			ip++;

_endcount:

		/* Encode MatchLength */

		length = (int)(ip - anchor);

		/* Check output limit */

		if (unlikely(op + (1 + LASTLITERALS) + (length >> 8) > oend))

			return 0;

		if (length >= (int)ML_MASK) {

			*token += ML_MASK;

			length -= ML_MASK;

			for (; length > 509 ; length -= 510) {

				*op++ = 255;

				*op++ = 255;

			}

			if (length > 254) {

				length -= 255;

				*op++ = 255;

			}

			*op++ = (u8)length;

		} else

			*token += length;



		/* Test end of chunk */

		if (ip > mflimit) {

			anchor = ip;

			break;

		}



		/* Fill table */

		hashtable[LZ4_HASH_VALUE(ip-2)] = ip - 2 - base;



		/* Test next position */

		ref = base + hashtable[LZ4_HASH_VALUE(ip)];

		hashtable[LZ4_HASH_VALUE(ip)] = ip - base;

		if ((ref > ip - (MAX_DISTANCE + 1)) && (A32(ref) == A32(ip))) {

			token = op++;

			*token = 0;

			goto _next_match;

		}



		/* Prepare next loop */

		anchor = ip++;

		forwardh = LZ4_HASH_VALUE(ip);

	}



_last_literals:

	/* Encode Last Literals */

	lastrun = (int)(iend - anchor);

	if (((char *)op - dest) + lastrun + 1

		+ ((lastrun + 255 - RUN_MASK) / 255) > (u32)maxoutputsize)

		return 0;



	if (lastrun >= (int)RUN_MASK) {

		*op++ = (RUN_MASK << ML_BITS);

		lastrun -= RUN_MASK;

		for (; lastrun > 254 ; lastrun -= 255)

			*op++ = 255;

		*op++ = (u8)lastrun;

	} else

		*op++ = (lastrun << ML_BITS);

	memcpy(op, anchor, iend - anchor);

	op += iend - anchor;



	/* End */

	return (int)(((char *)op) - dest);

}



static inline int lz4_compress64kctx(void *ctx,

		const char *source,

		char *dest,

		int isize,

		int maxoutputsize)

{

	u16 *hashtable = (u16 *)ctx;

	const u8 *ip = (u8 *) source;

	const u8 *anchor = ip;

	const u8 *const base = ip;

	const u8 *const iend = ip + isize;

	const u8 *const mflimit = iend - MFLIMIT;

	#define MATCHLIMIT (iend - LASTLITERALS)



	u8 *op = (u8 *) dest;

	u8 *const oend = op + maxoutputsize;

	int len, length;

	const int skipstrength = SKIPSTRENGTH;

	u32 forwardh;

	int lastrun;



	/* Init */

	if (isize < MINLENGTH)

		goto _last_literals;



	memset((void *)hashtable, 0, LZ4_MEM_COMPRESS);



	/* First Byte */

	ip++;

	forwardh = LZ4_HASH64K_VALUE(ip);



	/* Main Loop */

	for (;;) {

		int findmatchattempts = (1U << skipstrength) + 3;

		const u8 *forwardip = ip;

		const u8 *ref;

		u8 *token;



		/* Find a match */

		do {

			u32 h = forwardh;

			int step = findmatchattempts++ >> skipstrength;

			ip = forwardip;

			forwardip = ip + step;



			if (forwardip > mflimit)

				goto _last_literals;



			forwardh = LZ4_HASH64K_VALUE(forwardip);

			ref = base + hashtable[h];

			hashtable[h] = (u16)(ip - base);

		} while (A32(ref) != A32(ip));



		/* Catch up */

		while ((ip > anchor) && (ref > (u8 *)source)

			&& (ip[-1] == ref[-1])) {

			ip--;

			ref--;

		}



		/* Encode Literal length */

		length = (int)(ip - anchor);

		token = op++;

		/* Check output limit */

		if (unlikely(op + length + (2 + 1 + LASTLITERALS)

			+ (length >> 8) > oend))

			return 0;

		if (length >= (int)RUN_MASK) {

			*token = (RUN_MASK << ML_BITS);

			len = length - RUN_MASK;

			for (; len > 254 ; len -= 255)

				*op++ = 255;

			*op++ = (u8)len;

		} else

			*token = (length << ML_BITS);



		/* Copy Literals */

		LZ4_BLINDCOPY(anchor, op, length);



_next_match:

		/* Encode Offset */

		LZ4_WRITE_LITTLEENDIAN_16(op, (u16)(ip - ref));



		/* Start Counting */

		ip += MINMATCH;

		/* MinMatch verified */

		ref += MINMATCH;

		anchor = ip;



		while (ip < MATCHLIMIT - (STEPSIZE - 1)) {

			#if LZ4_ARCH64

			u64 diff = A64(ref) ^ A64(ip);

			#else

			u32 diff = A32(ref) ^ A32(ip);

			#endif



			if (!diff) {

				ip += STEPSIZE;

				ref += STEPSIZE;

				continue;

			}

			ip += LZ4_NBCOMMONBYTES(diff);

			goto _endcount;

		}

		#if LZ4_ARCH64

		if ((ip < (MATCHLIMIT - 3)) && (A32(ref) == A32(ip))) {

			ip += 4;

			ref += 4;

		}

		#endif

		if ((ip < (MATCHLIMIT - 1)) && (A16(ref) == A16(ip))) {

			ip += 2;

			ref += 2;

		}

		if ((ip < MATCHLIMIT) && (*ref == *ip))

			ip++;

_endcount:



		/* Encode MatchLength */

		len = (int)(ip - anchor);

		/* Check output limit */

		if (unlikely(op + (1 + LASTLITERALS) + (len >> 8) > oend))

			return 0;

		if (len >= (int)ML_MASK) {

			*token += ML_MASK;

			len -= ML_MASK;

			for (; len > 509 ; len -= 510) {

				*op++ = 255;

				*op++ = 255;

			}

			if (len > 254) {

				len -= 255;

				*op++ = 255;

			}

			*op++ = (u8)len;

		} else

			*token += len;



		/* Test end of chunk */

		if (ip > mflimit) {

			anchor = ip;

			break;

		}



		/* Fill table */

		hashtable[LZ4_HASH64K_VALUE(ip-2)] = (u16)(ip - 2 - base);



		/* Test next position */

		ref = base + hashtable[LZ4_HASH64K_VALUE(ip)];

		hashtable[LZ4_HASH64K_VALUE(ip)] = (u16)(ip - base);

		if (A32(ref) == A32(ip)) {

			token = op++;

			*token = 0;

			goto _next_match;

		}



		/* Prepare next loop */

		anchor = ip++;

		forwardh = LZ4_HASH64K_VALUE(ip);

	}



_last_literals:

	/* Encode Last Literals */

	lastrun = (int)(iend - anchor);

	if (op + lastrun + 1 + (lastrun - RUN_MASK + 255) / 255 > oend)

		return 0;

	if (lastrun >= (int)RUN_MASK) {

		*op++ = (RUN_MASK << ML_BITS);

		lastrun -= RUN_MASK;

		for (; lastrun > 254 ; lastrun -= 255)

			*op++ = 255;

		*op++ = (u8)lastrun;

	} else

		*op++ = (lastrun << ML_BITS);

	memcpy(op, anchor, iend - anchor);

	op += iend - anchor;

	/* End */

	return (int)(((char *)op) - dest);

}



int lz4_compress(const unsigned char *src, size_t src_len,

			unsigned char *dst, size_t *dst_len, void *wrkmem)

{

	int ret = -1;

	int out_len = 0;



	if (src_len < LZ4_64KLIMIT)

		out_len = lz4_compress64kctx(wrkmem, src, dst, src_len,

				lz4_compressbound(src_len));

	else

		out_len = lz4_compressctx(wrkmem, src, dst, src_len,

				lz4_compressbound(src_len));



	if (out_len < 0)

		goto exit;



	*dst_len = out_len;



	return 0;

exit:

	return ret;

}

EXPORT_SYMBOL_GPL(lz4_compress);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("LZ4 compressor");

CRA Git | Maintained and supported by SUSTech CRA and CCSE