upgrade to squashfs 3.0
authorImre Kaloz <kaloz@openwrt.org>
Tue, 21 Mar 2006 13:41:09 +0000 (13:41 +0000)
committerImre Kaloz <kaloz@openwrt.org>
Tue, 21 Mar 2006 13:41:09 +0000 (13:41 +0000)
SVN-Revision: 3431

openwrt/target/linux/generic-2.4/patches/001-squashfs.patch
openwrt/target/linux/generic-2.4/patches/002-squashfs_lzma.patch
openwrt/target/linux/generic-2.4/patches/010-disable_old_squashfs_compatibility.patch [new file with mode: 0644]
openwrt/target/linux/generic-2.6/patches/001-squashfs.patch
openwrt/target/linux/generic-2.6/patches/002-squashfs_lzma.patch
openwrt/target/linux/generic-2.6/patches/010-disable_old_squashfs_compatibility.patch [new file with mode: 0644]
openwrt/target/linux/image/squashfs/patches/100-lzma.patch

index ae6420a..b2d9cf3 100644 (file)
@@ -1,6 +1,6 @@
-diff --new-file -urp linux-2.4.31/fs/Config.in linux-2.4.31-squashfs2.2/fs/Config.in
---- linux-2.4.31/fs/Config.in  2004-11-17 11:54:21.000000000 +0000
-+++ linux-2.4.31-squashfs2.2/fs/Config.in      2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/fs/Config.in linux-2.4.32-squashfs3.0/fs/Config.in
+--- linux-2.4.32/fs/Config.in  2004-11-17 11:54:21.000000000 +0000
++++ linux-2.4.32-squashfs3.0/fs/Config.in      2006-03-07 21:12:36.000000000 +0000
 @@ -51,6 +51,14 @@ if [ "$CONFIG_JFFS2_FS" = "y" -o "$CONFI
     int 'JFFS2 debugging verbosity (0 = quiet, 2 = noisy)' CONFIG_JFFS2_FS_DEBUG 0
  fi
@@ -16,9 +16,9 @@ diff --new-file -urp linux-2.4.31/fs/Config.in linux-2.4.31-squashfs2.2/fs/Confi
  bool 'Virtual memory file system support (former shm fs)' CONFIG_TMPFS
  define_bool CONFIG_RAMFS y
  
-diff --new-file -urp linux-2.4.31/fs/Makefile linux-2.4.31-squashfs2.2/fs/Makefile
---- linux-2.4.31/fs/Makefile   2004-02-18 13:36:31.000000000 +0000
-+++ linux-2.4.31-squashfs2.2/fs/Makefile       2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/fs/Makefile linux-2.4.32-squashfs3.0/fs/Makefile
+--- linux-2.4.32/fs/Makefile   2004-02-18 13:36:31.000000000 +0000
++++ linux-2.4.32-squashfs3.0/fs/Makefile       2006-03-07 21:12:36.000000000 +0000
 @@ -65,6 +65,7 @@ subdir-$(CONFIG_REISERFS_FS) += reiserfs
  subdir-$(CONFIG_DEVPTS_FS)    += devpts
  subdir-$(CONFIG_SUN_OPENPROMFS)       += openpromfs
@@ -27,14 +27,15 @@ diff --new-file -urp linux-2.4.31/fs/Makefile linux-2.4.31-squashfs2.2/fs/Makefi
  subdir-$(CONFIG_JFS_FS)               += jfs
  subdir-$(CONFIG_XFS_FS)               += xfs
  
-diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/fs/squashfs/inode.c
---- linux-2.4.31/fs/squashfs/inode.c   1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/fs/squashfs/inode.c       2005-07-04 02:28:51.000000000 +0100
-@@ -0,0 +1,1695 @@
+diff --new-file -urp linux-2.4.32/fs/squashfs/inode.c linux-2.4.32-squashfs3.0/fs/squashfs/inode.c
+--- linux-2.4.32/fs/squashfs/inode.c   1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/fs/squashfs/inode.c       2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,2028 @@
 +/*
 + * Squashfs - a compressed read only filesystem for Linux
 + *
-+ * Copyright (c) 2002, 2003, 2004, 2005 Phillip Lougher <phillip@lougher.demon.co.uk>
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
@@ -49,39 +50,28 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 + * You should have received a copy of the GNU General Public License
 + * along with this program; if not, write to the Free Software
 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ * Squashfs - a compressed read only filesystem for Linux
 + *
 + * inode.c
 + */
 +
-+#define SQUASHFS_1_0_COMPATIBILITY
-+
 +#include <linux/types.h>
 +#include <linux/squashfs_fs.h>
 +#include <linux/module.h>
 +#include <linux/errno.h>
 +#include <linux/slab.h>
 +#include <linux/fs.h>
++#include <linux/smp_lock.h>
 +#include <linux/locks.h>
 +#include <linux/init.h>
 +#include <linux/dcache.h>
-+#include <asm/uaccess.h>
 +#include <linux/wait.h>
-+#include <asm/semaphore.h>
 +#include <linux/zlib.h>
 +#include <linux/blkdev.h>
 +#include <linux/vmalloc.h>
++#include <asm/uaccess.h>
++#include <asm/semaphore.h>
 +
-+#ifdef SQUASHFS_TRACE
-+#define TRACE(s, args...)                             printk(KERN_NOTICE "SQUASHFS: "s, ## args)
-+#else
-+#define TRACE(s, args...)                             {}
-+#endif
-+
-+#define ERROR(s, args...)                             printk(KERN_ERR "SQUASHFS error: "s, ## args)
-+
-+#define SERROR(s, args...)                            if(!silent) printk(KERN_ERR "SQUASHFS error: "s, ## args)
-+#define WARNING(s, args...)                           printk(KERN_WARNING "SQUASHFS: "s, ## args)
++#include "squashfs.h"
 +
 +static struct super_block *squashfs_read_super(struct super_block *, void *, int);
 +static void squashfs_put_super(struct super_block *);
@@ -91,24 +81,10 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +static int squashfs_readpage4K(struct file *file, struct page *page);
 +static int squashfs_readdir(struct file *, void *, filldir_t);
 +static struct dentry *squashfs_lookup(struct inode *, struct dentry *);
-+static unsigned int read_data(struct super_block *s, char *buffer,
-+              unsigned int index, unsigned int length, unsigned int *next_index);
-+static int squashfs_get_cached_block(struct super_block *s, char *buffer,
-+              unsigned int block, unsigned int offset, int length,
-+              unsigned int *next_block, unsigned int *next_offset);
-+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode);
-+static unsigned int read_blocklist(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize);
-+static void squashfs_put_super(struct super_block *s);
-+
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static int squashfs_readpage_lessthan4K(struct file *file, struct page *page);
-+static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode);
-+static unsigned int read_blocklist_1(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize);
-+#endif
-+
-+DECLARE_MUTEX(read_data_mutex);
++static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode);
++static long long read_blocklist(struct inode *inode, int index,
++                              int readahead_blks, char *block_list,
++                              unsigned short **block_p, unsigned int *bsize);
 +
 +static z_stream stream;
 +
@@ -119,42 +95,35 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +};
 +
 +static struct super_operations squashfs_ops = {
-+      statfs: squashfs_statfs,
-+      put_super: squashfs_put_super,
-+};
-+
-+static struct address_space_operations squashfs_symlink_aops = {
-+      readpage: squashfs_symlink_readpage
++      .statfs = squashfs_statfs,
++      .put_super = squashfs_put_super,
 +};
 +
-+static struct address_space_operations squashfs_aops = {
-+      readpage: squashfs_readpage
++SQSH_EXTERN struct address_space_operations squashfs_symlink_aops = {
++      .readpage = squashfs_symlink_readpage
 +};
 +
-+static struct address_space_operations squashfs_aops_4K = {
-+      readpage: squashfs_readpage4K
++SQSH_EXTERN struct address_space_operations squashfs_aops = {
++      .readpage = squashfs_readpage
 +};
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static struct address_space_operations squashfs_aops_lessthan4K = {
-+      readpage: squashfs_readpage_lessthan4K
++SQSH_EXTERN struct address_space_operations squashfs_aops_4K = {
++      .readpage = squashfs_readpage4K
 +};
-+#endif
 +
 +static struct file_operations squashfs_dir_ops = {
-+      read: generic_read_dir,
-+      readdir: squashfs_readdir
++      .read = generic_read_dir,
++      .readdir = squashfs_readdir
 +};
 +
 +static struct inode_operations squashfs_dir_inode_ops = {
-+      lookup: squashfs_lookup
++      .lookup = squashfs_lookup
 +};
 +
-+
 +static struct buffer_head *get_block_length(struct super_block *s,
 +                              int *cur_index, int *offset, int *c_byte)
 +{
-+      squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
 +      unsigned short temp;
 +      struct buffer_head *bh;
 +
@@ -195,7 +164,7 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +              *offset += 2;
 +      }
 +
-+      if (SQUASHFS_CHECK_DATA(msblk->sBlk.flags)) {
++      if (SQUASHFS_CHECK_DATA(msblk->sblk.flags)) {
 +              if (*offset == msblk->devblksize) {
 +                      brelse(bh);
 +                      if (!(bh = sb_bread(s, ++(*cur_index))))
@@ -218,58 +187,66 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +}
 +
 +
-+static unsigned int read_data(struct super_block *s, char *buffer,
-+              unsigned int index, unsigned int length, unsigned int *next_index)
++SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer,
++                      long long index, unsigned int length,
++                      long long *next_index)
 +{
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >> msBlk->devblksize_log2) + 2];
-+      unsigned int offset = index & ((1 << msBlk->devblksize_log2) - 1);
-+      unsigned int cur_index = index >> msBlk->devblksize_log2;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >>
++                      msblk->devblksize_log2) + 2];
++      unsigned int offset = index & ((1 << msblk->devblksize_log2) - 1);
++      unsigned int cur_index = index >> msblk->devblksize_log2;
 +      int bytes, avail_bytes, b = 0, k;
 +      char *c_buffer;
 +      unsigned int compressed;
 +      unsigned int c_byte = length;
 +
-+      if(c_byte) {
-+              bytes = msBlk->devblksize - offset;
++      if (c_byte) {
++              bytes = msblk->devblksize - offset;
 +              compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte);
-+              c_buffer = compressed ? msBlk->read_data : buffer;
++              c_buffer = compressed ? msblk->read_data : buffer;
 +              c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
 +
-+              TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte);
++              TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
++                                      ? "" : "un", (unsigned int) c_byte);
 +
-+              if(!(bh[0] = sb_getblk(s, cur_index)))
++              if (!(bh[0] = sb_getblk(s, cur_index)))
 +                      goto block_release;
-+              for(b = 1; bytes < c_byte; b++) {
-+                      if(!(bh[b] = sb_getblk(s, ++cur_index)))
++
++              for (b = 1; bytes < c_byte; b++) {
++                      if (!(bh[b] = sb_getblk(s, ++cur_index)))
 +                              goto block_release;
-+                      bytes += msBlk->devblksize;
++                      bytes += msblk->devblksize;
 +              }
 +              ll_rw_block(READ, b, bh);
 +      } else {
-+              if(!(bh[0] = get_block_length(s, &cur_index, &offset, &c_byte)))
++              if (!(bh[0] = get_block_length(s, &cur_index, &offset,
++                                                              &c_byte)))
 +                      goto read_failure;
 +
-+              bytes = msBlk->devblksize - offset;
++              bytes = msblk->devblksize - offset;
 +              compressed = SQUASHFS_COMPRESSED(c_byte);
-+              c_buffer = compressed ? msBlk->read_data : buffer;
++              c_buffer = compressed ? msblk->read_data : buffer;
 +              c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
 +
-+              TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte);
++              TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
++                                      ? "" : "un", (unsigned int) c_byte);
 +
-+              for(b = 1; bytes < c_byte; b++) {
-+                      if(!(bh[b] = sb_getblk(s, ++cur_index)))
++              for (b = 1; bytes < c_byte; b++) {
++                      if (!(bh[b] = sb_getblk(s, ++cur_index)))
 +                              goto block_release;
-+                      bytes += msBlk->devblksize;
++                      bytes += msblk->devblksize;
 +              }
 +              ll_rw_block(READ, b - 1, bh + 1);
 +      }
 +
-+      if(compressed)
-+              down(&read_data_mutex);
++      if (compressed)
++              down(&msblk->read_data_mutex);
 +
-+      for(bytes = 0, k = 0; k < b; k++) {
-+              avail_bytes = (c_byte - bytes) > (msBlk->devblksize - offset) ? msBlk->devblksize - offset : c_byte - bytes;
++      for (bytes = 0, k = 0; k < b; k++) {
++              avail_bytes = (c_byte - bytes) > (msblk->devblksize - offset) ?
++                                      msblk->devblksize - offset :
++                                      c_byte - bytes;
 +              wait_on_buffer(bh[k]);
 +              if (!buffer_uptodate(bh[k]))
 +                      goto block_release;
@@ -282,30 +259,36 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +      /*
 +       * uncompress block
 +       */
-+      if(compressed) {
++      if (compressed) {
 +              int zlib_err;
 +
 +              stream.next_in = c_buffer;
 +              stream.avail_in = c_byte;
 +              stream.next_out = buffer;
-+              stream.avail_out = msBlk->read_size;
-+              if(((zlib_err = zlib_inflateInit(&stream)) != Z_OK) ||
-+                              ((zlib_err = zlib_inflate(&stream, Z_FINISH)) != Z_STREAM_END) ||
-+                              ((zlib_err = zlib_inflateEnd(&stream)) != Z_OK)) {
-+                      ERROR("zlib_fs returned unexpected result 0x%x\n", zlib_err);
++              stream.avail_out = msblk->read_size;
++
++              if (((zlib_err = zlib_inflateInit(&stream)) != Z_OK) ||
++                              ((zlib_err = zlib_inflate(&stream, Z_FINISH))
++                               != Z_STREAM_END) || ((zlib_err =
++                              zlib_inflateEnd(&stream)) != Z_OK)) {
++                      ERROR("zlib_fs returned unexpected result 0x%x\n",
++                              zlib_err);
 +                      bytes = 0;
 +              } else
 +                      bytes = stream.total_out;
-+              up(&read_data_mutex);
++              
++              up(&msblk->read_data_mutex);
 +      }
 +
-+      if(next_index)
-+              *next_index = index + c_byte + (length ? 0 : (SQUASHFS_CHECK_DATA(msBlk->sBlk.flags) ? 3 : 2));
-+
++      if (next_index)
++              *next_index = index + c_byte + (length ? 0 :
++                              (SQUASHFS_CHECK_DATA(msblk->sblk.flags)
++                               ? 3 : 2));
 +      return bytes;
 +
 +block_release:
-+      while(--b >= 0) brelse(bh[b]);
++      while (--b >= 0)
++              brelse(bh[b]);
 +
 +read_failure:
 +      ERROR("sb_bread failed reading block 0x%x\n", cur_index);
@@ -313,802 +296,873 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +}
 +
 +
-+static int squashfs_get_cached_block(struct super_block *s, char *buffer,
-+              unsigned int block, unsigned int offset, int length,
-+              unsigned int *next_block, unsigned int *next_offset)
++SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, char *buffer,
++                              long long block, unsigned int offset,
++                              int length, long long *next_block,
++                              unsigned int *next_offset)
 +{
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
 +      int n, i, bytes, return_length = length;
-+      unsigned int next_index;
++      long long next_index;
 +
-+      TRACE("Entered squashfs_get_cached_block [%x:%x]\n", block, offset);
++      TRACE("Entered squashfs_get_cached_block [%llx:%x]\n", block, offset);
 +
-+      for(;;) {
-+              for(i = 0; i < SQUASHFS_CACHED_BLKS; i++) 
-+                      if(msBlk->block_cache[i].block == block)
++      while ( 1 ) {
++              for (i = 0; i < SQUASHFS_CACHED_BLKS; i++) 
++                      if (msblk->block_cache[i].block == block)
 +                              break; 
 +              
-+              down(&msBlk->block_cache_mutex);
-+              if(i == SQUASHFS_CACHED_BLKS) {
++              down(&msblk->block_cache_mutex);
++
++              if (i == SQUASHFS_CACHED_BLKS) {
 +                      /* read inode header block */
-+                      for(i = msBlk->next_cache, n = SQUASHFS_CACHED_BLKS; n ; n --, i = (i + 1) % SQUASHFS_CACHED_BLKS)
-+                              if(msBlk->block_cache[i].block != SQUASHFS_USED_BLK)
++                      for (i = msblk->next_cache, n = SQUASHFS_CACHED_BLKS;
++                                      n ; n --, i = (i + 1) %
++                                      SQUASHFS_CACHED_BLKS)
++                              if (msblk->block_cache[i].block !=
++                                                      SQUASHFS_USED_BLK)
 +                                      break;
-+                      if(n == 0) {
-+                              up(&msBlk->block_cache_mutex);
-+                              sleep_on(&msBlk->waitq);
++
++                      if (n == 0) {
++                              wait_queue_t wait;
++
++                              init_waitqueue_entry(&wait, current);
++                              add_wait_queue(&msblk->waitq, &wait);
++                              set_current_state(TASK_UNINTERRUPTIBLE);
++                              up(&msblk->block_cache_mutex);
++                              schedule();
++                              set_current_state(TASK_RUNNING);
++                              remove_wait_queue(&msblk->waitq, &wait);
 +                              continue;
 +                      }
-+                      msBlk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS;
-+
-+                      if(msBlk->block_cache[i].block == SQUASHFS_INVALID_BLK) {
-+                              if(!(msBlk->block_cache[i].data = (unsigned char *)
-+                                                      kmalloc(SQUASHFS_METADATA_SIZE, GFP_KERNEL))) {
-+                                      ERROR("Failed to allocate cache block\n");
-+                                      up(&msBlk->block_cache_mutex);
-+                                      return 0;
++                      msblk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS;
++
++                      if (msblk->block_cache[i].block ==
++                                                      SQUASHFS_INVALID_BLK) {
++                              if (!(msblk->block_cache[i].data =
++                                              kmalloc(SQUASHFS_METADATA_SIZE,
++                                              GFP_KERNEL))) {
++                                      ERROR("Failed to allocate cache"
++                                                      "block\n");
++                                      up(&msblk->block_cache_mutex);
++                                      goto out;
 +                              }
 +                      }
 +      
-+                      msBlk->block_cache[i].block = SQUASHFS_USED_BLK;
-+                      up(&msBlk->block_cache_mutex);
-+                      if(!(msBlk->block_cache[i].length = read_data(s, msBlk->block_cache[i].data, block, 0,
-+                                                      &next_index))) {
-+                              ERROR("Unable to read cache block [%x:%x]\n", block, offset);
-+                              return 0;
++                      msblk->block_cache[i].block = SQUASHFS_USED_BLK;
++                      up(&msblk->block_cache_mutex);
++
++                      if (!(msblk->block_cache[i].length =
++                                              squashfs_read_data(s,
++                                              msblk->block_cache[i].data,
++                                              block, 0, &next_index))) {
++                              ERROR("Unable to read cache block [%llx:%x]\n",
++                                              block, offset);
++                              goto out;
 +                      }
-+                      down(&msBlk->block_cache_mutex);
-+                      wake_up(&msBlk->waitq);
-+                      msBlk->block_cache[i].block = block;
-+                      msBlk->block_cache[i].next_index = next_index;
-+                      TRACE("Read cache block [%x:%x]\n", block, offset);
++
++                      down(&msblk->block_cache_mutex);
++                      wake_up(&msblk->waitq);
++                      msblk->block_cache[i].block = block;
++                      msblk->block_cache[i].next_index = next_index;
++                      TRACE("Read cache block [%llx:%x]\n", block, offset);
 +              }
 +
-+              if(msBlk->block_cache[i].block != block) {
-+                      up(&msBlk->block_cache_mutex);
++              if (msblk->block_cache[i].block != block) {
++                      up(&msblk->block_cache_mutex);
 +                      continue;
 +              }
 +
-+              if((bytes = msBlk->block_cache[i].length - offset) >= length) {
-+                      if(buffer)
-+                              memcpy(buffer, msBlk->block_cache[i].data + offset, length);
-+                      if(msBlk->block_cache[i].length - offset == length) {
-+                              *next_block = msBlk->block_cache[i].next_index;
++              if ((bytes = msblk->block_cache[i].length - offset) >= length) {
++                      if (buffer)
++                              memcpy(buffer, msblk->block_cache[i].data +
++                                              offset, length);
++                      if (msblk->block_cache[i].length - offset == length) {
++                              *next_block = msblk->block_cache[i].next_index;
 +                              *next_offset = 0;
 +                      } else {
 +                              *next_block = block;
 +                              *next_offset = offset + length;
 +                      }
-+      
-+                      up(&msBlk->block_cache_mutex);
-+                      return return_length;
++                      up(&msblk->block_cache_mutex);
++                      goto finish;
 +              } else {
-+                      if(buffer) {
-+                              memcpy(buffer, msBlk->block_cache[i].data + offset, bytes);
++                      if (buffer) {
++                              memcpy(buffer, msblk->block_cache[i].data +
++                                              offset, bytes);
 +                              buffer += bytes;
 +                      }
-+                      block = msBlk->block_cache[i].next_index;
-+                      up(&msBlk->block_cache_mutex);
++                      block = msblk->block_cache[i].next_index;
++                      up(&msblk->block_cache_mutex);
 +                      length -= bytes;
 +                      offset = 0;
 +              }
 +      }
++
++finish:
++      return return_length;
++out:
++      return 0;
 +}
 +
 +
-+static int get_fragment_location(struct super_block *s, unsigned int fragment, unsigned int *fragment_start_block, unsigned int *fragment_size)
++static int get_fragment_location(struct super_block *s, unsigned int fragment,
++                              long long *fragment_start_block,
++                              unsigned int *fragment_size)
 +{
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      unsigned int start_block = msBlk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)];
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      long long start_block =
++              msblk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)];
 +      int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment);
-+      squashfs_fragment_entry fragment_entry;
++      struct squashfs_fragment_entry fragment_entry;
 +
-+      if(msBlk->swap) {
-+              squashfs_fragment_entry sfragment_entry;
++      if (msblk->swap) {
++              struct squashfs_fragment_entry sfragment_entry;
 +
-+              if(!squashfs_get_cached_block(s, (char *) &sfragment_entry, start_block, offset,
-+                                      sizeof(sfragment_entry), &start_block, &offset))
-+                      return 0;
++              if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
++                                      start_block, offset,
++                                      sizeof(sfragment_entry), &start_block,
++                                      &offset))
++                      goto out;
 +              SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry);
 +      } else
-+              if(!squashfs_get_cached_block(s, (char *) &fragment_entry, start_block, offset,
-+                                      sizeof(fragment_entry), &start_block, &offset))
-+                      return 0;
++              if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
++                                      start_block, offset,
++                                      sizeof(fragment_entry), &start_block,
++                                      &offset))
++                      goto out;
 +
 +      *fragment_start_block = fragment_entry.start_block;
 +      *fragment_size = fragment_entry.size;
 +
 +      return 1;
++
++out:
++      return 0;
 +}
 +
 +
-+void release_cached_fragment(squashfs_sb_info *msBlk, struct squashfs_fragment_cache *fragment)
++SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk, struct
++                                      squashfs_fragment_cache *fragment)
 +{
-+      down(&msBlk->fragment_mutex);
++      down(&msblk->fragment_mutex);
 +      fragment->locked --;
-+      wake_up(&msBlk->fragment_wait_queue);
-+      up(&msBlk->fragment_mutex);
++      wake_up(&msblk->fragment_wait_queue);
++      up(&msblk->fragment_mutex);
 +}
 +
 +
-+struct squashfs_fragment_cache *get_cached_fragment(struct super_block *s, unsigned int start_block, int length)
++SQSH_EXTERN struct squashfs_fragment_cache *get_cached_fragment(struct super_block
++                                      *s, long long start_block,
++                                      int length)
 +{
 +      int i, n;
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+
-+      for(;;) {
-+              down(&msBlk->fragment_mutex);
-+              for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS && msBlk->fragment[i].block != start_block; i++);
-+              if(i == SQUASHFS_CACHED_FRAGMENTS) {
-+                      for(i = msBlk->next_fragment, n = SQUASHFS_CACHED_FRAGMENTS;
-+                              n && msBlk->fragment[i].locked; n--, i = (i + 1) % SQUASHFS_CACHED_FRAGMENTS);
-+
-+                      if(n == 0) {
-+                              up(&msBlk->fragment_mutex);
-+                              sleep_on(&msBlk->fragment_wait_queue);
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++
++      while ( 1 ) {
++              down(&msblk->fragment_mutex);
++
++              for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS &&
++                              msblk->fragment[i].block != start_block; i++);
++
++              if (i == SQUASHFS_CACHED_FRAGMENTS) {
++                      for (i = msblk->next_fragment, n =
++                              SQUASHFS_CACHED_FRAGMENTS; n &&
++                              msblk->fragment[i].locked; n--, i = (i + 1) %
++                              SQUASHFS_CACHED_FRAGMENTS);
++
++                      if (n == 0) {
++                              wait_queue_t wait;
++
++                              init_waitqueue_entry(&wait, current);
++                              add_wait_queue(&msblk->fragment_wait_queue,
++                                                                      &wait);
++                              set_current_state(TASK_UNINTERRUPTIBLE);
++                              up(&msblk->fragment_mutex);
++                              schedule();
++                              set_current_state(TASK_RUNNING);
++                              remove_wait_queue(&msblk->fragment_wait_queue,
++                                                                      &wait);
 +                              continue;
 +                      }
-+                      msBlk->next_fragment = (msBlk->next_fragment + 1) % SQUASHFS_CACHED_FRAGMENTS;
++                      msblk->next_fragment = (msblk->next_fragment + 1) %
++                              SQUASHFS_CACHED_FRAGMENTS;
 +                      
-+                      if(msBlk->fragment[i].data == NULL)
-+                              if(!(msBlk->fragment[i].data = (unsigned char *)
-+                                                      SQUASHFS_ALLOC(SQUASHFS_FILE_MAX_SIZE))) {
-+                                      ERROR("Failed to allocate fragment cache block\n");
-+                                      up(&msBlk->fragment_mutex);
-+                                      return NULL;
++                      if (msblk->fragment[i].data == NULL)
++                              if (!(msblk->fragment[i].data = SQUASHFS_ALLOC
++                                              (SQUASHFS_FILE_MAX_SIZE))) {
++                                      ERROR("Failed to allocate fragment "
++                                                      "cache block\n");
++                                      up(&msblk->fragment_mutex);
++                                      goto out;
 +                              }
 +
-+                      msBlk->fragment[i].block = SQUASHFS_INVALID_BLK;
-+                      msBlk->fragment[i].locked = 1;
-+                      up(&msBlk->fragment_mutex);
-+                      if(!(msBlk->fragment[i].length = read_data(s, msBlk->fragment[i].data, start_block, length,
-+                                                      NULL))) {
-+                              ERROR("Unable to read fragment cache block [%x]\n", start_block);
-+                              msBlk->fragment[i].locked = 0;
-+                              return NULL;
-+                      }
-+                      msBlk->fragment[i].block = start_block;
-+                      TRACE("New fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked);
-+                      return &msBlk->fragment[i];
-+              }
-+
-+              msBlk->fragment[i].locked ++;
-+              up(&msBlk->fragment_mutex);
-+              
-+              TRACE("Got fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked);
-+              return &msBlk->fragment[i];
-+      }
-+}
-+
-+
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode)
-+{
-+      struct inode *i = new_inode(s);
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
-+      unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
-+      unsigned int next_block, next_offset;
-+      squashfs_base_inode_header_1 inodeb;
-+
-+      TRACE("Entered squashfs_iget_1\n");
-+
-+      if(msBlk->swap) {
-+              squashfs_base_inode_header_1 sinodeb;
-+
-+              if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
-+                                      sizeof(sinodeb), &next_block, &next_offset))
-+                      goto failed_read;
-+              SQUASHFS_SWAP_BASE_INODE_HEADER_1(&inodeb, &sinodeb, sizeof(sinodeb));
-+      } else
-+              if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
-+                                      sizeof(inodeb), &next_block, &next_offset))
-+                      goto failed_read;
-+
-+      i->i_nlink = 1;
-+
-+      i->i_mtime = sBlk->mkfs_time;
-+      i->i_atime = sBlk->mkfs_time;
-+      i->i_ctime = sBlk->mkfs_time;
-+
-+      if(inodeb.inode_type != SQUASHFS_IPC_TYPE)
-+              i->i_uid = msBlk->uid[((inodeb.inode_type - 1) / SQUASHFS_TYPES) * 16 + inodeb.uid];
-+      i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);
-+
-+      i->i_mode = inodeb.mode;
-+
-+      switch(inodeb.inode_type == SQUASHFS_IPC_TYPE ? SQUASHFS_IPC_TYPE : (inodeb.inode_type - 1) % SQUASHFS_TYPES + 1) {
-+              case SQUASHFS_FILE_TYPE: {
-+                      squashfs_reg_inode_header_1 inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_reg_inode_header_1 sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_REG_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+
-+                      i->i_size = inodep.file_size;
-+                      i->i_fop = &generic_ro_fops;
-+                      if(sBlk->block_size > 4096)
-+                              i->i_data.a_ops = &squashfs_aops;
-+                      else if(sBlk->block_size == 4096)
-+                              i->i_data.a_ops = &squashfs_aops_4K;
-+                      else
-+                              i->i_data.a_ops = &squashfs_aops_lessthan4K;
-+                      i->i_mode |= S_IFREG;
-+                      i->i_mtime = inodep.mtime;
-+                      i->i_atime = inodep.mtime;
-+                      i->i_ctime = inodep.mtime;
-+                      i->i_blocks = ((i->i_size - 1) >> 9) + 1;
-+                      i->i_blksize = PAGE_CACHE_SIZE;
-+                      i->u.squashfs_i.u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
-+                      i->u.squashfs_i.u.s1.fragment_offset = 0;
-+                      i->u.squashfs_i.start_block = inodep.start_block;
-+                      i->u.squashfs_i.block_list_start = next_block;
-+                      i->u.squashfs_i.offset = next_offset;
-+                      TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x\n",
-+                                      SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset);
-+                      break;
-+              }
-+              case SQUASHFS_DIR_TYPE: {
-+                      squashfs_dir_inode_header_1 inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_dir_inode_header_1 sinodep;
++                      msblk->fragment[i].block = SQUASHFS_INVALID_BLK;
++                      msblk->fragment[i].locked = 1;
++                      up(&msblk->fragment_mutex);
 +
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_DIR_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++                      if (!(msblk->fragment[i].length = squashfs_read_data(s,
++                                              msblk->fragment[i].data,
++                                              start_block, length, NULL))) {
++                              ERROR("Unable to read fragment cache block "
++                                                      "[%llx]\n", start_block);
++                              msblk->fragment[i].locked = 0;
++                              goto out;
++                      }
 +
-+                      i->i_size = inodep.file_size;
-+                      i->i_op = &squashfs_dir_inode_ops;
-+                      i->i_fop = &squashfs_dir_ops;
-+                      i->i_mode |= S_IFDIR;
-+                      i->i_mtime = inodep.mtime;
-+                      i->i_atime = inodep.mtime;
-+                      i->i_ctime = inodep.mtime;
-+                      i->u.squashfs_i.start_block = inodep.start_block;
-+                      i->u.squashfs_i.offset = inodep.offset;
-+                      i->u.squashfs_i.u.s2.directory_index_count = 0;
-+                      TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
-+                                      inodep.start_block, inodep.offset);
++                      msblk->fragment[i].block = start_block;
++                      TRACE("New fragment %d, start block %lld, locked %d\n",
++                                              i, msblk->fragment[i].block,
++                                              msblk->fragment[i].locked);
 +                      break;
 +              }
