[net-next-2.6.git] / fs / squashfs / inode.c

/*
 * Squashfs - a compressed read only filesystem for Linux
 *
 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
 * 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * inode.c
 */

/*
 * This file implements code to create and read inodes from disk.
 *
 * Inodes in Squashfs are identified by a 48-bit inode which encodes the
 * location of the compressed metadata block containing the inode, and the byte
 * offset into that block where the inode is placed (<block, offset>).
 *
 * To maximise compression there are different inodes for each file type
 * (regular file, directory, device, etc.), the inode contents and length
 * varying with the type.
 *
 * To further maximise compression, two types of regular file inode and
 * directory inode are defined: inodes optimised for frequently occurring
 * regular files and directories, and extended types where extra
 * information has to be stored.
 */

#include <linux/fs.h>
#include <linux/vfs.h>
#include <linux/xattr.h>

#include "squashfs_fs.h"
#include "squashfs_fs_sb.h"
#include "squashfs_fs_i.h"
#include "squashfs.h"
#include "xattr.h"

/*
 * Initialise VFS inode with the base inode information common to all
 * Squashfs inode types.  Sqsh_ino contains the unswapped base inode
 * off disk.
 */
static int squashfs_new_inode(struct super_block *sb, struct inode *inode,
				struct squashfs_base_inode *sqsh_ino)
{
	int err;

	err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->uid), &inode->i_uid);
	if (err)
		return err;

	err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->guid), &inode->i_gid);
	if (err)
		return err;

	inode->i_ino = le32_to_cpu(sqsh_ino->inode_number);
	inode->i_mtime.tv_sec = le32_to_cpu(sqsh_ino->mtime);
	inode->i_atime.tv_sec = inode->i_mtime.tv_sec;
	inode->i_ctime.tv_sec = inode->i_mtime.tv_sec;
	inode->i_mode = le16_to_cpu(sqsh_ino->mode);
	inode->i_size = 0;

	return err;
}


struct inode *squashfs_iget(struct super_block *sb, long long ino,
				unsigned int ino_number)
{
	struct inode *inode = iget_locked(sb, ino_number);
	int err;

	TRACE("Entered squashfs_iget\n");

	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	err = squashfs_read_inode(inode, ino);
	if (err) {
		iget_failed(inode);
		return ERR_PTR(err);
	}

	unlock_new_inode(inode);
	return inode;
}


/*
 * Initialise VFS inode by reading inode from inode table (compressed
 * metadata).  The format and amount of data read depends on type.
 */
