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

Commit ff116fc8 authored by Jan Kara's avatar Jan Kara Committed by Linus Torvalds
Browse files

UDF: introduce struct extent_position 



Introduce a structure extent_position to store a position of an extent and
the corresponding buffer_head in one place.

Signed-off-by: default avatarJan Kara <jack@suse.cz>
Acked-by: default avatarChristoph Hellwig <hch@infradead.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 60448b1d

fs/udf/balloc.c

+83 −89
Original line number Diff line number Diff line
@@ -427,9 +427,9 @@ static void udf_table_free_blocks(struct super_block * sb, 
{

	struct udf_sb_info *sbi = UDF_SB(sb);

	uint32_t start, end;

	uint32_t nextoffset, oextoffset, elen;

	kernel_lb_addr nbloc, obloc, eloc;

	struct buffer_head *obh, *nbh;

	uint32_t elen;

	kernel_lb_addr eloc;

	struct extent_position oepos, epos;

	int8_t etype;

	int i;
@@ -457,14 +457,13 @@ static void udf_table_free_blocks(struct super_block * sb, 
	start = bloc.logicalBlockNum + offset;

	end = bloc.logicalBlockNum + offset + count - 1;



	oextoffset = nextoffset = sizeof(struct unallocSpaceEntry);

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

	elen = 0;

	obloc = nbloc = UDF_I_LOCATION(table);



	obh = nbh = NULL;

	epos.block = oepos.block = UDF_I_LOCATION(table);

	epos.bh = oepos.bh = NULL;



	while (count && (etype =

		udf_next_aext(table, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)

		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)

	{

		if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==

			start))
@@ -482,7 +481,7 @@ static void udf_table_free_blocks(struct super_block * sb, 
				start += count;

				count = 0;

			}

			udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);

			udf_write_aext(table, &oepos, eloc, elen, 1);

		}

		else if (eloc.logicalBlockNum == (end + 1))

		{
@@ -502,20 +501,20 @@ static void udf_table_free_blocks(struct super_block * sb, 
				end -= count;

				count = 0;

			}

			udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);

			udf_write_aext(table, &oepos, eloc, elen, 1);

		}



		if (nbh != obh)

		if (epos.bh != oepos.bh)

		{

			i = -1;

			obloc = nbloc;

			udf_release_data(obh);

			atomic_inc(&nbh->b_count);

			obh = nbh;

			oextoffset = 0;

			oepos.block = epos.block;

			udf_release_data(oepos.bh);

			atomic_inc(&epos.bh->b_count);

			oepos.bh = epos.bh;

			oepos.offset = 0;

		}

		else

			oextoffset = nextoffset;

			oepos.offset = epos.offset;

	}



	if (count)
