Merge branch 'linus' into x86/setup-lzma
authorIngo Molnar <mingo@elte.hu>
Sat, 10 Jan 2009 11:04:41 +0000 (12:04 +0100)
committerIngo Molnar <mingo@elte.hu>
Sat, 10 Jan 2009 11:04:41 +0000 (12:04 +0100)
Conflicts:
init/do_mounts_rd.c

1  2 
init/Kconfig
init/do_mounts_rd.c
init/initramfs.c

diff --combined init/Kconfig
index f9633c03cb121129922eab2c8fb3dd983cc53386,a724a149bf3f232aba760c6b584db3f52dfd7e32..a3e3bf548046d89f689ece21dbfa025177862c36
@@@ -101,66 -101,6 +101,66 @@@ config LOCALVERSION_AUT
  
          which is done within the script "scripts/setlocalversion".)
  
 +config HAVE_KERNEL_GZIP
 +      bool
 +
 +config HAVE_KERNEL_BZIP2
 +      bool
 +
 +config HAVE_KERNEL_LZMA
 +      bool
 +
 +choice
 +      prompt "Kernel compression mode"
 +      default KERNEL_GZIP
 +      depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA
 +      help
 +        The linux kernel is a kind of self-extracting executable.
 +        Several compression algorithms are available, which differ
 +        in efficiency, compression and decompression speed.
 +        Compression speed is only relevant when building a kernel.
 +        Decompression speed is relevant at each boot.
 +
 +        If you have any problems with bzip2 or lzma compressed
 +        kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older
 +        version of this functionality (bzip2 only), for 2.4, was
 +        supplied by Christian Ludwig)
 +
 +        High compression options are mostly useful for users, who
 +        are low on disk space (embedded systems), but for whom ram
 +        size matters less.
 +
 +        If in doubt, select 'gzip'
 +
 +config KERNEL_GZIP
 +      bool "Gzip"
 +      depends on HAVE_KERNEL_GZIP
 +      help
 +        The old and tried gzip compression. Its compression ratio is
 +        the poorest among the 3 choices; however its speed (both
 +        compression and decompression) is the fastest.
 +
 +config KERNEL_BZIP2
 +      bool "Bzip2"
 +      depends on HAVE_KERNEL_BZIP2
 +      help
 +        Its compression ratio and speed is intermediate.
 +        Decompression speed is slowest among the three.  The kernel
 +        size is about 10% smaller with bzip2, in comparison to gzip.
 +        Bzip2 uses a large amount of memory. For modern kernels you
 +        will need at least 8MB RAM or more for booting.
 +
 +config KERNEL_LZMA
 +      bool "LZMA"
 +      depends on HAVE_KERNEL_LZMA
 +      help
 +        The most recent compression algorithm.
 +        Its ratio is best, decompression speed is between the other
 +        two. Compression is slowest.  The kernel size is about 33%
 +        smaller with LZMA in comparison to gzip.
 +
 +endchoice
 +
  config SWAP
        bool "Support for paging of anonymous memory (swap)"
        depends on MMU && BLOCK
@@@ -331,59 -271,6 +331,6 @@@ config LOG_BUF_SHIF
                     13 =>  8 KB
                     12 =>  4 KB
  
- config CGROUPS
-       bool "Control Group support"
-       help
-         This option will let you use process cgroup subsystems
-         such as Cpusets
-         Say N if unsure.
- config CGROUP_DEBUG
-       bool "Example debug cgroup subsystem"
-       depends on CGROUPS
-       default n
-       help
-         This option enables a simple cgroup subsystem that
-         exports useful debugging information about the cgroups
-         framework
-         Say N if unsure
- config CGROUP_NS
-         bool "Namespace cgroup subsystem"
-         depends on CGROUPS
-         help
-           Provides a simple namespace cgroup subsystem to
-           provide hierarchical naming of sets of namespaces,
-           for instance virtual servers and checkpoint/restart
-           jobs.
- config CGROUP_FREEZER
-         bool "control group freezer subsystem"
-         depends on CGROUPS
-         help
-           Provides a way to freeze and unfreeze all tasks in a
-         cgroup.
- config CGROUP_DEVICE
-       bool "Device controller for cgroups"
-       depends on CGROUPS && EXPERIMENTAL
-       help
-         Provides a cgroup implementing whitelists for devices which
-         a process in the cgroup can mknod or open.
- config CPUSETS
-       bool "Cpuset support"
-       depends on SMP && CGROUPS
-       help
-         This option will let you create and manage CPUSETs which
-         allow dynamically partitioning a system into sets of CPUs and
-         Memory Nodes and assigning tasks to run only within those sets.
-         This is primarily useful on large SMP or NUMA systems.
-         Say N if unsure.
  #
  # Architectures with an unreliable sched_clock() should select this:
  #