int squashfs_read_inode(struct inode *inode, long long ino)
{
	struct super_block *sb = inode->i_sb;
	struct squashfs_sb_info *msblk = sb->s_fs_info;
	u64 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
	int err, type, offset = SQUASHFS_INODE_OFFSET(ino);
	union squashfs_inode squashfs_ino;
	struct squashfs_base_inode *sqshb_ino = &squashfs_ino.base;
	int xattr_id = SQUASHFS_INVALID_XATTR;

	TRACE("Entered squashfs_read_inode\n");

	/*
	 * Read inode base common to all inode types.
	 */
	err = squashfs_read_metadata(sb, sqshb_ino, &block,
				&offset, sizeof(*sqshb_ino));
	if (err < 0)
		goto failed_read;

	err = squashfs_new_inode(sb, inode, sqshb_ino);
	if (err)
		goto failed_read;

	block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
	offset = SQUASHFS_INODE_OFFSET(ino);

	type = le16_to_cpu(sqshb_ino->inode_type);
	switch (type) {
	case SQUASHFS_REG_TYPE: {
		unsigned int frag_offset, frag;
		int frag_size;
		u64 frag_blk;
		struct squashfs_reg_inode *sqsh_ino = &squashfs_ino.reg;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
							sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		frag = le32_to_cpu(sqsh_ino->fragment);
		if (frag != SQUASHFS_INVALID_FRAG) {
			frag_offset = le32_to_cpu(sqsh_ino->offset);
			frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
			if (frag_size < 0) {
				err = frag_size;
				goto failed_read;
			}
		} else {
			frag_blk = SQUASHFS_INVALID_BLK;
			frag_size = 0;
			frag_offset = 0;
		}

		inode->i_nlink = 1;
		inode->i_size = le32_to_cpu(sqsh_ino->file_size);
		inode->i_fop = &generic_ro_fops;
		inode->i_mode |= S_IFREG;
		inode->i_blocks = ((inode->i_size - 1) >> 9) + 1;
		squashfs_i(inode)->fragment_block = frag_blk;
		squashfs_i(inode)->fragment_size = frag_size;
		squashfs_i(inode)->fragment_offset = frag_offset;
		squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
		squashfs_i(inode)->block_list_start = block;
		squashfs_i(inode)->offset = offset;
		inode->i_data.a_ops = &squashfs_aops;

		TRACE("File inode %x:%x, start_block %llx, block_list_start "
			"%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
			offset, squashfs_i(inode)->start, block, offset);
		break;
	}
	case SQUASHFS_LREG_TYPE: {
		unsigned int frag_offset, frag;
		int frag_size;
		u64 frag_blk;
		struct squashfs_lreg_inode *sqsh_ino = &squashfs_ino.lreg;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
							sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		frag = le32_to_cpu(sqsh_ino->fragment);
		if (frag != SQUASHFS_INVALID_FRAG) {
			frag_offset = le32_to_cpu(sqsh_ino->offset);
			frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
			if (frag_size < 0) {
				err = frag_size;
				goto failed_read;
			}
		} else {
			frag_blk = SQUASHFS_INVALID_BLK;
			frag_size = 0;
			frag_offset = 0;
		}

		xattr_id = le32_to_cpu(sqsh_ino->xattr);
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		inode->i_size = le64_to_cpu(sqsh_ino->file_size);
		inode->i_op = &squashfs_inode_ops;
		inode->i_fop = &generic_ro_fops;
		inode->i_mode |= S_IFREG;
		inode->i_blocks = ((inode->i_size -
				le64_to_cpu(sqsh_ino->sparse) - 1) >> 9) + 1;

		squashfs_i(inode)->fragment_block = frag_blk;
		squashfs_i(inode)->fragment_size = frag_size;
		squashfs_i(inode)->fragment_offset = frag_offset;
		squashfs_i(inode)->start = le64_to_cpu(sqsh_ino->start_block);
		squashfs_i(inode)->block_list_start = block;
		squashfs_i(inode)->offset = offset;
		inode->i_data.a_ops = &squashfs_aops;

		TRACE("File inode %x:%x, start_block %llx, block_list_start "
			"%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
			offset, squashfs_i(inode)->start, block, offset);
		break;
	}
	case SQUASHFS_DIR_TYPE: {
		struct squashfs_dir_inode *sqsh_ino = &squashfs_ino.dir;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		inode->i_size = le16_to_cpu(sqsh_ino->file_size);
		inode->i_op = &squashfs_dir_inode_ops;
		inode->i_fop = &squashfs_dir_ops;
		inode->i_mode |= S_IFDIR;
		squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
		squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
		squashfs_i(inode)->dir_idx_cnt = 0;
		squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);

		TRACE("Directory inode %x:%x, start_block %llx, offset %x\n",
				SQUASHFS_INODE_BLK(ino), offset,
				squashfs_i(inode)->start,
				le16_to_cpu(sqsh_ino->offset));
		break;
	}
	case SQUASHFS_LDIR_TYPE: {
		struct squashfs_ldir_inode *sqsh_ino = &squashfs_ino.ldir;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		xattr_id = le32_to_cpu(sqsh_ino->xattr);
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		inode->i_size = le32_to_cpu(sqsh_ino->file_size);
		inode->i_op = &squashfs_dir_inode_ops;
		inode->i_fop = &squashfs_dir_ops;
		inode->i_mode |= S_IFDIR;
		squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
		squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
		squashfs_i(inode)->dir_idx_start = block;
		squashfs_i(inode)->dir_idx_offset = offset;
		squashfs_i(inode)->dir_idx_cnt = le16_to_cpu(sqsh_ino->i_count);
		squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);

		TRACE("Long directory inode %x:%x, start_block %llx, offset "
				"%x\n", SQUASHFS_INODE_BLK(ino), offset,
				squashfs_i(inode)->start,
				le16_to_cpu(sqsh_ino->offset));
		break;
	}
	case SQUASHFS_SYMLINK_TYPE:
	case SQUASHFS_LSYMLINK_TYPE: {
		struct squashfs_symlink_inode *sqsh_ino = &squashfs_ino.symlink;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		inode->i_size = le32_to_cpu(sqsh_ino->symlink_size);
		inode->i_op = &squashfs_symlink_inode_ops;
		inode->i_data.a_ops = &squashfs_symlink_aops;
		inode->i_mode |= S_IFLNK;
		squashfs_i(inode)->start = block;
		squashfs_i(inode)->offset = offset;

		if (type == SQUASHFS_LSYMLINK_TYPE) {
			__le32 xattr;

			err = squashfs_read_metadata(sb, NULL, &block,
						&offset, inode->i_size);
			if (err < 0)
				goto failed_read;
			err = squashfs_read_metadata(sb, &xattr, &block,
						&offset, sizeof(xattr));
			if (err < 0)
				goto failed_read;
			xattr_id = le32_to_cpu(xattr);
		}

		TRACE("Symbolic link inode %x:%x, start_block %llx, offset "
				"%x\n", SQUASHFS_INODE_BLK(ino), offset,
				block, offset);
		break;
	}
	case SQUASHFS_BLKDEV_TYPE:
	case SQUASHFS_CHRDEV_TYPE: {
		struct squashfs_dev_inode *sqsh_ino = &squashfs_ino.dev;
		unsigned int rdev;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		if (type == SQUASHFS_CHRDEV_TYPE)
			inode->i_mode |= S_IFCHR;
		else
			inode->i_mode |= S_IFBLK;
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		rdev = le32_to_cpu(sqsh_ino->rdev);
		init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));

		TRACE("Device inode %x:%x, rdev %x\n",
				SQUASHFS_INODE_BLK(ino), offset, rdev);
		break;
	}
	case SQUASHFS_LBLKDEV_TYPE:
	case SQUASHFS_LCHRDEV_TYPE: {
		struct squashfs_ldev_inode *sqsh_ino = &squashfs_ino.ldev;
		unsigned int rdev;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		if (type == SQUASHFS_LCHRDEV_TYPE)
			inode->i_mode |= S_IFCHR;
		else
			inode->i_mode |= S_IFBLK;
		xattr_id = le32_to_cpu(sqsh_ino->xattr);
		inode->i_op = &squashfs_inode_ops;
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		rdev = le32_to_cpu(sqsh_ino->rdev);
		init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));

		TRACE("Device inode %x:%x, rdev %x\n",
				SQUASHFS_INODE_BLK(ino), offset, rdev);
		break;
	}
	case SQUASHFS_FIFO_TYPE:
	case SQUASHFS_SOCKET_TYPE: {
		struct squashfs_ipc_inode *sqsh_ino = &squashfs_ino.ipc;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		if (type == SQUASHFS_FIFO_TYPE)
			inode->i_mode |= S_IFIFO;
		else
			inode->i_mode |= S_IFSOCK;
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		init_special_inode(inode, inode->i_mode, 0);
		break;
	}
	case SQUASHFS_LFIFO_TYPE:
	case SQUASHFS_LSOCKET_TYPE: {
		struct squashfs_lipc_inode *sqsh_ino = &squashfs_ino.lipc;

		err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
				sizeof(*sqsh_ino));
		if (err < 0)
			goto failed_read;

		if (type == SQUASHFS_LFIFO_TYPE)
			inode->i_mode |= S_IFIFO;
		else
			inode->i_mode |= S_IFSOCK;
		xattr_id = le32_to_cpu(sqsh_ino->xattr);
		inode->i_op = &squashfs_inode_ops;
		inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
		init_special_inode(inode, inode->i_mode, 0);
		break;
	}
	default:
		ERROR("Unknown inode type %d in squashfs_iget!\n", type);
		return -EINVAL;
	}

	if (xattr_id != SQUASHFS_INVALID_XATTR && msblk->xattr_id_table) {
		err = squashfs_xattr_lookup(sb, xattr_id,
					&squashfs_i(inode)->xattr_count,
					&squashfs_i(inode)->xattr_size,
					&squashfs_i(inode)->xattr);
		if (err < 0)
			goto failed_read;
		inode->i_blocks += ((squashfs_i(inode)->xattr_size - 1) >> 9)
				+ 1;
	} else
		squashfs_i(inode)->xattr_count = 0;

	return 0;