@@ -547,55 +546,53 @@ static void udf_table_free_blocks(struct super_block * sb, 
			adsize = sizeof(long_ad);

		else

		{

			udf_release_data(obh);

			udf_release_data(nbh);

			udf_release_data(oepos.bh);

			udf_release_data(epos.bh);

			goto error_return;

		}



		if (nextoffset + (2 * adsize) > sb->s_blocksize)

		if (epos.offset + (2 * adsize) > sb->s_blocksize)

		{

			char *sptr, *dptr;

			int loffset;

	

			udf_release_data(obh);

			obh = nbh;

			obloc = nbloc;

			oextoffset = nextoffset;

			udf_release_data(oepos.bh);

			oepos = epos;



			/* Steal a block from the extent being free'd */

			nbloc.logicalBlockNum = eloc.logicalBlockNum;

			epos.block.logicalBlockNum = eloc.logicalBlockNum;

			eloc.logicalBlockNum ++;

			elen -= sb->s_blocksize;



			if (!(nbh = udf_tread(sb,

				udf_get_lb_pblock(sb, nbloc, 0))))

			if (!(epos.bh = udf_tread(sb,

				udf_get_lb_pblock(sb, epos.block, 0))))

			{

				udf_release_data(obh);

				udf_release_data(oepos.bh);

				goto error_return;

			}

			aed = (struct allocExtDesc *)(nbh->b_data);

			aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);

			if (nextoffset + adsize > sb->s_blocksize)

			aed = (struct allocExtDesc *)(epos.bh->b_data);

			aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);

			if (epos.offset + adsize > sb->s_blocksize)

			{

				loffset = nextoffset;

				loffset = epos.offset;

				aed->lengthAllocDescs = cpu_to_le32(adsize);

				sptr = UDF_I_DATA(inode) + nextoffset -

				sptr = UDF_I_DATA(inode) + epos.offset -

					udf_file_entry_alloc_offset(inode) +

					UDF_I_LENEATTR(inode) - adsize;

				dptr = nbh->b_data + sizeof(struct allocExtDesc);

				dptr = epos.bh->b_data + sizeof(struct allocExtDesc);

				memcpy(dptr, sptr, adsize);

				nextoffset = sizeof(struct allocExtDesc) + adsize;

				epos.offset = sizeof(struct allocExtDesc) + adsize;

			}

			else

			{

				loffset = nextoffset + adsize;

				loffset = epos.offset + adsize;

				aed->lengthAllocDescs = cpu_to_le32(0);

				sptr = (obh)->b_data + nextoffset;

				nextoffset = sizeof(struct allocExtDesc);

				sptr = oepos.bh->b_data + epos.offset;

				epos.offset = sizeof(struct allocExtDesc);



				if (obh)

				if (oepos.bh)

				{

					aed = (struct allocExtDesc *)(obh)->b_data;

					aed = (struct allocExtDesc *)oepos.bh->b_data;

					aed->lengthAllocDescs =

						cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);

				}
@@ -606,11 +603,11 @@ static void udf_table_free_blocks(struct super_block * sb, 
				}

			}

			if (UDF_SB_UDFREV(sb) >= 0x0200)

				udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,

					nbloc.logicalBlockNum, sizeof(tag));

				udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,

					epos.block.logicalBlockNum, sizeof(tag));

			else

				udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,

					nbloc.logicalBlockNum, sizeof(tag));

				udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,

					epos.block.logicalBlockNum, sizeof(tag));

			switch (UDF_I_ALLOCTYPE(table))

			{

				case ICBTAG_FLAG_AD_SHORT:
@@ -619,7 +616,7 @@ static void udf_table_free_blocks(struct super_block * sb, 
					sad->extLength = cpu_to_le32(

						EXT_NEXT_EXTENT_ALLOCDECS |

						sb->s_blocksize);

					sad->extPosition = cpu_to_le32(nbloc.logicalBlockNum);

					sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);

					break;

				}

				case ICBTAG_FLAG_AD_LONG:
@@ -628,14 +625,14 @@ static void udf_table_free_blocks(struct super_block * sb, 
					lad->extLength = cpu_to_le32(

						EXT_NEXT_EXTENT_ALLOCDECS |

						sb->s_blocksize);

					lad->extLocation = cpu_to_lelb(nbloc);

					lad->extLocation = cpu_to_lelb(epos.block);

					break;

				}

			}

			if (obh)

			if (oepos.bh)

			{

				udf_update_tag(obh->b_data, loffset);

				mark_buffer_dirty(obh);

				udf_update_tag(oepos.bh->b_data, loffset);

				mark_buffer_dirty(oepos.bh);

			}

			else

				mark_inode_dirty(table);
