Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 48d6d8ff authored by Marcin Slusarz's avatar Marcin Slusarz Committed by Linus Torvalds
Browse files

udf: cache struct udf_inode_info 



cache UDF_I(struct inode *) return values when there are
at least 2 uses in one function

Signed-off-by: default avatarMarcin Slusarz <marcin.slusarz@gmail.com>
Acked-by: default avatarJan Kara <jack@suse.cz>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent c0b34438

fs/udf/balloc.c

+20 −15
Original line number Diff line number Diff line
@@ -436,6 +436,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
	struct extent_position oepos, epos;

	int8_t etype;

	int i;

	struct udf_inode_info *iinfo;



	mutex_lock(&sbi->s_alloc_mutex);

	if (bloc.logicalBlockNum < 0 ||
@@ -448,6 +449,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
		goto error_return;

	}



	iinfo = UDF_I(table);

	/* We do this up front - There are some error conditions that

	   could occure, but.. oh well */

	if (inode)
@@ -460,7 +462,7 @@ static void udf_table_free_blocks(struct super_block *sb, 


	epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);

	elen = 0;

	epos.block = oepos.block = UDF_I(table)->i_location;

	epos.block = oepos.block = iinfo->i_location;

	epos.bh = oepos.bh = NULL;



	while (count &&
@@ -539,11 +541,11 @@ static void udf_table_free_blocks(struct super_block *sb, 
		elen = EXT_RECORDED_ALLOCATED |

			(count << sb->s_blocksize_bits);



		if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) {

		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

			adsize = sizeof(short_ad);

		} else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) {

		else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)

			adsize = sizeof(long_ad);

		} else {

		else {

			brelse(oepos.bh);

			brelse(epos.bh);

			goto error_return;
@@ -573,7 +575,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
			if (epos.offset + adsize > sb->s_blocksize) {

				loffset = epos.offset;

				aed->lengthAllocDescs = cpu_to_le32(adsize);

				sptr = UDF_I(table)->i_ext.i_data + epos.offset

				sptr = iinfo->i_ext.i_data + epos.offset

								- adsize;

				dptr = epos.bh->b_data +

					sizeof(struct allocExtDesc);
@@ -592,9 +594,9 @@ static void udf_table_free_blocks(struct super_block *sb, 
							aed->lengthAllocDescs) +

								adsize);

				} else {

					sptr = UDF_I(table)->i_ext.i_data +

					sptr = iinfo->i_ext.i_data +

								epos.offset;

					UDF_I(table)->i_lenAlloc += adsize;

					iinfo->i_lenAlloc += adsize;

					mark_inode_dirty(table);

				}

				epos.offset = sizeof(struct allocExtDesc);
@@ -608,7 +610,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
					    2, 1, epos.block.logicalBlockNum,

					    sizeof(tag));



			switch (UDF_I(table)->i_alloc_type) {

			switch (iinfo->i_alloc_type) {

			case ICBTAG_FLAG_AD_SHORT:

				sad = (short_ad *)sptr;

				sad->extLength = cpu_to_le32(
@@ -639,7 +641,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
			udf_write_aext(table, &epos, eloc, elen, 1);



			if (!epos.bh) {

				UDF_I(table)->i_lenAlloc += adsize;

				iinfo->i_lenAlloc += adsize;

				mark_inode_dirty(table);

			} else {

				aed = (struct allocExtDesc *)epos.bh->b_data;
@@ -672,21 +674,23 @@ static int udf_table_prealloc_blocks(struct super_block *sb, 
	kernel_lb_addr eloc;

	struct extent_position epos;

	int8_t etype = -1;

	struct udf_inode_info *iinfo;



	if (first_block < 0 ||

		first_block >= sbi->s_partmaps[partition].s_partition_len)

		return 0;



	if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

	iinfo = UDF_I(table);

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

		adsize = sizeof(short_ad);

	else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)

	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)

		adsize = sizeof(long_ad);

	else

		return 0;



	mutex_lock(&sbi->s_alloc_mutex);

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I(table)->i_location;

	epos.block = iinfo->i_location;

	epos.bh = NULL;

	eloc.logicalBlockNum = 0xFFFFFFFF;
@@ -739,12 +743,13 @@ static int udf_table_new_block(struct super_block *sb, 
	kernel_lb_addr eloc, uninitialized_var(goal_eloc);

	struct extent_position epos, goal_epos;

	int8_t etype;

	struct udf_inode_info *iinfo = UDF_I(table);



	*err = -ENOSPC;



	if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

		adsize = sizeof(short_ad);

	else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)

	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)

		adsize = sizeof(long_ad);

	else

		return newblock;
@@ -759,7 +764,7 @@ static int udf_table_new_block(struct super_block *sb, 
	   of the current closest match and use that when we are done.

	 */

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I(table)->i_location;

	epos.block = iinfo->i_location;

	epos.bh = goal_epos.bh = NULL;



	while (spread &&

fs/udf/dir.c

+5 −3
Original line number Diff line number Diff line
@@ -117,6 +117,7 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir, 
	int i, num;

	unsigned int dt_type;

	struct extent_position epos = { NULL, 0, {0, 0} };

	struct udf_inode_info *iinfo;



	if (nf_pos >= size)

		return 0;
@@ -125,15 +126,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir, 
		nf_pos = (udf_ext0_offset(dir) >> 2);



	fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;

	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

	iinfo = UDF_I(dir);

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		fibh.sbh = fibh.ebh = NULL;

	} else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),

			      &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {

		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);

		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {

			if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

			if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

				epos.offset -= sizeof(short_ad);

			else if (UDF_I(dir)->i_alloc_type ==

			else if (iinfo->i_alloc_type ==

					ICBTAG_FLAG_AD_LONG)

				epos.offset -= sizeof(long_ad);

		} else {

fs/udf/directory.c

+4 −3
Original line number Diff line number Diff line
@@ -81,12 +81,13 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
	struct fileIdentDesc *fi;

	int i, num, block;

	struct buffer_head *tmp, *bha[16];

	struct udf_inode_info *iinfo = UDF_I(dir);



	fibh->soffset = fibh->eoffset;



	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		fi = udf_get_fileident(UDF_I(dir)->i_ext.i_data -

				       (UDF_I(dir)->i_efe ?

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		fi = udf_get_fileident(iinfo->i_ext.i_data -

				       (iinfo->i_efe ?

					sizeof(struct extendedFileEntry) :

					sizeof(struct fileEntry)),

				       dir->i_sb->s_blocksize,

fs/udf/file.c

+11 −10
Original line number Diff line number Diff line
@@ -45,13 +45,13 @@ static int udf_adinicb_readpage(struct file *file, struct page *page) 
{

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

	char *kaddr;

	struct udf_inode_info *iinfo = UDF_I(inode);



	BUG_ON(!PageLocked(page));



	kaddr = kmap(page);

	memset(kaddr, 0, PAGE_CACHE_SIZE);

	memcpy(kaddr, UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr,

								inode->i_size);

	memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, inode->i_size);

	flush_dcache_page(page);

	SetPageUptodate(page);

	kunmap(page);
@@ -65,12 +65,12 @@ static int udf_adinicb_writepage(struct page *page, 
{

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

	char *kaddr;

	struct udf_inode_info *iinfo = UDF_I(inode);



	BUG_ON(!PageLocked(page));



	kaddr = kmap(page);

	memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, kaddr,

								inode->i_size);

	memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);

	mark_inode_dirty(inode);

	SetPageUptodate(page);

	kunmap(page);
@@ -87,9 +87,10 @@ static int udf_adinicb_write_end(struct file *file, 
	struct inode *inode = mapping->host;

	unsigned offset = pos & (PAGE_CACHE_SIZE - 1);

	char *kaddr;

	struct udf_inode_info *iinfo = UDF_I(inode);



	kaddr = kmap_atomic(page, KM_USER0);

	memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr + offset,

	memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,

		kaddr + offset, copied);

	kunmap_atomic(kaddr, KM_USER0);
@@ -112,8 +113,9 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
	struct inode *inode = file->f_path.dentry->d_inode;

	int err, pos;

	size_t count = iocb->ki_left;

	struct udf_inode_info *iinfo = UDF_I(inode);



	if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		if (file->f_flags & O_APPEND)

			pos = inode->i_size;

		else
@@ -123,16 +125,15 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
				(udf_file_entry_alloc_offset(inode) +

						pos + count)) {

			udf_expand_file_adinicb(inode, pos + count, &err);

			if (UDF_I(inode)->i_alloc_type ==

							ICBTAG_FLAG_AD_IN_ICB) {

			if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

				udf_debug("udf_expand_adinicb: err=%d\n", err);

				return err;

			}

		} else {

			if (pos + count > inode->i_size)

				UDF_I(inode)->i_lenAlloc = pos + count;

				iinfo->i_lenAlloc = pos + count;

			else

				UDF_I(inode)->i_lenAlloc = inode->i_size;

				iinfo->i_lenAlloc = inode->i_size;

		}

	}

fs/udf/ialloc.c

+26 −23
Original line number Diff line number Diff line
@@ -67,6 +67,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	struct inode *inode;

	int block;

	uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;

	struct udf_inode_info *iinfo;

	struct udf_inode_info *dinfo = UDF_I(dir);



	inode = new_inode(sb);
@@ -76,14 +78,15 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	}

	*err = -ENOSPC;



	UDF_I(inode)->i_unique = 0;

	UDF_I(inode)->i_lenExtents = 0;

	UDF_I(inode)->i_next_alloc_block = 0;

	UDF_I(inode)->i_next_alloc_goal = 0;

	UDF_I(inode)->i_strat4096 = 0;

	iinfo = UDF_I(inode);

	iinfo->i_unique = 0;

	iinfo->i_lenExtents = 0;

	iinfo->i_next_alloc_block = 0;

	iinfo->i_next_alloc_goal = 0;

	iinfo->i_strat4096 = 0;



	block = udf_new_block(dir->i_sb, NULL,

			      UDF_I(dir)->i_location.partitionReferenceNum,

			      dinfo->i_location.partitionReferenceNum,

			      start, err);

	if (*err) {

		iput(inode);
@@ -107,7 +110,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
		else

			lvidiu->numFiles =

				cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);

		UDF_I(inode)->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);

		iinfo->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);

		if (!(++uniqueID & 0x00000000FFFFFFFFUL))

			uniqueID += 16;

		lvhd->uniqueID = cpu_to_le64(uniqueID);
@@ -123,41 +126,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
		inode->i_gid = current->fsgid;

	}



	UDF_I(inode)->i_location.logicalBlockNum = block;

	UDF_I(inode)->i_location.partitionReferenceNum =

				UDF_I(dir)->i_location.partitionReferenceNum;

	inode->i_ino = udf_get_lb_pblock(sb, UDF_I(inode)->i_location, 0);

	iinfo->i_location.logicalBlockNum = block;

	iinfo->i_location.partitionReferenceNum =

				dinfo->i_location.partitionReferenceNum;

	inode->i_ino = udf_get_lb_pblock(sb, iinfo->i_location, 0);

	inode->i_blocks = 0;

	UDF_I(inode)->i_lenEAttr = 0;

	UDF_I(inode)->i_lenAlloc = 0;

	UDF_I(inode)->i_use = 0;

	iinfo->i_lenEAttr = 0;

	iinfo->i_lenAlloc = 0;

	iinfo->i_use = 0;

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {

		UDF_I(inode)->i_efe = 1;

		iinfo->i_efe = 1;

		if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)

			sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;

		UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

		iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

					    sizeof(struct extendedFileEntry),

					    GFP_KERNEL);

	} else {

		UDF_I(inode)->i_efe = 0;

		UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

		iinfo->i_efe = 0;

		iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

					    sizeof(struct fileEntry),

					    GFP_KERNEL);

	}

	if (!UDF_I(inode)->i_ext.i_data) {

	if (!iinfo->i_ext.i_data) {

		iput(inode);

		*err = -ENOMEM;

		mutex_unlock(&sbi->s_alloc_mutex);

		return NULL;

	}

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;

		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;

	else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;

		iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;

	else

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;

		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;

	inode->i_mtime = inode->i_atime = inode->i_ctime =

		UDF_I(inode)->i_crtime = current_fs_time(inode->i_sb);

		iinfo->i_crtime = current_fs_time(inode->i_sb);

	insert_inode_hash(inode);

	mark_inode_dirty(inode);

	mutex_unlock(&sbi->s_alloc_mutex);