failed_read:
	ERROR("Unable to read inode 0x%llx\n", ino);
	return err;
}


const struct inode_operations squashfs_inode_ops = {
	.getxattr = generic_getxattr,
	.listxattr = squashfs_listxattr
};
Commit	Line	Data
6545b246 PL	1	/*
	2	* Squashfs - a compressed read only filesystem for Linux
	3	*
	4	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
	5	* Phillip Lougher <phillip@lougher.demon.co.uk>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version 2,
	10	* or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	20	*
	21	* inode.c
	22	*/
	23
	24	/*
	25	* This file implements code to create and read inodes from disk.
	26	*
	27	* Inodes in Squashfs are identified by a 48-bit inode which encodes the
	28	* location of the compressed metadata block containing the inode, and the byte
	29	* offset into that block where the inode is placed (<block, offset>).
	30	*
	31	* To maximise compression there are different inodes for each file type
	32	* (regular file, directory, device, etc.), the inode contents and length
	33	* varying with the type.
	34	*
	35	* To further maximise compression, two types of regular file inode and
	36	* directory inode are defined: inodes optimised for frequently occurring
	37	* regular files and directories, and extended types where extra
	38	* information has to be stored.
	39	*/
	40
	41	#include <linux/fs.h>
	42	#include <linux/vfs.h>