@@@ -397,6 -284,8 +344,8 @@@ config GROUP_SCHE
        help
          This feature lets CPU scheduler recognize task groups and control CPU
          bandwidth allocation to such task groups.
+         In order to create a group from arbitrary set of processes, use
+         CONFIG_CGROUPS. (See Control Group support.)
  
  config FAIR_GROUP_SCHED
        bool "Group scheduling for SCHED_OTHER"
@@@ -439,6 -328,66 +388,66 @@@ config CGROUP_SCHE
  
  endchoice
  
+ menu "Control Group support"
+ config CGROUPS
+       bool "Control Group support"
+       help
+         This option add support for grouping sets of processes together, for
+         use with process control subsystems such as Cpusets, CFS, memory
+         controls or device isolation.
+         See
+               - Documentation/cpusets.txt     (Cpusets)
+               - Documentation/scheduler/sched-design-CFS.txt  (CFS)
+               - Documentation/cgroups/ (features for grouping, isolation)
+               - Documentation/controllers/ (features for resource control)
+         Say N if unsure.
+ config CGROUP_DEBUG
+       bool "Example debug cgroup subsystem"
+       depends on CGROUPS
+       default n
+       help
+         This option enables a simple cgroup subsystem that
+         exports useful debugging information about the cgroups
+         framework
+         Say N if unsure
+ config CGROUP_NS
+         bool "Namespace cgroup subsystem"
+         depends on CGROUPS
+         help
+           Provides a simple namespace cgroup subsystem to
+           provide hierarchical naming of sets of namespaces,
+           for instance virtual servers and checkpoint/restart
+           jobs.
+ config CGROUP_FREEZER
+         bool "control group freezer subsystem"
+         depends on CGROUPS
+         help
+           Provides a way to freeze and unfreeze all tasks in a
+         cgroup.
+ config CGROUP_DEVICE
+       bool "Device controller for cgroups"
+       depends on CGROUPS && EXPERIMENTAL
+       help
+         Provides a cgroup implementing whitelists for devices which
+         a process in the cgroup can mknod or open.
+ config CPUSETS
+       bool "Cpuset support"
+       depends on SMP && CGROUPS
+       help
+         This option will let you create and manage CPUSETs which
+         allow dynamically partitioning a system into sets of CPUs and
+         Memory Nodes and assigning tasks to run only within those sets.
+         This is primarily useful on large SMP or NUMA systems.
+         Say N if unsure.
  config CGROUP_CPUACCT
        bool "Simple CPU accounting cgroup subsystem"
        depends on CGROUPS
@@@ -453,9 -402,6 +462,6 @@@ config RESOURCE_COUNTER
            infrastructure that works with cgroups
        depends on CGROUPS
  
- config MM_OWNER
-       bool
  config CGROUP_MEM_RES_CTLR
        bool "Memory Resource Controller for Control Groups"
        depends on CGROUPS && RESOURCE_COUNTERS
          sure you need the memory resource controller. Even when you enable
          this, you can set "cgroup_disable=memory" at your boot option to
          disable memory resource controller and you can avoid overheads.
-         (and lose benefits of memory resource contoller)
+         (and lose benefits of memory resource controller)
  
          This config option also selects MM_OWNER config option, which
          could in turn add some fork/exit overhead.
  
+ config MM_OWNER
+       bool
+ config CGROUP_MEM_RES_CTLR_SWAP
+       bool "Memory Resource Controller Swap Extension(EXPERIMENTAL)"
+       depends on CGROUP_MEM_RES_CTLR && SWAP && EXPERIMENTAL
+       help
+         Add swap management feature to memory resource controller. When you
+         enable this, you can limit mem+swap usage per cgroup. In other words,
+         when you disable this, memory resource controller has no cares to
+         usage of swap...a process can exhaust all of the swap. This extension
+         is useful when you want to avoid exhaustion swap but this itself
+         adds more overheads and consumes memory for remembering information.
+         Especially if you use 32bit system or small memory system, please
+         be careful about enabling this. When memory resource controller
+         is disabled by boot option, this will be automatically disabled and
+         there will be no overhead from this. Even when you set this config=y,
+         if boot option "noswapaccount" is set, swap will not be accounted.
+ endmenu
  config SYSFS_DEPRECATED
        bool
  
  config SYSFS_DEPRECATED_V2
