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

Commit 22b4eb5e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs 

* 'for-linus' of git://oss.sgi.com/xfs/xfs:
  xfs: cleanup xfs_file_aio_write
  xfs: always return with the iolock held from xfs_file_aio_write_checks
  xfs: remove the i_new_size field in struct xfs_inode
  xfs: remove the i_size field in struct xfs_inode
  xfs: replace i_pin_wait with a bit waitqueue
  xfs: replace i_flock with a sleeping bitlock
  xfs: make i_flags an unsigned long
  xfs: remove the if_ext_max field in struct xfs_ifork
  xfs: remove the unused dm_attrs structure
  xfs: cleanup xfs_iomap_eof_align_last_fsb
  xfs: remove xfs_itruncate_data
parents d65773b2 d0606464

fs/xfs/xfs_aops.c

+16 −13
Original line number Diff line number Diff line
@@ -111,8 +111,7 @@ xfs_ioend_new_eof( 
	xfs_fsize_t		bsize;



	bsize = ioend->io_offset + ioend->io_size;

	isize = MAX(ip->i_size, ip->i_new_size);

	isize = MIN(isize, bsize);

	isize = MIN(i_size_read(VFS_I(ip)), bsize);

	return isize > ip->i_d.di_size ? isize : 0;

}
@@ -126,11 +125,7 @@ static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend) 
}



/*

 * Update on-disk file size now that data has been written to disk.  The

 * current in-memory file size is i_size.  If a write is beyond eof i_new_size

 * will be the intended file size until i_size is updated.  If this write does

 * not extend all the way to the valid file size then restrict this update to

 * the end of the write.

 * Update on-disk file size now that data has been written to disk.

 *

 * This function does not block as blocking on the inode lock in IO completion

 * can lead to IO completion order dependency deadlocks.. If it can't get the
@@ -1278,6 +1273,15 @@ xfs_end_io_direct_write( 
{

	struct xfs_ioend	*ioend = iocb->private;



	/*

	 * While the generic direct I/O code updates the inode size, it does

	 * so only after the end_io handler is called, which means our

	 * end_io handler thinks the on-disk size is outside the in-core

	 * size.  To prevent this just update it a little bit earlier here.

	 */

	if (offset + size > i_size_read(ioend->io_inode))

		i_size_write(ioend->io_inode, offset + size);



	/*

	 * blockdev_direct_IO can return an error even after the I/O

	 * completion handler was called.  Thus we need to protect
@@ -1340,12 +1344,11 @@ xfs_vm_write_failed( 


	if (to > inode->i_size) {

		/*

		 * punch out the delalloc blocks we have already allocated. We

		 * don't call xfs_setattr() to do this as we may be in the

		 * middle of a multi-iovec write and so the vfs inode->i_size

		 * will not match the xfs ip->i_size and so it will zero too

		 * much. Hence we jus truncate the page cache to zero what is

		 * necessary and punch the delalloc blocks directly.

		 * Punch out the delalloc blocks we have already allocated.

		 *

		 * Don't bother with xfs_setattr given that nothing can have

		 * made it to disk yet as the page is still locked at this

		 * point.

		 */

		struct xfs_inode	*ip = XFS_I(inode);

		xfs_fileoff_t		start_fsb;

fs/xfs/xfs_attr.c

+0 −4
Original line number Diff line number Diff line
@@ -827,10 +827,6 @@ xfs_attr_inactive(xfs_inode_t *dp) 
	if (error)

		goto out;



	/*

	 * Commit the last in the sequence of transactions.

	 */

	xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);

	error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);

	xfs_iunlock(dp, XFS_ILOCK_EXCL);

fs/xfs/xfs_attr_leaf.c

+0 −9
Original line number Diff line number Diff line
@@ -271,10 +271,6 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff) 
	dp = args->dp;

	mp = dp->i_mount;

	dp->i_d.di_forkoff = forkoff;

	dp->i_df.if_ext_max =

		XFS_IFORK_DSIZE(dp) / (uint)sizeof(xfs_bmbt_rec_t);

	dp->i_afp->if_ext_max =

		XFS_IFORK_ASIZE(dp) / (uint)sizeof(xfs_bmbt_rec_t);



	ifp = dp->i_afp;

	ASSERT(ifp->if_flags & XFS_IFINLINE);
