xfs: replace xfs_mod_incore_sb_batched (0bd5dded) · Commits · 戴 / test

fs/xfs/xfs_mount.c

+0 −51

Original line number	Original line	Diff line number	Diff line
	@@ -1352,57 +1352,6 @@ xfs_mod_incore_sb(
	return status;		return status;
	}		}

	/*
	* Change more than one field in the in-core superblock structure at a time.
	*
	* The fields and changes to those fields are specified in the array of
	* xfs_mod_sb structures passed in. Either all of the specified deltas
	* will be applied or none of them will. If any modified field dips below 0,
	* then all modifications will be backed out and EINVAL will be returned.
	*
	* Note that this function may not be used for the superblock values that
	* are tracked with the in-memory per-cpu counters - a direct call to
	* xfs_mod_incore_sb is required for these.
	*/
	int
	xfs_mod_incore_sb_batch(
	struct xfs_mount *mp,
	xfs_mod_sb_t *msb,
	uint nmsb,
	int rsvd)
	{
	xfs_mod_sb_t *msbp;
	int error = 0;

	/*
	* Loop through the array of mod structures and apply each individually.
	* If any fail, then back out all those which have already been applied.
	* Do all of this within the scope of the m_sb_lock so that all of the
	* changes will be atomic.
	*/
	spin_lock(&mp->m_sb_lock);
	for (msbp = msb; msbp < (msb + nmsb); msbp++) {
	ASSERT(msbp->msb_field < XFS_SBS_ICOUNT \|\|
	msbp->msb_field > XFS_SBS_FDBLOCKS);

	error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field,
	msbp->msb_delta, rsvd);
	if (error)
	goto unwind;
	}
	spin_unlock(&mp->m_sb_lock);
	return 0;

	unwind:
	while (--msbp >= msb) {
	error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field,
	-msbp->msb_delta, rsvd);
	ASSERT(error == 0);
	}
	spin_unlock(&mp->m_sb_lock);
	return error;
	}

	/*		/*
	* xfs_getsb() is called to obtain the buffer for the superblock.		* xfs_getsb() is called to obtain the buffer for the superblock.
	* The buffer is returned locked and read in from disk.		* The buffer is returned locked and read in from disk.

fs/xfs/xfs_mount.h

+0 −11

Original line number	Original line	Diff line number	Diff line
	@@ -259,15 +259,6 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)
	return (xfs_agblock_t) do_div(ld, mp->m_sb.sb_agblocks);		return (xfs_agblock_t) do_div(ld, mp->m_sb.sb_agblocks);
	}		}

	/*
	* This structure is for use by the xfs_mod_incore_sb_batch() routine.
	* xfs_growfs can specify a few fields which are more than int limit
	*/
	typedef struct xfs_mod_sb {
	xfs_sb_field_t msb_field; /* Field to modify, see below */
	int64_t msb_delta; /* Change to make to specified field */
	} xfs_mod_sb_t;

	/*		/*
	* Per-ag incore structure, copies of information in agf and agi, to improve the		* Per-ag incore structure, copies of information in agf and agi, to improve the
	* performance of allocation group selection.		* performance of allocation group selection.
	@@ -325,8 +316,6 @@ extern int xfs_initialize_perag(xfs_mount_t *mp, xfs_agnumber_t agcount,

	extern void xfs_unmountfs(xfs_mount_t *);		extern void xfs_unmountfs(xfs_mount_t *);
	extern int xfs_mod_incore_sb(xfs_mount_t *, xfs_sb_field_t, int64_t, int);		extern int xfs_mod_incore_sb(xfs_mount_t *, xfs_sb_field_t, int64_t, int);
	extern int xfs_mod_incore_sb_batch(xfs_mount_t , xfs_mod_sb_t ,
	uint, int);
	extern int xfs_mod_icount(struct xfs_mount *mp, int64_t delta);		extern int xfs_mod_icount(struct xfs_mount *mp, int64_t delta);
	extern int xfs_mod_ifree(struct xfs_mount *mp, int64_t delta);		extern int xfs_mod_ifree(struct xfs_mount *mp, int64_t delta);
	extern int xfs_mod_fdblocks(struct xfs_mount *mp, int64_t delta,		extern int xfs_mod_fdblocks(struct xfs_mount *mp, int64_t delta,

fs/xfs/xfs_trans.c

+126 −72

Original line number	Original line	Diff line number	Diff line
	@@ -485,6 +485,54 @@ xfs_trans_apply_sb_deltas(
	sizeof(sbp->sb_frextents) - 1);		sizeof(sbp->sb_frextents) - 1);
	}		}

			STATIC int
			xfs_sb_mod8(
			uint8_t *field,
			int8_t delta)
			{
			int8_t counter = *field;

			counter += delta;
			if (counter < 0) {
			ASSERT(0);
			return -EINVAL;
			}
			*field = counter;
			return 0;
			}

			STATIC int
			xfs_sb_mod32(
			uint32_t *field,
			int32_t delta)
			{
			int32_t counter = *field;

			counter += delta;
			if (counter < 0) {
			ASSERT(0);
			return -EINVAL;
			}
			*field = counter;
			return 0;
			}

			STATIC int
			xfs_sb_mod64(
			uint64_t *field,
			int64_t delta)
			{
			int64_t counter = *field;

			counter += delta;
			if (counter < 0) {
			ASSERT(0);
			return -EINVAL;
			}
			*field = counter;
			return 0;
			}

	/*		/*
	* xfs_trans_unreserve_and_mod_sb() is called to release unused reservations		* xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
	* and apply superblock counter changes to the in-core superblock. The		* and apply superblock counter changes to the in-core superblock. The
	@@ -492,13 +540,6 @@ xfs_trans_apply_sb_deltas(
	* applied to the in-core superblock. The idea is that that has already been		* applied to the in-core superblock. The idea is that that has already been
	* done.		* done.
	*		*
	* This is done efficiently with a single call to xfs_mod_incore_sb_batch().
	* However, we have to ensure that we only modify each superblock field only
	* once because the application of the delta values may not be atomic. That can
	* lead to ENOSPC races occurring if we have two separate modifcations of the
	* free space counter to put back the entire reservation and then take away
	* what we used.
	*
	* If we are not logging superblock counters, then the inode allocated/free and		* If we are not logging superblock counters, then the inode allocated/free and
	* used block counts are not updated in the on disk superblock. In this case,		* used block counts are not updated in the on disk superblock. In this case,
	* XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we		* XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
	@@ -506,20 +547,15 @@ xfs_trans_apply_sb_deltas(
	*/		*/
	void		void
	xfs_trans_unreserve_and_mod_sb(		xfs_trans_unreserve_and_mod_sb(
	xfs_trans_t *tp)		struct xfs_trans *tp)
	{		{
	xfs_mod_sb_t msb[9]; /* If you add cases, add entries */		struct xfs_mount *mp = tp->t_mountp;
	xfs_mod_sb_t *msbp;
	xfs_mount_t *mp = tp->t_mountp;
	/* REFERENCED */
	int error;
	bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;		bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
	int64_t blkdelta = 0;		int64_t blkdelta = 0;
	int64_t rtxdelta = 0;		int64_t rtxdelta = 0;
	int64_t idelta = 0;		int64_t idelta = 0;
	int64_t ifreedelta = 0;		int64_t ifreedelta = 0;
			int error;
	msbp = msb;

	/* calculate deltas */		/* calculate deltas */
	if (tp->t_blk_res > 0)		if (tp->t_blk_res > 0)
	@@ -560,72 +596,90 @@ xfs_trans_unreserve_and_mod_sb(
	goto out_undo_icount;		goto out_undo_icount;
	}		}

			if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
			return;

	/* apply remaining deltas */		/* apply remaining deltas */
			spin_lock(&mp->m_sb_lock);
	if (rtxdelta) {		if (rtxdelta) {
	error = xfs_mod_frextents(mp, rtxdelta);		error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
	if (error)		if (error)
	goto out_undo_ifree;		goto out_undo_ifree;
	}		}

	if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
	if (tp->t_dblocks_delta != 0) {		if (tp->t_dblocks_delta != 0) {
	msbp->msb_field = XFS_SBS_DBLOCKS;		error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
	msbp->msb_delta = tp->t_dblocks_delta;		if (error)
	msbp++;		goto out_undo_frextents;
	}		}
	if (tp->t_agcount_delta != 0) {		if (tp->t_agcount_delta != 0) {
	msbp->msb_field = XFS_SBS_AGCOUNT;		error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta);
	msbp->msb_delta = tp->t_agcount_delta;		if (error)
	msbp++;		goto out_undo_dblocks;
	}		}
	if (tp->t_imaxpct_delta != 0) {		if (tp->t_imaxpct_delta != 0) {
	msbp->msb_field = XFS_SBS_IMAX_PCT;		error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta);
	msbp->msb_delta = tp->t_imaxpct_delta;		if (error)
	msbp++;		goto out_undo_agcount;
	}		}
	if (tp->t_rextsize_delta != 0) {		if (tp->t_rextsize_delta != 0) {
	msbp->msb_field = XFS_SBS_REXTSIZE;		error = xfs_sb_mod32(&mp->m_sb.sb_rextsize,
	msbp->msb_delta = tp->t_rextsize_delta;		tp->t_rextsize_delta);
	msbp++;		if (error)
			goto out_undo_imaxpct;
	}		}
	if (tp->t_rbmblocks_delta != 0) {		if (tp->t_rbmblocks_delta != 0) {
	msbp->msb_field = XFS_SBS_RBMBLOCKS;		error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks,
	msbp->msb_delta = tp->t_rbmblocks_delta;		tp->t_rbmblocks_delta);
	msbp++;		if (error)
			goto out_undo_rextsize;
	}		}
	if (tp->t_rblocks_delta != 0) {		if (tp->t_rblocks_delta != 0) {
	msbp->msb_field = XFS_SBS_RBLOCKS;		error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta);
	msbp->msb_delta = tp->t_rblocks_delta;		if (error)
	msbp++;		goto out_undo_rbmblocks;
	}		}
	if (tp->t_rextents_delta != 0) {		if (tp->t_rextents_delta != 0) {
	msbp->msb_field = XFS_SBS_REXTENTS;		error = xfs_sb_mod64(&mp->m_sb.sb_rextents,
	msbp->msb_delta = tp->t_rextents_delta;		tp->t_rextents_delta);
	msbp++;		if (error)
			goto out_undo_rblocks;
	}		}
	if (tp->t_rextslog_delta != 0) {		if (tp->t_rextslog_delta != 0) {
	msbp->msb_field = XFS_SBS_REXTSLOG;		error = xfs_sb_mod8(&mp->m_sb.sb_rextslog,
	msbp->msb_delta = tp->t_rextslog_delta;		tp->t_rextslog_delta);
	msbp++;
	}
	}

	/*
	* If we need to change anything, do it.
	*/
	if (msbp > msb) {
	error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
	(uint)(msbp - msb), rsvd);
	if (error)		if (error)
	goto out_undo_frextents;		goto out_undo_rextents;
	}		}
			spin_unlock(&mp->m_sb_lock);
	return;		return;

			out_undo_rextents:
			if (tp->t_rextents_delta)
			xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta);
			out_undo_rblocks:
			if (tp->t_rblocks_delta)
			xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta);
			out_undo_rbmblocks:
			if (tp->t_rbmblocks_delta)
			xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta);
			out_undo_rextsize:
			if (tp->t_rextsize_delta)
			xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta);
			out_undo_imaxpct:
			if (tp->t_rextsize_delta)
			xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta);
			out_undo_agcount:
			if (tp->t_agcount_delta)
			xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta);
			out_undo_dblocks:
			if (tp->t_dblocks_delta)
			xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta);
	out_undo_frextents:		out_undo_frextents:
	if (rtxdelta)		if (rtxdelta)
	xfs_mod_frextents(mp, -rtxdelta);		xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
	out_undo_ifree:		out_undo_ifree:
			spin_unlock(&mp->m_sb_lock);
	if (ifreedelta)		if (ifreedelta)
	xfs_mod_ifree(mp, -ifreedelta);		xfs_mod_ifree(mp, -ifreedelta);
	out_undo_icount:		out_undo_icount:

Admin message