Skip to content

L
linux
Commit b0af9cd9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Options

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
Hide whitespace changes
Inline Side-by-side
Showing with 488 additions and 434 deletions
crypto/testmgr.h
View file @ b0af9cd9
...@@ -25084,38 +25084,40 @@ static struct pcomp_testvec zlib_decomp_tv_template[] = { ...@@ -25084,38 +25084,40 @@ static struct pcomp_testvec zlib_decomp_tv_template[] = {
static struct comp_testvec lzo_comp_tv_template[] = { static struct comp_testvec lzo_comp_tv_template[] = {
{ {
.inlen = 70, .inlen = 70,
.outlen = 46, .outlen = 57,
.input = "Join us now and share the software " .input = "Join us now and share the software "
"Join us now and share the software ", "Join us now and share the software ",
.output = "\x00\x0d\x4a\x6f\x69\x6e\x20\x75" .output = "\x00\x0d\x4a\x6f\x69\x6e\x20\x75"
"\x73\x20\x6e\x6f\x77\x20\x61\x6e" "\x73\x20\x6e\x6f\x77\x20\x61\x6e"
"\x64\x20\x73\x68\x61\x72\x65\x20" "\x64\x20\x73\x68\x61\x72\x65\x20"
"\x74\x68\x65\x20\x73\x6f\x66\x74" "\x74\x68\x65\x20\x73\x6f\x66\x74"
"\x77\x70\x01\x01\x4a\x6f\x69\x6e" "\x77\x70\x01\x32\x88\x00\x0c\x65"
"\x3d\x88\x00\x11\x00\x00", "\x20\x74\x68\x65\x20\x73\x6f\x66"
"\x74\x77\x61\x72\x65\x20\x11\x00"
"\x00",
}, { }, {
.inlen = 159, .inlen = 159,
.outlen = 133, .outlen = 131,
.input = "This document describes a compression method based on the LZO " .input = "This document describes a compression method based on the LZO "
"compression algorithm. This document defines the application of " "compression algorithm. This document defines the application of "
"the LZO algorithm used in UBIFS.", "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" "\x6f\x63\x75\x6d\x65\x6e\x74\x20"
"\x64\x65\x73\x63\x72\x69\x62\x65" "\x64\x65\x73\x63\x72\x69\x62\x65"
"\x73\x20\x61\x20\x63\x6f\x6d\x70" "\x73\x20\x61\x20\x63\x6f\x6d\x70"
"\x72\x65\x73\x73\x69\x6f\x6e\x20" "\x72\x65\x73\x73\x69\x6f\x6e\x20"
"\x6d\x65\x74\x68\x6f\x64\x20\x62" "\x6d\x65\x74\x68\x6f\x64\x20\x62"
"\x61\x73\x65\x64\x20\x6f\x6e\x20" "\x61\x73\x65\x64\x20\x6f\x6e\x20"
"\x74\x68\x65\x20\x4c\x5a\x4f\x2b" "\x74\x68\x65\x20\x4c\x5a\x4f\x20"
"\x8c\x00\x0d\x61\x6c\x67\x6f\x72" "\x2a\x8c\x00\x09\x61\x6c\x67\x6f"
"\x69\x74\x68\x6d\x2e\x20\x20\x54" "\x72\x69\x74\x68\x6d\x2e\x20\x20"
"\x68\x69\x73\x2a\x54\x01\x02\x66" "\x2e\x54\x01\x03\x66\x69\x6e\x65"
"\x69\x6e\x65\x73\x94\x06\x05\x61" "\x73\x20\x74\x06\x05\x61\x70\x70"
"\x70\x70\x6c\x69\x63\x61\x74\x76" "\x6c\x69\x63\x61\x74\x76\x0a\x6f"
"\x0a\x6f\x66\x88\x02\x60\x09\x27" "\x66\x88\x02\x60\x09\x27\xf0\x00"
"\xf0\x00\x0c\x20\x75\x73\x65\x64" "\x0c\x20\x75\x73\x65\x64\x20\x69"
"\x20\x69\x6e\x20\x55\x42\x49\x46" "\x6e\x20\x55\x42\x49\x46\x53\x2e"
"\x53\x2e\x11\x00\x00", "\x11\x00\x00",
}, },
}; };
......
include/linux/lzo.h
View file @ b0af9cd9
...@@ -4,28 +4,28 @@ ...@@ -4,28 +4,28 @@
* LZO Public Kernel Interface * LZO Public Kernel Interface
* A mini subset of the LZO real-time data compression library * 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: * The full LZO package can be found at:
* http://www.oberhumer.com/opensource/lzo/ * http://www.oberhumer.com/opensource/lzo/
* *
* Changed for kernel use by: * Changed for Linux kernel use by:
* Nitin Gupta <nitingupta910@gmail.com> * Nitin Gupta <nitingupta910@gmail.com>
* Richard Purdie <rpurdie@openedhand.com> * Richard Purdie <rpurdie@openedhand.com>
*/ */
#define LZO1X_MEM_COMPRESS (16384 * sizeof(unsigned char *)) #define LZO1X_1_MEM_COMPRESS (8192 * sizeof(unsigned short))
#define LZO1X_1_MEM_COMPRESS LZO1X_MEM_COMPRESS #define LZO1X_MEM_COMPRESS LZO1X_1_MEM_COMPRESS
#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3) #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, int lzo1x_1_compress(const unsigned char *src, size_t src_len,
unsigned char *dst, size_t *dst_len, void *wrkmem); unsigned char *dst, size_t *dst_len, void *wrkmem);
/* safe decompression with overrun testing */ /* safe decompression with overrun testing */
int lzo1x_decompress_safe(const unsigned char *src, size_t src_len, int lzo1x_decompress_safe(const unsigned char *src, size_t src_len,
unsigned char *dst, size_t *dst_len); unsigned char *dst, size_t *dst_len);
/* /*
* Return values (< 0 = Error) * Return values (< 0 = Error)
...@@ -40,5 +40,6 @@ int lzo1x_decompress_safe(const unsigned char *src, size_t src_len, ...@@ -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_EOF_NOT_FOUND (-7)
#define LZO_E_INPUT_NOT_CONSUMED (-8) #define LZO_E_INPUT_NOT_CONSUMED (-8)
#define LZO_E_NOT_YET_IMPLEMENTED (-9) #define LZO_E_NOT_YET_IMPLEMENTED (-9)
#define LZO_E_INVALID_ARGUMENT (-10)
#endif #endif
lib/decompress_unlzo.c
View file @ b0af9cd9
...@@ -31,7 +31,7 @@ ...@@ -31,7 +31,7 @@
*/ */
#ifdef STATIC #ifdef STATIC
#include "lzo/lzo1x_decompress.c" #include "lzo/lzo1x_decompress_safe.c"
#else #else
#include <linux/decompress/unlzo.h> #include <linux/decompress/unlzo.h>
#endif #endif
......
lib/lzo/Makefile
View file @ b0af9cd9
lzo_compress-objs := lzo1x_compress.o 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_COMPRESS) += lzo_compress.o
obj-$(CONFIG_LZO_DECOMPRESS) += lzo_decompress.o obj-$(CONFIG_LZO_DECOMPRESS) += lzo_decompress.o
lib/lzo/lzo1x_compress.c
View file @ b0af9cd9
/* /*
* 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: * The full LZO package can be found at:
* http://www.oberhumer.com/opensource/lzo/ * http://www.oberhumer.com/opensource/lzo/
* *
* Changed for kernel use by: * Changed for Linux kernel use by:
* Nitin Gupta <nitingupta910@gmail.com> * Nitin Gupta <nitingupta910@gmail.com>
* Richard Purdie <rpurdie@openedhand.com> * Richard Purdie <rpurdie@openedhand.com>
*/ */
#include <linux/module.h> #include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/lzo.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <linux/lzo.h>
#include "lzodefs.h" #include "lzodefs.h"
static noinline size_t static noinline size_t
_lzo1x_1_do_compress(const unsigned char *in, size_t in_len, lzo1x_1_do_compress(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len, void *wrkmem) 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 in_end = in + in_len;
const unsigned char * const ip_end = in + in_len - M2_MAX_LEN - 5; const unsigned char * const ip_end = in + in_len - 20;
const unsigned char ** const dict = wrkmem; const unsigned char *ii;
const unsigned char *ip = in, *ii = ip; lzo_dict_t * const dict = (lzo_dict_t *) wrkmem;
const unsigned char *end, *m, *m_pos;
size_t m_off, m_len, dindex;
unsigned char *op = out;
ip += 4; op = out;
ip = in;
ii = ip;
ip += ti < 4 ? 4 - ti : 0;
for (;;) { for (;;) {
dindex = ((size_t)(0x21 * DX3(ip, 5, 5, 6)) >> 5) & D_MASK; const unsigned char *m_pos;
m_pos = dict[dindex]; size_t t, m_len, m_off;
u32 dv;
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;
}
literal: literal:
dict[dindex] = ip; ip += 1 + ((ip - ii) >> 5);
++ip; next:
if (unlikely(ip >= ip_end)) if (unlikely(ip >= ip_end))
break; break;
continue; dv = get_unaligned_le32(ip);
t = ((dv * 0x1824429d) >> (32 - D_BITS)) & D_MASK;
match: m_pos = in + dict[t];
dict[dindex] = ip; dict[t] = (lzo_dict_t) (ip - in);
if (ip != ii) { if (unlikely(dv != get_unaligned_le32(m_pos)))
size_t t = ip - ii; goto literal;
ii -= ti;
ti = 0;
t = ip - ii;
if (t != 0) {
if (t <= 3) { if (t <= 3) {
op[-2] |= t; op[-2] |= t;
} else if (t <= 18) { COPY4(op, ii);
op += t;
} else if (t <= 16) {
*op++ = (t - 3); *op++ = (t - 3);
COPY8(op, ii);
COPY8(op + 8, ii + 8);
op += t;
} else { } else {
size_t tt = t - 18; if (t <= 18) {
*op++ = (t - 3);
*op++ = 0; } else {
while (tt > 255) { size_t tt = t - 18;
tt -= 255;
*op++ = 0; *op++ = 0;
while (unlikely(tt > 255)) {
tt -= 255;
*op++ = 0;
}
*op++ = tt;
} }
*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);
} }
do {
*op++ = *ii++;
} while (--t > 0);
} }
ip += 3; m_len = 4;
if (m_pos[3] != *ip++ || m_pos[4] != *ip++ {
|| m_pos[5] != *ip++ || m_pos[6] != *ip++ #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && defined(LZO_USE_CTZ64)
|| m_pos[7] != *ip++ || m_pos[8] != *ip++) { u64 v;
--ip; v = get_unaligned((const u64 *) (ip + m_len)) ^
m_len = ip - ii; 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;
m_off -= 1; ip += m_len;
*op++ = (((m_len - 1) << 5) ii = ip;
| ((m_off & 7) << 2)); if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) {
*op++ = (m_off >> 3); m_off -= 1;
} else if (m_off <= M3_MAX_OFFSET) { *op++ = (((m_len - 1) << 5) | ((m_off & 7) << 2));
m_off -= 1; *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)); *op++ = (M3_MARKER | (m_len - 2));
goto m3_m4_offset; else {
} else { m_len -= M3_MAX_LEN;
m_off -= 0x4000; *op++ = M3_MARKER | 0;
while (unlikely(m_len > 255)) {
*op++ = (M4_MARKER | ((m_off & 0x4000) >> 11) m_len -= 255;
| (m_len - 2)); *op++ = 0;
goto m3_m4_offset; }
*op++ = (m_len);
} }
*op++ = (m_off << 2);
*op++ = (m_off >> 6);
} else { } else {
end = in_end; m_off -= 0x4000;
m = m_pos + M2_MAX_LEN + 1; if (m_len <= M4_MAX_LEN)
*op++ = (M4_MARKER | ((m_off >> 11) & 8)
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;
*op++ = M3_MARKER | 0;
goto m3_m4_len;
}
} else {
m_off -= 0x4000;
if (m_len <= M4_MAX_LEN) {
*op++ = (M4_MARKER
| ((m_off & 0x4000) >> 11)
| (m_len - 2)); | (m_len - 2));
} else { else {
m_len -= M4_MAX_LEN; m_len -= M4_MAX_LEN;
*op++ = (M4_MARKER *op++ = (M4_MARKER | ((m_off >> 11) & 8));
| ((m_off & 0x4000) >> 11)); while (unlikely(m_len > 255)) {
m3_m4_len: m_len -= 255;
while (m_len > 255) { *op++ = 0;
m_len -= 255;
*op++ = 0;
}
*op++ = (m_len);
} }
*op++ = (m_len);
} }
m3_m4_offset: *op++ = (m_off << 2);
*op++ = ((m_off & 63) << 2);
*op++ = (m_off >> 6); *op++ = (m_off >> 6);
} }
goto next;
ii = ip;
if (unlikely(ip >= ip_end))
break;
} }
*out_len = op - out; *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, int lzo1x_1_compress(const unsigned char *in, size_t in_len,
size_t *out_len, void *wrkmem) unsigned char *out, size_t *out_len,
void *wrkmem)
{ {
const unsigned char *ii; const unsigned char *ip = in;
unsigned char *op = out; unsigned char *op = out;
size_t t; size_t l = in_len;
size_t t = 0;
if (unlikely(in_len <= M2_MAX_LEN + 5)) { while (l > 20) {
t = in_len; size_t ll = l <= (M4_MAX_OFFSET + 1) ? l : (M4_MAX_OFFSET + 1);
} else { uintptr_t ll_end = (uintptr_t) ip + ll;
t = _lzo1x_1_do_compress(in, in_len, op, out_len, wrkmem); 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; op += *out_len;
l -= ll;
} }
t += l;
if (t > 0) { if (t > 0) {
ii = in + in_len - t; const unsigned char *ii = in + in_len - t;
if (op == out && t <= 238) { if (op == out && t <= 238) {
*op++ = (17 + t); *op++ = (17 + t);
...@@ -198,16 +247,21 @@ int lzo1x_1_compress(const unsigned char *in, size_t in_len, unsigned char *out, ...@@ -198,16 +247,21 @@ int lzo1x_1_compress(const unsigned char *in, size_t in_len, unsigned char *out,
*op++ = (t - 3); *op++ = (t - 3);
} else { } else {
size_t tt = t - 18; size_t tt = t - 18;
*op++ = 0; *op++ = 0;
while (tt > 255) { while (tt > 255) {
tt -= 255; tt -= 255;
*op++ = 0; *op++ = 0;
} }
*op++ = tt; *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++; *op++ = *ii++;
} while (--t > 0); } while (--t > 0);
} }
...@@ -223,4 +277,3 @@ EXPORT_SYMBOL_GPL(lzo1x_1_compress); ...@@ -223,4 +277,3 @@ EXPORT_SYMBOL_GPL(lzo1x_1_compress);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("LZO1X-1 Compressor"); MODULE_DESCRIPTION("LZO1X-1 Compressor");
lib/lzo/lzo1x_decompress.c deleted 100644 → 0
View file @ 1e500597
/*
* LZO1X Decompressor from MiniLZO
*
* Copyright (C) 1996-2005 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:
* Nitin Gupta <nitingupta910@gmail.com>
* Richard Purdie <rpurdie@openedhand.com>
*/
#ifndef STATIC
#include <linux/module.h>
#include <linux/kernel.h>
#endif
#include <asm/unaligned.h>
#include <linux/lzo.h>
#include "lzodefs.h"
#define HAVE_IP(x, ip_end, ip) ((size_t)(ip_end - ip) < (x))
#define HAVE_OP(x, op_end, op) ((size_t)(op_end - op) < (x))
#define HAVE_LB(m_pos, out, op) (m_pos < out || m_pos >= op)
#define COPY4(dst, src) \
put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len)
{
const unsigned char * const ip_end = in + in_len;
unsigned char * const op_end = out + *out_len;
const unsigned char *ip = in, *m_pos;
unsigned char *op = out;
size_t t;
*out_len = 0;
if (*ip > 17) {
t = *ip++ - 17;
if (t < 4)
goto match_next;
if (HAVE_OP(t, op_end, op))
goto output_overrun;
if (HAVE_IP(t + 1, ip_end, ip))
goto input_overrun;
do {
*op++ = *ip++;
} while (--t > 0);
goto first_literal_run;
}
while ((ip < ip_end)) {
t = *ip++;
if (t >= 16)
goto match;
if (t == 0) {
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
while (*ip == 0) {
t += 255;
ip++;
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
}
t += 15 + *ip++;
}
if (HAVE_OP(t + 3, op_end, op))
goto output_overrun;
if (HAVE_IP(t + 4, ip_end, ip))
goto input_overrun;
COPY4(op, ip);
op += 4;
ip += 4;
if (--t > 0) {
if (t >= 4) {
do {
COPY4(op, ip);
op += 4;
ip += 4;
t -= 4;
} while (t >= 4);
if (t > 0) {
do {
*op++ = *ip++;
} while (--t > 0);
}
} else {
do {
*op++ = *ip++;
} while (--t > 0);
}
}
first_literal_run:
t = *ip++;
if (t >= 16)
goto match;
m_pos = op - (1 + M2_MAX_OFFSET);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
if (HAVE_LB(m_pos, out, op))
goto lookbehind_overrun;
if (HAVE_OP(3, op_end, op))
goto output_overrun;
*op++ = *m_pos++;
*op++ = *m_pos++;
*op++ = *m_pos;
goto match_done;
do {
match:
if (t >= 64) {
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1;
if (HAVE_LB(m_pos, out, op))
goto lookbehind_overrun;
if (HAVE_OP(t + 3 - 1, op_end, op))
goto output_overrun;
goto copy_match;
} else if (t >= 32) {
t &= 31;
if (t == 0) {
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
while (*ip == 0) {
t += 255;
ip++;
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
}
t += 31 + *ip++;
}
m_pos = op - 1;
m_pos -= get_unaligned_le16(ip) >> 2;
ip += 2;
} else if (t >= 16) {
m_pos = op;
m_pos -= (t & 8) << 11;
t &= 7;
if (t == 0) {
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
while (*ip == 0) {
t += 255;
ip++;
if (HAVE_IP(1, ip_end, ip))
goto input_overrun;
}
t += 7 + *ip++;
}
m_pos -= get_unaligned_le16(ip) >> 2;
ip += 2;
if (m_pos == op)
goto eof_found;
m_pos -= 0x4000;
} else {
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
if (HAVE_LB(m_pos, out, op))
goto lookbehind_overrun;
if (HAVE_OP(2, op_end, op))
goto output_overrun;
*op++ = *m_pos++;
*op++ = *m_pos;
goto match_done;
}
if (HAVE_LB(m_pos, out, op))
goto lookbehind_overrun;
if (HAVE_OP(t + 3 - 1, op_end, op))
goto output_overrun;
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) {
COPY4(op, m_pos);
op += 4;
m_pos += 4;
t -= 4 - (3 - 1);
do {
COPY4(op, m_pos);
op += 4;
m_pos += 4;
t -= 4;
} while (t >= 4);
if (t > 0)
do {
*op++ = *m_pos++;
} while (--t > 0);
} else {
copy_match:
*op++ = *m_pos++;
*op++ = *m_pos++;
do {
*op++ = *m_pos++;
} while (--t > 0);
}
match_done:
t = ip[-2] & 3;
if (t == 0)
break;
match_next:
if (HAVE_OP(t, op_end, op))
goto output_overrun;
if (HAVE_IP(t + 1, ip_end, ip))
goto input_overrun;
*op++ = *ip++;
if (t > 1) {
*op++ = *ip++;
if (t > 2)
*op++ = *ip++;
}
t = *ip++;
} while (ip < ip_end);
}
*out_len = op - out;
return LZO_E_EOF_NOT_FOUND;
eof_found:
*out_len = op - out;
return (ip == ip_end ? LZO_E_OK :
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
input_overrun:
*out_len = op - out;
return LZO_E_INPUT_OVERRUN;
output_overrun:
*out_len = op - out;
return LZO_E_OUTPUT_OVERRUN;
lookbehind_overrun:
*out_len = op - out;
return LZO_E_LOOKBEHIND_OVERRUN;
}
#ifndef STATIC
EXPORT_SYMBOL_GPL(lzo1x_decompress_safe);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("LZO1X Decompressor");
#endif
lib/lzo/lzo1x_decompress_safe.c 0 → 100644
View file @ b0af9cd9
/*
* LZO1X Decompressor from LZO
*
* 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 Linux kernel use by:
* Nitin Gupta <nitingupta910@gmail.com>
* Richard Purdie <rpurdie@openedhand.com>
*/
#ifndef STATIC
#include <linux/module.h>
#include <linux/kernel.h>
#endif
#include <asm/unaligned.h>
#include <linux/lzo.h>
#include "lzodefs.h"
#define HAVE_IP(x) ((size_t)(ip_end - ip) >= (size_t)(x))
#define HAVE_OP(x) ((size_t)(op_end - op) >= (size_t)(x))
#define NEED_IP(x) if (!HAVE_IP(x)) goto input_overrun
#define NEED_OP(x) if (!HAVE_OP(x)) goto output_overrun
#define TEST_LB(m_pos) if ((m_pos) < out) goto lookbehind_overrun
int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len)
{
unsigned char *op;
const unsigned char *ip;
size_t t, next;
size_t state = 0;
const unsigned char *m_pos;
const unsigned char * const ip_end = in + in_len;
unsigned char * const op_end = out + *out_len;
op = out;
ip = in;
if (unlikely(in_len < 3))
goto input_overrun;
if (*ip > 17) {
t = *ip++ - 17;
if (t < 4) {
next = t;
goto match_next;
}
goto copy_literal_run;
}
for (;;) {
t = *ip++;
if (t < 16) {
if (likely(state == 0)) {
if (unlikely(t == 0)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1);
}
t += 15 + *ip++;
}
t += 3;
copy_literal_run:
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
if (likely(HAVE_IP(t + 15) && HAVE_OP(t + 15))) {
const unsigned char *ie = ip + t;
unsigned char *oe = op + t;
do {
COPY8(op, ip);
op += 8;
ip += 8;
COPY8(op, ip);
op += 8;
ip += 8;
} while (ip < ie);
ip = ie;
op = oe;
} else
#endif
{
NEED_OP(t);
NEED_IP(t + 3);
do {
*op++ = *ip++;
} while (--t > 0);
}
state = 4;
continue;
} else if (state != 4) {
next = t & 3;
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
TEST_LB(m_pos);
NEED_OP(2);
op[0] = m_pos[0];
op[1] = m_pos[1];
op += 2;
goto match_next;
} else {
next = t & 3;
m_pos = op - (1 + M2_MAX_OFFSET);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
t = 3;
}
} else if (t >= 64) {
next = t & 3;
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1 + (3 - 1);
} else if (t >= 32) {
t = (t & 31) + (3 - 1);
if (unlikely(t == 2)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1);
}
t += 31 + *ip++;
NEED_IP(2);
}
m_pos = op - 1;
next = get_unaligned_le16(ip);
ip += 2;
m_pos -= next >> 2;
next &= 3;
} else {
m_pos = op;
m_pos -= (t & 8) << 11;
t = (t & 7) + (3 - 1);
if (unlikely(t == 2)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1);
}
t += 7 + *ip++;
NEED_IP(2);
}
next = get_unaligned_le16(ip);
ip += 2;
m_pos -= next >> 2;
next &= 3;
if (m_pos == op)
goto eof_found;
m_pos -= 0x4000;
}
TEST_LB(m_pos);
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
if (op - m_pos >= 8) {
unsigned char *oe = op + t;
if (likely(HAVE_OP(t + 15))) {
do {
COPY8(op, m_pos);
op += 8;
m_pos += 8;
COPY8(op, m_pos);
op += 8;
m_pos += 8;
} while (op < oe);
op = oe;
if (HAVE_IP(6)) {
state = next;
COPY4(op, ip);
op += next;
ip += next;
continue;
}
} else {
NEED_OP(t);
do {
*op++ = *m_pos++;
} while (op < oe);
}
} else
#endif
{
unsigned char *oe = op + t;
NEED_OP(t);
op[0] = m_pos[0];
op[1] = m_pos[1];
op += 2;
m_pos += 2;
do {
*op++ = *m_pos++;
} while (op < oe);
}
match_next:
state = next;
t = next;
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
if (likely(HAVE_IP(6) && HAVE_OP(4))) {
COPY4(op, ip);
op += t;
ip += t;
} else
#endif
{
NEED_IP(t + 3);
NEED_OP(t);
while (t > 0) {
*op++ = *ip++;
t--;
}
}
}
eof_found:
*out_len = op - out;
return (t != 3 ? LZO_E_ERROR :
ip == ip_end ? LZO_E_OK :
ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN);
input_overrun:
*out_len = op - out;
return LZO_E_INPUT_OVERRUN;
output_overrun:
*out_len = op - out;
return LZO_E_OUTPUT_OVERRUN;
lookbehind_overrun:
*out_len = op - out;
return LZO_E_LOOKBEHIND_OVERRUN;
}
#ifndef STATIC
EXPORT_SYMBOL_GPL(lzo1x_decompress_safe);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("LZO1X Decompressor");
#endif
lib/lzo/lzodefs.h
View file @ b0af9cd9
/* /*
* lzodefs.h -- architecture, OS and compiler specific defines * lzodefs.h -- architecture, OS and compiler specific defines
* *
* 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: * The full LZO package can be found at:
* http://www.oberhumer.com/opensource/lzo/ * http://www.oberhumer.com/opensource/lzo/
* *
* Changed for kernel use by: * Changed for Linux kernel use by:
* Nitin Gupta <nitingupta910@gmail.com> * Nitin Gupta <nitingupta910@gmail.com>
* Richard Purdie <rpurdie@openedhand.com> * Richard Purdie <rpurdie@openedhand.com>
*/ */
#define LZO_VERSION 0x2020
#define LZO_VERSION_STRING "2.02" #define COPY4(dst, src) \
#define LZO_VERSION_DATE "Oct 17 2005" put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
#if defined(__x86_64__)
#define COPY8(dst, src) \
put_unaligned(get_unaligned((const u64 *)(src)), (u64 *)(dst))
#else
#define COPY8(dst, src) \
COPY4(dst, src); COPY4((dst) + 4, (src) + 4)
#endif
#if defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN)
#error "conflicting endian definitions"
#elif defined(__x86_64__)
#define LZO_USE_CTZ64 1
#define LZO_USE_CTZ32 1
#elif defined(__i386__) || defined(__powerpc__)
#define LZO_USE_CTZ32 1
#elif defined(__arm__) && (__LINUX_ARM_ARCH__ >= 5)
#define LZO_USE_CTZ32 1
#endif
#define M1_MAX_OFFSET 0x0400 #define M1_MAX_OFFSET 0x0400
#define M2_MAX_OFFSET 0x0800 #define M2_MAX_OFFSET 0x0800
...@@ -34,10 +52,8 @@ ...@@ -34,10 +52,8 @@
#define M3_MARKER 32 #define M3_MARKER 32
#define M4_MARKER 16 #define M4_MARKER 16
#define D_BITS 14 #define lzo_dict_t unsigned short
#define D_MASK ((1u << D_BITS) - 1) #define D_BITS 13
#define D_SIZE (1u << D_BITS)
#define D_MASK (D_SIZE - 1)
#define D_HIGH ((D_MASK >> 1) + 1) #define D_HIGH ((D_MASK >> 1) + 1)
#define DX2(p, s1, s2) (((((size_t)((p)[2]) << (s2)) ^ (p)[1]) \
<< (s1)) ^ (p)[0])
#define DX3(p, s1, s2, s3) ((DX2((p)+1, s2, s3) << (s1)) ^ (p)[0])
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7