Commit 97e961fd authored by Pekka Enberg's avatar Pekka Enberg Committed by Jan Kara
Browse files

Fix the udf code not to pass structs on stack where possible. 



Signed-off-by: default avatarPekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent 5ca4e4be

fs/udf/balloc.c

+31 −28
Original line number Diff line number Diff line
@@ -92,7 +92,7 @@ static int read_block_bitmap(struct super_block *sb, 
	loc.logicalBlockNum = bitmap->s_extPosition;

	loc.partitionReferenceNum = UDF_SB(sb)->s_partition;



	bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block));

	bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block));

	if (!bh)

		retval = -EIO;
@@ -156,11 +156,13 @@ static bool udf_add_free_space(struct udf_sb_info *sbi, 
static void udf_bitmap_free_blocks(struct super_block *sb,

				   struct inode *inode,

				   struct udf_bitmap *bitmap,

				   struct kernel_lb_addr bloc, uint32_t offset,

				   struct kernel_lb_addr *bloc,

				   uint32_t offset,

				   uint32_t count)

{

	struct udf_sb_info *sbi = UDF_SB(sb);

	struct buffer_head *bh = NULL;

	struct udf_part_map *partmap;

	unsigned long block;

	unsigned long block_group;

	unsigned long bit;
@@ -169,17 +171,17 @@ static void udf_bitmap_free_blocks(struct super_block *sb, 
	unsigned long overflow;



	mutex_lock(&sbi->s_alloc_mutex);

	if (bloc.logicalBlockNum < 0 ||

	    (bloc.logicalBlockNum + count) >

		sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {

	partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];

	if (bloc->logicalBlockNum < 0 ||

	    (bloc->logicalBlockNum + count) >

		partmap->s_partition_len) {

		udf_debug("%d < %d || %d + %d > %d\n",

			  bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,

			  sbi->s_partmaps[bloc.partitionReferenceNum].

							s_partition_len);

			  bloc->logicalBlockNum, 0, bloc->logicalBlockNum,

			  count, partmap->s_partition_len);

		goto error_return;

	}



	block = bloc.logicalBlockNum + offset +

	block = bloc->logicalBlockNum + offset +

		(sizeof(struct spaceBitmapDesc) << 3);



	do {
@@ -425,10 +427,12 @@ static int udf_bitmap_new_block(struct super_block *sb, 
static void udf_table_free_blocks(struct super_block *sb,

				  struct inode *inode,

				  struct inode *table,

				  struct kernel_lb_addr bloc, uint32_t offset,

				  struct kernel_lb_addr *bloc,

				  uint32_t offset,

				  uint32_t count)

{

	struct udf_sb_info *sbi = UDF_SB(sb);

	struct udf_part_map *partmap;

	uint32_t start, end;

	uint32_t elen;

	struct kernel_lb_addr eloc;
@@ -438,13 +442,13 @@ static void udf_table_free_blocks(struct super_block *sb, 
	struct udf_inode_info *iinfo;



	mutex_lock(&sbi->s_alloc_mutex);

	if (bloc.logicalBlockNum < 0 ||

	    (bloc.logicalBlockNum + count) >

		sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {

	partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];

	if (bloc->logicalBlockNum < 0 ||

	    (bloc->logicalBlockNum + count) >

		partmap->s_partition_len) {

		udf_debug("%d < %d || %d + %d > %d\n",

			  bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,

			  sbi->s_partmaps[bloc.partitionReferenceNum].

							s_partition_len);

			  partmap->s_partition_len);

		goto error_return;

	}
@@ -456,8 +460,8 @@ static void udf_table_free_blocks(struct super_block *sb, 
	if (udf_add_free_space(sbi, sbi->s_partition, count))

		mark_buffer_dirty(sbi->s_lvid_bh);



	start = bloc.logicalBlockNum + offset;

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

	start = bloc->logicalBlockNum + offset;

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



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

	elen = 0;
@@ -483,7 +487,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
				start += count;

				count = 0;

			}

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

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

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

			if ((0x3FFFFFFF - elen) <

					(count << sb->s_blocksize_bits)) {
@@ -502,7 +506,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
				end -= count;

				count = 0;

			}

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

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

		}



		if (epos.bh != oepos.bh) {
@@ -563,7 +567,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
			elen -= sb->s_blocksize;



			epos.bh = udf_tread(sb,

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

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

			if (!epos.bh) {

				brelse(oepos.bh);

				goto error_return;
@@ -635,7 +639,7 @@ static void udf_table_free_blocks(struct super_block *sb, 


		/* It's possible that stealing the block emptied the extent */

		if (elen) {

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

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



			if (!epos.bh) {

				iinfo->i_lenAlloc += adsize;
@@ -707,7 +711,7 @@ 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, &epos, eloc,

			udf_write_aext(table, &epos, &eloc,

					(etype << 30) | elen, 1);

		} else

			udf_delete_aext(table, epos, eloc,
@@ -814,7 +818,7 @@ static int udf_table_new_block(struct super_block *sb, 
	}



	if (goal_elen)

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

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

	else

		udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);

	brelse(goal_epos.bh);
@@ -828,12 +832,11 @@ static int udf_table_new_block(struct super_block *sb, 
	return newblock;

}



inline void udf_free_blocks(struct super_block *sb,

			    struct inode *inode,

			    struct kernel_lb_addr bloc, uint32_t offset,

void udf_free_blocks(struct super_block *sb, struct inode *inode,

		     struct kernel_lb_addr *bloc, uint32_t offset,

		     uint32_t count)

{

	uint16_t partition = bloc.partitionReferenceNum;

	uint16_t partition = bloc->partitionReferenceNum;

	struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];



	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {

fs/udf/dir.c

+3 −3
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, 
			ret = -ENOENT;

			goto out;

		}

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

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

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

			if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

				epos.offset -= sizeof(struct short_ad);
@@ -101,7 +101,7 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, 
			if (i + offset > (elen >> dir->i_sb->s_blocksize_bits))

				i = (elen >> dir->i_sb->s_blocksize_bits) - offset;

			for (num = 0; i > 0; i--) {

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

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

				tmp = udf_tgetblk(dir->i_sb, block);

				if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))

					bha[num++] = tmp;
@@ -163,7 +163,7 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, 
		} else {

			struct kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation);



			iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0);

			iblock = udf_get_lb_pblock(dir->i_sb, &tloc, 0);

			flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);

			dt_type = DT_UNKNOWN;

		}

fs/udf/directory.c

+3 −3
Original line number Diff line number Diff line
@@ -111,7 +111,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
		    (EXT_RECORDED_ALLOCATED >> 30))

			return NULL;



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

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



		(*offset)++;
@@ -131,7 +131,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
			if (i + *offset > (*elen >> blocksize_bits))

				i = (*elen >> blocksize_bits)-*offset;

			for (num = 0; i > 0; i--) {

				block = udf_get_lb_pblock(dir->i_sb, *eloc,

				block = udf_get_lb_pblock(dir->i_sb, eloc,

							  *offset + i);

				tmp = udf_tgetblk(dir->i_sb, block);

				if (tmp && !buffer_uptodate(tmp) &&
@@ -169,7 +169,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, 
		    (EXT_RECORDED_ALLOCATED >> 30))

			return NULL;



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

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



		(*offset)++;

fs/udf/ialloc.c

+2 −2
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ void udf_free_inode(struct inode *inode) 
	}

	mutex_unlock(&sbi->s_alloc_mutex);



	udf_free_blocks(sb, NULL, UDF_I(inode)->i_location, 0, 1);

	udf_free_blocks(sb, NULL, &UDF_I(inode)->i_location, 0, 1);

}



struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
@@ -138,7 +138,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	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_ino = udf_get_lb_pblock(sb, &iinfo->i_location, 0);

	inode->i_blocks = 0;

	iinfo->i_lenEAttr = 0;

	iinfo->i_lenAlloc = 0;

fs/udf/inode.c

+35 −35
Original line number Diff line number Diff line
@@ -281,7 +281,7 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block, 
	epos.bh = NULL;

	epos.block = iinfo->i_location;

	epos.offset = udf_file_entry_alloc_offset(inode);

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

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

	/* UniqueID stuff */



	brelse(epos.bh);
@@ -411,11 +411,11 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, 
	}



	if (fake) {

		udf_add_aext(inode, last_pos, last_ext->extLocation,

		udf_add_aext(inode, last_pos, &last_ext->extLocation,

			     last_ext->extLength, 1);

		count++;

	} else

		udf_write_aext(inode, last_pos, last_ext->extLocation,

		udf_write_aext(inode, last_pos, &last_ext->extLocation,

				last_ext->extLength, 1);



	/* Managed to do everything necessary? */
@@ -432,7 +432,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, 
	/* Create enough extents to cover the whole hole */

	while (blocks > add) {

		blocks -= add;

		if (udf_add_aext(inode, last_pos, last_ext->extLocation,

		if (udf_add_aext(inode, last_pos, &last_ext->extLocation,

				 last_ext->extLength, 1) == -1)

			return -1;

		count++;
@@ -440,7 +440,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, 
	if (blocks) {

		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |

			(blocks << sb->s_blocksize_bits);

		if (udf_add_aext(inode, last_pos, last_ext->extLocation,

		if (udf_add_aext(inode, last_pos, &last_ext->extLocation,

				 last_ext->extLength, 1) == -1)

			return -1;

		count++;
@@ -449,7 +449,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, 
out:

	/* Do we have some preallocated blocks saved? */

	if (prealloc_len) {

		if (udf_add_aext(inode, last_pos, prealloc_loc,

		if (udf_add_aext(inode, last_pos, &prealloc_loc,

				 prealloc_len, 1) == -1)

			return -1;

		last_ext->extLocation = prealloc_loc;
@@ -550,12 +550,12 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block, 
			elen = EXT_RECORDED_ALLOCATED |

				((elen + inode->i_sb->s_blocksize - 1) &

				 ~(inode->i_sb->s_blocksize - 1));

			etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);

			etype = udf_write_aext(inode, &cur_epos, &eloc, elen, 1);

		}

		brelse(prev_epos.bh);

		brelse(cur_epos.bh);

		brelse(next_epos.bh);

		newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);

		newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset);

		*phys = newblock;

		return NULL;

	}
@@ -726,7 +726,7 @@ static void udf_split_extents(struct inode *inode, int *c, int offset, 
		if (offset) {

			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {

				udf_free_blocks(inode->i_sb, inode,

						laarr[curr].extLocation,

						&laarr[curr].extLocation,

						0, offset);

				laarr[curr].extLength =

					EXT_NOT_RECORDED_NOT_ALLOCATED |
@@ -911,7 +911,7 @@ static void udf_merge_extents(struct inode *inode, 
				(EXT_NOT_RECORDED_ALLOCATED >> 30)) &&

			   ((lip1->extLength >> 30) ==

				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {

			udf_free_blocks(inode->i_sb, inode, li->extLocation, 0,

			udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,

					((li->extLength &

					  UDF_EXTENT_LENGTH_MASK) +

					 blocksize - 1) >> blocksize_bits);
@@ -945,7 +945,7 @@ static void udf_merge_extents(struct inode *inode, 
		} else if ((li->extLength >> 30) ==

					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {

			udf_free_blocks(inode->i_sb, inode,

					li->extLocation, 0,

					&li->extLocation, 0,

					((li->extLength &

						UDF_EXTENT_LENGTH_MASK) +

					 blocksize - 1) >> blocksize_bits);
@@ -983,7 +983,7 @@ static void udf_update_extents(struct inode *inode, 


	for (i = start; i < endnum; i++) {

		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);

		udf_write_aext(inode, epos, laarr[i].extLocation,

		udf_write_aext(inode, epos, &laarr[i].extLocation,

			       laarr[i].extLength, 1);

	}

}
@@ -1076,7 +1076,7 @@ static void __udf_read_inode(struct inode *inode) 
	 *      i_nlink = 1

	 *      i_op = NULL;

	 */

	bh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 0, &ident);

	bh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 0, &ident);

	if (!bh) {

		printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",

		       inode->i_ino);
@@ -1098,7 +1098,7 @@ static void __udf_read_inode(struct inode *inode) 
	if (fe->icbTag.strategyType == cpu_to_le16(4096)) {

		struct buffer_head *ibh;



		ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,

		ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1,

					&ident);

		if (ident == TAG_IDENT_IE && ibh) {

			struct buffer_head *nbh = NULL;
@@ -1109,7 +1109,7 @@ static void __udf_read_inode(struct inode *inode) 
			loc = lelb_to_cpu(ie->indirectICB.extLocation);



			if (ie->indirectICB.extLength &&

				(nbh = udf_read_ptagged(inode->i_sb, loc, 0,

				(nbh = udf_read_ptagged(inode->i_sb, &loc, 0,

							&ident))) {

				if (ident == TAG_IDENT_FE ||

					ident == TAG_IDENT_EFE) {
@@ -1396,7 +1396,7 @@ static int udf_update_inode(struct inode *inode, int do_sync) 


	bh = udf_tread(inode->i_sb,

			udf_get_lb_pblock(inode->i_sb,

					  iinfo->i_location, 0));

					  &iinfo->i_location, 0));

	if (!bh) {

		udf_debug("bread failure\n");

		return -EIO;
@@ -1606,7 +1606,7 @@ static int udf_update_inode(struct inode *inode, int do_sync) 
	return err;

}



struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr ino)

struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr *ino)

{

	unsigned long block = udf_get_lb_pblock(sb, ino, 0);

	struct inode *inode = iget_locked(sb, block);
@@ -1615,7 +1615,7 @@ struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr ino) 
		return NULL;



	if (inode->i_state & I_NEW) {

		memcpy(&UDF_I(inode)->i_location, &ino, sizeof(struct kernel_lb_addr));

		memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));

		__udf_read_inode(inode);

		unlock_new_inode(inode);

	}
@@ -1623,10 +1623,10 @@ struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr ino) 
	if (is_bad_inode(inode))

		goto out_iput;



	if (ino.logicalBlockNum >= UDF_SB(sb)->

			s_partmaps[ino.partitionReferenceNum].s_partition_len) {

	if (ino->logicalBlockNum >= UDF_SB(sb)->

			s_partmaps[ino->partitionReferenceNum].s_partition_len) {

		udf_debug("block=%d, partition=%d out of range\n",

			  ino.logicalBlockNum, ino.partitionReferenceNum);

			  ino->logicalBlockNum, ino->partitionReferenceNum);

		make_bad_inode(inode);

		goto out_iput;

	}
@@ -1639,7 +1639,7 @@ struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr ino) 
}



int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,

		    struct kernel_lb_addr eloc, uint32_t elen, int inc)

		    struct kernel_lb_addr *eloc, uint32_t elen, int inc)

{

	int adsize;

	struct short_ad *sad = NULL;
@@ -1675,7 +1675,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, 
		if (!epos->block.logicalBlockNum)

			return -1;

		nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,

								 epos->block,

								 &epos->block,

								 0));

		if (!nbh)

			return -1;
@@ -1769,7 +1769,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, 
}



int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,

		      struct kernel_lb_addr eloc, uint32_t elen, int inc)

		      struct kernel_lb_addr *eloc, uint32_t elen, int inc)

{

	int adsize;

	uint8_t *ptr;
@@ -1788,13 +1788,13 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, 
	case ICBTAG_FLAG_AD_SHORT:

		sad = (struct short_ad *)ptr;

		sad->extLength = cpu_to_le32(elen);

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

		sad->extPosition = cpu_to_le32(eloc->logicalBlockNum);

		adsize = sizeof(struct short_ad);

		break;

	case ICBTAG_FLAG_AD_LONG:

		lad = (struct long_ad *)ptr;

		lad->extLength = cpu_to_le32(elen);

		lad->extLocation = cpu_to_lelb(eloc);

		lad->extLocation = cpu_to_lelb(*eloc);

		memset(lad->impUse, 0x00, sizeof(lad->impUse));

		adsize = sizeof(struct long_ad);

		break;
@@ -1833,7 +1833,7 @@ int8_t udf_next_aext(struct inode *inode, struct extent_position *epos, 
		epos->block = *eloc;

		epos->offset = sizeof(struct allocExtDesc);

		brelse(epos->bh);

		block = udf_get_lb_pblock(inode->i_sb, epos->block, 0);

		block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);

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

		if (!epos->bh) {

			udf_debug("reading block %d failed!\n", block);
@@ -1910,11 +1910,11 @@ static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos, 
		get_bh(epos.bh);



	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {

		udf_write_aext(inode, &epos, neloc, nelen, 1);

		udf_write_aext(inode, &epos, &neloc, nelen, 1);

		neloc = oeloc;

		nelen = (etype << 30) | oelen;

	}

	udf_add_aext(inode, &epos, neloc, nelen, 1);

	udf_add_aext(inode, &epos, &neloc, nelen, 1);

	brelse(epos.bh);



	return (nelen >> 30);
@@ -1947,7 +1947,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, 
		return -1;



	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {

		udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);

		udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);

		if (oepos.bh != epos.bh) {

			oepos.block = epos.block;

			brelse(oepos.bh);
@@ -1960,9 +1960,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, 
	elen = 0;



	if (epos.bh != oepos.bh) {

		udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);

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

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

		udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1);

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

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

		if (!oepos.bh) {

			iinfo->i_lenAlloc -= (adsize * 2);

			mark_inode_dirty(inode);
@@ -1979,7 +1979,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, 
			mark_buffer_dirty_inode(oepos.bh, inode);

		}

	} else {

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

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

		if (!oepos.bh) {

			iinfo->i_lenAlloc -= adsize;

			mark_inode_dirty(inode);
@@ -2046,7 +2046,7 @@ long udf_block_map(struct inode *inode, sector_t block) 


	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==

						(EXT_RECORDED_ALLOCATED >> 30))

		ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);

		ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);

	else

		ret = 0;