-       bool "Create deprecated sysfs files"
+       bool "Create deprecated sysfs layout for older userspace tools"
        depends on SYSFS
        default y
        select SYSFS_DEPRECATED
        help
-         This option creates deprecated symlinks such as the
-         "device"-link, the <subsystem>:<name>-link, and the
-         "bus"-link. It may also add deprecated key in the
-         uevent environment.
-         None of these features or values should be used today, as
-         they export driver core implementation details to userspace
-         or export properties which can't be kept stable across kernel
-         releases.
-         If enabled, this option will also move any device structures
-         that belong to a class, back into the /sys/class hierarchy, in
-         order to support older versions of udev and some userspace
-         programs.
-         If you are using a distro with the most recent userspace
-         packages, it should be safe to say N here.
+         This option switches the layout of sysfs to the deprecated
+         version.
+         The current sysfs layout features a unified device tree at
+         /sys/devices/, which is able to express a hierarchy between
+         class devices. If the deprecated option is set to Y, the
+         unified device tree is split into a bus device tree at
+         /sys/devices/ and several individual class device trees at
+         /sys/class/. The class and bus devices will be connected by
+         "<subsystem>:<name>" and the "device" links. The "block"
+         class devices, will not show up in /sys/class/block/. Some
+         subsystems will suppress the creation of some devices which
+         depend on the unified device tree.
+         This option is not a pure compatibility option that can
+         be safely enabled on newer distributions. It will change the
+         layout of sysfs to the non-extensible deprecated version,
+         and disable some features, which can not be exported without
+         confusing older userspace tools. Since 2007/2008 all major
+         distributions do not enable this option, and ship no tools which
+         depend on the deprecated layout or this option.
+         If you are using a new kernel on an older distribution, or use
+         older userspace tools, you might need to say Y here. Do not say Y,
+         if the original kernel, that came with your distribution, has
+         this option set to N.
  
  config PROC_PID_CPUSET
        bool "Include legacy /proc/<pid>/cpuset file"
@@@ -898,10 -876,6 +936,6 @@@ config RT_MUTEXE
        boolean
        select PLIST
  
- config TINY_SHMEM
-       default !SHMEM
-       bool
  config BASE_SMALL
        int
        default 0 if BASE_FULL
@@@ -976,12 -950,6 +1010,6 @@@ config MODULE_SRCVERSION_AL
          the version).  With this option, such a "srcversion" field
          will be created for all modules.  If unsure, say N.
  
- config KMOD
-       def_bool y
-       help
-         This is being removed soon.  These days, CONFIG_MODULES
-         implies CONFIG_KMOD, so use that instead.
  endif # MODULES
  
  config INIT_ALL_POSSIBLE
diff --combined init/do_mounts_rd.c
index a06ed4f92e0eeef1551611944700bc700b042b01,0f0f0cf3ba9aa97c34d88824fbf4644ca76b0fac..a015e267fd170ff57f1713459c6d72af98e4b516
@@@ -9,10 -9,8 +9,11 @@@
  #include <linux/string.h>
  
  #include "do_mounts.h"
+ #include "../fs/squashfs/squashfs_fs.h"
  
 +#include <linux/decompress/generic.h>
 +
 +
  int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
  
  static int __init prompt_ramdisk(char *str)
