Skip to content

K
Kernel

openeuler / Kernel
1 年多 前同步成功

通知 8
Star 0
Fork 0
K
Kernel
提交 8b975bd3 编写于 作者: M Markus F.X.J. Oberhumer
浏览文件
操作

lib/lzo: Update LZO compression to current upstream version 

This commit updates the kernel LZO code to the current upsteam version
which features a significant speed improvement - benchmarking the Calgary
and Silesia test corpora typically shows a doubled performance in
both compression and decompression on modern i386/x86_64/powerpc machines.
Signed-off-by: NMarkus F.X.J. Oberhumer <markus@oberhumer.com>
上级 b6bec26c
隐藏空白更改
内联 并排
Showing with 395 addition and 343 deletion
include/linux/lzo.h
浏览文件 @ 8b975bd3
...@@ -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/lzo/lzo1x_compress.c
浏览文件 @ 8b975bd3
/* /*
* 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_safe.c
浏览文件 @ 8b975bd3
/* /*
* LZO1X Decompressor from MiniLZO * LZO1X Decompressor 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>
*/ */
...@@ -15,225 +15,207 @@ ...@@ -15,225 +15,207 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#endif #endif
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <linux/lzo.h> #include <linux/lzo.h>
#include "lzodefs.h" #include "lzodefs.h"
#define HAVE_IP(x, ip_end, ip) ((size_t)(ip_end - ip) < (x)) #define HAVE_IP(x) ((size_t)(ip_end - ip) >= (size_t)(x))
#define HAVE_OP(x, op_end, op) ((size_t)(op_end - op) < (x)) #define HAVE_OP(x) ((size_t)(op_end - op) >= (size_t)(x))
#define HAVE_LB(m_pos, out, op) (m_pos < out || m_pos >= op) #define NEED_IP(x) if (!HAVE_IP(x)) goto input_overrun
#define NEED_OP(x) if (!HAVE_OP(x)) goto output_overrun
#define COPY4(dst, src) \ #define TEST_LB(m_pos) if ((m_pos) < out) goto lookbehind_overrun
put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
int lzo1x_decompress_safe(const unsigned char *in, size_t in_len, int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_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; const unsigned char * const ip_end = in + in_len;
unsigned char * const op_end = out + *out_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; op = out;
ip = in;
if (unlikely(in_len < 3))
goto input_overrun;
if (*ip > 17) { if (*ip > 17) {
t = *ip++ - 17; t = *ip++ - 17;
if (t < 4) if (t < 4) {
next = t;
goto match_next; 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);
}
} }
goto copy_literal_run;
}
first_literal_run: for (;;) {
t = *ip++; t = *ip++;
if (t >= 16) if (t < 16) {
goto match; if (likely(state == 0)) {
m_pos = op - (1 + M2_MAX_OFFSET); if (unlikely(t == 0)) {
m_pos -= t >> 2; while (unlikely(*ip == 0)) {
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; t += 255;
ip++; ip++;
if (HAVE_IP(1, ip_end, ip)) NEED_IP(1);
goto input_overrun;
} }
t += 31 + *ip++; t += 15 + *ip++;
} }
m_pos = op - 1; t += 3;
m_pos -= get_unaligned_le16(ip) >> 2; copy_literal_run:
ip += 2; #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
} else if (t >= 16) { if (likely(HAVE_IP(t + 15) && HAVE_OP(t + 15))) {
m_pos = op; const unsigned char *ie = ip + t;
m_pos -= (t & 8) << 11; unsigned char *oe = op + t;
do {
t &= 7; COPY8(op, ip);
if (t == 0) { op += 8;
if (HAVE_IP(1, ip_end, ip)) ip += 8;
goto input_overrun; COPY8(op, ip);
while (*ip == 0) { op += 8;
t += 255; ip += 8;
ip++; } while (ip < ie);
if (HAVE_IP(1, ip_end, ip)) ip = ie;
goto input_overrun; op = oe;
} } else
t += 7 + *ip++; #endif
{
NEED_OP(t);
NEED_IP(t + 3);
do {
*op++ = *ip++;
} while (--t > 0);
} }
m_pos -= get_unaligned_le16(ip) >> 2; state = 4;
ip += 2; continue;
if (m_pos == op) } else if (state != 4) {
goto eof_found; next = t & 3;
m_pos -= 0x4000;
} else {
m_pos = op - 1; m_pos = op - 1;
m_pos -= t >> 2; m_pos -= t >> 2;
m_pos -= *ip++ << 2; m_pos -= *ip++ << 2;
TEST_LB(m_pos);
if (HAVE_LB(m_pos, out, op)) NEED_OP(2);
goto lookbehind_overrun; op[0] = m_pos[0];
if (HAVE_OP(2, op_end, op)) op[1] = m_pos[1];
goto output_overrun; op += 2;
goto match_next;
*op++ = *m_pos++; } else {
*op++ = *m_pos; next = t & 3;
goto match_done; m_pos = op - (1 + M2_MAX_OFFSET);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
t = 3;
} }
} else if (t >= 64) {
if (HAVE_LB(m_pos, out, op)) next = t & 3;
goto lookbehind_overrun; m_pos = op - 1;
if (HAVE_OP(t + 3 - 1, op_end, op)) m_pos -= (t >> 2) & 7;
goto output_overrun; m_pos -= *ip++ << 3;
t = (t >> 5) - 1 + (3 - 1);
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) { } else if (t >= 32) {
COPY4(op, m_pos); t = (t & 31) + (3 - 1);
op += 4; if (unlikely(t == 2)) {
m_pos += 4; while (unlikely(*ip == 0)) {
t -= 4 - (3 - 1); 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 { do {
COPY4(op, m_pos); COPY8(op, m_pos);
op += 4; op += 8;
m_pos += 4; m_pos += 8;
t -= 4; COPY8(op, m_pos);
} while (t >= 4); op += 8;
if (t > 0) m_pos += 8;
do { } while (op < oe);
*op++ = *m_pos++; op = oe;
} while (--t > 0); if (HAVE_IP(6)) {
state = next;
COPY4(op, ip);
op += next;
ip += next;
continue;
}
} else { } else {
copy_match: NEED_OP(t);
*op++ = *m_pos++;
*op++ = *m_pos++;
do { do {
*op++ = *m_pos++; *op++ = *m_pos++;
} while (--t > 0); } while (op < oe);
} }
match_done: } else
t = ip[-2] & 3; #endif
if (t == 0) {
break; 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: match_next:
if (HAVE_OP(t, op_end, op)) state = next;
goto output_overrun; t = next;
if (HAVE_IP(t + 1, ip_end, ip)) #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
goto input_overrun; if (likely(HAVE_IP(6) && HAVE_OP(4))) {
COPY4(op, ip);
*op++ = *ip++; op += t;
if (t > 1) { ip += t;
} else
#endif
{
NEED_IP(t + 3);
NEED_OP(t);
while (t > 0) {
*op++ = *ip++; *op++ = *ip++;
if (t > 2) t--;
*op++ = *ip++;
} }
}
t = *ip++;
} while (ip < ip_end);
} }
*out_len = op - out;
return LZO_E_EOF_NOT_FOUND;
eof_found: eof_found:
*out_len = op - out; *out_len = op - out;
return (ip == ip_end ? LZO_E_OK : return (t != 3 ? LZO_E_ERROR :
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ip == ip_end ? LZO_E_OK :
ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN);
input_overrun: input_overrun:
*out_len = op - out; *out_len = op - out;
return LZO_E_INPUT_OVERRUN; return LZO_E_INPUT_OVERRUN;
......
lib/lzo/lzodefs.h
浏览文件 @ 8b975bd3
/* /*
* 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% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或