config SQUASHFS

	tristate "SquashFS 3.3 - Squashed file system support"

	select ZLIB_INFLATE

	help

	  Saying Y here includes support for SquashFS 3.3 (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 1 Mbytes (default

	  block size 128K).  SquashFS 3.3 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 systems where low overhead is needed.  Further information

	  and filesystem tools are available from http://squashfs.sourceforge.net.

	  If you want to compile this as a module ( = code which can be

	  inserted in and removed from the running kernel whenever you want),

	  say M here and read <file:Documentation/modules.txt>.  The module

	  will be called squashfs.  Note that the root file system (the one

	  containing the directory /) cannot be compiled as a module.

	  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.

	  If unsure, say N.

config SQUASHFS_FRAGMENT_CACHE_SIZE

	int "Number of fragments cached" if SQUASHFS_EMBEDDED

	depends on SQUASHFS

	default "3"

	help

	  By default SquashFS caches the last 3 fragments read from

	  the filesystem.  Increasing this amount may mean SquashFS

	  has to re-read fragments less often from disk, at the expense

	  of extra system memory.  Decreasing this amount will mean

	  SquashFS uses less memory at the expense of extra reads from disk.

	  Note there must be at least one cached fragment.  Anything

	  much more than three will probably not make much difference.

obj-$(CONFIG_SQUASHFS)		+= squashfs/

/*

 * Squashfs - a compressed read only filesystem for Linux

 *

 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007

 * Phillip Lougher <phillip@lougher.demon.co.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.

 *

 * inode.c

 */

#include <linux/squashfs_fs.h>

#include <linux/module.h>

#include <linux/zlib.h>

#include <linux/fs.h>

#include <linux/squashfs_fs_sb.h>

#include <linux/squashfs_fs_i.h>

#include <linux/buffer_head.h>

#include <linux/vfs.h>

#include <linux/vmalloc.h>

#include <linux/smp_lock.h>

#include <linux/exportfs.h>

#include "squashfs.h"

int squashfs_cached_blks;

static struct dentry *squashfs_get_parent(struct dentry *child);

static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode);

static int squashfs_statfs(struct dentry *, struct kstatfs *);

static int squashfs_symlink_readpage(struct file *file, struct page *page);

static long long read_blocklist(struct inode *inode, int index,

				int readahead_blks, char *block_list,

				unsigned short **block_p, unsigned int *bsize);

static int squashfs_readpage(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 int squashfs_remount(struct super_block *s, int *flags, char *data);

static void squashfs_put_super(struct super_block *);

static int squashfs_get_sb(struct file_system_type *,int, const char *, void *,

				struct vfsmount *);

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 file_system_type squashfs_fs_type = {

	.owner = THIS_MODULE,

	.name = "squashfs",

	.get_sb = squashfs_get_sb,

	.kill_sb = kill_block_super,

	.fs_flags = FS_REQUIRES_DEV

};

static const unsigned char squashfs_filetype_table[] = {

	DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK

};

static struct super_operations squashfs_super_ops = {

	.alloc_inode = squashfs_alloc_inode,

	.destroy_inode = squashfs_destroy_inode,

	.statfs = squashfs_statfs,

	.put_super = squashfs_put_super,

	.remount_fs = squashfs_remount

};

static struct super_operations squashfs_export_super_ops = {

	.alloc_inode = squashfs_alloc_inode,

	.destroy_inode = squashfs_destroy_inode,

	.statfs = squashfs_statfs,

	.put_super = squashfs_put_super,

};

static struct export_operations squashfs_export_ops = {

	.get_parent = squashfs_get_parent

};

SQSH_EXTERN const struct address_space_operations squashfs_symlink_aops = {

	.readpage = squashfs_symlink_readpage

};

SQSH_EXTERN const struct address_space_operations squashfs_aops = {

	.readpage = squashfs_readpage

};

static const struct file_operations squashfs_dir_ops = {

	.read = generic_read_dir,

	.readdir = squashfs_readdir

};

SQSH_EXTERN struct inode_operations squashfs_dir_inode_ops = {

	.lookup = squashfs_lookup

};

static struct buffer_head *get_block_length(struct super_block *s,

				int *cur_index, int *offset, int *c_byte)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	unsigned short temp;

	struct buffer_head *bh;

	if (!(bh = sb_bread(s, *cur_index)))

		goto out;

	if (msblk->devblksize - *offset == 1) {

		if (msblk->swap)

			((unsigned char *) &temp)[1] = *((unsigned char *)

				(bh->b_data + *offset));

		else

			((unsigned char *) &temp)[0] = *((unsigned char *)

				(bh->b_data + *offset));

		brelse(bh);

		if (!(bh = sb_bread(s, ++(*cur_index))))

			goto out;

		if (msblk->swap)

			((unsigned char *) &temp)[0] = *((unsigned char *)

				bh->b_data); 

		else

			((unsigned char *) &temp)[1] = *((unsigned char *)

				bh->b_data); 

		*c_byte = temp;

		*offset = 1;

	} else {

		if (msblk->swap) {

			((unsigned char *) &temp)[1] = *((unsigned char *)

				(bh->b_data + *offset));

			((unsigned char *) &temp)[0] = *((unsigned char *)

				(bh->b_data + *offset + 1)); 

		} else {

			((unsigned char *) &temp)[0] = *((unsigned char *)

				(bh->b_data + *offset));

			((unsigned char *) &temp)[1] = *((unsigned char *)

				(bh->b_data + *offset + 1)); 

		}

		*c_byte = temp;

		*offset += 2;

	}

	if (SQUASHFS_CHECK_DATA(msblk->sblk.flags)) {

		if (*offset == msblk->devblksize) {

			brelse(bh);

			if (!(bh = sb_bread(s, ++(*cur_index))))

				goto out;

			*offset = 0;

		}

		if (*((unsigned char *) (bh->b_data + *offset)) !=

						SQUASHFS_MARKER_BYTE) {

			ERROR("Metadata block marker corrupt @ %x\n",

						*cur_index);

			brelse(bh);

			goto out;

		}

		(*offset)++;

	}

	return bh;

out:

	return NULL;

}

SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer,

			long long index, unsigned int length,

			long long *next_index, int srclength)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	struct buffer_head **bh;

	unsigned int offset = index & ((1 << msblk->devblksize_log2) - 1);

	unsigned int cur_index = index >> msblk->devblksize_log2;

	int bytes, avail_bytes, b = 0, k = 0;

	unsigned int compressed;

	unsigned int c_byte = length;

	bh = kmalloc(((sblk->block_size >> msblk->devblksize_log2) + 1) *

								sizeof(struct buffer_head *), GFP_KERNEL);

	if (bh == NULL)

		goto read_failure;

	if (c_byte) {

		bytes = msblk->devblksize - offset;

		compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte);

		c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);

		TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n", index,

					compressed ? "" : "un", (unsigned int) c_byte, srclength);

		if (c_byte > srclength || index < 0 || (index + c_byte) > sblk->bytes_used)

			goto read_failure;

		bh[0] = sb_getblk(s, cur_index);

		if (bh[0] == NULL)

			goto block_release;

		for (b = 1; bytes < c_byte; b++) {

			bh[b] = sb_getblk(s, ++cur_index);

			if (bh[b] == NULL)

				goto block_release;

			bytes += msblk->devblksize;

		}

		ll_rw_block(READ, b, bh);

	} else {

		if (index < 0 || (index + 2) > sblk->bytes_used)

			goto read_failure;

		bh[0] = get_block_length(s, &cur_index, &offset, &c_byte);

		if (bh[0] == NULL)

			goto read_failure;

		bytes = msblk->devblksize - offset;

		compressed = SQUASHFS_COMPRESSED(c_byte);

		c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);

		TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed

					? "" : "un", (unsigned int) c_byte);

		if (c_byte > srclength || (index + c_byte) > sblk->bytes_used)

			goto read_failure;

		for (b = 1; bytes < c_byte; b++) {

			bh[b] = sb_getblk(s, ++cur_index);

			if (bh[b] == NULL)

				goto block_release;

			bytes += msblk->devblksize;

		}

		ll_rw_block(READ, b - 1, bh + 1);

	}

	if (compressed) {

		int zlib_err = 0;

		/*

	 	* uncompress block

	 	*/

		mutex_lock(&msblk->read_data_mutex);

		msblk->stream.next_out = buffer;

		msblk->stream.avail_out = srclength;

		for (bytes = 0; k < b; k++) {

			avail_bytes = min(c_byte - bytes, msblk->devblksize - offset);

			wait_on_buffer(bh[k]);

			if (!buffer_uptodate(bh[k]))

				goto release_mutex;

			msblk->stream.next_in = bh[k]->b_data + offset;

			msblk->stream.avail_in = avail_bytes;

			if (k == 0) {

				zlib_err = zlib_inflateInit(&msblk->stream);

				if (zlib_err != Z_OK) {

					ERROR("zlib_inflateInit returned unexpected result 0x%x,"

						" srclength %d\n", zlib_err, srclength);

					goto release_mutex;

				}

				if (avail_bytes == 0) {

					offset = 0;

					brelse(bh[k]);

					continue;

				}

			}

			zlib_err = zlib_inflate(&msblk->stream, Z_NO_FLUSH);

			if (zlib_err != Z_OK && zlib_err != Z_STREAM_END) {

				ERROR("zlib_inflate returned unexpected result 0x%x,"

					" srclength %d, avail_in %d, avail_out %d\n", zlib_err,

					srclength, msblk->stream.avail_in, msblk->stream.avail_out);

				goto release_mutex;

			}

			bytes += avail_bytes;

			offset = 0;

			brelse(bh[k]);

		}

		if (zlib_err != Z_STREAM_END)

			goto release_mutex;

		zlib_err = zlib_inflateEnd(&msblk->stream);

		if (zlib_err != Z_OK) {

			ERROR("zlib_inflateEnd returned unexpected result 0x%x,"

				" srclength %d\n", zlib_err, srclength);

			goto release_mutex;

		}

		bytes = msblk->stream.total_out;

		mutex_unlock(&msblk->read_data_mutex);

	} else {

		int i;

		for(i = 0; i < b; i++) {

			wait_on_buffer(bh[i]);

			if (!buffer_uptodate(bh[i]))

				goto block_release;

		}

		for (bytes = 0; k < b; k++) {

			avail_bytes = min(c_byte - bytes, msblk->devblksize - offset);

			memcpy(buffer + bytes, bh[k]->b_data + offset, avail_bytes);

			bytes += avail_bytes;

			offset = 0;

			brelse(bh[k]);

		}

	}

	if (next_index)

		*next_index = index + c_byte + (length ? 0 :

				(SQUASHFS_CHECK_DATA(msblk->sblk.flags) ? 3 : 2));

	kfree(bh);

	return bytes;

