--- /dev/null
+diff -Nurp kernel-2.6.28-20094102.3+0m5/crypto/lzo.c kernel-2.6.28-20094102.6+0m5/crypto/lzo.c
+--- kernel-2.6.28-20094102.3+0m5/crypto/lzo.c 2008-12-25 00:26:37.000000000 +0100
++++ kernel-2.6.28-20094102.6+0m5/crypto/lzo.c 2011-09-04 11:36:23.000000000 +0200
+@@ -37,6 +37,17 @@ static int lzo_init(struct crypto_tfm *t
+ return 0;
+ }
+
++static int lzo999_init(struct crypto_tfm *tfm)
++{
++ struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
++
++ ctx->lzo_comp_mem = vmalloc(LZO1X_999_MEM_COMPRESS);
++ if (!ctx->lzo_comp_mem)
++ return -ENOMEM;
++
++ return 0;
++}
++
+ static void lzo_exit(struct crypto_tfm *tfm)
+ {
+ struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
+@@ -60,6 +71,24 @@ static int lzo_compress(struct crypto_tf
+ return 0;
+ }
+
++static int lzo999_compress(struct crypto_tfm *tfm, const u8 *src,
++ unsigned int slen, u8 *dst, unsigned int *dlen)
++{
++ struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
++ size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
++ int err;
++
++ err = lzo1x_999_compress_level(src, slen, dst, &tmp_len,
++ ctx->lzo_comp_mem, NULL, 0 ,
++ (lzo_progress_callback_t) 0, 7);
++
++ if (err != LZO_E_OK)
++ return -EINVAL;
++
++ *dlen = tmp_len;
++ return 0;
++}
++
+ static int lzo_decompress(struct crypto_tfm *tfm, const u8 *src,
+ unsigned int slen, u8 *dst, unsigned int *dlen)
+ {
+@@ -89,13 +118,37 @@ static struct crypto_alg alg = {
+ .coa_decompress = lzo_decompress } }
+ };
+
++static struct crypto_alg alg999 = {
++ .cra_name = "lzo999",
++ .cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
++ .cra_ctxsize = sizeof(struct lzo_ctx),
++ .cra_module = THIS_MODULE,
++ .cra_list = LIST_HEAD_INIT(alg999.cra_list),
++ .cra_init = lzo999_init,
++ .cra_exit = lzo_exit,
++ .cra_u = { .compress = {
++ .coa_compress = lzo999_compress,
++ .coa_decompress = lzo_decompress } }
++};
++
+ static int __init lzo_mod_init(void)
+ {
+- return crypto_register_alg(&alg);
++ int ret;
++
++ ret = crypto_register_alg(&alg);
++ if (ret < 0)
++ return ret;
++
++ ret = crypto_register_alg(&alg999);
++ if (ret < 0)
++ crypto_unregister_alg(&alg);
++
++ return ret;
+ }
+
+ static void __exit lzo_mod_fini(void)
+ {
++ crypto_unregister_alg(&alg999);
+ crypto_unregister_alg(&alg);
+ }
+
+diff -Nurp kernel-2.6.28-20094102.3+0m5/fs/ubifs/compress.c kernel-2.6.28-20094102.6+0m5/fs/ubifs/compress.c
+--- kernel-2.6.28-20094102.3+0m5/fs/ubifs/compress.c 2011-09-04 11:34:12.000000000 +0200
++++ kernel-2.6.28-20094102.6+0m5/fs/ubifs/compress.c 2011-09-04 11:36:23.000000000 +0200
+@@ -46,11 +46,24 @@ static struct ubifs_compressor lzo_compr
+ .name = "lzo",
+ .capi_name = "lzo",
+ };
++
++static DEFINE_MUTEX(lzo999_mutex);
++
++static struct ubifs_compressor lzo999_compr = {
++ .compr_type = UBIFS_COMPR_LZO999,
++ .comp_mutex = &lzo999_mutex,
++ .name = "lzo999",
++ .capi_name = "lzo999",
++};
+ #else
+ static struct ubifs_compressor lzo_compr = {
+ .compr_type = UBIFS_COMPR_LZO,
+ .name = "lzo",
+ };
++static struct ubifs_compressor lzo_compr = {
++ .compr_type = UBIFS_COMPR_LZO999,
++ .name = "lzo999",
++};
+ #endif
+
+ #ifdef CONFIG_UBIFS_FS_ZLIB
+@@ -125,6 +138,9 @@ void ubifs_compress(const void *in_buf,
+ if (in_len - *out_len < UBIFS_MIN_COMPRESS_DIFF)
+ goto no_compr;
+
++ if (*compr_type == UBIFS_COMPR_LZO999)
++ *compr_type = UBIFS_COMPR_LZO;
++
+ return;
+
+ no_compr:
+@@ -229,13 +245,19 @@ int __init ubifs_compressors_init(void)
+ if (err)
+ return err;
+
+- err = compr_init(&zlib_compr);
++ err = compr_init(&lzo999_compr);
+ if (err)
+ goto out_lzo;
+
++ err = compr_init(&zlib_compr);
++ if (err)
++ goto out_lzo999;
++
+ ubifs_compressors[UBIFS_COMPR_NONE] = &none_compr;
+ return 0;
+
++out_lzo999:
++ compr_exit(&lzo999_compr);
+ out_lzo:
+ compr_exit(&lzo_compr);
+ return err;
+@@ -246,6 +268,7 @@ out_lzo:
+ */
+ void ubifs_compressors_exit(void)
+ {
++ compr_exit(&lzo999_compr);
+ compr_exit(&lzo_compr);
+ compr_exit(&zlib_compr);
+ }
+diff -Nurp kernel-2.6.28-20094102.3+0m5/fs/ubifs/journal.c kernel-2.6.28-20094102.6+0m5/fs/ubifs/journal.c
+--- kernel-2.6.28-20094102.3+0m5/fs/ubifs/journal.c 2011-09-04 11:34:12.000000000 +0200
++++ kernel-2.6.28-20094102.6+0m5/fs/ubifs/journal.c 2011-09-04 11:36:23.000000000 +0200
+@@ -469,7 +469,10 @@ static void pack_inode(struct ubifs_info
+ ino->flags = cpu_to_le32(ui->flags);
+ ino->size = cpu_to_le64(ui->ui_size);
+ ino->nlink = cpu_to_le32(inode->i_nlink);
+- ino->compr_type = cpu_to_le16(ui->compr_type);
++ if (ui->compr_type == UBIFS_COMPR_LZO999)
++ ino->compr_type = cpu_to_le16(UBIFS_COMPR_LZO);
++ else
++ ino->compr_type = cpu_to_le16(ui->compr_type);
+ ino->data_len = cpu_to_le32(ui->data_len);
+ ino->xattr_cnt = cpu_to_le32(ui->xattr_cnt);
+ ino->xattr_size = cpu_to_le32(ui->xattr_size);
+diff -Nurp kernel-2.6.28-20094102.3+0m5/fs/ubifs/sb.c kernel-2.6.28-20094102.6+0m5/fs/ubifs/sb.c
+--- kernel-2.6.28-20094102.3+0m5/fs/ubifs/sb.c 2011-09-04 11:34:12.000000000 +0200
++++ kernel-2.6.28-20094102.6+0m5/fs/ubifs/sb.c 2011-09-04 11:36:23.000000000 +0200
+@@ -181,9 +181,12 @@ static int create_default_filesystem(str
+ sup->lsave_cnt = cpu_to_le32(c->lsave_cnt);
+ sup->fmt_version = cpu_to_le32(UBIFS_FORMAT_VERSION);
+ sup->time_gran = cpu_to_le32(DEFAULT_TIME_GRAN);
+- if (c->mount_opts.override_compr)
+- sup->default_compr = cpu_to_le16(c->mount_opts.compr_type);
+- else
++ if (c->mount_opts.override_compr) {
++ if (c->mount_opts.compr_type == UBIFS_COMPR_LZO999)
++ sup->default_compr = cpu_to_le16(UBIFS_COMPR_LZO);
++ else
++ sup->default_compr = cpu_to_le16(c->mount_opts.compr_type);
++ } else
+ sup->default_compr = cpu_to_le16(UBIFS_COMPR_LZO);
+
+ generate_random_uuid(sup->uuid);
+diff -Nurp kernel-2.6.28-20094102.3+0m5/fs/ubifs/super.c kernel-2.6.28-20094102.6+0m5/fs/ubifs/super.c
+--- kernel-2.6.28-20094102.3+0m5/fs/ubifs/super.c 2011-09-04 11:34:12.000000000 +0200
++++ kernel-2.6.28-20094102.6+0m5/fs/ubifs/super.c 2011-09-04 11:36:23.000000000 +0200
+@@ -1001,6 +1001,8 @@ static int ubifs_parse_options(struct ub
+ c->mount_opts.compr_type = UBIFS_COMPR_LZO;
+ else if (!strcmp(name, "zlib"))
+ c->mount_opts.compr_type = UBIFS_COMPR_ZLIB;
++ else if (!strcmp(name, "lzo999"))
++ c->mount_opts.compr_type = UBIFS_COMPR_LZO999;
+ else {
+ ubifs_err("unknown compressor \"%s\"", name);
+ kfree(name);
+diff -Nurp kernel-2.6.28-20094102.3+0m5/fs/ubifs/ubifs-media.h kernel-2.6.28-20094102.6+0m5/fs/ubifs/ubifs-media.h
+--- kernel-2.6.28-20094102.3+0m5/fs/ubifs/ubifs-media.h 2011-09-04 11:34:12.000000000 +0200
++++ kernel-2.6.28-20094102.6+0m5/fs/ubifs/ubifs-media.h 2011-09-04 11:36:23.000000000 +0200
+@@ -303,12 +303,14 @@ enum {
+ * UBIFS_COMPR_NONE: no compression
+ * UBIFS_COMPR_LZO: LZO compression
+ * UBIFS_COMPR_ZLIB: ZLIB compression
++ * UBIFS_COMPR_LZO999: LZO999 compression
+ * UBIFS_COMPR_TYPES_CNT: count of supported compression types
+ */
+ enum {
+ UBIFS_COMPR_NONE,
+ UBIFS_COMPR_LZO,
+ UBIFS_COMPR_ZLIB,
++ UBIFS_COMPR_LZO999,
+ UBIFS_COMPR_TYPES_CNT,
+ };
+
+diff -Nurp kernel-2.6.28-20094102.3+0m5/include/linux/lzo.h kernel-2.6.28-20094102.6+0m5/include/linux/lzo.h
+--- kernel-2.6.28-20094102.3+0m5/include/linux/lzo.h 2008-12-25 00:26:37.000000000 +0100
++++ kernel-2.6.28-20094102.6+0m5/include/linux/lzo.h 2011-09-04 11:36:23.000000000 +0200
+@@ -17,6 +17,8 @@
+ #define LZO1X_MEM_COMPRESS (16384 * sizeof(unsigned char *))
+ #define LZO1X_1_MEM_COMPRESS LZO1X_MEM_COMPRESS
+
++#define LZO1X_999_MEM_COMPRESS ((unsigned) (14 * 16384L * sizeof(short)))
++
+ #define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)
+
+ /* This requires 'workmem' of size LZO1X_1_MEM_COMPRESS */
+@@ -27,6 +29,27 @@ int lzo1x_1_compress(const unsigned char
+ int lzo1x_decompress_safe(const unsigned char *src, size_t src_len,
+ unsigned char *dst, size_t *dst_len);
+
++int
++lzo1x_999_compress ( const unsigned char *src, unsigned src_len,
++ unsigned char *dst, unsigned * dst_len,
++ void * wrkmem );
++
++int
++lzo1x_999_compress_dict ( const unsigned char *in , unsigned in_len,
++ unsigned char *out, unsigned * out_len,
++ void * wrkmem,
++ const unsigned char *dict, unsigned dict_len );
++
++typedef void ( *lzo_progress_callback_t) (unsigned, unsigned);
++
++int
++lzo1x_999_compress_level ( const unsigned char *in , unsigned in_len,
++ unsigned char *out, unsigned * out_len,
++ void * wrkmem,
++ const unsigned char *dict, unsigned dict_len,
++ lzo_progress_callback_t cb,
++ int compression_level );
++
+ /*
+ * Return values (< 0 = Error)
+ */
+diff -Nurp kernel-2.6.28-20094102.3+0m5/lib/lzo/lzo1x_9x.c kernel-2.6.28-20094102.6+0m5/lib/lzo/lzo1x_9x.c
+--- kernel-2.6.28-20094102.3+0m5/lib/lzo/lzo1x_9x.c 1970-01-01 01:00:00.000000000 +0100
++++ kernel-2.6.28-20094102.6+0m5/lib/lzo/lzo1x_9x.c 2011-09-04 11:36:23.000000000 +0200
+@@ -0,0 +1,1272 @@
++/* lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm
++
++ This file is part of the LZO real-time data compression library.
++
++ Copyright (C) 1996-2002 Markus Franz Xaver Johannes Oberhumer
++ All Rights Reserved.
++
++ The LZO library is free software; you can redistribute it and/or
++ modify it under the terms of version 2 of the GNU General Public
++ License as published by the Free Software Foundation.
++
++ The LZO library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with the LZO library; see the file COPYING.
++ If not, write to the Free Software Foundation, Inc.,
++ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++ Markus F.X.J. Oberhumer
++ <markus@oberhumer.com>
++ */
++
++#include <linux/module.h>
++#include <linux/string.h>
++
++typedef unsigned int lzo_uint32;
++typedef int lzo_int32;
++typedef unsigned int lzo_uint;
++typedef int lzo_int;
++typedef int lzo_bool;
++
++typedef void ( *lzo_progress_callback_t) (unsigned, unsigned);
++
++typedef struct
++{
++ int init;
++
++ lzo_uint look;
++
++ lzo_uint m_len;
++ lzo_uint m_off;
++
++ lzo_uint last_m_len;
++ lzo_uint last_m_off;
++
++ const unsigned char *bp;
++ const unsigned char *ip;
++ const unsigned char *in;
++ const unsigned char *in_end;
++ unsigned char *out;
++
++ lzo_progress_callback_t cb;
++
++ lzo_uint textsize;
++ lzo_uint codesize;
++ lzo_uint printcount;
++
++
++ unsigned long lit_bytes;
++ unsigned long match_bytes;
++ unsigned long rep_bytes;
++ unsigned long lazy;
++
++ lzo_uint r1_lit;
++ lzo_uint r1_m_len;
++
++ unsigned long m1a_m, m1b_m, m2_m, m3_m, m4_m;
++ unsigned long lit1_r, lit2_r, lit3_r;
++}
++lzo1x_999_t;
++
++typedef unsigned short swd_uint;
++
++typedef struct
++{
++ lzo_uint n;
++ lzo_uint f;
++ lzo_uint threshold;
++
++ lzo_uint max_chain;
++ lzo_uint nice_length;
++ lzo_bool use_best_off;
++ lzo_uint lazy_insert;
++
++ lzo_uint m_len;
++ lzo_uint m_off;
++ lzo_uint look;
++ int b_char;
++
++ lzo_uint best_off[ (((8) >= (33) ? ((8) >= (9) ? (8) : (9)) : ((33) >= (9) ? (33) : (9))) + 1) ];
++
++ lzo1x_999_t *c;
++ lzo_uint m_pos;
++
++ lzo_uint best_pos[ (((8) >= (33) ? ((8) >= (9) ? (8) : (9)) : ((33) >= (9) ? (33) : (9))) + 1) ];
++
++ const unsigned char *dict;
++ const unsigned char *dict_end;
++ lzo_uint dict_len;
++
++ lzo_uint ip;
++ lzo_uint bp;
++ lzo_uint rp;
++ lzo_uint b_size;
++
++ unsigned char *b_wrap;
++
++ lzo_uint node_count;
++ lzo_uint first_rp;
++
++ unsigned char b [ 0xbfff + 2048 + 2048 ];
++ swd_uint head3 [ 16384 ];
++ swd_uint succ3 [ 0xbfff + 2048 ];
++ swd_uint best3 [ 0xbfff + 2048 ];
++ swd_uint llen3 [ 16384 ];
++
++ swd_uint head2 [ 65536L ];
++}
++lzo1x_999_swd_t;
++
++static
++void swd_initdict(lzo1x_999_swd_t *s, const unsigned char *dict, lzo_uint dict_len)
++{
++ s->dict = s->dict_end = ((void *)0);
++ s->dict_len = 0;
++
++ if (!dict || dict_len <= 0)
++ return;
++ if (dict_len > s->n)
++ {
++ dict += dict_len - s->n;
++ dict_len = s->n;
++ }
++
++ s->dict = dict;
++ s->dict_len = dict_len;
++ s->dict_end = dict + dict_len;
++ memcpy(s->b,dict,dict_len);
++ s->ip = dict_len;
++}
++
++
++static
++void swd_insertdict(lzo1x_999_swd_t *s, lzo_uint node, lzo_uint len)
++{
++ lzo_uint key;
++
++ s->node_count = s->n - len;
++ s->first_rp = node;
++
++ while (len-- > 0)
++ {
++ key = (((0x9f5f*(((((lzo_uint32)s->b[node]<<5)^s->b[node+1])<<5)^s->b[node+2]))>>5) & (16384 -1));
++ s->succ3[node] = s->head3[key];
++ s->head3[key] = ((swd_uint)(node));
++ s->best3[node] = ((swd_uint)(s->f + 1));
++ s->llen3[key]++;
++ ((void) (0));
++
++
++ key = (* (unsigned short *) &(s->b[node]));
++ s->head2[key] = ((swd_uint)(node));
++
++
++ node++;
++ }
++}
++
++
++
++
++
++
++static
++int swd_init(lzo1x_999_swd_t *s, const unsigned char *dict, lzo_uint dict_len)
++{
++ lzo_uint i = 0;
++ int c = 0;
++
++ s->n = 0xbfff;
++ s->f = 2048;
++ s->threshold = 1;
++
++
++ s->max_chain = 2048;
++ s->nice_length = 2048;
++ s->use_best_off = 0;
++ s->lazy_insert = 0;
++
++ s->b_size = s->n + s->f;
++ if (2 * s->f >= s->n || s->b_size + s->f >= (32767 * 2 + 1))
++ return (-1);
++ s->b_wrap = s->b + s->b_size;
++ s->node_count = s->n;
++
++ memset(s->llen3, 0, sizeof(s->llen3[0]) * 16384);
++
++
++ memset(s->head2, 0xff, sizeof(s->head2[0]) * 65536L);
++ ((void) (0));
++
++
++
++
++
++
++ s->ip = 0;
++ swd_initdict(s,dict,dict_len);
++ s->bp = s->ip;
++ s->first_rp = s->ip;
++
++ ((void) (0));
++
++ s->look = (lzo_uint) (s->c->in_end - s->c->ip);
++ if (s->look > 0)
++ {
++ if (s->look > s->f)
++ s->look = s->f;
++ memcpy(&s->b[s->ip],s->c->ip,s->look);
++ s->c->ip += s->look;
++ s->ip += s->look;
++ }
++
++ if (s->ip == s->b_size)
++ s->ip = 0;
++
++ if (s->look >= 2 && s->dict_len > 0)
++ swd_insertdict(s,0,s->dict_len);
++
++ s->rp = s->first_rp;
++ if (s->rp >= s->node_count)
++ s->rp -= s->node_count;
++ else
++ s->rp += s->b_size - s->node_count;
++
++ ((void)&i);
++ ((void)&c);
++ return 0;
++}
++
++
++static
++void swd_exit(lzo1x_999_swd_t *s)
++{
++
++ ((void)&s);
++
++}
++
++static __inline__
++void swd_getbyte(lzo1x_999_swd_t *s)
++{
++ int c;
++
++ if ((c = ((*(s->c)).ip < (*(s->c)).in_end ? *((*(s->c)).ip)++ : (-1))) < 0)
++ {
++ if (s->look > 0)
++ --s->look;
++
++
++
++
++
++
++ }
++ else
++ {
++ s->b[s->ip] = ((unsigned char) ((c) & 0xff));
++ if (s->ip < s->f)
++ s->b_wrap[s->ip] = ((unsigned char) ((c) & 0xff));
++ }
++ if (++s->ip == s->b_size)
++ s->ip = 0;
++ if (++s->bp == s->b_size)
++ s->bp = 0;
++ if (++s->rp == s->b_size)
++ s->rp = 0;
++}
++
++
++
++
++
++
++static __inline__
++void swd_remove_node(lzo1x_999_swd_t *s, lzo_uint node)
++{
++ if (s->node_count == 0)
++ {
++ lzo_uint key;
++
++ key = (((0x9f5f*(((((lzo_uint32)s->b[node]<<5)^s->b[node+1])<<5)^s->b[node+2]))>>5) & (16384 -1));
++ ((void) (0));
++ --s->llen3[key];
++
++
++ key = (* (unsigned short *) &(s->b[node]));
++ ((void) (0));
++ if ((lzo_uint) s->head2[key] == node)
++ s->head2[key] = (32767 * 2 + 1);
++
++ }
++ else
++ --s->node_count;
++}
++
++
++
++
++
++
++static
++void swd_accept(lzo1x_999_swd_t *s, lzo_uint n)
++{
++ ((void) (0));
++
++ while (n--)
++ {
++ lzo_uint key;
++
++ swd_remove_node(s,s->rp);
++
++
++ key = (((0x9f5f*(((((lzo_uint32)s->b[s->bp]<<5)^s->b[s->bp+1])<<5)^s->b[s->bp+2]))>>5) & (16384 -1));
++ s->succ3[s->bp] = s->head3[key];
++ s->head3[key] = ((swd_uint)(s->bp));
++ s->best3[s->bp] = ((swd_uint)(s->f + 1));
++ s->llen3[key]++;
++ ((void) (0));
++
++
++
++ key = (* (unsigned short *) &(s->b[s->bp]));
++ s->head2[key] = ((swd_uint)(s->bp));
++
++
++ swd_getbyte(s);
++ }
++}
++
++
++
++
++
++
++static
++void swd_search(lzo1x_999_swd_t *s, lzo_uint node, lzo_uint cnt)
++{
++
++
++
++
++
++ const unsigned char *p1;
++ const unsigned char *p2;
++ const unsigned char *px;
++
++ lzo_uint m_len = s->m_len;
++ const unsigned char * b = s->b;
++ const unsigned char * bp = s->b + s->bp;
++ const unsigned char * bx = s->b + s->bp + s->look;
++ unsigned char scan_end1;
++
++ ((void) (0));
++
++ scan_end1 = bp[m_len - 1];
++ for ( ; cnt-- > 0; node = s->succ3[node])
++ {
++ p1 = bp;
++ p2 = b + node;
++ px = bx;
++
++ ((void) (0));
++
++ if (
++
++ p2[m_len - 1] == scan_end1 &&
++ p2[m_len] == p1[m_len] &&
++
++ p2[0] == p1[0] &&
++ p2[1] == p1[1])
++ {
++ lzo_uint i;
++ ((void) (0));
++
++ p1 += 2; p2 += 2;
++ do {} while (++p1 < px && *p1 == *++p2);
++
++ i = p1 - bp;
++
++
++
++
++
++
++
++ ((void) (0));
++
++
++ if (i < (((8) >= (33) ? ((8) >= (9) ? (8) : (9)) : ((33) >= (9) ? (33) : (9))) + 1))
++ {
++ if (s->best_pos[i] == 0)
++ s->best_pos[i] = node + 1;
++ }
++
++ if (i > m_len)
++ {
++ s->m_len = m_len = i;
++ s->m_pos = node;
++ if (m_len == s->look)
++ return;
++ if (m_len >= s->nice_length)
++ return;
++ if (m_len > (lzo_uint) s->best3[node])
++ return;
++ scan_end1 = bp[m_len - 1];
++ }
++ }
++ }
++}
++
++static
++lzo_bool swd_search2(lzo1x_999_swd_t *s)
++{
++ lzo_uint key;
++
++ ((void) (0));
++ ((void) (0));
++
++ key = s->head2[ (* (unsigned short *) &(s->b[s->bp])) ];
++ if (key == (32767 * 2 + 1))
++ return 0;
++
++
++
++
++
++ ((void) (0));
++
++ if (s->best_pos[2] == 0)
++ s->best_pos[2] = key + 1;
++
++
++ if (s->m_len < 2)
++ {
++ s->m_len = 2;
++ s->m_pos = key;
++ }
++ return 1;
++}
++
++static
++void swd_findbest(lzo1x_999_swd_t *s)
++{
++ lzo_uint key;
++ lzo_uint cnt, node;
++ lzo_uint len;
++
++ ((void) (0));
++
++
++ key = (((0x9f5f*(((((lzo_uint32)s->b[s->bp]<<5)^s->b[s->bp+1])<<5)^s->b[s->bp+2]))>>5) & (16384 -1));
++ node = s->succ3[s->bp] = s->head3[key];
++ cnt = s->llen3[key]++;
++ ((void) (0));
++ if (cnt > s->max_chain && s->max_chain > 0)
++ cnt = s->max_chain;
++ s->head3[key] = ((swd_uint)(s->bp));
++
++ s->b_char = s->b[s->bp];
++ len = s->m_len;
++ if (s->m_len >= s->look)
++ {
++ if (s->look == 0)
++ s->b_char = -1;
++ s->m_off = 0;
++ s->best3[s->bp] = ((swd_uint)(s->f + 1));
++ }
++ else
++ {
++
++ if (swd_search2(s))
++
++ if (s->look >= 3)
++ swd_search(s,node,cnt);
++ if (s->m_len > len)
++ s->m_off = (s->bp > (s->m_pos) ? s->bp - (s->m_pos) : s->b_size - ((s->m_pos) - s->bp));
++ s->best3[s->bp] = ((swd_uint)(s->m_len));
++
++
++ if (s->use_best_off)
++ {
++ int i;
++ for (i = 2; i < (((8) >= (33) ? ((8) >= (9) ? (8) : (9)) : ((33) >= (9) ? (33) : (9))) + 1); i++)
++ if (s->best_pos[i] > 0)
++ s->best_off[i] = (s->bp > (s->best_pos[i]-1) ? s->bp - (s->best_pos[i]-1) : s->b_size - ((s->best_pos[i]-1) - s->bp));
++ else
++ s->best_off[i] = 0;
++ }
++
++ }
++
++ swd_remove_node(s,s->rp);
++
++
++
++ key = (* (unsigned short *) &(s->b[s->bp]));
++ s->head2[key] = ((swd_uint)(s->bp));
++
++}
++
++
++
++
++
++
++
++
++static int
++init_match ( lzo1x_999_t *c, lzo1x_999_swd_t *s,
++ const unsigned char *dict, lzo_uint dict_len,
++ lzo_uint32 flags )
++{
++ int r;
++
++ ((void) (0));
++ c->init = 1;
++
++ s->c = c;
++
++ c->last_m_len = c->last_m_off = 0;
++
++ c->textsize = c->codesize = c->printcount = 0;
++ c->lit_bytes = c->match_bytes = c->rep_bytes = 0;
++ c->lazy = 0;
++
++ r = swd_init(s,dict,dict_len);
++ if (r != 0)
++ return r;
++
++ s->use_best_off = (flags & 1) ? 1 : 0;
++ return r;
++}
++
++
++
++
++
++
++static int
++find_match ( lzo1x_999_t *c, lzo1x_999_swd_t *s,
++ lzo_uint this_len, lzo_uint skip )
++{
++ ((void) (0));
++
++ if (skip > 0)
++ {
++ ((void) (0));
++ swd_accept(s, this_len - skip);
++ c->textsize += this_len - skip + 1;
++ }
++ else
++ {
++ ((void) (0));
++ c->textsize += this_len - skip;
++ }
++
++ s->m_len = 1;
++ s->m_len = 1;
++
++ if (s->use_best_off)
++ memset(s->best_pos,0,sizeof(s->best_pos));
++
++ swd_findbest(s);
++ c->m_len = s->m_len;
++ c->m_off = s->m_off;
++
++ swd_getbyte(s);
++
++ if (s->b_char < 0)
++ {
++ c->look = 0;
++ c->m_len = 0;
++ swd_exit(s);
++ }
++ else
++ {
++ c->look = s->look + 1;
++ }
++ c->bp = c->ip - c->look;
++
++ if (c->cb && c->textsize > c->printcount)
++ {
++ (*c->cb)(c->textsize,c->codesize);
++ c->printcount += 1024;
++ }
++
++ return 0;
++}
++
++
++
++
++static int
++lzo1x_999_compress_internal ( const unsigned char *in , lzo_uint in_len,
++ unsigned char *out, lzo_uint * out_len,
++ void * wrkmem,
++ const unsigned char *dict, lzo_uint dict_len,
++ lzo_progress_callback_t cb,
++ int try_lazy,
++ lzo_uint good_length,
++ lzo_uint max_lazy,
++ lzo_uint nice_length,
++ lzo_uint max_chain,
++ lzo_uint32 flags );
++
++
++
++
++
++
++static unsigned char *
++code_match ( lzo1x_999_t *c, unsigned char *op, lzo_uint m_len, lzo_uint m_off )
++{
++ lzo_uint x_len = m_len;
++ lzo_uint x_off = m_off;
++
++ c->match_bytes += m_len;
++
++ ((void) (0));
++ if (m_len == 2)
++ {
++ ((void) (0));
++ ((void) (0)); ((void) (0));
++ m_off -= 1;
++
++
++
++
++ *op++ = ((unsigned char) ((0 | ((m_off & 3) << 2)) & 0xff));
++ *op++ = ((unsigned char) ((m_off >> 2) & 0xff));
++
++ c->m1a_m++;
++ }
++
++
++
++ else if (m_len <= 8 && m_off <= 0x0800)
++
++ {
++ ((void) (0));
++
++ m_off -= 1;
++ *op++ = ((unsigned char) ((((m_len - 1) << 5) | ((m_off & 7) << 2)) & 0xff));
++ *op++ = ((unsigned char) ((m_off >> 3) & 0xff));
++ ((void) (0));
++
++ c->m2_m++;
++ }
++ else if (m_len == 3 && m_off <= (0x0400 + 0x0800) && c->r1_lit >= 4)
++ {
++ ((void) (0));
++ ((void) (0));
++ m_off -= 1 + 0x0800;
++
++
++
++
++ *op++ = ((unsigned char) ((0 | ((m_off & 3) << 2)) & 0xff));
++ *op++ = ((unsigned char) ((m_off >> 2) & 0xff));
++
++ c->m1b_m++;
++ }
++ else if (m_off <= 0x4000)
++ {
++ ((void) (0));
++ m_off -= 1;
++ if (m_len <= 33)
++ *op++ = ((unsigned char) ((32 | (m_len - 2)) & 0xff));
++ else
++ {
++ m_len -= 33;
++ *op++ = 32 | 0;
++ while (m_len > 255)
++ {
++ m_len -= 255;
++ *op++ = 0;
++ }
++ ((void) (0));
++ *op++ = ((unsigned char) ((m_len) & 0xff));
++ }
++
++
++
++
++ *op++ = ((unsigned char) ((m_off << 2) & 0xff));
++ *op++ = ((unsigned char) ((m_off >> 6) & 0xff));
++
++ c->m3_m++;
++ }
++ else
++ {
++ lzo_uint k;
++
++ ((void) (0));
++ ((void) (0)); ((void) (0));
++ m_off -= 0x4000;
++ k = (m_off & 0x4000) >> 11;
++ if (m_len <= 9)
++ *op++ = ((unsigned char) ((16 | k | (m_len - 2)) & 0xff));
++ else
++ {
++ m_len -= 9;
++ *op++ = ((unsigned char) ((16 | k | 0) & 0xff));
++ while (m_len > 255)
++ {
++ m_len -= 255;
++ *op++ = 0;
++ }
++ ((void) (0));
++ *op++ = ((unsigned char) ((m_len) & 0xff));
++ }
++
++
++
++
++ *op++ = ((unsigned char) ((m_off << 2) & 0xff));
++ *op++ = ((unsigned char) ((m_off >> 6) & 0xff));
++
++ c->m4_m++;
++ }
++
++ c->last_m_len = x_len;
++ c->last_m_off = x_off;
++ return op;
++}
++
++
++static unsigned char *
++STORE_RUN ( lzo1x_999_t *c, unsigned char *op, const unsigned char *ii, lzo_uint t )
++{
++ c->lit_bytes += t;
++
++ if (op == c->out && t <= 238)
++ {
++ *op++ = ((unsigned char) ((17 + t) & 0xff));
++ }
++ else if (t <= 3)
++ {
++
++
++
++ op[-2] |= ((unsigned char) ((t) & 0xff));
++
++ c->lit1_r++;
++ }
++ else if (t <= 18)
++ {
++ *op++ = ((unsigned char) ((t - 3) & 0xff));
++ c->lit2_r++;
++ }
++ else
++ {
++ lzo_uint tt = t - 18;
++
++ *op++ = 0;
++ while (tt > 255)
++ {
++ tt -= 255;
++ *op++ = 0;
++ }
++ ((void) (0));
++ *op++ = ((unsigned char) ((tt) & 0xff));
++ c->lit3_r++;
++ }
++ do *op++ = *ii++; while (--t > 0);
++
++ return op;
++}
++
++
++static unsigned char *
++code_run ( lzo1x_999_t *c, unsigned char *op, const unsigned char *ii,
++ lzo_uint lit, lzo_uint m_len )
++{
++ if (lit > 0)
++ {
++ ((void) (0));
++ op = STORE_RUN(c,op,ii,lit);
++ c->r1_m_len = m_len;
++ c->r1_lit = lit;
++ }
++ else
++ {
++ ((void) (0));
++ c->r1_m_len = 0;
++ c->r1_lit = 0;
++ }
++
++ return op;
++}
++
++
++
++
++
++
++static int
++len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit )
++{
++ int n = 4;
++
++ if (m_len < 2)
++ return -1;
++ if (m_len == 2)
++ return (m_off <= 0x0400 && lit > 0 && lit < 4) ? 2 : -1;
++ if (m_len <= 8 && m_off <= 0x0800)
++ return 2;
++ if (m_len == 3 && m_off <= (0x0400 + 0x0800) && lit >= 4)
++ return 2;
++ if (m_off <= 0x4000)
++ {
++ if (m_len <= 33)
++ return 3;
++ m_len -= 33;
++ while (m_len > 255)
++ {
++ m_len -= 255;
++ n++;
++ }
++ return n;
++ }
++ if (m_off <= 0xbfff)
++ {
++ if (m_len <= 9)
++ return 3;
++ m_len -= 9;
++ while (m_len > 255)
++ {
++ m_len -= 255;
++ n++;
++ }
++ return n;
++ }
++ return -1;
++}
++
++
++static lzo_int
++min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, int l1, int l2, int l3)
++{
++ lzo_int lazy_match_min_gain = 0;
++
++ ((void) (0));
++ lazy_match_min_gain += ahead;
++
++
++
++
++
++
++ if (lit1 <= 3)
++ lazy_match_min_gain += (lit2 <= 3) ? 0 : 2;
++ else if (lit1 <= 18)
++ lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
++
++ lazy_match_min_gain += (l2 - l1) * 2;
++ if (l3 > 0)
++ lazy_match_min_gain -= (ahead - l3) * 2;
++
++ if (lazy_match_min_gain < 0)
++ lazy_match_min_gain = 0;
++
++
++
++
++
++
++
++ return lazy_match_min_gain;
++}
++
++static void
++better_match ( const lzo1x_999_swd_t *swd, lzo_uint *m_len, lzo_uint *m_off )
++{
++
++
++
++
++ if (*m_len <= 3)
++ return;
++
++ if (*m_off <= 0x0800)
++ return;
++
++
++
++ if (*m_off > 0x0800 &&
++ *m_len >= 3 + 1 && *m_len <= 8 + 1 &&
++ swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= 0x0800)
++ {
++ *m_len = *m_len - 1;
++ *m_off = swd->best_off[*m_len];
++ return;
++ }
++
++
++
++
++ if (*m_off > 0x4000 &&
++ *m_len >= 9 + 1 && *m_len <= 8 + 2 &&
++ swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= 0x0800)
++ {
++ *m_len = *m_len - 2;
++ *m_off = swd->best_off[*m_len];
++ return;
++ }
++
++
++
++
++ if (*m_off > 0x4000 &&
++ *m_len >= 9 + 1 && *m_len <= 33 + 1 &&
++ swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= 0x4000)
++ {
++ *m_len = *m_len - 1;
++ *m_off = swd->best_off[*m_len];
++ }
++
++}
++
++ int
++lzo1x_999_compress_internal ( const unsigned char *in , lzo_uint in_len,
++ unsigned char *out, lzo_uint * out_len,
++ void * wrkmem,
++ const unsigned char *dict, lzo_uint dict_len,
++ lzo_progress_callback_t cb,
++ int try_lazy,
++ lzo_uint good_length,
++ lzo_uint max_lazy,
++ lzo_uint nice_length,
++ lzo_uint max_chain,
++ lzo_uint32 flags )
++{
++ unsigned char *op;
++ const unsigned char *ii;
++ lzo_uint lit;
++ lzo_uint m_len, m_off;
++ lzo1x_999_t cc;
++ lzo1x_999_t * const c = &cc;
++ lzo1x_999_swd_t * const swd = (lzo1x_999_swd_t *) wrkmem;
++ int r;
++
++
++
++
++
++
++
++ if (!(((lzo_uint32) (14 * 16384L * sizeof(short))) >= ((lzo_uint) (sizeof(lzo1x_999_swd_t)))))
++ return (-1);
++
++
++
++ if (try_lazy < 0)
++ try_lazy = 1;
++
++ if (good_length <= 0)
++ good_length = 32;
++
++ if (max_lazy <= 0)
++ max_lazy = 32;
++
++ if (nice_length <= 0)
++ nice_length = 0;
++
++ if (max_chain <= 0)
++ max_chain = 2048;
++
++ c->init = 0;
++ c->ip = c->in = in;
++ c->in_end = in + in_len;
++ c->out = out;
++ c->cb = cb;
++ c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0;
++ c->lit1_r = c->lit2_r = c->lit3_r = 0;
++
++ op = out;
++ ii = c->ip;
++ lit = 0;
++ c->r1_lit = c->r1_m_len = 0;
++
++ r = init_match(c,swd,dict,dict_len,flags);
++ if (r != 0)
++ return r;
++ if (max_chain > 0)
++ swd->max_chain = max_chain;
++ if (nice_length > 0)
++ swd->nice_length = nice_length;
++
++ r = find_match(c,swd,0,0);
++ if (r != 0)
++ return r;
++ while (c->look > 0)
++ {
++ lzo_uint ahead;
++ lzo_uint max_ahead;
++ int l1, l2, l3;
++
++ c->codesize = op - out;
++
++ m_len = c->m_len;
++ m_off = c->m_off;
++
++ ((void) (0));
++ ((void) (0));
++ if (lit == 0)
++ ii = c->bp;
++ ((void) (0));
++ ((void) (0));
++
++ if ( m_len < 2 ||
++ (m_len == 2 && (m_off > 0x0400 || lit == 0 || lit >= 4)) ||
++
++
++
++
++
++ (m_len == 2 && op == out) ||
++
++ (op == out && lit == 0))
++ {
++
++ m_len = 0;
++ }
++ else if (m_len == 3)
++ {
++
++ if (m_off > (0x0400 + 0x0800) && lit >= 4)
++ m_len = 0;
++ }
++
++ if (m_len == 0)
++ {
++
++ lit++;
++ swd->max_chain = max_chain;
++ r = find_match(c,swd,1,0);
++ ((void) (0));
++ continue;
++ }
++
++
++
++ if (swd->use_best_off)
++ better_match(swd,&m_len,&m_off);
++
++ ((void)0);
++
++
++
++
++ ahead = 0;
++ if (try_lazy <= 0 || m_len >= max_lazy)
++ {
++
++ l1 = 0;
++ max_ahead = 0;
++ }
++ else
++ {
++
++ l1 = len_of_coded_match(m_len,m_off,lit);
++ ((void) (0));
++
++ max_ahead = ((try_lazy) <= (l1 - 1) ? (try_lazy) : (l1 - 1));
++
++
++
++ }
++
++
++ while (ahead < max_ahead && c->look > m_len)
++ {
++ lzo_int lazy_match_min_gain;
++
++ if (m_len >= good_length)
++ swd->max_chain = max_chain >> 2;
++ else
++ swd->max_chain = max_chain;
++ r = find_match(c,swd,1,0);
++ ahead++;
++
++ ((void) (0));
++ ((void) (0));
++ ((void) (0));
++
++
++
++
++
++
++ if (c->m_len < m_len)
++ continue;
++
++ if (c->m_len == m_len && c->m_off >= m_off)
++ continue;
++
++
++ if (swd->use_best_off)
++ better_match(swd,&c->m_len,&c->m_off);
++
++ l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead);
++ if (l2 < 0)
++ continue;
++
++ l3 = (op == out) ? -1 : len_of_coded_match(ahead,m_off,lit);
++
++
++
++
++ lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3);
++ if (c->m_len >= m_len + lazy_match_min_gain)
++ {
++ c->lazy++;
++ ((void)0);
++
++ if (l3 > 0)
++ {
++
++ op = code_run(c,op,ii,lit,ahead);
++ lit = 0;
++
++ op = code_match(c,op,ahead,m_off);
++ }
++ else
++ {
++ lit += ahead;
++ ((void) (0));
++ }
++ goto lazy_match_done;
++ }
++ }
++
++
++ ((void) (0));
++
++
++ op = code_run(c,op,ii,lit,m_len);
++ lit = 0;
++
++
++ op = code_match(c,op,m_len,m_off);
++ swd->max_chain = max_chain;
++ r = find_match(c,swd,m_len,1+ahead);
++ ((void) (0));
++
++lazy_match_done: ;
++ }
++
++
++
++ if (lit > 0)
++ op = STORE_RUN(c,op,ii,lit);
++
++
++ *op++ = 16 | 1;
++ *op++ = 0;
++ *op++ = 0;
++
++
++ c->codesize = op - out;
++ ((void) (0));
++
++ *out_len = op - out;
++
++ if (c->cb)
++ (*c->cb)(c->textsize,c->codesize);
++
++
++
++
++
++
++
++ ((void) (0));
++
++ return 0;
++}
++
++
++
++
++
++
++ int
++lzo1x_999_compress_level ( const unsigned char *in , unsigned in_len,
++ unsigned char *out, unsigned * out_len,
++ void * wrkmem,
++ const unsigned char *dict, unsigned dict_len,
++ lzo_progress_callback_t cb,
++ int compression_level )
++{
++ static const struct
++ {
++ int try_lazy;
++ lzo_uint good_length;
++ lzo_uint max_lazy;
++ lzo_uint nice_length;
++ lzo_uint max_chain;
++ lzo_uint32 flags;
++ } c[9] = {
++ { 0, 0, 0, 8, 4, 0 },
++ { 0, 0, 0, 16, 8, 0 },
++ { 0, 0, 0, 32, 16, 0 },
++
++ { 1, 4, 4, 16, 16, 0 },
++ { 1, 8, 16, 32, 32, 0 },
++ { 1, 8, 16, 128, 128, 0 },
++
++ { 2, 8, 32, 128, 256, 0 },
++ { 2, 32, 128, 2048, 2048, 1 },
++ { 2, 2048, 2048, 2048, 4096, 1 }
++ };
++
++ if (compression_level < 1 || compression_level > 9)
++ return (-1);
++
++ compression_level -= 1;
++ return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem,
++ dict, dict_len, cb,
++ c[compression_level].try_lazy,
++ c[compression_level].good_length,
++ c[compression_level].max_lazy,
++
++
++
++ 0,
++
++ c[compression_level].max_chain,
++ c[compression_level].flags);
++}
++EXPORT_SYMBOL_GPL(lzo1x_999_compress_level);
++
++
++
++
++
++ int
++lzo1x_999_compress_dict ( const unsigned char *in , unsigned in_len,
++ unsigned char *out, unsigned * out_len,
++ void * wrkmem,
++ const unsigned char *dict, unsigned dict_len )
++{
++ return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
++ dict, dict_len, 0, 8);
++}
++EXPORT_SYMBOL_GPL(lzo1x_999_compress_dict);
++
++ int
++lzo1x_999_compress ( const unsigned char *in , unsigned in_len,
++ unsigned char *out, unsigned * out_len,
++ void * wrkmem )
++{
++ return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
++ ((void *)0), 0, 0, 8);
++}
++EXPORT_SYMBOL_GPL(lzo1x_999_compress);
++
+diff -Nurp kernel-2.6.28-20094102.3+0m5/lib/lzo/Makefile kernel-2.6.28-20094102.6+0m5/lib/lzo/Makefile
+--- kernel-2.6.28-20094102.3+0m5/lib/lzo/Makefile 2008-12-25 00:26:37.000000000 +0100
++++ kernel-2.6.28-20094102.6+0m5/lib/lzo/Makefile 2011-09-04 11:36:23.000000000 +0200
+@@ -1,4 +1,4 @@
+-lzo_compress-objs := lzo1x_compress.o
++lzo_compress-objs := lzo1x_compress.o lzo1x_9x.o
+ lzo_decompress-objs := lzo1x_decompress.o
+
+ obj-$(CONFIG_LZO_COMPRESS) += lzo_compress.o
projects / kernel-bfs / blobdiff