inode.c

一款linux的文件系统

			return &msBlk->fragment[i];
		}

		msBlk->fragment[i].locked ++;
		up(&msBlk->fragment_mutex);
		
		TRACE("Got fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked);
		return &msBlk->fragment[i];
	}
}


#ifdef SQUASHFS_1_0_COMPATIBILITY
static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode)
{
	struct inode *i = new_inode(s);
	squashfs_sb_info *msBlk = &s->u.squashfs_sb;
	squashfs_super_block *sBlk = &msBlk->sBlk;
	unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
	unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
	unsigned int next_block, next_offset;
	squashfs_base_inode_header_1 inodeb;

	TRACE("Entered squashfs_iget_1\n");

	if(msBlk->swap) {
		squashfs_base_inode_header_1 sinodeb;

		if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
					sizeof(sinodeb), &next_block, &next_offset))
			goto failed_read;
		SQUASHFS_SWAP_BASE_INODE_HEADER_1(&inodeb, &sinodeb, sizeof(sinodeb));
	} else
		if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
					sizeof(inodeb), &next_block, &next_offset))
			goto failed_read;

	i->i_nlink = 1;

	i->i_mtime = sBlk->mkfs_time;
	i->i_atime = sBlk->mkfs_time;
	i->i_ctime = sBlk->mkfs_time;

	if(inodeb.inode_type != SQUASHFS_IPC_TYPE)
		i->i_uid = msBlk->uid[((inodeb.inode_type - 1) / SQUASHFS_TYPES) * 16 + inodeb.uid];
	i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);

	i->i_mode = inodeb.mode;

	switch(inodeb.inode_type == SQUASHFS_IPC_TYPE ? SQUASHFS_IPC_TYPE : (inodeb.inode_type - 1) % SQUASHFS_TYPES + 1) {
		case SQUASHFS_FILE_TYPE: {
			squashfs_reg_inode_header_1 inodep;

			if(msBlk->swap) {
				squashfs_reg_inode_header_1 sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_REG_INODE_HEADER_1(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.file_size;
			i->i_fop = &generic_ro_fops;
			if(sBlk->block_size > 4096)
				i->i_data.a_ops = &squashfs_aops;
			else if(sBlk->block_size == 4096)
				i->i_data.a_ops = &squashfs_aops_4K;
			else
				i->i_data.a_ops = &squashfs_aops_lessthan4K;
			i->i_mode |= S_IFREG;
			i->i_mtime = inodep.mtime;
			i->i_atime = inodep.mtime;
			i->i_ctime = inodep.mtime;
			i->i_blocks = ((i->i_size - 1) >> 9) + 1;
			i->i_blksize = PAGE_CACHE_SIZE;
			i->u.squashfs_i.u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
			i->u.squashfs_i.u.s1.fragment_offset = 0;
			i->u.squashfs_i.start_block = inodep.start_block;
			i->u.squashfs_i.block_list_start = next_block;
			i->u.squashfs_i.offset = next_offset;
			TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x\n",
					SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset);
			break;
		}
		case SQUASHFS_DIR_TYPE: {
			squashfs_dir_inode_header_1 inodep;

			if(msBlk->swap) {
				squashfs_dir_inode_header_1 sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_DIR_INODE_HEADER_1(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.file_size;
			i->i_op = &squashfs_dir_inode_ops;
			i->i_fop = &squashfs_dir_ops;
			i->i_mode |= S_IFDIR;
			i->i_mtime = inodep.mtime;
			i->i_atime = inodep.mtime;
			i->i_ctime = inodep.mtime;
			i->u.squashfs_i.start_block = inodep.start_block;
			i->u.squashfs_i.offset = inodep.offset;
			i->u.squashfs_i.u.s2.directory_index_count = 0;
			TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
					inodep.start_block, inodep.offset);
			break;
		}
		case SQUASHFS_SYMLINK_TYPE: {
			squashfs_symlink_inode_header_1 inodep;
	
			if(msBlk->swap) {
				squashfs_symlink_inode_header_1 sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.symlink_size;
			i->i_op = &page_symlink_inode_operations;
			i->i_data.a_ops = &squashfs_symlink_aops;
			i->i_mode |= S_IFLNK;
			i->u.squashfs_i.start_block = next_block;
			i->u.squashfs_i.offset = next_offset;
			TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n",
				SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset);
			break;
		 }
		 case SQUASHFS_BLKDEV_TYPE:
		 case SQUASHFS_CHRDEV_TYPE: {
			squashfs_dev_inode_header_1 inodep;

			if(msBlk->swap) {
				squashfs_dev_inode_header_1 sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_DEV_INODE_HEADER_1(&inodep, &sinodep);
			} else	
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = 0;
			i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK;
			init_special_inode(i, i->i_mode, inodep.rdev);
			TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev);
			break;
		 }
		 case SQUASHFS_IPC_TYPE: {
			squashfs_ipc_inode_header_1 inodep;

			if(msBlk->swap) {
				squashfs_ipc_inode_header_1 sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_IPC_INODE_HEADER_1(&inodep, &sinodep);
			} else	
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = 0;
			i->i_mode |= (inodep.type == SQUASHFS_FIFO_TYPE) ? S_IFIFO : S_IFSOCK;
			i->i_uid = msBlk->uid[inodep.offset * 16 + inodeb.uid];
			init_special_inode(i, i->i_mode, 0);
			break;
		 }
		 default:
			ERROR("Unknown inode type %d in squashfs_iget!\n", inodeb.inode_type);
				goto failed_read1;
	}
	
	if(inodeb.guid == 15)
		i->i_gid = i->i_uid;
	else
		i->i_gid = msBlk->guid[inodeb.guid];

	insert_inode_hash(i);
	return i;

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

failed_read1:
	return NULL;
}
#endif