@@ -326,7 +322,6 @@ xfs_attr_fork_reset( 
	ASSERT(ip->i_d.di_anextents == 0);

	ASSERT(ip->i_afp == NULL);



	ip->i_df.if_ext_max = XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t);

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

}
@@ -389,10 +384,6 @@ xfs_attr_shortform_remove(xfs_da_args_t *args) 
				(args->op_flags & XFS_DA_OP_ADDNAME) ||

				!(mp->m_flags & XFS_MOUNT_ATTR2) ||

				dp->i_d.di_format == XFS_DINODE_FMT_BTREE);

		dp->i_afp->if_ext_max =

			XFS_IFORK_ASIZE(dp) / (uint)sizeof(xfs_bmbt_rec_t);

		dp->i_df.if_ext_max =

			XFS_IFORK_DSIZE(dp) / (uint)sizeof(xfs_bmbt_rec_t);

		xfs_trans_log_inode(args->trans, dp,

					XFS_ILOG_CORE | XFS_ILOG_ADATA);

	}

fs/xfs/xfs_bmap.c

+53 −63
Original line number Diff line number Diff line
@@ -248,6 +248,26 @@ xfs_bmbt_lookup_ge( 
	return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);

}



/*

 * Check if the inode needs to be converted to btree format.

 */

static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)

{

	return XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&

		XFS_IFORK_NEXTENTS(ip, whichfork) >

			XFS_IFORK_MAXEXT(ip, whichfork);

}



/*

 * Check if the inode should be converted to extent format.

 */

static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)

{

	return XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&

		XFS_IFORK_NEXTENTS(ip, whichfork) <=

			XFS_IFORK_MAXEXT(ip, whichfork);

}



/*

 * Update the record referred to by cur to the value given

 * by [off, bno, len, state].
@@ -683,8 +703,8 @@ xfs_bmap_add_extent_delay_real( 
				goto done;

			XFS_WANT_CORRUPTED_GOTO(i == 1, done);

		}

		if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&

		    bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {



		if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) {

			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,

					bma->firstblock, bma->flist,

					&bma->cur, 1, &tmp_rval, XFS_DATA_FORK);
@@ -767,8 +787,8 @@ xfs_bmap_add_extent_delay_real( 
				goto done;

			XFS_WANT_CORRUPTED_GOTO(i == 1, done);

		}

		if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&

		    bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {



		if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) {

			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,

				bma->firstblock, bma->flist, &bma->cur, 1,

				&tmp_rval, XFS_DATA_FORK);
@@ -836,8 +856,8 @@ xfs_bmap_add_extent_delay_real( 
				goto done;

			XFS_WANT_CORRUPTED_GOTO(i == 1, done);

		}

		if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&

		    bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {



		if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) {

			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,

					bma->firstblock, bma->flist, &bma->cur,

					1, &tmp_rval, XFS_DATA_FORK);
@@ -884,8 +904,7 @@ xfs_bmap_add_extent_delay_real( 
	}



	/* convert to a btree if necessary */

	if (XFS_IFORK_FORMAT(bma->ip, XFS_DATA_FORK) == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(bma->ip, XFS_DATA_FORK) > ifp->if_ext_max) {

	if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) {

		int	tmp_logflags;	/* partial log flag return val */



		ASSERT(bma->cur == NULL);
@@ -1421,8 +1440,7 @@ xfs_bmap_add_extent_unwritten_real( 
	}



	/* convert to a btree if necessary */

	if (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > ifp->if_ext_max) {

	if (xfs_bmap_needs_btree(ip, XFS_DATA_FORK)) {

		int	tmp_logflags;	/* partial log flag return val */



		ASSERT(cur == NULL);
@@ -1812,8 +1830,7 @@ xfs_bmap_add_extent_hole_real( 
	}



	/* convert to a btree if necessary */

	if (XFS_IFORK_FORMAT(bma->ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(bma->ip, whichfork) > ifp->if_ext_max) {

	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {

		int	tmp_logflags;	/* partial log flag return val */



		ASSERT(bma->cur == NULL);
@@ -3037,8 +3054,7 @@ xfs_bmap_extents_to_btree( 


	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS);

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	/*

	 * Make space in the inode incore.

	 */
@@ -3184,13 +3200,8 @@ xfs_bmap_forkoff_reset( 
	    ip->i_d.di_format != XFS_DINODE_FMT_BTREE) {

		uint	dfl_forkoff = xfs_default_attroffset(ip) >> 3;



		if (dfl_forkoff > ip->i_d.di_forkoff) {

		if (dfl_forkoff > ip->i_d.di_forkoff)

			ip->i_d.di_forkoff = dfl_forkoff;

			ip->i_df.if_ext_max =

				XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t);

			ip->i_afp->if_ext_max =

				XFS_IFORK_ASIZE(ip) / sizeof(xfs_bmbt_rec_t);

		}

	}

}
@@ -3430,8 +3441,6 @@ xfs_bmap_add_attrfork( 
	int			error;		/* error return value */



	ASSERT(XFS_IFORK_Q(ip) == 0);

	ASSERT(ip->i_df.if_ext_max ==

	       XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t));



	mp = ip->i_mount;

	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
@@ -3486,12 +3495,9 @@ xfs_bmap_add_attrfork( 
		error = XFS_ERROR(EINVAL);

		goto error1;

	}

	ip->i_df.if_ext_max =

		XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);



	ASSERT(ip->i_afp == NULL);

	ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);

	ip->i_afp->if_ext_max =

		XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);

	ip->i_afp->if_flags = XFS_IFEXTENTS;

	logflags = 0;

	xfs_bmap_init(&flist, &firstblock);
@@ -3535,20 +3541,17 @@ xfs_bmap_add_attrfork( 
		} else

			spin_unlock(&mp->m_sb_lock);

	}

	if ((error = xfs_bmap_finish(&tp, &flist, &committed)))



	error = xfs_bmap_finish(&tp, &flist, &committed);

	if (error)

		goto error2;

	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);

	ASSERT(ip->i_df.if_ext_max ==

	       XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t));

	return error;

	return xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);