-+              case SQUASHFS_SYMLINK_TYPE: {
-+                      squashfs_symlink_inode_header_1 inodep;
-+      
-+                      if(msBlk->swap) {
-+                              squashfs_symlink_inode_header_1 sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+
-+                      i->i_size = inodep.symlink_size;
-+                      i->i_op = &page_symlink_inode_operations;
-+                      i->i_data.a_ops = &squashfs_symlink_aops;
-+                      i->i_mode |= S_IFLNK;
-+                      i->u.squashfs_i.start_block = next_block;
-+                      i->u.squashfs_i.offset = next_offset;
-+                      TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n",
-+                              SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset);
-+                      break;
-+               }
-+               case SQUASHFS_BLKDEV_TYPE:
-+               case SQUASHFS_CHRDEV_TYPE: {
-+                      squashfs_dev_inode_header_1 inodep;
 +
-+                      if(msBlk->swap) {
-+                              squashfs_dev_inode_header_1 sinodep;
++              msblk->fragment[i].locked++;
++              up(&msblk->fragment_mutex);
++              TRACE("Got fragment %d, start block %lld, locked %d\n", i,
++                                              msblk->fragment[i].block,
++                                              msblk->fragment[i].locked);
++              break;
++      }
 +
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_DEV_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else  
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++      return &msblk->fragment[i];
 +
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK;
-+                      init_special_inode(i, i->i_mode, inodep.rdev);
-+                      TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev);
-+                      break;
-+               }
-+               case SQUASHFS_IPC_TYPE: {
-+                      squashfs_ipc_inode_header_1 inodep;
++out:
++      return NULL;
++}
 +
-+                      if(msBlk->swap) {
-+                              squashfs_ipc_inode_header_1 sinodep;
 +
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_IPC_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else  
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++static struct inode *squashfs_new_inode(struct super_block *s,
++              struct squashfs_base_inode_header *inodeb)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct inode *i = new_inode(s);
 +
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodep.type == SQUASHFS_FIFO_TYPE) ? S_IFIFO : S_IFSOCK;
-+                      i->i_uid = msBlk->uid[inodep.offset * 16 + inodeb.uid];
-+                      init_special_inode(i, i->i_mode, 0);
-+                      break;
-+               }
-+               default:
-+                      ERROR("Unknown inode type %d in squashfs_iget!\n", inodeb.inode_type);
-+                              goto failed_read1;
++      if (i) {
++              i->i_ino = inodeb->inode_number;
++              i->i_mtime = inodeb->mtime;
++              i->i_atime = inodeb->mtime;
++              i->i_ctime = inodeb->mtime;
++              i->i_uid = msblk->uid[inodeb->uid];
++              i->i_mode = inodeb->mode;
++              i->i_size = 0;
++              if (inodeb->guid == SQUASHFS_GUIDS)
++                      i->i_gid = i->i_uid;
++              else
++                      i->i_gid = msblk->guid[inodeb->guid];
 +      }
-+      
-+      if(inodeb.guid == 15)
-+              i->i_gid = i->i_uid;
-+      else
-+              i->i_gid = msBlk->guid[inodeb.guid];
 +
-+      insert_inode_hash(i);
 +      return i;
-+
-+failed_read:
-+      ERROR("Unable to read inode [%x:%x]\n", block, offset);
-+
-+failed_read1:
-+      return NULL;
 +}
-+#endif
 +
 +
-+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode)
++static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode)
 +{
-+      struct inode *i = new_inode(s);
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
++      struct inode *i;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long block = SQUASHFS_INODE_BLK(inode) +
++              sblk->inode_table_start;
 +      unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
-+      unsigned int next_block, next_offset;
-+      squashfs_base_inode_header inodeb;
++      long long next_block;
++      unsigned int next_offset;
++      union squashfs_inode_header id, sid;
++      struct squashfs_base_inode_header *inodeb = &id.base,
++                                        *sinodeb = &sid.base;
 +
 +      TRACE("Entered squashfs_iget\n");
 +
-+      if(msBlk->swap) {
-+              squashfs_base_inode_header sinodeb;
-+
-+              if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
-+                                      sizeof(sinodeb), &next_block, &next_offset))
++      if (msblk->swap) {
++              if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
++                                      offset, sizeof(*sinodeb), &next_block,
++                                      &next_offset))
 +                      goto failed_read;
-+              SQUASHFS_SWAP_BASE_INODE_HEADER(&inodeb, &sinodeb, sizeof(sinodeb));
++              SQUASHFS_SWAP_BASE_INODE_HEADER(inodeb, sinodeb,
++                                      sizeof(*sinodeb));
 +      } else
-+              if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
-+                                      sizeof(inodeb), &next_block, &next_offset))
++              if (!squashfs_get_cached_block(s, (char *) inodeb, block,
++                                      offset, sizeof(*inodeb), &next_block,
++                                      &next_offset))
 +                      goto failed_read;
 +
-+      i->i_nlink = 1;
-+
-+      i->i_mtime = sBlk->mkfs_time;
-+      i->i_atime = sBlk->mkfs_time;
-+      i->i_ctime = sBlk->mkfs_time;
-+
-+      i->i_uid = msBlk->uid[inodeb.uid];
-+      i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);
-+
-+      i->i_mode = inodeb.mode;
-+
-+      switch(inodeb.inode_type) {
++      switch(inodeb->inode_type) {
 +              case SQUASHFS_FILE_TYPE: {
-+                      squashfs_reg_inode_header inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_reg_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      unsigned int frag_size;
++                      long long frag_blk;
++                      struct squashfs_reg_inode_header *inodep = &id.reg;
++                      struct squashfs_reg_inode_header *sinodep = &sid.reg;
++                              
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_REG_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_REG_INODE_HEADER(inodep, sinodep);
 +                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      i->u.squashfs_i.u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
-+                      if(inodep.fragment != SQUASHFS_INVALID_BLK && !get_fragment_location(s, inodep.fragment,
-+                                                      &i->u.squashfs_i.u.s1.fragment_start_block, &i->u.squashfs_i.u.s1.fragment_size))
++                      frag_blk = SQUASHFS_INVALID_BLK;
++                      if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
++                                      !get_fragment_location(s,
++                                      inodep->fragment, &frag_blk, &frag_size))
 +                              goto failed_read;
++                              
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
 +
-+                      i->u.squashfs_i.u.s1.fragment_offset = inodep.offset;
-+                      i->i_size = inodep.file_size;
++                      i->i_nlink = 1;
++                      i->i_size = inodep->file_size;
 +                      i->i_fop = &generic_ro_fops;
-+                      if(sBlk->block_size > 4096)
++                      i->i_mode |= S_IFREG;
++                      i->i_blocks = ((i->i_size - 1) >> 9) + 1;
++                      i->i_blksize = PAGE_CACHE_SIZE;
++                      SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
++                      SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
++                      SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->u.s1.block_list_start = next_block;
++                      SQUASHFS_I(i)->offset = next_offset;
++                      if (sblk->block_size > 4096)
 +                              i->i_data.a_ops = &squashfs_aops;
 +                      else
 +                              i->i_data.a_ops = &squashfs_aops_4K;
++
++                      TRACE("File inode %x:%x, start_block %llx, "
++                                      "block_list_start %llx, offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->start_block, next_block,
++                                      next_offset);
++                      break;
++              }
++              case SQUASHFS_LREG_TYPE: {
++                      unsigned int frag_size;
++                      long long frag_blk;
++                      struct squashfs_lreg_inode_header *inodep = &id.lreg;
++                      struct squashfs_lreg_inode_header *sinodep = &sid.lreg;
++                              
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_LREG_INODE_HEADER(inodep, sinodep);
++                      } else
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      frag_blk = SQUASHFS_INVALID_BLK;
++                      if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
++                                      !get_fragment_location(s,
++                                      inodep->fragment, &frag_blk, &frag_size))
++                              goto failed_read;
++                              
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_size = inodep->file_size;
++                      i->i_fop = &generic_ro_fops;
 +                      i->i_mode |= S_IFREG;
-+                      i->i_mtime = inodep.mtime;
-+                      i->i_atime = inodep.mtime;
-+                      i->i_ctime = inodep.mtime;
 +                      i->i_blocks = ((i->i_size - 1) >> 9) + 1;
 +                      i->i_blksize = PAGE_CACHE_SIZE;
-+                      i->u.squashfs_i.start_block = inodep.start_block;
-+                      i->u.squashfs_i.block_list_start = next_block;
-+                      i->u.squashfs_i.offset = next_offset;
-+                      TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x fragment_index %x fragment_offset %x\n",
-+                                      SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset, inodep.fragment, inodep.offset);
++                      SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
++                      SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
++                      SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->u.s1.block_list_start = next_block;
++                      SQUASHFS_I(i)->offset = next_offset;
++                      if (sblk->block_size > 4096)
++                              i->i_data.a_ops = &squashfs_aops;
++                      else
++                              i->i_data.a_ops = &squashfs_aops_4K;
++
++                      TRACE("File inode %x:%x, start_block %llx, "
++                                      "block_list_start %llx, offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->start_block, next_block,
++                                      next_offset);
 +                      break;
 +              }
 +              case SQUASHFS_DIR_TYPE: {
-+                      squashfs_dir_inode_header inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_dir_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      struct squashfs_dir_inode_header *inodep = &id.dir;
++                      struct squashfs_dir_inode_header *sinodep = &sid.dir;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_DIR_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_DIR_INODE_HEADER(inodep, sinodep);
 +                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      i->i_size = inodep.file_size;
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_size = inodep->file_size;
 +                      i->i_op = &squashfs_dir_inode_ops;
 +                      i->i_fop = &squashfs_dir_ops;
 +                      i->i_mode |= S_IFDIR;
-+                      i->i_mtime = inodep.mtime;
-+                      i->i_atime = inodep.mtime;
-+                      i->i_ctime = inodep.mtime;
-+                      i->u.squashfs_i.start_block = inodep.start_block;
-+                      i->u.squashfs_i.offset = inodep.offset;
-+                      i->u.squashfs_i.u.s2.directory_index_count = 0;
-+                      TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
-+                                      inodep.start_block, inodep.offset);
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->offset = inodep->offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_count = 0;
++                      SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode;
++
++                      TRACE("Directory inode %x:%x, start_block %x, offset "
++                                      "%x\n", SQUASHFS_INODE_BLK(inode),
++                                      offset, inodep->start_block,
++                                      inodep->offset);
 +                      break;
 +              }
 +              case SQUASHFS_LDIR_TYPE: {
-+                      squashfs_ldir_inode_header inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_ldir_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      struct squashfs_ldir_inode_header *inodep = &id.ldir;
++                      struct squashfs_ldir_inode_header *sinodep = &sid.ldir;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_LDIR_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_LDIR_INODE_HEADER(inodep,
++                                              sinodep);
 +                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      i->i_size = inodep.file_size;
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_size = inodep->file_size;
 +                      i->i_op = &squashfs_dir_inode_ops;
 +                      i->i_fop = &squashfs_dir_ops;
 +                      i->i_mode |= S_IFDIR;
-+                      i->i_mtime = inodep.mtime;
-+                      i->i_atime = inodep.mtime;
-+                      i->i_ctime = inodep.mtime;
-+                      i->u.squashfs_i.start_block = inodep.start_block;
-+                      i->u.squashfs_i.offset = inodep.offset;
-+                      i->u.squashfs_i.u.s2.directory_index_start = next_block;
-+                      i->u.squashfs_i.u.s2.directory_index_offset = next_offset;
-+                      i->u.squashfs_i.u.s2.directory_index_count = inodep.i_count;
-+                      TRACE("Long directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
-+                                      inodep.start_block, inodep.offset);
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->offset = inodep->offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
++                      SQUASHFS_I(i)->u.s2.directory_index_offset =
++                                                              next_offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_count =
++                                                              inodep->i_count;
++                      SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode;
++
++                      TRACE("Long directory inode %x:%x, start_block %x, "
++                                      "offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->start_block, inodep->offset);
 +                      break;
 +              }
 +              case SQUASHFS_SYMLINK_TYPE: {
-+                      squashfs_symlink_inode_header inodep;
++                      struct squashfs_symlink_inode_header *inodep =
++                                                              &id.symlink;
++                      struct squashfs_symlink_inode_header *sinodep =
++                                                              &sid.symlink;
 +      
-+                      if(msBlk->swap) {
-+                              squashfs_symlink_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_SYMLINK_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_SYMLINK_INODE_HEADER(inodep,
++                                                              sinodep);
 +                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      i->i_size = inodep.symlink_size;
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_size = inodep->symlink_size;
 +                      i->i_op = &page_symlink_inode_operations;
 +                      i->i_data.a_ops = &squashfs_symlink_aops;
 +                      i->i_mode |= S_IFLNK;
-+                      i->u.squashfs_i.start_block = next_block;
-+                      i->u.squashfs_i.offset = next_offset;
-+                      TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n",
-+                              SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset);
++                      SQUASHFS_I(i)->start_block = next_block;
++                      SQUASHFS_I(i)->offset = next_offset;
++
++                      TRACE("Symbolic link inode %x:%x, start_block %llx, "
++                                      "offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      next_block, next_offset);
 +                      break;
 +               }
 +               case SQUASHFS_BLKDEV_TYPE:
 +               case SQUASHFS_CHRDEV_TYPE: {
-+                      squashfs_dev_inode_header inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_dev_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      struct squashfs_dev_inode_header *inodep = &id.dev;
++                      struct squashfs_dev_inode_header *sinodep = &sid.dev;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_DEV_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_DEV_INODE_HEADER(inodep, sinodep);
 +                      } else  
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK;
-+                      init_special_inode(i, i->i_mode, inodep.rdev);
-+                      TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev);
++                      if ((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_mode |= (inodeb->inode_type ==
++                                      SQUASHFS_CHRDEV_TYPE) ?  S_IFCHR :
++                                      S_IFBLK;
++                      init_special_inode(i, i->i_mode, inodep->rdev);
++
++                      TRACE("Device inode %x:%x, rdev %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->rdev);
 +                      break;
 +               }
 +               case SQUASHFS_FIFO_TYPE:
 +               case SQUASHFS_SOCKET_TYPE: {
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodeb.inode_type == SQUASHFS_FIFO_TYPE) ? S_IFIFO : S_IFSOCK;
++                      struct squashfs_ipc_inode_header *inodep = &id.ipc;
++                      struct squashfs_ipc_inode_header *sinodep = &sid.ipc;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_IPC_INODE_HEADER(inodep, sinodep);
++                      } else  
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      if ((i = squashfs_new_inode(s, inodeb)) == NULL)
++                              goto failed_read1;
++
++                      i->i_nlink = inodep->nlink;
++                      i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE)
++                                                      ? S_IFIFO : S_IFSOCK;
 +                      init_special_inode(i, i->i_mode, 0);
 +                      break;
 +               }
 +               default:
-+                      ERROR("Unknown inode type %d in squashfs_iget!\n", inodeb.inode_type);
-+                              goto failed_read1;
++                      ERROR("Unknown inode type %d in squashfs_iget!\n",
++                                      inodeb->inode_type);
++                      goto failed_read1;
 +      }
 +      
-+      if(inodeb.guid == SQUASHFS_GUIDS)
-+              i->i_gid = i->i_uid;
-+      else
-+              i->i_gid = msBlk->guid[inodeb.guid];
-+
 +      insert_inode_hash(i);
 +      return i;
 +
 +failed_read:
-+      ERROR("Unable to read inode [%x:%x]\n", block, offset);
++      ERROR("Unable to read inode [%llx:%x]\n", block, offset);
 +
 +failed_read1:
 +      return NULL;
 +}
 +
 +