@@ -643,26 +640,26 @@ static void udf_table_free_blocks(struct super_block * sb, 


		if (elen) /* It's possible that stealing the block emptied the extent */

		{

			udf_write_aext(table, nbloc, &nextoffset, eloc, elen, nbh, 1);

			udf_write_aext(table, &epos, eloc, elen, 1);



			if (!nbh)

			if (!epos.bh)

			{

				UDF_I_LENALLOC(table) += adsize;

				mark_inode_dirty(table);

			}

			else

			{

				aed = (struct allocExtDesc *)nbh->b_data;

				aed = (struct allocExtDesc *)epos.bh->b_data;

				aed->lengthAllocDescs =

					cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);

				udf_update_tag(nbh->b_data, nextoffset);

				mark_buffer_dirty(nbh);

				udf_update_tag(epos.bh->b_data, epos.offset);

				mark_buffer_dirty(epos.bh);

			}

		}

	}



	udf_release_data(nbh);

	udf_release_data(obh);

	udf_release_data(epos.bh);

	udf_release_data(oepos.bh);



error_return:

	sb->s_dirt = 1;
@@ -677,9 +674,9 @@ static int udf_table_prealloc_blocks(struct super_block * sb, 
{

	struct udf_sb_info *sbi = UDF_SB(sb);

	int alloc_count = 0;

	uint32_t extoffset, elen, adsize;

	kernel_lb_addr bloc, eloc;

	struct buffer_head *bh;

	uint32_t elen, adsize;

	kernel_lb_addr eloc;

	struct extent_position epos;

	int8_t etype = -1;



	if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
@@ -693,14 +690,13 @@ static int udf_table_prealloc_blocks(struct super_block * sb, 
		return 0;



	mutex_lock(&sbi->s_alloc_mutex);

	extoffset = sizeof(struct unallocSpaceEntry);

	bloc = UDF_I_LOCATION(table);



	bh = NULL;

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I_LOCATION(table);

	epos.bh = NULL;

	eloc.logicalBlockNum = 0xFFFFFFFF;



	while (first_block != eloc.logicalBlockNum && (etype =

		udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)

		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)

	{

		udf_debug("eloc=%d, elen=%d, first_block=%d\n",

			eloc.logicalBlockNum, elen, first_block);
@@ -709,7 +705,7 @@ static int udf_table_prealloc_blocks(struct super_block * sb, 


	if (first_block == eloc.logicalBlockNum)

	{

		extoffset -= adsize;

		epos.offset -= adsize;



		alloc_count = (elen >> sb->s_blocksize_bits);

		if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))
@@ -719,15 +715,15 @@ static int udf_table_prealloc_blocks(struct super_block * sb, 
			alloc_count = block_count;

			eloc.logicalBlockNum += alloc_count;

			elen -= (alloc_count << sb->s_blocksize_bits);

			udf_write_aext(table, bloc, &extoffset, eloc, (etype << 30) | elen, bh, 1);

			udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);

		}

		else

			udf_delete_aext(table, bloc, extoffset, eloc, (etype << 30) | elen, bh);

			udf_delete_aext(table, epos, eloc, (etype << 30) | elen);

	}

	else

		alloc_count = 0;



	udf_release_data(bh);

	udf_release_data(epos.bh);



	if (alloc_count && UDF_SB_LVIDBH(sb))

	{
@@ -747,9 +743,9 @@ static int udf_table_new_block(struct super_block * sb, 
	struct udf_sb_info *sbi = UDF_SB(sb);

	uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;

	uint32_t newblock = 0, adsize;

	uint32_t extoffset, goal_extoffset, elen, goal_elen = 0;

	kernel_lb_addr bloc, goal_bloc, eloc, goal_eloc;

	struct buffer_head *bh, *goal_bh;

	uint32_t elen, goal_elen = 0;

	kernel_lb_addr eloc, goal_eloc;

	struct extent_position epos, goal_epos;

	int8_t etype;



	*err = -ENOSPC;
@@ -770,14 +766,12 @@ static int udf_table_new_block(struct super_block * sb, 
	   We store the buffer_head, bloc, and extoffset of the current closest

	   match and use that when we are done.

	*/



	extoffset = sizeof(struct unallocSpaceEntry);

	bloc = UDF_I_LOCATION(table);



	goal_bh = bh = NULL;

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I_LOCATION(table);

	epos.bh = goal_epos.bh = NULL;



	while (spread && (etype =

		udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)

		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)

	{

		if (goal >= eloc.logicalBlockNum)

		{
@@ -793,24 +787,24 @@ static int udf_table_new_block(struct super_block * sb, 
		if (nspread < spread)

		{

			spread = nspread;

			if (goal_bh != bh)

			if (goal_epos.bh != epos.bh)

			{

				udf_release_data(goal_bh);

				goal_bh = bh;

				atomic_inc(&goal_bh->b_count);

				udf_release_data(goal_epos.bh);

				goal_epos.bh = epos.bh;

				atomic_inc(&goal_epos.bh->b_count);

			}

			goal_bloc = bloc;

			goal_extoffset = extoffset - adsize;

			goal_epos.block = epos.block;

			goal_epos.offset = epos.offset - adsize;

			goal_eloc = eloc;

			goal_elen = (etype << 30) | elen;

		}

	}



	udf_release_data(bh);

	udf_release_data(epos.bh);



	if (spread == 0xFFFFFFFF)

	{

		udf_release_data(goal_bh);

		udf_release_data(goal_epos.bh);

		mutex_unlock(&sbi->s_alloc_mutex);

		return 0;

	}
@@ -826,17 +820,17 @@ static int udf_table_new_block(struct super_block * sb, 


	if (inode && DQUOT_ALLOC_BLOCK(inode, 1))

	{

		udf_release_data(goal_bh);

		udf_release_data(goal_epos.bh);

		mutex_unlock(&sbi->s_alloc_mutex);

		*err = -EDQUOT;

		return 0;

	}



	if (goal_elen)

		udf_write_aext(table, goal_bloc, &goal_extoffset, goal_eloc, goal_elen, goal_bh, 1);

		udf_write_aext(table, &goal_epos, goal_eloc, goal_elen, 1);

	else

		udf_delete_aext(table, goal_bloc, goal_extoffset, goal_eloc, goal_elen, goal_bh);

	udf_release_data(goal_bh);

		udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);

	udf_release_data(goal_epos.bh);



	if (UDF_SB_LVIDBH(sb))

	{

fs/udf/dir.c

+13 −12
Original line number Diff line number Diff line
@@ -111,12 +111,13 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
	uint16_t liu;

	uint8_t lfi;

	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;

	struct buffer_head * bh = NULL, * tmp, * bha[16];

	kernel_lb_addr bloc, eloc;

	uint32_t extoffset, elen;

	struct buffer_head *tmp, *bha[16];

	kernel_lb_addr eloc;

	uint32_t elen;

	sector_t offset;

	int i, num;

	unsigned int dt_type;

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



	if (nf_pos >= size)

		return 0;
@@ -128,22 +129,22 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)

		fibh.sbh = fibh.ebh = NULL;

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

		&bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))

		&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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

				extoffset -= sizeof(short_ad);

				epos.offset -= sizeof(short_ad);

			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

				extoffset -= sizeof(long_ad);

				epos.offset -= sizeof(long_ad);

		}

		else

			offset = 0;



		if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))

		{

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return -EIO;

		}
@@ -171,7 +172,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
	}

	else

	{

		udf_release_data(bh);

		udf_release_data(epos.bh);

		return -ENOENT;

	}
@@ -179,14 +180,14 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
	{

		filp->f_pos = nf_pos + 1;



		fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);

		fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);



		if (!fi)

		{

			if (fibh.sbh != fibh.ebh)

				udf_release_data(fibh.ebh);

			udf_release_data(fibh.sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return 0;

		}
@@ -246,7 +247,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
				if (fibh.sbh != fibh.ebh)

					udf_release_data(fibh.ebh);

				udf_release_data(fibh.sbh);

				udf_release_data(bh);

				udf_release_data(epos.bh);

	 			return 0;

			}

		}
