Commit b0af9cd9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'lzo-update-signature-20130226' of git://github.com/markus-oberhumer/linux 

Pull LZO compression update from Markus Oberhumer:
 "Summary:
  ========

  Update the Linux kernel LZO compression and decompression code to the
  current upstream version which features significant performance
  improvements on modern machines.

  Some *synthetic* benchmarks:
  ============================

    x86_64 (Sandy Bridge), gcc-4.6 -O3, Silesia test corpus, 256 kB block-size:

                     compression speed   decompression speed

    LZO-2005    :         150 MB/sec          468 MB/sec
    LZO-2012    :         434 MB/sec         1210 MB/sec

    i386 (Sandy Bridge), gcc-4.6 -O3, Silesia test corpus, 256 kB block-size:

                     compression speed   decompression speed

    LZO-2005    :         143 MB/sec          409 MB/sec
    LZO-2012    :         372 MB/sec         1121 MB/sec

    armv7 (Cortex-A9), Linaro gcc-4.6 -O3, Silesia test corpus, 256 kB block-size:

                     compression speed   decompression speed

    LZO-2005    :          27 MB/sec           84 MB/sec
    LZO-2012    :          44 MB/sec          117 MB/sec
  **LZO-2013-UA :          47 MB/sec          167 MB/sec

  Legend:

    LZO-2005    : LZO version in current 3.8 kernel (which is based on
                     the LZO 2.02 release from 2005)
    LZO-2012    : updated LZO version available in linux-next
  **LZO-2013-UA : updated LZO version available in linux-next plus experimental
                     ARM Unaligned Access patch. This needs approval
                     from some ARM maintainer ist NOT YET INCLUDED."

Andrew Morton <akpm@linux-foundation.org> acks it and says:
 "There's a new LZ4 on the block which is even faster than the sped-up
  LZO, but various filesystems and things use LZO"

* tag 'lzo-update-signature-20130226' of git://github.com/markus-oberhumer/linux:
  crypto: testmgr - update LZO compression test vectors
  lib/lzo: Update LZO compression to current upstream version
  lib/lzo: Rename lzo1x_decompress.c to lzo1x_decompress_safe.c
parents 1e500597 0ec73820

crypto/testmgr.h