++int read_fragment_index_table(struct super_block *s)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++
++      if (!(msblk->fragment_index = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES
++                                      (sblk->fragments), GFP_KERNEL))) {
++              ERROR("Failed to allocate uid/gid table\n");
++              return 0;
++      }
++   
++      if (SQUASHFS_FRAGMENT_INDEX_BYTES(sblk->fragments) &&
++                                      !squashfs_read_data(s, (char *)
++                                      msblk->fragment_index,
++                                      sblk->fragment_table_start,
++                                      SQUASHFS_FRAGMENT_INDEX_BYTES
++                                      (sblk->fragments) |
++                                      SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
++              ERROR("unable to read fragment index table\n");
++              return 0;
++      }
++
++      if (msblk->swap) {
++              int i;
++              long long fragment;
++
++              for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES(sblk->fragments);
++                                                                      i++) {
++                      SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment),
++                                              &msblk->fragment_index[i], 1);
++                      msblk->fragment_index[i] = fragment;
++              }
++      }
++
++      return 1;
++}
++
++
++static int supported_squashfs_filesystem(struct squashfs_sb_info *msblk, int silent)
++{
++      struct squashfs_super_block *sblk = &msblk->sblk;
++
++      msblk->iget = squashfs_iget;
++      msblk->read_blocklist = read_blocklist;
++      msblk->read_fragment_index_table = read_fragment_index_table;
++
++      if (sblk->s_major == 1) {
++              if (!squashfs_1_0_supported(msblk)) {
++                      SERROR("Major/Minor mismatch, Squashfs 1.0 filesystems "
++                              "are unsupported\n");
++                      SERROR("Please recompile with "
++                              "Squashfs 1.0 support enabled\n");
++                      return 0;
++              }
++      } else if (sblk->s_major == 2) {
++              if (!squashfs_2_0_supported(msblk)) {
++                      SERROR("Major/Minor mismatch, Squashfs 2.0 filesystems "
++                              "are unsupported\n");
++                      SERROR("Please recompile with "
++                              "Squashfs 2.0 support enabled\n");
++                      return 0;
++              }
++      } else if(sblk->s_major != SQUASHFS_MAJOR || sblk->s_minor >
++                      SQUASHFS_MINOR) {
++              SERROR("Major/Minor mismatch, trying to mount newer %d.%d "
++                              "filesystem\n", sblk->s_major, sblk->s_minor);
++              SERROR("Please update your kernel\n");
++              return 0;
++      }
++
++      return 1;
++}
++
++
 +static struct super_block *squashfs_read_super(struct super_block *s,
 +              void *data, int silent)
 +{
 +      kdev_t dev = s->s_dev;
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +      int i;
-+
-+      TRACE("Entered squashfs_read_superblock\n");
-+
-+      msBlk->devblksize = get_hardsect_size(dev);
-+      if(msBlk->devblksize < BLOCK_SIZE)
-+              msBlk->devblksize = BLOCK_SIZE;
-+      msBlk->devblksize_log2 = ffz(~msBlk->devblksize);
-+      set_blocksize(dev, msBlk->devblksize);
-+      s->s_blocksize = msBlk->devblksize;
-+      s->s_blocksize_bits = msBlk->devblksize_log2;
-+
-+      init_MUTEX(&msBlk->read_page_mutex);
-+      init_MUTEX(&msBlk->block_cache_mutex);
-+      init_MUTEX(&msBlk->fragment_mutex);
++      struct inode *root;
++      
++      msblk->devblksize = get_hardsect_size(dev);
++      if(msblk->devblksize < BLOCK_SIZE)
++              msblk->devblksize = BLOCK_SIZE;
++      msblk->devblksize_log2 = ffz(~msblk->devblksize);
++        set_blocksize(dev, msblk->devblksize);
++      s->s_blocksize = msblk->devblksize;
++      s->s_blocksize_bits = msblk->devblksize_log2;
 +      
-+      init_waitqueue_head(&msBlk->waitq);
-+      init_waitqueue_head(&msBlk->fragment_wait_queue);
++      init_MUTEX(&msblk->read_data_mutex);
++      init_MUTEX(&msblk->read_page_mutex);
++      init_MUTEX(&msblk->block_cache_mutex);
++      init_MUTEX(&msblk->fragment_mutex);
++      
++      init_waitqueue_head(&msblk->waitq);
++      init_waitqueue_head(&msblk->fragment_wait_queue);
 +
-+      if(!read_data(s, (char *) sBlk, SQUASHFS_START, sizeof(squashfs_super_block) | SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
++      if (!squashfs_read_data(s, (char *) sblk, SQUASHFS_START,
++                                      sizeof(struct squashfs_super_block) |
++                                      SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
 +              SERROR("unable to read superblock\n");
 +              goto failed_mount;
 +      }
 +
 +      /* Check it is a SQUASHFS superblock */
-+      msBlk->swap = 0;
-+      if((s->s_magic = sBlk->s_magic) != SQUASHFS_MAGIC) {
-+              if(sBlk->s_magic == SQUASHFS_MAGIC_SWAP) {
-+                      squashfs_super_block sblk;
-+                      WARNING("Mounting a different endian SQUASHFS filesystem on %s\n", bdevname(dev));
-+                      SQUASHFS_SWAP_SUPER_BLOCK(&sblk, sBlk);
-+                      memcpy(sBlk, &sblk, sizeof(squashfs_super_block));
-+                      msBlk->swap = 1;
++      msblk->swap = 0;
++      if ((s->s_magic = sblk->s_magic) != SQUASHFS_MAGIC) {
++              if (sblk->s_magic == SQUASHFS_MAGIC_SWAP) {
++                      struct squashfs_super_block ssblk;
++
++                      WARNING("Mounting a different endian SQUASHFS "
++                              "filesystem on %s\n", bdevname(dev));
++
++                      SQUASHFS_SWAP_SUPER_BLOCK(&ssblk, sblk);
++                      memcpy(sblk, &ssblk, sizeof(struct squashfs_super_block));
++                      msblk->swap = 1;
 +              } else  {
-+                      SERROR("Can't find a SQUASHFS superblock on %s\n", bdevname(dev));
++                      SERROR("Can't find a SQUASHFS superblock on %s\n",
++                                                      bdevname(dev));
 +                      goto failed_mount;
 +              }
 +      }
 +
 +      /* Check the MAJOR & MINOR versions */
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+      if((sBlk->s_major != 1) && (sBlk->s_major != 2 || sBlk->s_minor > SQUASHFS_MINOR)) {
-+              SERROR("Major/Minor mismatch, filesystem is (%d:%d), I support (1 : x) or (2 : <= %d)\n",
-+                              sBlk->s_major, sBlk->s_minor, SQUASHFS_MINOR);
-+              goto failed_mount;
-+      }
-+      if(sBlk->s_major == 1)
-+              sBlk->block_size = sBlk->block_size_1;
-+#else
-+      if(sBlk->s_major != SQUASHFS_MAJOR || sBlk->s_minor > SQUASHFS_MINOR) {
-+              SERROR("Major/Minor mismatch, filesystem is (%d:%d), I support (%d: <= %d)\n",
-+                              sBlk->s_major, sBlk->s_minor, SQUASHFS_MAJOR, SQUASHFS_MINOR);
++      if(!supported_squashfs_filesystem(msblk, silent))
 +              goto failed_mount;
-+      }
-+#endif
 +
 +      TRACE("Found valid superblock on %s\n", bdevname(dev));
-+      TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : "");
-+      TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(sBlk->flags) ? "un" : "");
-+      TRACE("Check data is %s present in the filesystem\n", SQUASHFS_CHECK_DATA(sBlk->flags) ? "" : "not");
-+      TRACE("Filesystem size %d bytes\n", sBlk->bytes_used);
-+      TRACE("Block size %d\n", sBlk->block_size);
-+      TRACE("Number of inodes %d\n", sBlk->inodes);
-+      if(sBlk->s_major > 1)
-+              TRACE("Number of fragments %d\n", sBlk->fragments);
-+      TRACE("Number of uids %d\n", sBlk->no_uids);
-+      TRACE("Number of gids %d\n", sBlk->no_guids);
-+      TRACE("sBlk->inode_table_start %x\n", sBlk->inode_table_start);
-+      TRACE("sBlk->directory_table_start %x\n", sBlk->directory_table_start);
-+              if(sBlk->s_major > 1)
-+      TRACE("sBlk->fragment_table_start %x\n", sBlk->fragment_table_start);
-+      TRACE("sBlk->uid_start %x\n", sBlk->uid_start);
++      TRACE("Inodes are %scompressed\n",
++                                      SQUASHFS_UNCOMPRESSED_INODES
++                                      (sblk->flags) ? "un" : "");
++      TRACE("Data is %scompressed\n",
++                                      SQUASHFS_UNCOMPRESSED_DATA(sblk->flags)
++                                      ? "un" : "");
++      TRACE("Check data is %s present in the filesystem\n",
++                                      SQUASHFS_CHECK_DATA(sblk->flags) ?
++                                      "" : "not");
++      TRACE("Filesystem size %lld bytes\n", sblk->bytes_used);
++      TRACE("Block size %d\n", sblk->block_size);
++      TRACE("Number of inodes %d\n", sblk->inodes);
++      if (sblk->s_major > 1)
++              TRACE("Number of fragments %d\n", sblk->fragments);
++      TRACE("Number of uids %d\n", sblk->no_uids);
++      TRACE("Number of gids %d\n", sblk->no_guids);
++      TRACE("sblk->inode_table_start %llx\n", sblk->inode_table_start);
++      TRACE("sblk->directory_table_start %llx\n", sblk->directory_table_start);
++      if (sblk->s_major > 1)
++              TRACE("sblk->fragment_table_start %llx\n",
++                                      sblk->fragment_table_start);
++      TRACE("sblk->uid_start %llx\n", sblk->uid_start);
 +
 +      s->s_flags |= MS_RDONLY;
 +      s->s_op = &squashfs_ops;
 +
 +      /* Init inode_table block pointer array */
-+      if(!(msBlk->block_cache = (squashfs_cache *) kmalloc(sizeof(squashfs_cache) * SQUASHFS_CACHED_BLKS, GFP_KERNEL))) {
++      if (!(msblk->block_cache = kmalloc(sizeof(struct squashfs_cache) *
++                                      SQUASHFS_CACHED_BLKS, GFP_KERNEL))) {
 +              ERROR("Failed to allocate block cache\n");
 +              goto failed_mount;
 +      }
 +
-+      for(i = 0; i < SQUASHFS_CACHED_BLKS; i++)
-+              msBlk->block_cache[i].block = SQUASHFS_INVALID_BLK;
++      for (i = 0; i < SQUASHFS_CACHED_BLKS; i++)
++              msblk->block_cache[i].block = SQUASHFS_INVALID_BLK;
 +
-+      msBlk->next_cache = 0;
++      msblk->next_cache = 0;
 +
 +      /* Allocate read_data block */
-+      msBlk->read_size = (sBlk->block_size < SQUASHFS_METADATA_SIZE) ? SQUASHFS_METADATA_SIZE : sBlk->block_size;
-+      if(!(msBlk->read_data = (char *) kmalloc(msBlk->read_size, GFP_KERNEL))) {
++      msblk->read_size = (sblk->block_size < SQUASHFS_METADATA_SIZE) ?
++                                      SQUASHFS_METADATA_SIZE :
++                                      sblk->block_size;
++
++      if (!(msblk->read_data = kmalloc(msblk->read_size, GFP_KERNEL))) {
 +              ERROR("Failed to allocate read_data block\n");
-+              goto failed_mount1;
++              goto failed_mount;
 +      }
 +
 +      /* Allocate read_page block */
-+      if(sBlk->block_size > PAGE_CACHE_SIZE) {
-+              if(!(msBlk->read_page = (char *) kmalloc(sBlk->block_size, GFP_KERNEL))) {
-+                      ERROR("Failed to allocate read_page block\n");
-+                      goto failed_mount2;
-+              }
-+      } else
-+              msBlk->read_page = NULL;
++      if (!(msblk->read_page = kmalloc(sblk->block_size, GFP_KERNEL))) {
++              ERROR("Failed to allocate read_page block\n");
++              goto failed_mount;
++      }
 +
 +      /* Allocate uid and gid tables */
-+      if(!(msBlk->uid = (squashfs_uid *) kmalloc((sBlk->no_uids +
-+              sBlk->no_guids) * sizeof(squashfs_uid), GFP_KERNEL))) {
++      if (!(msblk->uid = kmalloc((sblk->no_uids + sblk->no_guids) *
++                                      sizeof(unsigned int), GFP_KERNEL))) {
 +              ERROR("Failed to allocate uid/gid table\n");
-+              goto failed_mount3;
++              goto failed_mount;
 +      }
-+      msBlk->guid = msBlk->uid + sBlk->no_uids;
++      msblk->guid = msblk->uid + sblk->no_uids;
 +   
-+      if(msBlk->swap) {
-+              squashfs_uid suid[sBlk->no_uids + sBlk->no_guids];
-+
-+              if(!read_data(s, (char *) &suid, sBlk->uid_start, ((sBlk->no_uids + sBlk->no_guids) *
-+                              sizeof(squashfs_uid)) | SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
-+                      SERROR("unable to read uid/gid table\n");
-+                      goto failed_mount4;
++      if (msblk->swap) {
++              unsigned int suid[sblk->no_uids + sblk->no_guids];
++
++              if (!squashfs_read_data(s, (char *) &suid, sblk->uid_start,
++                                      ((sblk->no_uids + sblk->no_guids) *
++                                       sizeof(unsigned int)) |
++                                      SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
++                      ERROR("unable to read uid/gid table\n");
++                      goto failed_mount;
 +              }
-+              SQUASHFS_SWAP_DATA(msBlk->uid, suid, (sBlk->no_uids + sBlk->no_guids), (sizeof(squashfs_uid) * 8));
++
++              SQUASHFS_SWAP_DATA(msblk->uid, suid, (sblk->no_uids +
++                      sblk->no_guids), (sizeof(unsigned int) * 8));
 +      } else
-+              if(!read_data(s, (char *) msBlk->uid, sBlk->uid_start, ((sBlk->no_uids + sBlk->no_guids) *
-+                              sizeof(squashfs_uid)) | SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
-+                      SERROR("unable to read uid/gid table\n");
-+                      goto failed_mount4;
++              if (!squashfs_read_data(s, (char *) msblk->uid, sblk->uid_start,
++                                      ((sblk->no_uids + sblk->no_guids) *
++                                       sizeof(unsigned int)) |
++                                      SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
++                      ERROR("unable to read uid/gid table\n");
++                      goto failed_mount;
 +              }
 +
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+      if(sBlk->s_major == 1) {
-+              msBlk->iget = squashfs_iget_1;
-+              msBlk->read_blocklist = read_blocklist_1;
-+              msBlk->fragment = NULL;
-+              msBlk->fragment_index = NULL;
++      if (sblk->s_major == 1 && squashfs_1_0_supported(msblk))
 +              goto allocate_root;
-+      }
-+#endif
-+      msBlk->iget = squashfs_iget;
-+      msBlk->read_blocklist = read_blocklist;
 +
-+      if(!(msBlk->fragment = (struct squashfs_fragment_cache *) kmalloc(sizeof(struct squashfs_fragment_cache) * SQUASHFS_CACHED_FRAGMENTS, GFP_KERNEL))) {
++      if (!(msblk->fragment = kmalloc(sizeof(struct squashfs_fragment_cache) *
++                              SQUASHFS_CACHED_FRAGMENTS, GFP_KERNEL))) {
 +              ERROR("Failed to allocate fragment block cache\n");
-+              goto failed_mount4;
++              goto failed_mount;
 +      }
 +
-+      for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) {
-+              msBlk->fragment[i].locked = 0;
-+              msBlk->fragment[i].block = SQUASHFS_INVALID_BLK;
-+              msBlk->fragment[i].data = NULL;
++      for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) {
++              msblk->fragment[i].locked = 0;
++              msblk->fragment[i].block = SQUASHFS_INVALID_BLK;
++              msblk->fragment[i].data = NULL;
 +      }
 +
-+      msBlk->next_fragment = 0;
++      msblk->next_fragment = 0;
 +
 +      /* Allocate fragment index table */
-+      if(!(msBlk->fragment_index = (squashfs_fragment_index *) kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments), GFP_KERNEL))) {
-+              ERROR("Failed to allocate uid/gid table\n");
-+              goto failed_mount5;
-+      }
-+   
-+      if(SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments) &&
-+              !read_data(s, (char *) msBlk->fragment_index, sBlk->fragment_table_start,
-+              SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments) | SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
-+                      SERROR("unable to read fragment index table\n");
-+                      goto failed_mount6;
-+      }
-+
-+      if(msBlk->swap) {
-+              int i;
-+              squashfs_fragment_index fragment;
-+
-+              for(i = 0; i < SQUASHFS_FRAGMENT_INDEXES(sBlk->fragments); i++) {
-+                      SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment), &msBlk->fragment_index[i], 1);
-+                      msBlk->fragment_index[i] = fragment;
-+              }
-+      }
++      if(msblk->read_fragment_index_table(s) == 0)
++              goto failed_mount;
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
 +allocate_root:
-+#endif
-+      if(!(s->s_root = d_alloc_root((msBlk->iget)(s, sBlk->root_inode)))) {
++      if ((root = (msblk->iget)(s, sblk->root_inode)) == NULL)
++              goto failed_mount;
++
++      if ((s->s_root = d_alloc_root(root)) == NULL) {
 +              ERROR("Root inode create failed\n");
-+              goto failed_mount5;
++              iput(root);
++              goto failed_mount;
 +      }
 +
 +      TRACE("Leaving squashfs_read_super\n");
 +      return s;
 +
-+failed_mount6:
-+      kfree(msBlk->fragment_index);
-+failed_mount5:
-+      kfree(msBlk->fragment);
-+failed_mount4:
-+      kfree(msBlk->uid);
-+failed_mount3:
-+      kfree(msBlk->read_page);
-+failed_mount2:
-+      kfree(msBlk->read_data);
-+failed_mount1:
-+      kfree(msBlk->block_cache);
 +failed_mount:
++      kfree(msblk->fragment_index);
++      kfree(msblk->fragment);
++      kfree(msblk->uid);
++      kfree(msblk->read_page);
++      kfree(msblk->read_data);
++      kfree(msblk->block_cache);
++      kfree(msblk->fragment_index_2);
 +      return NULL;
 +}
 +
 +
 +static int squashfs_statfs(struct super_block *s, struct statfs *buf)
 +{
-+      squashfs_super_block *sBlk = &s->u.squashfs_sb.sBlk;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +
 +      TRACE("Entered squashfs_statfs\n");
++
 +      buf->f_type = SQUASHFS_MAGIC;
-+      buf->f_bsize = sBlk->block_size;
-+      buf->f_blocks = ((sBlk->bytes_used - 1) >> sBlk->block_log) + 1;
++      buf->f_bsize = sblk->block_size;
++      buf->f_blocks = ((sblk->bytes_used - 1) >> sblk->block_log) + 1;
 +      buf->f_bfree = buf->f_bavail = 0;
-+      buf->f_files = sBlk->inodes;
++      buf->f_files = sblk->inodes;
 +      buf->f_ffree = 0;
 +      buf->f_namelen = SQUASHFS_NAME_LEN;
++
 +      return 0;
 +}
 +
@@ -1117,35 +1171,41 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +{
 +      struct inode *inode = page->mapping->host;
 +      int index = page->index << PAGE_CACHE_SHIFT, length, bytes;
-+      unsigned int block = inode->u.squashfs_i.start_block;
-+      int offset = inode->u.squashfs_i.offset;
-+      void *pageaddr = kmap(page);
-+
-+      TRACE("Entered squashfs_symlink_readpage, page index %x, start block %x, offset %x\n",
-+              (unsigned int) page->index, inode->u.squashfs_i.start_block, inode->u.squashfs_i.offset);
-+
-+      for(length = 0; length < index; length += bytes) {
-+              if(!(bytes = squashfs_get_cached_block(inode->i_sb, NULL, block, offset,
-+                                      PAGE_CACHE_SIZE, &block, &offset))) {
-+                      ERROR("Unable to read symbolic link [%x:%x]\n", block, offset);
++      long long block = SQUASHFS_I(inode)->start_block;
++      int offset = SQUASHFS_I(inode)->offset;
++      void *pageaddr = kmap(page);
++
++      TRACE("Entered squashfs_symlink_readpage, page index %ld, start block "
++                              "%llx, offset %x\n", page->index,
++                              SQUASHFS_I(inode)->start_block,
++                              SQUASHFS_I(inode)->offset);
++
++      for (length = 0; length < index; length += bytes) {
++              if (!(bytes = squashfs_get_cached_block(inode->i_sb, NULL,
++                              block, offset, PAGE_CACHE_SIZE, &block,
++                              &offset))) {
++                      ERROR("Unable to read symbolic link [%llx:%x]\n", block,
++                                      offset);
 +                      goto skip_read;
 +              }
 +      }
 +
-+      if(length != index) {
++      if (length != index) {
 +              ERROR("(squashfs_symlink_readpage) length != index\n");
 +              bytes = 0;
 +              goto skip_read;
 +      }
 +
-+      bytes = (inode->i_size - length) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE : inode->i_size - length;
-+      if(!(bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block, offset, bytes, &block, &offset)))
-+              ERROR("Unable to read symbolic link [%x:%x]\n", block, offset);
++      bytes = (i_size_read(inode) - length) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE :
++                                      i_size_read(inode) - length;
++
++      if (!(bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block,
++                                      offset, bytes, &block, &offset)))
++              ERROR("Unable to read symbolic link [%llx:%x]\n", block, offset);
 +
 +skip_read:
 +      memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
 +      kunmap(page);
-+      flush_dcache_page(page);
 +      SetPageUptodate(page);
 +      UnlockPage(page);
 +
@@ -1153,159 +1213,358 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +}
 +
 +
-+#define SIZE 256
++struct meta_index *locate_meta_index(struct inode *inode, int index, int offset)
++{
++      struct meta_index *meta = NULL;
++      struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
++      int i;
++
++      down(&msblk->meta_index_mutex);
++
++      TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
++
++      if(msblk->meta_index == NULL)
++              goto not_allocated;
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static unsigned int read_blocklist_1(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize)
++      for (i = 0; i < SQUASHFS_META_NUMBER; i ++)
++              if (msblk->meta_index[i].inode_number == inode->i_ino &&
++                              msblk->meta_index[i].offset >= offset &&
++                              msblk->meta_index[i].offset <= index &&
++                              msblk->meta_index[i].locked == 0) {
++                      TRACE("locate_meta_index: entry %d, offset %d\n", i,
++                                      msblk->meta_index[i].offset);
++                      meta = &msblk->meta_index[i];
++                      offset = meta->offset;
++              }
++
++      if (meta)
++              meta->locked = 1;
++
++not_allocated:
++      up(&msblk->meta_index_mutex);
++
++      return meta;
++}
++
++
++struct meta_index *empty_meta_index(struct inode *inode, int offset, int skip)
 +{
-+      squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb;
-+      unsigned short *block_listp;
-+      int i = 0;
-+      int block_ptr = inode->u.squashfs_i.block_list_start;
-+      int offset = inode->u.squashfs_i.offset;
-+      unsigned int block = inode->u.squashfs_i.start_block;
-+
-+      for(;;) {
-+              int blocks = (index + readahead_blks - i);
-+              if(blocks > (SIZE >> 1)) {
-+                      if((index - i) <= (SIZE >> 1))
-+                              blocks = index - i;
-+                      else
-+                              blocks = SIZE >> 1;
++      struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
++      struct meta_index *meta = NULL;
++      int i;
++
++      down(&msblk->meta_index_mutex);
++
++      TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
++
++      if(msblk->meta_index == NULL) {
++              if (!(msblk->meta_index = kmalloc(sizeof(struct meta_index) *
++                                      SQUASHFS_META_NUMBER, GFP_KERNEL))) {
++                      ERROR("Failed to allocate meta_index\n");
++                      goto failed;
 +              }
++              for(i = 0; i < SQUASHFS_META_NUMBER; i++) {
++                      msblk->meta_index[i].inode_number = 0;
++                      msblk->meta_index[i].locked = 0;
++              }
++              msblk->next_meta_index = 0;
++      }
 +
-+              if(msBlk->swap) {
-+                      unsigned char sblock_list[SIZE];
-+                      if(!squashfs_get_cached_block(inode->i_sb, (char *) sblock_list, block_ptr, offset, blocks << 1, &block_ptr, &offset)) {
-+                              ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset);
-+                              return 0;
-+                      }
-+                      SQUASHFS_SWAP_SHORTS(((unsigned short *)block_list), ((unsigned short *)sblock_list), blocks);
-+              } else
-+                      if(!squashfs_get_cached_block(inode->i_sb, (char *) block_list, block_ptr, offset, blocks << 1, &block_ptr, &offset)) {
-+                              ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset);
-+                              return 0;
-+                      }
-+              for(block_listp = (unsigned short *) block_list; i < index && blocks; i ++, block_listp ++, blocks --)
-+                      block += SQUASHFS_COMPRESSED_SIZE(*block_listp);
-+              if(blocks >= readahead_blks)
-+                      break;
++      for(i = SQUASHFS_META_NUMBER; i &&
++                      msblk->meta_index[msblk->next_meta_index].locked; i --)
++              msblk->next_meta_index = (msblk->next_meta_index + 1) %
++                      SQUASHFS_META_NUMBER;
++
++      if(i == 0) {
++              TRACE("empty_meta_index: failed!\n");
++              goto failed;
 +      }
 +
-+      if(bsize)
-+              *bsize = SQUASHFS_COMPRESSED_SIZE(*block_listp) | (!SQUASHFS_COMPRESSED(*block_listp) ? SQUASHFS_COMPRESSED_BIT_BLOCK : 0);
-+      else
-+              *block_p = block_listp;
-+      return block;
++      TRACE("empty_meta_index: returned meta entry %d, %p\n",
++                      msblk->next_meta_index,
++                      &msblk->meta_index[msblk->next_meta_index]);
++
++      meta = &msblk->meta_index[msblk->next_meta_index];
++      msblk->next_meta_index = (msblk->next_meta_index + 1) %
++                      SQUASHFS_META_NUMBER;
++
++      meta->inode_number = inode->i_ino;
++      meta->offset = offset;
++      meta->skip = skip;
++      meta->entries = 0;
++      meta->locked = 1;
++
++failed:
++      up(&msblk->meta_index_mutex);
++      return meta;
 +}
-+#endif
 +
 +
++void release_meta_index(struct inode *inode, struct meta_index *meta)
++{
++      meta->locked = 0;
++}
++
 +
-+static unsigned int read_blocklist(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize)
++static int read_block_index(struct super_block *s, int blocks, char *block_list,
++              long long *start_block, int *offset)
 +{
-+      squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
 +      unsigned int *block_listp;
-+      int i = 0;
-+      int block_ptr = inode->u.squashfs_i.block_list_start;
-+      int offset = inode->u.squashfs_i.offset;
-+      unsigned int block = inode->u.squashfs_i.start_block;
-+
-+      for(;;) {
-+              int blocks = (index + readahead_blks - i);
-+              if(blocks > (SIZE >> 2)) {
-+                      if((index - i) <= (SIZE >> 2))
-+                              blocks = index - i;
-+                      else
-+                              blocks = SIZE >> 2;
++      int block = 0;
++      
++      if (msblk->swap) {
++              char sblock_list[blocks << 2];
++
++              if (!squashfs_get_cached_block(s, sblock_list, *start_block,
++                              *offset, blocks << 2, start_block, offset)) {
++                      ERROR("Unable to read block list [%llx:%x]\n",
++                              *start_block, *offset);
++                      goto failure;
++              }
++              SQUASHFS_SWAP_INTS(((unsigned int *)block_list),
++                              ((unsigned int *)sblock_list), blocks);
++      } else
++              if (!squashfs_get_cached_block(s, block_list, *start_block,
++                              *offset, blocks << 2, start_block, offset)) {
++                      ERROR("Unable to read block list [%llx:%x]\n",
++                              *start_block, *offset);
++                      goto failure;
 +              }
 +
-+              if(msBlk->swap) {
-+                      unsigned char sblock_list[SIZE];
-+                      if(!squashfs_get_cached_block(inode->i_sb, (char *) sblock_list, block_ptr, offset, blocks << 2, &block_ptr, &offset)) {
-+                              ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset);
-+                              return 0;
-+                      }
-+                      SQUASHFS_SWAP_INTS(((unsigned int *)block_list), ((unsigned int *)sblock_list), blocks);
-+              } else
-+                      if(!squashfs_get_cached_block(inode->i_sb, (char *) block_list, block_ptr, offset, blocks << 2, &block_ptr, &offset)) {
-+                              ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset);
-+                              return 0;
++      for (block_listp = (unsigned int *) block_list; blocks;
++                              block_listp++, blocks --)
++              block += SQUASHFS_COMPRESSED_SIZE_BLOCK(*block_listp);
++
++      return block;
++
++failure:
++      return -1;
++}
++
++
++#define SIZE 256
++
++static inline int calculate_skip(int blocks) {
++      int skip = (blocks - 1) / ((SQUASHFS_SLOTS * SQUASHFS_META_ENTRIES + 1) * SQUASHFS_META_INDEXES);
++      return skip >= 7 ? 7 : skip + 1;
++}
++
++
++static int get_meta_index(struct inode *inode, int index,
++              long long *index_block, int *index_offset,
++              long long *data_block, char *block_list)
++{
++      struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      int skip = calculate_skip(i_size_read(inode) >> sblk->block_log);
++      int offset = 0;
++      struct meta_index *meta;
++      struct meta_entry *meta_entry;
++      long long cur_index_block = SQUASHFS_I(inode)->u.s1.block_list_start;
++      int cur_offset = SQUASHFS_I(inode)->offset;
++      long long cur_data_block = SQUASHFS_I(inode)->start_block;
++      int i;
++ 
++      index /= SQUASHFS_META_INDEXES * skip;
++
++      while ( offset < index ) {
++              meta = locate_meta_index(inode, index, offset + 1);
++
++              if (meta == NULL) {
++                      if ((meta = empty_meta_index(inode, offset + 1,
++                                                      skip)) == NULL)
++                              goto all_done;
++              } else {
++                      offset = index < meta->offset + meta->entries ? index :
++                              meta->offset + meta->entries - 1;
++                      meta_entry = &meta->meta_entry[offset - meta->offset];
++                      cur_index_block = meta_entry->index_block + sblk->inode_table_start;
++                      cur_offset = meta_entry->offset;
++                      cur_data_block = meta_entry->data_block;
++                      TRACE("get_meta_index: offset %d, meta->offset %d, "
++                              "meta->entries %d\n", offset, meta->offset,
++                              meta->entries);
++                      TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
++                              " data_block 0x%llx\n", cur_index_block,
++                              cur_offset, cur_data_block);
++              }
++
++              for (i = meta->offset + meta->entries; i <= index &&
++                              i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
++                      int blocks = skip * SQUASHFS_META_INDEXES;
++
++                      while (blocks) {
++                              int block = blocks > (SIZE >> 2) ? (SIZE >> 2) :
++                                      blocks;
++                              int res = read_block_index(inode->i_sb, block,
++                                      block_list, &cur_index_block,
++                                      &cur_offset);
++
++                              if (res == -1)
++                                      goto failed;
++
++                              cur_data_block += res;
++                              blocks -= block;
 +                      }
-+              for(block_listp = (unsigned int *) block_list; i < index && blocks; i ++, block_listp ++, blocks --)
-+                      block += SQUASHFS_COMPRESSED_SIZE_BLOCK(*block_listp);
-+              if(blocks >= readahead_blks)
-+                      break;
++
++                      meta_entry = &meta->meta_entry[i - meta->offset];
++                      meta_entry->index_block = cur_index_block - sblk->inode_table_start;
++                      meta_entry->offset = cur_offset;
++                      meta_entry->data_block = cur_data_block;
++                      meta->entries ++;
++                      offset ++;
++              }
++
++              TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
++                              meta->offset, meta->entries);
++
++              release_meta_index(inode, meta);
++      }
++
++all_done:
++      *index_block = cur_index_block;
++      *index_offset = cur_offset;
++      *data_block = cur_data_block;
++
++      return offset * SQUASHFS_META_INDEXES * skip;
++
++failed:
++      release_meta_index(inode, meta);
++      return -1;
++}
++
++
++static long long read_blocklist(struct inode *inode, int index,
++                              int readahead_blks, char *block_list,
++                              unsigned short **block_p, unsigned int *bsize)
++{
++      long long block_ptr;
++      int offset;
++      long long block;
++      int res = get_meta_index(inode, index, &block_ptr, &offset, &block,
++              block_list);
++
++      TRACE("read_blocklist: res %d, index %d, block_ptr 0x%llx, offset"
++                     " 0x%x, block 0x%llx\n", res, index, block_ptr, offset,
++                     block);
++
++      if(res == -1)
++              goto failure;
++
++      index -= res;
++
++      while ( index ) {
++              int blocks = index > (SIZE >> 2) ? (SIZE >> 2) : index;
++              int res = read_block_index(inode->i_sb, blocks, block_list,
++                      &block_ptr, &offset);
++              if (res == -1)
++                      goto failure;
++              block += res;
++              index -= blocks;
 +      }
 +
-+      *bsize = *block_listp;
++      if (read_block_index(inode->i_sb, 1, block_list,
++                      &block_ptr, &offset) == -1)
++              goto failure;
++      *bsize = *((unsigned int *) block_list);
++
 +      return block;
++
++failure:
++      return 0;
 +}
 +
 +
 +static int squashfs_readpage(struct file *file, struct page *page)
 +{
 +      struct inode *inode = page->mapping->host;
-+      squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
++      struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +      unsigned char block_list[SIZE];
-+      unsigned int bsize, block, i = 0, bytes = 0, byte_offset = 0;
-+      int index = page->index >> (sBlk->block_log - PAGE_CACHE_SHIFT);
-+      void *pageaddr = kmap(page);
++      long long block;
++      unsigned int bsize, i = 0, bytes = 0, byte_offset = 0;
++      int index = page->index >> (sblk->block_log - PAGE_CACHE_SHIFT);
++      void *pageaddr;
 +      struct squashfs_fragment_cache *fragment = NULL;
-+      char *data_ptr = msBlk->read_page;
++      char *data_ptr = msblk->read_page;
 +      
-+      int mask = (1 << (sBlk->block_log - PAGE_CACHE_SHIFT)) - 1;
++      int mask = (1 << (sblk->block_log - PAGE_CACHE_SHIFT)) - 1;
 +      int start_index = page->index & ~mask;
 +      int end_index = start_index | mask;
 +
-+      TRACE("Entered squashfs_readpage, page index %x, start block %x\n", (unsigned int) page->index,
-+              inode->u.squashfs_i.start_block);
++      TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
++                                      page->index,
++                                      SQUASHFS_I(inode)->start_block);
 +
-+      if(page->index >= ((inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT)) {
++      if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
++                                      PAGE_CACHE_SHIFT))
 +              goto skip_read;
-+      }
 +
-+      if(inode->u.squashfs_i.u.s1.fragment_start_block == SQUASHFS_INVALID_BLK || index < (inode->i_size >> sBlk->block_log)) {
-+              if((block = (msBlk->read_blocklist)(inode, index, 1, block_list, NULL, &bsize)) == 0)
++      if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
++                                      || index < (i_size_read(inode) >>
++                                      sblk->block_log)) {
++              if ((block = (msblk->read_blocklist)(inode, index, 1,
++                                      block_list, NULL, &bsize)) == 0)
 +                      goto skip_read;
 +
-+              down(&msBlk->read_page_mutex);
-+              if(!(bytes = read_data(inode->i_sb, msBlk->read_page, block, bsize, NULL))) {
-+                      ERROR("Unable to read page, block %x, size %x\n", block, bsize);
-+                      up(&msBlk->read_page_mutex);
++              down(&msblk->read_page_mutex);
++              
++              if (!(bytes = squashfs_read_data(inode->i_sb, msblk->read_page,
++                                      block, bsize, NULL))) {
++                      ERROR("Unable to read page, block %llx, size %x\n", block,
++                                      bsize);
++                      up(&msblk->read_page_mutex);
 +                      goto skip_read;
 +              }
 +      } else {
-+              if((fragment = get_cached_fragment(inode->i_sb, inode->u.squashfs_i.u.s1.fragment_start_block, inode->u.squashfs_i.u.s1.fragment_size)) == NULL) {
-+                      ERROR("Unable to read page, block %x, size %x\n", inode->u.squashfs_i.u.s1.fragment_start_block, (int) inode->u.squashfs_i.u.s1.fragment_size);
++              if ((fragment = get_cached_fragment(inode->i_sb,
++                                      SQUASHFS_I(inode)->
++                                      u.s1.fragment_start_block,
++                                      SQUASHFS_I(inode)->u.s1.fragment_size))
++                                      == NULL) {
++                      ERROR("Unable to read page, block %llx, size %x\n",
++                                      SQUASHFS_I(inode)->
++                                      u.s1.fragment_start_block,
++                                      (int) SQUASHFS_I(inode)->
++                                      u.s1.fragment_size);
 +                      goto skip_read;
 +              }
-+              bytes = inode->u.squashfs_i.u.s1.fragment_offset + (inode->i_size & (sBlk->block_size - 1));
-+              byte_offset = inode->u.squashfs_i.u.s1.fragment_offset;
++              bytes = SQUASHFS_I(inode)->u.s1.fragment_offset +
++                                      (i_size_read(inode) & (sblk->block_size
++                                      - 1));
++              byte_offset = SQUASHFS_I(inode)->u.s1.fragment_offset;
 +              data_ptr = fragment->data;
 +      }
 +
-+      for(i = start_index; i <= end_index && byte_offset < bytes; i++, byte_offset += PAGE_CACHE_SIZE) {
++      for (i = start_index; i <= end_index && byte_offset < bytes;
++                                      i++, byte_offset += PAGE_CACHE_SIZE) {
 +              struct page *push_page;
-+              int available_bytes = (bytes - byte_offset) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE : bytes - byte_offset;
-+
-+              TRACE("bytes %d, i %d, byte_offset %d, available_bytes %d\n", bytes, i, byte_offset, available_bytes);
-+
-+              if(i == page->index)  {
-+                      memcpy(pageaddr, data_ptr + byte_offset, available_bytes);
-+                      memset(pageaddr + available_bytes, 0, PAGE_CACHE_SIZE - available_bytes);
-+                      kunmap(page);
++              int available_bytes = (bytes - byte_offset) > PAGE_CACHE_SIZE ?
++                                      PAGE_CACHE_SIZE : bytes - byte_offset;
++
++              TRACE("bytes %d, i %d, byte_offset %d, available_bytes %d\n",
++                                      bytes, i, byte_offset, available_bytes);
++
++              if (i == page->index)  {
++                      pageaddr = kmap_atomic(page, KM_USER0);
++                      memcpy(pageaddr, data_ptr + byte_offset,
++                                      available_bytes);
++                      memset(pageaddr + available_bytes, 0,
++                                      PAGE_CACHE_SIZE - available_bytes);
++                      kunmap_atomic(pageaddr, KM_USER0);
 +                      flush_dcache_page(page);
 +                      SetPageUptodate(page);
 +                      UnlockPage(page);
-+              } else if((push_page = grab_cache_page_nowait(page->mapping, i))) {
-+                      void *pageaddr = kmap(push_page);
-+                      memcpy(pageaddr, data_ptr + byte_offset, available_bytes);
-+                      memset(pageaddr + available_bytes, 0, PAGE_CACHE_SIZE - available_bytes);
-+                      kunmap(push_page);
++              } else if ((push_page =
++                              grab_cache_page_nowait(page->mapping, i))) {
++                      pageaddr = kmap_atomic(push_page, KM_USER0);
++
++                      memcpy(pageaddr, data_ptr + byte_offset,
++                                      available_bytes);
++                      memset(pageaddr + available_bytes, 0,
++                                      PAGE_CACHE_SIZE - available_bytes);
++                      kunmap_atomic(pageaddr, KM_USER0);
 +                      flush_dcache_page(push_page);
 +                      SetPageUptodate(push_page);
 +                      UnlockPage(push_page);
@@ -1313,16 +1572,19 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +              }
 +      }
 +
-+      if(inode->u.squashfs_i.u.s1.fragment_start_block == SQUASHFS_INVALID_BLK || index < (inode->i_size >> sBlk->block_log))
-+              up(&msBlk->read_page_mutex);
++      if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
++                                      || index < (i_size_read(inode) >>
++                                      sblk->block_log))
++              up(&msblk->read_page_mutex);
 +      else
-+              release_cached_fragment(msBlk, fragment);
++              release_cached_fragment(msblk, fragment);
 +
 +      return 0;
 +
 +skip_read:
++      pageaddr = kmap_atomic(page, KM_USER0);
 +      memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
-+      kunmap(page);
++      kunmap_atomic(pageaddr, KM_USER0);
 +      flush_dcache_page(page);
 +      SetPageUptodate(page);
 +      UnlockPage(page);
@@ -1334,39 +1596,61 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +static int squashfs_readpage4K(struct file *file, struct page *page)
 +{
 +      struct inode *inode = page->mapping->host;
-+      squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
++      struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +      unsigned char block_list[SIZE];
-+      unsigned int bsize, block, bytes = 0;
-+      void *pageaddr = kmap(page);
++      long long block;
++      unsigned int bsize, bytes = 0;
++      void *pageaddr;
 +      
-+      TRACE("Entered squashfs_readpage4K, page index %x, start block %x\n", (unsigned int) page->index,
-+              inode->u.squashfs_i.start_block);
++      TRACE("Entered squashfs_readpage4K, page index %lx, start block %llx\n",
++                                      page->index,
++                                      SQUASHFS_I(inode)->start_block);
 +
-+      if(page->index >= ((inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT)) {
++      if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
++                                      PAGE_CACHE_SHIFT)) {
++              pageaddr = kmap_atomic(page, KM_USER0);
 +              goto skip_read;
 +      }
 +
-+      if(inode->u.squashfs_i.u.s1.fragment_start_block == SQUASHFS_INVALID_BLK || page->index < (inode->i_size >> sBlk->block_log)) {
-+              block = (msBlk->read_blocklist)(inode, page->index, 1, block_list, NULL, &bsize);
-+
-+              if(!(bytes = read_data(inode->i_sb, pageaddr, block, bsize, NULL)))
-+                      ERROR("Unable to read page, block %x, size %x\n", block, bsize);
++      if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
++                                      || page->index < (i_size_read(inode) >>
++                                      sblk->block_log)) {
++              block = (msblk->read_blocklist)(inode, page->index, 1,
++                                      block_list, NULL, &bsize);
++
++              down(&msblk->read_page_mutex);
++              bytes = squashfs_read_data(inode->i_sb, msblk->read_page, block,
++                                      bsize, NULL);
++              pageaddr = kmap_atomic(page, KM_USER0);
++              if (bytes)
++                      memcpy(pageaddr, msblk->read_page, bytes);
++              else
++                      ERROR("Unable to read page, block %llx, size %x\n",
++                                      block, bsize);
++              up(&msblk->read_page_mutex);
 +      } else {
-+              struct squashfs_fragment_cache *fragment;
-+
-+              if((fragment = get_cached_fragment(inode->i_sb, inode->u.squashfs_i.u.s1.fragment_start_block, inode->u.squashfs_i.u.s1.fragment_size)) == NULL)
-+                      ERROR("Unable to read page, block %x, size %x\n", inode->u.squashfs_i.u.s1.fragment_start_block, (int) inode->u.squashfs_i.u.s1.fragment_size);
-+              else {
-+                      bytes = inode->i_size & (sBlk->block_size - 1);
-+                      memcpy(pageaddr, fragment->data + inode->u.squashfs_i.u.s1.fragment_offset, bytes);
-+                      release_cached_fragment(msBlk, fragment);
-+              }
++              struct squashfs_fragment_cache *fragment =
++                      get_cached_fragment(inode->i_sb,
++                                      SQUASHFS_I(inode)->
++                                      u.s1.fragment_start_block,
++                                      SQUASHFS_I(inode)-> u.s1.fragment_size);
++              pageaddr = kmap_atomic(page, KM_USER0);
++              if (fragment) {
++                      bytes = i_size_read(inode) & (sblk->block_size - 1);
++                      memcpy(pageaddr, fragment->data + SQUASHFS_I(inode)->
++                                      u.s1.fragment_offset, bytes);
++                      release_cached_fragment(msblk, fragment);
++              } else
++                      ERROR("Unable to read page, block %llx, size %x\n",
++                                      SQUASHFS_I(inode)->
++                                      u.s1.fragment_start_block, (int)
++                                      SQUASHFS_I(inode)-> u.s1.fragment_size);
 +      }
 +
 +skip_read:
 +      memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
-+      kunmap(page);
++      kunmap_atomic(pageaddr, KM_USER0);
 +      flush_dcache_page(page);
 +      SetPageUptodate(page);
 +      UnlockPage(page);
@@ -1375,103 +1659,67 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +}
 +
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static int squashfs_readpage_lessthan4K(struct file *file, struct page *page)
++static int get_dir_index_using_offset(struct super_block *s, long long 
++                              *next_block, unsigned int *next_offset,
++                              long long index_start,
++                              unsigned int index_offset, int i_count,
++                              long long f_pos)
 +{
-+      struct inode *inode = page->mapping->host;
-+      squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      unsigned char block_list[SIZE];
-+      unsigned short *block_listp, block, bytes = 0;
-+      int index = page->index << (PAGE_CACHE_SHIFT - sBlk->block_log);
-+      int file_blocks = ((inode->i_size - 1) >> sBlk->block_log) + 1;
-+      int readahead_blks = 1 << (PAGE_CACHE_SHIFT - sBlk->block_log);
-+      void *pageaddr = kmap(page);
-+      
-+      int i_end = index + (1 << (PAGE_CACHE_SHIFT - sBlk->block_log));
-+      int byte;
-+
-+      TRACE("Entered squashfs_readpage_lessthan4K, page index %x, start block %x\n", (unsigned int) page->index,
-+              inode->u.squashfs_i.start_block);
-+
-+      block = read_blocklist_1(inode, index, readahead_blks, block_list, &block_listp, NULL);
-+
-+      if(i_end > file_blocks)
-+              i_end = file_blocks;
-+
-+      while(index < i_end) {
-+              int c_byte = !SQUASHFS_COMPRESSED(*block_listp) ? SQUASHFS_COMPRESSED_SIZE(*block_listp) | SQUASHFS_COMPRESSED_BIT_BLOCK : *block_listp;
-+              if(!(byte = read_data(inode->i_sb, pageaddr, block, c_byte, NULL))) {
-+                      ERROR("Unable to read page, block %x, size %x\n", block, *block_listp);
-+                      goto skip_read;
-+              }
-+              block += SQUASHFS_COMPRESSED_SIZE(*block_listp);
-+              pageaddr += byte;
-+              bytes += byte;
-+              index ++;
-+              block_listp ++;
-+      }
-+
-+skip_read:
-+      memset(pageaddr, 0, PAGE_CACHE_SIZE - bytes);
-+      kunmap(page);
-+      flush_dcache_page(page);
-+      SetPageUptodate(page);
-+      UnlockPage(page);
-+
-+      return 0;
-+}
-+#endif
-+
-+
-+static int get_dir_index_using_offset(struct super_block *s, unsigned int *next_block,
-+      unsigned int *next_offset, unsigned int index_start, unsigned int index_offset,
-+      int i_count, long long f_pos)
-+{
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +      int i, length = 0;
-+      squashfs_dir_index index;
++      struct squashfs_dir_index index;
 +
-+      TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n", i_count, (unsigned int) f_pos);
++      TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
++                                      i_count, (unsigned int) f_pos);
 +
-+      if(f_pos == 0)
-+              return 0;
++      f_pos -= 3;
++      if (f_pos == 0)
++              goto finish;
 +
-+      for(i = 0; i < i_count; i++) {
-+              if(msBlk->swap) {
-+                      squashfs_dir_index sindex;
-+                      squashfs_get_cached_block(s, (char *) &sindex, index_start, index_offset,
-+                              sizeof(sindex), &index_start, &index_offset);
++      for (i = 0; i < i_count; i++) {
++              if (msblk->swap) {
++                      struct squashfs_dir_index sindex;
++                      squashfs_get_cached_block(s, (char *) &sindex,
++                                      index_start, index_offset,
++                                      sizeof(sindex), &index_start,
++                                      &index_offset);
 +                      SQUASHFS_SWAP_DIR_INDEX(&index, &sindex);
 +              } else
-+                      squashfs_get_cached_block(s, (char *) &index, index_start, index_offset,
-+                              sizeof(index), &index_start, &index_offset);
++                      squashfs_get_cached_block(s, (char *) &index,
++                                      index_start, index_offset,
++                                      sizeof(index), &index_start,
++                                      &index_offset);
 +
-+              if(index.index > f_pos)
++              if (index.index > f_pos)
 +                      break;
 +
 +              squashfs_get_cached_block(s, NULL, index_start, index_offset,
-+                              index.size + 1, &index_start, &index_offset);
++                                      index.size + 1, &index_start,
++                                      &index_offset);
 +
 +              length = index.index;
-+              *next_block = index.start_block + sBlk->directory_table_start;
++              *next_block = index.start_block + sblk->directory_table_start;
 +      }
 +
 +      *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
-+      return length;
++
++finish:
++      return length + 3;
 +}
 +
 +
-+static int get_dir_index_using_name(struct super_block *s, unsigned int *next_block,
-+      unsigned int *next_offset, unsigned int index_start, unsigned int index_offset,
-+      int i_count, const char *name, int size)
++static int get_dir_index_using_name(struct super_block *s, long long
++                              *next_block, unsigned int *next_offset,
++                              long long index_start,
++                              unsigned int index_offset, int i_count,
++                              const char *name, int size)
 +{
-+      squashfs_sb_info *msBlk = &s->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
 +      int i, length = 0;
-+      char buffer[sizeof(squashfs_dir_index) + SQUASHFS_NAME_LEN + 1];
-+      squashfs_dir_index *index = (squashfs_dir_index *) buffer;
++      char buffer[sizeof(struct squashfs_dir_index) + SQUASHFS_NAME_LEN + 1];
++      struct squashfs_dir_index *index = (struct squashfs_dir_index *) buffer;
 +      char str[SQUASHFS_NAME_LEN + 1];
 +
 +      TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
@@ -1479,180 +1727,263 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +      strncpy(str, name, size);
 +      str[size] = '\0';
 +
-+      for(i = 0; i < i_count; i++) {
-+              if(msBlk->swap) {
-+                      squashfs_dir_index sindex;
-+                      squashfs_get_cached_block(s, (char *) &sindex, index_start, index_offset,
-+                              sizeof(sindex), &index_start, &index_offset);
++      for (i = 0; i < i_count; i++) {
++              if (msblk->swap) {
++                      struct squashfs_dir_index sindex;
++                      squashfs_get_cached_block(s, (char *) &sindex,
++                                      index_start, index_offset,
++                                      sizeof(sindex), &index_start,
++                                      &index_offset);
 +                      SQUASHFS_SWAP_DIR_INDEX(index, &sindex);
 +              } else
-+                      squashfs_get_cached_block(s, (char *) index, index_start, index_offset,
-+                              sizeof(squashfs_dir_index), &index_start, &index_offset);
++                      squashfs_get_cached_block(s, (char *) index,
++                                      index_start, index_offset,
++                                      sizeof(struct squashfs_dir_index),
++                                      &index_start, &index_offset);
 +
-+              squashfs_get_cached_block(s, index->name, index_start, index_offset,
-+                              index->size + 1, &index_start, &index_offset);
++              squashfs_get_cached_block(s, index->name, index_start,
++                                      index_offset, index->size + 1,
++                                      &index_start, &index_offset);
 +
 +              index->name[index->size + 1] = '\0';
 +
-+              if(strcmp(index->name, str) > 0)
++              if (strcmp(index->name, str) > 0)
 +                      break;
 +
 +              length = index->index;
-+              *next_block = index->start_block + sBlk->directory_table_start;
++              *next_block = index->start_block + sblk->directory_table_start;
 +      }
 +
 +      *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
-+      return length;
++      return length + 3;
 +}
 +
-+
++              
 +static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
 +{
 +      struct inode *i = file->f_dentry->d_inode;
-+      squashfs_sb_info *msBlk = &i->i_sb->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      int next_block = i->u.squashfs_i.start_block + sBlk->directory_table_start, next_offset =
-+              i->u.squashfs_i.offset, length = 0, dirs_read = 0, dir_count;
-+      squashfs_dir_header dirh;
-+      char buffer[sizeof(squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1];
-+      squashfs_dir_entry *dire = (squashfs_dir_entry *) buffer;
-+
-+      TRACE("Entered squashfs_readdir [%x:%x]\n", next_block, next_offset);
++      struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long next_block = SQUASHFS_I(i)->start_block +
++              sblk->directory_table_start;
++      int next_offset = SQUASHFS_I(i)->offset, length = 0, dirs_read = 0,
++              dir_count;
++      struct squashfs_dir_header dirh;
++      char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1];
++      struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
++
++      TRACE("Entered squashfs_readdir [%llx:%x]\n", next_block, next_offset);
++
++      while(file->f_pos < 3) {
++              char *name;
++              int size, i_ino;
++
++              if(file->f_pos == 0) {
++                      name = ".";
++                      size = 1;
++                      i_ino = i->i_ino;
++              } else {
++                      name = "..";
++                      size = 2;
++                      i_ino = SQUASHFS_I(i)->u.s2.parent_inode;
++              }
++              TRACE("Calling filldir(%x, %s, %d, %d, %d, %d)\n",
++                              (unsigned int) dirent, name, size, (int)
++                              file->f_pos, i_ino,
++                              squashfs_filetype_table[1]);
++
++              if (filldir(dirent, name, size,
++                              file->f_pos, i_ino,
++                              squashfs_filetype_table[1]) < 0) {
++                              TRACE("Filldir returned less than 0\n");
++                              goto finish;
++              }
++              file->f_pos += size;
++              dirs_read++;
++      }
 +
-+      length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset, i->u.squashfs_i.u.s2.directory_index_start,
-+              i->u.squashfs_i.u.s2.directory_index_offset, i->u.squashfs_i.u.s2.directory_index_count, file->f_pos);
++      length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_start,
++                              SQUASHFS_I(i)->u.s2.directory_index_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_count,
++                              file->f_pos);
 +
-+      while(length < i->i_size) {
++      while (length < i_size_read(i)) {
 +              /* read directory header */
-+              if(msBlk->swap) {
-+                      squashfs_dir_header sdirh;
-+                      if(!squashfs_get_cached_block(i->i_sb, (char *) &sdirh, next_block,
-+                                              next_offset, sizeof(sdirh), &next_block, &next_offset))
++              if (msblk->swap) {
++                      struct squashfs_dir_header sdirh;
++                      
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
++                                      next_block, next_offset, sizeof(sdirh),
++                                      &next_block, &next_offset))
 +                              goto failed_read;
++
 +                      length += sizeof(sdirh);
 +                      SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh);
 +              } else {
-+                      if(!squashfs_get_cached_block(i->i_sb, (char *) &dirh, next_block,
-+                                              next_offset, sizeof(dirh), &next_block, &next_offset))
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
++                                      next_block, next_offset, sizeof(dirh),
++                                      &next_block, &next_offset))
 +                              goto failed_read;
++
 +                      length += sizeof(dirh);
 +              }
 +
 +              dir_count = dirh.count + 1;
-+              while(dir_count--) {
-+                      if(msBlk->swap) {
-+                              squashfs_dir_entry sdire;
-+                              if(!squashfs_get_cached_block(i->i_sb, (char *) &sdire, next_block,
-+                                                      next_offset, sizeof(sdire), &next_block, &next_offset))
++              while (dir_count--) {
++                      if (msblk->swap) {
++                              struct squashfs_dir_entry sdire;
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              &sdire, next_block, next_offset,
++                                              sizeof(sdire), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
++                              
 +                              length += sizeof(sdire);
 +                              SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire);
 +                      } else {
-+                              if(!squashfs_get_cached_block(i->i_sb, (char *) dire, next_block,
-+                                                      next_offset, sizeof(*dire), &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              dire, next_block, next_offset,
++                                              sizeof(*dire), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
++
 +                              length += sizeof(*dire);
 +                      }
 +
-+                      if(!squashfs_get_cached_block(i->i_sb, dire->name, next_block,
-+                                              next_offset, dire->size + 1, &next_block, &next_offset))
++                      if (!squashfs_get_cached_block(i->i_sb, dire->name,
++                                              next_block, next_offset,
++                                              dire->size + 1, &next_block,
++                                              &next_offset))
 +                              goto failed_read;
++
 +                      length += dire->size + 1;
 +
-+                      if(file->f_pos >= length)
++                      if (file->f_pos >= length)
 +                              continue;
 +
 +                      dire->name[dire->size + 1] = '\0';
 +
-+                      TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d)\n", (unsigned int) dirent,
-+                      dire->name, dire->size + 1, (int) file->f_pos,
-+                      dirh.start_block, dire->offset, squashfs_filetype_table[dire->type]);
-+
-+                      if(filldir(dirent, dire->name, dire->size + 1, file->f_pos, SQUASHFS_MK_VFS_INODE(dirh.start_block,
-+                                                      dire->offset), squashfs_filetype_table[dire->type]) < 0) {
++                      TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d, %d)\n",
++                                      (unsigned int) dirent, dire->name,
++                                      dire->size + 1, (int) file->f_pos,
++                                      dirh.start_block, dire->offset,
++                                      dirh.inode_number + dire->inode_number,
++                                      squashfs_filetype_table[dire->type]);
++
++                      if (filldir(dirent, dire->name, dire->size + 1,
++                                      file->f_pos,
++                                      dirh.inode_number + dire->inode_number,
++                                      squashfs_filetype_table[dire->type])
++                                      < 0) {
 +                              TRACE("Filldir returned less than 0\n");
-+                              return dirs_read;
++                              goto finish;
 +                      }
-+
 +                      file->f_pos = length;
-+                      dirs_read ++;
++                      dirs_read++;
 +              }
 +      }
 +
++finish:
 +      return dirs_read;
 +
 +failed_read:
-+      ERROR("Unable to read directory block [%x:%x]\n", next_block, next_offset);
++      ERROR("Unable to read directory block [%llx:%x]\n", next_block,
++              next_offset);
 +      return 0;
 +}
 +
 +
 +static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry)
 +{
-+      const char *name =dentry->d_name.name;
++      const unsigned char *name = dentry->d_name.name;
 +      int len = dentry->d_name.len;
 +      struct inode *inode = NULL;
-+      squashfs_sb_info *msBlk = &i->i_sb->u.squashfs_sb;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      int next_block = i->u.squashfs_i.start_block + sBlk->directory_table_start, next_offset =
-+              i->u.squashfs_i.offset, length = 0, dir_count;
-+      squashfs_dir_header dirh;
-+      char buffer[sizeof(squashfs_dir_entry) + SQUASHFS_NAME_LEN];
-+      squashfs_dir_entry *dire = (squashfs_dir_entry *) buffer;
-+      int squashfs_2_1 = sBlk->s_major == 2 && sBlk->s_minor == 1;
-+
-+      TRACE("Entered squashfs_lookup [%x:%x]\n", next_block, next_offset);
-+
-+      length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset, i->u.squashfs_i.u.s2.directory_index_start,
-+              i->u.squashfs_i.u.s2.directory_index_offset, i->u.squashfs_i.u.s2.directory_index_count, name, len);
-+
-+      while(length < i->i_size) {
++      struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long next_block = SQUASHFS_I(i)->start_block +
++                              sblk->directory_table_start;
++      int next_offset = SQUASHFS_I(i)->offset, length = 0,
++                              dir_count;
++      struct squashfs_dir_header dirh;
++      char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN];
++      struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
++
++      TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
++
++      if (len > SQUASHFS_NAME_LEN)
++              goto exit_loop;
++
++      length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_start,
++                              SQUASHFS_I(i)->u.s2.directory_index_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_count, name,
++                              len);
++
++      while (length < i_size_read(i)) {
 +              /* read directory header */
-+              if(msBlk->swap) {
-+                      squashfs_dir_header sdirh;
-+                      if(!squashfs_get_cached_block(i->i_sb, (char *) &sdirh, next_block, next_offset,
-+                                              sizeof(sdirh), &next_block, &next_offset))
++              if (msblk->swap) {
++                      struct squashfs_dir_header sdirh;
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
++                                      next_block, next_offset, sizeof(sdirh),
++                                      &next_block, &next_offset))
 +                              goto failed_read;
++
 +                      length += sizeof(sdirh);
 +                      SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh);
 +              } else {
-+                      if(!squashfs_get_cached_block(i->i_sb, (char *) &dirh, next_block, next_offset,
-+                                              sizeof(dirh), &next_block, &next_offset))
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
++                                      next_block, next_offset, sizeof(dirh),
++                                      &next_block, &next_offset))
 +                              goto failed_read;
++
 +                      length += sizeof(dirh);
 +              }
 +
 +              dir_count = dirh.count + 1;
-+              while(dir_count--) {
-+                      if(msBlk->swap) {
-+                              squashfs_dir_entry sdire;
-+                              if(!squashfs_get_cached_block(i->i_sb, (char *) &sdire,
-+                                                      next_block,next_offset, sizeof(sdire), &next_block, &next_offset))
++              while (dir_count--) {
++                      if (msblk->swap) {
++                              struct squashfs_dir_entry sdire;
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              &sdire, next_block,next_offset,
++                                              sizeof(sdire), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
++                              
 +                              length += sizeof(sdire);
 +                              SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire);
 +                      } else {
-+                              if(!squashfs_get_cached_block(i->i_sb, (char *) dire,
-+                                                      next_block,next_offset, sizeof(*dire), &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              dire, next_block,next_offset,
++                                              sizeof(*dire), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
++
 +                              length += sizeof(*dire);
 +                      }
 +
-+                      if(!squashfs_get_cached_block(i->i_sb, dire->name,
-+                                              next_block, next_offset, dire->size + 1, &next_block, &next_offset))
++                      if (!squashfs_get_cached_block(i->i_sb, dire->name,
++                                      next_block, next_offset, dire->size + 1,
++                                      &next_block, &next_offset))
 +                              goto failed_read;
++
 +                      length += dire->size + 1;
 +
-+                      if(squashfs_2_1 && name[0] < dire->name[0])
++                      if (name[0] < dire->name[0])
 +                              goto exit_loop;
 +
-+                      if((len == dire->size + 1) && !strncmp(name, dire->name, len)) {
-+                              squashfs_inode ino = SQUASHFS_MKINODE(dirh.start_block, dire->offset);
++                      if ((len == dire->size + 1) && !strncmp(name,
++                                              dire->name, len)) {
++                              squashfs_inode_t ino =
++                                      SQUASHFS_MKINODE(dirh.start_block,
++                                      dire->offset);
 +
-+                              TRACE("calling squashfs_iget for directory entry %s, inode %x:%x\n",
-+                                              name, dirh.start_block, dire->offset);
++                              TRACE("calling squashfs_iget for directory "
++                                      "entry %s, inode %x:%x, %d\n", name,
++                                      dirh.start_block, dire->offset,
++                                      dirh.inode_number + dire->inode_number);
 +
-+                              inode = (msBlk->iget)(i->i_sb, ino);
++                              inode = (msblk->iget)(i->i_sb, ino);
 +
 +                              goto exit_loop;
 +                      }
@@ -1664,7 +1995,8 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +      return ERR_PTR(0);
 +
 +failed_read:
-+      ERROR("Unable to read directory block [%x:%x]\n", next_block, next_offset);
++      ERROR("Unable to read directory block [%llx:%x]\n", next_block,
++              next_offset);
 +      goto exit_loop;
 +}
 +
@@ -1673,38 +2005,39 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +{
 +      int i;
 +
-+      squashfs_sb_info *sbi = (squashfs_sb_info *) &s->u.squashfs_sb;
-+      if(sbi->block_cache) {
-+              for(i = 0; i < SQUASHFS_CACHED_BLKS; i++)
-+                      if(sbi->block_cache[i].block != SQUASHFS_INVALID_BLK)
-+                              kfree(sbi->block_cache[i].data);
-+              kfree(sbi->block_cache);
-+      }
-+      if(sbi->read_data) kfree(sbi->read_data);
-+      if(sbi->read_page) kfree(sbi->read_page);
-+      if(sbi->uid) kfree(sbi->uid);
-+      if(sbi->fragment) {
-+              for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) 
-+                      if(sbi->fragment[i].data != NULL)
++              struct squashfs_sb_info *sbi = &s->u.squashfs_sb;
++              if (sbi->block_cache)
++                      for (i = 0; i < SQUASHFS_CACHED_BLKS; i++)
++                              if (sbi->block_cache[i].block !=
++                                                      SQUASHFS_INVALID_BLK)
++                                      kfree(sbi->block_cache[i].data);
++              if (sbi->fragment)
++                      for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) 
 +                              SQUASHFS_FREE(sbi->fragment[i].data);
 +              kfree(sbi->fragment);
-+      }
-+      if(sbi->fragment_index) kfree(sbi->fragment_index);
-+      sbi->block_cache = NULL;
-+      sbi->uid = NULL;
-+      sbi->read_data = NULL;
-+      sbi->read_page = NULL;
-+      sbi->fragment = NULL;
-+      sbi->fragment_index = NULL;
++              kfree(sbi->block_cache);
++              kfree(sbi->read_data);
++              kfree(sbi->read_page);
++              kfree(sbi->uid);
++              kfree(sbi->fragment_index);
++              kfree(sbi->fragment_index_2);
++              sbi->block_cache = NULL;
++              sbi->uid = NULL;
++              sbi->read_data = NULL;
++              sbi->read_page = NULL;
++              sbi->fragment = NULL;
++              sbi->fragment_index = NULL;
++              sbi->fragment_index_2 = NULL;
 +}
 +
 +
 +static int __init init_squashfs_fs(void)
 +{
 +
-+      printk(KERN_INFO "Squashfs 2.2 (released 2005/07/03) (C) 2002-2004, 2005 Phillip Lougher\n");
++      printk(KERN_INFO "squashfs: version 3.0 (2006/03/15) "
++              "Phillip Lougher\n");
 +
-+      if(!(stream.workspace = (char *) vmalloc(zlib_inflate_workspacesize()))) {
++      if (!(stream.workspace = vmalloc(zlib_inflate_workspacesize()))) {
 +              ERROR("Failed to allocate zlib workspace\n");
 +              return -ENOMEM;
 +      }
@@ -1724,11 +2057,11 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/inode.c linux-2.4.31-squashfs2.2/f
 +module_init(init_squashfs_fs);
 +module_exit(exit_squashfs_fs);
 +MODULE_DESCRIPTION("squashfs, a compressed read-only filesystem");
-+MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
++MODULE_AUTHOR("Phillip Lougher <phillip@lougher.org.uk>");
 +MODULE_LICENSE("GPL");
-diff --new-file -urp linux-2.4.31/fs/squashfs/Makefile linux-2.4.31-squashfs2.2/fs/squashfs/Makefile
---- linux-2.4.31/fs/squashfs/Makefile  1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/fs/squashfs/Makefile      2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/fs/squashfs/Makefile linux-2.4.32-squashfs3.0/fs/squashfs/Makefile
+--- linux-2.4.32/fs/squashfs/Makefile  1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/fs/squashfs/Makefile      2006-03-07 21:12:36.000000000 +0000
 @@ -0,0 +1,11 @@
 +#
 +# Makefile for the linux squashfs routines.
@@ -1736,14 +2069,858 @@ diff --new-file -urp linux-2.4.31/fs/squashfs/Makefile linux-2.4.31-squashfs2.2/
 +
 +O_TARGET := squashfs.o
 +
-+obj-y  := inode.o
++obj-y  := inode.o squashfs2_0.o
 +
 +obj-m := $(O_TARGET)
 +
 +include $(TOPDIR)/Rules.make
-diff --new-file -urp linux-2.4.31/include/linux/fs.h linux-2.4.31-squashfs2.2/include/linux/fs.h
---- linux-2.4.31/include/linux/fs.h    2005-04-04 02:42:20.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/include/linux/fs.h        2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/fs/squashfs/squashfs2_0.c linux-2.4.32-squashfs3.0/fs/squashfs/squashfs2_0.c
+--- linux-2.4.32/fs/squashfs/squashfs2_0.c     1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/fs/squashfs/squashfs2_0.c 2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,751 @@
++/*
++ * Squashfs - a compressed read only filesystem for Linux
++ *
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2,
++ * or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++ *
++ * squashfs2_0.c
++ */
++
++#include <linux/types.h>
++#include <linux/squashfs_fs.h>
++#include <linux/module.h>
++#include <linux/errno.h>
++#include <linux/slab.h>
++#include <linux/fs.h>
++#include <linux/smp_lock.h>
++#include <linux/locks.h>
++#include <linux/init.h>
++#include <linux/dcache.h>
++#include <linux/wait.h>
++#include <linux/zlib.h>
++#include <linux/blkdev.h>
++#include <linux/vmalloc.h>
++#include <asm/uaccess.h>
++#include <asm/semaphore.h>
++#include "squashfs.h"
++
++static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir);
++static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry);
++
++static struct file_operations squashfs_dir_ops_2 = {
++      .read = generic_read_dir,
++      .readdir = squashfs_readdir_2
++};
++
++static struct inode_operations squashfs_dir_inode_ops_2 = {
++      .lookup = squashfs_lookup_2
++};
++
++static unsigned char squashfs_filetype_table[] = {
++      DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
++};
++
++static int read_fragment_index_table_2(struct super_block *s)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++
++      if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES_2
++                                      (sblk->fragments), GFP_KERNEL))) {
++              ERROR("Failed to allocate uid/gid table\n");
++              return 0;
++      }
++   
++      if (SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments) &&
++                                      !squashfs_read_data(s, (char *)
++                                      msblk->fragment_index_2,
++                                      sblk->fragment_table_start,
++                                      SQUASHFS_FRAGMENT_INDEX_BYTES_2
++                                      (sblk->fragments) |
++                                      SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
++              ERROR("unable to read fragment index table\n");
++              return 0;
++      }
++
++      if (msblk->swap) {
++              int i;
++              unsigned int fragment;
++
++              for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES_2(sblk->fragments);
++                                                                      i++) {
++                      SQUASHFS_SWAP_FRAGMENT_INDEXES_2((&fragment),
++                                              &msblk->fragment_index_2[i], 1);
++                      msblk->fragment_index_2[i] = fragment;
++              }
++      }
++
++      return 1;
++}
++
++
++static int get_fragment_location_2(struct super_block *s, unsigned int fragment,
++                              long long *fragment_start_block,
++                              unsigned int *fragment_size)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      long long start_block =
++              msblk->fragment_index_2[SQUASHFS_FRAGMENT_INDEX_2(fragment)];
++      int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET_2(fragment);
++      struct squashfs_fragment_entry_2 fragment_entry;
++
++      if (msblk->swap) {
++              struct squashfs_fragment_entry_2 sfragment_entry;
++
++              if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
++                                      start_block, offset,
++                                      sizeof(sfragment_entry), &start_block,
++                                      &offset))
++                      goto out;
++              SQUASHFS_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry);
++      } else
++              if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
++                                      start_block, offset,
++                                      sizeof(fragment_entry), &start_block,
++                                      &offset))
++                      goto out;
++
++      *fragment_start_block = fragment_entry.start_block;
++      *fragment_size = fragment_entry.size;
++
++      return 1;
++
++out:
++      return 0;
++}
++
++
++static struct inode *squashfs_new_inode(struct super_block *s,
++              struct squashfs_base_inode_header_2 *inodeb, unsigned int ino)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      struct inode *i = new_inode(s);
++
++      if (i) {
++              i->i_ino = ino;
++              i->i_mtime = sblk->mkfs_time;
++              i->i_atime = sblk->mkfs_time;
++              i->i_ctime = sblk->mkfs_time;
++              i->i_uid = msblk->uid[inodeb->uid];
++              i->i_mode = inodeb->mode;
++              i->i_nlink = 1;
++              i->i_size = 0;
++              if (inodeb->guid == SQUASHFS_GUIDS)
++                      i->i_gid = i->i_uid;
++              else
++                      i->i_gid = msblk->guid[inodeb->guid];
++      }
++
++      return i;
++}
++
++
++static struct inode *squashfs_iget_2(struct super_block *s, squashfs_inode_t inode)
++{
++      struct inode *i;
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      unsigned int block = SQUASHFS_INODE_BLK(inode) +
++              sblk->inode_table_start;
++      unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
++      unsigned int ino = SQUASHFS_MK_VFS_INODE(block
++              - sblk->inode_table_start, offset);
++      long long next_block;
++      unsigned int next_offset;
++      union squashfs_inode_header_2 id, sid;
++      struct squashfs_base_inode_header_2 *inodeb = &id.base,
++                                        *sinodeb = &sid.base;
++
++      TRACE("Entered squashfs_iget\n");
++
++      if (msblk->swap) {
++              if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
++                                      offset, sizeof(*sinodeb), &next_block,
++                                      &next_offset))
++                      goto failed_read;
++              SQUASHFS_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb,
++                                      sizeof(*sinodeb));
++      } else
++              if (!squashfs_get_cached_block(s, (char *) inodeb, block,
++                                      offset, sizeof(*inodeb), &next_block,
++                                      &next_offset))
++                      goto failed_read;
++
++      switch(inodeb->inode_type) {
++              case SQUASHFS_FILE_TYPE: {
++                      struct squashfs_reg_inode_header_2 *inodep = &id.reg;
++                      struct squashfs_reg_inode_header_2 *sinodep = &sid.reg;
++                      long long frag_blk;
++                      unsigned int frag_size;
++                              
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_REG_INODE_HEADER_2(inodep, sinodep);
++                      } else
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      frag_blk = SQUASHFS_INVALID_BLK;
++                      if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
++                                      !get_fragment_location_2(s,
++                                      inodep->fragment, &frag_blk, &frag_size))
++                              goto failed_read;
++                              
++                      if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_size = inodep->file_size;
++                      i->i_fop = &generic_ro_fops;
++                      i->i_mode |= S_IFREG;
++                      i->i_mtime = inodep->mtime;
++                      i->i_atime = inodep->mtime;
++                      i->i_ctime = inodep->mtime;
++                      i->i_blocks = ((i->i_size - 1) >> 9) + 1;
++                      i->i_blksize = PAGE_CACHE_SIZE;
++                      SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
++                      SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
++                      SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->u.s1.block_list_start = next_block;
++                      SQUASHFS_I(i)->offset = next_offset;
++                      if (sblk->block_size > 4096)
++                              i->i_data.a_ops = &squashfs_aops;
++                      else
++                              i->i_data.a_ops = &squashfs_aops_4K;
++
++                      TRACE("File inode %x:%x, start_block %x, "
++                                      "block_list_start %llx, offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->start_block, next_block,
++                                      next_offset);
++                      break;
++              }
++              case SQUASHFS_DIR_TYPE: {
++                      struct squashfs_dir_inode_header_2 *inodep = &id.dir;
++                      struct squashfs_dir_inode_header_2 *sinodep = &sid.dir;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_DIR_INODE_HEADER_2(inodep, sinodep);
++                      } else
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_size = inodep->file_size;
++                      i->i_op = &squashfs_dir_inode_ops_2;
++                      i->i_fop = &squashfs_dir_ops_2;
++                      i->i_mode |= S_IFDIR;
++                      i->i_mtime = inodep->mtime;
++                      i->i_atime = inodep->mtime;
++                      i->i_ctime = inodep->mtime;
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->offset = inodep->offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_count = 0;
++                      SQUASHFS_I(i)->u.s2.parent_inode = 0;
++
++                      TRACE("Directory inode %x:%x, start_block %x, offset "
++                                      "%x\n", SQUASHFS_INODE_BLK(inode),
++                                      offset, inodep->start_block,
++                                      inodep->offset);
++                      break;
++              }
++              case SQUASHFS_LDIR_TYPE: {
++                      struct squashfs_ldir_inode_header_2 *inodep = &id.ldir;
++                      struct squashfs_ldir_inode_header_2 *sinodep = &sid.ldir;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_LDIR_INODE_HEADER_2(inodep,
++                                              sinodep);
++                      } else
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_size = inodep->file_size;
++                      i->i_op = &squashfs_dir_inode_ops_2;
++                      i->i_fop = &squashfs_dir_ops_2;
++                      i->i_mode |= S_IFDIR;
++                      i->i_mtime = inodep->mtime;
++                      i->i_atime = inodep->mtime;
++                      i->i_ctime = inodep->mtime;
++                      SQUASHFS_I(i)->start_block = inodep->start_block;
++                      SQUASHFS_I(i)->offset = inodep->offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
++                      SQUASHFS_I(i)->u.s2.directory_index_offset =
++                                                              next_offset;
++                      SQUASHFS_I(i)->u.s2.directory_index_count =
++                                                              inodep->i_count;
++                      SQUASHFS_I(i)->u.s2.parent_inode = 0;
++
++                      TRACE("Long directory inode %x:%x, start_block %x, "
++                                      "offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->start_block, inodep->offset);
++                      break;
++              }
++              case SQUASHFS_SYMLINK_TYPE: {
++                      struct squashfs_symlink_inode_header_2 *inodep =
++                                                              &id.symlink;
++                      struct squashfs_symlink_inode_header_2 *sinodep =
++                                                              &sid.symlink;
++      
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(inodep,
++                                                              sinodep);
++                      } else
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_size = inodep->symlink_size;
++                      i->i_op = &page_symlink_inode_operations;
++                      i->i_data.a_ops = &squashfs_symlink_aops;
++                      i->i_mode |= S_IFLNK;
++                      SQUASHFS_I(i)->start_block = next_block;
++                      SQUASHFS_I(i)->offset = next_offset;
++
++                      TRACE("Symbolic link inode %x:%x, start_block %llx, "
++                                      "offset %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      next_block, next_offset);
++                      break;
++               }
++               case SQUASHFS_BLKDEV_TYPE:
++               case SQUASHFS_CHRDEV_TYPE: {
++                      struct squashfs_dev_inode_header_2 *inodep = &id.dev;
++                      struct squashfs_dev_inode_header_2 *sinodep = &sid.dev;
++
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep, sinodep);
++                      } else  
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                      if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_mode |= (inodeb->inode_type ==
++                                      SQUASHFS_CHRDEV_TYPE) ?  S_IFCHR :
++                                      S_IFBLK;
++                      init_special_inode(i, i->i_mode, inodep->rdev);
++
++                      TRACE("Device inode %x:%x, rdev %x\n",
++                                      SQUASHFS_INODE_BLK(inode), offset,
++                                      inodep->rdev);
++                      break;
++               }
++               case SQUASHFS_FIFO_TYPE:
++               case SQUASHFS_SOCKET_TYPE: {
++                      if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
++                              goto failed_read1;
++
++                      i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE)
++                                                      ? S_IFIFO : S_IFSOCK;
++                      init_special_inode(i, i->i_mode, 0);
++                      break;
++               }
++               default:
++                      ERROR("Unknown inode type %d in squashfs_iget!\n",
++                                      inodeb->inode_type);
++                      goto failed_read1;
++      }
++      
++      insert_inode_hash(i);
++      return i;
++
++failed_read:
++      ERROR("Unable to read inode [%x:%x]\n", block, offset);
++
++failed_read1:
++      return NULL;
++}
++
++
++static int get_dir_index_using_offset(struct super_block *s, long long 
++                              *next_block, unsigned int *next_offset,
++                              long long index_start,
++                              unsigned int index_offset, int i_count,
++                              long long f_pos)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      int i, length = 0;
++      struct squashfs_dir_index_2 index;
++
++      TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
++                                      i_count, (unsigned int) f_pos);
++
++      if (f_pos == 0)
++              goto finish;
++
++      for (i = 0; i < i_count; i++) {
++              if (msblk->swap) {
++                      struct squashfs_dir_index_2 sindex;
++                      squashfs_get_cached_block(s, (char *) &sindex,
++                                      index_start, index_offset,
++                                      sizeof(sindex), &index_start,
++                                      &index_offset);
++                      SQUASHFS_SWAP_DIR_INDEX_2(&index, &sindex);
++              } else
++                      squashfs_get_cached_block(s, (char *) &index,
++                                      index_start, index_offset,
++                                      sizeof(index), &index_start,
++                                      &index_offset);
++
++              if (index.index > f_pos)
++                      break;
++
++              squashfs_get_cached_block(s, NULL, index_start, index_offset,
++                                      index.size + 1, &index_start,
++                                      &index_offset);
++
++              length = index.index;
++              *next_block = index.start_block + sblk->directory_table_start;
++      }
++
++      *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
++
++finish:
++      return length;
++}
++
++
++static int get_dir_index_using_name(struct super_block *s, long long
++                              *next_block, unsigned int *next_offset,
++                              long long index_start,
++                              unsigned int index_offset, int i_count,
++                              const char *name, int size)
++{
++      struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      int i, length = 0;
++      char buffer[sizeof(struct squashfs_dir_index_2) + SQUASHFS_NAME_LEN + 1];
++      struct squashfs_dir_index_2 *index = (struct squashfs_dir_index_2 *) buffer;
++      char str[SQUASHFS_NAME_LEN + 1];
++
++      TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
++
++      strncpy(str, name, size);
++      str[size] = '\0';
++
++      for (i = 0; i < i_count; i++) {
++              if (msblk->swap) {
++                      struct squashfs_dir_index_2 sindex;
++                      squashfs_get_cached_block(s, (char *) &sindex,
++                                      index_start, index_offset,
++                                      sizeof(sindex), &index_start,
++                                      &index_offset);
++                      SQUASHFS_SWAP_DIR_INDEX_2(index, &sindex);
++              } else
++                      squashfs_get_cached_block(s, (char *) index,
++                                      index_start, index_offset,
++                                      sizeof(struct squashfs_dir_index_2),
++                                      &index_start, &index_offset);
++
++              squashfs_get_cached_block(s, index->name, index_start,
++                                      index_offset, index->size + 1,
++                                      &index_start, &index_offset);
++
++              index->name[index->size + 1] = '\0';
++
++              if (strcmp(index->name, str) > 0)
++                      break;
++
++              length = index->index;
++              *next_block = index->start_block + sblk->directory_table_start;
++      }
++
++      *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
++      return length;
++}
++
++              
++static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir)
++{
++      struct inode *i = file->f_dentry->d_inode;
++      struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long next_block = SQUASHFS_I(i)->start_block +
++              sblk->directory_table_start;
++      int next_offset = SQUASHFS_I(i)->offset, length = 0, dirs_read = 0,
++              dir_count;
++      struct squashfs_dir_header_2 dirh;
++      char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN + 1];
++      struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
++
++      TRACE("Entered squashfs_readdir_2 [%llx:%x]\n", next_block, next_offset);
++
++      length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_start,
++                              SQUASHFS_I(i)->u.s2.directory_index_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_count,
++                              file->f_pos);
++
++      while (length < i_size_read(i)) {
++              /* read directory header */
++              if (msblk->swap) {
++                      struct squashfs_dir_header_2 sdirh;
++                      
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
++                                      next_block, next_offset, sizeof(sdirh),
++                                      &next_block, &next_offset))
++                              goto failed_read;
++
++                      length += sizeof(sdirh);
++                      SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
++              } else {
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
++                                      next_block, next_offset, sizeof(dirh),
++                                      &next_block, &next_offset))
++                              goto failed_read;
++
++                      length += sizeof(dirh);
++              }
++
++              dir_count = dirh.count + 1;
++              while (dir_count--) {
++                      if (msblk->swap) {
++                              struct squashfs_dir_entry_2 sdire;
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              &sdire, next_block, next_offset,
++                                              sizeof(sdire), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              
++                              length += sizeof(sdire);
++                              SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
++                      } else {
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              dire, next_block, next_offset,
++                                              sizeof(*dire), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                              length += sizeof(*dire);
++                      }
++
++                      if (!squashfs_get_cached_block(i->i_sb, dire->name,
++                                              next_block, next_offset,
++                                              dire->size + 1, &next_block,
++                                              &next_offset))
++                              goto failed_read;
++
++                      length += dire->size + 1;
++
++                      if (file->f_pos >= length)
++                              continue;
++
++                      dire->name[dire->size + 1] = '\0';
++
++                      TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d)\n",
++                                      (unsigned int) dirent, dire->name,
++                                      dire->size + 1, (int) file->f_pos,
++                                      dirh.start_block, dire->offset,
++                                      squashfs_filetype_table[dire->type]);
++
++                      if (filldir(dirent, dire->name, dire->size + 1,
++                                      file->f_pos, SQUASHFS_MK_VFS_INODE(
++                                      dirh.start_block, dire->offset),
++                                      squashfs_filetype_table[dire->type])
++                                      < 0) {
++                              TRACE("Filldir returned less than 0\n");
++                              goto finish;
++                      }
++                      file->f_pos = length;
++                      dirs_read++;
++              }
++      }
++
++finish:
++      return dirs_read;
++
++failed_read:
++      ERROR("Unable to read directory block [%llx:%x]\n", next_block,
++              next_offset);
++      return 0;
++}
++
++
++static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry)
++{
++      const unsigned char *name = dentry->d_name.name;
++      int len = dentry->d_name.len;
++      struct inode *inode = NULL;
++      struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long next_block = SQUASHFS_I(i)->start_block +
++                              sblk->directory_table_start;
++      int next_offset = SQUASHFS_I(i)->offset, length = 0,
++                              dir_count;
++      struct squashfs_dir_header_2 dirh;
++      char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN];
++      struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
++      int sorted = sblk->s_major == 2 && sblk->s_minor >= 1;
++
++      TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
++
++      if (len > SQUASHFS_NAME_LEN)
++              goto exit_loop;
++
++      length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_start,
++                              SQUASHFS_I(i)->u.s2.directory_index_offset,
++                              SQUASHFS_I(i)->u.s2.directory_index_count, name,
++                              len);
++
++      while (length < i_size_read(i)) {
++              /* read directory header */
++              if (msblk->swap) {
++                      struct squashfs_dir_header_2 sdirh;
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
++                                      next_block, next_offset, sizeof(sdirh),
++                                      &next_block, &next_offset))
++                              goto failed_read;
++
++                      length += sizeof(sdirh);
++                      SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
++              } else {
++                      if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
++                                      next_block, next_offset, sizeof(dirh),
++                                      &next_block, &next_offset))
++                              goto failed_read;
++
++                      length += sizeof(dirh);
++              }
++
++              dir_count = dirh.count + 1;
++              while (dir_count--) {
++                      if (msblk->swap) {
++                              struct squashfs_dir_entry_2 sdire;
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              &sdire, next_block,next_offset,
++                                              sizeof(sdire), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++                              
++                              length += sizeof(sdire);
++                              SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
++                      } else {
++                              if (!squashfs_get_cached_block(i->i_sb, (char *)
++                                              dire, next_block,next_offset,
++                                              sizeof(*dire), &next_block,
++                                              &next_offset))
++                                      goto failed_read;
++
++                              length += sizeof(*dire);
++                      }
++
++                      if (!squashfs_get_cached_block(i->i_sb, dire->name,
++                                      next_block, next_offset, dire->size + 1,
++                                      &next_block, &next_offset))
++                              goto failed_read;
++
++                      length += dire->size + 1;
++
++                      if (sorted && name[0] < dire->name[0])
++                              goto exit_loop;
++
++                      if ((len == dire->size + 1) && !strncmp(name,
++                                              dire->name, len)) {
++                              squashfs_inode_t ino =
++                                      SQUASHFS_MKINODE(dirh.start_block,
++                                      dire->offset);
++
++                              TRACE("calling squashfs_iget for directory "
++                                      "entry %s, inode %x:%x, %d\n", name,
++                                      dirh.start_block, dire->offset, ino);
++
++                              inode = (msblk->iget)(i->i_sb, ino);
++
++                              goto exit_loop;
++                      }
++              }
++      }
++
++exit_loop:
++      d_add(dentry, inode);
++      return ERR_PTR(0);
++
++failed_read:
++      ERROR("Unable to read directory block [%llx:%x]\n", next_block,
++              next_offset);
++      goto exit_loop;
++}
++
++
++int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
++{
++      struct squashfs_super_block *sblk = &msblk->sblk;
++
++      msblk->iget = squashfs_iget_2;
++      msblk->read_fragment_index_table = read_fragment_index_table_2;
++
++      sblk->bytes_used = sblk->bytes_used_2;
++      sblk->uid_start = sblk->uid_start_2;
++      sblk->guid_start = sblk->guid_start_2;
++      sblk->inode_table_start = sblk->inode_table_start_2;
++      sblk->directory_table_start = sblk->directory_table_start_2;
++      sblk->fragment_table_start = sblk->fragment_table_start_2;
++
++      return 1;
++}
+diff --new-file -urp linux-2.4.32/fs/squashfs/squashfs.h linux-2.4.32-squashfs3.0/fs/squashfs/squashfs.h
+--- linux-2.4.32/fs/squashfs/squashfs.h        1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/fs/squashfs/squashfs.h    2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,85 @@
++/*
++ * Squashfs - a compressed read only filesystem for Linux
++ *
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2,
++ * or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++ *
++ * squashfs.h
++ */
++
++#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
++#undef CONFIG_SQUASHFS_1_0_COMPATIBILITY
++#endif
++#ifdef SQUASHFS_TRACE
++#define TRACE(s, args...)     printk(KERN_NOTICE "SQUASHFS: "s, ## args)
++#else
++#define TRACE(s, args...)     {}
++#endif
++
++#define ERROR(s, args...)     printk(KERN_ERR "SQUASHFS error: "s, ## args)
++
++#define SERROR(s, args...)    do { \
++                              if (!silent) \
++                              printk(KERN_ERR "SQUASHFS error: "s, ## args);\
++                              } while(0)
++
++#define WARNING(s, args...)   printk(KERN_WARNING "SQUASHFS: "s, ## args)
++
++#define SQUASHFS_I(INO)                       (&INO->u.squashfs_i)
++
++#define i_size_read(INO)              (INO->i_size)
++
++#if defined(CONFIG_SQUASHFS_1_0_COMPATIBILITY ) || defined(CONFIG_SQUASHFS_2_0_COMPATIBILITY)
++#define SQSH_EXTERN
++extern unsigned int squashfs_read_data(struct super_block *s, char *buffer,
++                              long long index, unsigned int length,
++                              long long *next_index);
++extern int squashfs_get_cached_block(struct super_block *s, char *buffer,
++                              long long block, unsigned int offset,
++                              int length, long long *next_block,
++                              unsigned int *next_offset);
++extern void release_cached_fragment(struct squashfs_sb_info *msblk, struct
++                                      squashfs_fragment_cache *fragment);
++extern struct squashfs_fragment_cache *get_cached_fragment(struct super_block
++                                      *s, long long start_block,
++                                      int length);
++extern struct address_space_operations squashfs_symlink_aops;
++extern struct address_space_operations squashfs_aops;
++extern struct address_space_operations squashfs_aops_4K;
++extern struct file_operations squashfs_dir_ops;
++extern struct inode_operations squashfs_dir_inode_ops;
++#else
++#define SQSH_EXTERN static
++#endif
++
++#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
++extern int squashfs_1_0_supported(struct squashfs_sb_info *msblk);
++#else
++static inline int squashfs_1_0_supported(struct squashfs_sb_info *msblk)
++{
++      return 0;
++}
++#endif
++
++#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
++extern int squashfs_2_0_supported(struct squashfs_sb_info *msblk);
++#else
++static inline int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
++{
++      return 0;
++}
++#endif
+diff --new-file -urp linux-2.4.32/include/linux/fs.h linux-2.4.32-squashfs3.0/include/linux/fs.h
+--- linux-2.4.32/include/linux/fs.h    2005-04-04 02:42:20.000000000 +0100
++++ linux-2.4.32-squashfs3.0/include/linux/fs.h        2006-03-07 21:12:36.000000000 +0000
 @@ -324,6 +324,7 @@ extern void set_bh_page(struct buffer_he
  #include <linux/usbdev_fs_i.h>
  #include <linux/jffs2_fs_i.h>
@@ -1776,16 +2953,18 @@ diff --new-file -urp linux-2.4.31/include/linux/fs.h linux-2.4.31-squashfs2.2/in
                void                    *generic_sbp;
        } u;
        /*
-diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squashfs2.2/include/linux/squashfs_fs.h
---- linux-2.4.31/include/linux/squashfs_fs.h   1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/include/linux/squashfs_fs.h       2005-07-04 02:28:51.000000000 +0100
-@@ -0,0 +1,523 @@
+diff --new-file -urp linux-2.4.32/include/linux/squashfs_fs.h linux-2.4.32-squashfs3.0/include/linux/squashfs_fs.h
+--- linux-2.4.32/include/linux/squashfs_fs.h   1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/include/linux/squashfs_fs.h       2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,915 @@
 +#ifndef SQUASHFS_FS
 +#define SQUASHFS_FS
++
 +/*
 + * Squashfs
 + *
-+ * Copyright (c) 2002, 2003, 2004, 2005 Phillip Lougher <phillip@lougher.demon.co.uk>
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
@@ -1804,7 +2983,11 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 + * squashfs_fs.h
 + */
 +