@@@ -31,7 -29,7 +32,7 @@@ static int __init ramdisk_start_setup(c
  }
  __setup("ramdisk_start=", ramdisk_start_setup);
  
 -static int __init crd_load(int in_fd, int out_fd);
 +static int __init crd_load(int in_fd, int out_fd, decompress_fn deco);
  
  /*
   * This routine tries to find a RAM disk image to load, and returns the
   * numbers could not be found.
   *
   * We currently check for the following magic numbers:
 - *    minix
 - *    ext2
 + *    minix
 + *    ext2
   *    romfs
   *    cramfs
 - *    gzip
+  *    squashfs
 + *    gzip
   */
 -static int __init 
 -identify_ramdisk_image(int fd, int start_block)
 +static int __init
 +identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
  {
        const int size = 512;
        struct minix_super_block *minixsb;
        struct ext2_super_block *ext2sb;
        struct romfs_super_block *romfsb;
        struct cramfs_super *cramfsb;
+       struct squashfs_super_block *squashfsb;
        int nblocks = -1;
        unsigned char *buf;
 +      const char *compress_name;
  
        buf = kmalloc(size, GFP_KERNEL);
        if (!buf)
        ext2sb = (struct ext2_super_block *) buf;
        romfsb = (struct romfs_super_block *) buf;
        cramfsb = (struct cramfs_super *) buf;
+       squashfsb = (struct squashfs_super_block *) buf;
        memset(buf, 0xe5, size);
  
        /*
 -       * Read block 0 to test for gzipped kernel
 +       * Read block 0 to test for compressed kernel
         */
        sys_lseek(fd, start_block * BLOCK_SIZE, 0);
        sys_read(fd, buf, size);
  
 -      /*
 -       * If it matches the gzip magic numbers, return 0
 -       */
 -      if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
 -              printk(KERN_NOTICE
 -                     "RAMDISK: Compressed image found at block %d\n",
 -                     start_block);
 +      *decompressor = decompress_method(buf, size, &compress_name);
 +      if (*decompressor) {
 +              printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n",
 +                     compress_name, start_block);
                nblocks = 0;
                goto done;
        }
                goto done;
        }
  
+       /* squashfs is at block zero too */
+       if (le32_to_cpu(squashfsb->s_magic) == SQUASHFS_MAGIC) {
+               printk(KERN_NOTICE
+                      "RAMDISK: squashfs filesystem found at block %d\n",
+                      start_block);
+               nblocks = (le64_to_cpu(squashfsb->bytes_used) + BLOCK_SIZE - 1)
+                        >> BLOCK_SIZE_BITS;
+               goto done;
+       }
        /*
         * Read block 1 to test for minix and ext2 superblock
         */
        printk(KERN_NOTICE
               "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
               start_block);
 -      
 +
  done:
        sys_lseek(fd, start_block * BLOCK_SIZE, 0);
        kfree(buf);
@@@ -144,7 -157,6 +158,7 @@@ int __init rd_load_image(char *from
        int nblocks, i, disk;
        char *buf = NULL;
        unsigned short rotate = 0;
 +      decompress_fn decompressor = NULL;
  #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
        char rotator[4] = { '|' , '/' , '-' , '\\' };
  #endif
        if (in_fd < 0)
                goto noclose_input;
  
 -      nblocks = identify_ramdisk_image(in_fd, rd_image_start);
 +      nblocks = identify_ramdisk_image(in_fd, rd_image_start, &decompressor);
        if (nblocks < 0)
                goto done;
  
        if (nblocks == 0) {
 -              if (crd_load(in_fd, out_fd) == 0)
 +              if (crd_load(in_fd, out_fd, decompressor) == 0)
                        goto successful_load;
                goto done;
        }
                       nblocks, rd_blocks);
                goto done;
        }
 -              
 +
        /*
         * OK, time to copy in the data
         */
