25 files changed, 546 insertions, 231 deletions

diff --git a/fs/squashfs/Kconfig b/fs/squashfs/Kconfig
index e5f63da64d04..7797218d0b30 100644
--- a/fs/squashfs/Kconfig
+++ b/fs/squashfs/Kconfig
@@ -5,12 +5,12 @@ config SQUASHFS
         help
           Saying Y here includes support for SquashFS 4.0 (a Compressed
           Read-Only File System).  Squashfs is a highly compressed read-only
-          filesystem for Linux.  It uses zlib/lzo 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 1 Mbytes (default
-          block size 128K).  SquashFS 4.0 supports 64 bit filesystems and files
-          (larger than 4GB), full uid/gid information, hard links and
+          filesystem for Linux.  It uses zlib, lzo or xz 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 1 Mbytes
+          (default block size 128K).  SquashFS 4.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
@@ -29,7 +29,6 @@ config SQUASHFS
 config SQUASHFS_XATTR
         bool "Squashfs XATTR support"
         depends on SQUASHFS
-        default n
         help
           Saying Y here includes support for extended attributes (xattrs).
           Xattrs are name:value pairs associated with inodes by
@@ -40,11 +39,10 @@ config SQUASHFS_XATTR
 config SQUASHFS_LZO
         bool "Include support for LZO compressed file systems"
         depends on SQUASHFS
-        default n
         select LZO_DECOMPRESS
         help
           Saying Y here includes support for reading Squashfs file systems
-          compressed with LZO compresssion.  LZO compression is mainly
+          compressed with LZO compression.  LZO compression is mainly
           aimed at embedded systems with slower CPUs where the overheads
           of zlib are too high.
 
@@ -53,10 +51,24 @@ config SQUASHFS_LZO
 
           If unsure, say N.
 
+config SQUASHFS_XZ
+        bool "Include support for XZ compressed file systems"
+        depends on SQUASHFS
+        select XZ_DEC
+        help
+          Saying Y here includes support for reading Squashfs file systems
+          compressed with XZ compression.  XZ gives better compression than
+          the default zlib compression, at the expense of greater CPU and
+          memory overhead.
+
+          XZ is not the standard compression used in Squashfs and so most
+          file systems will be readable without selecting this option.
+
+          If unsure, say N.
+
 config SQUASHFS_EMBEDDED
         bool "Additional option for memory-constrained systems"
         depends on SQUASHFS
-        default n
         help
           Saying Y here allows you to specify cache size.
 
diff --git a/fs/squashfs/Makefile b/fs/squashfs/Makefile
index 7672bac8d328..cecf2bea07af 100644
--- a/fs/squashfs/Makefile
+++ b/fs/squashfs/Makefile
@@ -7,3 +7,4 @@ squashfs-y += block.o cache.o dir.o export.o file.o fragment.o id.o inode.o
 squashfs-y += namei.o super.o symlink.o zlib_wrapper.o decompressor.o
 squashfs-$(CONFIG_SQUASHFS_XATTR) += xattr.o xattr_id.o
 squashfs-$(CONFIG_SQUASHFS_LZO) += lzo_wrapper.o
+squashfs-$(CONFIG_SQUASHFS_XZ) += xz_wrapper.o
diff --git a/fs/squashfs/block.c b/fs/squashfs/block.c
index 653c030eb840..ed0eb2a921f4 100644
--- a/fs/squashfs/block.c
+++ b/fs/squashfs/block.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -34,7 +34,6 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 #include "decompressor.h"
 
@@ -64,6 +63,14 @@ static struct buffer_head *get_block_length(struct super_block *sb,
                 *length = (unsigned char) bh->b_data[*offset] |
                         (unsigned char) bh->b_data[*offset + 1] << 8;
                 *offset += 2;
+
+                if (*offset == msblk->devblksize) {
+                        put_bh(bh);
+                        bh = sb_bread(sb, ++(*cur_index));
+                        if (bh == NULL)
+                                return NULL;
+                        *offset = 0;
+                }
         }
 
         return bh;
diff --git a/fs/squashfs/cache.c b/fs/squashfs/cache.c
index 57314bee9059..f744be98cd5a 100644
--- a/fs/squashfs/cache.c
+++ b/fs/squashfs/cache.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -29,7 +29,7 @@
  * plus functions layered ontop of the generic cache implementation to
  * access the metadata and fragment caches.
  *
- * To avoid out of memory and fragmentation isssues with vmalloc the cache
+ * To avoid out of memory and fragmentation issues with vmalloc the cache
  * uses sequences of kmalloced PAGE_CACHE_SIZE buffers.
  *
  * It should be noted that the cache is not used for file datablocks, these
@@ -55,7 +55,6 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 
 /*
@@ -105,7 +104,7 @@ struct squashfs_cache_entry *squashfs_cache_get(struct super_block *sb,
                         entry = &cache->entry[i];
 
                         /*
-                         * Initialise choosen cache entry, and fill it in from
+                         * Initialise chosen cache entry, and fill it in from
                          * disk.
                          */
                         cache->unused--;
@@ -287,7 +286,7 @@ cleanup:
 
 
 /*
- * Copy upto length bytes from cache entry to buffer starting at offset bytes
+ * Copy up to length bytes from cache entry to buffer starting at offset bytes
  * into the cache entry.  If there's not length bytes then copy the number of
  * bytes available.  In all cases return the number of bytes copied.
  */