+20 −18
Original line number Diff line number Diff line
@@ -25084,38 +25084,40 @@ static struct pcomp_testvec zlib_decomp_tv_template[] = { 
static struct comp_testvec lzo_comp_tv_template[] = {

	{

		.inlen	= 70,

		.outlen	= 46,

		.outlen	= 57,

		.input	= "Join us now and share the software "

			"Join us now and share the software ",

		.output	= "\x00\x0d\x4a\x6f\x69\x6e\x20\x75"

			  "\x73\x20\x6e\x6f\x77\x20\x61\x6e"

			  "\x64\x20\x73\x68\x61\x72\x65\x20"

			  "\x74\x68\x65\x20\x73\x6f\x66\x74"

			"\x77\x70\x01\x01\x4a\x6f\x69\x6e"

			"\x3d\x88\x00\x11\x00\x00",

			  "\x77\x70\x01\x32\x88\x00\x0c\x65"

			  "\x20\x74\x68\x65\x20\x73\x6f\x66"

			  "\x74\x77\x61\x72\x65\x20\x11\x00"

			  "\x00",

	}, {

		.inlen	= 159,

		.outlen	= 133,

		.outlen	= 131,

		.input	= "This document describes a compression method based on the LZO "

			"compression algorithm.  This document defines the application of "

			"the LZO algorithm used in UBIFS.",

		.output	= "\x00\x2b\x54\x68\x69\x73\x20\x64"

		.output	= "\x00\x2c\x54\x68\x69\x73\x20\x64"

			  "\x6f\x63\x75\x6d\x65\x6e\x74\x20"

			  "\x64\x65\x73\x63\x72\x69\x62\x65"

			  "\x73\x20\x61\x20\x63\x6f\x6d\x70"

			  "\x72\x65\x73\x73\x69\x6f\x6e\x20"

			  "\x6d\x65\x74\x68\x6f\x64\x20\x62"

			  "\x61\x73\x65\x64\x20\x6f\x6e\x20"

			  "\x74\x68\x65\x20\x4c\x5a\x4f\x2b"

			  "\x8c\x00\x0d\x61\x6c\x67\x6f\x72"

			  "\x69\x74\x68\x6d\x2e\x20\x20\x54"

			  "\x68\x69\x73\x2a\x54\x01\x02\x66"

			  "\x69\x6e\x65\x73\x94\x06\x05\x61"

			  "\x70\x70\x6c\x69\x63\x61\x74\x76"

			  "\x0a\x6f\x66\x88\x02\x60\x09\x27"

			  "\xf0\x00\x0c\x20\x75\x73\x65\x64"

			  "\x20\x69\x6e\x20\x55\x42\x49\x46"

			  "\x53\x2e\x11\x00\x00",

			  "\x74\x68\x65\x20\x4c\x5a\x4f\x20"

			  "\x2a\x8c\x00\x09\x61\x6c\x67\x6f"

			  "\x72\x69\x74\x68\x6d\x2e\x20\x20"

			  "\x2e\x54\x01\x03\x66\x69\x6e\x65"

			  "\x73\x20\x74\x06\x05\x61\x70\x70"

			  "\x6c\x69\x63\x61\x74\x76\x0a\x6f"

			  "\x66\x88\x02\x60\x09\x27\xf0\x00"

			  "\x0c\x20\x75\x73\x65\x64\x20\x69"

			  "\x6e\x20\x55\x42\x49\x46\x53\x2e"

			  "\x11\x00\x00",

	},

};

























include/linux/lzo.h



+8
−7






























Original line number
Diff line number
Diff line








@@ -4,22 +4,22 @@













 *  LZO Public Kernel Interface















 *  A mini subset of the LZO real-time data compression library















 *













 *  Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>













 *  Copyright (C) 1996-2012 Markus F.X.J. Oberhumer <markus@oberhumer.com>















 *















 *  The full LZO package can be found at:















 *  http://www.oberhumer.com/opensource/lzo/















 *













 *  Changed for kernel use by:













 *  Changed for Linux kernel use by:















 *  Nitin Gupta <nitingupta910@gmail.com>















 *  Richard Purdie <rpurdie@openedhand.com>















 */





























#define LZO1X_MEM_COMPRESS	(16384 * sizeof(unsigned char *))













#define LZO1X_1_MEM_COMPRESS	LZO1X_MEM_COMPRESS













#define LZO1X_1_MEM_COMPRESS	(8192 * sizeof(unsigned short))













#define LZO1X_MEM_COMPRESS	LZO1X_1_MEM_COMPRESS































#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)





























/* This requires 'workmem' of size LZO1X_1_MEM_COMPRESS */













/* This requires 'wrkmem' of size LZO1X_1_MEM_COMPRESS */















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















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

























@@ -40,5 +40,6 @@ int lzo1x_decompress_safe(const unsigned char *src, size_t src_len,













#define LZO_E_EOF_NOT_FOUND		(-7)















#define LZO_E_INPUT_NOT_CONSUMED	(-8)















#define LZO_E_NOT_YET_IMPLEMENTED	(-9)













#define LZO_E_INVALID_ARGUMENT		(-10)































#endif
























lib/decompress_unlzo.c



+1
−1






























Original line number
Diff line number
Diff line








@@ -31,7 +31,7 @@













 */































#ifdef STATIC













#include "lzo/lzo1x_decompress.c"













#include "lzo/lzo1x_decompress_safe.c"















#else















#include <linux/decompress/unlzo.h>















#endif

































lib/lzo/Makefile



+1
−1






























Original line number
Diff line number
Diff line















lzo_compress-objs := lzo1x_compress.o













lzo_decompress-objs := lzo1x_decompress.o













lzo_decompress-objs := lzo1x_decompress_safe.o































obj-$(CONFIG_LZO_COMPRESS) += lzo_compress.o















obj-$(CONFIG_LZO_DECOMPRESS) += lzo_decompress.o
























lib/lzo/lzo1x_compress.c



+194
−141






























Original line number
Diff line number
Diff line















/*













 *  LZO1X Compressor from MiniLZO













 *  LZO1X Compressor from LZO















 *













 *  Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>













 *  Copyright (C) 1996-2012 Markus F.X.J. Oberhumer <markus@oberhumer.com>















 *















 *  The full LZO package can be found at:















 *  http://www.oberhumer.com/opensource/lzo/















 *













 *  Changed for kernel use by:













 *  Changed for Linux kernel use by:















 *  Nitin Gupta <nitingupta910@gmail.com>















 *  Richard Purdie <rpurdie@openedhand.com>















 */































#include <linux/module.h>















#include <linux/kernel.h>













#include <linux/lzo.h>















#include <asm/unaligned.h>













#include <linux/lzo.h>















#include "lzodefs.h"































static noinline size_t













_lzo1x_1_do_compress(const unsigned char *in, size_t in_len,













		unsigned char *out, size_t *out_len, void *wrkmem)













lzo1x_1_do_compress(const unsigned char *in, size_t in_len,













		    unsigned char *out, size_t *out_len,













		    size_t ti, void *wrkmem)















{













	const unsigned char *ip;













	unsigned char *op;















	const unsigned char * const in_end = in + in_len;













	const unsigned char * const ip_end = in + in_len - M2_MAX_LEN - 5;













	const unsigned char ** const dict = wrkmem;













	const unsigned char *ip = in, *ii = ip;













	const unsigned char *end, *m, *m_pos;













	size_t m_off, m_len, dindex;













	unsigned char *op = out;













	const unsigned char * const ip_end = in + in_len - 20;













	const unsigned char *ii;













	lzo_dict_t * const dict = (lzo_dict_t *) wrkmem;





























	ip += 4;













	op = out;













	ip = in;













	ii = ip;













	ip += ti < 4 ? 4 - ti : 0;































	for (;;) {













		dindex = ((size_t)(0x21 * DX3(ip, 5, 5, 6)) >> 5) & D_MASK;













		m_pos = dict[dindex];



























		if (m_pos < in)













			goto literal;



























		if (ip == m_pos || ((size_t)(ip - m_pos) > M4_MAX_OFFSET))













			goto literal;



























		m_off = ip - m_pos;













		if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])













			goto try_match;



























		dindex = (dindex & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f);













		m_pos = dict[dindex];



























		if (m_pos < in)













			goto literal;



























		if (ip == m_pos || ((size_t)(ip - m_pos) > M4_MAX_OFFSET))













			goto literal;



























		m_off = ip - m_pos;













		if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])













			goto try_match;



























		goto literal;



