release_mutex:

	mutex_unlock(&msblk->read_data_mutex);

block_release:

	for (; k < b; k++)

		brelse(bh[k]);

read_failure:

	ERROR("sb_bread failed reading block 0x%x\n", cur_index);

	kfree(bh);

	return 0;

}

SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, void *buffer,

				long long block, unsigned int offset,

				int length, long long *next_block,

				unsigned int *next_offset)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	int n, i, bytes, return_length = length;

	long long next_index;

	TRACE("Entered squashfs_get_cached_block [%llx:%x]\n", block, offset);

	while (1) {

		for (i = 0; i < squashfs_cached_blks; i++) 

			if (msblk->block_cache[i].block == block)

				break; 

		mutex_lock(&msblk->block_cache_mutex);

		if (i == squashfs_cached_blks) {

			/* read inode header block */

			if (msblk->unused_cache_blks == 0) {

				mutex_unlock(&msblk->block_cache_mutex);

				wait_event(msblk->waitq, msblk->unused_cache_blks);

				continue;

			}

			i = msblk->next_cache;

			for (n = 0; n < squashfs_cached_blks; n++) {

				if (msblk->block_cache[i].block != SQUASHFS_USED_BLK)

					break;

				i = (i + 1) % squashfs_cached_blks;

			}

			msblk->next_cache = (i + 1) % squashfs_cached_blks;

			if (msblk->block_cache[i].block == SQUASHFS_INVALID_BLK) {

				msblk->block_cache[i].data = vmalloc(SQUASHFS_METADATA_SIZE);

				if (msblk->block_cache[i].data == NULL) {

					ERROR("Failed to allocate cache block\n");

					mutex_unlock(&msblk->block_cache_mutex);

					goto out;

				}

			}

			msblk->block_cache[i].block = SQUASHFS_USED_BLK;

			msblk->unused_cache_blks --;

			mutex_unlock(&msblk->block_cache_mutex);

			msblk->block_cache[i].length = squashfs_read_data(s,

				msblk->block_cache[i].data, block, 0, &next_index,

				SQUASHFS_METADATA_SIZE);

			if (msblk->block_cache[i].length == 0) {

				ERROR("Unable to read cache block [%llx:%x]\n", block, offset);

				mutex_lock(&msblk->block_cache_mutex);

				msblk->block_cache[i].block = SQUASHFS_INVALID_BLK;

				msblk->unused_cache_blks ++;

				smp_mb();

				vfree(msblk->block_cache[i].data);

				wake_up(&msblk->waitq);

				mutex_unlock(&msblk->block_cache_mutex);

				goto out;

			}

			mutex_lock(&msblk->block_cache_mutex);

			msblk->block_cache[i].block = block;

			msblk->block_cache[i].next_index = next_index;

			msblk->unused_cache_blks ++;

			smp_mb();

			wake_up(&msblk->waitq);

			TRACE("Read cache block [%llx:%x]\n", block, offset);

		}

		if (msblk->block_cache[i].block != block) {

			mutex_unlock(&msblk->block_cache_mutex);

			continue;

		}

		bytes = msblk->block_cache[i].length - offset;

		if (bytes < 1) {

			mutex_unlock(&msblk->block_cache_mutex);

			goto out;

		} else if (bytes >= 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;

			}

			mutex_unlock(&msblk->block_cache_mutex);

			goto finish;

		} else {

			if (buffer) {

				memcpy(buffer, msblk->block_cache[i].data + offset, bytes);

				buffer = (char *) buffer + bytes;

			}

			block = msblk->block_cache[i].next_index;

			mutex_unlock(&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,

				long long *fragment_start_block,

				unsigned int *fragment_size)

{

	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);

	struct squashfs_fragment_entry fragment_entry;

	if (msblk->swap) {

		struct squashfs_fragment_entry sfragment_entry;

		if (!squashfs_get_cached_block(s, &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, &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;

}

SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk,

				struct squashfs_fragment_cache *fragment)

{

	mutex_lock(&msblk->fragment_mutex);

	fragment->locked --;

	if (fragment->locked == 0) {

		msblk->unused_frag_blks ++;

		smp_mb();

		wake_up(&msblk->fragment_wait_queue);

	}

	mutex_unlock(&msblk->fragment_mutex);

}

SQSH_EXTERN

struct squashfs_fragment_cache *get_cached_fragment(struct super_block *s,

				long long start_block, int length)

{

	int i, n;

	struct squashfs_sb_info *msblk = s->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	while (1) {

		mutex_lock(&msblk->fragment_mutex);

		for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS &&

				msblk->fragment[i].block != start_block; i++);

		if (i == SQUASHFS_CACHED_FRAGMENTS) {

			if (msblk->unused_frag_blks == 0) {

				mutex_unlock(&msblk->fragment_mutex);

				wait_event(msblk->fragment_wait_queue, msblk->unused_frag_blks);

				continue;

			}

			i = msblk->next_fragment;

			for (n = 0; n < SQUASHFS_CACHED_FRAGMENTS; n++) {

				if (msblk->fragment[i].locked == 0)

					break;

				i = (i + 1) % SQUASHFS_CACHED_FRAGMENTS;

			}

			msblk->next_fragment = (msblk->next_fragment + 1) %

				SQUASHFS_CACHED_FRAGMENTS;

			if (msblk->fragment[i].data == NULL) {

				msblk->fragment[i].data = vmalloc(sblk->block_size);

				if (msblk->fragment[i].data == NULL) {

					ERROR("Failed to allocate fragment cache block\n");

					mutex_unlock(&msblk->fragment_mutex);

					goto out;

				}

			}

			msblk->unused_frag_blks --;

			msblk->fragment[i].block = SQUASHFS_INVALID_BLK;

			msblk->fragment[i].locked = 1;

			mutex_unlock(&msblk->fragment_mutex);

			msblk->fragment[i].length = squashfs_read_data(s,

				msblk->fragment[i].data, start_block, length, NULL,

				sblk->block_size);

			if (msblk->fragment[i].length == 0) {

				ERROR("Unable to read fragment cache block [%llx]\n", start_block);

				msblk->fragment[i].locked = 0;

				msblk->unused_frag_blks ++;

				smp_mb();

				wake_up(&msblk->fragment_wait_queue);

				goto out;

			}

			mutex_lock(&msblk->fragment_mutex);

			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);

			mutex_unlock(&msblk->fragment_mutex);

			break;

		}

		if (msblk->fragment[i].locked == 0)

			msblk->unused_frag_blks --;

		msblk->fragment[i].locked++;

		mutex_unlock(&msblk->fragment_mutex);

		TRACE("Got fragment %d, start block %lld, locked %d\n", i,

			msblk->fragment[i].block, msblk->fragment[i].locked);

		break;

	}

	return &msblk->fragment[i];

out:

	return NULL;

}