@@ -257,7 +258,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d 
	if (fibh.sbh != fibh.ebh)

		udf_release_data(fibh.ebh);

	udf_release_data(fibh.sbh);

	udf_release_data(bh);

	udf_release_data(epos.bh);



	return 0;

}

fs/udf/directory.c

+8 −12
Original line number Diff line number Diff line
@@ -75,9 +75,9 @@ struct fileIdentDesc * 
udf_fileident_read(struct inode *dir, loff_t *nf_pos,

	struct udf_fileident_bh *fibh,

	struct fileIdentDesc *cfi,

	kernel_lb_addr *bloc, uint32_t *extoffset, 

	struct extent_position *epos,

	kernel_lb_addr *eloc, uint32_t *elen,

	sector_t *offset, struct buffer_head **bh)

	sector_t *offset)

{

	struct fileIdentDesc *fi;

	int i, num, block;
@@ -105,13 +105,11 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, 


	if (fibh->eoffset == dir->i_sb->s_blocksize)

	{

		int lextoffset = *extoffset;

		int lextoffset = epos->offset;



		if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=

		if (udf_next_aext(dir, epos, eloc, elen, 1) !=

			(EXT_RECORDED_ALLOCATED >> 30))

		{

			return NULL;

		}



		block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
@@ -120,7 +118,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
		if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)

			*offset = 0;

		else

			*extoffset = lextoffset;

			epos->offset = lextoffset;



		udf_release_data(fibh->sbh);

		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
@@ -169,13 +167,11 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
	}

	else if (fibh->eoffset > dir->i_sb->s_blocksize)

	{

		int lextoffset = *extoffset;

		int lextoffset = epos->offset;



		if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=

		if (udf_next_aext(dir, epos, eloc, elen, 1) !=

			(EXT_RECORDED_ALLOCATED >> 30))

		{

			return NULL;

		}



		block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
@@ -184,7 +180,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
		if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)

			*offset = 0;

		else

			*extoffset = lextoffset;

			epos->offset = lextoffset;



		fibh->soffset -= dir->i_sb->s_blocksize;

		fibh->eoffset -= dir->i_sb->s_blocksize;