@@ -394,19 +393,36 @@ struct squashfs_cache_entry *squashfs_get_datablock(struct super_block *sb,
 /*
  * Read a filesystem table (uncompressed sequence of bytes) from disk
  */
-int squashfs_read_table(struct super_block *sb, void *buffer, u64 block,
-        int length)
+void *squashfs_read_table(struct super_block *sb, u64 block, int length)
 {
         int pages = (length + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
         int i, res;
-        void **data = kcalloc(pages, sizeof(void *), GFP_KERNEL);
-        if (data == NULL)
-                return -ENOMEM;
+        void *table, *buffer, **data;
+
+        table = buffer = kmalloc(length, GFP_KERNEL);
+        if (table == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        data = kcalloc(pages, sizeof(void *), GFP_KERNEL);
+        if (data == NULL) {
+                res = -ENOMEM;
+                goto failed;
+        }
 
         for (i = 0; i < pages; i++, buffer += PAGE_CACHE_SIZE)
                 data[i] = buffer;
+
         res = squashfs_read_data(sb, data, block, length |
                 SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length, pages);
+
         kfree(data);
-        return res;
+
+        if (res < 0)
+                goto failed;
+
+        return table;
+
+failed:
+        kfree(table);
+        return ERR_PTR(res);
 }
diff --git a/fs/squashfs/decompressor.c b/fs/squashfs/decompressor.c
index 24af9ce9722f..9f1b0bb96f13 100644
--- a/fs/squashfs/decompressor.c
+++ b/fs/squashfs/decompressor.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -23,11 +23,11 @@
 
 #include <linux/types.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <linux/buffer_head.h>
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "decompressor.h"
 #include "squashfs.h"
 
@@ -41,23 +41,26 @@ static const struct squashfs_decompressor squashfs_lzma_unsupported_comp_ops = {
 };
 
 #ifndef CONFIG_SQUASHFS_LZO
-static const struct squashfs_decompressor squashfs_lzo_unsupported_comp_ops = {
+static const struct squashfs_decompressor squashfs_lzo_comp_ops = {
         NULL, NULL, NULL, LZO_COMPRESSION, "lzo", 0
 };
 #endif
 
+#ifndef CONFIG_SQUASHFS_XZ
+static const struct squashfs_decompressor squashfs_xz_comp_ops = {
+        NULL, NULL, NULL, XZ_COMPRESSION, "xz", 0
+};
+#endif
+
 static const struct squashfs_decompressor squashfs_unknown_comp_ops = {
         NULL, NULL, NULL, 0, "unknown", 0
 };
 
 static const struct squashfs_decompressor *decompressor[] = {
         &squashfs_zlib_comp_ops,
-        &squashfs_lzma_unsupported_comp_ops,
-#ifdef CONFIG_SQUASHFS_LZO
         &squashfs_lzo_comp_ops,
-#else
-        &squashfs_lzo_unsupported_comp_ops,
-#endif
+        &squashfs_xz_comp_ops,
+        &squashfs_lzma_unsupported_comp_ops,
         &squashfs_unknown_comp_ops
 };
 
@@ -72,3 +75,36 @@ const struct squashfs_decompressor *squashfs_lookup_decompressor(int id)
 
         return decompressor[i];
 }
+
+
+void *squashfs_decompressor_init(struct super_block *sb, unsigned short flags)
+{
+        struct squashfs_sb_info *msblk = sb->s_fs_info;
+        void *strm, *buffer = NULL;
+        int length = 0;
+
+        /*
+         * Read decompressor specific options from file system if present
+         */
+        if (SQUASHFS_COMP_OPTS(flags)) {
+                buffer = kmalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
+                if (buffer == NULL)
+                        return ERR_PTR(-ENOMEM);
+
+                length = squashfs_read_data(sb, &buffer,
+                        sizeof(struct squashfs_super_block), 0, NULL,
+                        PAGE_CACHE_SIZE, 1);
+
+                if (length < 0) {
+                        strm = ERR_PTR(length);
+                        goto finished;
+                }
+        }
+
+        strm = msblk->decompressor->init(msblk, buffer, length);
+
+finished:
+        kfree(buffer);
+
+        return strm;
+}
diff --git a/fs/squashfs/decompressor.h b/fs/squashfs/decompressor.h
index 7425f80783f6..8ba70cff09a6 100644
--- a/fs/squashfs/decompressor.h
+++ b/fs/squashfs/decompressor.h
@@ -4,7 +4,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -24,7 +24,7 @@
  */
 
 struct squashfs_decompressor {
-        void    *(*init)(struct squashfs_sb_info *);
+        void    *(*init)(struct squashfs_sb_info *, void *, int);
         void    (*free)(void *);
         int     (*decompress)(struct squashfs_sb_info *, void **,
                 struct buffer_head **, int, int, int, int, int);
@@ -33,11 +33,6 @@ struct squashfs_decompressor {
         int     supported;
 };
 
-static inline void *squashfs_decompressor_init(struct squashfs_sb_info *msblk)
-{
-        return msblk->decompressor->init(msblk);
-}
-
 static inline void squashfs_decompressor_free(struct squashfs_sb_info *msblk,
         void *s)
 {
@@ -52,4 +47,13 @@ static inline int squashfs_decompress(struct squashfs_sb_info *msblk,
         return msblk->decompressor->decompress(msblk, buffer, bh, b, offset,
                 length, srclength, pages);
 }
+
+#ifdef CONFIG_SQUASHFS_XZ
+extern const struct squashfs_decompressor squashfs_xz_comp_ops;
+#endif
+
+#ifdef CONFIG_SQUASHFS_LZO
+extern const struct squashfs_decompressor squashfs_lzo_comp_ops;
+#endif
+
 #endif
diff --git a/fs/squashfs/dir.c b/fs/squashfs/dir.c
index 12b933ac6585..9dfe2ce0fb70 100644
--- a/fs/squashfs/dir.c
+++ b/fs/squashfs/dir.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -172,6 +172,11 @@ static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
                 length += sizeof(dirh);
 
                 dir_count = le32_to_cpu(dirh.count) + 1;
+
+                /* dir_count should never be larger than 256 */
+                if (dir_count > 256)
+                        goto failed_read;
+
                 while (dir_count--) {
                         /*
                          * Read directory entry.
@@ -183,6 +188,10 @@ static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
 
                         size = le16_to_cpu(dire->size) + 1;
 
+                        /* size should never be larger than SQUASHFS_NAME_LEN */
+                        if (size > SQUASHFS_NAME_LEN)
+                                goto failed_read;
+
                         err = squashfs_read_metadata(inode->i_sb, dire->name,
                                         &block, &offset, size);
                         if (err < 0)
@@ -230,5 +239,6 @@ failed_read:
 
 const struct file_operations squashfs_dir_ops = {
         .read = generic_read_dir,
-        .readdir = squashfs_readdir
+        .readdir = squashfs_readdir,
+        .llseek = default_llseek,
 };
diff --git a/fs/squashfs/export.c b/fs/squashfs/export.c
index 7f93d5a9ee05..5e1101ff276f 100644
--- a/fs/squashfs/export.c
+++ b/fs/squashfs/export.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -121,30 +121,38 @@ static struct dentry *squashfs_get_parent(struct dentry *child)
  * Read uncompressed inode lookup table indexes off disk into memory
  */
 __le64 *squashfs_read_inode_lookup_table(struct super_block *sb,
-                u64 lookup_table_start, unsigned int inodes)
+                u64 lookup_table_start, u64 next_table, unsigned int inodes)
 {
         unsigned int length = SQUASHFS_LOOKUP_BLOCK_BYTES(inodes);
-        __le64 *inode_lookup_table;
-        int err;
+        __le64 *table;
 
         TRACE("In read_inode_lookup_table, length %d\n", length);
 
-        /* Allocate inode lookup table indexes */
-        inode_lookup_table = kmalloc(length, GFP_KERNEL);
-        if (inode_lookup_table == NULL) {
-                ERROR("Failed to allocate inode lookup table\n");
-                return ERR_PTR(-ENOMEM);
-        }
+        /* Sanity check values */
+
+        /* there should always be at least one inode */
+        if (inodes == 0)
+                return ERR_PTR(-EINVAL);
+
+        /* length bytes should not extend into the next table - this check
+         * also traps instances where lookup_table_start is incorrectly larger
+         * than the next table start
+         */
+        if (lookup_table_start + length > next_table)
+                return ERR_PTR(-EINVAL);
+
+        table = squashfs_read_table(sb, lookup_table_start, length);
 
-        err = squashfs_read_table(sb, inode_lookup_table, lookup_table_start,
-                        length);
-        if (err < 0) {
-                ERROR("unable to read inode lookup table\n");
-                kfree(inode_lookup_table);
-                return ERR_PTR(err);
+        /*
+         * table[0] points to the first inode lookup table metadata block,
+         * this should be less than lookup_table_start
+         */
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= lookup_table_start) {
+                kfree(table);
+                return ERR_PTR(-EINVAL);
         }
 
-        return inode_lookup_table;
+        return table;
 }
 
 
diff --git a/fs/squashfs/file.c b/fs/squashfs/file.c
index a25c5060bdcb..38bb1c640559 100644
--- a/fs/squashfs/file.c
+++ b/fs/squashfs/file.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/fs/squashfs/fragment.c b/fs/squashfs/fragment.c
index 7c90bbd6879d..0ed6edbc5c71 100644
--- a/fs/squashfs/fragment.c
+++ b/fs/squashfs/fragment.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -39,7 +39,6 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 
 /*
@@ -72,26 +71,29 @@ int squashfs_frag_lookup(struct super_block *sb, unsigned int fragment,
  * Read the uncompressed fragment lookup table indexes off disk into memory
  */
 __le64 *squashfs_read_fragment_index_table(struct super_block *sb,
-        u64 fragment_table_start, unsigned int fragments)
+        u64 fragment_table_start, u64 next_table, unsigned int fragments)
 {
         unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(fragments);
-        __le64 *fragment_index;
-        int err;
+        __le64 *table;
 
-        /* Allocate fragment lookup table indexes */
-        fragment_index = kmalloc(length, GFP_KERNEL);
-        if (fragment_index == NULL) {
-                ERROR("Failed to allocate fragment index table\n");
-                return ERR_PTR(-ENOMEM);
-        }
+        /*
+         * Sanity check, length bytes should not extend into the next table -
+         * this check also traps instances where fragment_table_start is
+         * incorrectly larger than the next table start
+         */
+        if (fragment_table_start + length > next_table)
+                return ERR_PTR(-EINVAL);
+
+        table = squashfs_read_table(sb, fragment_table_start, length);
 
-        err = squashfs_read_table(sb, fragment_index, fragment_table_start,
-                        length);
-        if (err < 0) {
-                ERROR("unable to read fragment index table\n");
-                kfree(fragment_index);
-                return ERR_PTR(err);
+        /*
+         * table[0] points to the first fragment table metadata block, this
+         * should be less than fragment_table_start
+         */
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= fragment_table_start) {
+                kfree(table);
+                return ERR_PTR(-EINVAL);
         }
 
-        return fragment_index;
+        return table;
 }
diff --git a/fs/squashfs/id.c b/fs/squashfs/id.c
index b7f64bcd2b70..d38ea3dab951 100644
--- a/fs/squashfs/id.c
+++ b/fs/squashfs/id.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -37,7 +37,6 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 
 /*
@@ -67,27 +66,37 @@ int squashfs_get_id(struct super_block *sb, unsigned int index,
  * Read uncompressed id lookup table indexes from disk into memory
  */
 __le64 *squashfs_read_id_index_table(struct super_block *sb,
-                        u64 id_table_start, unsigned short no_ids)
+                u64 id_table_start, u64 next_table, unsigned short no_ids)
 {
         unsigned int length = SQUASHFS_ID_BLOCK_BYTES(no_ids);
-        __le64 *id_table;
-        int err;
+        __le64 *table;
 
         TRACE("In read_id_index_table, length %d\n", length);
 
-        /* Allocate id lookup table indexes */
-        id_table = kmalloc(length, GFP_KERNEL);
-        if (id_table == NULL) {
-                ERROR("Failed to allocate id index table\n");
-                return ERR_PTR(-ENOMEM);
-        }
+        /* Sanity check values */
+
+        /* there should always be at least one id */
+        if (no_ids == 0)
+                return ERR_PTR(-EINVAL);
+
+        /*
+         * length bytes should not extend into the next table - this check
+         * also traps instances where id_table_start is incorrectly larger
+         * than the next table start
+         */
+        if (id_table_start + length > next_table)
+                return ERR_PTR(-EINVAL);
+
+        table = squashfs_read_table(sb, id_table_start, length);
 
-        err = squashfs_read_table(sb, id_table, id_table_start, length);
-        if (err < 0) {
-                ERROR("unable to read id index table\n");
-                kfree(id_table);
-                return ERR_PTR(err);
+        /*
+         * table[0] points to the first id lookup table metadata block, this
+         * should be less than id_table_start
+         */
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= id_table_start) {
+                kfree(table);
+                return ERR_PTR(-EINVAL);
         }
 
-        return id_table;
+        return table;
 }
diff --git a/fs/squashfs/inode.c b/fs/squashfs/inode.c
index 62e63ad25075..04bebcaa2373 100644
--- a/fs/squashfs/inode.c
+++ b/fs/squashfs/inode.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/fs/squashfs/lzo_wrapper.c b/fs/squashfs/lzo_wrapper.c
index 5d87789bf1c1..00f4dfc5f088 100644
--- a/fs/squashfs/lzo_wrapper.c
+++ b/fs/squashfs/lzo_wrapper.c
@@ -29,7 +29,6 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 #include "decompressor.h"
 
@@ -38,7 +37,7 @@ struct squashfs_lzo {
         void    *output;
 };
 
-static void *lzo_init(struct squashfs_sb_info *msblk)
+static void *lzo_init(struct squashfs_sb_info *msblk, void *buff, int len)
 {
         int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE);
 
@@ -59,7 +58,7 @@ failed2:
 failed:
         ERROR("Failed to allocate lzo workspace\n");
         kfree(stream);
-        return NULL;
+        return ERR_PTR(-ENOMEM);
 }
 
 
diff --git a/fs/squashfs/namei.c b/fs/squashfs/namei.c
index 7a9464d08cf6..4bc63ac64bc0 100644
--- a/fs/squashfs/namei.c
+++ b/fs/squashfs/namei.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -176,6 +176,11 @@ static struct dentry *squashfs_lookup(struct inode *dir, struct dentry *dentry,
                 length += sizeof(dirh);
 
                 dir_count = le32_to_cpu(dirh.count) + 1;
+
+                /* dir_count should never be larger than 256 */
+                if (dir_count > 256)
+                        goto data_error;
+
                 while (dir_count--) {
                         /*
                          * Read directory entry.
@@ -187,6 +192,10 @@ static struct dentry *squashfs_lookup(struct inode *dir, struct dentry *dentry,
 
                         size = le16_to_cpu(dire->size) + 1;
 
+                        /* size should never be larger than SQUASHFS_NAME_LEN */
+                        if (size > SQUASHFS_NAME_LEN)
+                                goto data_error;
+
                         err = squashfs_read_metadata(dir->i_sb, dire->name,
                                         &block, &offset, size);
                         if (err < 0)
@@ -228,6 +237,9 @@ exit_lookup:
         d_add(dentry, inode);
         return ERR_PTR(0);
 
+data_error:
+        err = -EIO;
+
 read_failure:
         ERROR("Unable to read directory block [%llx:%x]\n",
                 squashfs_i(dir)->start + msblk->directory_table,
diff --git a/fs/squashfs/squashfs.h b/fs/squashfs/squashfs.h
index 5d45569d5f72..e3be6a71cfa7 100644
--- a/fs/squashfs/squashfs.h
+++ b/fs/squashfs/squashfs.h
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -27,11 +27,6 @@
 
 #define WARNING(s, args...)     pr_warning("SQUASHFS: "s, ## args)
 
-static inline struct squashfs_inode_info *squashfs_i(struct inode *inode)
-{
-        return list_entry(inode, struct squashfs_inode_info, vfs_inode);
-}
-
 /* block.c */
 extern int squashfs_read_data(struct super_block *, void **, u64, int, u64 *,
                                 int, int);
@@ -49,23 +44,24 @@ extern struct squashfs_cache_entry *squashfs_get_fragment(struct super_block *,
                                 u64, int);
 extern struct squashfs_cache_entry *squashfs_get_datablock(struct super_block *,
                                 u64, int);
-extern int squashfs_read_table(struct super_block *, void *, u64, int);
+extern void *squashfs_read_table(struct super_block *, u64, int);
 
 /* decompressor.c */
 extern const struct squashfs_decompressor *squashfs_lookup_decompressor(int);
+extern void *squashfs_decompressor_init(struct super_block *, unsigned short);
 
 /* export.c */
-extern __le64 *squashfs_read_inode_lookup_table(struct super_block *, u64,
+extern __le64 *squashfs_read_inode_lookup_table(struct super_block *, u64, u64,
                                 unsigned int);
 
 /* fragment.c */
 extern int squashfs_frag_lookup(struct super_block *, unsigned int, u64 *);
 extern __le64 *squashfs_read_fragment_index_table(struct super_block *,
-                                u64, unsigned int);
+                                u64, u64, unsigned int);
 
 /* id.c */
 extern int squashfs_get_id(struct super_block *, unsigned int, unsigned int *);
-extern __le64 *squashfs_read_id_index_table(struct super_block *, u64,
+extern __le64 *squashfs_read_id_index_table(struct super_block *, u64, u64,
                                 unsigned short);
 
 /* inode.c */
@@ -104,6 +100,3 @@ extern const struct xattr_handler *squashfs_xattr_handlers[];
 
 /* zlib_wrapper.c */
 extern const struct squashfs_decompressor squashfs_zlib_comp_ops;
-
-/* lzo_wrapper.c */
-extern const struct squashfs_decompressor squashfs_lzo_comp_ops;
diff --git a/fs/squashfs/squashfs_fs.h b/fs/squashfs/squashfs_fs.h
index c5137fc9ab11..b4a4e539a08c 100644
--- a/fs/squashfs/squashfs_fs.h
+++ b/fs/squashfs/squashfs_fs.h
@@ -4,7 +4,7 @@
  * Squashfs
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -57,6 +57,7 @@
 #define SQUASHFS_ALWAYS_FRAG            5
 #define SQUASHFS_DUPLICATE              6
 #define SQUASHFS_EXPORT                 7
+#define SQUASHFS_COMP_OPT               10
 
 #define SQUASHFS_BIT(flag, bit)         ((flag >> bit) & 1)
 
@@ -81,6 +82,9 @@
 #define SQUASHFS_EXPORTABLE(flags)              SQUASHFS_BIT(flags, \
                                                 SQUASHFS_EXPORT)
 
+#define SQUASHFS_COMP_OPTS(flags)               SQUASHFS_BIT(flags, \
+                                                SQUASHFS_COMP_OPT)
+
 /* Max number of types and file types */
 #define SQUASHFS_DIR_TYPE               1
 #define SQUASHFS_REG_TYPE               2
@@ -238,6 +242,7 @@ struct meta_index {
 #define ZLIB_COMPRESSION        1
 #define LZMA_COMPRESSION        2
 #define LZO_COMPRESSION         3
+#define XZ_COMPRESSION          4
 
 struct squashfs_super_block {
         __le32                  s_magic;
diff --git a/fs/squashfs/squashfs_fs_i.h b/fs/squashfs/squashfs_fs_i.h
index d3e3a37f28a1..73588e7700ed 100644
--- a/fs/squashfs/squashfs_fs_i.h
+++ b/fs/squashfs/squashfs_fs_i.h
@@ -4,7 +4,7 @@
  * Squashfs
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -45,4 +45,10 @@ struct squashfs_inode_info {
         };
         struct inode    vfs_inode;
 };
+
+
+static inline struct squashfs_inode_info *squashfs_i(struct inode *inode)
+{
+        return list_entry(inode, struct squashfs_inode_info, vfs_inode);
+}
 #endif
diff --git a/fs/squashfs/squashfs_fs_sb.h b/fs/squashfs/squashfs_fs_sb.h
index d9037a5215f0..651f0b31d296 100644
--- a/fs/squashfs/squashfs_fs_sb.h
+++ b/fs/squashfs/squashfs_fs_sb.h
@@ -4,7 +4,7 @@
  * Squashfs
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index 88b4f8606652..7438850c62d0 100644
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -30,7 +30,6 @@
 #include <linux/fs.h>
 #include <linux/vfs.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/pagemap.h>
 #include <linux/init.h>
@@ -84,7 +83,7 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
         long long root_inode;
         unsigned short flags;
         unsigned int fragments;
-        u64 lookup_table_start, xattr_id_table_start;
+        u64 lookup_table_start, xattr_id_table_start, next_table;
         int err;
 
         TRACE("Entered squashfs_fill_superblock\n");
@@ -96,12 +95,6 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
         }
         msblk = sb->s_fs_info;
 
-        sblk = kzalloc(sizeof(*sblk), GFP_KERNEL);
-        if (sblk == NULL) {
-                ERROR("Failed to allocate squashfs_super_block\n");
-                goto failure;
-        }
-
         msblk->devblksize = sb_min_blocksize(sb, BLOCK_SIZE);
         msblk->devblksize_log2 = ffz(~msblk->devblksize);
 
@@ -115,10 +108,12 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
          * of bytes_used) we need to set it to an initial sensible dummy value
          */
         msblk->bytes_used = sizeof(*sblk);
-        err = squashfs_read_table(sb, sblk, SQUASHFS_START, sizeof(*sblk));
+        sblk = squashfs_read_table(sb, SQUASHFS_START, sizeof(*sblk));
 
-        if (err < 0) {
+        if (IS_ERR(sblk)) {
                 ERROR("unable to read squashfs_super_block\n");
+                err = PTR_ERR(sblk);
+                sblk = NULL;
                 goto failed_mount;
         }
 
@@ -200,10 +195,6 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
 
         err = -ENOMEM;
 
-        msblk->stream = squashfs_decompressor_init(msblk);
-        if (msblk->stream == NULL)
-                goto failed_mount;
-
         msblk->block_cache = squashfs_cache_init("metadata",
                         SQUASHFS_CACHED_BLKS, SQUASHFS_METADATA_SIZE);
         if (msblk->block_cache == NULL)
@@ -216,18 +207,68 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
                 goto failed_mount;
         }
 
+        msblk->stream = squashfs_decompressor_init(sb, flags);
+        if (IS_ERR(msblk->stream)) {
+                err = PTR_ERR(msblk->stream);
+                msblk->stream = NULL;
+                goto failed_mount;
+        }
+
+        /* Handle xattrs */
+        sb->s_xattr = squashfs_xattr_handlers;
+        xattr_id_table_start = le64_to_cpu(sblk->xattr_id_table_start);
+        if (xattr_id_table_start == SQUASHFS_INVALID_BLK) {
+                next_table = msblk->bytes_used;
+                goto allocate_id_index_table;
+        }
+
+        /* Allocate and read xattr id lookup table */
+        msblk->xattr_id_table = squashfs_read_xattr_id_table(sb,
+                xattr_id_table_start, &msblk->xattr_table, &msblk->xattr_ids);
+        if (IS_ERR(msblk->xattr_id_table)) {
+                ERROR("unable to read xattr id index table\n");
+                err = PTR_ERR(msblk->xattr_id_table);
+                msblk->xattr_id_table = NULL;
+                if (err != -ENOTSUPP)
+                        goto failed_mount;
+        }
+        next_table = msblk->xattr_table;
+
+allocate_id_index_table:
         /* Allocate and read id index table */
         msblk->id_table = squashfs_read_id_index_table(sb,
-                le64_to_cpu(sblk->id_table_start), le16_to_cpu(sblk->no_ids));
+                le64_to_cpu(sblk->id_table_start), next_table,
+                le16_to_cpu(sblk->no_ids));
         if (IS_ERR(msblk->id_table)) {
+                ERROR("unable to read id index table\n");
                 err = PTR_ERR(msblk->id_table);
                 msblk->id_table = NULL;
                 goto failed_mount;
         }
+        next_table = le64_to_cpu(msblk->id_table[0]);
+
+        /* Handle inode lookup table */
+        lookup_table_start = le64_to_cpu(sblk->lookup_table_start);
+        if (lookup_table_start == SQUASHFS_INVALID_BLK)
+                goto handle_fragments;
+
+        /* Allocate and read inode lookup table */
+        msblk->inode_lookup_table = squashfs_read_inode_lookup_table(sb,
+                lookup_table_start, next_table, msblk->inodes);
+        if (IS_ERR(msblk->inode_lookup_table)) {
+                ERROR("unable to read inode lookup table\n");
+                err = PTR_ERR(msblk->inode_lookup_table);
+                msblk->inode_lookup_table = NULL;
+                goto failed_mount;
+        }
+        next_table = le64_to_cpu(msblk->inode_lookup_table[0]);
+
+        sb->s_export_op = &squashfs_export_ops;
 
+handle_fragments:
         fragments = le32_to_cpu(sblk->fragments);
         if (fragments == 0)
-                goto allocate_lookup_table;
+                goto check_directory_table;
 
         msblk->fragment_cache = squashfs_cache_init("fragment",
                 SQUASHFS_CACHED_FRAGMENTS, msblk->block_size);
@@ -238,45 +279,29 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
 
         /* Allocate and read fragment index table */
         msblk->fragment_index = squashfs_read_fragment_index_table(sb,
-                le64_to_cpu(sblk->fragment_table_start), fragments);
+                le64_to_cpu(sblk->fragment_table_start), next_table, fragments);
         if (IS_ERR(msblk->fragment_index)) {
+                ERROR("unable to read fragment index table\n");
                 err = PTR_ERR(msblk->fragment_index);
                 msblk->fragment_index = NULL;
                 goto failed_mount;
         }
+        next_table = le64_to_cpu(msblk->fragment_index[0]);
 
-allocate_lookup_table:
-        lookup_table_start = le64_to_cpu(sblk->lookup_table_start);
-        if (lookup_table_start == SQUASHFS_INVALID_BLK)
-                goto allocate_xattr_table;
-
-        /* Allocate and read inode lookup table */
-        msblk->inode_lookup_table = squashfs_read_inode_lookup_table(sb,
-                lookup_table_start, msblk->inodes);
-        if (IS_ERR(msblk->inode_lookup_table)) {
-                err = PTR_ERR(msblk->inode_lookup_table);
-                msblk->inode_lookup_table = NULL;
+check_directory_table:
+        /* Sanity check directory_table */
+        if (msblk->directory_table >= next_table) {
+                err = -EINVAL;
                 goto failed_mount;
         }
 
-        sb->s_export_op = &squashfs_export_ops;
-
-allocate_xattr_table:
-        sb->s_xattr = squashfs_xattr_handlers;
-        xattr_id_table_start = le64_to_cpu(sblk->xattr_id_table_start);
-        if (xattr_id_table_start == SQUASHFS_INVALID_BLK)
-                goto allocate_root;
-
-        /* Allocate and read xattr id lookup table */
-        msblk->xattr_id_table = squashfs_read_xattr_id_table(sb,
-                xattr_id_table_start, &msblk->xattr_table, &msblk->xattr_ids);
-        if (IS_ERR(msblk->xattr_id_table)) {
-                err = PTR_ERR(msblk->xattr_id_table);
-                msblk->xattr_id_table = NULL;
-                if (err != -ENOTSUPP)
-                        goto failed_mount;
+        /* Sanity check inode_table */
+        if (msblk->inode_table >= msblk->directory_table) {
+                err = -EINVAL;
+                goto failed_mount;
         }
-allocate_root:
+
+        /* allocate root */
         root = new_inode(sb);
         if (!root) {
                 err = -ENOMEM;
@@ -316,11 +341,6 @@ failed_mount:
         sb->s_fs_info = NULL;
         kfree(sblk);
         return err;
-
-failure:
-        kfree(sb->s_fs_info);
-        sb->s_fs_info = NULL;
-        return -ENOMEM;
 }
 
 
@@ -354,8 +374,6 @@ static int squashfs_remount(struct super_block *sb, int *flags, char *data)
 
 static void squashfs_put_super(struct super_block *sb)
 {
-        lock_kernel();
-
         if (sb->s_fs_info) {
                 struct squashfs_sb_info *sbi = sb->s_fs_info;
                 squashfs_cache_delete(sbi->block_cache);
@@ -370,17 +388,13 @@ static void squashfs_put_super(struct super_block *sb)
                 kfree(sb->s_fs_info);
                 sb->s_fs_info = NULL;
         }
-
-        unlock_kernel();
 }
 
 
-static int squashfs_get_sb(struct file_system_type *fs_type, int flags,
-                                const char *dev_name, void *data,
-                                struct vfsmount *mnt)
+static struct dentry *squashfs_mount(struct file_system_type *fs_type,
+                                int flags, const char *dev_name, void *data)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, squashfs_fill_super,
-                                mnt);
+        return mount_bdev(fs_type, flags, dev_name, data, squashfs_fill_super);
 }
 
 
@@ -447,16 +461,23 @@ static struct inode *squashfs_alloc_inode(struct super_block *sb)
 }
 
 