67f66cc6	43	#include <linux/xattr.h>
6545b246 PL	44
	45	#include "squashfs_fs.h"
	46	#include "squashfs_fs_sb.h"
	47	#include "squashfs_fs_i.h"
	48	#include "squashfs.h"
01e5b4e4	49	#include "xattr.h"
6545b246 PL	50
	51	/*
	52	* Initialise VFS inode with the base inode information common to all
	53	* Squashfs inode types. Sqsh_ino contains the unswapped base inode
	54	* off disk.
	55	*/
	56	static int squashfs_new_inode(struct super_block sb, struct inode inode,
	57	struct squashfs_base_inode *sqsh_ino)
	58	{
	59	int err;
	60
	61	err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->uid), &inode->i_uid);
	62	if (err)
	63	return err;
	64
	65	err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->guid), &inode->i_gid);
	66	if (err)
	67	return err;
	68
	69	inode->i_ino = le32_to_cpu(sqsh_ino->inode_number);
	70	inode->i_mtime.tv_sec = le32_to_cpu(sqsh_ino->mtime);
	71	inode->i_atime.tv_sec = inode->i_mtime.tv_sec;
	72	inode->i_ctime.tv_sec = inode->i_mtime.tv_sec;
	73	inode->i_mode = le16_to_cpu(sqsh_ino->mode);
	74	inode->i_size = 0;
	75
	76	return err;
	77	}
	78
	79
	80	struct inode squashfs_iget(struct super_block sb, long long ino,
	81	unsigned int ino_number)
	82	{
	83	struct inode *inode = iget_locked(sb, ino_number);
	84	int err;
	85
	86	TRACE("Entered squashfs_iget\n");
	87
	88	if (!inode)
	89	return ERR_PTR(-ENOMEM);
	90	if (!(inode->i_state & I_NEW))
	91	return inode;
	92
	93	err = squashfs_read_inode(inode, ino);
	94	if (err) {
	95	iget_failed(inode);
	96	return ERR_PTR(err);
	97	}
	98
	99	unlock_new_inode(inode);
	100	return inode;
	101	}
	102
	103
	104	/*
	105	* Initialise VFS inode by reading inode from inode table (compressed
	106	* metadata). The format and amount of data read depends on type.
	107	*/
	108	int squashfs_read_inode(struct inode *inode, long long ino)
	109	{
	110	struct super_block *sb = inode->i_sb;
	111	struct squashfs_sb_info *msblk = sb->s_fs_info;
	112	u64 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
	113	int err, type, offset = SQUASHFS_INODE_OFFSET(ino);
114	union squashfs_inode squashfs_ino;
115	struct squashfs_base_inode *sqshb_ino = &squashfs_ino.base;
67f66cc6	116	int xattr_id = SQUASHFS_INVALID_XATTR;
6545b246 PL	117
	118	TRACE("Entered squashfs_read_inode\n");
	119
	120	/*
	121	* Read inode base common to all inode types.
	122	*/
	123	err = squashfs_read_metadata(sb, sqshb_ino, &block,
	124	&offset, sizeof(*sqshb_ino));
	125	if (err < 0)
	126	goto failed_read;
	127
	128	err = squashfs_new_inode(sb, inode, sqshb_ino);
	129	if (err)
	130	goto failed_read;
	131
	132	block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
	133	offset = SQUASHFS_INODE_OFFSET(ino);
	134
	135	type = le16_to_cpu(sqshb_ino->inode_type);
	136	switch (type) {
	137	case SQUASHFS_REG_TYPE: {
f4f8056a RK	138	unsigned int frag_offset, frag;
f4f8056a RK	139	int frag_size;
6545b246 PL	140	u64 frag_blk;
	141	struct squashfs_reg_inode *sqsh_ino = &squashfs_ino.reg;
	142
	143	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	144	sizeof(*sqsh_ino));
	145	if (err < 0)
	146	goto failed_read;
	147
	148	frag = le32_to_cpu(sqsh_ino->fragment);
	149	if (frag != SQUASHFS_INVALID_FRAG) {
	150	frag_offset = le32_to_cpu(sqsh_ino->offset);
	151	frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
	152	if (frag_size < 0) {
	153	err = frag_size;
	154	goto failed_read;
	155	}
	156	} else {
	157	frag_blk = SQUASHFS_INVALID_BLK;
	158	frag_size = 0;
	159	frag_offset = 0;
	160	}
	161
	162	inode->i_nlink = 1;
	163	inode->i_size = le32_to_cpu(sqsh_ino->file_size);
	164	inode->i_fop = &generic_ro_fops;
	165	inode->i_mode \|= S_IFREG;
	166	inode->i_blocks = ((inode->i_size - 1) >> 9) + 1;
	167	squashfs_i(inode)->fragment_block = frag_blk;
	168	squashfs_i(inode)->fragment_size = frag_size;
	169	squashfs_i(inode)->fragment_offset = frag_offset;
	170	squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
	171	squashfs_i(inode)->block_list_start = block;
	172	squashfs_i(inode)->offset = offset;
	173	inode->i_data.a_ops = &squashfs_aops;
	174
	175	TRACE("File inode %x:%x, start_block %llx, block_list_start "
	176	"%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
	177	offset, squashfs_i(inode)->start, block, offset);
	178	break;
	179	}
	180	case SQUASHFS_LREG_TYPE: {
f4f8056a RK	181	unsigned int frag_offset, frag;
f4f8056a RK	182	int frag_size;
6545b246 PL	183	u64 frag_blk;
	184	struct squashfs_lreg_inode *sqsh_ino = &squashfs_ino.lreg;
	185
	186	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	187	sizeof(*sqsh_ino));
	188	if (err < 0)
	189	goto failed_read;
	190
	191	frag = le32_to_cpu(sqsh_ino->fragment);
	192	if (frag != SQUASHFS_INVALID_FRAG) {
	193	frag_offset = le32_to_cpu(sqsh_ino->offset);
	194	frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
	195	if (frag_size < 0) {
	196	err = frag_size;
	197	goto failed_read;
	198	}
	199	} else {
	200	frag_blk = SQUASHFS_INVALID_BLK;
	201	frag_size = 0;
	202	frag_offset = 0;
	203	}
	204
67f66cc6	205	xattr_id = le32_to_cpu(sqsh_ino->xattr);
6545b246 PL	206	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
6545b246 PL	207	inode->i_size = le64_to_cpu(sqsh_ino->file_size);
67f66cc6	208	inode->i_op = &squashfs_inode_ops;
6545b246 PL	209	inode->i_fop = &generic_ro_fops;
	210	inode->i_mode \|= S_IFREG;
	211	inode->i_blocks = ((inode->i_size -
	212	le64_to_cpu(sqsh_ino->sparse) - 1) >> 9) + 1;
	213
	214	squashfs_i(inode)->fragment_block = frag_blk;
	215	squashfs_i(inode)->fragment_size = frag_size;
	216	squashfs_i(inode)->fragment_offset = frag_offset;
	217	squashfs_i(inode)->start = le64_to_cpu(sqsh_ino->start_block);
	218	squashfs_i(inode)->block_list_start = block;
	219	squashfs_i(inode)->offset = offset;
	220	inode->i_data.a_ops = &squashfs_aops;
	221
	222	TRACE("File inode %x:%x, start_block %llx, block_list_start "
	223	"%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
	224	offset, squashfs_i(inode)->start, block, offset);
	225	break;
	226	}
	227	case SQUASHFS_DIR_TYPE: {
	228	struct squashfs_dir_inode *sqsh_ino = &squashfs_ino.dir;
	229
	230	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	231	sizeof(*sqsh_ino));
	232	if (err < 0)
	233	goto failed_read;
	234
	235	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	236	inode->i_size = le16_to_cpu(sqsh_ino->file_size);
	237	inode->i_op = &squashfs_dir_inode_ops;
	238	inode->i_fop = &squashfs_dir_ops;
	239	inode->i_mode \|= S_IFDIR;
	240	squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
	241	squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
	242	squashfs_i(inode)->dir_idx_cnt = 0;
	243	squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);
	244
	245	TRACE("Directory inode %x:%x, start_block %llx, offset %x\n",
	246	SQUASHFS_INODE_BLK(ino), offset,
	247	squashfs_i(inode)->start,
	248	le16_to_cpu(sqsh_ino->offset));
	249	break;
	250	}
	251	case SQUASHFS_LDIR_TYPE: {
	252	struct squashfs_ldir_inode *sqsh_ino = &squashfs_ino.ldir;
	253
	254	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	255	sizeof(*sqsh_ino));
	256	if (err < 0)
	257	goto failed_read;
	258