fs/udf/inode.c

+169 −174

File changed.

Preview size limit exceeded, changes collapsed.

fs/udf/namei.c

+61 −61
Original line number Diff line number Diff line
@@ -155,10 +155,10 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, 
	uint8_t lfi;

	uint16_t liu;

	loff_t size;

	kernel_lb_addr bloc, eloc;

	uint32_t extoffset, elen;

	kernel_lb_addr eloc;

	uint32_t elen;

	sector_t offset;

	struct buffer_head *bh = NULL;

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



	size = (udf_ext0_offset(dir) + dir->i_size) >> 2;

	f_pos = (udf_ext0_offset(dir) >> 2);
@@ -167,41 +167,41 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, 
	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)

		fibh->sbh = fibh->ebh = NULL;

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

		&bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))

		&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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

				extoffset -= sizeof(short_ad);

				epos.offset -= sizeof(short_ad);

			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

				extoffset -= sizeof(long_ad);

				epos.offset -= sizeof(long_ad);

		}

		else

			offset = 0;



		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))

		{

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return NULL;

		}

	}

	else

	{

		udf_release_data(bh);

		udf_release_data(epos.bh);

		return NULL;

	}



	while ( (f_pos < size) )

	{

		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);

		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);



		if (!fi)

		{

			if (fibh->sbh != fibh->ebh)

				udf_release_data(fibh->ebh);

			udf_release_data(fibh->sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return NULL;

		}
@@ -247,7 +247,7 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, 
		{

			if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name))

			{

				udf_release_data(bh);

				udf_release_data(epos.bh);

				return fi;

			}

		}
@@ -255,7 +255,7 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, 
	if (fibh->sbh != fibh->ebh)

		udf_release_data(fibh->ebh);

	udf_release_data(fibh->sbh);

	udf_release_data(bh);

	udf_release_data(epos.bh);

	return NULL;

}
@@ -353,10 +353,10 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
	uint8_t lfi;

	uint16_t liu;

	int block;

	kernel_lb_addr bloc, eloc;

	uint32_t extoffset, elen;

	kernel_lb_addr eloc;

	uint32_t elen;

	sector_t offset;

	struct buffer_head *bh = NULL;

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



	sb = dir->i_sb;