static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i,

				struct squashfs_base_inode_header *inodeb)

{

	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];

}

static squashfs_inode_t squashfs_inode_lookup(struct super_block *s, int ino)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	long long start = msblk->inode_lookup_table[SQUASHFS_LOOKUP_BLOCK(ino - 1)];

	int offset = SQUASHFS_LOOKUP_BLOCK_OFFSET(ino - 1);

	squashfs_inode_t inode;

	TRACE("Entered squashfs_inode_lookup, inode_number = %d\n", ino);

	if (msblk->swap) {

		squashfs_inode_t sinode;

		if (!squashfs_get_cached_block(s, &sinode, start, offset,

					sizeof(sinode), &start, &offset))

			goto out;

		SQUASHFS_SWAP_INODE_T((&inode), &sinode);

	} else if (!squashfs_get_cached_block(s, &inode, start, offset,

					sizeof(inode), &start, &offset))

			goto out;

	TRACE("squashfs_inode_lookup, inode = 0x%llx\n", inode);

	return inode;

out:

	return SQUASHFS_INVALID_BLK;

}

static struct dentry *squashfs_get_parent(struct dentry *child)

{

	struct inode *i = child->d_inode;

	unsigned long ino = SQUASHFS_I(i)->u.s2.parent_inode;

	squashfs_inode_t inode = squashfs_inode_lookup(i->i_sb, ino);

	struct inode *parent;

	struct dentry *rv;

	TRACE("Entered squashfs_get_parent\n");

	if (inode == SQUASHFS_INVALID_BLK)

		return ERR_PTR(-EINVAL);

	parent = squashfs_iget(i->i_sb, inode, ino);

	if (IS_ERR(parent)) {

		rv = ERR_PTR(-EACCES);

		goto out;

	}

	rv = d_alloc_anon(parent);

	if(rv == NULL)

		rv = ERR_PTR(-ENOMEM);

out:

	return rv;

}

SQSH_EXTERN struct inode *squashfs_iget(struct super_block *s,

				squashfs_inode_t inode, unsigned int inode_number)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	struct inode *i = iget_locked(s, inode_number);

	TRACE("Entered squashfs_iget\n");

	if (!i)

		return ERR_PTR(-ENOMEM);

	if (i->i_state & I_NEW) {

		(msblk->read_inode)(i, inode);

		unlock_new_inode(i);

	}

	return i;

}

static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode)