67f66cc6	259	xattr_id = le32_to_cpu(sqsh_ino->xattr);
6545b246 PL	260	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	261	inode->i_size = le32_to_cpu(sqsh_ino->file_size);
	262	inode->i_op = &squashfs_dir_inode_ops;
	263	inode->i_fop = &squashfs_dir_ops;
	264	inode->i_mode \|= S_IFDIR;
	265	squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
	266	squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
	267	squashfs_i(inode)->dir_idx_start = block;
	268	squashfs_i(inode)->dir_idx_offset = offset;
	269	squashfs_i(inode)->dir_idx_cnt = le16_to_cpu(sqsh_ino->i_count);
	270	squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);
	271
	272	TRACE("Long directory inode %x:%x, start_block %llx, offset "
	273	"%x\n", SQUASHFS_INODE_BLK(ino), offset,
	274	squashfs_i(inode)->start,
	275	le16_to_cpu(sqsh_ino->offset));
	276	break;
	277	}
	278	case SQUASHFS_SYMLINK_TYPE:
	279	case SQUASHFS_LSYMLINK_TYPE: {
	280	struct squashfs_symlink_inode *sqsh_ino = &squashfs_ino.symlink;
	281
	282	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	283	sizeof(*sqsh_ino));
	284	if (err < 0)
	285	goto failed_read;
	286
	287	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	288	inode->i_size = le32_to_cpu(sqsh_ino->symlink_size);
