From 5c105d9f3fd086aff195d3849dcf847d6b0bd927 Mon Sep 17 00:00:00 2001 From: blogic Date: Fri, 5 Oct 2012 10:12:53 +0000 Subject: branch Attitude Adjustment git-svn-id: svn://svn.openwrt.org/openwrt/branches/attitude_adjustment@33625 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- .../compcache/patches/000-provide_lzo_kmod.patch | 647 +++++++++++++++++++++ package/compcache/patches/001-lzo-speed.patch | 181 ++++++ .../patches/002-kernel-2.6.34-compat.patch | 10 + .../compcache/patches/003-kernel-3.x-compat.patch | 31 + 4 files changed, 869 insertions(+) create mode 100644 package/compcache/patches/000-provide_lzo_kmod.patch create mode 100644 package/compcache/patches/001-lzo-speed.patch create mode 100644 package/compcache/patches/002-kernel-2.6.34-compat.patch create mode 100644 package/compcache/patches/003-kernel-3.x-compat.patch (limited to 'package/compcache/patches') diff --git a/package/compcache/patches/000-provide_lzo_kmod.patch b/package/compcache/patches/000-provide_lzo_kmod.patch new file mode 100644 index 000000000..1dab08507 --- /dev/null +++ b/package/compcache/patches/000-provide_lzo_kmod.patch @@ -0,0 +1,647 @@ +--- a/Makefile ++++ b/Makefile +@@ -1,14 +1,17 @@ + KERNEL_BUILD_PATH ?= "/lib/modules/$(shell uname -r)/build" + + XVM = sub-projects/allocators/xvmalloc-kmod ++LZO = sub-projects/compression/lzo-kmod + EXTRA_CFLAGS := -DCONFIG_RAMZSWAP_STATS \ + -Wall + +-obj-m += ramzswap.o ++obj-m += ramzswap.o $(LZO)/lzo1x.o + ramzswap-objs := ramzswap_drv.o $(XVM)/xvmalloc.o ++ + + all: + make -C $(KERNEL_BUILD_PATH) M=$(PWD) modules ++ make -C $(KERNEL_BUILD_PATH) M=$(PWD)/$(LZO) modules + make -C sub-projects/rzscontrol + + doc: +@@ -16,5 +19,6 @@ doc: + + clean: + make -C $(KERNEL_BUILD_PATH) M=$(PWD) clean ++ make -C $(KERNEL_BUILD_PATH) M=$(PWD)/$(LZO) clean + make -C sub-projects/rzscontrol clean + @rm -rf *.ko +--- a/ramzswap_drv.c ++++ b/ramzswap_drv.c +@@ -23,13 +23,13 @@ + #include + #include + #include +-#include + #include + #include + #include + #include + #include + ++#include "lzo.h" + #include "compat.h" + #include "ramzswap_drv.h" + +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/lzo1x.c +@@ -0,0 +1,7 @@ ++#include ++ ++#include "lzo1x_compress.c" ++#include "lzo1x_decompress.c" ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("LZO1X Lib"); +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/lzo1x_compress.c +@@ -0,0 +1,227 @@ ++/* ++ * LZO1X Compressor from MiniLZO ++ * ++ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer ++ * ++ * The full LZO package can be found at: ++ * http://www.oberhumer.com/opensource/lzo/ ++ * ++ * Changed for kernel use by: ++ * Nitin Gupta ++ * Richard Purdie ++ */ ++ ++#include ++#include ++#include ++ ++#include "lzodefs.h" ++#include "lzo.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) ++{ ++ 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; ++ ++ ip += 4; ++ ++ 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; ++ } ++ ++literal: ++ dict[dindex] = ip; ++ ++ip; ++ if (unlikely(ip >= ip_end)) ++ break; ++ continue; ++ ++match: ++ dict[dindex] = ip; ++ if (ip != ii) { ++ size_t t = ip - ii; ++ ++ if (t <= 3) { ++ op[-2] |= t; ++ } else if (t <= 18) { ++ *op++ = (t - 3); ++ } else { ++ size_t tt = t - 18; ++ ++ *op++ = 0; ++ while (tt > 255) { ++ tt -= 255; ++ *op++ = 0; ++ } ++ *op++ = tt; ++ } ++ 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; ++ ++ if (m_off <= M2_MAX_OFFSET) { ++ m_off -= 1; ++ *op++ = (((m_len - 1) << 5) ++ | ((m_off & 7) << 2)); ++ *op++ = (m_off >> 3); ++ } else if (m_off <= M3_MAX_OFFSET) { ++ m_off -= 1; ++ *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; ++ *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)); ++ } else { ++ m_len -= M4_MAX_LEN; ++ *op++ = (M4_MARKER ++ | ((m_off & 0x4000) >> 11)); ++m3_m4_len: ++ while (m_len > 255) { ++ m_len -= 255; ++ *op++ = 0; ++ } ++ ++ *op++ = (m_len); ++ } ++ } ++m3_m4_offset: ++ *op++ = ((m_off & 63) << 2); ++ *op++ = (m_off >> 6); ++ } ++ ++ ii = ip; ++ if (unlikely(ip >= ip_end)) ++ break; ++ } ++ ++ *out_len = op - out; ++ return in_end - ii; ++} ++ ++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; ++ unsigned char *op = out; ++ size_t t; ++ ++ if (unlikely(in_len <= M2_MAX_LEN + 5)) { ++ t = in_len; ++ } else { ++ t = _lzo1x_1_do_compress(in, in_len, op, out_len, wrkmem); ++ op += *out_len; ++ } ++ ++ if (t > 0) { ++ ii = in + in_len - t; ++ ++ if (op == out && t <= 238) { ++ *op++ = (17 + t); ++ } else if (t <= 3) { ++ op[-2] |= t; ++ } else if (t <= 18) { ++ *op++ = (t - 3); ++ } else { ++ size_t tt = t - 18; ++ ++ *op++ = 0; ++ while (tt > 255) { ++ tt -= 255; ++ *op++ = 0; ++ } ++ ++ *op++ = tt; ++ } ++ do { ++ *op++ = *ii++; ++ } while (--t > 0); ++ } ++ ++ *op++ = M4_MARKER | 1; ++ *op++ = 0; ++ *op++ = 0; ++ ++ *out_len = op - out; ++ return LZO_E_OK; ++} ++EXPORT_SYMBOL_GPL(lzo1x_1_compress); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("LZO1X-1 Compressor"); ++ +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/lzo1x_decompress.c +@@ -0,0 +1,255 @@ ++/* ++ * LZO1X Decompressor from MiniLZO ++ * ++ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer ++ * ++ * The full LZO package can be found at: ++ * http://www.oberhumer.com/opensource/lzo/ ++ * ++ * Changed for kernel use by: ++ * Nitin Gupta ++ * Richard Purdie ++ */ ++ ++#include ++#include ++#include ++#include ++ ++#include "lzodefs.h" ++#include "lzo.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 -= le16_to_cpu(get_unaligned( ++ (const unsigned short *)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 -= le16_to_cpu(get_unaligned( ++ (const unsigned short *)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; ++} ++ ++EXPORT_SYMBOL_GPL(lzo1x_decompress_safe); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("LZO1X Decompressor"); ++ +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/lzodefs.h +@@ -0,0 +1,43 @@ ++/* ++ * lzodefs.h -- architecture, OS and compiler specific defines ++ * ++ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer ++ * ++ * The full LZO package can be found at: ++ * http://www.oberhumer.com/opensource/lzo/ ++ * ++ * Changed for kernel use by: ++ * Nitin Gupta ++ * Richard Purdie ++ */ ++ ++#define LZO_VERSION 0x2020 ++#define LZO_VERSION_STRING "2.02" ++#define LZO_VERSION_DATE "Oct 17 2005" ++ ++#define M1_MAX_OFFSET 0x0400 ++#define M2_MAX_OFFSET 0x0800 ++#define M3_MAX_OFFSET 0x4000 ++#define M4_MAX_OFFSET 0xbfff ++ ++#define M1_MIN_LEN 2 ++#define M1_MAX_LEN 2 ++#define M2_MIN_LEN 3 ++#define M2_MAX_LEN 8 ++#define M3_MIN_LEN 3 ++#define M3_MAX_LEN 33 ++#define M4_MIN_LEN 3 ++#define M4_MAX_LEN 9 ++ ++#define M1_MARKER 0 ++#define M2_MARKER 64 ++#define M3_MARKER 32 ++#define M4_MARKER 16 ++ ++#define D_BITS 14 ++#define D_MASK ((1u << D_BITS) - 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]) +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/lzo.h +@@ -0,0 +1,44 @@ ++#ifndef __LZO_H__ ++#define __LZO_H__ ++/* ++ * LZO Public Kernel Interface ++ * A mini subset of the LZO real-time data compression library ++ * ++ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer ++ * ++ * The full LZO package can be found at: ++ * http://www.oberhumer.com/opensource/lzo/ ++ * ++ * Changed for kernel use by: ++ * Nitin Gupta ++ * Richard Purdie ++ */ ++ ++#define LZO1X_MEM_COMPRESS (16384 * sizeof(unsigned char *)) ++#define LZO1X_1_MEM_COMPRESS LZO1X_MEM_COMPRESS ++ ++#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3) ++ ++/* This requires 'workmem' 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); ++ ++/* safe decompression with overrun testing */ ++int lzo1x_decompress_safe(const unsigned char *src, size_t src_len, ++ unsigned char *dst, size_t *dst_len); ++ ++/* ++ * Return values (< 0 = Error) ++ */ ++#define LZO_E_OK 0 ++#define LZO_E_ERROR (-1) ++#define LZO_E_OUT_OF_MEMORY (-2) ++#define LZO_E_NOT_COMPRESSIBLE (-3) ++#define LZO_E_INPUT_OVERRUN (-4) ++#define LZO_E_OUTPUT_OVERRUN (-5) ++#define LZO_E_LOOKBEHIND_OVERRUN (-6) ++#define LZO_E_EOF_NOT_FOUND (-7) ++#define LZO_E_INPUT_NOT_CONSUMED (-8) ++#define LZO_E_NOT_YET_IMPLEMENTED (-9) ++ ++#endif +--- /dev/null ++++ b/sub-projects/compression/lzo-kmod/Makefile +@@ -0,0 +1,8 @@ ++obj-m += lzo1x_compress.o lzo1x_decompress.o ++ ++all: ++ make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules ++ ++clean: ++ make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean ++ diff --git a/package/compcache/patches/001-lzo-speed.patch b/package/compcache/patches/001-lzo-speed.patch new file mode 100644 index 000000000..130f79da6 --- /dev/null +++ b/package/compcache/patches/001-lzo-speed.patch @@ -0,0 +1,181 @@ +--- a/sub-projects/compression/lzo-kmod/lzo1x_compress.c ++++ b/sub-projects/compression/lzo-kmod/lzo1x_compress.c +@@ -62,8 +62,12 @@ _lzo1x_1_do_compress(const unsigned char + goto literal; + + try_match: ++#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS + if (get_unaligned((const unsigned short *)m_pos) + == get_unaligned((const unsigned short *)ip)) { ++#else ++ if (m_pos[0] == ip[0] && m_pos[1] == ip[1]) { ++#endif + if (likely(m_pos[2] == ip[2])) + goto match; + } +@@ -94,9 +98,14 @@ match: + } + *op++ = tt; + } +- do { +- *op++ = *ii++; +- } while (--t > 0); ++ if (t >= 2 * 4) { ++ memcpy(op, ii, t); ++ op += t; ++ ii += t; ++ } else ++ do { ++ *op++ = *ii++; ++ } while (--t > 0); + } + + ip += 3; +@@ -208,9 +217,14 @@ int lzo1x_1_compress(const unsigned char + + *op++ = tt; + } +- do { +- *op++ = *ii++; +- } while (--t > 0); ++ if (t >= 2 * 4) { ++ memcpy(op, ii, t); ++ op += t; ++ ii += t; ++ } else ++ do { ++ *op++ = *ii++; ++ } while (--t > 0); + } + + *op++ = M4_MARKER | 1; +@@ -224,4 +238,3 @@ EXPORT_SYMBOL_GPL(lzo1x_1_compress); + + MODULE_LICENSE("GPL"); + MODULE_DESCRIPTION("LZO1X-1 Compressor"); +- +--- a/sub-projects/compression/lzo-kmod/lzo1x_decompress.c ++++ b/sub-projects/compression/lzo-kmod/lzo1x_decompress.c +@@ -45,10 +45,7 @@ int lzo1x_decompress_safe(const unsigned + goto output_overrun; + if (HAVE_IP(t + 1, ip_end, ip)) + goto input_overrun; +- do { +- *op++ = *ip++; +- } while (--t > 0); +- goto first_literal_run; ++ goto prep_first_literal_run; + } + + while ((ip < ip_end)) { +@@ -71,30 +68,27 @@ int lzo1x_decompress_safe(const unsigned + 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 { ++ t += (4 - 1); ++ if (t >= 2 * 4) { ++ memcpy(op, ip, t); ++ op += t; ++ ip += t; ++ } else { ++ do { ++ COPY4(op, ip); ++ op += 4; ++ ip += 4; ++ t -= 4; ++ } while (t >= 4); ++ if (t > 0) { ++prep_first_literal_run: + do { + *op++ = *ip++; + } while (--t > 0); + } + } + +-first_literal_run: ++//first_literal_run: + t = *ip++; + if (t >= 16) + goto match; +@@ -139,8 +133,7 @@ match: + t += 31 + *ip++; + } + m_pos = op - 1; +- m_pos -= le16_to_cpu(get_unaligned( +- (const unsigned short *)ip)) >> 2; ++ m_pos -= get_unaligned_le16(ip) >> 2; + ip += 2; + } else if (t >= 16) { + m_pos = op; +@@ -158,8 +151,7 @@ match: + } + t += 7 + *ip++; + } +- m_pos -= le16_to_cpu(get_unaligned( +- (const unsigned short *)ip)) >> 2; ++ m_pos -= get_unaligned_le16(ip) >> 2; + ip += 2; + if (m_pos == op) + goto eof_found; +@@ -184,21 +176,33 @@ match: + 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 { ++ if (t >= 2 * 4 - (3 - 1)) { ++ /* ++ * Assume memcpy don't copy ++ * more than 32 bytes at once ++ */ ++ if ((op - m_pos) >= 32) { ++ t += (3 - 1); ++ memcpy(op, m_pos, t); ++ op += t; ++ m_pos += t; ++ } else if ((op - m_pos) >= 4) { + COPY4(op, m_pos); + op += 4; + m_pos += 4; +- t -= 4; +- } while (t >= 4); +- if (t > 0) ++ t -= 4 - (3 - 1); + do { +- *op++ = *m_pos++; +- } while (--t > 0); ++ 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 ++ goto copy_match; + } else { + copy_match: + *op++ = *m_pos++; diff --git a/package/compcache/patches/002-kernel-2.6.34-compat.patch b/package/compcache/patches/002-kernel-2.6.34-compat.patch new file mode 100644 index 000000000..5cd8129f8 --- /dev/null +++ b/package/compcache/patches/002-kernel-2.6.34-compat.patch @@ -0,0 +1,10 @@ +--- a/ramzswap_drv.c ++++ b/ramzswap_drv.c +@@ -23,6 +23,7 @@ + #include + #include + #include ++#include + #include + #include + #include diff --git a/package/compcache/patches/003-kernel-3.x-compat.patch b/package/compcache/patches/003-kernel-3.x-compat.patch new file mode 100644 index 000000000..70996ebe7 --- /dev/null +++ b/package/compcache/patches/003-kernel-3.x-compat.patch @@ -0,0 +1,31 @@ +Index: compcache-0.6.2/ramzswap_drv.c +=================================================================== +--- compcache-0.6.2.orig/ramzswap_drv.c 2012-07-25 01:02:39.000000000 +0200 ++++ compcache-0.6.2/ramzswap_drv.c 2012-07-25 01:04:29.270750850 +0200 +@@ -525,7 +525,7 @@ + + if (S_ISBLK(inode->i_mode)) { + bdev = I_BDEV(inode); +- ret = bd_claim(bdev, setup_backing_swap); ++ ret = blkdev_get(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL, setup_backing_swap); + if (ret < 0) { + bdev = NULL; + goto bad_param; +@@ -557,7 +557,7 @@ + + bad_param: + if (bdev) +- bd_release(bdev); ++ blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL); + filp_close(swap_file, NULL); + + out: +@@ -1097,7 +1097,7 @@ + /* Close backing swap device, if present */ + if (rzs->backing_swap) { + if (is_backing_blkdev) +- bd_release(rzs->backing_swap); ++ blkdev_put(rzs->backing_swap, FMODE_READ | FMODE_WRITE | FMODE_EXCL); + filp_close(rzs->swap_file, NULL); + rzs->backing_swap = NULL; + memset(rzs->backing_swap_name, 0, MAX_SWAP_NAME_LEN); -- cgit v1.2.3