{

	struct super_block *s = i->i_sb;

	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);

	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_read_inode\n");

	if (msblk->swap) {

		if (!squashfs_get_cached_block(s, sinodeb, block, offset,

					sizeof(*sinodeb), &next_block, &next_offset))

			goto failed_read;

		SQUASHFS_SWAP_BASE_INODE_HEADER(inodeb, sinodeb, sizeof(*sinodeb));

	} else

		if (!squashfs_get_cached_block(s, inodeb, block, offset,

					sizeof(*inodeb), &next_block, &next_offset))

			goto failed_read;

	squashfs_new_inode(msblk, i, inodeb);

	switch(inodeb->inode_type) {

		case SQUASHFS_FILE_TYPE: {

			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, sinodep, block, offset,

						sizeof(*sinodep), &next_block, &next_offset))

					goto failed_read;

				SQUASHFS_SWAP_REG_INODE_HEADER(inodep, sinodep);

			} else

				if (!squashfs_get_cached_block(s, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			frag_blk = SQUASHFS_INVALID_BLK;

			if (inodep->fragment != SQUASHFS_INVALID_FRAG)

					if(!get_fragment_location(s, inodep->fragment, &frag_blk,

												&frag_size))

						goto failed_read;

			i->i_nlink = 1;

			i->i_size = inodep->file_size;

			i->i_fop = &generic_ro_fops;

			i->i_mode |= S_IFREG;

			i->i_blocks = ((i->i_size - 1) >> 9) + 1;

			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;

			i->i_data.a_ops = &squashfs_aops;

			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, 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, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			frag_blk = SQUASHFS_INVALID_BLK;

			if (inodep->fragment != SQUASHFS_INVALID_FRAG)

				if (!get_fragment_location(s, inodep->fragment, &frag_blk,

												 &frag_size))

					goto failed_read;

			i->i_nlink = inodep->nlink;

			i->i_size = inodep->file_size;

			i->i_fop = &generic_ro_fops;

			i->i_mode |= S_IFREG;

			i->i_blocks = ((i->i_size - 1) >> 9) + 1;

			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;

			i->i_data.a_ops = &squashfs_aops;

			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: {

			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, sinodep, block, offset,

						sizeof(*sinodep), &next_block, &next_offset))

					goto failed_read;

				SQUASHFS_SWAP_DIR_INODE_HEADER(inodep, sinodep);

			} else

				if (!squashfs_get_cached_block(s, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			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;

			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: {

			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, sinodep, block, offset,

						sizeof(*sinodep), &next_block, &next_offset))

					goto failed_read;

				SQUASHFS_SWAP_LDIR_INODE_HEADER(inodep, sinodep);

			} else

				if (!squashfs_get_cached_block(s, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			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;

			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: {

			struct squashfs_symlink_inode_header *inodep = &id.symlink;

			struct squashfs_symlink_inode_header *sinodep = &sid.symlink;

			if (msblk->swap) {

				if (!squashfs_get_cached_block(s, sinodep, block, offset,

						sizeof(*sinodep), &next_block, &next_offset))

					goto failed_read;

				SQUASHFS_SWAP_SYMLINK_INODE_HEADER(inodep, sinodep);

			} else

				if (!squashfs_get_cached_block(s, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			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;

			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 *inodep = &id.dev;

			struct squashfs_dev_inode_header *sinodep = &sid.dev;

			if (msblk->swap) {

				if (!squashfs_get_cached_block(s, sinodep, block, offset,

						sizeof(*sinodep), &next_block, &next_offset))

					goto failed_read;

				SQUASHFS_SWAP_DEV_INODE_HEADER(inodep, sinodep);

			} else	

				if (!squashfs_get_cached_block(s, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			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, old_decode_dev(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: {

			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, 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, inodep, block, offset,

						sizeof(*inodep), &next_block, &next_offset))

					goto failed_read;

			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;

	}

	return 1;

failed_read:

	ERROR("Unable to read inode [%llx:%x]\n", block, offset);

failed_read1:

	make_bad_inode(i);

	return 0;

}

static int read_inode_lookup_table(struct super_block *s)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	unsigned int length = SQUASHFS_LOOKUP_BLOCK_BYTES(sblk->inodes);

	TRACE("In read_inode_lookup_table, length %d\n", length);

	/* Allocate inode lookup table */

	msblk->inode_lookup_table = kmalloc(length, GFP_KERNEL);

	if (msblk->inode_lookup_table == NULL) {

		ERROR("Failed to allocate inode lookup table\n");

		return 0;

	}

	if (!squashfs_read_data(s, (char *) msblk->inode_lookup_table,

			sblk->lookup_table_start, length |

			SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length)) {

		ERROR("unable to read inode lookup table\n");

		return 0;

	}

	if (msblk->swap) {

		int i;

		long long block;

		for (i = 0; i < SQUASHFS_LOOKUP_BLOCKS(sblk->inodes); i++) {

			/* XXX */

			SQUASHFS_SWAP_LOOKUP_BLOCKS((&block),

						&msblk->inode_lookup_table[i], 1);

			msblk->inode_lookup_table[i] = block;

		}

	}

	return 1;

}

static int read_fragment_index_table(struct super_block *s)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(sblk->fragments);

	if(length == 0)

		return 1;

	/* Allocate fragment index table */

	msblk->fragment_index = kmalloc(length, GFP_KERNEL);

	if (msblk->fragment_index == NULL) {

		ERROR("Failed to allocate fragment index table\n");

		return 0;

	}

	if (!squashfs_read_data(s, (char *) msblk->fragment_index,

			sblk->fragment_table_start, length |

			SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length)) {

		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++) {

			/* XXX */

			SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment),

						&msblk->fragment_index[i], 1);

			msblk->fragment_index[i] = fragment;

		}

	}

	return 1;

}