error2:

	xfs_bmap_cancel(&flist);

error1:

	xfs_iunlock(ip, XFS_ILOCK_EXCL);

error0:

	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);

	ASSERT(ip->i_df.if_ext_max ==

	       XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t));

	return error;

}
@@ -3994,11 +3997,8 @@ xfs_bmap_one_block( 
	xfs_bmbt_irec_t	s;		/* internal version of extent */



#ifndef DEBUG

	if (whichfork == XFS_DATA_FORK) {

		return S_ISREG(ip->i_d.di_mode) ?

			(ip->i_size == ip->i_mount->m_sb.sb_blocksize) :

			(ip->i_d.di_size == ip->i_mount->m_sb.sb_blocksize);

	}

	if (whichfork == XFS_DATA_FORK)

		return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize;

#endif	/* !DEBUG */

	if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1)

		return 0;
@@ -4010,7 +4010,7 @@ xfs_bmap_one_block( 
	xfs_bmbt_get_all(ep, &s);

	rval = s.br_startoff == 0 && s.br_blockcount == 1;

	if (rval && whichfork == XFS_DATA_FORK)

		ASSERT(ip->i_size == ip->i_mount->m_sb.sb_blocksize);

		ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize);

	return rval;

}
@@ -4379,8 +4379,6 @@ xfs_bmapi_read( 
	XFS_STATS_INC(xs_blk_mapr);



	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	if (!(ifp->if_flags & XFS_IFEXTENTS)) {

		error = xfs_iread_extents(NULL, ip, whichfork);
@@ -4871,8 +4869,6 @@ xfs_bmapi_write( 
		return XFS_ERROR(EIO);



	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	XFS_STATS_INC(xs_blk_mapw);
@@ -4981,8 +4977,7 @@ xfs_bmapi_write( 
	/*

	 * Transform from btree to extents, give it cur.

	 */

	if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&

	    XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max) {

	if (xfs_bmap_wants_extents(ip, whichfork)) {

		int		tmp_logflags = 0;



		ASSERT(bma.cur);
@@ -4992,10 +4987,10 @@ xfs_bmapi_write( 
		if (error)

			goto error0;

	}

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE ||

	       XFS_IFORK_NEXTENTS(ip, whichfork) > ifp->if_ext_max);

	       XFS_IFORK_NEXTENTS(ip, whichfork) >

		XFS_IFORK_MAXEXT(ip, whichfork));

	error = 0;

error0:

	/*
@@ -5095,8 +5090,7 @@ xfs_bunmapi( 


	ASSERT(len > 0);

	ASSERT(nexts >= 0);

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	if (!(ifp->if_flags & XFS_IFEXTENTS) &&

	    (error = xfs_iread_extents(tp, ip, whichfork)))

		return error;
@@ -5322,7 +5316,8 @@ xfs_bunmapi( 
		 */

		if (!wasdel && xfs_trans_get_block_res(tp) == 0 &&

		    XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&

		    XFS_IFORK_NEXTENTS(ip, whichfork) >= ifp->if_ext_max &&

		    XFS_IFORK_NEXTENTS(ip, whichfork) >= /* Note the >= */

			XFS_IFORK_MAXEXT(ip, whichfork) &&

		    del.br_startoff > got.br_startoff &&

		    del.br_startoff + del.br_blockcount <

		    got.br_startoff + got.br_blockcount) {
@@ -5353,13 +5348,11 @@ xfs_bunmapi( 
		}

	}

	*done = bno == (xfs_fileoff_t)-1 || bno < start || lastx < 0;

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));



	/*

	 * Convert to a btree if necessary.

	 */

	if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(ip, whichfork) > ifp->if_ext_max) {

	if (xfs_bmap_needs_btree(ip, whichfork)) {

		ASSERT(cur == NULL);

		error = xfs_bmap_extents_to_btree(tp, ip, firstblock, flist,

			&cur, 0, &tmp_logflags, whichfork);
@@ -5370,8 +5363,7 @@ xfs_bunmapi( 
	/*

	 * transform from btree to extents, give it cur

	 */

	else if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&

		 XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max) {

	else if (xfs_bmap_wants_extents(ip, whichfork)) {

		ASSERT(cur != NULL);

		error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags,

			whichfork);
@@ -5382,8 +5374,6 @@ xfs_bunmapi( 
	/*

	 * transform from extents to local?

	 */

	ASSERT(ifp->if_ext_max ==

	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));

	error = 0;

error0:

	/*
@@ -5434,7 +5424,7 @@ xfs_getbmapx_fix_eof_hole( 
	if (startblock == HOLESTARTBLOCK) {

		mp = ip->i_mount;

		out->bmv_block = -1;

		fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, ip->i_size));

		fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));

		fixlen -= out->bmv_offset;

		if (prealloced && out->bmv_offset + out->bmv_length == end) {

			/* Came to hole at EOF. Trim it. */
@@ -5522,7 +5512,7 @@ xfs_getbmap( 
			fixlen = XFS_MAXIOFFSET(mp);

		} else {

			prealloced = 0;

			fixlen = ip->i_size;

			fixlen = XFS_ISIZE(ip);

		}

	}
@@ -5551,7 +5541,7 @@ xfs_getbmap( 


	xfs_ilock(ip, XFS_IOLOCK_SHARED);

	if (whichfork == XFS_DATA_FORK && !(iflags & BMV_IF_DELALLOC)) {

		if (ip->i_delayed_blks || ip->i_size > ip->i_d.di_size) {

		if (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size) {

			error = xfs_flush_pages(ip, 0, -1, 0, FI_REMAPF);

			if (error)

				goto out_unlock_iolock;

fs/xfs/xfs_dfrag.c

+21 −22
Original line number Diff line number Diff line
@@ -163,12 +163,14 @@ xfs_swap_extents_check_format( 


	/* Check temp in extent form to max in target */

	if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) > ip->i_df.if_ext_max)

	    XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >

			XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))

		return EINVAL;



	/* Check target in extent form to max in temp */

	if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&

	    XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > tip->i_df.if_ext_max)

	    XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >

			XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))

		return EINVAL;



	/*
@@ -180,18 +182,25 @@ xfs_swap_extents_check_format( 
	 * (a common defrag case) which will occur when the temp inode is in

	 * extent format...

	 */

	if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE &&

	    ((XFS_IFORK_BOFF(ip) &&

	      tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip)) ||

	     XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <= ip->i_df.if_ext_max))

	if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {

		if (XFS_IFORK_BOFF(ip) &&

		    tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip))

			return EINVAL;

		if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=

		    XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))

			return EINVAL;

	}



	/* Reciprocal target->temp btree format checks */

	if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&

	    ((XFS_IFORK_BOFF(tip) &&

	      ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip)) ||

	     XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <= tip->i_df.if_ext_max))

	if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {

		if (XFS_IFORK_BOFF(tip) &&

		    ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip))

			return EINVAL;



		if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=

		    XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))

			return EINVAL;

	}



	return 0;

}
@@ -348,16 +357,6 @@ xfs_swap_extents( 
	*ifp = *tifp;		/* struct copy */

	*tifp = *tempifp;	/* struct copy */



	/*

	 * Fix the in-memory data fork values that are dependent on the fork

	 * offset in the inode. We can't assume they remain the same as attr2

	 * has dynamic fork offsets.

	 */

	ifp->if_ext_max = XFS_IFORK_SIZE(ip, XFS_DATA_FORK) /

					(uint)sizeof(xfs_bmbt_rec_t);

	tifp->if_ext_max = XFS_IFORK_SIZE(tip, XFS_DATA_FORK) /

					(uint)sizeof(xfs_bmbt_rec_t);



	/*

	 * Fix the on-disk inode values

	 */