target/linux/rdc/patches-2.6.28/006-bzip2_lzma_x86.patch

   1 --- a/arch/arm/boot/compressed/Makefile
   2 +++ b/arch/arm/boot/compressed/Makefile
   3 @@ -67,8 +67,15 @@ endif
   4
   5  SEDFLAGS       = s/TEXT_START/$(ZTEXTADDR)/;s/BSS_START/$(ZBSSADDR)/
   6
   7 -targets       := vmlinux vmlinux.lds piggy.gz piggy.o font.o font.c \
   8 -                head.o misc.o $(OBJS)
   9 +suffix_$(CONFIG_KERNEL_GZIP)  = gz
  10 +suffix_$(CONFIG_KERNEL_BZIP2) = bz2
  11 +suffix_$(CONFIG_KERNEL_LZMA)  = lzma
  12 +
  13 +targets       := vmlinux vmlinux.lds \
  14 +                piggy.gz piggy.gz.o \
  15 +                piggy.bz2 piggy.bz2.o \
  16 +                piggy.lzma piggy.lzma.o \
  17 +                font.o font.c head.o misc.o $(OBJS)
  18
  19  ifeq ($(CONFIG_FUNCTION_TRACER),y)
  20  ORIG_CFLAGS := $(KBUILD_CFLAGS)
  21 @@ -95,7 +102,7 @@ LDFLAGS_vmlinux += -p --no-undefined -X
  22  # would otherwise mess up our GOT table
  23  CFLAGS_misc.o := -Dstatic=
  24
  25 -$(obj)/vmlinux: $(obj)/vmlinux.lds $(obj)/$(HEAD) $(obj)/piggy.o \
  26 +$(obj)/vmlinux: $(obj)/vmlinux.lds $(obj)/$(HEAD) $(obj)/piggy.$(suffix_y).o \
  27                 $(addprefix $(obj)/, $(OBJS)) FORCE
  28         $(call if_changed,ld)
  29         @:
  30 @@ -103,7 +110,17 @@ $(obj)/vmlinux: $(obj)/vmlinux.lds $(obj
  31  $(obj)/piggy.gz: $(obj)/../Image FORCE
  32         $(call if_changed,gzip)
  33
  34 -$(obj)/piggy.o:  $(obj)/piggy.gz FORCE
  35 +$(obj)/piggy.bz2: $(obj)/../Image FORCE
  36 +       $(call if_changed,bzip2)
  37 +
  38 +$(obj)/piggy.lzma: $(obj)/../Image FORCE
  39 +       $(call if_changed,lzma)
  40 +
  41 +$(obj)/piggy.gz.o:  $(obj)/piggy.gz FORCE
  42 +
  43 +$(obj)/piggy.bz2.o:  $(obj)/piggy.bz2 FORCE
  44 +
  45 +$(obj)/piggy.lzma.o:  $(obj)/piggy.lzma FORCE
  46
  47  CFLAGS_font.o := -Dstatic=
  48
  49 --- a/arch/arm/boot/compressed/misc.c
  50 +++ b/arch/arm/boot/compressed/misc.c
  51 @@ -169,116 +169,34 @@ static inline __ptr_t memcpy(__ptr_t __d
  52  /*
  53   * gzip delarations
  54   */
  55 -#define OF(args)  args
  56  #define STATIC static
  57
  58 -typedef unsigned char  uch;
  59 -typedef unsigned short ush;
  60  typedef unsigned long  ulg;
  61
  62 -#define WSIZE 0x8000           /* Window size must be at least 32k, */
  63 -                               /* and a power of two */
  64 -
  65 -static uch *inbuf;             /* input buffer */
  66 -static uch window[WSIZE];      /* Sliding window buffer */
  67 -
  68 -static unsigned insize;                /* valid bytes in inbuf */
  69 -static unsigned inptr;         /* index of next byte to be processed in inbuf */
  70 -static unsigned outcnt;                /* bytes in output buffer */
  71 -
  72 -/* gzip flag byte */
  73 -#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
  74 -#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
  75 -#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  76 -#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  77 -#define COMMENT      0x10 /* bit 4 set: file comment present */
  78 -#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
  79 -#define RESERVED     0xC0 /* bit 6,7:   reserved */
  80 -
  81 -#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
  82 -
  83 -/* Diagnostic functions */
  84 -#ifdef DEBUG
  85 -#  define Assert(cond,msg) {if(!(cond)) error(msg);}
  86 -#  define Trace(x) fprintf x
  87 -#  define Tracev(x) {if (verbose) fprintf x ;}
  88 -#  define Tracevv(x) {if (verbose>1) fprintf x ;}
  89 -#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
  90 -#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
  91 -#else
  92 -#  define Assert(cond,msg)
  93 -#  define Trace(x)
  94 -#  define Tracev(x)
  95 -#  define Tracevv(x)
  96 -#  define Tracec(c,x)
  97 -#  define Tracecv(c,x)
  98 -#endif
  99 -
 100 -static int  fill_inbuf(void);
 101 -static void flush_window(void);
 102 -static void error(char *m);
 103 -
 104  extern char input_data[];
 105  extern char input_data_end[];
 106
 107 -static uch *output_data;
 108 -static ulg output_ptr;
 109 -static ulg bytes_out;
 110 -
 111  static void error(char *m);
 112
 113 -static void putstr(const char *);
 114 -
 115 -extern int end;
 116  static ulg free_mem_ptr;
 117  static ulg free_mem_end_ptr;
 118
 119 -#ifdef STANDALONE_DEBUG
 120 -#define NO_INFLATE_MALLOC
 121 -#endif
 122 -
 123  #define ARCH_HAS_DECOMP_WDOG
 124 +#define NEW_CODE
 125
 126 +#ifdef CONFIG_KERNEL_GZIP
 127  #include "../../../../lib/inflate.c"
 128 +#endif
 129
 130 -/* ===========================================================================
 131 - * Fill the input buffer. This is called only when the buffer is empty
 132 - * and at least one byte is really needed.
 133 - */
 134 -int fill_inbuf(void)
 135 -{
 136 -       if (insize != 0)
 137 -               error("ran out of input data");
 138 +#ifdef CONFIG_KERNEL_BZIP2
 139 +#include "../../../../lib/decompress_bunzip2.c"
 140 +#endif
 141
 142 -       inbuf = input_data;
 143 -       insize = &input_data_end[0] - &input_data[0];
 144 +#ifdef CONFIG_KERNEL_LZMA
 145 +#include "../../../../lib/decompress_unlzma.c"
 146 +#endif
 147
 148 -       inptr = 1;
 149 -       return inbuf[0];
 150 -}
 151
 152 -/* ===========================================================================
 153 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 154 - * (Used for the decompressed data only.)
 155 - */
 156 -void flush_window(void)
 157 -{
 158 -       ulg c = crc;
 159 -       unsigned n;
 160 -       uch *in, *out, ch;
 161 -
 162 -       in = window;
 163 -       out = &output_data[output_ptr];
 164 -       for (n = 0; n < outcnt; n++) {
 165 -               ch = *out++ = *in++;
 166 -               c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 167 -       }
 168 -       crc = c;
 169 -       bytes_out += (ulg)outcnt;
 170 -       output_ptr += (ulg)outcnt;
 171 -       outcnt = 0;
 172 -       putstr(".");
 173 -}
 174
 175  #ifndef arch_error
 176  #define arch_error(x)
 177 @@ -301,16 +219,24 @@ ulg
 178  decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p,
 179                   int arch_id)
 180  {
 181 -       output_data             = (uch *)output_start;  /* Points to kernel start */
 182 -       free_mem_ptr            = free_mem_ptr_p;
 183 -       free_mem_end_ptr        = free_mem_ptr_end_p;
 184 +       ulg output_ptr;
 185 +       ulg *ptr;
 186 +       size_t input_len        = input_data_end - input_data;
 187 +       size_t pos              = 0;
 188 +
 189         __machine_arch_type     = arch_id;
 190
 191         arch_decomp_setup();
 192
 193 -       makecrc();
 194 -       putstr("Uncompressing Linux...");
 195 -       gunzip();
 196 +       ptr = (ulg *) (((long)input_data_end) - 4);
 197 +       output_ptr = output_start +  *ptr;
 198 +
 199 +       free_mem_ptr            = output_ptr;
 200 +       free_mem_end_ptr        = output_ptr + 0x4000000;
 201 +
 202 +       putstr("Decompressing Linux...");
 203 +       decompress(input_data, input_len,
 204 +                  NULL, NULL, (unsigned char *) output_start, &pos, error);
 205         putstr(" done, booting the kernel.\n");
 206         return output_ptr;
 207  }
 208 @@ -320,11 +246,8 @@ char output_buffer[1500*1024];
 209
 210  int main()
 211  {
 212 -       output_data = output_buffer;
 213 -
 214 -       makecrc();
 215         putstr("Uncompressing Linux...");
 216 -       gunzip();
 217 +       decompress(input_data, input_len, NULL, output_buffer, NULL);
 218         putstr("done.\n");
 219         return 0;
 220  }
 221 --- a/arch/x86/boot/compressed/Makefile
 222 +++ b/arch/x86/boot/compressed/Makefile
 223 @@ -4,7 +4,7 @@
 224  # create a compressed vmlinux image from the original vmlinux
 225  #
 226
 227 -targets := vmlinux vmlinux.bin vmlinux.bin.gz head_$(BITS).o misc.o piggy.o
 228 +targets := vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2 vmlinux.bin.lzma head_$(BITS).o misc.o piggy.o
 229
 230  KBUILD_CFLAGS := -m$(BITS) -D__KERNEL__ $(LINUX_INCLUDE) -O2
 231  KBUILD_CFLAGS += -fno-strict-aliasing -fPIC
 232 @@ -47,9 +47,17 @@ ifeq ($(CONFIG_X86_32),y)
 233  ifdef CONFIG_RELOCATABLE
 234  $(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin.all FORCE
 235         $(call if_changed,gzip)
 236 +$(obj)/vmlinux.bin.bz2: $(obj)/vmlinux.bin.all FORCE
 237 +       $(call if_changed,bzip2)
 238 +$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin.all FORCE
 239 +       $(call if_changed,lzma)
 240  else
 241  $(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
 242         $(call if_changed,gzip)
 243 +$(obj)/vmlinux.bin.bz2: $(obj)/vmlinux.bin FORCE
 244 +       $(call if_changed,bzip2)
 245 +$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE
 246 +       $(call if_changed,lzma)
 247  endif
 248  LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T
 249
 250 @@ -60,5 +68,9 @@ $(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bi
 251  LDFLAGS_piggy.o := -r --format binary --oformat elf64-x86-64 -T
 252  endif
 253
 254 -$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE
 255 +suffix_$(CONFIG_KERNEL_GZIP)  = gz
 256 +suffix_$(CONFIG_KERNEL_BZIP2) = bz2
 257 +suffix_$(CONFIG_KERNEL_LZMA)  = lzma
 258 +
 259 +$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.$(suffix_y) FORCE
 260         $(call if_changed,ld)
 261 --- a/arch/x86/boot/compressed/misc.c
 262 +++ b/arch/x86/boot/compressed/misc.c
 263 @@ -116,71 +116,13 @@
 264  /*
 265   * gzip declarations
 266   */
 267 -
 268 -#define OF(args)       args
 269  #define STATIC         static
 270
 271  #undef memset
 272  #undef memcpy
 273  #define memzero(s, n)  memset((s), 0, (n))
 274
 275 -typedef unsigned char  uch;
 276 -typedef unsigned short ush;
 277 -typedef unsigned long  ulg;
 278 -
 279 -/*
 280 - * Window size must be at least 32k, and a power of two.
 281 - * We don't actually have a window just a huge output buffer,
 282 - * so we report a 2G window size, as that should always be
 283 - * larger than our output buffer:
 284 - */
 285 -#define WSIZE          0x80000000
 286
 287 -/* Input buffer: */
 288 -static unsigned char   *inbuf;
 289 -
 290 -/* Sliding window buffer (and final output buffer): */
 291 -static unsigned char   *window;
 292 -
 293 -/* Valid bytes in inbuf: */
 294 -static unsigned                insize;
 295 -
 296 -/* Index of next byte to be processed in inbuf: */
 297 -static unsigned                inptr;
 298 -
 299 -/* Bytes in output buffer: */
 300 -static unsigned                outcnt;
 301 -
 302 -/* gzip flag byte */
 303 -#define ASCII_FLAG     0x01 /* bit 0 set: file probably ASCII text */
 304 -#define CONTINUATION   0x02 /* bit 1 set: continuation of multi-part gz file */
 305 -#define EXTRA_FIELD    0x04 /* bit 2 set: extra field present */
 306 -#define ORIG_NAM       0x08 /* bit 3 set: original file name present */
 307 -#define COMMENT                0x10 /* bit 4 set: file comment present */
 308 -#define ENCRYPTED      0x20 /* bit 5 set: file is encrypted */
 309 -#define RESERVED       0xC0 /* bit 6, 7:  reserved */
 310 -
 311 -#define get_byte()     (inptr < insize ? inbuf[inptr++] : fill_inbuf())
 312 -
 313 -/* Diagnostic functions */
 314 -#ifdef DEBUG
 315 -#  define Assert(cond, msg) do { if (!(cond)) error(msg); } while (0)
 316 -#  define Trace(x)     do { fprintf x; } while (0)
 317 -#  define Tracev(x)    do { if (verbose) fprintf x ; } while (0)
 318 -#  define Tracevv(x)   do { if (verbose > 1) fprintf x ; } while (0)
 319 -#  define Tracec(c, x) do { if (verbose && (c)) fprintf x ; } while (0)
 320 -#  define Tracecv(c, x)        do { if (verbose > 1 && (c)) fprintf x ; } while (0)
 321 -#else
 322 -#  define Assert(cond, msg)
 323 -#  define Trace(x)
 324 -#  define Tracev(x)
 325 -#  define Tracevv(x)
 326 -#  define Tracec(c, x)
 327 -#  define Tracecv(c, x)
 328 -#endif
 329 -
 330 -static int  fill_inbuf(void);
 331 -static void flush_window(void);
 332  static void error(char *m);
 333
 334  /*
 335 @@ -189,11 +131,6 @@ static void error(char *m);
 336  static struct boot_params *real_mode;          /* Pointer to real-mode data */
 337  static int quiet;
 338
 339 -extern unsigned char input_data[];
 340 -extern int input_len;
 341 -
 342 -static long bytes_out;
 343 -
 344  static void *memset(void *s, int c, unsigned n);
 345  static void *memcpy(void *dest, const void *src, unsigned n);
 346
 347 @@ -213,7 +150,19 @@ static char *vidmem;
 348  static int vidport;
 349  static int lines, cols;
 350
 351 +#define NEW_CODE
 352 +
 353 +#ifdef CONFIG_KERNEL_GZIP
 354  #include "../../../../lib/inflate.c"
 355 +#endif
 356 +
 357 +#ifdef CONFIG_KERNEL_BZIP2
 358 +#include "../../../../lib/decompress_bunzip2.c"
 359 +#endif
 360 +
 361 +#ifdef CONFIG_KERNEL_LZMA
 362 +#include "../../../../lib/decompress_unlzma.c"
 363 +#endif
 364
 365  static void scroll(void)
 366  {
 367 @@ -293,38 +242,6 @@ static void *memcpy(void *dest, const vo
 368         return dest;
 369  }
 370
 371 -/* ===========================================================================
 372 - * Fill the input buffer. This is called only when the buffer is empty
 373 - * and at least one byte is really needed.
 374 - */
 375 -static int fill_inbuf(void)
 376 -{
 377 -       error("ran out of input data");
 378 -       return 0;
 379 -}
 380 -
 381 -/* ===========================================================================
 382 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 383 - * (Used for the decompressed data only.)
 384 - */
 385 -static void flush_window(void)
 386 -{
 387 -       /* With my window equal to my output buffer
 388 -        * I only need to compute the crc here.
 389 -        */
 390 -       unsigned long c = crc;         /* temporary variable */
 391 -       unsigned n;
 392 -       unsigned char *in, ch;
 393 -
 394 -       in = window;
 395 -       for (n = 0; n < outcnt; n++) {
 396 -               ch = *in++;
 397 -               c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 398 -       }
 399 -       crc = c;
 400 -       bytes_out += (unsigned long)outcnt;
 401 -       outcnt = 0;
 402 -}
 403
 404  static void error(char *x)
 405  {
 406 @@ -407,12 +324,8 @@ asmlinkage void decompress_kernel(void *
 407         lines = real_mode->screen_info.orig_video_lines;
 408         cols = real_mode->screen_info.orig_video_cols;
 409
 410 -       window = output;                /* Output buffer (Normally at 1M) */
 411         free_mem_ptr     = heap;        /* Heap */
 412         free_mem_end_ptr = heap + BOOT_HEAP_SIZE;
 413 -       inbuf  = input_data;            /* Input buffer */
 414 -       insize = input_len;
 415 -       inptr  = 0;
 416
 417  #ifdef CONFIG_X86_64
 418         if ((unsigned long)output & (__KERNEL_ALIGN - 1))
 419 @@ -430,10 +343,9 @@ asmlinkage void decompress_kernel(void *
 420  #endif
 421  #endif
 422
 423 -       makecrc();
 424         if (!quiet)
 425                 putstr("\nDecompressing Linux... ");
 426 -       gunzip();
 427 +       decompress(input_data, input_len, NULL, NULL, output, NULL, error);
 428         parse_elf(output);
 429         if (!quiet)
 430                 putstr("done.\nBooting the kernel.\n");
 431 --- a/arch/x86/include/asm/boot.h
 432 +++ b/arch/x86/include/asm/boot.h
 433 @@ -15,11 +15,21 @@
 434                                 + (CONFIG_PHYSICAL_ALIGN - 1)) \
 435                                 & ~(CONFIG_PHYSICAL_ALIGN - 1))
 436
 437 +#if (defined CONFIG_KERNEL_BZIP2)
 438 +#define BOOT_HEAP_SIZE             0x400000
 439 +#else
 440 +
 441  #ifdef CONFIG_X86_64
 442  #define BOOT_HEAP_SIZE 0x7000
 443 -#define BOOT_STACK_SIZE        0x4000
 444  #else
 445  #define BOOT_HEAP_SIZE 0x4000
 446 +#endif
 447 +
 448 +#endif
 449 +
 450 +#ifdef CONFIG_X86_64
 451 +#define BOOT_STACK_SIZE        0x4000
 452 +#else
 453  #define BOOT_STACK_SIZE        0x1000
 454  #endif
 455
 456 --- a/drivers/block/Kconfig
 457 +++ b/drivers/block/Kconfig
 458 @@ -358,6 +358,30 @@ config BLK_DEV_XIP
 459           will prevent RAM block device backing store memory from being
 460           allocated from highmem (only a problem for highmem systems).
 461
 462 +config RD_BZIP2
 463 +       bool "Initial ramdisk compressed using bzip2"
 464 +       default n
 465 +       depends on BLK_DEV_INITRD=y
 466 +       help
 467 +         Support loading of a bzip2 encoded initial ramdisk or cpio buffer
 468 +         If unsure, say N.
 469 +
 470 +config RD_LZMA
 471 +       bool "Initial ramdisk compressed using lzma"
 472 +       default n
 473 +       depends on BLK_DEV_INITRD=y
 474 +       help
 475 +         Support loading of a lzma encoded initial ramdisk or cpio buffer
 476 +         If unsure, say N.
 477 +
 478 +config RD_GZIP
 479 +       bool "Initial ramdisk compressed using gzip"
 480 +       default y
 481 +       depends on BLK_DEV_INITRD=y
 482 +       help
 483 +         Support loading of a gzip encoded initial ramdisk or cpio buffer.
 484 +         If unsure, say Y.
 485 +
 486  config CDROM_PKTCDVD
 487         tristate "Packet writing on CD/DVD media"
 488         depends on !UML
 489 --- /dev/null
 490 +++ b/include/linux/decompress/bunzip2.h
 491 @@ -0,0 +1,10 @@
 492 +#ifndef DECOMPRESS_BUNZIP2_H
 493 +#define DECOMPRESS_BUNZIP2_H
 494 +
 495 +int bunzip2(unsigned char *inbuf, int len,
 496 +           int(*fill)(void*, unsigned int),
 497 +           int(*flush)(void*, unsigned int),
 498 +           unsigned char *output,
 499 +           int *pos,
 500 +           void(*error)(char *x));
 501 +#endif
 502 --- /dev/null
 503 +++ b/include/linux/decompress/generic.h
 504 @@ -0,0 +1,30 @@
 505 +#ifndef DECOMPRESS_GENERIC_H
 506 +#define DECOMPRESS_GENERIC_H
 507 +
 508 +/* Minimal chunksize to be read.
 509 + *Bzip2 prefers at least 4096
 510 + *Lzma prefers 0x10000 */
 511 +#define COMPR_IOBUF_SIZE       4096
 512 +
 513 +typedef int (*decompress_fn) (unsigned char *inbuf, int len,
 514 +                             int(*fill)(void*, unsigned int),
 515 +                             int(*writebb)(void*, unsigned int),
 516 +                             unsigned char *output,
 517 +                             int *posp,
 518 +                             void(*error)(char *x));
 519 +
 520 +/* inbuf   - input buffer
 521 + *len     - len of pre-read data in inbuf
 522 + *fill    - function to fill inbuf if empty
 523 + *writebb - function to write out outbug
 524 + *posp    - if non-null, input position (number of bytes read) will be
 525 + *       returned here
 526 + *
 527 + *If len != 0, the inbuf is initialized (with as much data), and fill
 528 + *should not be called
 529 + *If len = 0, the inbuf is allocated, but empty. Its size is IOBUF_SIZE
 530 + *fill should be called (repeatedly...) to read data, at most IOBUF_SIZE
 531 + */
 532 +
 533 +
 534 +#endif
 535 --- /dev/null
 536 +++ b/include/linux/decompress/inflate.h
 537 @@ -0,0 +1,13 @@
 538 +#ifndef INFLATE_H
 539 +#define INFLATE_H
 540 +
 541 +/* Other housekeeping constants */
 542 +#define INBUFSIZ 4096
 543 +
 544 +int gunzip(unsigned char *inbuf, int len,
 545 +          int(*fill)(void*, unsigned int),
 546 +          int(*flush)(void*, unsigned int),
 547 +          unsigned char *output,
 548 +          int *pos,
 549 +          void(*error_fn)(char *x));
 550 +#endif
 551 --- /dev/null
 552 +++ b/include/linux/decompress/mm.h
 553 @@ -0,0 +1,89 @@
 554 +/*
 555 + * linux/compr_mm.h
 556 + *
 557 + * Memory management for pre-boot and ramdisk uncompressors
 558 + *
 559 + * Authors: Alain Knaff <alain@knaff.lu>
 560 + *
 561 + */
 562 +
 563 +#ifndef DECOMPR_MM_H
 564 +#define DECOMPR_MM_H
 565 +
 566 +#ifdef STATIC
 567 +
 568 +/* Code active when included from pre-boot environment: */
 569 +
 570 +/* A trivial malloc implementation, adapted from
 571 + *  malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
 572 + */
 573 +static unsigned long malloc_ptr;
 574 +static int malloc_count;
 575 +
 576 +static void *malloc(int size)
 577 +{
 578 +       void *p;
 579 +
 580 +       if (size < 0)
 581 +               error("Malloc error");
 582 +       if (!malloc_ptr)
 583 +               malloc_ptr = free_mem_ptr;
 584 +
 585 +       malloc_ptr = (malloc_ptr + 3) & ~3;     /* Align */
 586 +
 587 +       p = (void *)malloc_ptr;
 588 +       malloc_ptr += size;
 589 +
 590 +       if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
 591 +               error("Out of memory");
 592 +
 593 +       malloc_count++;
 594 +       return p;
 595 +}
 596 +
 597 +static void free(void *where)
 598 +{
 599 +       malloc_count--;
 600 +       if (!malloc_count)
 601 +               malloc_ptr = free_mem_ptr;
 602 +}
 603 +
 604 +#define large_malloc(a) malloc(a)
 605 +#define large_free(a) free(a)
 606 +
 607 +#define set_error_fn(x)
 608 +#define panic error
 609 +
 610 +#define INIT
 611 +
 612 +#else /* STATIC */
 613 +
 614 +/* Code active when compiled standalone for use when loading ramdisk: */
 615 +
 616 +#include <linux/kernel.h>
 617 +#include <linux/fs.h>
 618 +#include <linux/string.h>
 619 +#include <linux/vmalloc.h>
 620 +
 621 +/* Use defines rather than static inline in order to avoid spurious
 622 + * warnings when not needed (indeed large_malloc / large_free are not
 623 + * needed by inflate */
 624 +
 625 +#define malloc(a) kmalloc(a, GFP_KERNEL)
 626 +#define free(a) kfree(a)
 627 +
 628 +#define large_malloc(a) vmalloc(a)
 629 +#define large_free(a) vfree(a)
 630 +
 631 +static void(*error)(char *m);
 632 +#define set_error_fn(x) error = x;
 633 +#define NEW_CODE
 634 +
 635 +#define INIT __init
 636 +#define STATIC
 637 +
 638 +#include <linux/init.h>
 639 +
 640 +#endif /* STATIC */
 641 +
 642 +#endif /* DECOMPR_MM_H */
 643 --- /dev/null
 644 +++ b/include/linux/decompress/unlzma.h
 645 @@ -0,0 +1,12 @@
 646 +#ifndef DECOMPRESS_UNLZMA_H
 647 +#define DECOMPRESS_UNLZMA_H
 648 +
 649 +int unlzma(unsigned char *, int,
 650 +          int(*fill)(void*, unsigned int),
 651 +          int(*flush)(void*, unsigned int),
 652 +          unsigned char *output,
 653 +          int *posp,
 654 +          void(*error)(char *x)
 655 +       );
 656 +
 657 +#endif
 658 --- a/init/Kconfig
 659 +++ b/init/Kconfig
 660 @@ -101,6 +101,56 @@ config LOCALVERSION_AUTO
 661
 662           which is done within the script "scripts/setlocalversion".)
 663
 664 +choice
 665 +        prompt "Kernel compression mode"
 666 +        default KERNEL_GZIP
 667 +        help
 668 +         The linux kernel is a kind of self-extracting executable.
 669 +         Several compression algorithms are available, which differ
 670 +         in efficiency, compression and decompression speed.
 671 +         Compression speed is only relevant when building a kernel.
 672 +         Decompression speed is relevant at each boot.
 673 +
 674 +         If you have any problems with bzip2 or lzma compressed
 675 +         kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older
 676 +         version of this functionality (bzip2 only), for 2.4, was
 677 +         supplied by Christian Ludwig)
 678 +
 679 +         High compression options are mostly useful for users, who
 680 +         are low on disk space (embedded systems), but for whom ram
 681 +         size matters less.
 682 +
 683 +         If in doubt, select 'gzip'
 684 +
 685 +config KERNEL_GZIP
 686 +       bool "Gzip"
 687 +       help
 688 +         The old and tried gzip compression. Its compression ratio is
 689 +        the poorest among the 3 choices; however its speed (both
 690 +        compression and decompression) is the fastest.
 691 +
 692 +config KERNEL_BZIP2
 693 +       bool "Bzip2"
 694 +       help
 695 +         Its compression ratio and speed is intermediate.
 696 +         Decompression speed is slowest among the 3.
 697 +         The kernel size is about 10 per cent smaller with bzip2,
 698 +         in comparison to gzip.
 699 +         Bzip2 uses a large amount of memory. For modern kernels
 700 +         you will need at least 8MB RAM or more for booting.
 701 +
 702 +config KERNEL_LZMA
 703 +       bool "LZMA"
 704 +       help
 705 +         The most recent compression algorithm.
 706 +        Its ratio is best, decompression speed is between the other
 707 +        2. Compression is slowest.
 708 +        The kernel size is about 33 per cent smaller with lzma,
 709 +        in comparison to gzip.
 710 +
 711 +endchoice
 712 +
 713 +
 714  config SWAP
 715         bool "Support for paging of anonymous memory (swap)"
 716         depends on MMU && BLOCK
 717 --- a/init/do_mounts_rd.c
 718 +++ b/init/do_mounts_rd.c
 719 @@ -11,6 +11,12 @@
 720
 721  #include "do_mounts.h"
 722
 723 +#include <linux/decompress/generic.h>
 724 +
 725 +#include <linux/decompress/bunzip2.h>
 726 +#include <linux/decompress/unlzma.h>
 727 +#include <linux/decompress/inflate.h>
 728 +
 729  int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
 730
 731  static int __init prompt_ramdisk(char *str)
 732 @@ -29,7 +35,7 @@ static int __init ramdisk_start_setup(ch
 733  }
 734  __setup("ramdisk_start=", ramdisk_start_setup);
 735
 736 -static int __init crd_load(int in_fd, int out_fd);
 737 +static int __init crd_load(int in_fd, int out_fd, decompress_fn deco);
 738
 739  /*
 740   * This routine tries to find a RAM disk image to load, and returns the
 741 @@ -46,7 +52,7 @@ static int __init crd_load(int in_fd, in
 742   *     gzip
 743   */
 744  static int __init
 745 -identify_ramdisk_image(int fd, int start_block)
 746 +identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
 747  {
 748         const int size = 512;
 749         struct minix_super_block *minixsb;
 750 @@ -74,6 +80,7 @@ identify_ramdisk_image(int fd, int start
 751         sys_lseek(fd, start_block * BLOCK_SIZE, 0);
 752         sys_read(fd, buf, size);
 753
 754 +#ifdef CONFIG_RD_GZIP
 755         /*
 756          * If it matches the gzip magic numbers, return 0
 757          */
 758 @@ -81,9 +88,39 @@ identify_ramdisk_image(int fd, int start
 759                 printk(KERN_NOTICE
 760                        "RAMDISK: Compressed image found at block %d\n",
 761                        start_block);
 762 +               *decompressor = gunzip;
 763 +               nblocks = 0;
 764 +               goto done;
 765 +       }
 766 +#endif
 767 +
 768 +#ifdef CONFIG_RD_BZIP2
 769 +       /*
 770 +        * If it matches the bzip2 magic numbers, return -1
 771 +        */
 772 +       if (buf[0] == 0x42 && (buf[1] == 0x5a)) {
 773 +               printk(KERN_NOTICE
 774 +                      "RAMDISK: Bzipped image found at block %d\n",
 775 +                      start_block);
 776 +               *decompressor = bunzip2;
 777                 nblocks = 0;
 778                 goto done;
 779         }
 780 +#endif
 781 +
 782 +#ifdef CONFIG_RD_LZMA
 783 +       /*
 784 +        * If it matches the lzma magic numbers, return -1
 785 +        */
 786 +       if (buf[0] == 0x5d && (buf[1] == 0x00)) {
 787 +               printk(KERN_NOTICE
 788 +                      "RAMDISK: Lzma image found at block %d\n",
 789 +                      start_block);
 790 +               *decompressor = unlzma;
 791 +               nblocks = 0;
 792 +               goto done;
 793 +       }
 794 +#endif
 795
 796         /* romfs is at block zero too */
 797         if (romfsb->word0 == ROMSB_WORD0 &&
 798 @@ -156,6 +193,7 @@ int __init rd_load_image(char *from)
 799         int nblocks, i, disk;
 800         char *buf = NULL;
 801         unsigned short rotate = 0;
 802 +       decompress_fn decompressor = NULL;
 803  #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
 804         char rotator[4] = { '|' , '/' , '-' , '\\' };
 805  #endif
 806 @@ -168,12 +206,12 @@ int __init rd_load_image(char *from)
 807         if (in_fd < 0)
 808                 goto noclose_input;
 809
 810 -       nblocks = identify_ramdisk_image(in_fd, rd_image_start);
 811 +       nblocks = identify_ramdisk_image(in_fd, rd_image_start, &decompressor);
 812         if (nblocks < 0)
 813                 goto done;
 814
 815         if (nblocks == 0) {
 816 -               if (crd_load(in_fd, out_fd) == 0)
 817 +               if (crd_load(in_fd, out_fd, decompressor) == 0)
 818                         goto successful_load;
 819                 goto done;
 820         }
 821 @@ -272,138 +310,48 @@ int __init rd_load_disk(int n)
 822         return rd_load_image("/dev/root");
 823  }
 824
 825 -/*
 826 - * gzip declarations
 827 - */
 828 -
 829 -#define OF(args)  args
 830 -
 831 -#ifndef memzero
 832 -#define memzero(s, n)     memset ((s), 0, (n))
 833 -#endif
 834 -
 835 -typedef unsigned char  uch;
 836 -typedef unsigned short ush;
 837 -typedef unsigned long  ulg;
 838 -
 839 -#define INBUFSIZ 4096
 840 -#define WSIZE 0x8000    /* window size--must be a power of two, and */
 841 -                       /*  at least 32K for zip's deflate method */
 842 -
 843 -static uch *inbuf;
 844 -static uch *window;
 845 -
 846 -static unsigned insize;  /* valid bytes in inbuf */
 847 -static unsigned inptr;   /* index of next byte to be processed in inbuf */
 848 -static unsigned outcnt;  /* bytes in output buffer */
 849  static int exit_code;
 850 -static int unzip_error;
 851 -static long bytes_out;
 852 +static int decompress_error;
 853  static int crd_infd, crd_outfd;
 854
 855 -#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
 856 -
 857 -/* Diagnostic functions (stubbed out) */
 858 -#define Assert(cond,msg)
 859 -#define Trace(x)
 860 -#define Tracev(x)
 861 -#define Tracevv(x)
 862 -#define Tracec(c,x)
 863 -#define Tracecv(c,x)
 864 -
 865 -#define STATIC static
 866 -#define INIT __init
 867 -
 868 -static int  __init fill_inbuf(void);
 869 -static void __init flush_window(void);
 870 -static void __init error(char *m);
 871 -
 872 -#define NO_INFLATE_MALLOC
 873 -
 874 -#include "../lib/inflate.c"
 875 -
 876 -/* ===========================================================================
 877 - * Fill the input buffer. This is called only when the buffer is empty
 878 - * and at least one byte is really needed.
 879 - * Returning -1 does not guarantee that gunzip() will ever return.
 880 - */
 881 -static int __init fill_inbuf(void)
 882 +static int __init compr_fill(void *buf, unsigned int len)
 883  {
 884 -       if (exit_code) return -1;
 885 -
 886 -       insize = sys_read(crd_infd, inbuf, INBUFSIZ);
 887 -       if (insize == 0) {
 888 -               error("RAMDISK: ran out of compressed data");
 889 -               return -1;
 890 -       }
 891 -
 892 -       inptr = 1;
 893 -
 894 -       return inbuf[0];
 895 +       int r = sys_read(crd_infd, buf, len);
 896 +       if (r < 0)
 897 +               printk(KERN_ERR "RAMDISK: error while reading compressed data");
 898 +       else if (r == 0)
 899 +               printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
 900 +       return r;
 901  }
 902
 903 -/* ===========================================================================
 904 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 905 - * (Used for the decompressed data only.)
 906 - */
 907 -static void __init flush_window(void)
 908 +static int __init compr_flush(void *window, unsigned int outcnt)
 909  {
 910 -    ulg c = crc;         /* temporary variable */
 911 -    unsigned n, written;
 912 -    uch *in, ch;
 913 -
 914 -    written = sys_write(crd_outfd, window, outcnt);
 915 -    if (written != outcnt && unzip_error == 0) {
 916 -       printk(KERN_ERR "RAMDISK: incomplete write (%d != %d) %ld\n",
 917 -              written, outcnt, bytes_out);
 918 -       unzip_error = 1;
 919 -    }
 920 -    in = window;
 921 -    for (n = 0; n < outcnt; n++) {
 922 -           ch = *in++;
 923 -           c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 924 -    }
 925 -    crc = c;
 926 -    bytes_out += (ulg)outcnt;
 927 -    outcnt = 0;
 928 +       int written = sys_write(crd_outfd, window, outcnt);
 929 +       if (written != outcnt) {
 930 +               if (decompress_error == 0)
 931 +                       printk(KERN_ERR
 932 +                              "RAMDISK: incomplete write (%d != %d)\n",
 933 +                              written, outcnt);
 934 +               decompress_error = 1;
 935 +               return -1;
 936 +       }
 937 +       return outcnt;
 938  }
 939
 940  static void __init error(char *x)
 941  {
 942         printk(KERN_ERR "%s\n", x);
 943         exit_code = 1;
 944 -       unzip_error = 1;
 945 +       decompress_error = 1;
 946  }
 947
 948 -static int __init crd_load(int in_fd, int out_fd)
 949 +static int __init crd_load(int in_fd, int out_fd, decompress_fn deco)
 950  {
 951         int result;
 952 -
 953 -       insize = 0;             /* valid bytes in inbuf */
 954 -       inptr = 0;              /* index of next byte to be processed in inbuf */
 955 -       outcnt = 0;             /* bytes in output buffer */
 956 -       exit_code = 0;
 957 -       bytes_out = 0;
 958 -       crc = (ulg)0xffffffffL; /* shift register contents */
 959 -
 960         crd_infd = in_fd;
 961         crd_outfd = out_fd;
 962 -       inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
 963 -       if (!inbuf) {
 964 -               printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
 965 -               return -1;
 966 -       }
 967 -       window = kmalloc(WSIZE, GFP_KERNEL);
 968 -       if (!window) {
 969 -               printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
 970 -               kfree(inbuf);
 971 -               return -1;
 972 -       }
 973 -       makecrc();
 974 -       result = gunzip();
 975 -       if (unzip_error)
 976 +       result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
 977 +       if (decompress_error)
 978                 result = 1;
 979 -       kfree(inbuf);
 980 -       kfree(window);
 981         return result;
 982  }
 983 --- a/init/initramfs.c
 984 +++ b/init/initramfs.c
 985 @@ -389,11 +389,14 @@ static int __init write_buffer(char *buf
 986         return len - count;
 987  }
 988
 989 -static void __init flush_buffer(char *buf, unsigned len)
 990 +
 991 +static int __init flush_buffer(void *bufv, unsigned len)
 992  {
 993 +       char *buf = (char *) bufv;
 994         int written;
 995 +       int origLen = len;
 996         if (message)
 997 -               return;
 998 +               return -1;
 999         while ((written = write_buffer(buf, len)) < len && !message) {
1000                 char c = buf[written];
1001                 if (c == '0') {
1002 @@ -407,73 +410,14 @@ static void __init flush_buffer(char *bu
1003                 } else
1004                         error("junk in compressed archive");
1005         }
1006 +       return origLen;
1007  }
1008
1009 -/*
1010 - * gzip declarations
1011 - */
1012 -
1013 -#define OF(args)  args
1014 -
1015 -#ifndef memzero
1016 -#define memzero(s, n)     memset ((s), 0, (n))
1017 -#endif
1018 +static unsigned my_inptr;   /* index of next byte to be processed in inbuf */
1019
1020 -typedef unsigned char  uch;
1021 -typedef unsigned short ush;
1022 -typedef unsigned long  ulg;
1023 -
1024 -#define WSIZE 0x8000    /* window size--must be a power of two, and */
1025 -                       /*  at least 32K for zip's deflate method */
1026 -
1027 -static uch *inbuf;
1028 -static uch *window;
1029 -
1030 -static unsigned insize;  /* valid bytes in inbuf */
1031 -static unsigned inptr;   /* index of next byte to be processed in inbuf */
1032 -static unsigned outcnt;  /* bytes in output buffer */
1033 -static long bytes_out;
1034 -
1035 -#define get_byte()  (inptr < insize ? inbuf[inptr++] : -1)
1036 -
1037 -/* Diagnostic functions (stubbed out) */
1038 -#define Assert(cond,msg)
1039 -#define Trace(x)
1040 -#define Tracev(x)
1041 -#define Tracevv(x)
1042 -#define Tracec(c,x)
1043 -#define Tracecv(c,x)
1044 -
1045 -#define STATIC static
1046 -#define INIT __init
1047 -
1048 -static void __init flush_window(void);
1049 -static void __init error(char *m);
1050 -
1051 -#define NO_INFLATE_MALLOC
1052 -
1053 -#include "../lib/inflate.c"
1054 -
1055 -/* ===========================================================================
1056 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
1057 - * (Used for the decompressed data only.)
1058 - */
1059 -static void __init flush_window(void)
1060 -{
1061 -       ulg c = crc;         /* temporary variable */
1062 -       unsigned n;
1063 -       uch *in, ch;
1064 -
1065 -       flush_buffer(window, outcnt);
1066 -       in = window;
1067 -       for (n = 0; n < outcnt; n++) {
1068 -               ch = *in++;
1069 -               c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
1070 -       }
1071 -       crc = c;
1072 -       bytes_out += (ulg)outcnt;
1073 -       outcnt = 0;
1074 -}
1075 +#include <linux/decompress/bunzip2.h>
1076 +#include <linux/decompress/unlzma.h>
1077 +#include <linux/decompress/inflate.h>
1078
1079  static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
1080  {
1081 @@ -482,9 +426,10 @@ static char * __init unpack_to_rootfs(ch
1082         header_buf = kmalloc(110, GFP_KERNEL);
1083         symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
1084         name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
1085 -       window = kmalloc(WSIZE, GFP_KERNEL);
1086 -       if (!window || !header_buf || !symlink_buf || !name_buf)
1087 +
1088 +       if (!header_buf || !symlink_buf || !name_buf)
1089                 panic("can't allocate buffers");
1090 +
1091         state = Start;
1092         this_header = 0;
1093         message = NULL;
1094 @@ -504,22 +449,38 @@ static char * __init unpack_to_rootfs(ch
1095                         continue;
1096                 }
1097                 this_header = 0;
1098 -               insize = len;
1099 -               inbuf = buf;
1100 -               inptr = 0;
1101 -               outcnt = 0;             /* bytes in output buffer */
1102 -               bytes_out = 0;
1103 -               crc = (ulg)0xffffffffL; /* shift register contents */
1104 -               makecrc();
1105 -               gunzip();
1106 +               if (!gunzip(buf, len, NULL, flush_buffer, NULL,
1107 +                                       &my_inptr, error) &&
1108 +                       message == NULL)
1109 +                       goto ok;
1110 +
1111 +#ifdef CONFIG_RD_BZIP2
1112 +               message = NULL; /* Zero out message, or else cpio will think an error has already occured */
1113 +               if (!bunzip2(buf, len, NULL, flush_buffer, NULL,
1114 +                                       &my_inptr, error) < 0
1115 +                   &&
1116 +                   message == NULL) {
1117 +                       goto ok;
1118 +               }
1119 +#endif
1120 +
1121 +#ifdef CONFIG_RD_LZMA
1122 +               message = NULL; /* Zero out message, or else cpio will think an error has already occured */
1123 +               if (!unlzma(buf, len, NULL, flush_buffer, NULL,
1124 +                       &my_inptr, error) < 0
1125 +                       &&
1126 +                       message == NULL) {
1127 +                               goto ok;
1128 +               }
1129 +#endif
1130 +ok:
1131                 if (state != Reset)
1132 -                       error("junk in gzipped archive");
1133 -               this_header = saved_offset + inptr;
1134 -               buf += inptr;
1135 -               len -= inptr;
1136 +                       error("junk in compressed archive");
1137 +               this_header = saved_offset + my_inptr;
1138 +               buf += my_inptr;
1139 +               len -= my_inptr;
1140         }
1141         dir_utime();
1142 -       kfree(window);
1143         kfree(name_buf);
1144         kfree(symlink_buf);
1145         kfree(header_buf);
1146 --- a/lib/Makefile
1147 +++ b/lib/Makefile
1148 @@ -11,7 +11,8 @@ lib-y := ctype.o string.o vsprintf.o cmd
1149          rbtree.o radix-tree.o dump_stack.o \
1150          idr.o int_sqrt.o extable.o prio_tree.o \
1151          sha1.o irq_regs.o reciprocal_div.o argv_split.o \
1152 -        proportions.o prio_heap.o ratelimit.o show_mem.o
1153 +        proportions.o prio_heap.o ratelimit.o show_mem.o \
1154 +        inflate.o decompress_bunzip2.o decompress_unlzma.o
1155
1156  lib-$(CONFIG_MMU) += ioremap.o
1157  lib-$(CONFIG_SMP) += cpumask.o
1158 --- /dev/null
1159 +++ b/lib/decompress_bunzip2.c
1160 @@ -0,0 +1,735 @@
1161 +/* vi: set sw = 4 ts = 4: */
1162 +/*     Small bzip2 deflate implementation, by Rob Landley (rob@landley.net).
1163 +
1164 +       Based on bzip2 decompression code by Julian R Seward (jseward@acm.org),
1165 +       which also acknowledges contributions by Mike Burrows, David Wheeler,
1166 +       Peter Fenwick, Alistair Moffat, Radford Neal, Ian H. Witten,
1167 +       Robert Sedgewick, and Jon L. Bentley.
1168 +
1169 +       This code is licensed under the LGPLv2:
1170 +               LGPL (http://www.gnu.org/copyleft/lgpl.html
1171 +*/
1172 +
1173 +/*
1174 +       Size and speed optimizations by Manuel Novoa III  (mjn3@codepoet.org).
1175 +
1176 +       More efficient reading of Huffman codes, a streamlined read_bunzip()
1177 +       function, and various other tweaks.  In (limited) tests, approximately
1178 +       20% faster than bzcat on x86 and about 10% faster on arm.
1179 +
1180 +       Note that about 2/3 of the time is spent in read_unzip() reversing
1181 +       the Burrows-Wheeler transformation.  Much of that time is delay
1182 +       resulting from cache misses.
1183 +
1184 +       I would ask that anyone benefiting from this work, especially those
1185 +       using it in commercial products, consider making a donation to my local
1186 +       non-profit hospice organization in the name of the woman I loved, who
1187 +       passed away Feb. 12, 2003.
1188 +
1189 +               In memory of Toni W. Hagan
1190 +
1191 +               Hospice of Acadiana, Inc.
1192 +               2600 Johnston St., Suite 200
1193 +               Lafayette, LA 70503-3240
1194 +
1195 +               Phone (337) 232-1234 or 1-800-738-2226
1196 +               Fax   (337) 232-1297
1197 +
1198 +               http://www.hospiceacadiana.com/
1199 +
1200 +       Manuel
1201 + */
1202 +
1203 +/*
1204 +       Made it fit for running in Linux Kernel by Alain Knaff (alain@knaff.lu)
1205 +*/
1206 +
1207 +
1208 +#ifndef STATIC
1209 +#include <linux/decompress/bunzip2.h>
1210 +#endif /* !STATIC */
1211 +
1212 +#include <linux/decompress/mm.h>
1213 +
1214 +#ifndef INT_MAX
1215 +#define INT_MAX 0x7fffffff
1216 +#endif
1217 +
1218 +/* Constants for Huffman coding */
1219 +#define MAX_GROUPS             6
1220 +#define GROUP_SIZE             50      /* 64 would have been more efficient */
1221 +#define MAX_HUFCODE_BITS       20      /* Longest Huffman code allowed */
1222 +#define MAX_SYMBOLS            258     /* 256 literals + RUNA + RUNB */
1223 +#define SYMBOL_RUNA            0
1224 +#define SYMBOL_RUNB            1
1225 +
1226 +/* Status return values */
1227 +#define RETVAL_OK                      0
1228 +#define RETVAL_LAST_BLOCK              (-1)
1229 +#define RETVAL_NOT_BZIP_DATA           (-2)
1230 +#define RETVAL_UNEXPECTED_INPUT_EOF    (-3)
1231 +#define RETVAL_UNEXPECTED_OUTPUT_EOF   (-4)
1232 +#define RETVAL_DATA_ERROR              (-5)
1233 +#define RETVAL_OUT_OF_MEMORY           (-6)
1234 +#define RETVAL_OBSOLETE_INPUT          (-7)
1235 +
1236 +/* Other housekeeping constants */
1237 +#define BZIP2_IOBUF_SIZE               4096
1238 +
1239 +/* This is what we know about each Huffman coding group */
1240 +struct group_data {
1241 +       /* We have an extra slot at the end of limit[] for a sentinal value. */
1242 +       int limit[MAX_HUFCODE_BITS+1];
1243 +       int base[MAX_HUFCODE_BITS];
1244 +       int permute[MAX_SYMBOLS];
1245 +       int minLen, maxLen;
1246 +};
1247 +
1248 +/* Structure holding all the housekeeping data, including IO buffers and
1249 +   memory that persists between calls to bunzip */
1250 +struct bunzip_data {
1251 +       /* State for interrupting output loop */
1252 +       int writeCopies, writePos, writeRunCountdown, writeCount, writeCurrent;
1253 +       /* I/O tracking data (file handles, buffers, positions, etc.) */
1254 +       int (*fill)(void*, unsigned int);
1255 +       int inbufCount, inbufPos /*, outbufPos*/;
1256 +       unsigned char *inbuf /*,*outbuf*/;
1257 +       unsigned int inbufBitCount, inbufBits;
1258 +       /* The CRC values stored in the block header and calculated from the
1259 +       data */
1260 +       unsigned int crc32Table[256], headerCRC, totalCRC, writeCRC;
1261 +       /* Intermediate buffer and its size (in bytes) */
1262 +       unsigned int *dbuf, dbufSize;
1263 +       /* These things are a bit too big to go on the stack */
1264 +       unsigned char selectors[32768];         /* nSelectors = 15 bits */
1265 +       struct group_data groups[MAX_GROUPS];   /* Huffman coding tables */
1266 +       int io_error;                   /* non-zero if we have IO error */
1267 +};
1268 +
1269 +
1270 +/* Return the next nnn bits of input.  All reads from the compressed input
1271 +   are done through this function.  All reads are big endian */
1272 +static unsigned int INIT get_bits(struct bunzip_data *bd, char bits_wanted)
1273 +{
1274 +       unsigned int bits = 0;
1275 +
1276 +       /* If we need to get more data from the byte buffer, do so.
1277 +          (Loop getting one byte at a time to enforce endianness and avoid
1278 +          unaligned access.) */
1279 +       while (bd->inbufBitCount < bits_wanted) {
1280 +               /* If we need to read more data from file into byte buffer, do
1281 +                  so */
1282 +               if (bd->inbufPos == bd->inbufCount) {
1283 +                       if (bd->io_error)
1284 +                               return 0;
1285 +                       bd->inbufCount = bd->fill(bd->inbuf, BZIP2_IOBUF_SIZE);
1286 +                       if (bd->inbufCount <= 0) {
1287 +                               bd->io_error = RETVAL_UNEXPECTED_INPUT_EOF;
1288 +                               return 0;
1289 +                       }
1290 +                       bd->inbufPos = 0;
1291 +               }
1292 +               /* Avoid 32-bit overflow (dump bit buffer to top of output) */
1293 +               if (bd->inbufBitCount >= 24) {
1294 +                       bits = bd->inbufBits&((1 << bd->inbufBitCount)-1);
1295 +                       bits_wanted -= bd->inbufBitCount;
1296 +                       bits <<= bits_wanted;
1297 +                       bd->inbufBitCount = 0;
1298 +               }
1299 +               /* Grab next 8 bits of input from buffer. */
1300 +               bd->inbufBits = (bd->inbufBits << 8)|bd->inbuf[bd->inbufPos++];
1301 +               bd->inbufBitCount += 8;
1302 +       }
1303 +       /* Calculate result */
1304 +       bd->inbufBitCount -= bits_wanted;
1305 +       bits |= (bd->inbufBits >> bd->inbufBitCount)&((1 << bits_wanted)-1);
1306 +
1307 +       return bits;
1308 +}
1309 +
1310 +/* Unpacks the next block and sets up for the inverse burrows-wheeler step. */
1311 +
1312 +static int INIT get_next_block(struct bunzip_data *bd)
1313 +{
1314 +       struct group_data *hufGroup = NULL;
1315 +       int *base = NULL;
1316 +       int *limit = NULL;
1317 +       int dbufCount, nextSym, dbufSize, groupCount, selector,
1318 +               i, j, k, t, runPos, symCount, symTotal, nSelectors,
1319 +               byteCount[256];
1320 +       unsigned char uc, symToByte[256], mtfSymbol[256], *selectors;
1321 +       unsigned int *dbuf, origPtr;
1322 +
1323 +       dbuf = bd->dbuf;
1324 +       dbufSize = bd->dbufSize;
1325 +       selectors = bd->selectors;
1326 +
1327 +       /* Read in header signature and CRC, then validate signature.
1328 +          (last block signature means CRC is for whole file, return now) */
1329 +       i = get_bits(bd, 24);
1330 +       j = get_bits(bd, 24);
1331 +       bd->headerCRC = get_bits(bd, 32);
1332 +       if ((i == 0x177245) && (j == 0x385090))
1333 +               return RETVAL_LAST_BLOCK;
1334 +       if ((i != 0x314159) || (j != 0x265359))
1335 +               return RETVAL_NOT_BZIP_DATA;
1336 +       /* We can add support for blockRandomised if anybody complains.
1337 +          There was some code for this in busybox 1.0.0-pre3, but nobody ever
1338 +          noticed that it didn't actually work. */
1339 +       if (get_bits(bd, 1))
1340 +               return RETVAL_OBSOLETE_INPUT;
1341 +       origPtr = get_bits(bd, 24);
1342 +       if (origPtr > dbufSize)
1343 +               return RETVAL_DATA_ERROR;
1344 +       /* mapping table: if some byte values are never used (encoding things
1345 +          like ascii text), the compression code removes the gaps to have fewer
1346 +          symbols to deal with, and writes a sparse bitfield indicating which
1347 +          values were present.  We make a translation table to convert the
1348 +          symbols back to the corresponding bytes. */
1349 +       t = get_bits(bd, 16);
1350 +       symTotal = 0;
1351 +       for (i = 0; i < 16; i++) {
1352 +               if (t&(1 << (15-i))) {
1353 +                       k = get_bits(bd, 16);
1354 +                       for (j = 0; j < 16; j++)
1355 +                               if (k&(1 << (15-j)))
1356 +                                       symToByte[symTotal++] = (16*i)+j;
1357 +               }
1358 +       }
1359 +       /* How many different Huffman coding groups does this block use? */
1360 +       groupCount = get_bits(bd, 3);
1361 +       if (groupCount < 2 || groupCount > MAX_GROUPS)
1362 +               return RETVAL_DATA_ERROR;
1363 +       /* nSelectors: Every GROUP_SIZE many symbols we select a new
1364 +          Huffman coding group.  Read in the group selector list,
1365 +          which is stored as MTF encoded bit runs.  (MTF = Move To
1366 +          Front, as each value is used it's moved to the start of the
1367 +          list.) */
1368 +       nSelectors = get_bits(bd, 15);
1369 +       if (!nSelectors)
1370 +               return RETVAL_DATA_ERROR;
1371 +       for (i = 0; i < groupCount; i++)
1372 +               mtfSymbol[i] = i;
1373 +       for (i = 0; i < nSelectors; i++) {
1374 +               /* Get next value */
1375 +               for (j = 0; get_bits(bd, 1); j++)
1376 +                       if (j >= groupCount)
1377 +                               return RETVAL_DATA_ERROR;
1378 +               /* Decode MTF to get the next selector */
1379 +               uc = mtfSymbol[j];
1380 +               for (; j; j--)
1381 +                       mtfSymbol[j] = mtfSymbol[j-1];
1382 +               mtfSymbol[0] = selectors[i] = uc;
1383 +       }
1384 +       /* Read the Huffman coding tables for each group, which code
1385 +          for symTotal literal symbols, plus two run symbols (RUNA,
1386 +          RUNB) */
1387 +       symCount = symTotal+2;
1388 +       for (j = 0; j < groupCount; j++) {
1389 +               unsigned char length[MAX_SYMBOLS], temp[MAX_HUFCODE_BITS+1];
1390 +               int     minLen, maxLen, pp;
1391 +               /* Read Huffman code lengths for each symbol.  They're
1392 +                  stored in a way similar to mtf; record a starting
1393 +                  value for the first symbol, and an offset from the
1394 +                  previous value for everys symbol after that.
1395 +                  (Subtracting 1 before the loop and then adding it
1396 +                  back at the end is an optimization that makes the
1397 +                  test inside the loop simpler: symbol length 0
1398 +                  becomes negative, so an unsigned inequality catches
1399 +                  it.) */
1400 +               t = get_bits(bd, 5)-1;
1401 +               for (i = 0; i < symCount; i++) {
1402 +                       for (;;) {
1403 +                               if (((unsigned)t) > (MAX_HUFCODE_BITS-1))
1404 +                                       return RETVAL_DATA_ERROR;
1405 +
1406 +                               /* If first bit is 0, stop.  Else
1407 +                                  second bit indicates whether to
1408 +                                  increment or decrement the value.
1409 +                                  Optimization: grab 2 bits and unget
1410 +                                  the second if the first was 0. */
1411 +
1412 +                               k = get_bits(bd, 2);
1413 +                               if (k < 2) {
1414 +                                       bd->inbufBitCount++;
1415 +                                       break;
1416 +                               }
1417 +                               /* Add one if second bit 1, else
1418 +                                * subtract 1.  Avoids if/else */
1419 +                               t += (((k+1)&2)-1);
1420 +                       }
1421 +                       /* Correct for the initial -1, to get the
1422 +                        * final symbol length */
1423 +                       length[i] = t+1;
1424 +               }
1425 +               /* Find largest and smallest lengths in this group */
1426 +               minLen = maxLen = length[0];
1427 +
1428 +               for (i = 1; i < symCount; i++) {
1429 +                       if (length[i] > maxLen)
1430 +                               maxLen = length[i];
1431 +                       else if (length[i] < minLen)
1432 +                               minLen = length[i];
1433 +               }
1434 +
1435 +               /* Calculate permute[], base[], and limit[] tables from
1436 +                * length[].
1437 +                *
1438 +                * permute[] is the lookup table for converting
1439 +                * Huffman coded symbols into decoded symbols.  base[]
1440 +                * is the amount to subtract from the value of a
1441 +                * Huffman symbol of a given length when using
1442 +                * permute[].
1443 +                *
1444 +                * limit[] indicates the largest numerical value a
1445 +                * symbol with a given number of bits can have.  This
1446 +                * is how the Huffman codes can vary in length: each
1447 +                * code with a value > limit[length] needs another
1448 +                * bit.
1449 +                */
1450 +               hufGroup = bd->groups+j;
1451 +               hufGroup->minLen = minLen;
1452 +               hufGroup->maxLen = maxLen;
1453 +               /* Note that minLen can't be smaller than 1, so we
1454 +                  adjust the base and limit array pointers so we're
1455 +                  not always wasting the first entry.  We do this
1456 +                  again when using them (during symbol decoding).*/
1457 +               base = hufGroup->base-1;
1458 +               limit = hufGroup->limit-1;
1459 +               /* Calculate permute[].  Concurently, initialize
1460 +                * temp[] and limit[]. */
1461 +               pp = 0;
1462 +               for (i = minLen; i <= maxLen; i++) {
1463 +                       temp[i] = limit[i] = 0;
1464 +                       for (t = 0; t < symCount; t++)
1465 +                               if (length[t] == i)
1466 +                                       hufGroup->permute[pp++] = t;
1467 +               }
1468 +               /* Count symbols coded for at each bit length */
1469 +               for (i = 0; i < symCount; i++)
1470 +                       temp[length[i]]++;
1471 +               /* Calculate limit[] (the largest symbol-coding value
1472 +                *at each bit length, which is (previous limit <<
1473 +                *1)+symbols at this level), and base[] (number of
1474 +                *symbols to ignore at each bit length, which is limit
1475 +                *minus the cumulative count of symbols coded for
1476 +                *already). */
1477 +               pp = t = 0;
1478 +               for (i = minLen; i < maxLen; i++) {
1479 +                       pp += temp[i];
1480 +                       /* We read the largest possible symbol size
1481 +                          and then unget bits after determining how
1482 +                          many we need, and those extra bits could be
1483 +                          set to anything.  (They're noise from
1484 +                          future symbols.)  At each level we're
1485 +                          really only interested in the first few
1486 +                          bits, so here we set all the trailing
1487 +                          to-be-ignored bits to 1 so they don't
1488 +                          affect the value > limit[length]
1489 +                          comparison. */
1490 +                       limit[i] = (pp << (maxLen - i)) - 1;
1491 +                       pp <<= 1;
1492 +                       base[i+1] = pp-(t += temp[i]);
1493 +               }
1494 +               limit[maxLen+1] = INT_MAX; /* Sentinal value for
1495 +                                           * reading next sym. */
1496 +               limit[maxLen] = pp+temp[maxLen]-1;
1497 +               base[minLen] = 0;
1498 +       }
1499 +       /* We've finished reading and digesting the block header.  Now
1500 +          read this block's Huffman coded symbols from the file and
1501 +          undo the Huffman coding and run length encoding, saving the
1502 +          result into dbuf[dbufCount++] = uc */
1503 +
1504 +       /* Initialize symbol occurrence counters and symbol Move To
1505 +        * Front table */
1506 +       for (i = 0; i < 256; i++) {
1507 +               byteCount[i] = 0;
1508 +               mtfSymbol[i] = (unsigned char)i;
1509 +       }
1510 +       /* Loop through compressed symbols. */
1511 +       runPos = dbufCount = symCount = selector = 0;
1512 +       for (;;) {
1513 +               /* Determine which Huffman coding group to use. */
1514 +               if (!(symCount--)) {
1515 +                       symCount = GROUP_SIZE-1;
1516 +                       if (selector >= nSelectors)
1517 +                               return RETVAL_DATA_ERROR;
1518 +                       hufGroup = bd->groups+selectors[selector++];
1519 +                       base = hufGroup->base-1;
1520 +                       limit = hufGroup->limit-1;
1521 +               }
1522 +               /* Read next Huffman-coded symbol. */
1523 +               /* Note: It is far cheaper to read maxLen bits and
1524 +                  back up than it is to read minLen bits and then an
1525 +                  additional bit at a time, testing as we go.
1526 +                  Because there is a trailing last block (with file
1527 +                  CRC), there is no danger of the overread causing an
1528 +                  unexpected EOF for a valid compressed file.  As a
1529 +                  further optimization, we do the read inline
1530 +                  (falling back to a call to get_bits if the buffer
1531 +                  runs dry).  The following (up to got_huff_bits:) is
1532 +                  equivalent to j = get_bits(bd, hufGroup->maxLen);
1533 +                */
1534 +               while (bd->inbufBitCount < hufGroup->maxLen) {
1535 +                       if (bd->inbufPos == bd->inbufCount) {
1536 +                               j = get_bits(bd, hufGroup->maxLen);
1537 +                               goto got_huff_bits;
1538 +                       }
1539 +                       bd->inbufBits =
1540 +                               (bd->inbufBits << 8)|bd->inbuf[bd->inbufPos++];
1541 +                       bd->inbufBitCount += 8;
1542 +               };
1543 +               bd->inbufBitCount -= hufGroup->maxLen;
1544 +               j = (bd->inbufBits >> bd->inbufBitCount)&
1545 +                       ((1 << hufGroup->maxLen)-1);
1546 +got_huff_bits:
1547 +               /* Figure how how many bits are in next symbol and
1548 +                * unget extras */
1549 +               i = hufGroup->minLen;
1550 +               while (j > limit[i])
1551 +                       ++i;
1552 +               bd->inbufBitCount += (hufGroup->maxLen - i);
1553 +               /* Huffman decode value to get nextSym (with bounds checking) */
1554 +               if ((i > hufGroup->maxLen)
1555 +                       || (((unsigned)(j = (j>>(hufGroup->maxLen-i))-base[i]))
1556 +                               >= MAX_SYMBOLS))
1557 +                       return RETVAL_DATA_ERROR;
1558 +               nextSym = hufGroup->permute[j];
1559 +               /* We have now decoded the symbol, which indicates
1560 +                  either a new literal byte, or a repeated run of the
1561 +                  most recent literal byte.  First, check if nextSym
1562 +                  indicates a repeated run, and if so loop collecting
1563 +                  how many times to repeat the last literal. */
1564 +               if (((unsigned)nextSym) <= SYMBOL_RUNB) { /* RUNA or RUNB */
1565 +                       /* If this is the start of a new run, zero out
1566 +                        * counter */
1567 +                       if (!runPos) {
1568 +                               runPos = 1;
1569 +                               t = 0;
1570 +                       }
1571 +                       /* Neat trick that saves 1 symbol: instead of
1572 +                          or-ing 0 or 1 at each bit position, add 1
1573 +                          or 2 instead.  For example, 1011 is 1 << 0
1574 +                          + 1 << 1 + 2 << 2.  1010 is 2 << 0 + 2 << 1
1575 +                          + 1 << 2.  You can make any bit pattern
1576 +                          that way using 1 less symbol than the basic
1577 +                          or 0/1 method (except all bits 0, which
1578 +                          would use no symbols, but a run of length 0
1579 +                          doesn't mean anything in this context).
1580 +                          Thus space is saved. */
1581 +                       t += (runPos << nextSym);
1582 +                       /* +runPos if RUNA; +2*runPos if RUNB */
1583 +
1584 +                       runPos <<= 1;
1585 +                       continue;
1586 +               }
1587 +               /* When we hit the first non-run symbol after a run,
1588 +                  we now know how many times to repeat the last
1589 +                  literal, so append that many copies to our buffer
1590 +                  of decoded symbols (dbuf) now.  (The last literal
1591 +                  used is the one at the head of the mtfSymbol
1592 +                  array.) */
1593 +               if (runPos) {
1594 +                       runPos = 0;
1595 +                       if (dbufCount+t >= dbufSize)
1596 +                               return RETVAL_DATA_ERROR;
1597 +
1598 +                       uc = symToByte[mtfSymbol[0]];
1599 +                       byteCount[uc] += t;
1600 +                       while (t--)
1601 +                               dbuf[dbufCount++] = uc;
1602 +               }
1603 +               /* Is this the terminating symbol? */
1604 +               if (nextSym > symTotal)
1605 +                       break;
1606 +               /* At this point, nextSym indicates a new literal
1607 +                  character.  Subtract one to get the position in the
1608 +                  MTF array at which this literal is currently to be
1609 +                  found.  (Note that the result can't be -1 or 0,
1610 +                  because 0 and 1 are RUNA and RUNB.  But another
1611 +                  instance of the first symbol in the mtf array,
1612 +                  position 0, would have been handled as part of a
1613 +                  run above.  Therefore 1 unused mtf position minus 2
1614 +                  non-literal nextSym values equals -1.) */
1615 +               if (dbufCount >= dbufSize)
1616 +                       return RETVAL_DATA_ERROR;
1617 +               i = nextSym - 1;
1618 +               uc = mtfSymbol[i];
1619 +               /* Adjust the MTF array.  Since we typically expect to
1620 +                *move only a small number of symbols, and are bound
1621 +                *by 256 in any case, using memmove here would
1622 +                *typically be bigger and slower due to function call
1623 +                *overhead and other assorted setup costs. */
1624 +               do {
1625 +                       mtfSymbol[i] = mtfSymbol[i-1];
1626 +               } while (--i);
1627 +               mtfSymbol[0] = uc;
1628 +               uc = symToByte[uc];
1629 +               /* We have our literal byte.  Save it into dbuf. */
1630 +               byteCount[uc]++;
1631 +               dbuf[dbufCount++] = (unsigned int)uc;
1632 +       }
1633 +       /* At this point, we've read all the Huffman-coded symbols
1634 +          (and repeated runs) for this block from the input stream,
1635 +          and decoded them into the intermediate buffer.  There are
1636 +          dbufCount many decoded bytes in dbuf[].  Now undo the
1637 +          Burrows-Wheeler transform on dbuf.  See
1638 +          http://dogma.net/markn/articles/bwt/bwt.htm
1639 +        */
1640 +       /* Turn byteCount into cumulative occurrence counts of 0 to n-1. */
1641 +       j = 0;
1642 +       for (i = 0; i < 256; i++) {
1643 +               k = j+byteCount[i];
1644 +               byteCount[i] = j;
1645 +               j = k;
1646 +       }
1647 +       /* Figure out what order dbuf would be in if we sorted it. */
1648 +       for (i = 0; i < dbufCount; i++) {
1649 +               uc = (unsigned char)(dbuf[i] & 0xff);
1650 +               dbuf[byteCount[uc]] |= (i << 8);
1651 +               byteCount[uc]++;
1652 +       }
1653 +       /* Decode first byte by hand to initialize "previous" byte.
1654 +          Note that it doesn't get output, and if the first three
1655 +          characters are identical it doesn't qualify as a run (hence
1656 +          writeRunCountdown = 5). */
1657 +       if (dbufCount) {
1658 +               if (origPtr >= dbufCount)
1659 +                       return RETVAL_DATA_ERROR;
1660 +               bd->writePos = dbuf[origPtr];
1661 +               bd->writeCurrent = (unsigned char)(bd->writePos&0xff);
1662 +               bd->writePos >>= 8;
1663 +               bd->writeRunCountdown = 5;
1664 +       }
1665 +       bd->writeCount = dbufCount;
1666 +
1667 +       return RETVAL_OK;
1668 +}
1669 +
1670 +/* Undo burrows-wheeler transform on intermediate buffer to produce output.
1671 +   If start_bunzip was initialized with out_fd =-1, then up to len bytes of
1672 +   data are written to outbuf.  Return value is number of bytes written or
1673 +   error (all errors are negative numbers).  If out_fd!=-1, outbuf and len
1674 +   are ignored, data is written to out_fd and return is RETVAL_OK or error.
1675 +*/
1676 +
1677 +static int INIT read_bunzip(struct bunzip_data *bd, char *outbuf, int len)
1678 +{
1679 +       const unsigned int *dbuf;
1680 +       int pos, xcurrent, previous, gotcount;
1681 +
1682 +       /* If last read was short due to end of file, return last block now */
1683 +       if (bd->writeCount < 0)
1684 +               return bd->writeCount;
1685 +
1686 +       gotcount = 0;
1687 +       dbuf = bd->dbuf;
1688 +       pos = bd->writePos;
1689 +       xcurrent = bd->writeCurrent;
1690 +
1691 +       /* We will always have pending decoded data to write into the output
1692 +          buffer unless this is the very first call (in which case we haven't
1693 +          Huffman-decoded a block into the intermediate buffer yet). */
1694 +
1695 +       if (bd->writeCopies) {
1696 +               /* Inside the loop, writeCopies means extra copies (beyond 1) */
1697 +               --bd->writeCopies;
1698 +               /* Loop outputting bytes */
1699 +               for (;;) {
1700 +                       /* If the output buffer is full, snapshot
1701 +                        * state and return */
1702 +                       if (gotcount >= len) {
1703 +                               bd->writePos = pos;
1704 +                               bd->writeCurrent = xcurrent;
1705 +                               bd->writeCopies++;
1706 +                               return len;
1707 +                       }
1708 +                       /* Write next byte into output buffer, updating CRC */
1709 +                       outbuf[gotcount++] = xcurrent;
1710 +                       bd->writeCRC = (((bd->writeCRC) << 8)
1711 +                               ^bd->crc32Table[((bd->writeCRC) >> 24)
1712 +                               ^xcurrent]);
1713 +                       /* Loop now if we're outputting multiple
1714 +                        * copies of this byte */
1715 +                       if (bd->writeCopies) {
1716 +                               --bd->writeCopies;
1717 +                               continue;
1718 +                       }
1719 +decode_next_byte:
1720 +                       if (!bd->writeCount--)
1721 +                               break;
1722 +                       /* Follow sequence vector to undo
1723 +                        * Burrows-Wheeler transform */
1724 +                       previous = xcurrent;
1725 +                       pos = dbuf[pos];
1726 +                       xcurrent = pos&0xff;
1727 +                       pos >>= 8;
1728 +                       /* After 3 consecutive copies of the same
1729 +                          byte, the 4th is a repeat count.  We count
1730 +                          down from 4 instead *of counting up because
1731 +                          testing for non-zero is faster */
1732 +                       if (--bd->writeRunCountdown) {
1733 +                               if (xcurrent != previous)
1734 +                                       bd->writeRunCountdown = 4;
1735 +                       } else {
1736 +                               /* We have a repeated run, this byte
1737 +                                * indicates the count */
1738 +                               bd->writeCopies = xcurrent;
1739 +                               xcurrent = previous;
1740 +                               bd->writeRunCountdown = 5;
1741 +                               /* Sometimes there are just 3 bytes
1742 +                                * (run length 0) */
1743 +                               if (!bd->writeCopies)
1744 +                                       goto decode_next_byte;
1745 +                               /* Subtract the 1 copy we'd output
1746 +                                * anyway to get extras */
1747 +                               --bd->writeCopies;
1748 +                       }
1749 +               }
1750 +               /* Decompression of this block completed successfully */
1751 +               bd->writeCRC = ~bd->writeCRC;
1752 +               bd->totalCRC = ((bd->totalCRC << 1) |
1753 +                               (bd->totalCRC >> 31)) ^ bd->writeCRC;
1754 +               /* If this block had a CRC error, force file level CRC error. */
1755 +               if (bd->writeCRC != bd->headerCRC) {
1756 +                       bd->totalCRC = bd->headerCRC+1;
1757 +                       return RETVAL_LAST_BLOCK;
1758 +               }
1759 +       }
1760 +
1761 +       /* Refill the intermediate buffer by Huffman-decoding next
1762 +        * block of input */
1763 +       /* (previous is just a convenient unused temp variable here) */
1764 +       previous = get_next_block(bd);
1765 +       if (previous) {
1766 +               bd->writeCount = previous;
1767 +               return (previous != RETVAL_LAST_BLOCK) ? previous : gotcount;
1768 +       }
1769 +       bd->writeCRC = 0xffffffffUL;
1770 +       pos = bd->writePos;
1771 +       xcurrent = bd->writeCurrent;
1772 +       goto decode_next_byte;
1773 +}
1774 +
1775 +static int INIT nofill(void *buf, unsigned int len)
1776 +{
1777 +       return -1;
1778 +}
1779 +
1780 +/* Allocate the structure, read file header.  If in_fd ==-1, inbuf must contain
1781 +   a complete bunzip file (len bytes long).  If in_fd!=-1, inbuf and len are
1782 +   ignored, and data is read from file handle into temporary buffer. */
1783 +static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len,
1784 +                            int (*fill)(void*, unsigned int))
1785 +{
1786 +       struct bunzip_data *bd;
1787 +       unsigned int i, j, c;
1788 +       const unsigned int BZh0 =
1789 +               (((unsigned int)'B') << 24)+(((unsigned int)'Z') << 16)
1790 +               +(((unsigned int)'h') << 8)+(unsigned int)'0';
1791 +
1792 +       /* Figure out how much data to allocate */
1793 +       i = sizeof(struct bunzip_data);
1794 +
1795 +       /* Allocate bunzip_data.  Most fields initialize to zero. */
1796 +       bd = *bdp = malloc(i);
1797 +       memset(bd, 0, sizeof(struct bunzip_data));
1798 +       /* Setup input buffer */
1799 +       bd->inbuf = inbuf;
1800 +       bd->inbufCount = len;
1801 +       if (fill != NULL)
1802 +               bd->fill = fill;
1803 +       else
1804 +               bd->fill = nofill;
1805 +
1806 +       /* Init the CRC32 table (big endian) */
1807 +       for (i = 0; i < 256; i++) {
1808 +               c = i << 24;
1809 +               for (j = 8; j; j--)
1810 +                       c = c&0x80000000 ? (c << 1)^0x04c11db7 : (c << 1);
1811 +               bd->crc32Table[i] = c;
1812 +       }
1813 +
1814 +       /* Ensure that file starts with "BZh['1'-'9']." */
1815 +       i = get_bits(bd, 32);
1816 +       if (((unsigned int)(i-BZh0-1)) >= 9)
1817 +               return RETVAL_NOT_BZIP_DATA;
1818 +
1819 +       /* Fourth byte (ascii '1'-'9'), indicates block size in units of 100k of
1820 +          uncompressed data.  Allocate intermediate buffer for block. */
1821 +       bd->dbufSize = 100000*(i-BZh0);
1822 +
1823 +       bd->dbuf = large_malloc(bd->dbufSize * sizeof(int));
1824 +       return RETVAL_OK;
1825 +}
1826 +
1827 +/* Example usage: decompress src_fd to dst_fd.  (Stops at end of bzip2 data,
1828 +   not end of file.) */
1829 +STATIC int INIT bunzip2(unsigned char *buf, int len,
1830 +                       int(*fill)(void*, unsigned int),
1831 +                       int(*flush)(void*, unsigned int),
1832 +                       unsigned char *outbuf,
1833 +                       int *pos,
1834 +                       void(*error_fn)(char *x))
1835 +{
1836 +       struct bunzip_data *bd;
1837 +       int i = -1;
1838 +       unsigned char *inbuf;
1839 +
1840 +       set_error_fn(error_fn);
1841 +       if (flush)
1842 +               outbuf = malloc(BZIP2_IOBUF_SIZE);
1843 +       else
1844 +               len -= 4; /* Uncompressed size hack active in pre-boot
1845 +                            environment */
1846 +       if (!outbuf) {
1847 +               error("Could not allocate output bufer");
1848 +               return -1;
1849 +       }
1850 +       if (buf)
1851 +               inbuf = buf;
1852 +       else
1853 +               inbuf = malloc(BZIP2_IOBUF_SIZE);
1854 +       if (!inbuf) {
1855 +               error("Could not allocate input bufer");
1856 +               goto exit_0;
1857 +       }
1858 +       i = start_bunzip(&bd, inbuf, len, fill);
1859 +       if (!i) {
1860 +               for (;;) {
1861 +                       i = read_bunzip(bd, outbuf, BZIP2_IOBUF_SIZE);
1862 +                       if (i <= 0)
1863 +                               break;
1864 +                       if (!flush)
1865 +                               outbuf += i;
1866 +                       else
1867 +                               if (i != flush(outbuf, i)) {
1868 +                                       i = RETVAL_UNEXPECTED_OUTPUT_EOF;
1869 +                                       break;
1870 +                               }
1871 +               }
1872 +       }
1873 +       /* Check CRC and release memory */
1874 +       if (i == RETVAL_LAST_BLOCK) {
1875 +               if (bd->headerCRC != bd->totalCRC)
1876 +                       error("Data integrity error when decompressing.");
1877 +               else
1878 +                       i = RETVAL_OK;
1879 +       } else if (i == RETVAL_UNEXPECTED_OUTPUT_EOF) {
1880 +               error("Compressed file ends unexpectedly");
1881 +       }
1882 +       if (bd->dbuf)
1883 +               large_free(bd->dbuf);
1884 +       if (pos)
1885 +               *pos = bd->inbufPos;
1886 +       free(bd);
1887 +       if (!buf)
1888 +               free(inbuf);
1889 +exit_0:
1890 +       if (flush)
1891 +               free(outbuf);
1892 +       return i;
1893 +}
1894 +
1895 +#define decompress bunzip2
1896 --- /dev/null
1897 +++ b/lib/decompress_unlzma.c
1898 @@ -0,0 +1,647 @@
1899 +/* Lzma decompressor for Linux kernel. Shamelessly snarfed
1900 + *from busybox 1.1.1
1901 + *
1902 + *Linux kernel adaptation
1903 + *Copyright (C) 2006  Alain < alain@knaff.lu >
1904 + *
1905 + *Based on small lzma deflate implementation/Small range coder
1906 + *implementation for lzma.
1907 + *Copyright (C) 2006  Aurelien Jacobs < aurel@gnuage.org >
1908 + *
1909 + *Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
1910 + *Copyright (C) 1999-2005  Igor Pavlov
1911 + *
1912 + *Copyrights of the parts, see headers below.
1913 + *
1914 + *
1915 + *This program is free software; you can redistribute it and/or
1916 + *modify it under the terms of the GNU Lesser General Public
1917 + *License as published by the Free Software Foundation; either
1918 + *version 2.1 of the License, or (at your option) any later version.
1919 + *
1920 + *This program is distributed in the hope that it will be useful,
1921 + *but WITHOUT ANY WARRANTY; without even the implied warranty of
1922 + *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1923 + *Lesser General Public License for more details.
1924 + *
1925 + *You should have received a copy of the GNU Lesser General Public
1926 + *License along with this library; if not, write to the Free Software
1927 + *Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1928 + */
1929 +
1930 +#ifndef STATIC
1931 +#include <linux/decompress/unlzma.h>
1932 +#endif /* STATIC */
1933 +
1934 +#include <linux/decompress/mm.h>
1935 +
1936 +#define        MIN(a, b) (((a) < (b)) ? (a) : (b))
1937 +
1938 +static long long INIT read_int(unsigned char *ptr, int size)
1939 +{
1940 +       int i;
1941 +       long long ret = 0;
1942 +
1943 +       for (i = 0; i < size; i++)
1944 +               ret = (ret << 8) | ptr[size-i-1];
1945 +       return ret;
1946 +}
1947 +
1948 +#define ENDIAN_CONVERT(x) \
1949 +  x = (typeof(x))read_int((unsigned char *)&x, sizeof(x))
1950 +
1951 +
1952 +/* Small range coder implementation for lzma.
1953 + *Copyright (C) 2006  Aurelien Jacobs < aurel@gnuage.org >
1954 + *
1955 + *Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
1956 + *Copyright (c) 1999-2005  Igor Pavlov
1957 + */
1958 +
1959 +#include <linux/compiler.h>
1960 +
1961 +#define LZMA_IOBUF_SIZE        0x10000
1962 +
1963 +struct rc {
1964 +       int (*fill)(void*, unsigned int);
1965 +       uint8_t *ptr;
1966 +       uint8_t *buffer;
1967 +       uint8_t *buffer_end;
1968 +       int buffer_size;
1969 +       uint32_t code;
1970 +       uint32_t range;
1971 +       uint32_t bound;
1972 +};
1973 +
1974 +
1975 +#define RC_TOP_BITS 24
1976 +#define RC_MOVE_BITS 5
1977 +#define RC_MODEL_TOTAL_BITS 11
1978 +
1979 +
1980 +/* Called twice: once at startup and once in rc_normalize() */
1981 +static void INIT rc_read(struct rc *rc)
1982 +{
1983 +       rc->buffer_size = rc->fill((char *)rc->buffer, LZMA_IOBUF_SIZE);
1984 +       if (rc->buffer_size <= 0)
1985 +               error("unexpected EOF");
1986 +       rc->ptr = rc->buffer;
1987 +       rc->buffer_end = rc->buffer + rc->buffer_size;
1988 +}
1989 +
1990 +/* Called once */
1991 +static inline void INIT rc_init(struct rc *rc,
1992 +                                      int (*fill)(void*, unsigned int),
1993 +                                      char *buffer, int buffer_size)
1994 +{
1995 +       rc->fill = fill;
1996 +       rc->buffer = (uint8_t *)buffer;
1997 +       rc->buffer_size = buffer_size;
1998 +       rc->buffer_end = rc->buffer + rc->buffer_size;
1999 +       rc->ptr = rc->buffer;
2000 +
2001 +       rc->code = 0;
2002 +       rc->range = 0xFFFFFFFF;
2003 +}
2004 +
2005 +static inline void INIT rc_init_code(struct rc *rc)
2006 +{
2007 +       int i;
2008 +
2009 +       for (i = 0; i < 5; i++) {
2010 +               if (rc->ptr >= rc->buffer_end)
2011 +                       rc_read(rc);
2012 +               rc->code = (rc->code << 8) | *rc->ptr++;
2013 +       }
2014 +}
2015 +
2016 +
2017 +/* Called once. TODO: bb_maybe_free() */
2018 +static inline void INIT rc_free(struct rc *rc)
2019 +{
2020 +       free(rc->buffer);
2021 +}
2022 +
2023 +/* Called twice, but one callsite is in inline'd rc_is_bit_0_helper() */
2024 +static void INIT rc_do_normalize(struct rc *rc)
2025 +{
2026 +       if (rc->ptr >= rc->buffer_end)
2027 +               rc_read(rc);
2028 +       rc->range <<= 8;
2029 +       rc->code = (rc->code << 8) | *rc->ptr++;
2030 +}
2031 +static inline void INIT rc_normalize(struct rc *rc)
2032 +{
2033 +       if (rc->range < (1 << RC_TOP_BITS))
2034 +               rc_do_normalize(rc);
2035 +}
2036 +
2037 +/* Called 9 times */
2038 +/* Why rc_is_bit_0_helper exists?
2039 + *Because we want to always expose (rc->code < rc->bound) to optimizer
2040 + */
2041 +static inline uint32_t INIT rc_is_bit_0_helper(struct rc *rc, uint16_t *p)
2042 +{
2043 +       rc_normalize(rc);
2044 +       rc->bound = *p * (rc->range >> RC_MODEL_TOTAL_BITS);
2045 +       return rc->bound;
2046 +}
2047 +static inline int INIT rc_is_bit_0(struct rc *rc, uint16_t *p)
2048 +{
2049 +       uint32_t t = rc_is_bit_0_helper(rc, p);
2050 +       return rc->code < t;
2051 +}
2052 +
2053 +/* Called ~10 times, but very small, thus inlined */
2054 +static inline void INIT rc_update_bit_0(struct rc *rc, uint16_t *p)
2055 +{
2056 +       rc->range = rc->bound;
2057 +       *p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
2058 +}
2059 +static inline void rc_update_bit_1(struct rc *rc, uint16_t *p)
2060 +{
2061 +       rc->range -= rc->bound;
2062 +       rc->code -= rc->bound;
2063 +       *p -= *p >> RC_MOVE_BITS;
2064 +}
2065 +
2066 +/* Called 4 times in unlzma loop */
2067 +static int INIT rc_get_bit(struct rc *rc, uint16_t *p, int *symbol)
2068 +{
2069 +       if (rc_is_bit_0(rc, p)) {
2070 +               rc_update_bit_0(rc, p);
2071 +               *symbol *= 2;
2072 +               return 0;
2073 +       } else {
2074 +               rc_update_bit_1(rc, p);
2075 +               *symbol = *symbol * 2 + 1;
2076 +               return 1;
2077 +       }
2078 +}
2079 +
2080 +/* Called once */
2081 +static inline int INIT rc_direct_bit(struct rc *rc)
2082 +{
2083 +       rc_normalize(rc);
2084 +       rc->range >>= 1;
2085 +       if (rc->code >= rc->range) {
2086 +               rc->code -= rc->range;
2087 +               return 1;
2088 +       }
2089 +       return 0;
2090 +}
2091 +
2092 +/* Called twice */
2093 +static inline void INIT
2094 +rc_bit_tree_decode(struct rc *rc, uint16_t *p, int num_levels, int *symbol)
2095 +{
2096 +       int i = num_levels;
2097 +
2098 +       *symbol = 1;
2099 +       while (i--)
2100 +               rc_get_bit(rc, p + *symbol, symbol);
2101 +       *symbol -= 1 << num_levels;
2102 +}
2103 +
2104 +
2105 +/*
2106 + * Small lzma deflate implementation.
2107 + * Copyright (C) 2006  Aurelien Jacobs < aurel@gnuage.org >
2108 + *
2109 + * Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
2110 + * Copyright (C) 1999-2005  Igor Pavlov
2111 + */
2112 +
2113 +
2114 +struct lzma_header {
2115 +       uint8_t pos;
2116 +       uint32_t dict_size;
2117 +       uint64_t dst_size;
2118 +} __attribute__ ((packed)) ;
2119 +
2120 +
2121 +#define LZMA_BASE_SIZE 1846
2122 +#define LZMA_LIT_SIZE 768
2123 +
2124 +#define LZMA_NUM_POS_BITS_MAX 4
2125 +
2126 +#define LZMA_LEN_NUM_LOW_BITS 3
2127 +#define LZMA_LEN_NUM_MID_BITS 3
2128 +#define LZMA_LEN_NUM_HIGH_BITS 8
2129 +
2130 +#define LZMA_LEN_CHOICE 0
2131 +#define LZMA_LEN_CHOICE_2 (LZMA_LEN_CHOICE + 1)
2132 +#define LZMA_LEN_LOW (LZMA_LEN_CHOICE_2 + 1)
2133 +#define LZMA_LEN_MID (LZMA_LEN_LOW \
2134 +                     + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS)))
2135 +#define LZMA_LEN_HIGH (LZMA_LEN_MID \
2136 +                      +(1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS)))
2137 +#define LZMA_NUM_LEN_PROBS (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS))
2138 +
2139 +#define LZMA_NUM_STATES 12
2140 +#define LZMA_NUM_LIT_STATES 7
2141 +
2142 +#define LZMA_START_POS_MODEL_INDEX 4
2143 +#define LZMA_END_POS_MODEL_INDEX 14
2144 +#define LZMA_NUM_FULL_DISTANCES (1 << (LZMA_END_POS_MODEL_INDEX >> 1))
2145 +
2146 +#define LZMA_NUM_POS_SLOT_BITS 6
2147 +#define LZMA_NUM_LEN_TO_POS_STATES 4
2148 +
2149 +#define LZMA_NUM_ALIGN_BITS 4
2150 +
2151 +#define LZMA_MATCH_MIN_LEN 2
2152 +
2153 +#define LZMA_IS_MATCH 0
2154 +#define LZMA_IS_REP (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
2155 +#define LZMA_IS_REP_G0 (LZMA_IS_REP + LZMA_NUM_STATES)
2156 +#define LZMA_IS_REP_G1 (LZMA_IS_REP_G0 + LZMA_NUM_STATES)
2157 +#define LZMA_IS_REP_G2 (LZMA_IS_REP_G1 + LZMA_NUM_STATES)
2158 +#define LZMA_IS_REP_0_LONG (LZMA_IS_REP_G2 + LZMA_NUM_STATES)
2159 +#define LZMA_POS_SLOT (LZMA_IS_REP_0_LONG \
2160 +                      + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
2161 +#define LZMA_SPEC_POS (LZMA_POS_SLOT \
2162 +                      +(LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS))
2163 +#define LZMA_ALIGN (LZMA_SPEC_POS \
2164 +                   + LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX)
2165 +#define LZMA_LEN_CODER (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS))
2166 +#define LZMA_REP_LEN_CODER (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS)
2167 +#define LZMA_LITERAL (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS)
2168 +
2169 +
2170 +struct writer {
2171 +       uint8_t *buffer;
2172 +       uint8_t previous_byte;
2173 +       size_t buffer_pos;
2174 +       int bufsize;
2175 +       size_t global_pos;
2176 +       int(*flush)(void*, unsigned int);
2177 +       struct lzma_header *header;
2178 +};
2179 +
2180 +struct cstate {
2181 +       int state;
2182 +       uint32_t rep0, rep1, rep2, rep3;
2183 +};
2184 +
2185 +static inline size_t INIT get_pos(struct writer *wr)
2186 +{
2187 +       return
2188 +               wr->global_pos + wr->buffer_pos;
2189 +}
2190 +
2191 +static inline uint8_t INIT peek_old_byte(struct writer *wr,
2192 +                                               uint32_t offs)
2193 +{
2194 +       if (!wr->flush) {
2195 +               int32_t pos;
2196 +               while (offs > wr->header->dict_size)
2197 +                       offs -= wr->header->dict_size;
2198 +               pos = wr->buffer_pos - offs;
2199 +               return wr->buffer[pos];
2200 +       } else {
2201 +               uint32_t pos = wr->buffer_pos - offs;
2202 +               while (pos >= wr->header->dict_size)
2203 +                       pos += wr->header->dict_size;
2204 +               return wr->buffer[pos];
2205 +       }
2206 +
2207 +}
2208 +
2209 +static inline void INIT write_byte(struct writer *wr, uint8_t byte)
2210 +{
2211 +       wr->buffer[wr->buffer_pos++] = wr->previous_byte = byte;
2212 +       if (wr->flush && wr->buffer_pos == wr->header->dict_size) {
2213 +               wr->buffer_pos = 0;
2214 +               wr->global_pos += wr->header->dict_size;
2215 +               wr->flush((char *)wr->buffer, wr->header->dict_size);
2216 +       }
2217 +}
2218 +
2219 +
2220 +static inline void INIT copy_byte(struct writer *wr, uint32_t offs)
2221 +{
2222 +       write_byte(wr, peek_old_byte(wr, offs));
2223 +}
2224 +
2225 +static inline void INIT copy_bytes(struct writer *wr,
2226 +                                        uint32_t rep0, int len)
2227 +{
2228 +       do {
2229 +               copy_byte(wr, rep0);
2230 +               len--;
2231 +       } while (len != 0 && wr->buffer_pos < wr->header->dst_size);
2232 +}
2233 +
2234 +static inline void INIT process_bit0(struct writer *wr, struct rc *rc,
2235 +                                    struct cstate *cst, uint16_t *p,
2236 +                                    int pos_state, uint16_t *prob,
2237 +                                    int lc, uint32_t literal_pos_mask) {
2238 +       int mi = 1;
2239 +       rc_update_bit_0(rc, prob);
2240 +       prob = (p + LZMA_LITERAL +
2241 +               (LZMA_LIT_SIZE
2242 +                * (((get_pos(wr) & literal_pos_mask) << lc)
2243 +                   + (wr->previous_byte >> (8 - lc))))
2244 +               );
2245 +
2246 +       if (cst->state >= LZMA_NUM_LIT_STATES) {
2247 +               int match_byte = peek_old_byte(wr, cst->rep0);
2248 +               do {
2249 +                       int bit;
2250 +                       uint16_t *prob_lit;
2251 +
2252 +                       match_byte <<= 1;
2253 +                       bit = match_byte & 0x100;
2254 +                       prob_lit = prob + 0x100 + bit + mi;
2255 +                       if (rc_get_bit(rc, prob_lit, &mi)) {
2256 +                               if (!bit)
2257 +                                       break;
2258 +                       } else {
2259 +                               if (bit)
2260 +                                       break;
2261 +                       }
2262 +               } while (mi < 0x100);
2263 +       }
2264 +       while (mi < 0x100) {
2265 +               uint16_t *prob_lit = prob + mi;
2266 +               rc_get_bit(rc, prob_lit, &mi);
2267 +       }
2268 +       write_byte(wr, mi);
2269 +       if (cst->state < 4)
2270 +               cst->state = 0;
2271 +       else if (cst->state < 10)
2272 +               cst->state -= 3;
2273 +       else
2274 +               cst->state -= 6;
2275 +}
2276 +
2277 +static inline void INIT process_bit1(struct writer *wr, struct rc *rc,
2278 +                                           struct cstate *cst, uint16_t *p,
2279 +                                           int pos_state, uint16_t *prob) {
2280 +  int offset;
2281 +       uint16_t *prob_len;
2282 +       int num_bits;
2283 +       int len;
2284 +
2285 +       rc_update_bit_1(rc, prob);
2286 +       prob = p + LZMA_IS_REP + cst->state;
2287 +       if (rc_is_bit_0(rc, prob)) {
2288 +               rc_update_bit_0(rc, prob);
2289 +               cst->rep3 = cst->rep2;
2290 +               cst->rep2 = cst->rep1;
2291 +               cst->rep1 = cst->rep0;
2292 +               cst->state = cst->state < LZMA_NUM_LIT_STATES ? 0 : 3;
2293 +               prob = p + LZMA_LEN_CODER;
2294 +       } else {
2295 +               rc_update_bit_1(rc, prob);
2296 +               prob = p + LZMA_IS_REP_G0 + cst->state;
2297 +               if (rc_is_bit_0(rc, prob)) {
2298 +                       rc_update_bit_0(rc, prob);
2299 +                       prob = (p + LZMA_IS_REP_0_LONG
2300 +                               + (cst->state <<
2301 +                                  LZMA_NUM_POS_BITS_MAX) +
2302 +                               pos_state);
2303 +                       if (rc_is_bit_0(rc, prob)) {
2304 +                               rc_update_bit_0(rc, prob);
2305 +
2306 +                               cst->state = cst->state < LZMA_NUM_LIT_STATES ?
2307 +                                       9 : 11;
2308 +                               copy_byte(wr, cst->rep0);
2309 +                               return;
2310 +                       } else {
2311 +                               rc_update_bit_1(rc, prob);
2312 +                       }
2313 +               } else {
2314 +                       uint32_t distance;
2315 +
2316 +                       rc_update_bit_1(rc, prob);
2317 +                       prob = p + LZMA_IS_REP_G1 + cst->state;
2318 +                       if (rc_is_bit_0(rc, prob)) {
2319 +                               rc_update_bit_0(rc, prob);
2320 +                               distance = cst->rep1;
2321 +                       } else {
2322 +                               rc_update_bit_1(rc, prob);
2323 +                               prob = p + LZMA_IS_REP_G2 + cst->state;
2324 +                               if (rc_is_bit_0(rc, prob)) {
2325 +                                       rc_update_bit_0(rc, prob);
2326 +                                       distance = cst->rep2;
2327 +                               } else {
2328 +                                       rc_update_bit_1(rc, prob);
2329 +                                       distance = cst->rep3;
2330 +                                       cst->rep3 = cst->rep2;
2331 +                               }
2332 +                               cst->rep2 = cst->rep1;
2333 +                       }
2334 +                       cst->rep1 = cst->rep0;
2335 +                       cst->rep0 = distance;
2336 +               }
2337 +               cst->state = cst->state < LZMA_NUM_LIT_STATES ? 8 : 11;
2338 +               prob = p + LZMA_REP_LEN_CODER;
2339 +       }
2340 +
2341 +       prob_len = prob + LZMA_LEN_CHOICE;
2342 +       if (rc_is_bit_0(rc, prob_len)) {
2343 +               rc_update_bit_0(rc, prob_len);
2344 +               prob_len = (prob + LZMA_LEN_LOW
2345 +                           + (pos_state <<
2346 +                              LZMA_LEN_NUM_LOW_BITS));
2347 +               offset = 0;
2348 +               num_bits = LZMA_LEN_NUM_LOW_BITS;
2349 +       } else {
2350 +               rc_update_bit_1(rc, prob_len);
2351 +               prob_len = prob + LZMA_LEN_CHOICE_2;
2352 +               if (rc_is_bit_0(rc, prob_len)) {
2353 +                       rc_update_bit_0(rc, prob_len);
2354 +                       prob_len = (prob + LZMA_LEN_MID
2355 +                                   + (pos_state <<
2356 +                                      LZMA_LEN_NUM_MID_BITS));
2357 +                       offset = 1 << LZMA_LEN_NUM_LOW_BITS;
2358 +                       num_bits = LZMA_LEN_NUM_MID_BITS;
2359 +               } else {
2360 +                       rc_update_bit_1(rc, prob_len);
2361 +                       prob_len = prob + LZMA_LEN_HIGH;
2362 +                       offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
2363 +                                 + (1 << LZMA_LEN_NUM_MID_BITS));
2364 +                       num_bits = LZMA_LEN_NUM_HIGH_BITS;
2365 +               }
2366 +       }
2367 +
2368 +       rc_bit_tree_decode(rc, prob_len, num_bits, &len);
2369 +       len += offset;
2370 +
2371 +       if (cst->state < 4) {
2372 +               int pos_slot;
2373 +
2374 +               cst->state += LZMA_NUM_LIT_STATES;
2375 +               prob =
2376 +                       p + LZMA_POS_SLOT +
2377 +                       ((len <
2378 +                         LZMA_NUM_LEN_TO_POS_STATES ? len :
2379 +                         LZMA_NUM_LEN_TO_POS_STATES - 1)
2380 +                        << LZMA_NUM_POS_SLOT_BITS);
2381 +               rc_bit_tree_decode(rc, prob,
2382 +                                  LZMA_NUM_POS_SLOT_BITS,
2383 +                                  &pos_slot);
2384 +               if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
2385 +                       int i, mi;
2386 +                       num_bits = (pos_slot >> 1) - 1;
2387 +                       cst->rep0 = 2 | (pos_slot & 1);
2388 +                       if (pos_slot < LZMA_END_POS_MODEL_INDEX) {
2389 +                               cst->rep0 <<= num_bits;
2390 +                               prob = p + LZMA_SPEC_POS +
2391 +                                       cst->rep0 - pos_slot - 1;
2392 +                       } else {
2393 +                               num_bits -= LZMA_NUM_ALIGN_BITS;
2394 +                               while (num_bits--)
2395 +                                       cst->rep0 = (cst->rep0 << 1) |
2396 +                                               rc_direct_bit(rc);
2397 +                               prob = p + LZMA_ALIGN;
2398 +                               cst->rep0 <<= LZMA_NUM_ALIGN_BITS;
2399 +                               num_bits = LZMA_NUM_ALIGN_BITS;
2400 +                       }
2401 +                       i = 1;
2402 +                       mi = 1;
2403 +                       while (num_bits--) {
2404 +                               if (rc_get_bit(rc, prob + mi, &mi))
2405 +                                       cst->rep0 |= i;
2406 +                               i <<= 1;
2407 +                       }
2408 +               } else
2409 +                       cst->rep0 = pos_slot;
2410 +               if (++(cst->rep0) == 0)
2411 +                       return;
2412 +       }
2413 +
2414 +       len += LZMA_MATCH_MIN_LEN;
2415 +
2416 +       copy_bytes(wr, cst->rep0, len);
2417 +}
2418 +
2419 +
2420 +
2421 +STATIC inline int INIT unlzma(unsigned char *buf, int in_len,
2422 +                             int(*fill)(void*, unsigned int),
2423 +                             int(*flush)(void*, unsigned int),
2424 +                             unsigned char *output,
2425 +                             int *posp,
2426 +                             void(*error_fn)(char *x)
2427 +       )
2428 +{
2429 +       struct lzma_header header;
2430 +       int lc, pb, lp;
2431 +       uint32_t pos_state_mask;
2432 +       uint32_t literal_pos_mask;
2433 +       uint16_t *p;
2434 +       int num_probs;
2435 +       struct rc rc;
2436 +       int i, mi;
2437 +       struct writer wr;
2438 +       struct cstate cst;
2439 +       unsigned char *inbuf;
2440 +       int ret = -1;
2441 +
2442 +       set_error_fn(error_fn);
2443 +       if (!flush)
2444 +               in_len -= 4; /* Uncompressed size hack active in pre-boot
2445 +                               environment */
2446 +       if (buf)
2447 +               inbuf = buf;
2448 +       else
2449 +               inbuf = malloc(LZMA_IOBUF_SIZE);
2450 +       if (!inbuf) {
2451 +               error("Could not allocate input bufer");
2452 +               goto exit_0;
2453 +       }
2454 +
2455 +       cst.state = 0;
2456 +       cst.rep0 = cst.rep1 = cst.rep2 = cst.rep3 = 1;
2457 +
2458 +       wr.header = &header;
2459 +       wr.flush = flush;
2460 +       wr.global_pos = 0;
2461 +       wr.previous_byte = 0;
2462 +       wr.buffer_pos = 0;
2463 +
2464 +       rc_init(&rc, fill, inbuf, in_len);
2465 +
2466 +       for (i = 0; i < sizeof(header); i++) {
2467 +               if (rc.ptr >= rc.buffer_end)
2468 +                       rc_read(&rc);
2469 +               ((unsigned char *)&header)[i] = *rc.ptr++;
2470 +       }
2471 +
2472 +       if (header.pos >= (9 * 5 * 5))
2473 +               error("bad header");
2474 +
2475 +       mi = 0;
2476 +       lc = header.pos;
2477 +       while (lc >= 9) {
2478 +               mi++;
2479 +               lc -= 9;
2480 +       }
2481 +       pb = 0;
2482 +       lp = mi;
2483 +       while (lp >= 5) {
2484 +               pb++;
2485 +               lp -= 5;
2486 +       }
2487 +       pos_state_mask = (1 << pb) - 1;
2488 +       literal_pos_mask = (1 << lp) - 1;
2489 +
2490 +       ENDIAN_CONVERT(header.dict_size);
2491 +       ENDIAN_CONVERT(header.dst_size);
2492 +
2493 +       if (header.dict_size == 0)
2494 +               header.dict_size = 1;
2495 +
2496 +       if (output)
2497 +               wr.buffer = output;
2498 +       else {
2499 +               wr.bufsize = MIN(header.dst_size, header.dict_size);
2500 +               wr.buffer = large_malloc(wr.bufsize);
2501 +       }
2502 +       if (wr.buffer == NULL)
2503 +               goto exit_1;
2504 +
2505 +       num_probs = LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp));
2506 +       p = (uint16_t *) large_malloc(num_probs * sizeof(*p));
2507 +       if (p == 0)
2508 +               goto exit_2;
2509 +       num_probs = LZMA_LITERAL + (LZMA_LIT_SIZE << (lc + lp));
2510 +       for (i = 0; i < num_probs; i++)
2511 +               p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
2512 +
2513 +       rc_init_code(&rc);
2514 +
2515 +       while (get_pos(&wr) < header.dst_size) {
2516 +               int pos_state = get_pos(&wr) & pos_state_mask;
2517 +               uint16_t *prob = p + LZMA_IS_MATCH +
2518 +                       (cst.state << LZMA_NUM_POS_BITS_MAX) + pos_state;
2519 +               if (rc_is_bit_0(&rc, prob))
2520 +                       process_bit0(&wr, &rc, &cst, p, pos_state, prob,
2521 +                                    lc, literal_pos_mask);
2522 +               else {
2523 +                       process_bit1(&wr, &rc, &cst, p, pos_state, prob);
2524 +                       if (cst.rep0 == 0)
2525 +                               break;
2526 +               }
2527 +       }
2528 +
2529 +       if (posp)
2530 +               *posp = rc.ptr-rc.buffer;
2531 +       if (wr.flush)
2532 +               wr.flush(wr.buffer, wr.buffer_pos);
2533 +       ret = 0;
2534 +       large_free(p);
2535 +exit_2:
2536 +       if (!output)
2537 +               large_free(wr.buffer);
2538 +exit_1:
2539 +       if (!buf)
2540 +               free(inbuf);
2541 +exit_0:
2542 +       return ret;
2543 +}
2544 +
2545 +#define decompress unlzma
2546 --- a/lib/inflate.c
2547 +++ b/lib/inflate.c
2548 @@ -109,20 +109,78 @@ static char rcsid[] = "#Id: inflate.c,v
2549  #endif
2550
2551  #ifndef STATIC
2552 +#include <linux/decompress/inflate.h>
2553 +#endif /* ! STATIC */
2554
2555 -#if defined(STDC_HEADERS) || defined(HAVE_STDLIB_H)
2556 -#  include <sys/types.h>
2557 -#  include <stdlib.h>
2558 +#include <linux/decompress/mm.h>
2559 +
2560 +#include <linux/string.h>
2561 +
2562 +#ifdef NEW_CODE
2563 +static int(*flush_cb)(void*, unsigned int);
2564 +static int(*fill_cb)(void*, unsigned int);
2565 +
2566 +/* Begin stuff copied from initramfs */
2567 +/*
2568 + * gzip declarations
2569 + */
2570 +
2571 +#define OF(args)  args
2572 +
2573 +#ifndef memzero
2574 +#define memzero(s, n)     memset((s), 0, (n))
2575  #endif
2576
2577 -#include "gzip.h"
2578 -#define STATIC
2579 -#endif /* !STATIC */
2580 +#define INBUFSIZ 4096
2581 +
2582 +#define WSIZE 0x8000    /* window size--must be a power of two, and */
2583 +                       /*  at least 32K for zip's deflate method */
2584 +
2585 +static uint8_t *inbuf;
2586 +static uint8_t *window;
2587 +
2588 +static unsigned insize;  /* valid bytes in inbuf */
2589 +static unsigned outcnt;  /* bytes in output buffer */
2590 +static long bytes_out;
2591 +
2592 +/* --- */
2593 +
2594 +static unsigned inptr;   /* index of next byte to be processed in inbuf */
2595 +
2596 +/* --- */
2597 +
2598 +/* ===========================================================================
2599 + * Fill the input buffer. This is called only when the buffer is empty
2600 + * and at least one byte is really needed.
2601 + * Returning -1 does not guarantee that gunzip() will ever return.
2602 + */
2603 +static int INIT fill_inbuf(void)
2604 +{
2605 +       insize = fill_cb(inbuf, INBUFSIZ);
2606 +       if (insize <= 0) {
2607 +               error("RAMDISK: ran out of compressed data");
2608 +               return -1;
2609 +       }
2610 +
2611 +       inptr = 1;
2612 +
2613 +       return inbuf[0];
2614 +}
2615 +
2616 +#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
2617 +
2618 +/* Diagnostic functions (stubbed out) */
2619 +#define Assert(cond, msg)
2620 +#define Trace(x)
2621 +#define Tracev(x)
2622 +#define Tracevv(x)
2623 +#define Tracec(c, x)
2624 +#define Tracecv(c, x)
2625
2626 -#ifndef INIT
2627 -#define INIT
2628 +static void flush_window(void);
2629 +/* End stuff copied from initramfs */
2630  #endif
2631 -
2632 +
2633  #define slide window
2634
2635  /* Huffman code lookup table entry--this entry is four bytes for machines
2636 @@ -133,10 +191,10 @@ static char rcsid[] = "#Id: inflate.c,v
2637     an unused code.  If a code with e == 99 is looked up, this implies an
2638     error in the data. */
2639  struct huft {
2640 -  uch e;                /* number of extra bits or operation */
2641 -  uch b;                /* number of bits in this code or subcode */
2642 +  uint8_t e;                /* number of extra bits or operation */
2643 +  uint8_t b;                /* number of bits in this code or subcode */
2644    union {
2645 -    ush n;              /* literal, length base, or distance base */
2646 +    uint16_t n;              /* literal, length base, or distance base */
2647      struct huft *t;     /* pointer to next level of table */
2648    } v;
2649  };
2650 @@ -144,7 +202,7 @@ struct huft {
2651
2652  /* Function prototypes */
2653  STATIC int INIT huft_build OF((unsigned *, unsigned, unsigned,
2654 -               const ush *, const ush *, struct huft **, int *));
2655 +               const uint16_t *, const uint16_t *, struct huft **, int *));
2656  STATIC int INIT huft_free OF((struct huft *));
2657  STATIC int INIT inflate_codes OF((struct huft *, struct huft *, int, int));
2658  STATIC int INIT inflate_stored OF((void));
2659 @@ -159,28 +217,28 @@ STATIC int INIT inflate OF((void));
2660     circular buffer.  The index is updated simply by incrementing and then
2661     ANDing with 0x7fff (32K-1). */
2662  /* It is left to other modules to supply the 32 K area.  It is assumed
2663 -   to be usable as if it were declared "uch slide[32768];" or as just
2664 -   "uch *slide;" and then malloc'ed in the latter case.  The definition
2665 +   to be usable as if it were declared "uint8_t slide[32768];" or as just
2666 +   "uint8_t *slide;" and then malloc'ed in the latter case.  The definition
2667     must be in unzip.h, included above. */
2668  /* unsigned wp;             current position in slide */
2669  #define wp outcnt
2670  #define flush_output(w) (wp=(w),flush_window())
2671
2672  /* Tables for deflate from PKZIP's appnote.txt. */
2673 -static const unsigned border[] = {    /* Order of the bit length code lengths */
2674 +static const unsigned border[] = {   /* Order of the bit length code lengths */
2675          16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
2676 -static const ush cplens[] = {         /* Copy lengths for literal codes 257..285 */
2677 +static const uint16_t cplens[] = { /* Copy lengths for literal codes 257..285 */
2678          3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
2679          35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
2680          /* note: see note #13 above about the 258 in this list. */
2681 -static const ush cplext[] = {         /* Extra bits for literal codes 257..285 */
2682 +static const uint16_t cplext[] = {   /* Extra bits for literal codes 257..285 */
2683          0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
2684          3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */
2685 -static const ush cpdist[] = {         /* Copy offsets for distance codes 0..29 */
2686 +static const uint16_t cpdist[] = {   /* Copy offsets for distance codes 0..29 */
2687          1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
2688          257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
2689          8193, 12289, 16385, 24577};
2690 -static const ush cpdext[] = {         /* Extra bits for distance codes */
2691 +static const uint16_t cpdext[] = {   /* Extra bits for distance codes */
2692          0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
2693          7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
2694          12, 12, 13, 13};
2695 @@ -217,59 +275,21 @@ static const ush cpdext[] = {         /*
2696     the stream.
2697   */
2698
2699 -STATIC ulg bb;                         /* bit buffer */
2700 +STATIC uint32_t bb;                         /* bit buffer */
2701  STATIC unsigned bk;                    /* bits in bit buffer */
2702
2703 -STATIC const ush mask_bits[] = {
2704 +STATIC const uint16_t mask_bits[] = {
2705      0x0000,
2706      0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
2707      0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
2708  };
2709
2710 -#define NEXTBYTE()  ({ int v = get_byte(); if (v < 0) goto underrun; (uch)v; })
2711 -#define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE())<<k;k+=8;}}
2712 +#define NEXTBYTE()  ({ int v = get_byte(); if (v < 0) goto underrun; \
2713 +                       (uint8_t)v; })
2714 +#define NEEDBITS(n) {while (k < (n)) \
2715 +                       {b |= ((uint32_t)NEXTBYTE())<<k; k += 8; } }
2716  #define DUMPBITS(n) {b>>=(n);k-=(n);}
2717
2718 -#ifndef NO_INFLATE_MALLOC
2719 -/* A trivial malloc implementation, adapted from
2720 - *  malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
2721 - */
2722 -
2723 -static unsigned long malloc_ptr;
2724 -static int malloc_count;
2725 -
2726 -static void *malloc(int size)
2727 -{
2728 -       void *p;
2729 -
2730 -       if (size < 0)
2731 -               error("Malloc error");
2732 -       if (!malloc_ptr)
2733 -               malloc_ptr = free_mem_ptr;
2734 -
2735 -       malloc_ptr = (malloc_ptr + 3) & ~3;     /* Align */
2736 -
2737 -       p = (void *)malloc_ptr;
2738 -       malloc_ptr += size;
2739 -
2740 -       if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
2741 -               error("Out of memory");
2742 -
2743 -       malloc_count++;
2744 -       return p;
2745 -}
2746 -
2747 -static void free(void *where)
2748 -{
2749 -       malloc_count--;
2750 -       if (!malloc_count)
2751 -               malloc_ptr = free_mem_ptr;
2752 -}
2753 -#else
2754 -#define malloc(a) kmalloc(a, GFP_KERNEL)
2755 -#define free(a) kfree(a)
2756 -#endif
2757 -
2758  /*
2759     Huffman code decoding is performed using a multi-level table lookup.
2760     The fastest way to decode is to simply build a lookup table whose
2761 @@ -307,7 +327,7 @@ STATIC const int lbits = 9;          /*
2762  STATIC const int dbits = 6;          /* bits in base distance lookup table */
2763
2764
2765 -/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
2766 +/* If BMAX needs to be larger than 16, then h and x[] should be uint32_t. */
2767  #define BMAX 16         /* maximum bit length of any code (16 for explode) */
2768  #define N_MAX 288       /* maximum number of codes in any set */
2769
2770 @@ -319,8 +339,8 @@ STATIC int INIT huft_build(
2771         unsigned *b,            /* code lengths in bits (all assumed <= BMAX) */
2772         unsigned n,             /* number of codes (assumed <= N_MAX) */
2773         unsigned s,             /* number of simple-valued codes (0..s-1) */
2774 -       const ush *d,           /* list of base values for non-simple codes */
2775 -       const ush *e,           /* list of extra bits for non-simple codes */
2776 +       const uint16_t *d,      /* list of base values for non-simple codes */
2777 +       const uint16_t *e,      /* list of extra bits for non-simple codes */
2778         struct huft **t,        /* result: starting table */
2779         int *m                  /* maximum lookup bits, returns actual */
2780         )
2781 @@ -500,8 +520,8 @@ DEBG1("5 ");
2782          if (h)
2783          {
2784            x[h] = i;             /* save pattern for backing up */
2785 -          r.b = (uch)l;         /* bits to dump before this table */
2786 -          r.e = (uch)(16 + j);  /* bits in this table */
2787 +         r.b = (uint8_t)l;         /* bits to dump before this table */
2788 +         r.e = (uint8_t)(16 + j);  /* bits in this table */
2789            r.v.t = q;            /* pointer to this table */
2790            j = i >> (w - l);     /* (get around Turbo C bug) */
2791            u[h-1][j] = r;        /* connect to last table */
2792 @@ -511,18 +531,18 @@ DEBG1("6 ");
2793  DEBG("h6c ");
2794
2795        /* set up table entry in r */
2796 -      r.b = (uch)(k - w);
2797 +      r.b = (uint8_t)(k - w);
2798        if (p >= v + n)
2799          r.e = 99;               /* out of values--invalid code */
2800        else if (*p < s)
2801        {
2802 -        r.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
2803 -        r.v.n = (ush)(*p);             /* simple code is just the value */
2804 +       r.e = (uint8_t)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
2805 +       r.v.n = (uint16_t)(*p);             /* simple code is just the value */
2806         p++;                           /* one compiler does not like *p++ */
2807        }
2808        else
2809        {
2810 -        r.e = (uch)e[*p - s];   /* non-simple--look up in lists */
2811 +       r.e = (uint8_t)e[*p - s];   /* non-simple--look up in lists */
2812          r.v.n = d[*p++ - s];
2813        }
2814  DEBG("h6d ");
2815 @@ -592,11 +612,12 @@ STATIC int INIT inflate_codes(
2816     Return an error code or zero if it all goes ok. */
2817  {
2818    register unsigned e;  /* table entry flag/number of extra bits */
2819 -  unsigned n, d;        /* length and index for copy */
2820 +  unsigned n;
2821 +  int d;              /* source index for copy */
2822    unsigned w;           /* current window position */
2823    struct huft *t;       /* pointer to table entry */
2824    unsigned ml, md;      /* masks for bl and bd bits */
2825 -  register ulg b;       /* bit buffer */
2826 +  register uint32_t b;       /* bit buffer */
2827    register unsigned k;  /* number of bits in bit buffer */
2828
2829
2830 @@ -622,7 +643,7 @@ STATIC int INIT inflate_codes(
2831      DUMPBITS(t->b)
2832      if (e == 16)                /* then it's a literal */
2833      {
2834 -      slide[w++] = (uch)t->v.n;
2835 +      slide[w++] = (uint8_t)t->v.n;
2836        Tracevv((stderr, "%c", slide[w-1]));
2837        if (w == WSIZE)
2838        {
2839 @@ -659,11 +680,25 @@ STATIC int INIT inflate_codes(
2840
2841        /* do the copy */
2842        do {
2843 -        n -= (e = (e = WSIZE - ((d &= WSIZE-1) > w ? d : w)) > n ? n : e);
2844 +#ifdef NEW_CODE
2845 +       if (flush_cb) {
2846 +#endif
2847 +               /* Sliding window emulated using circular buffer:
2848 +                * manage wrap-around */
2849 +               e = WSIZE - ((d &= WSIZE-1) > w ? d : w);
2850 +               if (e > n)
2851 +                       e = n;
2852 +#ifdef NEW_CODE
2853 +       } else {
2854 +               e = n;
2855 +       }
2856 +#endif
2857 +       n -= e;
2858 +
2859  #if !defined(NOMEMCPY) && !defined(DEBUG)
2860          if (w - d >= e)         /* (this test assumes unsigned comparison) */
2861          {
2862 -          memcpy(slide + w, slide + d, e);
2863 +               memcpy(slide + w, slide + d, e);
2864            w += e;
2865            d += e;
2866          }
2867 @@ -673,9 +708,8 @@ STATIC int INIT inflate_codes(
2868              slide[w++] = slide[d++];
2869             Tracevv((stderr, "%c", slide[w-1]));
2870            } while (--e);
2871 -        if (w == WSIZE)
2872 -        {
2873 -          flush_output(w);
2874 +       if (w == WSIZE) {
2875 +         flush_output(w);
2876            w = 0;
2877          }
2878        } while (n);
2879 @@ -702,7 +736,7 @@ STATIC int INIT inflate_stored(void)
2880  {
2881    unsigned n;           /* number of bytes in block */
2882    unsigned w;           /* current window position */
2883 -  register ulg b;       /* bit buffer */
2884 +  register uint32_t b;       /* bit buffer */
2885    register unsigned k;  /* number of bits in bit buffer */
2886
2887  DEBG("<stor");
2888 @@ -732,7 +766,7 @@ DEBG("<stor");
2889    while (n--)
2890    {
2891      NEEDBITS(8)
2892 -    slide[w++] = (uch)b;
2893 +    slide[w++] = (uint8_t)b;
2894      if (w == WSIZE)
2895      {
2896        flush_output(w);
2897 @@ -838,7 +872,7 @@ STATIC int noinline INIT inflate_dynamic
2898    unsigned nl;          /* number of literal/length codes */
2899    unsigned nd;          /* number of distance codes */
2900    unsigned *ll;         /* literal/length and distance code lengths */
2901 -  register ulg b;       /* bit buffer */
2902 +  register uint32_t b;       /* bit buffer */
2903    register unsigned k;  /* number of bits in bit buffer */
2904    int ret;
2905
2906 @@ -1033,7 +1067,7 @@ STATIC int INIT inflate_block(
2907  /* decompress an inflated block */
2908  {
2909    unsigned t;           /* block type */
2910 -  register ulg b;       /* bit buffer */
2911 +  register uint32_t b;       /* bit buffer */
2912    register unsigned k;  /* number of bits in bit buffer */
2913
2914    DEBG("<blk");
2915 @@ -1130,8 +1164,8 @@ STATIC int INIT inflate(void)
2916   *
2917   **********************************************************************/
2918
2919 -static ulg crc_32_tab[256];
2920 -static ulg crc;                /* initialized in makecrc() so it'll reside in bss */
2921 +static uint32_t crc_32_tab[256];
2922 +static uint32_t crc;   /* initialized in makecrc() so it'll reside in bss */
2923  #define CRC_VALUE (crc ^ 0xffffffffUL)
2924
2925  /*
2926 @@ -1172,7 +1206,7 @@ makecrc(void)
2927    }
2928
2929    /* this is initialized here so this code could reside in ROM */
2930 -  crc = (ulg)0xffffffffUL; /* shift register contents */
2931 +  crc = (uint32_t)0xffffffffUL; /* shift register contents */
2932  }
2933
2934  /* gzip flag byte */
2935 @@ -1184,18 +1218,89 @@ makecrc(void)
2936  #define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
2937  #define RESERVED     0xC0 /* bit 6,7:   reserved */
2938
2939 +#ifdef NEW_CODE
2940 +/* ===========================================================================
2941 + * Write the output window window[0..outcnt-1] and update crc and bytes_out.
2942 + * (Used for the decompressed data only.)
2943 + */
2944 +static void INIT flush_window(void)
2945 +{
2946 +       uint32_t c = crc;         /* temporary variable */
2947 +       unsigned n;
2948 +       uint8_t *in, ch;
2949 +
2950 +       in = window;
2951 +       for (n = 0; n < outcnt; n++) {
2952 +               ch = *in++;
2953 +               c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
2954 +       }
2955 +       crc = c;
2956 +       bytes_out += (uint32_t)outcnt;
2957 +       if (flush_cb != NULL)
2958 +               flush_cb(window, outcnt); /* TODO: handle unzip_error */
2959 +       else
2960 +               window += outcnt;
2961 +       outcnt = 0;
2962 +}
2963 +
2964 +static int empty_fill(void *buf, unsigned int len)
2965 +{
2966 +       return 0;
2967 +}
2968 +#endif
2969 +
2970 +
2971  /*
2972   * Do the uncompression!
2973   */
2974 -static int INIT gunzip(void)
2975 +STATIC int INIT gunzip(
2976 +#ifdef NEW_CODE
2977 +                      unsigned char *buf, int len,
2978 +                      int(*fill)(void*, unsigned int),
2979 +                      int(*flush)(void*, unsigned int),
2980 +                      unsigned char *output,
2981 +                      int *posp,
2982 +                      void(*error_fn)(char *x)
2983 +#else
2984 +                      void
2985 +#endif
2986 +  )
2987  {
2988 -    uch flags;
2989 +    uint8_t flags;
2990      unsigned char magic[2]; /* magic header */
2991      char method;
2992 -    ulg orig_crc = 0;       /* original crc */
2993 -    ulg orig_len = 0;       /* original uncompressed length */
2994 +    uint32_t orig_crc = 0;       /* original crc */
2995 +    uint32_t orig_len = 0;       /* original uncompressed length */
2996      int res;
2997
2998 +#ifdef NEW_CODE
2999 +    set_error_fn(error_fn);
3000 +    if (fill == NULL)
3001 +           fill_cb = empty_fill;
3002 +    else
3003 +           fill_cb = fill;
3004 +    if (output)
3005 +           window = output;
3006 +    else {
3007 +           window = malloc(0x8000);
3008 +           if (!window)
3009 +                   panic("can't allocate buffers");
3010 +           flush_cb = flush;
3011 +    }
3012 +
3013 +    insize = len;
3014 +    if (buf)
3015 +           inbuf = buf;
3016 +    else
3017 +           inbuf = malloc(INBUFSIZ);
3018 +#endif
3019 +
3020 +    inptr = 0;
3021 +    outcnt = 0;                /* bytes in output buffer */
3022 +    bytes_out = 0;
3023 +    crc = (uint32_t)0xffffffffL; /* shift register contents */
3024 +    makecrc();
3025 +
3026      magic[0] = NEXTBYTE();
3027      magic[1] = NEXTBYTE();
3028      method   = NEXTBYTE();
3029 @@ -1212,7 +1317,7 @@ static int INIT gunzip(void)
3030             return -1;
3031      }
3032
3033 -    flags  = (uch)get_byte();
3034 +    flags  = (uint8_t)get_byte();
3035      if ((flags & ENCRYPTED) != 0) {
3036             error("Input is encrypted");
3037             return -1;
3038 @@ -1277,15 +1382,15 @@ static int INIT gunzip(void)
3039      /* crc32  (see algorithm.doc)
3040       * uncompressed input size modulo 2^32
3041       */
3042 -    orig_crc = (ulg) NEXTBYTE();
3043 -    orig_crc |= (ulg) NEXTBYTE() << 8;
3044 -    orig_crc |= (ulg) NEXTBYTE() << 16;
3045 -    orig_crc |= (ulg) NEXTBYTE() << 24;
3046 +    orig_crc = (uint32_t) NEXTBYTE();
3047 +    orig_crc |= (uint32_t) NEXTBYTE() << 8;
3048 +    orig_crc |= (uint32_t) NEXTBYTE() << 16;
3049 +    orig_crc |= (uint32_t) NEXTBYTE() << 24;
3050
3051 -    orig_len = (ulg) NEXTBYTE();
3052 -    orig_len |= (ulg) NEXTBYTE() << 8;
3053 -    orig_len |= (ulg) NEXTBYTE() << 16;
3054 -    orig_len |= (ulg) NEXTBYTE() << 24;
3055 +    orig_len = (uint32_t) NEXTBYTE();
3056 +    orig_len |= (uint32_t) NEXTBYTE() << 8;
3057 +    orig_len |= (uint32_t) NEXTBYTE() << 16;
3058 +    orig_len |= (uint32_t) NEXTBYTE() << 24;
3059
3060      /* Validate decompression */
3061      if (orig_crc != CRC_VALUE) {
3062 @@ -1296,11 +1401,22 @@ static int INIT gunzip(void)
3063             error("length error");
3064             return -1;
3065      }
3066 +#ifdef NEW_CODE
3067 +    if (!output)
3068 +           free(window);
3069 +    if (posp)
3070 +           *posp = inptr;
3071 +#endif
3072      return 0;
3073
3074   underrun:                     /* NEXTBYTE() goto's here if needed */
3075 +    free(window);
3076 +#ifdef NEW_CODE
3077 +    if (!buf)
3078 +           free(inbuf);
3079 +#endif
3080      error("out of input data");
3081      return -1;
3082  }
3083
3084 -
3085 +#define decompress gunzip
3086 --- a/scripts/Makefile.lib
3087 +++ b/scripts/Makefile.lib
3088 @@ -183,3 +183,17 @@ quiet_cmd_gzip = GZIP    $@
3089  cmd_gzip = gzip -f -9 < $< > $@
3090
3091
3092 +# Bzip2
3093 +# ---------------------------------------------------------------------------
3094 +
3095 +# Bzip2 does not include size in file... so we have to fake that
3096 +size_append=$(CONFIG_SHELL) $(srctree)/scripts/bin_size
3097 +
3098 +quiet_cmd_bzip2 = BZIP2    $@
3099 +cmd_bzip2 = (bzip2 -9 < $< ; $(size_append) $<) > $@ || (rm -f $@ ; false)
3100 +
3101 +# Lzma
3102 +# ---------------------------------------------------------------------------
3103 +
3104 +quiet_cmd_lzma = LZMA    $@
3105 +cmd_lzma = (/usr/bin/lzma -9 -c $< ; $(size_append) $<) >$@ || (rm -f $@ ; false)
3106 --- /dev/null
3107 +++ b/scripts/bin_size
3108 @@ -0,0 +1,10 @@
3109 +#!/bin/sh
3110 +
3111 +if [ $# = 0 ] ; then
3112 +   echo Usage: $0 file
3113 +fi
3114 +
3115 +size_dec=`stat -c "%s" $1`
3116 +size_hex_echo_string=`printf "%08x" $size_dec |
3117 +     sed 's/\(..\)\(..\)\(..\)\(..\)/\\\\x\4\\\\x\3\\\\x\2\\\\x\1/g'`
3118 +/bin/echo -ne $size_hex_echo_string