static int readahead_metadata(struct super_block *s)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	int i;

	squashfs_cached_blks = SQUASHFS_CACHED_BLKS;

	/* Init inode_table block pointer array */

	msblk->block_cache = kmalloc(sizeof(struct squashfs_cache) *

					squashfs_cached_blks, GFP_KERNEL);

	if (msblk->block_cache == NULL) {

		ERROR("Failed to allocate block cache\n");

		goto failed;

	}

	for (i = 0; i < squashfs_cached_blks; i++)

		msblk->block_cache[i].block = SQUASHFS_INVALID_BLK;

	msblk->next_cache = 0;

	msblk->unused_cache_blks = squashfs_cached_blks;

	return 1;

failed:

	return 0;

}

static int supported_squashfs_filesystem(struct squashfs_sb_info *msblk, int silent)

{

	struct squashfs_super_block *sblk = &msblk->sblk;

	msblk->read_inode = squashfs_read_inode;

	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 int squashfs_fill_super(struct super_block *s, void *data, int silent)

{

	struct squashfs_sb_info *msblk;

	struct squashfs_super_block *sblk;

	int i;

	char b[BDEVNAME_SIZE];

	struct inode *root;

	TRACE("Entered squashfs_fill_superblock\n");

	s->s_fs_info = kzalloc(sizeof(struct squashfs_sb_info), GFP_KERNEL);

	if (s->s_fs_info == NULL) {

		ERROR("Failed to allocate superblock\n");

		goto failure;

	}

	msblk = s->s_fs_info;

	msblk->stream.workspace = vmalloc(zlib_inflate_workspacesize());

	if (msblk->stream.workspace == NULL) {

		ERROR("Failed to allocate zlib workspace\n");

		goto failure;

	}

	sblk = &msblk->sblk;

	msblk->devblksize = sb_min_blocksize(s, BLOCK_SIZE);

	msblk->devblksize_log2 = ffz(~msblk->devblksize);

	mutex_init(&msblk->read_data_mutex);

	mutex_init(&msblk->read_page_mutex);

	mutex_init(&msblk->block_cache_mutex);

	mutex_init(&msblk->fragment_mutex);

	mutex_init(&msblk->meta_index_mutex);

	init_waitqueue_head(&msblk->waitq);

	init_waitqueue_head(&msblk->fragment_wait_queue);

	/* sblk->bytes_used is checked in squashfs_read_data to ensure reads are not

 	 * beyond filesystem end.  As we're using squashfs_read_data to read sblk here,

 	 * first set sblk->bytes_used to a useful value */

	sblk->bytes_used = sizeof(struct squashfs_super_block);

	if (!squashfs_read_data(s, (char *) sblk, SQUASHFS_START,

					sizeof(struct squashfs_super_block) |

					SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, sizeof(struct squashfs_super_block))) {

		SERROR("unable to read superblock\n");

		goto failed_mount;

	}

	/* Check it is a SQUASHFS superblock */

	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(s->s_bdev, b));

			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(s->s_bdev, b));

			goto failed_mount;

		}

	}

	/* Check the MAJOR & MINOR versions */

	if(!supported_squashfs_filesystem(msblk, silent))

		goto failed_mount;

	/* Check the filesystem does not extend beyond the end of the

	   block device */

	if(sblk->bytes_used < 0 || sblk->bytes_used > i_size_read(s->s_bdev->bd_inode))

		goto failed_mount;

	/* Check the root inode for sanity */

	if (SQUASHFS_INODE_OFFSET(sblk->root_inode) > SQUASHFS_METADATA_SIZE)

		goto failed_mount;

	TRACE("Found valid superblock on %s\n", bdevname(s->s_bdev, b));

	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 %spresent 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_maxbytes = MAX_LFS_FILESIZE;

	s->s_flags |= MS_RDONLY;

	s->s_op = &squashfs_super_ops;

	if (readahead_metadata(s) == 0)

		goto failed_mount;

	/* Allocate read_page block */

	msblk->read_page = vmalloc(sblk->block_size);

	if (msblk->read_page == NULL) {

		ERROR("Failed to allocate read_page block\n");

		goto failed_mount;

	}

	/* Allocate uid and gid tables */

	msblk->uid = kmalloc((sblk->no_uids + sblk->no_guids) *

					sizeof(unsigned int), GFP_KERNEL);

	if (msblk->uid == NULL) {

		ERROR("Failed to allocate uid/gid table\n");

		goto failed_mount;

	}

	msblk->guid = msblk->uid + sblk->no_uids;

	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, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) {

			ERROR("unable to read uid/gid table\n");

			goto failed_mount;

		}

		SQUASHFS_SWAP_DATA(msblk->uid, suid, (sblk->no_uids +

			sblk->no_guids), (sizeof(unsigned int) * 8));

	} else

		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, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) {

			ERROR("unable to read uid/gid table\n");

			goto failed_mount;

		}

	if (sblk->s_major == 1 && squashfs_1_0_supported(msblk))

		goto allocate_root;

	msblk->fragment = kzalloc(sizeof(struct squashfs_fragment_cache) *

				SQUASHFS_CACHED_FRAGMENTS, GFP_KERNEL);

	if (msblk->fragment == NULL) {

		ERROR("Failed to allocate fragment block cache\n");

		goto failed_mount;

	}

	for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) {

		msblk->fragment[i].block = SQUASHFS_INVALID_BLK;

	}

	msblk->next_fragment = 0;

	msblk->unused_frag_blks = SQUASHFS_CACHED_FRAGMENTS;

	/* Allocate and read fragment index table */

	if (msblk->read_fragment_index_table(s) == 0)

		goto failed_mount;

	if(sblk->s_major < 3 || sblk->lookup_table_start == SQUASHFS_INVALID_BLK)

		goto allocate_root;

	/* Allocate and read inode lookup table */

	if (read_inode_lookup_table(s) == 0)

		goto failed_mount;

	s->s_op = &squashfs_export_super_ops;

	s->s_export_op = &squashfs_export_ops;