try_match:













		if (get_unaligned((const unsigned short *)m_pos)













				== get_unaligned((const unsigned short *)ip)) {













			if (likely(m_pos[2] == ip[2]))













					goto match;













		}



























		const unsigned char *m_pos;













		size_t t, m_len, m_off;













		u32 dv;















literal:













		dict[dindex] = ip;













		++ip;













		ip += 1 + ((ip - ii) >> 5);













next:















		if (unlikely(ip >= ip_end))















			break;













		continue;



























match:













		dict[dindex] = ip;













		if (ip != ii) {













			size_t t = ip - ii;













		dv = get_unaligned_le32(ip);













		t = ((dv * 0x1824429d) >> (32 - D_BITS)) & D_MASK;













		m_pos = in + dict[t];













		dict[t] = (lzo_dict_t) (ip - in);













		if (unlikely(dv != get_unaligned_le32(m_pos)))













			goto literal;





























		ii -= ti;













		ti = 0;













		t = ip - ii;













		if (t != 0) {















			if (t <= 3) {















				op[-2] |= t;













			} else if (t <= 18) {













				COPY4(op, ii);













				op += t;













			} else if (t <= 16) {













				*op++ = (t - 3);













				COPY8(op, ii);













				COPY8(op + 8, ii + 8);













				op += t;













			} else {













				if (t <= 18) {















					*op++ = (t - 3);















				} else {















					size_t tt = t - 18;





























					*op++ = 0;













				while (tt > 255) {













					while (unlikely(tt > 255)) {















						tt -= 255;















						*op++ = 0;















					}















					*op++ = tt;















				}















				do {













					COPY8(op, ii);













					COPY8(op + 8, ii + 8);













					op += 16;













					ii += 16;













					t -= 16;













				} while (t >= 16);













				if (t > 0) do {















					*op++ = *ii++;















				} while (--t > 0);















			}













		}





























		ip += 3;













		if (m_pos[3] != *ip++ || m_pos[4] != *ip++













				|| m_pos[5] != *ip++ || m_pos[6] != *ip++













				|| m_pos[7] != *ip++ || m_pos[8] != *ip++) {













			--ip;













			m_len = ip - ii;













		m_len = 4;













		{













#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && defined(LZO_USE_CTZ64)













		u64 v;













		v = get_unaligned((const u64 *) (ip + m_len)) ^













		    get_unaligned((const u64 *) (m_pos + m_len));













		if (unlikely(v == 0)) {













			do {













				m_len += 8;













				v = get_unaligned((const u64 *) (ip + m_len)) ^













				    get_unaligned((const u64 *) (m_pos + m_len));













				if (unlikely(ip + m_len >= ip_end))













					goto m_len_done;













			} while (v == 0);













		}













#  if defined(__LITTLE_ENDIAN)













		m_len += (unsigned) __builtin_ctzll(v) / 8;













#  elif defined(__BIG_ENDIAN)













		m_len += (unsigned) __builtin_clzll(v) / 8;













#  else













#    error "missing endian definition"













#  endif













#elif defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && defined(LZO_USE_CTZ32)













		u32 v;













		v = get_unaligned((const u32 *) (ip + m_len)) ^













		    get_unaligned((const u32 *) (m_pos + m_len));













		if (unlikely(v == 0)) {













			do {













				m_len += 4;













				v = get_unaligned((const u32 *) (ip + m_len)) ^













				    get_unaligned((const u32 *) (m_pos + m_len));













				if (v != 0)













					break;













				m_len += 4;













				v = get_unaligned((const u32 *) (ip + m_len)) ^













				    get_unaligned((const u32 *) (m_pos + m_len));













				if (unlikely(ip + m_len >= ip_end))













					goto m_len_done;













			} while (v == 0);













		}













#  if defined(__LITTLE_ENDIAN)













		m_len += (unsigned) __builtin_ctz(v) / 8;













#  elif defined(__BIG_ENDIAN)













		m_len += (unsigned) __builtin_clz(v) / 8;













#  else













#    error "missing endian definition"













#  endif













#else













		if (unlikely(ip[m_len] == m_pos[m_len])) {













			do {













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (ip[m_len] != m_pos[m_len])













					break;













				m_len += 1;













				if (unlikely(ip + m_len >= ip_end))













					goto m_len_done;













			} while (ip[m_len] == m_pos[m_len]);













		}













#endif













		}













m_len_done:





























			if (m_off <= M2_MAX_OFFSET) {













		m_off = ip - m_pos;













		ip += m_len;













		ii = ip;













		if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) {















			m_off -= 1;













				*op++ = (((m_len - 1) << 5)













						| ((m_off & 7) << 2));













			*op++ = (((m_len - 1) << 5) | ((m_off & 7) << 2));















			*op++ = (m_off >> 3);















		} else if (m_off <= M3_MAX_OFFSET) {















			m_off -= 1;













			if (m_len <= M3_MAX_LEN)















				*op++ = (M3_MARKER | (m_len - 2));













				goto m3_m4_offset;













			} else {













				m_off -= 0x4000;



























				*op++ = (M4_MARKER | ((m_off & 0x4000) >> 11)













						| (m_len - 2));













				goto m3_m4_offset;













			}













		} else {













			end = in_end;













			m = m_pos + M2_MAX_LEN + 1;



























			while (ip < end && *m == *ip) {













				m++;













				ip++;













			}













			m_len = ip - ii;



























			if (m_off <= M3_MAX_OFFSET) {













				m_off -= 1;













				if (m_len <= 33) {













					*op++ = (M3_MARKER | (m_len - 2));













				} else {













					m_len -= 33;













			else {













				m_len -= M3_MAX_LEN;















				*op++ = M3_MARKER | 0;













					goto m3_m4_len;













				while (unlikely(m_len > 255)) {













					m_len -= 255;













					*op++ = 0;















				}













				*op++ = (m_len);













			}













			*op++ = (m_off << 2);













			*op++ = (m_off >> 6);















		} else {















			m_off -= 0x4000;













				if (m_len <= M4_MAX_LEN) {













					*op++ = (M4_MARKER













						| ((m_off & 0x4000) >> 11)













			if (m_len <= M4_MAX_LEN)













				*op++ = (M4_MARKER | ((m_off >> 11) & 8)















						| (m_len - 2));













				} else {













			else {















				m_len -= M4_MAX_LEN;













					*op++ = (M4_MARKER













						| ((m_off & 0x4000) >> 11));













m3_m4_len:













					while (m_len > 255) {













				*op++ = (M4_MARKER | ((m_off >> 11) & 8));













				while (unlikely(m_len > 255)) {















					m_len -= 255;















					*op++ = 0;















				}





























				*op++ = (m_len);















			}













			}













m3_m4_offset:













			*op++ = ((m_off & 63) << 2);













			*op++ = (m_off << 2);















			*op++ = (m_off >> 6);















		}



























		ii = ip;













		if (unlikely(ip >= ip_end))













			break;













		goto next;















	}





























	*out_len = op - out;













	return in_end - ii;













	return in_end - (ii - ti);















}





























int lzo1x_1_compress(const unsigned char *in, size_t in_len, unsigned char *out,













			size_t *out_len, void *wrkmem)













int lzo1x_1_compress(const unsigned char *in, size_t in_len,













		     unsigned char *out, size_t *out_len,













		     void *wrkmem)















{













	const unsigned char *ii;













	const unsigned char *ip = in;















	unsigned char *op = out;













	size_t t;













	size_t l = in_len;













	size_t t = 0;





























	if (unlikely(in_len <= M2_MAX_LEN + 5)) {













		t = in_len;













	} else {













		t = _lzo1x_1_do_compress(in, in_len, op, out_len, wrkmem);













	while (l > 20) {













		size_t ll = l <= (M4_MAX_OFFSET + 1) ? l : (M4_MAX_OFFSET + 1);













		uintptr_t ll_end = (uintptr_t) ip + ll;













		if ((ll_end + ((t + ll) >> 5)) <= ll_end)













			break;













		BUILD_BUG_ON(D_SIZE * sizeof(lzo_dict_t) > LZO1X_1_MEM_COMPRESS);













		memset(wrkmem, 0, D_SIZE * sizeof(lzo_dict_t));













		t = lzo1x_1_do_compress(ip, ll, op, out_len, t, wrkmem);













		ip += ll;















		op += *out_len;













		l  -= ll;















	}













	t += l;































	if (t > 0) {













		ii = in + in_len - t;













		const unsigned char *ii = in + in_len - t;































		if (op == out && t <= 238) {















			*op++ = (17 + t);









@@ -198,16 +247,21 @@ int lzo1x_1_compress(const unsigned char *in, size_t in_len, unsigned char *out,













			*op++ = (t - 3);















		} else {















			size_t tt = t - 18;





























			*op++ = 0;















			while (tt > 255) {















				tt -= 255;















				*op++ = 0;















			}





























			*op++ = tt;















		}













		do {













		if (t >= 16) do {













			COPY8(op, ii);













			COPY8(op + 8, ii + 8);













			op += 16;













			ii += 16;













			t -= 16;













		} while (t >= 16);













		if (t > 0) do {















			*op++ = *ii++;















		} while (--t > 0);















	}









@@ -223,4 +277,3 @@ EXPORT_SYMBOL_GPL(lzo1x_1_compress);





























MODULE_LICENSE("GPL");















MODULE_DESCRIPTION("LZO1X-1 Compressor");












































































CRA Git | Maintained and supported by SUSTech CRA and CCSE