-static void squashfs_destroy_inode(struct inode *inode)
+static void squashfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(squashfs_inode_cachep, squashfs_i(inode));
 }
 
+static void squashfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, squashfs_i_callback);
+}
+
 
 static struct file_system_type squashfs_fs_type = {
         .owner = THIS_MODULE,
         .name = "squashfs",
-        .get_sb = squashfs_get_sb,
+        .mount = squashfs_mount,
         .kill_sb = kill_block_super,
         .fs_flags = FS_REQUIRES_DEV
 };
@@ -472,5 +493,5 @@ static const struct super_operations squashfs_super_ops = {
 module_init(init_squashfs_fs);
 module_exit(exit_squashfs_fs);
 MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
-MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
+MODULE_AUTHOR("Phillip Lougher <phillip@squashfs.org.uk>");
 MODULE_LICENSE("GPL");
diff --git a/fs/squashfs/symlink.c b/fs/squashfs/symlink.c
index ec86434921e1..1191817264cc 100644
--- a/fs/squashfs/symlink.c
+++ b/fs/squashfs/symlink.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/fs/squashfs/xattr.c b/fs/squashfs/xattr.c
index 652b8541f9c6..92fcde7b4d61 100644
--- a/fs/squashfs/xattr.c
+++ b/fs/squashfs/xattr.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2010
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -158,17 +158,18 @@ static int squashfs_xattr_get(struct inode *inode, int name_index,
                                         strncmp(target, name, name_size) == 0) {
                         /* found xattr */
                         if (type & SQUASHFS_XATTR_VALUE_OOL) {
-                                __le64 xattr;
+                                __le64 xattr_val;
+                                u64 xattr;
                                 /* val is a reference to the real location */
                                 err = squashfs_read_metadata(sb, &val, &start,
                                                 &offset, sizeof(val));
                                 if (err < 0)
                                         goto failed;
-                                err = squashfs_read_metadata(sb, &xattr, &start,
-                                         &offset, sizeof(xattr));
+                                err = squashfs_read_metadata(sb, &xattr_val,
+                                        &start, &offset, sizeof(xattr_val));
                                 if (err < 0)
                                         goto failed;
-                                xattr = le64_to_cpu(xattr);
+                                xattr = le64_to_cpu(xattr_val);
                                 start = SQUASHFS_XATTR_BLK(xattr) +
                                                         msblk->xattr_table;
                                 offset = SQUASHFS_XATTR_OFFSET(xattr);
diff --git a/fs/squashfs/xattr.h b/fs/squashfs/xattr.h
index 49fe0d719fbf..c83f5d9ec125 100644
--- a/fs/squashfs/xattr.h
+++ b/fs/squashfs/xattr.h
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2010
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -25,17 +25,18 @@
 extern __le64 *squashfs_read_xattr_id_table(struct super_block *, u64,
                 u64 *, int *);
 extern int squashfs_xattr_lookup(struct super_block *, unsigned int, int *,
-                int *, unsigned long long *);
+                unsigned int *, unsigned long long *);
 #else
 static inline __le64 *squashfs_read_xattr_id_table(struct super_block *sb,
                 u64 start, u64 *xattr_table_start, int *xattr_ids)
 {
         ERROR("Xattrs in filesystem, these will be ignored\n");
+        *xattr_table_start = start;
         return ERR_PTR(-ENOTSUPP);
 }
 
 static inline int squashfs_xattr_lookup(struct super_block *sb,
-                unsigned int index, int *count, int *size,
+                unsigned int index, int *count, unsigned int *size,
                 unsigned long long *xattr)
 {
         return 0;
diff --git a/fs/squashfs/xattr_id.c b/fs/squashfs/xattr_id.c
index cfb41106098f..c89607d690c4 100644
--- a/fs/squashfs/xattr_id.c
+++ b/fs/squashfs/xattr_id.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2010
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -32,8 +32,8 @@
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
+#include "xattr.h"
 
 /*
  * Map xattr id using the xattr id look up table
@@ -67,34 +67,29 @@ __le64 *squashfs_read_xattr_id_table(struct super_block *sb, u64 start,
                 u64 *xattr_table_start, int *xattr_ids)
 {
         unsigned int len;
-        __le64 *xid_table;
-        struct squashfs_xattr_id_table id_table;
-        int err;
+        struct squashfs_xattr_id_table *id_table;
+
+        id_table = squashfs_read_table(sb, start, sizeof(*id_table));
+        if (IS_ERR(id_table))
+                return (__le64 *) id_table;
+
+        *xattr_table_start = le64_to_cpu(id_table->xattr_table_start);
+        *xattr_ids = le32_to_cpu(id_table->xattr_ids);
+        kfree(id_table);
+
+        /* Sanity check values */
+
+        /* there is always at least one xattr id */
+        if (*xattr_ids == 0)
+                return ERR_PTR(-EINVAL);
+
+        /* xattr_table should be less than start */
+        if (*xattr_table_start >= start)
+                return ERR_PTR(-EINVAL);
 
-        err = squashfs_read_table(sb, &id_table, start, sizeof(id_table));
-        if (err < 0) {
-                ERROR("unable to read xattr id table\n");
-                return ERR_PTR(err);
-        }
-        *xattr_table_start = le64_to_cpu(id_table.xattr_table_start);
-        *xattr_ids = le32_to_cpu(id_table.xattr_ids);
         len = SQUASHFS_XATTR_BLOCK_BYTES(*xattr_ids);
 
         TRACE("In read_xattr_index_table, length %d\n", len);
 
-        /* Allocate xattr id lookup table indexes */
-        xid_table = kmalloc(len, GFP_KERNEL);
-        if (xid_table == NULL) {
-                ERROR("Failed to allocate xattr id index table\n");
-                return ERR_PTR(-ENOMEM);
-        }
-
-        err = squashfs_read_table(sb, xid_table, start + sizeof(id_table), len);
-        if (err < 0) {
-                ERROR("unable to read xattr id index table\n");
-                kfree(xid_table);
-                return ERR_PTR(err);
-        }
-
-        return xid_table;
+        return squashfs_read_table(sb, start + sizeof(*id_table), len);
 }
diff --git a/fs/squashfs/xz_wrapper.c b/fs/squashfs/xz_wrapper.c
new file mode 100644
index 000000000000..1760b7d108f6
--- /dev/null
+++ b/fs/squashfs/xz_wrapper.c
@@ -0,0 +1,180 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ * Phillip Lougher <phillip@squashfs.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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * xz_wrapper.c
+ */
+
+
+#include <linux/mutex.h>
+#include <linux/buffer_head.h>
+#include <linux/slab.h>
+#include <linux/xz.h>
+#include <linux/bitops.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs.h"
+#include "decompressor.h"
+
+struct squashfs_xz {
+        struct xz_dec *state;
+        struct xz_buf buf;
+};
+
+struct comp_opts {
+        __le32 dictionary_size;
+        __le32 flags;
+};
+
+static void *squashfs_xz_init(struct squashfs_sb_info *msblk, void *buff,
+        int len)
+{
+        struct comp_opts *comp_opts = buff;
+        struct squashfs_xz *stream;
+        int dict_size = msblk->block_size;
+        int err, n;
+
+        if (comp_opts) {
+                /* check compressor options are the expected length */
+                if (len < sizeof(*comp_opts)) {
+                        err = -EIO;
+                        goto failed;
+                }
+
+                dict_size = le32_to_cpu(comp_opts->dictionary_size);
+
+                /* the dictionary size should be 2^n or 2^n+2^(n+1) */
+                n = ffs(dict_size) - 1;
+                if (dict_size != (1 << n) && dict_size != (1 << n) +
+                                                (1 << (n + 1))) {
+                        err = -EIO;
+                        goto failed;
+                }
+        }
+
+        dict_size = max_t(int, dict_size, SQUASHFS_METADATA_SIZE);
+
+        stream = kmalloc(sizeof(*stream), GFP_KERNEL);
+        if (stream == NULL) {
+                err = -ENOMEM;
+                goto failed;
+        }
+
+        stream->state = xz_dec_init(XZ_PREALLOC, dict_size);
+        if (stream->state == NULL) {
+                kfree(stream);
+                err = -ENOMEM;
+                goto failed;
+        }
+
+        return stream;
+
+failed:
+        ERROR("Failed to initialise xz decompressor\n");
+        return ERR_PTR(err);
+}
+
+
+static void squashfs_xz_free(void *strm)
+{
+        struct squashfs_xz *stream = strm;
+
+        if (stream) {
+                xz_dec_end(stream->state);
+                kfree(stream);
+        }
+}
+
+
+static int squashfs_xz_uncompress(struct squashfs_sb_info *msblk, void **buffer,
+        struct buffer_head **bh, int b, int offset, int length, int srclength,
+        int pages)
+{
+        enum xz_ret xz_err;
+        int avail, total = 0, k = 0, page = 0;
+        struct squashfs_xz *stream = msblk->stream;
+
+        mutex_lock(&msblk->read_data_mutex);
+
+        xz_dec_reset(stream->state);
+        stream->buf.in_pos = 0;
+        stream->buf.in_size = 0;
+        stream->buf.out_pos = 0;
+        stream->buf.out_size = PAGE_CACHE_SIZE;
+        stream->buf.out = buffer[page++];
+
+        do {
+                if (stream->buf.in_pos == stream->buf.in_size && k < b) {
+                        avail = min(length, msblk->devblksize - offset);
+                        length -= avail;
+                        wait_on_buffer(bh[k]);
+                        if (!buffer_uptodate(bh[k]))
+                                goto release_mutex;
+
+                        stream->buf.in = bh[k]->b_data + offset;
+                        stream->buf.in_size = avail;
+                        stream->buf.in_pos = 0;
+                        offset = 0;
+                }
+
+                if (stream->buf.out_pos == stream->buf.out_size
+                                                        && page < pages) {
+                        stream->buf.out = buffer[page++];
+                        stream->buf.out_pos = 0;
+                        total += PAGE_CACHE_SIZE;
+                }
+
+                xz_err = xz_dec_run(stream->state, &stream->buf);
+
+                if (stream->buf.in_pos == stream->buf.in_size && k < b)
+                        put_bh(bh[k++]);
+        } while (xz_err == XZ_OK);
+
+        if (xz_err != XZ_STREAM_END) {
+                ERROR("xz_dec_run error, data probably corrupt\n");
+                goto release_mutex;
+        }
+
+        if (k < b) {
+                ERROR("xz_uncompress error, input remaining\n");
+                goto release_mutex;
+        }
+
+        total += stream->buf.out_pos;
+        mutex_unlock(&msblk->read_data_mutex);
+        return total;
+
+release_mutex:
+        mutex_unlock(&msblk->read_data_mutex);
+
+        for (; k < b; k++)
+                put_bh(bh[k]);
+
+        return -EIO;
+}
+
+const struct squashfs_decompressor squashfs_xz_comp_ops = {
+        .init = squashfs_xz_init,
+        .free = squashfs_xz_free,
+        .decompress = squashfs_xz_uncompress,
+        .id = XZ_COMPRESSION,
+        .name = "xz",
+        .supported = 1
+};
diff --git a/fs/squashfs/zlib_wrapper.c b/fs/squashfs/zlib_wrapper.c
index 7a603874e483..55d918fd2d86 100644
--- a/fs/squashfs/zlib_wrapper.c
+++ b/fs/squashfs/zlib_wrapper.c
@@ -2,7 +2,7 @@
  * Squashfs - a compressed read only filesystem for Linux
  *
  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- * Phillip Lougher <phillip@lougher.demon.co.uk>
+ * Phillip Lougher <phillip@squashfs.org.uk>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -26,20 +26,19 @@
 #include <linux/buffer_head.h>
 #include <linux/slab.h>
 #include <linux/zlib.h>
+#include <linux/vmalloc.h>
 
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
-#include "squashfs_fs_i.h"
 #include "squashfs.h"
 #include "decompressor.h"
 
-static void *zlib_init(struct squashfs_sb_info *dummy)
+static void *zlib_init(struct squashfs_sb_info *dummy, void *buff, int len)
 {
         z_stream *stream = kmalloc(sizeof(z_stream), GFP_KERNEL);
         if (stream == NULL)
                 goto failed;
-        stream->workspace = kmalloc(zlib_inflate_workspacesize(),
-                GFP_KERNEL);
+        stream->workspace = vmalloc(zlib_inflate_workspacesize());
         if (stream->workspace == NULL)
                 goto failed;
 
@@ -48,7 +47,7 @@ static void *zlib_init(struct squashfs_sb_info *dummy)
 failed:
         ERROR("Failed to allocate zlib workspace\n");
         kfree(stream);
-        return NULL;
+        return ERR_PTR(-ENOMEM);
 }
 
 
@@ -57,7 +56,7 @@ static void zlib_free(void *strm)
         z_stream *stream = strm;
 
         if (stream)
-                kfree(stream->workspace);
+                vfree(stream->workspace);
         kfree(stream);
 }
 
@@ -66,8 +65,8 @@ static int zlib_uncompress(struct squashfs_sb_info *msblk, void **buffer,
         struct buffer_head **bh, int b, int offset, int length, int srclength,
         int pages)
 {
-        int zlib_err = 0, zlib_init = 0;
-        int avail, bytes, k = 0, page = 0;
+        int zlib_err, zlib_init = 0;
+        int k = 0, page = 0;
         z_stream *stream = msblk->stream;
 
         mutex_lock(&msblk->read_data_mutex);
@@ -75,21 +74,14 @@ static int zlib_uncompress(struct squashfs_sb_info *msblk, void **buffer,
         stream->avail_out = 0;
         stream->avail_in = 0;
 
-        bytes = length;
         do {
                 if (stream->avail_in == 0 && k < b) {
-                        avail = min(bytes, msblk->devblksize - offset);
-                        bytes -= avail;
+                        int avail = min(length, msblk->devblksize - offset);
+                        length -= avail;
                         wait_on_buffer(bh[k]);
                         if (!buffer_uptodate(bh[k]))
                                 goto release_mutex;
 
-                        if (avail == 0) {
-                                offset = 0;
-                                put_bh(bh[k++]);
-                                continue;
-                        }
-
                         stream->next_in = bh[k]->b_data + offset;
                         stream->avail_in = avail;
                         offset = 0;
@@ -128,6 +120,11 @@ static int zlib_uncompress(struct squashfs_sb_info *msblk, void **buffer,
                 goto release_mutex;
         }
 
+        if (k < b) {
+                ERROR("zlib_uncompress error, data remaining\n");
+                goto release_mutex;
+        }
+
         length = stream->total_out;
         mutex_unlock(&msblk->read_data_mutex);
         return length;