67f66cc6	289	inode->i_op = &squashfs_symlink_inode_ops;
6545b246 PL	290	inode->i_data.a_ops = &squashfs_symlink_aops;
	291	inode->i_mode \|= S_IFLNK;
	292	squashfs_i(inode)->start = block;
	293	squashfs_i(inode)->offset = offset;
	294
67f66cc6 PL	295	if (type == SQUASHFS_LSYMLINK_TYPE) {
	296	__le32 xattr;
	297
	298	err = squashfs_read_metadata(sb, NULL, &block,
	299	&offset, inode->i_size);
	300	if (err < 0)
	301	goto failed_read;
	302	err = squashfs_read_metadata(sb, &xattr, &block,
	303	&offset, sizeof(xattr));
	304	if (err < 0)
	305	goto failed_read;
	306	xattr_id = le32_to_cpu(xattr);
	307	}
	308
6545b246 PL	309	TRACE("Symbolic link inode %x:%x, start_block %llx, offset "
	310	"%x\n", SQUASHFS_INODE_BLK(ino), offset,
	311	block, offset);
	312	break;
	313	}
	314	case SQUASHFS_BLKDEV_TYPE:
67f66cc6	315	case SQUASHFS_CHRDEV_TYPE: {
6545b246 PL	316	struct squashfs_dev_inode *sqsh_ino = &squashfs_ino.dev;
	317	unsigned int rdev;
	318
	319	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	320	sizeof(*sqsh_ino));
	321	if (err < 0)
	322	goto failed_read;
	323
	324	if (type == SQUASHFS_CHRDEV_TYPE)
	325	inode->i_mode \|= S_IFCHR;
	326	else
	327	inode->i_mode \|= S_IFBLK;
	328	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	329	rdev = le32_to_cpu(sqsh_ino->rdev);
	330	init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
	331
	332	TRACE("Device inode %x:%x, rdev %x\n",
	333	SQUASHFS_INODE_BLK(ino), offset, rdev);
	334	break;
	335	}