-+#ifdef        CONFIG_SQUASHFS_VMALLOC
++#ifndef CONFIG_SQUASHFS_2_0_COMPATIBILITY
++#define CONFIG_SQUASHFS_2_0_COMPATIBILITY
++#endif
++
++#ifdef CONFIG_SQUASHFS_VMALLOC
 +#define SQUASHFS_ALLOC(a)             vmalloc(a)
 +#define SQUASHFS_FREE(a)              vfree(a)
 +#else
@@ -1812,12 +2995,12 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +#define SQUASHFS_FREE(a)              kfree(a)
 +#endif
 +#ifdef CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
-+#define SQUASHFS_CACHED_FRAGMENTS     CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE     
++#define SQUASHFS_CACHED_FRAGMENTS     CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
 +#else
 +#define SQUASHFS_CACHED_FRAGMENTS     3
 +#endif
-+#define SQUASHFS_MAJOR                        2
-+#define SQUASHFS_MINOR                        1
++#define SQUASHFS_MAJOR                        3
++#define SQUASHFS_MINOR                        0
 +#define SQUASHFS_MAGIC                        0x73717368
 +#define SQUASHFS_MAGIC_SWAP           0x68737173
 +#define SQUASHFS_START                        0
@@ -1840,8 +3023,9 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +#define SQUASHFS_NAME_LEN             256
 +
 +#define SQUASHFS_INVALID              ((long long) 0xffffffffffff)