@@ -385,22 +385,22 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)

		fibh->sbh = fibh->ebh = NULL;

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

		&bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))

		&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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

				extoffset -= sizeof(short_ad);

				epos.offset -= sizeof(short_ad);

			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

				extoffset -= sizeof(long_ad);

				epos.offset -= sizeof(long_ad);

		}

		else

			offset = 0;



		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))

		{

			udf_release_data(bh);

			udf_release_data(epos.bh);

			*err = -EIO;

			return NULL;

		}
@@ -418,14 +418,14 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 


	while ( (f_pos < size) )

	{

		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);

		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);



		if (!fi)

		{

			if (fibh->sbh != fibh->ebh)

				udf_release_data(fibh->ebh);

			udf_release_data(fibh->sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			*err = -EIO;

			return NULL;

		}
@@ -455,7 +455,7 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
		{

			if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen)

			{

				udf_release_data(bh);

				udf_release_data(epos.bh);

				cfi->descTag.tagSerialNum = cpu_to_le16(1);

				cfi->fileVersionNum = cpu_to_le16(1);

				cfi->fileCharacteristics = 0;
@@ -480,7 +480,7 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
			if (fibh->sbh != fibh->ebh)

				udf_release_data(fibh->ebh);

			udf_release_data(fibh->sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			*err = -EEXIST;

			return NULL;

		}
@@ -492,8 +492,8 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&

		sb->s_blocksize - fibh->eoffset < nfidlen)

	{

		udf_release_data(bh);

		bh = NULL;

		udf_release_data(epos.bh);

		epos.bh = NULL;

		fibh->soffset -= udf_ext0_offset(dir);

		fibh->eoffset -= udf_ext0_offset(dir);

		f_pos -= (udf_ext0_offset(dir) >> 2);
@@ -502,15 +502,15 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
		udf_release_data(fibh->sbh);

		if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))

			return NULL;

		bloc = UDF_I_LOCATION(dir);

		epos.block = UDF_I_LOCATION(dir);

		eloc.logicalBlockNum = block;

		eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;

		elen = dir->i_sb->s_blocksize;

		extoffset = udf_file_entry_alloc_offset(dir);

		epos.offset = udf_file_entry_alloc_offset(dir);

		if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

			extoffset += sizeof(short_ad);

			epos.offset += sizeof(short_ad);

		else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

			extoffset += sizeof(long_ad);

			epos.offset += sizeof(long_ad);

	}



	if (sb->s_blocksize - fibh->eoffset >= nfidlen)
@@ -550,14 +550,14 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 


		if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err)))

		{

			udf_release_data(bh);

			udf_release_data(epos.bh);

			udf_release_data(fibh->sbh);

			return NULL;

		}



		if (!(fibh->soffset))

		{

			if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) ==

			if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==

				(EXT_RECORDED_ALLOCATED >> 30))

			{

				block = eloc.logicalBlockNum + ((elen - 1) >>
@@ -587,7 +587,7 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
	cfi->lengthOfImpUse = cpu_to_le16(0);

	if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name))

	{

		udf_release_data(bh);

		udf_release_data(epos.bh);

		dir->i_size += nfidlen;

		if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)

			UDF_I_LENALLOC(dir) += nfidlen;