67f66cc6 PL	336	case SQUASHFS_LBLKDEV_TYPE:
	337	case SQUASHFS_LCHRDEV_TYPE: {
	338	struct squashfs_ldev_inode *sqsh_ino = &squashfs_ino.ldev;
	339	unsigned int rdev;
	340
	341	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	342	sizeof(*sqsh_ino));
	343	if (err < 0)
	344	goto failed_read;
	345
	346	if (type == SQUASHFS_LCHRDEV_TYPE)
	347	inode->i_mode \|= S_IFCHR;
	348	else
	349	inode->i_mode \|= S_IFBLK;
	350	xattr_id = le32_to_cpu(sqsh_ino->xattr);
	351	inode->i_op = &squashfs_inode_ops;
	352	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	353	rdev = le32_to_cpu(sqsh_ino->rdev);
	354	init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
	355
	356	TRACE("Device inode %x:%x, rdev %x\n",
	357	SQUASHFS_INODE_BLK(ino), offset, rdev);
	358	break;
	359	}
6545b246	360	case SQUASHFS_FIFO_TYPE:
67f66cc6	361	case SQUASHFS_SOCKET_TYPE: {
6545b246 PL	362	struct squashfs_ipc_inode *sqsh_ino = &squashfs_ino.ipc;
	363
	364	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	365	sizeof(*sqsh_ino));
	366	if (err < 0)
	367	goto failed_read;
	368
	369	if (type == SQUASHFS_FIFO_TYPE)
	370	inode->i_mode \|= S_IFIFO;
	371	else
	372	inode->i_mode \|= S_IFSOCK;
	373	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	374	init_special_inode(inode, inode->i_mode, 0);
	375	break;
	376	}
67f66cc6 PL	377	case SQUASHFS_LFIFO_TYPE:
	378	case SQUASHFS_LSOCKET_TYPE: {
	379	struct squashfs_lipc_inode *sqsh_ino = &squashfs_ino.lipc;
	380
	381	err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
	382	sizeof(*sqsh_ino));
	383	if (err < 0)
	384	goto failed_read;
	385
	386	if (type == SQUASHFS_LFIFO_TYPE)
	387	inode->i_mode \|= S_IFIFO;
	388	else
	389	inode->i_mode \|= S_IFSOCK;
	390	xattr_id = le32_to_cpu(sqsh_ino->xattr);
	391	inode->i_op = &squashfs_inode_ops;
	392	inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
	393	init_special_inode(inode, inode->i_mode, 0);
	394	break;
	395	}
6545b246 PL	396	default:
	397	ERROR("Unknown inode type %d in squashfs_iget!\n", type);
	398	return -EINVAL;
	399	}
	400
67f66cc6 PL	401	if (xattr_id != SQUASHFS_INVALID_XATTR && msblk->xattr_id_table) {
	402	err = squashfs_xattr_lookup(sb, xattr_id,
	403	&squashfs_i(inode)->xattr_count,
	404	&squashfs_i(inode)->xattr_size,
	405	&squashfs_i(inode)->xattr);
	406	if (err < 0)
	407	goto failed_read;
	408	inode->i_blocks += ((squashfs_i(inode)->xattr_size - 1) >> 9)
	409	+ 1;
	410	} else
	411	squashfs_i(inode)->xattr_count = 0;
	412
6545b246 PL	413	return 0;
	414
	415	failed_read:
	416	ERROR("Unable to read inode 0x%llx\n", ino);
	417	return err;
	418	}
67f66cc6 PL	419
	420
	421	const struct inode_operations squashfs_inode_ops = {
	422	.getxattr = generic_getxattr,
	423	.listxattr = squashfs_listxattr
	424	};
	425