-+#define SQUASHFS_INVALID_BLK          ((long long) 0xffffffff)
-+#define SQUASHFS_USED_BLK             ((long long) 0xfffffffe)
++#define SQUASHFS_INVALID_FRAG         ((unsigned int) 0xffffffff)
++#define SQUASHFS_INVALID_BLK          ((long long) -1)
++#define SQUASHFS_USED_BLK             ((long long) -2)
 +
 +/* Filesystem flags */
 +#define SQUASHFS_NOI                  0
@@ -1851,15 +3035,34 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +#define SQUASHFS_NO_FRAG              4
 +#define SQUASHFS_ALWAYS_FRAG          5
 +#define SQUASHFS_DUPLICATE            6
++
 +#define SQUASHFS_BIT(flag, bit)               ((flag >> bit) & 1)
-+#define SQUASHFS_UNCOMPRESSED_INODES(flags)   SQUASHFS_BIT(flags, SQUASHFS_NOI)
-+#define SQUASHFS_UNCOMPRESSED_DATA(flags)     SQUASHFS_BIT(flags, SQUASHFS_NOD)
-+#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags)        SQUASHFS_BIT(flags, SQUASHFS_NOF)
-+#define SQUASHFS_NO_FRAGMENTS(flags)          SQUASHFS_BIT(flags, SQUASHFS_NO_FRAG)
-+#define SQUASHFS_ALWAYS_FRAGMENTS(flags)      SQUASHFS_BIT(flags, SQUASHFS_ALWAYS_FRAG)
-+#define SQUASHFS_DUPLICATES(flags)            SQUASHFS_BIT(flags, SQUASHFS_DUPLICATE)
-+#define SQUASHFS_CHECK_DATA(flags)            SQUASHFS_BIT(flags, SQUASHFS_CHECK)
-+#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, duplicate_checking) (noi | (nod << 1) | (check_data << 2) | (nof << 3) | (no_frag << 4) | (always_frag << 5) | (duplicate_checking << 6))
++
++#define SQUASHFS_UNCOMPRESSED_INODES(flags)   SQUASHFS_BIT(flags, \
++                                              SQUASHFS_NOI)
++
++#define SQUASHFS_UNCOMPRESSED_DATA(flags)     SQUASHFS_BIT(flags, \
++                                              SQUASHFS_NOD)
++
++#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags)        SQUASHFS_BIT(flags, \
++                                              SQUASHFS_NOF)
++
++#define SQUASHFS_NO_FRAGMENTS(flags)          SQUASHFS_BIT(flags, \
++                                              SQUASHFS_NO_FRAG)
++
++#define SQUASHFS_ALWAYS_FRAGMENTS(flags)      SQUASHFS_BIT(flags, \
++                                              SQUASHFS_ALWAYS_FRAG)
++
++#define SQUASHFS_DUPLICATES(flags)            SQUASHFS_BIT(flags, \
++                                              SQUASHFS_DUPLICATE)
++
++#define SQUASHFS_CHECK_DATA(flags)            SQUASHFS_BIT(flags, \
++                                              SQUASHFS_CHECK)
++
++#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, \
++              duplicate_checking)     (noi | (nod << 1) | (check_data << 2) \
++              | (nof << 3) | (no_frag << 4) | (always_frag << 5) | \
++              (duplicate_checking << 6))
 +
 +/* Max number of types and file types */
 +#define SQUASHFS_DIR_TYPE             1
@@ -1870,73 +3073,113 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +#define SQUASHFS_FIFO_TYPE            6
 +#define SQUASHFS_SOCKET_TYPE          7
 +#define SQUASHFS_LDIR_TYPE            8
++#define SQUASHFS_LREG_TYPE            9
 +
 +/* 1.0 filesystem type definitions */
 +#define SQUASHFS_TYPES                        5
 +#define SQUASHFS_IPC_TYPE             0
 +
-+/* Flag whether block is compressed or uncompressed, bit is set if block is uncompressed */
++/* Flag whether block is compressed or uncompressed, bit is set if block is
++ * uncompressed */
 +#define SQUASHFS_COMPRESSED_BIT               (1 << 15)
++
 +#define SQUASHFS_COMPRESSED_SIZE(B)   (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
-+                                      (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT)
++              (B) & ~SQUASHFS_COMPRESSED_BIT :  SQUASHFS_COMPRESSED_BIT)
 +
 +#define SQUASHFS_COMPRESSED(B)                (!((B) & SQUASHFS_COMPRESSED_BIT))
 +
 +#define SQUASHFS_COMPRESSED_BIT_BLOCK         (1 << 24)
-+#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B)     (((B) & ~SQUASHFS_COMPRESSED_BIT_BLOCK) ? \
-+                                      (B) & ~SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT_BLOCK)
 +
-+#define SQUASHFS_COMPRESSED_BLOCK(B)          (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
++#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B)     (((B) & \
++      ~SQUASHFS_COMPRESSED_BIT_BLOCK) ? (B) & \
++      ~SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT_BLOCK)
++
++#define SQUASHFS_COMPRESSED_BLOCK(B)  (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
 +
 +/*
-+ * Inode number ops.  Inodes consist of a compressed block number, and an uncompressed
-+ * offset within that block
++ * Inode number ops.  Inodes consist of a compressed block number, and an
++ * uncompressed  offset within that block
 + */
 +#define SQUASHFS_INODE_BLK(a)         ((unsigned int) ((a) >> 16))