@@ -596,7 +596,7 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, 
	}

	else

	{

		udf_release_data(bh);

		udf_release_data(epos.bh);

		if (fibh->sbh != fibh->ebh)

			udf_release_data(fibh->ebh);

		udf_release_data(fibh->sbh);
@@ -781,10 +781,10 @@ static int empty_dir(struct inode *dir) 
	loff_t f_pos;

	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;

	int block;

	kernel_lb_addr bloc, eloc;

	uint32_t extoffset, elen;

	kernel_lb_addr eloc;

	uint32_t elen;

	sector_t offset;

	struct buffer_head *bh = NULL;

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



	f_pos = (udf_ext0_offset(dir) >> 2);
@@ -793,42 +793,42 @@ static int empty_dir(struct inode *dir) 
	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)

		fibh.sbh = fibh.ebh = NULL;

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

		&bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))

		&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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

				extoffset -= sizeof(short_ad);

				epos.offset -= sizeof(short_ad);

			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

				extoffset -= sizeof(long_ad);

				epos.offset -= sizeof(long_ad);

		}

		else

			offset = 0;



		if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))

		{

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return 0;

		}

	}

	else

	{

		udf_release_data(bh);

		udf_release_data(epos.bh);

		return 0;

	}





	while ( (f_pos < size) )

	{

		fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);

		fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);



		if (!fi)

		{

			if (fibh.sbh != fibh.ebh)

				udf_release_data(fibh.ebh);

			udf_release_data(fibh.sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return 0;

		}
@@ -837,14 +837,14 @@ static int empty_dir(struct inode *dir) 
			if (fibh.sbh != fibh.ebh)

				udf_release_data(fibh.ebh);

			udf_release_data(fibh.sbh);

			udf_release_data(bh);

			udf_release_data(epos.bh);

			return 0;

		}

	}

	if (fibh.sbh != fibh.ebh)

		udf_release_data(fibh.ebh);

	udf_release_data(fibh.sbh);

	udf_release_data(bh);

	udf_release_data(epos.bh);

	return 1;

}
@@ -941,7 +941,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * 
	struct pathComponent *pc;

	char *compstart;

	struct udf_fileident_bh fibh;

	struct buffer_head *bh = NULL;

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

	int eoffset, elen = 0;

	struct fileIdentDesc *fi;

	struct fileIdentDesc cfi;
@@ -961,33 +961,33 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * 


	if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB)

	{

		struct buffer_head *bh = NULL;

		kernel_lb_addr bloc, eloc;

		uint32_t elen, extoffset;

		kernel_lb_addr eloc;

		uint32_t elen;



		block = udf_new_block(inode->i_sb, inode,

			UDF_I_LOCATION(inode).partitionReferenceNum,

			UDF_I_LOCATION(inode).logicalBlockNum, &err);

		if (!block)

			goto out_no_entry;

		bloc = UDF_I_LOCATION(inode);

		epos.block = UDF_I_LOCATION(inode);

		epos.offset = udf_file_entry_alloc_offset(inode);

		epos.bh = NULL;

		eloc.logicalBlockNum = block;

		eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;

		elen = inode->i_sb->s_blocksize;

		UDF_I_LENEXTENTS(inode) = elen;

		extoffset = udf_file_entry_alloc_offset(inode);

		udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 0);

		udf_release_data(bh);

		udf_add_aext(inode, &epos, eloc, elen, 0);

		udf_release_data(epos.bh);



		block = udf_get_pblock(inode->i_sb, block,

			UDF_I_LOCATION(inode).partitionReferenceNum, 0);

		bh = udf_tread(inode->i_sb, block);

		lock_buffer(bh);

		memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);

		set_buffer_uptodate(bh);

		unlock_buffer(bh);

		mark_buffer_dirty_inode(bh, inode);

		ea = bh->b_data + udf_ext0_offset(inode);

		epos.bh = udf_tread(inode->i_sb, block);

		lock_buffer(epos.bh);

		memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);

		set_buffer_uptodate(epos.bh);

		unlock_buffer(epos.bh);

		mark_buffer_dirty_inode(epos.bh, inode);

		ea = epos.bh->b_data + udf_ext0_offset(inode);

	}

	else

		ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
@@ -1060,7 +1060,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * 
		}

	}



	udf_release_data(bh);

	udf_release_data(epos.bh);

	inode->i_size = elen;

	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)

		UDF_I_LENALLOC(inode) = inode->i_size;