allocate_root:

	root = new_inode(s);

	if ((msblk->read_inode)(root, sblk->root_inode) == 0)

		goto failed_mount;

	insert_inode_hash(root);

	s->s_root = d_alloc_root(root);

	if (s->s_root == NULL) {

		ERROR("Root inode create failed\n");

		iput(root);

		goto failed_mount;

	}

	TRACE("Leaving squashfs_fill_super\n");

	return 0;

failed_mount:

	kfree(msblk->inode_lookup_table);

	kfree(msblk->fragment_index);

	kfree(msblk->fragment);

	kfree(msblk->uid);

	vfree(msblk->read_page);

	kfree(msblk->block_cache);

	kfree(msblk->fragment_index_2);

	vfree(msblk->stream.workspace);

	kfree(s->s_fs_info);

	s->s_fs_info = NULL;

	return -EINVAL;

failure:

	return -ENOMEM;

}

static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf)

{

	struct squashfs_sb_info *msblk = dentry->d_sb->s_fs_info;

	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_bfree = buf->f_bavail = 0;

	buf->f_files = sblk->inodes;

	buf->f_ffree = 0;

	buf->f_namelen = SQUASHFS_NAME_LEN;

	return 0;

}

static int squashfs_symlink_readpage(struct file *file, struct page *page)

{

	struct inode *inode = page->mapping->host;

	int index = page->index << PAGE_CACHE_SHIFT, length, bytes, avail_bytes;

	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) {

		bytes = squashfs_get_cached_block(inode->i_sb, NULL, block,

				offset, PAGE_CACHE_SIZE, &block, &offset);

		if (bytes == 0) {

			ERROR("Unable to read symbolic link [%llx:%x]\n", block, offset);

			goto skip_read;

		}

	}

	if (length != index) {

		ERROR("(squashfs_symlink_readpage) length != index\n");

		bytes = 0;

		goto skip_read;

	}

	avail_bytes = min_t(int, i_size_read(inode) - length, PAGE_CACHE_SIZE);

	bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block, offset,

		avail_bytes, &block, &offset);

	if (bytes == 0)

		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);

	unlock_page(page);

	return 0;

}

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->s_fs_info;

	int i;

	mutex_lock(&msblk->meta_index_mutex);

	TRACE("locate_meta_index: index %d, offset %d\n", index, offset);

	if (msblk->meta_index == NULL)

		goto not_allocated;

	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:

	mutex_unlock(&msblk->meta_index_mutex);

	return meta;

}

struct meta_index *empty_meta_index(struct inode *inode, int offset, int skip)

{

	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;

	struct meta_index *meta = NULL;

	int i;

	mutex_lock(&msblk->meta_index_mutex);

	TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);

	if (msblk->meta_index == NULL) {

		msblk->meta_index = kmalloc(sizeof(struct meta_index) *

					SQUASHFS_META_NUMBER, GFP_KERNEL);

		if (msblk->meta_index == NULL) {

			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;

	}

	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;

	}

	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:

	mutex_unlock(&msblk->meta_index_mutex);

	return meta;

}

void release_meta_index(struct inode *inode, struct meta_index *meta)

{

	meta->locked = 0;

	smp_mb();

}

static int read_block_index(struct super_block *s, int blocks, char *block_list,

				long long *start_block, int *offset)