++
 +#define SQUASHFS_INODE_OFFSET(a)      ((unsigned int) ((a) & 0xffff))
-+#define SQUASHFS_MKINODE(A, B)                ((squashfs_inode)(((squashfs_inode) (A) << 16)\
-+                                      + (B)))
++
++#define SQUASHFS_MKINODE(A, B)                ((squashfs_inode_t)(((squashfs_inode_t) (A)\
++                                      << 16) + (B)))
 +
 +/* Compute 32 bit VFS inode number from squashfs inode number */
-+#define SQUASHFS_MK_VFS_INODE(a, b)   ((unsigned int) (((a) << 8) + ((b) >> 2) + 1))
++#define SQUASHFS_MK_VFS_INODE(a, b)   ((unsigned int) (((a) << 8) + \
++                                      ((b) >> 2) + 1))
++/* XXX */
 +
 +/* Translate between VFS mode and squashfs mode */
 +#define SQUASHFS_MODE(a)              ((a) & 0xfff)
 +
 +/* fragment and fragment table defines */
-+typedef unsigned int                  squashfs_fragment_index;
-+#define SQUASHFS_FRAGMENT_BYTES(A)    (A * sizeof(squashfs_fragment_entry))
-+#define SQUASHFS_FRAGMENT_INDEX(A)    (SQUASHFS_FRAGMENT_BYTES(A) / SQUASHFS_METADATA_SIZE)
-+#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A)     (SQUASHFS_FRAGMENT_BYTES(A) % SQUASHFS_METADATA_SIZE)
-+#define SQUASHFS_FRAGMENT_INDEXES(A)  ((SQUASHFS_FRAGMENT_BYTES(A) + SQUASHFS_METADATA_SIZE - 1) / SQUASHFS_METADATA_SIZE)
-+#define SQUASHFS_FRAGMENT_INDEX_BYTES(A)      (SQUASHFS_FRAGMENT_INDEXES(A) * sizeof(squashfs_fragment_index))
++#define SQUASHFS_FRAGMENT_BYTES(A)    (A * sizeof(struct squashfs_fragment_entry))
++
++#define SQUASHFS_FRAGMENT_INDEX(A)    (SQUASHFS_FRAGMENT_BYTES(A) / \
++                                      SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A)     (SQUASHFS_FRAGMENT_BYTES(A) % \
++                                              SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEXES(A)  ((SQUASHFS_FRAGMENT_BYTES(A) + \
++                                      SQUASHFS_METADATA_SIZE - 1) / \
++                                      SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEX_BYTES(A)      (SQUASHFS_FRAGMENT_INDEXES(A) *\
++                                              sizeof(long long))
 +
 +/* cached data constants for filesystem */
 +#define SQUASHFS_CACHED_BLKS          8
 +
-+#define SQUASHFS_MAX_FILE_SIZE_LOG    32
-+#define SQUASHFS_MAX_FILE_SIZE                ((long long) 1 << (SQUASHFS_MAX_FILE_SIZE_LOG - 1))
++#define SQUASHFS_MAX_FILE_SIZE_LOG    64
++
++#define SQUASHFS_MAX_FILE_SIZE                ((long long) 1 << \
++                                      (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
 +
 +#define SQUASHFS_MARKER_BYTE          0xff
 +
++/* meta index cache */
++#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
++#define SQUASHFS_META_ENTRIES 31
++#define SQUASHFS_META_NUMBER  8
++#define SQUASHFS_SLOTS                4
++
++struct meta_entry {
++      long long               data_block;
++      unsigned int            index_block;
++      unsigned short          offset;
++      unsigned short          pad;
++};
++
++struct meta_index {
++      unsigned int            inode_number;
++      unsigned int            offset;
++      unsigned short          entries;
++      unsigned short          skip;
++      unsigned short          locked;
++      unsigned short          pad;
++      struct meta_entry       meta_entry[SQUASHFS_META_ENTRIES];
++};
++
 +
 +/*
 + * definitions for structures on disk
 + */
 +
-+typedef unsigned int          squashfs_block;
-+typedef long long             squashfs_inode;
-+
-+typedef unsigned int          squashfs_uid;
++typedef long long             squashfs_block_t;
++typedef long long             squashfs_inode_t;
 +
-+typedef struct squashfs_super_block {
++struct squashfs_super_block {
 +      unsigned int            s_magic;
 +      unsigned int            inodes;
-+      unsigned int            bytes_used;
-+      unsigned int            uid_start;
-+      unsigned int            guid_start;
-+      unsigned int            inode_table_start;
-+      unsigned int            directory_table_start;
++      unsigned int            bytes_used_2;
++      unsigned int            uid_start_2;
++      unsigned int            guid_start_2;
++      unsigned int            inode_table_start_2;
++      unsigned int            directory_table_start_2;
 +      unsigned int            s_major:16;
 +      unsigned int            s_minor:16;
 +      unsigned int            block_size_1:16;
@@ -1945,108 +3188,125 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +      unsigned int            no_uids:8;
 +      unsigned int            no_guids:8;
 +      unsigned int            mkfs_time /* time of filesystem creation */;
-+      squashfs_inode          root_inode;
++      squashfs_inode_t        root_inode;
 +      unsigned int            block_size;
 +      unsigned int            fragments;
-+      unsigned int            fragment_table_start;
-+} __attribute__ ((packed)) squashfs_super_block;
-+
-+typedef struct {
-+      unsigned int            index:27;
-+      unsigned int            start_block:29;
++      unsigned int            fragment_table_start_2;
++      long long               bytes_used;
++      long long               uid_start;
++      long long               guid_start;
++      long long               inode_table_start;
++      long long               directory_table_start;
++      long long               fragment_table_start;
++      long long               unused;
++} __attribute__ ((packed));
++
++struct squashfs_dir_index {
++      unsigned int            index;
++      unsigned int            start_block;
 +      unsigned char           size;
 +      unsigned char           name[0];
-+} __attribute__ ((packed)) squashfs_dir_index;
-+
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
-+} __attribute__ ((packed)) squashfs_base_inode_header;
-+
-+typedef squashfs_base_inode_header squashfs_ipc_inode_header;
-+
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
++} __attribute__ ((packed));
++
++#define SQUASHFS_BASE_INODE_HEADER            \
++      unsigned int            inode_type:4;   \
++      unsigned int            mode:12;        \
++      unsigned int            uid:8;          \
++      unsigned int            guid:8;         \
++      unsigned int            mtime;          \
++      unsigned int            inode_number;
++
++struct squashfs_base_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++} __attribute__ ((packed));
++
++struct squashfs_ipc_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
++} __attribute__ ((packed));
++
++struct squashfs_dev_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
 +      unsigned short          rdev;
-+} __attribute__ ((packed)) squashfs_dev_inode_header;
++} __attribute__ ((packed));
 +      
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
++struct squashfs_symlink_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
 +      unsigned short          symlink_size;
 +      char                    symlink[0];
-+} __attribute__ ((packed)) squashfs_symlink_inode_header;
++} __attribute__ ((packed));
 +
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
-+      unsigned int            mtime;
-+      squashfs_block          start_block;
++struct squashfs_reg_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      squashfs_block_t        start_block;
 +      unsigned int            fragment;
 +      unsigned int            offset;
-+      unsigned int            file_size:SQUASHFS_MAX_FILE_SIZE_LOG;
++      unsigned int            file_size;
 +      unsigned short          block_list[0];
-+} __attribute__ ((packed)) squashfs_reg_inode_header;
++} __attribute__ ((packed));
 +
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
++struct squashfs_lreg_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
++      squashfs_block_t        start_block;
++      unsigned int            fragment;
++      unsigned int            offset;
++      long long               file_size;
++      unsigned short          block_list[0];
++} __attribute__ ((packed));
++
++struct squashfs_dir_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
 +      unsigned int            file_size:19;
 +      unsigned int            offset:13;
-+      unsigned int            mtime;
-+      unsigned int            start_block:24;
-+} __attribute__  ((packed)) squashfs_dir_inode_header;
++      unsigned int            start_block;
++      unsigned int            parent_inode;
++} __attribute__  ((packed));
 +
-+typedef struct {
-+      unsigned int            inode_type:4;
-+      unsigned int            mode:12; /* protection */
-+      unsigned int            uid:8; /* index into uid table */
-+      unsigned int            guid:8; /* index into guid table */
++struct squashfs_ldir_inode_header {
++      SQUASHFS_BASE_INODE_HEADER;
++      unsigned int            nlink;
 +      unsigned int            file_size:27;
 +      unsigned int            offset:13;
-+      unsigned int            mtime;
-+      unsigned int            start_block:24;
++      unsigned int            start_block;
 +      unsigned int            i_count:16;
-+      squashfs_dir_index      index[0];
-+} __attribute__  ((packed)) squashfs_ldir_inode_header;
-+
-+typedef union {
-+      squashfs_base_inode_header      base;
-+      squashfs_dev_inode_header       dev;
-+      squashfs_symlink_inode_header   symlink;
-+      squashfs_reg_inode_header       reg;
-+      squashfs_dir_inode_header       dir;
-+      squashfs_ldir_inode_header      ldir;
-+      squashfs_ipc_inode_header       ipc;
-+} squashfs_inode_header;
++      unsigned int            parent_inode;
++      struct squashfs_dir_index       index[0];
++} __attribute__  ((packed));
++
++union squashfs_inode_header {
++      struct squashfs_base_inode_header       base;
++      struct squashfs_dev_inode_header        dev;
++      struct squashfs_symlink_inode_header    symlink;
++      struct squashfs_reg_inode_header        reg;
++      struct squashfs_lreg_inode_header       lreg;
++      struct squashfs_dir_inode_header        dir;
++      struct squashfs_ldir_inode_header       ldir;
++      struct squashfs_ipc_inode_header        ipc;
++};
 +      
-+typedef struct {
++struct squashfs_dir_entry {
 +      unsigned int            offset:13;
 +      unsigned int            type:3;
 +      unsigned int            size:8;
++      int                     inode_number:16;
 +      char                    name[0];
-+} __attribute__ ((packed)) squashfs_dir_entry;
++} __attribute__ ((packed));
 +
-+typedef struct {
++struct squashfs_dir_header {
 +      unsigned int            count:8;
-+      unsigned int            start_block:24;
-+} __attribute__ ((packed)) squashfs_dir_header;
-+
-+typedef struct {
 +      unsigned int            start_block;
++      unsigned int            inode_number;
++} __attribute__ ((packed));
++
++struct squashfs_fragment_entry {
++      long long               start_block;
 +      unsigned int            size;
-+} __attribute__ ((packed)) squashfs_fragment_entry;
++      unsigned int            unused;
++} __attribute__ ((packed));
 +
 +extern int squashfs_uncompress_block(void *d, int dstlen, void *s, int srclen);
 +extern int squashfs_uncompress_init(void);
@@ -2054,20 +3314,28 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +
 +/*
 + * macros to convert each packed bitfield structure from little endian to big
-+ * endian and vice versa.  These are needed when creating or using a filesystem on a
-+ * machine with different byte ordering to the target architecture.
++ * endian and vice versa.  These are needed when creating or using a filesystem
++ * on a machine with different byte ordering to the target architecture.
 + *
 + */
 +
++#define SQUASHFS_SWAP_START \
++      int bits;\
++      int b_pos;\
++      unsigned long long val;\
++      unsigned char *s;\
++      unsigned char *d;
++
 +#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) {\
-+      SQUASHFS_MEMSET(s, d, sizeof(squashfs_super_block));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_super_block));\
 +      SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\
 +      SQUASHFS_SWAP((s)->inodes, d, 32, 32);\
-+      SQUASHFS_SWAP((s)->bytes_used, d, 64, 32);\
-+      SQUASHFS_SWAP((s)->uid_start, d, 96, 32);\
-+      SQUASHFS_SWAP((s)->guid_start, d, 128, 32);\
-+      SQUASHFS_SWAP((s)->inode_table_start, d, 160, 32);\
-+      SQUASHFS_SWAP((s)->directory_table_start, d, 192, 32);\
++      SQUASHFS_SWAP((s)->bytes_used_2, d, 64, 32);\
++      SQUASHFS_SWAP((s)->uid_start_2, d, 96, 32);\
++      SQUASHFS_SWAP((s)->guid_start_2, d, 128, 32);\
++      SQUASHFS_SWAP((s)->inode_table_start_2, d, 160, 32);\
++      SQUASHFS_SWAP((s)->directory_table_start_2, d, 192, 32);\
 +      SQUASHFS_SWAP((s)->s_major, d, 224, 16);\
 +      SQUASHFS_SWAP((s)->s_minor, d, 240, 16);\
 +      SQUASHFS_SWAP((s)->block_size_1, d, 256, 16);\
@@ -2079,153 +3347,218 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +      SQUASHFS_SWAP((s)->root_inode, d, 344, 64);\
 +      SQUASHFS_SWAP((s)->block_size, d, 408, 32);\
 +      SQUASHFS_SWAP((s)->fragments, d, 440, 32);\
-+      SQUASHFS_SWAP((s)->fragment_table_start, d, 472, 32);\
++      SQUASHFS_SWAP((s)->fragment_table_start_2, d, 472, 32);\
++      SQUASHFS_SWAP((s)->bytes_used, d, 504, 64);\
++      SQUASHFS_SWAP((s)->uid_start, d, 568, 64);\
++      SQUASHFS_SWAP((s)->guid_start, d, 632, 64);\
++      SQUASHFS_SWAP((s)->inode_table_start, d, 696, 64);\
++      SQUASHFS_SWAP((s)->directory_table_start, d, 760, 64);\
++      SQUASHFS_SWAP((s)->fragment_table_start, d, 824, 64);\
++      SQUASHFS_SWAP((s)->unused, d, 888, 64);\
 +}
 +
-+#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, n) {\
++#define SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
 +      SQUASHFS_MEMSET(s, d, n);\
 +      SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
 +      SQUASHFS_SWAP((s)->mode, d, 4, 12);\
 +      SQUASHFS_SWAP((s)->uid, d, 16, 8);\
 +      SQUASHFS_SWAP((s)->guid, d, 24, 8);\
++      SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
++      SQUASHFS_SWAP((s)->inode_number, d, 64, 32);
++
++#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, n) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
 +}
 +
-+#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_ipc_inode_header))
++#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_ipc_inode_header))\
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++}
 +
 +#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_dev_inode_header));\
-+      SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_dev_inode_header)); \
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++      SQUASHFS_SWAP((s)->rdev, d, 128, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_symlink_inode_header));\
-+      SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_symlink_inode_header));\
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++      SQUASHFS_SWAP((s)->symlink_size, d, 128, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_reg_inode_header));\
-+      SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
-+      SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
-+      SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
-+      SQUASHFS_SWAP((s)->offset, d, 128, 32);\
-+      SQUASHFS_SWAP((s)->file_size, d, 160, SQUASHFS_MAX_FILE_SIZE_LOG);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_reg_inode_header));\
++      SQUASHFS_SWAP((s)->start_block, d, 96, 64);\
++      SQUASHFS_SWAP((s)->fragment, d, 160, 32);\
++      SQUASHFS_SWAP((s)->offset, d, 192, 32);\
++      SQUASHFS_SWAP((s)->file_size, d, 224, 32);\
++}
++
++#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_lreg_inode_header));\
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++      SQUASHFS_SWAP((s)->start_block, d, 128, 64);\
++      SQUASHFS_SWAP((s)->fragment, d, 192, 32);\
++      SQUASHFS_SWAP((s)->offset, d, 224, 32);\
++      SQUASHFS_SWAP((s)->file_size, d, 256, 64);\
 +}
 +
 +#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_dir_inode_header));\
-+      SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
-+      SQUASHFS_SWAP((s)->offset, d, 51, 13);\
-+      SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
-+      SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_dir_inode_header));\
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++      SQUASHFS_SWAP((s)->file_size, d, 128, 19);\
++      SQUASHFS_SWAP((s)->offset, d, 147, 13);\
++      SQUASHFS_SWAP((s)->start_block, d, 160, 32);\
++      SQUASHFS_SWAP((s)->parent_inode, d, 192, 32);\
 +}
 +
 +#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_ldir_inode_header));\
-+      SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
-+      SQUASHFS_SWAP((s)->offset, d, 59, 13);\
-+      SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
-+      SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
-+      SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
++                      sizeof(struct squashfs_ldir_inode_header));\
++      SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
++      SQUASHFS_SWAP((s)->file_size, d, 128, 27);\
++      SQUASHFS_SWAP((s)->offset, d, 155, 13);\
++      SQUASHFS_SWAP((s)->start_block, d, 168, 32);\
++      SQUASHFS_SWAP((s)->i_count, d, 200, 16);\
++      SQUASHFS_SWAP((s)->parent_inode, d, 216, 32);\
 +}
 +
 +#define SQUASHFS_SWAP_DIR_INDEX(s, d) {\
-+      SQUASHFS_MEMSET(s, d, sizeof(squashfs_dir_index));\
-+      SQUASHFS_SWAP((s)->index, d, 0, 27);\
-+      SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
-+      SQUASHFS_SWAP((s)->size, d, 56, 8);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index));\
++      SQUASHFS_SWAP((s)->index, d, 0, 32);\
++      SQUASHFS_SWAP((s)->start_block, d, 32, 32);\
++      SQUASHFS_SWAP((s)->size, d, 64, 8);\
 +}
 +
 +#define SQUASHFS_SWAP_DIR_HEADER(s, d) {\
-+      SQUASHFS_MEMSET(s, d, sizeof(squashfs_dir_header));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header));\
 +      SQUASHFS_SWAP((s)->count, d, 0, 8);\
-+      SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
++      SQUASHFS_SWAP((s)->start_block, d, 8, 32);\
++      SQUASHFS_SWAP((s)->inode_number, d, 40, 32);\
 +}
 +
 +#define SQUASHFS_SWAP_DIR_ENTRY(s, d) {\
-+      SQUASHFS_MEMSET(s, d, sizeof(squashfs_dir_entry));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry));\
 +      SQUASHFS_SWAP((s)->offset, d, 0, 13);\
 +      SQUASHFS_SWAP((s)->type, d, 13, 3);\
 +      SQUASHFS_SWAP((s)->size, d, 16, 8);\
++      SQUASHFS_SWAP((s)->inode_number, d, 24, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) {\
-+      SQUASHFS_MEMSET(s, d, sizeof(squashfs_fragment_entry));\
-+      SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
-+      SQUASHFS_SWAP((s)->size, d, 32, 32);\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry));\
++      SQUASHFS_SWAP((s)->start_block, d, 0, 64);\
++      SQUASHFS_SWAP((s)->size, d, 64, 32);\
 +}
 +
 +#define SQUASHFS_SWAP_SHORTS(s, d, n) {\
 +      int entry;\
 +      int bit_position;\
++      SQUASHFS_SWAP_START\
 +      SQUASHFS_MEMSET(s, d, n * 2);\
-+      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += 16)\
++      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
++                      16)\
 +              SQUASHFS_SWAP(s[entry], d, bit_position, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_INTS(s, d, n) {\
 +      int entry;\
 +      int bit_position;\
++      SQUASHFS_SWAP_START\
 +      SQUASHFS_MEMSET(s, d, n * 4);\
-+      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += 32)\
++      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
++                      32)\
 +              SQUASHFS_SWAP(s[entry], d, bit_position, 32);\
 +}
 +
++#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) {\
++      int entry;\
++      int bit_position;\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, n * 8);\
++      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
++                      64)\
++              SQUASHFS_SWAP(s[entry], d, bit_position, 64);\
++}
++
 +#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\
 +      int entry;\
 +      int bit_position;\
++      SQUASHFS_SWAP_START\
 +      SQUASHFS_MEMSET(s, d, n * bits / 8);\
-+      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += bits)\
++      for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
++                      bits)\
 +              SQUASHFS_SWAP(s[entry], d, bit_position, bits);\
 +}
 +
-+#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_INTS(s, d, n)
++#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+typedef struct {
++#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
++
++struct squashfs_base_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
 +      unsigned int            guid:4; /* index into guid table */
-+} __attribute__ ((packed)) squashfs_base_inode_header_1;
++} __attribute__ ((packed));
 +
-+typedef struct {
++struct squashfs_ipc_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
 +      unsigned int            guid:4; /* index into guid table */
 +      unsigned int            type:4;
 +      unsigned int            offset:4;
-+} __attribute__ ((packed)) squashfs_ipc_inode_header_1;
++} __attribute__ ((packed));
 +
-+typedef struct {
++struct squashfs_dev_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
 +      unsigned int            guid:4; /* index into guid table */
 +      unsigned short          rdev;
-+} __attribute__ ((packed)) squashfs_dev_inode_header_1;
++} __attribute__ ((packed));
 +      
-+typedef struct {
++struct squashfs_symlink_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
 +      unsigned int            guid:4; /* index into guid table */
 +      unsigned short          symlink_size;
 +      char                    symlink[0];
-+} __attribute__ ((packed)) squashfs_symlink_inode_header_1;
++} __attribute__ ((packed));
 +
-+typedef struct {
++struct squashfs_reg_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
 +      unsigned int            guid:4; /* index into guid table */
 +      unsigned int            mtime;
-+      squashfs_block          start_block;
-+      unsigned int            file_size:SQUASHFS_MAX_FILE_SIZE_LOG;
++      unsigned int            start_block;
++      unsigned int            file_size:32;
 +      unsigned short          block_list[0];
-+} __attribute__ ((packed)) squashfs_reg_inode_header_1;
++} __attribute__ ((packed));
 +
-+typedef struct {
++struct squashfs_dir_inode_header_1 {
 +      unsigned int            inode_type:4;
 +      unsigned int            mode:12; /* protection */
 +      unsigned int            uid:4; /* index into uid table */
@@ -2234,85 +3567,322 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs.h linux-2.4.31-squas
 +      unsigned int            offset:13;
 +      unsigned int            mtime;
 +      unsigned int            start_block:24;
-+} __attribute__  ((packed)) squashfs_dir_inode_header_1;
++} __attribute__  ((packed));
 +
-+#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
++#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \
 +      SQUASHFS_MEMSET(s, d, n);\
 +      SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
 +      SQUASHFS_SWAP((s)->mode, d, 4, 12);\
 +      SQUASHFS_SWAP((s)->uid, d, 16, 4);\
-+      SQUASHFS_SWAP((s)->guid, d, 20, 4);\
++      SQUASHFS_SWAP((s)->guid, d, 20, 4);
++
++#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\
 +}
 +
 +#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, sizeof(squashfs_ipc_inode_header_1));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
++                      sizeof(struct squashfs_ipc_inode_header_1));\
 +      SQUASHFS_SWAP((s)->type, d, 24, 4);\
 +      SQUASHFS_SWAP((s)->offset, d, 28, 4);\
 +}
 +
 +#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, sizeof(squashfs_dev_inode_header_1));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
++                      sizeof(struct squashfs_dev_inode_header_1));\
 +      SQUASHFS_SWAP((s)->rdev, d, 24, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_symlink_inode_header_1));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
++                      sizeof(struct squashfs_symlink_inode_header_1));\
 +      SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\
 +}
 +
 +#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_reg_inode_header_1));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
++                      sizeof(struct squashfs_reg_inode_header_1));\
 +      SQUASHFS_SWAP((s)->mtime, d, 24, 32);\
 +      SQUASHFS_SWAP((s)->start_block, d, 56, 32);\
-+      SQUASHFS_SWAP((s)->file_size, d, 88, SQUASHFS_MAX_FILE_SIZE_LOG);\
++      SQUASHFS_SWAP((s)->file_size, d, 88, 32);\
 +}
 +
 +#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\
-+      SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_dir_inode_header_1));\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
++                      sizeof(struct squashfs_dir_inode_header_1));\
 +      SQUASHFS_SWAP((s)->file_size, d, 24, 19);\
 +      SQUASHFS_SWAP((s)->offset, d, 43, 13);\
 +      SQUASHFS_SWAP((s)->mtime, d, 56, 32);\
 +      SQUASHFS_SWAP((s)->start_block, d, 88, 24);\
 +}
++
++#endif
++
++#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
++
++struct squashfs_dir_index_2 {
++      unsigned int            index:27;
++      unsigned int            start_block:29;
++      unsigned char           size;
++      unsigned char           name[0];
++} __attribute__ ((packed));
++
++struct squashfs_base_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++} __attribute__ ((packed));
++
++struct squashfs_ipc_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++} __attribute__ ((packed));
++
++struct squashfs_dev_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++      unsigned short          rdev;
++} __attribute__ ((packed));
++      
++struct squashfs_symlink_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++      unsigned short          symlink_size;
++      char                    symlink[0];
++} __attribute__ ((packed));
++
++struct squashfs_reg_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++      unsigned int            mtime;
++      unsigned int            start_block;
++      unsigned int            fragment;
++      unsigned int            offset;
++      unsigned int            file_size:32;
++      unsigned short          block_list[0];
++} __attribute__ ((packed));
++
++struct squashfs_dir_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++      unsigned int            file_size:19;
++      unsigned int            offset:13;
++      unsigned int            mtime;
++      unsigned int            start_block:24;
++} __attribute__  ((packed));
++
++struct squashfs_ldir_inode_header_2 {
++      unsigned int            inode_type:4;
++      unsigned int            mode:12; /* protection */
++      unsigned int            uid:8; /* index into uid table */
++      unsigned int            guid:8; /* index into guid table */
++      unsigned int            file_size:27;
++      unsigned int            offset:13;
++      unsigned int            mtime;
++      unsigned int            start_block:24;
++      unsigned int            i_count:16;
++      struct squashfs_dir_index_2     index[0];
++} __attribute__  ((packed));
++
++union squashfs_inode_header_2 {
++      struct squashfs_base_inode_header_2     base;
++      struct squashfs_dev_inode_header_2      dev;
++      struct squashfs_symlink_inode_header_2  symlink;
++      struct squashfs_reg_inode_header_2      reg;
++      struct squashfs_dir_inode_header_2      dir;
++      struct squashfs_ldir_inode_header_2     ldir;
++      struct squashfs_ipc_inode_header_2      ipc;
++};
++      
++struct squashfs_dir_header_2 {
++      unsigned int            count:8;
++      unsigned int            start_block:24;
++} __attribute__ ((packed));
++
++struct squashfs_dir_entry_2 {
++      unsigned int            offset:13;
++      unsigned int            type:3;
++      unsigned int            size:8;
++      char                    name[0];
++} __attribute__ ((packed));
++
++struct squashfs_fragment_entry_2 {
++      unsigned int            start_block;
++      unsigned int            size;
++} __attribute__ ((packed));
++
++#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
++      SQUASHFS_MEMSET(s, d, n);\
++      SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
++      SQUASHFS_SWAP((s)->mode, d, 4, 12);\
++      SQUASHFS_SWAP((s)->uid, d, 16, 8);\
++      SQUASHFS_SWAP((s)->guid, d, 24, 8);\
++
++#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
++}
++
++#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \
++      SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2))
++
++#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
++                      sizeof(struct squashfs_dev_inode_header_2)); \
++      SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
++}
++
++#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
++                      sizeof(struct squashfs_symlink_inode_header_2));\
++      SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
++}
++
++#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
++                      sizeof(struct squashfs_reg_inode_header_2));\
++      SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
++      SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
++      SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
++      SQUASHFS_SWAP((s)->offset, d, 128, 32);\
++      SQUASHFS_SWAP((s)->file_size, d, 160, 32);\
++}
++
++#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
++                      sizeof(struct squashfs_dir_inode_header_2));\
++      SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
++      SQUASHFS_SWAP((s)->offset, d, 51, 13);\
++      SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
++      SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
++}
++
++#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
++                      sizeof(struct squashfs_ldir_inode_header_2));\
++      SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
++      SQUASHFS_SWAP((s)->offset, d, 59, 13);\
++      SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
++      SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
++      SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
++}
++
++#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\
++      SQUASHFS_SWAP((s)->index, d, 0, 27);\
++      SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
++      SQUASHFS_SWAP((s)->size, d, 56, 8);\
++}
++#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\
++      SQUASHFS_SWAP((s)->count, d, 0, 8);\
++      SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
++}
++
++#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\
++      SQUASHFS_SWAP((s)->offset, d, 0, 13);\
++      SQUASHFS_SWAP((s)->type, d, 13, 3);\
++      SQUASHFS_SWAP((s)->size, d, 16, 8);\
++}
++
++#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\
++      SQUASHFS_SWAP_START\
++      SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\
++      SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
++      SQUASHFS_SWAP((s)->size, d, 32, 32);\
++}
++
++#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS(s, d, n)
++
++/* fragment and fragment table defines */
++#define SQUASHFS_FRAGMENT_BYTES_2(A)  (A * sizeof(struct squashfs_fragment_entry_2))
++
++#define SQUASHFS_FRAGMENT_INDEX_2(A)  (SQUASHFS_FRAGMENT_BYTES_2(A) / \
++                                      SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A)   (SQUASHFS_FRAGMENT_BYTES_2(A) % \
++                                              SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEXES_2(A)        ((SQUASHFS_FRAGMENT_BYTES_2(A) + \
++                                      SQUASHFS_METADATA_SIZE - 1) / \
++                                      SQUASHFS_METADATA_SIZE)
++
++#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A)    (SQUASHFS_FRAGMENT_INDEXES_2(A) *\
++                                              sizeof(int))
++
 +#endif
 +
 +#ifdef __KERNEL__