@@@ -261,48 -273,138 +275,48 @@@ int __init rd_load_disk(int n
        return rd_load_image("/dev/root");
  }
  
 -/*
 - * gzip declarations
 - */
 -
 -#define OF(args)  args
 -
 -#ifndef memzero
 -#define memzero(s, n)     memset ((s), 0, (n))
 -#endif
 -
 -typedef unsigned char  uch;
 -typedef unsigned short ush;
 -typedef unsigned long  ulg;
 -
 -#define INBUFSIZ 4096
 -#define WSIZE 0x8000    /* window size--must be a power of two, and */
 -                      /*  at least 32K for zip's deflate method */
 -
 -static uch *inbuf;
 -static uch *window;
 -
 -static unsigned insize;  /* valid bytes in inbuf */
 -static unsigned inptr;   /* index of next byte to be processed in inbuf */
 -static unsigned outcnt;  /* bytes in output buffer */
  static int exit_code;
 -static int unzip_error;
 -static long bytes_out;
 +static int decompress_error;
  static int crd_infd, crd_outfd;
  
 -#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
 -              
 -/* Diagnostic functions (stubbed out) */
 -#define Assert(cond,msg)
 -#define Trace(x)
 -#define Tracev(x)
 -#define Tracevv(x)
 -#define Tracec(c,x)
 -#define Tracecv(c,x)
 -
 -#define STATIC static
 -#define INIT __init
 -
 -static int  __init fill_inbuf(void);
 -static void __init flush_window(void);
 -static void __init error(char *m);
 -
 -#define NO_INFLATE_MALLOC
 -
 -#include "../lib/inflate.c"
 -
 -/* ===========================================================================
 - * Fill the input buffer. This is called only when the buffer is empty
 - * and at least one byte is really needed.
 - * Returning -1 does not guarantee that gunzip() will ever return.
 - */
 -static int __init fill_inbuf(void)
 +static int __init compr_fill(void *buf, unsigned int len)
  {
 -      if (exit_code) return -1;
 -      
 -      insize = sys_read(crd_infd, inbuf, INBUFSIZ);
 -      if (insize == 0) {
 -              error("RAMDISK: ran out of compressed data");
 -              return -1;
 -      }
 -
 -      inptr = 1;
 -
 -      return inbuf[0];
 +      int r = sys_read(crd_infd, buf, len);
 +      if (r < 0)
 +              printk(KERN_ERR "RAMDISK: error while reading compressed data");
 +      else if (r == 0)
 +              printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
 +      return r;
  }
  
 -/* ===========================================================================
 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 - * (Used for the decompressed data only.)
 - */
 -static void __init flush_window(void)
 +static int __init compr_flush(void *window, unsigned int outcnt)
  {
 -    ulg c = crc;         /* temporary variable */
 -    unsigned n, written;
 -    uch *in, ch;
 -    
 -    written = sys_write(crd_outfd, window, outcnt);
 -    if (written != outcnt && unzip_error == 0) {
 -      printk(KERN_ERR "RAMDISK: incomplete write (%d != %d) %ld\n",
 -             written, outcnt, bytes_out);
 -      unzip_error = 1;
 -    }
 -    in = window;
 -    for (n = 0; n < outcnt; n++) {
 -          ch = *in++;
 -          c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 -    }
 -    crc = c;
 -    bytes_out += (ulg)outcnt;
 -    outcnt = 0;
 +      int written = sys_write(crd_outfd, window, outcnt);
 +      if (written != outcnt) {
 +              if (decompress_error == 0)
 +                      printk(KERN_ERR
 +                             "RAMDISK: incomplete write (%d != %d)\n",
 +                             written, outcnt);
 +              decompress_error = 1;
 +              return -1;
 +      }
 +      return outcnt;
  }
  
  static void __init error(char *x)
  {
        printk(KERN_ERR "%s\n", x);
        exit_code = 1;
 -      unzip_error = 1;
 +      decompress_error = 1;
  }
  
 -static int __init crd_load(int in_fd, int out_fd)
 +static int __init crd_load(int in_fd, int out_fd, decompress_fn deco)
  {
        int result;
 -
 -      insize = 0;             /* valid bytes in inbuf */
 -      inptr = 0;              /* index of next byte to be processed in inbuf */
 -      outcnt = 0;             /* bytes in output buffer */
 -      exit_code = 0;
 -      bytes_out = 0;
 -      crc = (ulg)0xffffffffL; /* shift register contents */
 -
        crd_infd = in_fd;
        crd_outfd = out_fd;
 -      inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
 -      if (!inbuf) {
 -              printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
 -              return -1;
 -      }
 -      window = kmalloc(WSIZE, GFP_KERNEL);
 -      if (!window) {
 -              printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
 -              kfree(inbuf);
 -              return -1;
 -      }
 -      makecrc();
 -      result = gunzip();
 -      if (unzip_error)
 +      result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
 +      if (decompress_error)
                result = 1;
 -      kfree(inbuf);
 -      kfree(window);
        return result;
  }