{

	struct squashfs_sb_info *msblk = s->s_fs_info;

	unsigned int *block_listp;

	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("Fail reading 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("Fail reading block list [%llx:%x]\n", *start_block, *offset);

			goto failure;

		}

	}

	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->s_fs_info;

	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) {

			meta = empty_meta_index(inode, offset + 1, skip);

			if (meta == NULL)

				goto all_done;

		} else {

			if(meta->entries == 0)

				goto failed;

			/* XXX */

			offset = index < meta->offset + meta->entries ? index :

				meta->offset + meta->entries - 1;

			/* XXX */

			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;

			}

			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;

	}

	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;

	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	unsigned char *block_list = NULL;

	long long block;

	unsigned int bsize, i;

	int bytes;

	int index = page->index >> (sblk->block_log - PAGE_CACHE_SHIFT);

 	void *pageaddr;

	struct squashfs_fragment_cache *fragment = NULL;

	char *data_ptr = msblk->read_page;

	int mask = (1 << (sblk->block_log - PAGE_CACHE_SHIFT)) - 1;

	int start_index = page->index & ~mask;

	int end_index = start_index | mask;

	int file_end = i_size_read(inode) >> sblk->block_log;

	int sparse = 0;

	TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",

					page->index, SQUASHFS_I(inode)->start_block);

	if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>

					PAGE_CACHE_SHIFT))

		goto out;

	if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK

					|| index < file_end) {

		block_list = kmalloc(SIZE, GFP_KERNEL);

		if (block_list == NULL) {

			ERROR("Failed to allocate block_list\n");

			goto error_out;

		}

		block = (msblk->read_blocklist)(inode, index, 1, block_list, NULL, &bsize);

		if (block == 0)

			goto error_out;

		if (bsize == 0) { /* hole */

			bytes = index == file_end ?

				(i_size_read(inode) & (sblk->block_size - 1)) : sblk->block_size;

			sparse = 1;

		} else {

			mutex_lock(&msblk->read_page_mutex);

			bytes = squashfs_read_data(inode->i_sb, msblk->read_page, block,

				bsize, NULL, sblk->block_size);

			if (bytes == 0) {

				ERROR("Unable to read page, block %llx, size %x\n", block, bsize);

				mutex_unlock(&msblk->read_page_mutex);

				goto error_out;

			}

		}

	} else {

		fragment = get_cached_fragment(inode->i_sb,

					SQUASHFS_I(inode)-> u.s1.fragment_start_block,

					SQUASHFS_I(inode)->u.s1.fragment_size);

		if (fragment == 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 error_out;

		}

		bytes = i_size_read(inode) & (sblk->block_size - 1);

		data_ptr = fragment->data + SQUASHFS_I(inode)->u.s1.fragment_offset;

	}

	for (i = start_index; i <= end_index && bytes > 0; i++,

						bytes -= PAGE_CACHE_SIZE, data_ptr += PAGE_CACHE_SIZE) {

		struct page *push_page;

		int avail = sparse ? 0 : min_t(unsigned int, bytes, PAGE_CACHE_SIZE);

		TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);

		push_page = (i == page->index) ? page :

			grab_cache_page_nowait(page->mapping, i);

		if (!push_page)

			continue;

		if (PageUptodate(push_page))

			goto skip_page;

 		pageaddr = kmap_atomic(push_page, KM_USER0);

		memcpy(pageaddr, data_ptr, avail);

		memset(pageaddr + avail, 0, PAGE_CACHE_SIZE - avail);

		kunmap_atomic(pageaddr, KM_USER0);

		flush_dcache_page(push_page);

		SetPageUptodate(push_page);

skip_page:

		unlock_page(push_page);

		if(i != page->index)

			page_cache_release(push_page);

	}

	if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK

					|| index < file_end) {

		if (!sparse)

			mutex_unlock(&msblk->read_page_mutex);

		kfree(block_list);

	} else

		release_cached_fragment(msblk, fragment);

	return 0;

error_out:

	SetPageError(page);

out:

	pageaddr = kmap_atomic(page, KM_USER0);

	memset(pageaddr, 0, PAGE_CACHE_SIZE);

	kunmap_atomic(pageaddr, KM_USER0);

	flush_dcache_page(page);

	if (!PageError(page))

		SetPageUptodate(page);

	unlock_page(page);

	kfree(block_list);

	return 0;

}

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->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	int i, length = 0;

	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);

	f_pos =- 3;

	if (f_pos == 0)

		goto finish;

	for (i = 0; i < i_count; i++) {

		if (msblk->swap) {

			struct squashfs_dir_index sindex;

			squashfs_get_cached_block(s, &sindex, index_start, index_offset,

					sizeof(sindex), &index_start, &index_offset);

			SQUASHFS_SWAP_DIR_INDEX(&index, &sindex);

		} else

			squashfs_get_cached_block(s, &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 + 3;

}

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->s_fs_info;

	struct squashfs_super_block *sblk = &msblk->sblk;

	int i, length = 0;

	struct squashfs_dir_index *index;

	char *str;

	TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);

	str = kmalloc(sizeof(struct squashfs_dir_index) +

		(SQUASHFS_NAME_LEN + 1) * 2, GFP_KERNEL);

	if (str == NULL) {

		ERROR("Failed to allocate squashfs_dir_index\n");

		goto failure;

	}

	index = (struct squashfs_dir_index *) (str + SQUASHFS_NAME_LEN + 1);

	strncpy(str, name, size);

	str[size] = '\0';

	for (i = 0; i < i_count; i++) {

		if (msblk->swap) {

			struct squashfs_dir_index sindex;

			squashfs_get_cached_block(s, &sindex, index_start, index_offset,

				sizeof(sindex), &index_start, &index_offset);

			SQUASHFS_SWAP_DIR_INDEX(index, &sindex);

		} else

			squashfs_get_cached_block(s, 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);

		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;

	kfree(str);

failure:

	return length + 3;

}

static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)

{

	struct inode *i = file->f_dentry->d_inode;

	struct squashfs_sb_info *msblk = i->i_sb->s_fs_info;

	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;

	struct squashfs_dir_entry *dire;

	TRACE("Entered squashfs_readdir [%llx:%x]\n", next_block, next_offset);

	dire = kmalloc(sizeof(struct squashfs_dir_entry) +

		SQUASHFS_NAME_LEN + 1, GFP_KERNEL);

	if (dire == NULL) {

		ERROR("Failed to allocate squashfs_dir_entry\n");

		goto finish;

	}

	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;

	}

	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)) {