++
 +/*
 + * macros used to swap each structure entry, taking into account
-+ * bitfields and different bitfield placing conventions on differing architectures
++ * bitfields and different bitfield placing conventions on differing
++ * architectures
 + */
++
 +#include <asm/byteorder.h>
++
 +#ifdef __BIG_ENDIAN
 +      /* convert from little endian to big endian */
-+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, tbits, b_pos)
++#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
++              tbits, b_pos)
 +#else
 +      /* convert from big endian to little endian */ 
-+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, tbits, 64 - tbits - b_pos)
++#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
++              tbits, 64 - tbits - b_pos)
 +#endif
 +
 +#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
-+      int bits;\
-+      int b_pos = pos % 8;\
-+      unsigned long long val = 0;\
-+      unsigned char *s = (unsigned char *)p + (pos / 8);\
-+      unsigned char *d = ((unsigned char *) &val) + 7;\
++      b_pos = pos % 8;\
++      val = 0;\
++      s = (unsigned char *)p + (pos / 8);\
++      d = ((unsigned char *) &val) + 7;\
 +      for(bits = 0; bits < (tbits + b_pos); bits += 8) \
 +              *d-- = *s++;\
 +      value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\
 +}
++
 +#define SQUASHFS_MEMSET(s, d, n)      memset(s, 0, n);
++
 +#endif
 +#endif
-diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs_i.h linux-2.4.31-squashfs2.2/include/linux/squashfs_fs_i.h
---- linux-2.4.31/include/linux/squashfs_fs_i.h 1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/include/linux/squashfs_fs_i.h     2005-07-04 02:28:51.000000000 +0100
-@@ -0,0 +1,42 @@
+diff --new-file -urp linux-2.4.32/include/linux/squashfs_fs_i.h linux-2.4.32-squashfs3.0/include/linux/squashfs_fs_i.h
+--- linux-2.4.32/include/linux/squashfs_fs_i.h 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/include/linux/squashfs_fs_i.h     2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,44 @@
 +#ifndef SQUASHFS_FS_I
 +#define SQUASHFS_FS_I
 +/*
 + * Squashfs
 + *
-+ * Copyright (c) 2002, 2003, 2004, 2005 Phillip Lougher <phillip@lougher.demon.co.uk>
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
@@ -2331,34 +3901,36 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs_i.h linux-2.4.31-squ
 + * squashfs_fs_i.h
 + */
 +
-+typedef struct squashfs_inode_info {
-+      unsigned int    start_block;
-+      unsigned int    block_list_start;
++struct squashfs_inode_info {
++      long long       start_block;
 +      unsigned int    offset;
 +      union {
 +              struct {
-+                      unsigned int    fragment_start_block;
++                      long long       fragment_start_block;
 +                      unsigned int    fragment_size;
 +                      unsigned int    fragment_offset;
++                      long long       block_list_start;
 +              } s1;
 +              struct {
-+                      unsigned int    directory_index_start;
++                      long long       directory_index_start;
 +                      unsigned int    directory_index_offset;
 +                      unsigned int    directory_index_count;
++                      unsigned int    parent_inode;
 +              } s2;
 +      } u;
-+      } squashfs_inode_info;
++};
 +#endif
-diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs_sb.h linux-2.4.31-squashfs2.2/include/linux/squashfs_fs_sb.h
---- linux-2.4.31/include/linux/squashfs_fs_sb.h        1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.4.31-squashfs2.2/include/linux/squashfs_fs_sb.h    2005-07-04 02:28:51.000000000 +0100
-@@ -0,0 +1,65 @@
+diff --new-file -urp linux-2.4.32/include/linux/squashfs_fs_sb.h linux-2.4.32-squashfs3.0/include/linux/squashfs_fs_sb.h
+--- linux-2.4.32/include/linux/squashfs_fs_sb.h        1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-squashfs3.0/include/linux/squashfs_fs_sb.h    2006-03-07 21:12:36.000000000 +0000
+@@ -0,0 +1,74 @@
 +#ifndef SQUASHFS_FS_SB
 +#define SQUASHFS_FS_SB
 +/*
 + * Squashfs
 + *
-+ * Copyright (c) 2002, 2003, 2004, 2005 Phillip Lougher <phillip@lougher.demon.co.uk>
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
@@ -2379,48 +3951,56 @@ diff --new-file -urp linux-2.4.31/include/linux/squashfs_fs_sb.h linux-2.4.31-sq
 +
 +#include <linux/squashfs_fs.h>
 +
-+typedef struct {
-+      unsigned int    block;
++struct squashfs_cache {
++      long long       block;
 +      int             length;
-+      unsigned int    next_index;
++      long long       next_index;
 +      char            *data;
-+      } squashfs_cache;
++};
 +
 +struct squashfs_fragment_cache {
-+      unsigned int    block;
++      long long       block;
 +      int             length;
 +      unsigned int    locked;
 +      char            *data;
-+      };
++};
 +
-+typedef struct squashfs_sb_info {
-+      squashfs_super_block    sBlk;
++struct squashfs_sb_info {
++      struct squashfs_super_block     sblk;
 +      int                     devblksize;
 +      int                     devblksize_log2;
 +      int                     swap;
-+      squashfs_cache          *block_cache;
++      struct squashfs_cache   *block_cache;
 +      struct squashfs_fragment_cache  *fragment;
 +      int                     next_cache;
 +      int                     next_fragment;
-+      squashfs_uid            *uid;
-+      squashfs_uid            *guid;
-+      squashfs_fragment_index         *fragment_index;
++      int                     next_meta_index;
++      unsigned int            *uid;
++      unsigned int            *guid;
++      long long               *fragment_index;
++      unsigned int            *fragment_index_2;
 +      unsigned int            read_size;
 +      char                    *read_data;
 +      char                    *read_page;
++      struct semaphore        read_data_mutex;
 +      struct semaphore        read_page_mutex;
 +      struct semaphore        block_cache_mutex;
 +      struct semaphore        fragment_mutex;
++      struct semaphore        meta_index_mutex;
 +      wait_queue_head_t       waitq;
 +      wait_queue_head_t       fragment_wait_queue;
-+      struct inode            *(*iget)(struct super_block *s, squashfs_inode inode);
-+      unsigned int            (*read_blocklist)(struct inode *inode, int index, int readahead_blks,
-+                                      char *block_list, unsigned short **block_p, unsigned int *bsize);
-+      } squashfs_sb_info;
++      struct meta_index       *meta_index;
++      struct inode            *(*iget)(struct super_block *s,  squashfs_inode_t \
++                              inode);
++      long long               (*read_blocklist)(struct inode *inode, int \
++                              index, int readahead_blks, char *block_list, \
++                              unsigned short **block_p, unsigned int *bsize);
++      int                     (*read_fragment_index_table)(struct super_block *s);
++};
 +#endif
-diff --new-file -urp linux-2.4.31/init/do_mounts.c linux-2.4.31-squashfs2.2/init/do_mounts.c
---- linux-2.4.31/init/do_mounts.c      2003-11-28 18:26:21.000000000 +0000
-+++ linux-2.4.31-squashfs2.2/init/do_mounts.c  2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/init/do_mounts.c linux-2.4.32-squashfs3.0/init/do_mounts.c
+--- linux-2.4.32/init/do_mounts.c      2003-11-28 18:26:21.000000000 +0000
++++ linux-2.4.32-squashfs3.0/init/do_mounts.c  2006-03-07 21:12:36.000000000 +0000
 @@ -15,6 +15,7 @@
  #include <linux/minix_fs.h>
  #include <linux/ext2_fs.h>
@@ -2469,9 +4049,9 @@ diff --new-file -urp linux-2.4.31/init/do_mounts.c linux-2.4.31-squashfs2.2/init
        /*
         * Read block 1 to test for minix and ext2 superblock
         */
-diff --new-file -urp linux-2.4.31/lib/Config.in linux-2.4.31-squashfs2.2/lib/Config.in
---- linux-2.4.31/lib/Config.in 2003-11-28 18:26:21.000000000 +0000
-+++ linux-2.4.31-squashfs2.2/lib/Config.in     2005-07-04 02:28:51.000000000 +0100
+diff --new-file -urp linux-2.4.32/lib/Config.in linux-2.4.32-squashfs3.0/lib/Config.in
+--- linux-2.4.32/lib/Config.in 2003-11-28 18:26:21.000000000 +0000
++++ linux-2.4.32-squashfs3.0/lib/Config.in     2006-03-07 21:12:36.000000000 +0000
 @@ -10,6 +10,7 @@ tristate 'CRC32 functions' CONFIG_CRC32
  # Do we need the compression support?
  #
index 570dce9..d534154 100644 (file)
@@ -1,13 +1,9 @@
-This patch adds LZMA support to the squashfs code, you should also
-change mksquashfs appropriately.
-
-Oleg I. Vdovikin <oleg@cs.msu.su>
-
---- linuz/fs/squashfs/inode.c  2004-12-15 22:56:47.000000000 +0300
-+++ linux/fs/squashfs/inode.c  2005-01-20 20:27:27.490010968 +0300
-@@ -3,6 +3,9 @@
-  *
-  * Copyright (c) 2002, 2003, 2004 Phillip Lougher <plougher@users.sourceforge.net>
+diff -Nur linux-2.4.32/fs/squashfs/inode.c linux-2.4.32-owrt/fs/squashfs/inode.c
+--- linux-2.4.32/fs/squashfs/inode.c   2006-03-21 13:06:10.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/inode.c      2006-03-21 13:12:07.000000000 +0100
+@@ -4,6 +4,9 @@
+  * Copyright (c) 2002, 2003, 2004, 2005, 2006
+  * Phillip Lougher <phillip@lougher.org.uk>
   *
 + * LZMA decompressor support added by Oleg I. Vdovikin
 + * Copyright (c) 2005 Oleg I.Vdovikin <oleg@cs.msu.su>
@@ -15,21 +11,17 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version 2,
-@@ -21,7 +24,11 @@
+@@ -21,6 +24,7 @@
   * inode.c
   */
  
 +#define SQUASHFS_LZMA
-+
-+#ifndef SQUASHFS_LZMA
- #define SQUASHFS_1_0_COMPATIBILITY
-+#endif
  #include <linux/types.h>
  #include <linux/squashfs_fs.h>
-@@ -39,6 +46,19 @@
- #include <linux/blkdev.h>
- #include <linux/vmalloc.h>
+ #include <linux/module.h>
+@@ -40,6 +44,20 @@
+ #include "squashfs.h"
  
 +#ifdef SQUASHFS_LZMA
 +#include "LzmaDecode.h"
@@ -40,16 +32,17 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
 +#define LZMA_PB 2
 +
 +#define LZMA_WORKSPACE_SIZE ((LZMA_BASE_SIZE + \
-+      (LZMA_LIT_SIZE << (LZMA_LC + LZMA_LP))) * sizeof(CProb))
++      (LZMA_LIT_SIZE << (LZMA_LC + LZMA_LP))) * sizeof(CProb))
 +
 +#endif
 +
- #ifdef SQUASHFS_TRACE
- #define TRACE(s, args...)                             printk(KERN_NOTICE "SQUASHFS: "s, ## args)
- #else
-@@ -77,7 +97,11 @@
- DECLARE_MUTEX(read_data_mutex);
++
+ static struct super_block *squashfs_read_super(struct super_block *, void *, int);
+ static void squashfs_put_super(struct super_block *);
+ static int squashfs_statfs(struct super_block *, struct statfs *);
+@@ -53,7 +71,11 @@
+                               int readahead_blks, char *block_list,
+                               unsigned short **block_p, unsigned int *bsize);
  
 +#ifdef SQUASHFS_LZMA
 +static unsigned char lzma_workspace[LZMA_WORKSPACE_SIZE];
@@ -59,14 +52,14 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
  
  static DECLARE_FSTYPE_DEV(squashfs_fs_type, "squashfs", squashfs_read_super);
  
-@@ -232,6 +256,15 @@
-       if(compressed) {
+@@ -229,6 +251,15 @@
+       if (compressed) {
                int zlib_err;
  
 +#ifdef SQUASHFS_LZMA
 +              if ((zlib_err = LzmaDecode(lzma_workspace, 
 +                      LZMA_WORKSPACE_SIZE, LZMA_LC, LZMA_LP, LZMA_PB, 
-+                      c_buffer, c_byte, buffer, msBlk->read_size, &bytes)) != LZMA_RESULT_OK)
++                      c_buffer, c_byte, buffer, msblk->read_size, &bytes)) != LZMA_RESULT_OK)
 +              {
 +                      ERROR("lzma returned unexpected result 0x%x\n", zlib_err);
 +                      bytes = 0;
@@ -75,20 +68,20 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
                stream.next_in = c_buffer;
                stream.avail_in = c_byte;
                stream.next_out = buffer;
-@@ -243,6 +276,7 @@
+@@ -243,6 +274,7 @@
                        bytes = 0;
                } else
                        bytes = stream.total_out;
 +#endif
-               up(&read_data_mutex);
+               
+               up(&msblk->read_data_mutex);
        }
-@@ -1491,17 +1525,21 @@
- static int __init init_squashfs_fs(void)
- {
+@@ -2004,17 +2036,21 @@
+       printk(KERN_INFO "squashfs: version 3.0 (2006/03/15) "
+               "Phillip Lougher\n");
  
 +#ifndef SQUASHFS_LZMA
-       if(!(stream.workspace = (char *) vmalloc(zlib_inflate_workspacesize()))) {
+       if (!(stream.workspace = vmalloc(zlib_inflate_workspacesize()))) {
                ERROR("Failed to allocate zlib workspace\n");
                return -ENOMEM;
        }
@@ -105,8 +98,9 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
        unregister_filesystem(&squashfs_fs_type);
  }
  
---- linuz/fs/squashfs/LzmaDecode.c     1970-01-01 03:00:00.000000000 +0300
-+++ linux/fs/squashfs/LzmaDecode.c     2005-01-20 19:40:35.400513552 +0300
+diff -Nur linux-2.4.32/fs/squashfs/LzmaDecode.c linux-2.4.32-owrt/fs/squashfs/LzmaDecode.c
+--- linux-2.4.32/fs/squashfs/LzmaDecode.c      1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/LzmaDecode.c 2006-03-21 13:06:33.000000000 +0100
 @@ -0,0 +1,663 @@
 +/*
 +  LzmaDecode.c
@@ -771,8 +765,9 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
 +  *outSizeProcessed = nowPos;
 +  return LZMA_RESULT_OK;
 +}
---- linuz/fs/squashfs/LzmaDecode.h     1970-01-01 03:00:00.000000000 +0300
-+++ linux/fs/squashfs/LzmaDecode.h     2005-01-20 19:40:36.794301664 +0300
+diff -Nur linux-2.4.32/fs/squashfs/LzmaDecode.h linux-2.4.32-owrt/fs/squashfs/LzmaDecode.h
+--- linux-2.4.32/fs/squashfs/LzmaDecode.h      1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/LzmaDecode.h 2006-03-21 13:06:33.000000000 +0100
 @@ -0,0 +1,100 @@
 +/* 
 +  LzmaDecode.h
@@ -874,14 +869,15 @@ Oleg I. Vdovikin <oleg@cs.msu.su>
 +    UInt32 *outSizeProcessed);
 +
 +#endif
---- linuz/fs/squashfs/Makefile 2004-12-15 22:56:47.000000000 +0300
-+++ linux/fs/squashfs/Makefile 2005-01-19 23:04:25.000000000 +0300
+diff -Nur linux-2.4.32/fs/squashfs/Makefile linux-2.4.32-owrt/fs/squashfs/Makefile
+--- linux-2.4.32/fs/squashfs/Makefile  2006-03-21 13:06:10.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/Makefile     2006-03-21 13:12:39.000000000 +0100
 @@ -4,7 +4,7 @@
  
  O_TARGET := squashfs.o
  
--obj-y  := inode.o
-+obj-y  := inode.o LzmaDecode.o
+-obj-y  := inode.o squashfs2_0.o
++obj-y  := inode.o squashfs2_0.o LzmaDecode.o
  
  obj-m := $(O_TARGET)
  
diff --git a/openwrt/target/linux/generic-2.4/patches/010-disable_old_squashfs_compatibility.patch b/openwrt/target/linux/generic-2.4/patches/010-disable_old_squashfs_compatibility.patch
new file mode 100644 (file)
index 0000000..8647652
--- /dev/null
@@ -0,0 +1,25 @@
+diff -Nur linux-2.4.32/fs/squashfs/Makefile linux-2.4.32-owrt/fs/squashfs/Makefile
+--- linux-2.4.32/fs/squashfs/Makefile  2006-03-21 13:47:50.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/Makefile     2006-03-21 13:48:49.000000000 +0100
+@@ -4,7 +4,7 @@
+ O_TARGET := squashfs.o
+-obj-y  := inode.o squashfs2_0.o LzmaDecode.o
++obj-y  := inode.o LzmaDecode.o
+ obj-m := $(O_TARGET)
+diff -Nur linux-2.4.32/fs/squashfs/squashfs.h linux-2.4.32-owrt/fs/squashfs/squashfs.h
+--- linux-2.4.32/fs/squashfs/squashfs.h        2006-03-21 13:06:10.000000000 +0100
++++ linux-2.4.32-owrt/fs/squashfs/squashfs.h   2006-03-21 13:48:36.000000000 +0100
+@@ -24,6 +24,9 @@
+ #ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+ #undef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+ #endif
++#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
++#undef CONFIG_SQUASHFS_2_0_COMPATIBILITY
++#endif
+ #ifdef SQUASHFS_TRACE
+ #define TRACE(s, args...)     printk(KERN_NOTICE "SQUASHFS: "s, ## args)
+ #else
index f51beaa..f88dbba 100644 (file)
@@ -1,19 +1,21 @@
-diff --new-file -urp linux-2.6.12/fs/Kconfig linux-2.6.12-squashfs2.2/fs/Kconfig
---- linux-2.6.12/fs/Kconfig    2005-06-17 20:48:29.000000000 +0100
-+++ linux-2.6.12-squashfs2.2/fs/Kconfig        2005-07-04 02:35:35.000000000 +0100
-@@ -1171,6 +1171,69 @@ config CRAMFS
+diff --new-file -urp linux-2.6.15/fs/Kconfig linux-2.6.15-squashfs3.0/fs/Kconfig
+--- linux-2.6.15/fs/Kconfig    2006-03-01 22:37:27.000000000 +0000
++++ linux-2.6.15-squashfs3.0/fs/Kconfig        2006-03-07 21:12:37.000000000 +0000
+@@ -1151,6 +1151,71 @@ config CRAMFS
  
          If unsure, say N.
  
 +config SQUASHFS
-+      tristate "SquashFS 2.0 - Squashed file system support"
++      tristate "SquashFS 3.0 - Squashed file system support"
 +      select ZLIB_INFLATE
 +      help
-+        Saying Y here includes support for SquashFs 2.0 (Compressed Read-Only File
++        Saying Y here includes support for SquashFS 3.0 (a Compressed Read-Only File
 +        System).  Squashfs is a highly compressed read-only filesystem for Linux.
 +        It uses zlib compression to compress both files, inodes and directories.
 +        Inodes in the system are very small and all blocks are packed to minimise
 +        data overhead. Block sizes greater than 4K are supported up to a maximum of 64K.
++        SquashFS 3.0 supports 64 bit filesystems and files (larger than 4GB), full
++        uid/gid information, hard links and timestamps.
 +
 +        Squashfs is intended for general read-only filesystem use, for archival
 +        use (i.e. in cases where a .tar.gz file may be used), and in embedded
@@ -71,10 +73,10 @@ diff --new-file -urp linux-2.6.12/fs/Kconfig linux-2.6.12-squashfs2.2/fs/Kconfig
  config VXFS_FS
        tristate "FreeVxFS file system support (VERITAS VxFS(TM) compatible)"
        help
-diff --new-file -urp linux-2.6.12/fs/Makefile linux-2.6.12-squashfs2.2/fs/Makefile
---- linux-2.6.12/fs/Makefile   2005-06-17 20:48:29.000000000 +0100
-+++ linux-2.6.12-squashfs2.2/fs/Makefile       2005-07-04 02:35:35.000000000 +0100
-@@ -52,6 +52,7 @@ obj-$(CONFIG_EXT3_FS)                += ext3/ # Before
+diff --new-file -urp linux-2.6.15/fs/Makefile linux-2.6.15-squashfs3.0/fs/Makefile
+--- linux-2.6.15/fs/Makefile   2006-03-01 22:37:27.000000000 +0000
++++ linux-2.6.15-squashfs3.0/fs/Makefile       2006-03-07 21:12:37.000000000 +0000
+@@ -55,6 +55,7 @@ obj-$(CONFIG_EXT3_FS)                += ext3/ # Before
  obj-$(CONFIG_JBD)             += jbd/
  obj-$(CONFIG_EXT2_FS)         += ext2/
  obj-$(CONFIG_CRAMFS)          += cramfs/
@@ -82,14 +84,15 @@ diff --new-file -urp linux-2.6.12/fs/Makefile linux-2.6.12-squashfs2.2/fs/Makefi
  obj-$(CONFIG_RAMFS)           += ramfs/
  obj-$(CONFIG_HUGETLBFS)               += hugetlbfs/
  obj-$(CONFIG_CODA_FS)         += coda/
-diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/fs/squashfs/inode.c
---- linux-2.6.12/fs/squashfs/inode.c   1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.12-squashfs2.2/fs/squashfs/inode.c       2005-07-04 02:35:35.000000000 +0100
-@@ -0,0 +1,1803 @@
+diff --new-file -urp linux-2.6.15/fs/squashfs/inode.c linux-2.6.15-squashfs3.0/fs/squashfs/inode.c
+--- linux-2.6.15/fs/squashfs/inode.c   1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.15-squashfs3.0/fs/squashfs/inode.c       2006-03-07 21:12:37.000000000 +0000
+@@ -0,0 +1,2127 @@
 +/*
 + * Squashfs - a compressed read only filesystem for Linux
 + *
-+ * Copyright (c) 2002, 2003, 2004, 2005 Phillip Lougher <phillip@lougher.demon.co.uk>
++ * Copyright (c) 2002, 2003, 2004, 2005, 2006
++ * Phillip Lougher <phillip@lougher.org.uk>
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
@@ -108,8 +111,6 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 + * inode.c
 + */
 +
-+#define SQUASHFS_1_0_COMPATIBILITY
-+
 +#include <linux/types.h>
 +#include <linux/squashfs_fs.h>
 +#include <linux/module.h>
@@ -124,23 +125,14 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +#include <linux/vfs.h>
 +#include <linux/init.h>
 +#include <linux/dcache.h>
-+#include <asm/uaccess.h>
 +#include <linux/wait.h>
-+#include <asm/semaphore.h>
 +#include <linux/zlib.h>
 +#include <linux/blkdev.h>
 +#include <linux/vmalloc.h>
++#include <asm/uaccess.h>
++#include <asm/semaphore.h>
 +
-+#ifdef SQUASHFS_TRACE
-+#define TRACE(s, args...)                             printk(KERN_NOTICE "SQUASHFS: "s, ## args)
-+#else
-+#define TRACE(s, args...)                             {}
-+#endif
-+
-+#define ERROR(s, args...)                             printk(KERN_ERR "SQUASHFS error: "s, ## args)
-+
-+#define SERROR(s, args...)                            if(!silent) printk(KERN_ERR "SQUASHFS error: "s, ## args)
-+#define WARNING(s, args...)                           printk(KERN_WARNING "SQUASHFS: "s, ## args)
++#include "squashfs.h"
 +
 +static void squashfs_put_super(struct super_block *);
 +static int squashfs_statfs(struct super_block *, struct kstatfs *);
@@ -148,30 +140,19 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +static int squashfs_readpage(struct file *file, struct page *page);
 +static int squashfs_readpage4K(struct file *file, struct page *page);
 +static int squashfs_readdir(struct file *, void *, filldir_t);
-+static struct dentry *squashfs_lookup(struct inode *, struct dentry *, struct nameidata *);
-+static unsigned int read_data(struct super_block *s, char *buffer,
-+              unsigned int index, unsigned int length, unsigned int *next_index);
-+static int squashfs_get_cached_block(struct super_block *s, char *buffer,
-+              unsigned int block, unsigned int offset, int length,
-+              unsigned int *next_block, unsigned int *next_offset);
-+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode);
-+static unsigned int read_blocklist(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize);
-+static void squashfs_put_super(struct super_block *s);
-+static struct super_block *squashfs_get_sb(struct file_system_type *, int, const char *, void *);
 +static struct inode *squashfs_alloc_inode(struct super_block *sb);
 +static void squashfs_destroy_inode(struct inode *inode);
 +static int init_inodecache(void);
 +static void destroy_inodecache(void);
++static struct dentry *squashfs_lookup(struct inode *, struct dentry *,
++                              struct nameidata *);
++static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode);
++static long long read_blocklist(struct inode *inode, int index,
++                              int readahead_blks, char *block_list,
++                              unsigned short **block_p, unsigned int *bsize);
++static struct super_block *squashfs_get_sb(struct file_system_type *, int,
++                              const char *, void *);
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static int squashfs_readpage_lessthan4K(struct file *file, struct page *page);
-+static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode);
-+static unsigned int read_blocklist_1(struct inode *inode, int index, int readahead_blks,
-+              char *block_list, unsigned short **block_p, unsigned int *bsize);
-+#endif
-+
-+DECLARE_MUTEX(read_data_mutex);
 +
 +static z_stream stream;
 +
@@ -181,7 +162,7 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +      .get_sb = squashfs_get_sb,
 +      .kill_sb = kill_block_super,
 +      .fs_flags = FS_REQUIRES_DEV
-+      };
++};
 +
 +static unsigned char squashfs_filetype_table[] = {
 +      DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
@@ -194,44 +175,32 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +      .put_super = squashfs_put_super,
 +};
 +
-+static struct address_space_operations squashfs_symlink_aops = {
++SQSH_EXTERN struct address_space_operations squashfs_symlink_aops = {
 +      .readpage = squashfs_symlink_readpage
 +};
 +
-+static struct address_space_operations squashfs_aops = {
++SQSH_EXTERN struct address_space_operations squashfs_aops = {
 +      .readpage = squashfs_readpage
 +};
 +
-+static struct address_space_operations squashfs_aops_4K = {
++SQSH_EXTERN struct address_space_operations squashfs_aops_4K = {
 +      .readpage = squashfs_readpage4K
 +};
 +
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static struct address_space_operations squashfs_aops_lessthan4K = {
-+      .readpage = squashfs_readpage_lessthan4K
-+};
-+#endif
-+
 +static struct file_operations squashfs_dir_ops = {
 +      .read = generic_read_dir,
 +      .readdir = squashfs_readdir
 +};
 +
-+static struct inode_operations squashfs_dir_inode_ops = {
++SQSH_EXTERN struct inode_operations squashfs_dir_inode_ops = {
 +      .lookup = squashfs_lookup
 +};
 +
 +
-+static inline struct squashfs_inode_info *SQUASHFS_I(struct inode *inode)
-+{
-+      return list_entry(inode, struct squashfs_inode_info, vfs_inode);
-+}
-+
-+
 +static struct buffer_head *get_block_length(struct super_block *s,
 +                              int *cur_index, int *offset, int *c_byte)
 +{
-+      squashfs_sb_info *msblk = s->s_fs_info;
++      struct squashfs_sb_info *msblk = s->s_fs_info;
 +      unsigned short temp;
 +      struct buffer_head *bh;
 +
@@ -272,7 +241,7 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +              *offset += 2;
 +      }
 +
-+      if (SQUASHFS_CHECK_DATA(msblk->sBlk.flags)) {
++      if (SQUASHFS_CHECK_DATA(msblk->sblk.flags)) {
 +              if (*offset == msblk->devblksize) {
 +                      brelse(bh);
 +                      if (!(bh = sb_bread(s, ++(*cur_index))))
@@ -295,58 +264,66 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +}
 +
 +
-+static unsigned int read_data(struct super_block *s, char *buffer,
-+              unsigned int index, unsigned int length, unsigned int *next_index)
++SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer,
++                      long long index, unsigned int length,
++                      long long *next_index)
 +{
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
-+      struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >> msBlk->devblksize_log2) + 2];
-+      unsigned int offset = index & ((1 << msBlk->devblksize_log2) - 1);
-+      unsigned int cur_index = index >> msBlk->devblksize_log2;
++      struct squashfs_sb_info *msblk = s->s_fs_info;
++      struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >>
++                      msblk->devblksize_log2) + 2];
++      unsigned int offset = index & ((1 << msblk->devblksize_log2) - 1);
++      unsigned int cur_index = index >> msblk->devblksize_log2;
 +      int bytes, avail_bytes, b = 0, k;
 +      char *c_buffer;
 +      unsigned int compressed;
 +      unsigned int c_byte = length;
 +
-+      if(c_byte) {
-+              bytes = msBlk->devblksize - offset;
++      if (c_byte) {
++              bytes = msblk->devblksize - offset;
 +              compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte);
-+              c_buffer = compressed ? msBlk->read_data : buffer;
++              c_buffer = compressed ? msblk->read_data : buffer;
 +              c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
 +
-+              TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte);
++              TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
++                                      ? "" : "un", (unsigned int) c_byte);
 +
-+              if(!(bh[0] = sb_getblk(s, cur_index)))
++              if (!(bh[0] = sb_getblk(s, cur_index)))
 +                      goto block_release;
-+              for(b = 1; bytes < c_byte; b++) {
-+                      if(!(bh[b] = sb_getblk(s, ++cur_index)))
++
++              for (b = 1; bytes < c_byte; b++) {
++                      if (!(bh[b] = sb_getblk(s, ++cur_index)))
 +                              goto block_release;
-+                      bytes += msBlk->devblksize;
++                      bytes += msblk->devblksize;
 +              }
 +              ll_rw_block(READ, b, bh);
 +      } else {
-+              if(!(bh[0] = get_block_length(s, &cur_index, &offset, &c_byte)))
++              if (!(bh[0] = get_block_length(s, &cur_index, &offset,
++                                                              &c_byte)))
 +                      goto read_failure;
 +
-+              bytes = msBlk->devblksize - offset;
++              bytes = msblk->devblksize - offset;
 +              compressed = SQUASHFS_COMPRESSED(c_byte);
-+              c_buffer = compressed ? msBlk->read_data : buffer;
++              c_buffer = compressed ? msblk->read_data : buffer;
 +              c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
 +
-+              TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte);
++              TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
++                                      ? "" : "un", (unsigned int) c_byte);
 +