diff --combined init/initramfs.c
index 2f42984e55821ff7d51376942e4e8a063e6d8ec7,d9c941c0c3cacd26fb051059540673b5e011d967..f8241e832aa39056a7ca0803956e1094ef3fd0f4
@@@ -317,6 -317,7 +317,7 @@@ static int __init do_name(void
                        if (wfd >= 0) {
                                sys_fchown(wfd, uid, gid);
                                sys_fchmod(wfd, mode);
+                               sys_ftruncate(wfd, body_len);
                                vcollected = kstrdup(collected, GFP_KERNEL);
                                state = CopyFile;
                        }
@@@ -389,14 -390,11 +390,14 @@@ static int __init write_buffer(char *bu
        return len - count;
  }
  
 -static void __init flush_buffer(char *buf, unsigned len)
 +#if defined CONFIG_RD_GZIP || defined CONFIG_RD_BZIP2 || defined CONFIG_RD_LZMA
 +static int __init flush_buffer(void *bufv, unsigned len)
  {
 +      char *buf = (char *) bufv;
        int written;
 +      int origLen = len;
        if (message)
 -              return;
 +              return -1;
        while ((written = write_buffer(buf, len)) < len && !message) {
                char c = buf[written];
                if (c == '0') {
                } else
                        error("junk in compressed archive");
        }
 +      return origLen;
  }
 -
 -/*
 - * gzip declarations
 - */
 -
 -#define OF(args)  args
 -
 -#ifndef memzero
 -#define memzero(s, n)     memset ((s), 0, (n))
  #endif
  
 -typedef unsigned char  uch;
 -typedef unsigned short ush;
 -typedef unsigned long  ulg;
 -
 -#define WSIZE 0x8000    /* window size--must be a power of two, and */
 -                      /*  at least 32K for zip's deflate method */
 -
 -static uch *inbuf;
 -static uch *window;
 -
 -static unsigned insize;  /* valid bytes in inbuf */
 -static unsigned inptr;   /* index of next byte to be processed in inbuf */
 -static unsigned outcnt;  /* bytes in output buffer */
 -static long bytes_out;
 -
 -#define get_byte()  (inptr < insize ? inbuf[inptr++] : -1)
 -              
 -/* Diagnostic functions (stubbed out) */
 -#define Assert(cond,msg)
 -#define Trace(x)
 -#define Tracev(x)
 -#define Tracevv(x)
 -#define Tracec(c,x)
 -#define Tracecv(c,x)
 -
 -#define STATIC static
 -#define INIT __init
 -
 -static void __init flush_window(void);
 -static void __init error(char *m);
 +static unsigned my_inptr;   /* index of next byte to be processed in inbuf */
  
 -#define NO_INFLATE_MALLOC
 -
 -#include "../lib/inflate.c"
 -
 -/* ===========================================================================
 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 - * (Used for the decompressed data only.)
 - */
 -static void __init flush_window(void)
 -{
 -      ulg c = crc;         /* temporary variable */
 -      unsigned n;
 -      uch *in, ch;
 -
 -      flush_buffer(window, outcnt);
 -      in = window;
 -      for (n = 0; n < outcnt; n++) {
 -              ch = *in++;
 -              c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 -      }
 -      crc = c;
 -      bytes_out += (ulg)outcnt;
 -      outcnt = 0;
 -}
 +#include <linux/decompress/generic.h>
  
  static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
  {
        int written;
 +      decompress_fn decompress;
 +
        dry_run = check_only;
        header_buf = kmalloc(110, GFP_KERNEL);
        symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
        name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
 -      window = kmalloc(WSIZE, GFP_KERNEL);
 -      if (!window || !header_buf || !symlink_buf || !name_buf)
 +
 +      if (!header_buf || !symlink_buf || !name_buf)
                panic("can't allocate buffers");
 +
        state = Start;
        this_header = 0;
        message = NULL;
                        continue;
                }
                this_header = 0;
 -              insize = len;
 -              inbuf = buf;
 -              inptr = 0;
 -              outcnt = 0;             /* bytes in output buffer */
 -              bytes_out = 0;
 -              crc = (ulg)0xffffffffL; /* shift register contents */
 -              makecrc();
 -              gunzip();
 +              decompress = decompress_method(buf, len, NULL);
 +              if (decompress)
 +                      decompress(buf, len, NULL, flush_buffer, NULL,
 +                                 &my_inptr, error);
                if (state != Reset)
 -                      error("junk in gzipped archive");
 -              this_header = saved_offset + inptr;
 -              buf += inptr;
 -              len -= inptr;
 +                      error("junk in compressed archive");
 +              this_header = saved_offset + my_inptr;
 +              buf += my_inptr;
 +              len -= my_inptr;
        }
        dir_utime();
 -      kfree(window);
        kfree(name_buf);
        kfree(symlink_buf);
        kfree(header_buf);