static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode)
{
	struct inode *i = new_inode(s);
	squashfs_sb_info *msBlk = &s->u.squashfs_sb;
	squashfs_super_block *sBlk = &msBlk->sBlk;
	unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start;
	unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
	unsigned int next_block, next_offset;
	squashfs_base_inode_header inodeb;

	TRACE("Entered squashfs_iget\n");

	if(msBlk->swap) {
		squashfs_base_inode_header sinodeb;

		if(!squashfs_get_cached_block(s, (char *) &sinodeb, block,  offset,
					sizeof(sinodeb), &next_block, &next_offset))
			goto failed_read;
		SQUASHFS_SWAP_BASE_INODE_HEADER(&inodeb, &sinodeb, sizeof(sinodeb));
	} else
		if(!squashfs_get_cached_block(s, (char *) &inodeb, block,  offset,
					sizeof(inodeb), &next_block, &next_offset))
			goto failed_read;

	i->i_nlink = 1;

	i->i_mtime = sBlk->mkfs_time;
	i->i_atime = sBlk->mkfs_time;
	i->i_ctime = sBlk->mkfs_time;

	i->i_uid = msBlk->uid[inodeb.uid];
	i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset);

	i->i_mode = inodeb.mode;

	switch(inodeb.inode_type) {
		case SQUASHFS_FILE_TYPE: {
			squashfs_reg_inode_header inodep;

			if(msBlk->swap) {
				squashfs_reg_inode_header sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_REG_INODE_HEADER(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->u.squashfs_i.u.s1.fragment_start_block = SQUASHFS_INVALID_BLK;
			if(inodep.fragment != SQUASHFS_INVALID_BLK && !get_fragment_location(s, inodep.fragment,
							&i->u.squashfs_i.u.s1.fragment_start_block, &i->u.squashfs_i.u.s1.fragment_size))
				goto failed_read;

			i->u.squashfs_i.u.s1.fragment_offset = inodep.offset;
			i->i_size = inodep.file_size;
			i->i_fop = &generic_ro_fops;
			if(sBlk->block_size > 4096)
				i->i_data.a_ops = &squashfs_aops;
			else
				i->i_data.a_ops = &squashfs_aops_4K;
			i->i_mode |= S_IFREG;
			i->i_mtime = inodep.mtime;
			i->i_atime = inodep.mtime;
			i->i_ctime = inodep.mtime;
			i->i_blocks = ((i->i_size - 1) >> 9) + 1;
			i->i_blksize = PAGE_CACHE_SIZE;
			i->u.squashfs_i.start_block = inodep.start_block;
			i->u.squashfs_i.block_list_start = next_block;
			i->u.squashfs_i.offset = next_offset;
			TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x fragment_index %x fragment_offset %x\n",
					SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset, inodep.fragment, inodep.offset);
			break;
		}
		case SQUASHFS_DIR_TYPE: {
			squashfs_dir_inode_header inodep;

			if(msBlk->swap) {
				squashfs_dir_inode_header sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_DIR_INODE_HEADER(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.file_size;
			i->i_op = &squashfs_dir_inode_ops;
			i->i_fop = &squashfs_dir_ops;
			i->i_mode |= S_IFDIR;
			i->i_mtime = inodep.mtime;
			i->i_atime = inodep.mtime;
			i->i_ctime = inodep.mtime;
			i->u.squashfs_i.start_block = inodep.start_block;
			i->u.squashfs_i.offset = inodep.offset;
			i->u.squashfs_i.u.s2.directory_index_count = 0;
			TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
					inodep.start_block, inodep.offset);
			break;
		}
		case SQUASHFS_LDIR_TYPE: {
			squashfs_ldir_inode_header inodep;

			if(msBlk->swap) {
				squashfs_ldir_inode_header sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_LDIR_INODE_HEADER(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.file_size;
			i->i_op = &squashfs_dir_inode_ops;
			i->i_fop = &squashfs_dir_ops;
			i->i_mode |= S_IFDIR;
			i->i_mtime = inodep.mtime;
			i->i_atime = inodep.mtime;
			i->i_ctime = inodep.mtime;
			i->u.squashfs_i.start_block = inodep.start_block;
			i->u.squashfs_i.offset = inodep.offset;
			i->u.squashfs_i.u.s2.directory_index_start = next_block;
			i->u.squashfs_i.u.s2.directory_index_offset = next_offset;
			i->u.squashfs_i.u.s2.directory_index_count = inodep.i_count;
			TRACE("Long directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset,
					inodep.start_block, inodep.offset);
			break;
		}
		case SQUASHFS_SYMLINK_TYPE: {
			squashfs_symlink_inode_header inodep;
	
			if(msBlk->swap) {
				squashfs_symlink_inode_header sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_SYMLINK_INODE_HEADER(&inodep, &sinodep);
			} else
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = inodep.symlink_size;
			i->i_op = &page_symlink_inode_operations;
			i->i_data.a_ops = &squashfs_symlink_aops;
			i->i_mode |= S_IFLNK;
			i->u.squashfs_i.start_block = next_block;
			i->u.squashfs_i.offset = next_offset;
			TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n",
				SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset);
			break;
		 }
		 case SQUASHFS_BLKDEV_TYPE:
		 case SQUASHFS_CHRDEV_TYPE: {
			squashfs_dev_inode_header inodep;

			if(msBlk->swap) {
				squashfs_dev_inode_header sinodep;

				if(!squashfs_get_cached_block(s, (char *) &sinodep, block,  offset, sizeof(sinodep),
							&next_block, &next_offset))
					goto failed_read;
				SQUASHFS_SWAP_DEV_INODE_HEADER(&inodep, &sinodep);
			} else	
				if(!squashfs_get_cached_block(s, (char *) &inodep, block,  offset, sizeof(inodep),
							&next_block, &next_offset))
					goto failed_read;

			i->i_size = 0;
			i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK;
			init_special_inode(i, i->i_mode, inodep.rdev);
			TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev);
			break;
		 }
		 case SQUASHFS_FIFO_TYPE:
		 case SQUASHFS_SOCKET_TYPE: {
			i->i_size = 0;
			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;
	}
	
	if(inodeb.guid == SQUASHFS_GUIDS)
		i->i_gid = i->i_uid;
	else
		i->i_gid = msBlk->guid[inodeb.guid];

	insert_inode_hash(i);
	return i;

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

failed_read1:
	return NULL;
}


static struct super_block *squashfs_read_super(struct super_block *s,
		void *data, int silent)