-+              for(b = 1; bytes < c_byte; b++) {
-+                      if(!(bh[b] = sb_getblk(s, ++cur_index)))
++              for (b = 1; bytes < c_byte; b++) {
++                      if (!(bh[b] = sb_getblk(s, ++cur_index)))
 +                              goto block_release;
-+                      bytes += msBlk->devblksize;
++                      bytes += msblk->devblksize;
 +              }
 +              ll_rw_block(READ, b - 1, bh + 1);
 +      }
 +
-+      if(compressed)
-+              down(&read_data_mutex);
++      if (compressed)
++              down(&msblk->read_data_mutex);
 +
-+      for(bytes = 0, k = 0; k < b; k++) {
-+              avail_bytes = (c_byte - bytes) > (msBlk->devblksize - offset) ? msBlk->devblksize - offset : c_byte - bytes;
++      for (bytes = 0, k = 0; k < b; k++) {
++              avail_bytes = (c_byte - bytes) > (msblk->devblksize - offset) ?
++                                      msblk->devblksize - offset :
++                                      c_byte - bytes;
 +              wait_on_buffer(bh[k]);
 +              if (!buffer_uptodate(bh[k]))
 +                      goto block_release;
@@ -359,30 +336,36 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +      /*
 +       * uncompress block
 +       */
-+      if(compressed) {
++      if (compressed) {
 +              int zlib_err;
 +
 +              stream.next_in = c_buffer;
 +              stream.avail_in = c_byte;
 +              stream.next_out = buffer;
-+              stream.avail_out = msBlk->read_size;
-+              if(((zlib_err = zlib_inflateInit(&stream)) != Z_OK) ||
-+                              ((zlib_err = zlib_inflate(&stream, Z_FINISH)) != Z_STREAM_END) ||
-+                              ((zlib_err = zlib_inflateEnd(&stream)) != Z_OK)) {
-+                      ERROR("zlib_fs returned unexpected result 0x%x\n", zlib_err);
++              stream.avail_out = msblk->read_size;
++
++              if (((zlib_err = zlib_inflateInit(&stream)) != Z_OK) ||
++                              ((zlib_err = zlib_inflate(&stream, Z_FINISH))
++                               != Z_STREAM_END) || ((zlib_err =
++                              zlib_inflateEnd(&stream)) != Z_OK)) {
++                      ERROR("zlib_fs returned unexpected result 0x%x\n",
++                              zlib_err);
 +                      bytes = 0;
 +              } else
 +                      bytes = stream.total_out;
-+              up(&read_data_mutex);
++              
++              up(&msblk->read_data_mutex);
 +      }
 +
-+      if(next_index)
-+              *next_index = index + c_byte + (length ? 0 : (SQUASHFS_CHECK_DATA(msBlk->sBlk.flags) ? 3 : 2));
-+
++      if (next_index)
++              *next_index = index + c_byte + (length ? 0 :
++                              (SQUASHFS_CHECK_DATA(msblk->sblk.flags)
++                               ? 3 : 2));
 +      return bytes;
 +
 +block_release:
-+      while(--b >= 0) brelse(bh[b]);
++      while (--b >= 0)
++              brelse(bh[b]);
 +
 +read_failure:
 +      ERROR("sb_bread failed reading block 0x%x\n", cur_index);
@@ -390,820 +373,886 @@ diff --new-file -urp linux-2.6.12/fs/squashfs/inode.c linux-2.6.12-squashfs2.2/f
 +}
 +
 +
-+static int squashfs_get_cached_block(struct super_block *s, char *buffer,
-+              unsigned int block, unsigned int offset, int length,
-+              unsigned int *next_block, unsigned int *next_offset)
++SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, char *buffer,
++                              long long block, unsigned int offset,
++                              int length, long long *next_block,
++                              unsigned int *next_offset)
 +{
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
++      struct squashfs_sb_info *msblk = s->s_fs_info;
 +      int n, i, bytes, return_length = length;
-+      unsigned int next_index;
++      long long next_index;
 +
-+      TRACE("Entered squashfs_get_cached_block [%x:%x]\n", block, offset);
++      TRACE("Entered squashfs_get_cached_block [%llx:%x]\n", block, offset);
 +
-+      for(;;) {
-+              for(i = 0; i < SQUASHFS_CACHED_BLKS; i++) 
-+                      if(msBlk->block_cache[i].block == block)
++      while ( 1 ) {
++              for (i = 0; i < SQUASHFS_CACHED_BLKS; i++) 
++                      if (msblk->block_cache[i].block == block)
 +                              break; 
 +              
-+              down(&msBlk->block_cache_mutex);
-+              if(i == SQUASHFS_CACHED_BLKS) {
++              down(&msblk->block_cache_mutex);
++
++              if (i == SQUASHFS_CACHED_BLKS) {
 +                      /* read inode header block */
-+                      for(i = msBlk->next_cache, n = SQUASHFS_CACHED_BLKS; n ; n --, i = (i + 1) % SQUASHFS_CACHED_BLKS)
-+                              if(msBlk->block_cache[i].block != SQUASHFS_USED_BLK)
++                      for (i = msblk->next_cache, n = SQUASHFS_CACHED_BLKS;
++                                      n ; n --, i = (i + 1) %
++                                      SQUASHFS_CACHED_BLKS)
++                              if (msblk->block_cache[i].block !=
++                                                      SQUASHFS_USED_BLK)
 +                                      break;
-+                      if(n == 0) {
++
++                      if (n == 0) {
 +                              wait_queue_t wait;
 +
 +                              init_waitqueue_entry(&wait, current);
-+                              add_wait_queue(&msBlk->waitq, &wait);
-+                              up(&msBlk->block_cache_mutex);
++                              add_wait_queue(&msblk->waitq, &wait);
 +                              set_current_state(TASK_UNINTERRUPTIBLE);
++                              up(&msblk->block_cache_mutex);
 +                              schedule();
 +                              set_current_state(TASK_RUNNING);
-+                              remove_wait_queue(&msBlk->waitq, &wait);
++                              remove_wait_queue(&msblk->waitq, &wait);
 +                              continue;
 +                      }
-+                      msBlk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS;
-+
-+                      if(msBlk->block_cache[i].block == SQUASHFS_INVALID_BLK) {
-+                              if(!(msBlk->block_cache[i].data = (unsigned char *)
-+                                                      kmalloc(SQUASHFS_METADATA_SIZE, GFP_KERNEL))) {
-+                                      ERROR("Failed to allocate cache block\n");
-+                                      up(&msBlk->block_cache_mutex);
-+                                      return 0;
++                      msblk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS;
++
++                      if (msblk->block_cache[i].block ==
++                                                      SQUASHFS_INVALID_BLK) {
++                              if (!(msblk->block_cache[i].data =
++                                              kmalloc(SQUASHFS_METADATA_SIZE,
++                                              GFP_KERNEL))) {
++                                      ERROR("Failed to allocate cache"
++                                                      "block\n");
++                                      up(&msblk->block_cache_mutex);
++                                      goto out;
 +                              }
 +                      }
 +      
-+                      msBlk->block_cache[i].block = SQUASHFS_USED_BLK;
-+                      up(&msBlk->block_cache_mutex);
-+                      if(!(msBlk->block_cache[i].length = read_data(s, msBlk->block_cache[i].data, block, 0,
-+                                                      &next_index))) {
-+                              ERROR("Unable to read cache block [%x:%x]\n", block, offset);
-+                              return 0;
++                      msblk->block_cache[i].block = SQUASHFS_USED_BLK;
++                      up(&msblk->block_cache_mutex);
++
++                      if (!(msblk->block_cache[i].length =
++                                              squashfs_read_data(s,
++                                              msblk->block_cache[i].data,
++                                              block, 0, &next_index))) {
++                              ERROR("Unable to read cache block [%llx:%x]\n",
++                                              block, offset);
++                              goto out;
 +                      }
-+                      down(&msBlk->block_cache_mutex);
-+                      wake_up(&msBlk->waitq);
-+                      msBlk->block_cache[i].block = block;
-+                      msBlk->block_cache[i].next_index = next_index;
-+                      TRACE("Read cache block [%x:%x]\n", block, offset);
++
++                      down(&msblk->block_cache_mutex);
++                      wake_up(&msblk->waitq);
++                      msblk->block_cache[i].block = block;
++                      msblk->block_cache[i].next_index = next_index;
++                      TRACE("Read cache block [%llx:%x]\n", block, offset);
 +              }
 +
-+              if(msBlk->block_cache[i].block != block) {
-+                      up(&msBlk->block_cache_mutex);
++              if (msblk->block_cache[i].block != block) {
++                      up(&msblk->block_cache_mutex);
 +                      continue;
 +              }
 +
-+              if((bytes = msBlk->block_cache[i].length - offset) >= length) {
-+                      if(buffer)
-+                              memcpy(buffer, msBlk->block_cache[i].data + offset, length);
-+                      if(msBlk->block_cache[i].length - offset == length) {
-+                              *next_block = msBlk->block_cache[i].next_index;
++              if ((bytes = msblk->block_cache[i].length - offset) >= length) {
++                      if (buffer)
++                              memcpy(buffer, msblk->block_cache[i].data +
++                                              offset, length);
++                      if (msblk->block_cache[i].length - offset == length) {
++                              *next_block = msblk->block_cache[i].next_index;
 +                              *next_offset = 0;
 +                      } else {
 +                              *next_block = block;
 +                              *next_offset = offset + length;
 +                      }
-+      
-+                      up(&msBlk->block_cache_mutex);
-+                      return return_length;
++                      up(&msblk->block_cache_mutex);
++                      goto finish;
 +              } else {
-+                      if(buffer) {
-+                              memcpy(buffer, msBlk->block_cache[i].data + offset, bytes);
++                      if (buffer) {
++                              memcpy(buffer, msblk->block_cache[i].data +
++                                              offset, bytes);
 +                              buffer += bytes;
 +                      }
-+                      block = msBlk->block_cache[i].next_index;
-+                      up(&msBlk->block_cache_mutex);
++                      block = msblk->block_cache[i].next_index;
++                      up(&msblk->block_cache_mutex);
 +                      length -= bytes;
 +                      offset = 0;
 +              }
 +      }
++
++finish:
++      return return_length;
++out:
++      return 0;
 +}
 +
 +
-+static int get_fragment_location(struct super_block *s, unsigned int fragment, unsigned int *fragment_start_block, unsigned int *fragment_size)
++static int get_fragment_location(struct super_block *s, unsigned int fragment,
++                              long long *fragment_start_block,
++                              unsigned int *fragment_size)
 +{
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
-+      unsigned int start_block = msBlk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)];
++      struct squashfs_sb_info *msblk = s->s_fs_info;
++      long long start_block =
++              msblk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)];
 +      int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment);
-+      squashfs_fragment_entry fragment_entry;
++      struct squashfs_fragment_entry fragment_entry;
 +
-+      if(msBlk->swap) {
-+              squashfs_fragment_entry sfragment_entry;
++      if (msblk->swap) {
++              struct squashfs_fragment_entry sfragment_entry;
 +
-+              if(!squashfs_get_cached_block(s, (char *) &sfragment_entry, start_block, offset,
-+                                      sizeof(sfragment_entry), &start_block, &offset))
-+                      return 0;
++              if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
++                                      start_block, offset,
++                                      sizeof(sfragment_entry), &start_block,
++                                      &offset))
++                      goto out;
 +              SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry);
 +      } else
-+              if(!squashfs_get_cached_block(s, (char *) &fragment_entry, start_block, offset,
-+                                      sizeof(fragment_entry), &start_block, &offset))
-+                      return 0;
++              if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
++                                      start_block, offset,
++                                      sizeof(fragment_entry), &start_block,
++                                      &offset))
++                      goto out;
 +
 +      *fragment_start_block = fragment_entry.start_block;
 +      *fragment_size = fragment_entry.size;
 +
 +      return 1;
++
++out:
++      return 0;
 +}
 +
 +
-+void release_cached_fragment(squashfs_sb_info *msBlk, struct squashfs_fragment_cache *fragment)
++SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk, struct
++                                      squashfs_fragment_cache *fragment)
 +{
-+      down(&msBlk->fragment_mutex);
++      down(&msblk->fragment_mutex);
 +      fragment->locked --;
-+      wake_up(&msBlk->fragment_wait_queue);
-+      up(&msBlk->fragment_mutex);
++      wake_up(&msblk->fragment_wait_queue);
++      up(&msblk->fragment_mutex);
 +}
 +
 +
-+struct squashfs_fragment_cache *get_cached_fragment(struct super_block *s, unsigned int start_block, int length)
++SQSH_EXTERN struct squashfs_fragment_cache *get_cached_fragment(struct super_block
++                                      *s, long long start_block,
++                                      int length)
 +{
 +      int i, n;
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
++      struct squashfs_sb_info *msblk = s->s_fs_info;
 +
-+      for(;;) {
-+              down(&msBlk->fragment_mutex);
-+              for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS && msBlk->fragment[i].block != start_block; i++);
-+              if(i == SQUASHFS_CACHED_FRAGMENTS) {
-+                      for(i = msBlk->next_fragment, n = SQUASHFS_CACHED_FRAGMENTS;
-+                              n && msBlk->fragment[i].locked; n--, i = (i + 1) % SQUASHFS_CACHED_FRAGMENTS);
++      while ( 1 ) {
++              down(&msblk->fragment_mutex);
 +
-+                      if(n == 0) {
++              for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS &&
++                              msblk->fragment[i].block != start_block; i++);
++
++              if (i == SQUASHFS_CACHED_FRAGMENTS) {
++                      for (i = msblk->next_fragment, n =
++                              SQUASHFS_CACHED_FRAGMENTS; n &&
++                              msblk->fragment[i].locked; n--, i = (i + 1) %
++                              SQUASHFS_CACHED_FRAGMENTS);
++
++                      if (n == 0) {
 +                              wait_queue_t wait;
 +
 +                              init_waitqueue_entry(&wait, current);
-+                              add_wait_queue(&msBlk->fragment_wait_queue, &wait);
-+                              up(&msBlk->fragment_mutex);
++                              add_wait_queue(&msblk->fragment_wait_queue,
++                                                                      &wait);
 +                              set_current_state(TASK_UNINTERRUPTIBLE);
++                              up(&msblk->fragment_mutex);
 +                              schedule();
 +                              set_current_state(TASK_RUNNING);
-+                              remove_wait_queue(&msBlk->fragment_wait_queue, &wait);
++                              remove_wait_queue(&msblk->fragment_wait_queue,
++                                                                      &wait);
 +                              continue;
 +                      }
-+                      msBlk->next_fragment = (msBlk->next_fragment + 1) % SQUASHFS_CACHED_FRAGMENTS;
++                      msblk->next_fragment = (msblk->next_fragment + 1) %
++                              SQUASHFS_CACHED_FRAGMENTS;
 +                      
-+                      if(msBlk->fragment[i].data == NULL)
-+                              if(!(msBlk->fragment[i].data = (unsigned char *)
-+                                                      SQUASHFS_ALLOC(SQUASHFS_FILE_MAX_SIZE))) {
-+                                      ERROR("Failed to allocate fragment cache block\n");
-+                                      up(&msBlk->fragment_mutex);
-+                                      return NULL;
++                      if (msblk->fragment[i].data == NULL)
++                              if (!(msblk->fragment[i].data = SQUASHFS_ALLOC
++                                              (SQUASHFS_FILE_MAX_SIZE))) {
++                                      ERROR("Failed to allocate fragment "
++                                                      "cache block\n");
++                                      up(&msblk->fragment_mutex);
++                                      goto out;
 +                              }
 +
-+                      msBlk->fragment[i].block = SQUASHFS_INVALID_BLK;
-+                      msBlk->fragment[i].locked = 1;
-+                      up(&msBlk->fragment_mutex);
-+                      if(!(msBlk->fragment[i].length = read_data(s, msBlk->fragment[i].data, start_block, length,
-+                                                      NULL))) {
-+                              ERROR("Unable to read fragment cache block [%x]\n", start_block);
-+                              msBlk->fragment[i].locked = 0;
-+                              return NULL;
-+                      }
-+                      msBlk->fragment[i].block = start_block;
-+                      TRACE("New fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked);
-+                      return &msBlk->fragment[i];
-+              }
-+
-+              msBlk->fragment[i].locked ++;
-+              up(&msBlk->fragment_mutex);
-+              
-+              TRACE("Got fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked);
-+              return &msBlk->fragment[i];
-+      }
-+}
-+
-+
-+#ifdef SQUASHFS_1_0_COMPATIBILITY
-+static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode)
-+{
-+      struct inode *i = new_inode(s);
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
-+      unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
-+      unsigned int next_block, next_offset;
-+      squashfs_base_inode_header_1 inodeb;
-+
-+      TRACE("Entered squashfs_iget_1\n");
-+
-+      if(msBlk->swap) {
-+              squashfs_base_inode_header_1 sinodeb;
-+
-+              if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
-+                                      sizeof(sinodeb), &next_block, &next_offset))
-+                      goto failed_read;
-+              SQUASHFS_SWAP_BASE_INODE_HEADER_1(&inodeb, &sinodeb, sizeof(sinodeb));
-+      } else
-+              if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
-+                                      sizeof(inodeb), &next_block, &next_offset))
-+                      goto failed_read;
-+
-+      i->i_nlink = 1;
-+
-+      i->i_mtime.tv_sec = sBlk->mkfs_time;
-+      i->i_atime.tv_sec = sBlk->mkfs_time;
-+      i->i_ctime.tv_sec = sBlk->mkfs_time;
-+
-+      if(inodeb.inode_type != SQUASHFS_IPC_TYPE)
-+              i->i_uid = msBlk->uid[((inodeb.inode_type - 1) / SQUASHFS_TYPES) * 16 + inodeb.uid];
-+      i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);
-+
-+      i->i_mode = inodeb.mode;
-+
-+      switch(inodeb.inode_type == SQUASHFS_IPC_TYPE ? SQUASHFS_IPC_TYPE : (inodeb.inode_type - 1) % SQUASHFS_TYPES + 1) {
-+              case SQUASHFS_FILE_TYPE: {
-+                      squashfs_reg_inode_header_1 inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_reg_inode_header_1 sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_REG_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+
-+                      i->i_size = inodep.file_size;
-+                      i->i_fop = &generic_ro_fops;
-+                      if(sBlk->block_size > 4096)
-+                              i->i_data.a_ops = &squashfs_aops;
-+                      else if(sBlk->block_size == 4096)
-+                              i->i_data.a_ops = &squashfs_aops_4K;
-+                      else
-+                              i->i_data.a_ops = &squashfs_aops_lessthan4K;
-+                      i->i_mode |= S_IFREG;
-+                      i->i_mtime.tv_sec = inodep.mtime;
-+                      i->i_atime.tv_sec = inodep.mtime;
-+                      i->i_ctime.tv_sec = inodep.mtime;
-+                      i->i_blocks = ((i->i_size - 1) >> 9) + 1;
-+                      i->i_blksize = PAGE_CACHE_SIZE;
-+                      SQUASHFS_I(i)->u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
-+                      SQUASHFS_I(i)->u.s1.fragment_offset = 0;
-+                      SQUASHFS_I(i)->start_block = inodep.start_block;
-+                      SQUASHFS_I(i)->block_list_start = next_block;
-+                      SQUASHFS_I(i)->offset = next_offset;
-+                      TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x\n",
-+                                      SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset);
-+                      break;
-+              }
-+              case SQUASHFS_DIR_TYPE: {
-+                      squashfs_dir_inode_header_1 inodep;
++                      msblk->fragment[i].block = SQUASHFS_INVALID_BLK;
++                      msblk->fragment[i].locked = 1;
++                      up(&msblk->fragment_mutex);
 +
-+                      if(msBlk->swap) {
-+                              squashfs_dir_inode_header_1 sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_DIR_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++                      if (!(msblk->fragment[i].length = squashfs_read_data(s,
++                                              msblk->fragment[i].data,
++                                              start_block, length, NULL))) {
++                              ERROR("Unable to read fragment cache block "
++                                                      "[%llx]\n", start_block);
++                              msblk->fragment[i].locked = 0;
++                              goto out;
++                      }
 +
-+                      i->i_size = inodep.file_size;
-+                      i->i_op = &squashfs_dir_inode_ops;
-+                      i->i_fop = &squashfs_dir_ops;
-+                      i->i_mode |= S_IFDIR;
-+                      i->i_mtime.tv_sec = inodep.mtime;
-+                      i->i_atime.tv_sec = inodep.mtime;
-+                      i->i_ctime.tv_sec = inodep.mtime;
-+                      SQUASHFS_I(i)->start_block = inodep.start_block;
-+                      SQUASHFS_I(i)->offset = inodep.offset;
-+                      SQUASHFS_I(i)->u.s2.directory_index_count = 0;
-+                      TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
-+                                      inodep.start_block, inodep.offset);
++                      msblk->fragment[i].block = start_block;
++                      TRACE("New fragment %d, start block %lld, locked %d\n",
++                                              i, msblk->fragment[i].block,
++                                              msblk->fragment[i].locked);
 +                      break;
 +              }
-+              case SQUASHFS_SYMLINK_TYPE: {
-+                      squashfs_symlink_inode_header_1 inodep;
-+      
-+                      if(msBlk->swap) {
-+                              squashfs_symlink_inode_header_1 sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+
-+                      i->i_size = inodep.symlink_size;
-+                      i->i_op = &page_symlink_inode_operations;
-+                      i->i_data.a_ops = &squashfs_symlink_aops;
-+                      i->i_mode |= S_IFLNK;
-+                      SQUASHFS_I(i)->start_block = next_block;
-+                      SQUASHFS_I(i)->offset = next_offset;
-+                      TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n",
-+                              SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset);
-+                      break;
-+               }
-+               case SQUASHFS_BLKDEV_TYPE:
-+               case SQUASHFS_CHRDEV_TYPE: {
-+                      squashfs_dev_inode_header_1 inodep;
 +
-+                      if(msBlk->swap) {
-+                              squashfs_dev_inode_header_1 sinodep;
++              msblk->fragment[i].locked++;
++              up(&msblk->fragment_mutex);
++              TRACE("Got fragment %d, start block %lld, locked %d\n", i,
++                                              msblk->fragment[i].block,
++                                              msblk->fragment[i].locked);
++              break;
++      }
 +
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_DEV_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else  
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++      return &msblk->fragment[i];
 +
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK;
-+                      init_special_inode(i, i->i_mode, old_decode_dev(inodep.rdev));
-+                      TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev);
-+                      break;
-+               }
-+               case SQUASHFS_IPC_TYPE: {
-+                      squashfs_ipc_inode_header_1 inodep;
++out:
++      return NULL;
++}
 +
-+                      if(msBlk->swap) {
-+                              squashfs_ipc_inode_header_1 sinodep;
 +
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
-+                              SQUASHFS_SWAP_IPC_INODE_HEADER_1(&inodep, &sinodep);
-+                      } else  
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
-+                                      goto failed_read;
++static struct inode *squashfs_new_inode(struct super_block *s,
++              struct squashfs_base_inode_header *inodeb)
++{
++      struct squashfs_sb_info *msblk = s->s_fs_info;
++      struct inode *i = new_inode(s);
 +
-+                      i->i_size = 0;
-+                      i->i_mode |= (inodep.type == SQUASHFS_FIFO_TYPE) ? S_IFIFO : S_IFSOCK;
-+                      i->i_uid = msBlk->uid[inodep.offset * 16 + inodeb.uid];
-+                      init_special_inode(i, i->i_mode, 0);
-+                      break;
-+               }
-+               default:
-+                      ERROR("Unknown inode type %d in squashfs_iget!\n", inodeb.inode_type);
-+                              goto failed_read1;
++      if (i) {
++              i->i_ino = inodeb->inode_number;
++              i->i_mtime.tv_sec = inodeb->mtime;
++              i->i_atime.tv_sec = inodeb->mtime;
++              i->i_ctime.tv_sec = inodeb->mtime;
++              i->i_uid = msblk->uid[inodeb->uid];
++              i->i_mode = inodeb->mode;
++              i->i_size = 0;
++              if (inodeb->guid == SQUASHFS_GUIDS)
++                      i->i_gid = i->i_uid;
++              else
++                      i->i_gid = msblk->guid[inodeb->guid];
 +      }
-+      
-+      if(inodeb.guid == 15)
-+              i->i_gid = i->i_uid;
-+      else
-+              i->i_gid = msBlk->guid[inodeb.guid];
 +
-+      insert_inode_hash(i);
 +      return i;
-+
-+failed_read:
-+      ERROR("Unable to read inode [%x:%x]\n", block, offset);
-+
-+failed_read1:
-+      return NULL;
 +}
-+#endif
 +
 +
-+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode)
++static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode)
 +{
-+      struct inode *i = new_inode(s);
-+      squashfs_sb_info *msBlk = (squashfs_sb_info *)s->s_fs_info;
-+      squashfs_super_block *sBlk = &msBlk->sBlk;
-+      unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
++      struct inode *i;
++      struct squashfs_sb_info *msblk = s->s_fs_info;
++      struct squashfs_super_block *sblk = &msblk->sblk;
++      long long block = SQUASHFS_INODE_BLK(inode) +
++              sblk->inode_table_start;
 +      unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
-+      unsigned int next_block, next_offset;
-+      squashfs_base_inode_header inodeb;
++      long long next_block;
++      unsigned int next_offset;
++      union squashfs_inode_header id, sid;
++      struct squashfs_base_inode_header *inodeb = &id.base,
++                                        *sinodeb = &sid.base;
 +
 +      TRACE("Entered squashfs_iget\n");
 +
-+      if(msBlk->swap) {
-+              squashfs_base_inode_header sinodeb;
-+
-+              if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
-+                                      sizeof(sinodeb), &next_block, &next_offset))
++      if (msblk->swap) {
++              if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
++                                      offset, sizeof(*sinodeb), &next_block,
++                                      &next_offset))
 +                      goto failed_read;
-+              SQUASHFS_SWAP_BASE_INODE_HEADER(&inodeb, &sinodeb, sizeof(sinodeb));
++              SQUASHFS_SWAP_BASE_INODE_HEADER(inodeb, sinodeb,
++                                      sizeof(*sinodeb));
 +      } else
-+              if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
-+                                      sizeof(inodeb), &next_block, &next_offset))
++              if (!squashfs_get_cached_block(s, (char *) inodeb, block,
++                                      offset, sizeof(*inodeb), &next_block,
++                                      &next_offset))
 +                      goto failed_read;
 +
-+      i->i_nlink = 1;
-+
-+      i->i_mtime.tv_sec = sBlk->mkfs_time;
-+      i->i_atime.tv_sec = sBlk->mkfs_time;
-+      i->i_ctime.tv_sec = sBlk->mkfs_time;
-+
-+      i->i_uid = msBlk->uid[inodeb.uid];
-+      i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);
-+
-+      i->i_mode = inodeb.mode;
-+
-+      switch(inodeb.inode_type) {
++      switch(inodeb->inode_type) {
 +              case SQUASHFS_FILE_TYPE: {
-+                      squashfs_reg_inode_header inodep;
-+
-+                      if(msBlk->swap) {
-+                              squashfs_reg_inode_header sinodep;
-+
-+                              if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
-+                                                      &next_block, &next_offset))
++                      unsigned int frag_size;
++                      long long frag_blk;
++                      struct squashfs_reg_inode_header *inodep = &id.reg;
++                      struct squashfs_reg_inode_header *sinodep = &sid.reg;
++                              
++                      if (msblk->swap) {
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              sinodep, block, offset,
++                                              sizeof(*sinodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
-+                              SQUASHFS_SWAP_REG_INODE_HEADER(&inodep, &sinodep);
++                              SQUASHFS_SWAP_REG_INODE_HEADER(inodep, sinodep);
 +                      } else
-+                              if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
-+                                                      &next_block, &next_offset))
++                              if (!squashfs_get_cached_block(s, (char *)
++                                              inodep, block, offset,
++                                              sizeof(*inodep), &next_block,
++                                              &next_offset))
 +                                      goto failed_read;
 +
-+                      SQUASHFS_I(i)->u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
-+                      if(inodep.fragment != SQUASHFS_INVALID_BLK && !get_fragment_location(s, inodep.fragment,
-+                                                      &SQUASHFS_I(i)->u.s1.fragment_start_block, &SQUASHFS_I(i)->u.s1.fragment_size))
++                      frag_blk = SQUASHFS_INVALID_BLK;
++                      if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
++                                      !get_fragment_location(s,
++                                      inodep->fragment, &frag_blk, &frag_size))
 +                              goto failed_read;
++                              
++                      if((i = squashfs_new_inode(s, inodeb)) == NULL)
++                     &nbs