Commit 1ae093cb authored by Brian Foster's avatar Brian Foster Committed by Darrick J. Wong
Browse files

xfs: replace xfs_defer_ops ->dop_pending with on-stack list 



The xfs_defer_ops ->dop_pending list is used to track active
deferred operations once intents are logged. These items must be
aborted in the event of an error. The list is populated as intents
are logged and items are removed as they complete (or are aborted).

Now that xfs_defer_finish() cancels on error, there is no need to
ever access ->dop_pending outside of xfs_defer_finish(). The list is
only ever populated after xfs_defer_finish() begins and is either
completed or cancelled before it returns.

Remove ->dop_pending from xfs_defer_ops and replace it with a local
list in the xfs_defer_finish() path. Pass the local list to the
various helpers now that it is not accessible via dfops. Note that
we have to check for NULL in the abort case as the final tx roll
occurs outside of the scope of the new local list (once the dfops
has completed and thus drained the list).

Signed-off-by: default avatarBrian Foster <bfoster@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent 9b1f4e98

fs/xfs/libxfs/xfs_defer.c

+68 −78
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ static const struct xfs_defer_op_type *defer_op_types[XFS_DEFER_OPS_TYPE_MAX]; 
 * the pending list.

 */

STATIC void

xfs_defer_intake_work(

xfs_defer_create_intents(

	struct xfs_trans		*tp)

{

	struct xfs_defer_ops		*dop = tp->t_dfops;
@@ -190,21 +190,19 @@ xfs_defer_intake_work( 
	list_for_each_entry(dfp, &dop->dop_intake, dfp_list) {

		dfp->dfp_intent = dfp->dfp_type->create_intent(tp,

				dfp->dfp_count);

		trace_xfs_defer_intake_work(tp->t_mountp, dfp);

		trace_xfs_defer_create_intent(tp->t_mountp, dfp);

		list_sort(tp->t_mountp, &dfp->dfp_work,

				dfp->dfp_type->diff_items);

		list_for_each(li, &dfp->dfp_work)

			dfp->dfp_type->log_item(tp, dfp->dfp_intent, li);

	}



	list_splice_tail_init(&dop->dop_intake, &dop->dop_pending);

}



/* Abort all the intents that were committed. */

STATIC void

xfs_defer_trans_abort(

	struct xfs_trans		*tp,

	int				error)

	struct list_head		*dop_pending)

{

	struct xfs_defer_ops		*dop = tp->t_dfops;

	struct xfs_defer_pending	*dfp;
@@ -212,24 +210,21 @@ xfs_defer_trans_abort( 
	trace_xfs_defer_trans_abort(tp->t_mountp, dop, _RET_IP_);



	/* Abort intent items that don't have a done item. */

	list_for_each_entry(dfp, &dop->dop_pending, dfp_list) {

	list_for_each_entry(dfp, dop_pending, dfp_list) {

		trace_xfs_defer_pending_abort(tp->t_mountp, dfp);

		if (dfp->dfp_intent && !dfp->dfp_done) {

			dfp->dfp_type->abort_intent(dfp->dfp_intent);

			dfp->dfp_intent = NULL;

		}

	}



	/* Shut down FS. */

	xfs_force_shutdown(tp->t_mountp, (error == -EFSCORRUPTED) ?

			SHUTDOWN_CORRUPT_INCORE : SHUTDOWN_META_IO_ERROR);

}



/* Roll a transaction so we can do some deferred op processing. */

STATIC int

xfs_defer_trans_roll(

	struct xfs_trans		**tp)

	struct xfs_trans		**tpp)

{

	struct xfs_trans		*tp = *tpp;

	struct xfs_buf_log_item		*bli;

	struct xfs_inode_log_item	*ili;

	struct xfs_log_item		*lip;
@@ -239,7 +234,7 @@ xfs_defer_trans_roll( 
	int				i;

	int				error;



	list_for_each_entry(lip, &(*tp)->t_items, li_trans) {

	list_for_each_entry(lip, &tp->t_items, li_trans) {

		switch (lip->li_type) {

		case XFS_LI_BUF:

			bli = container_of(lip, struct xfs_buf_log_item,
@@ -249,7 +244,7 @@ xfs_defer_trans_roll( 
					ASSERT(0);

					return -EFSCORRUPTED;

				}

				xfs_trans_dirty_buf(*tp, bli->bli_buf);

				xfs_trans_dirty_buf(tp, bli->bli_buf);

				bplist[bpcount++] = bli->bli_buf;

			}

			break;
@@ -261,7 +256,7 @@ xfs_defer_trans_roll( 
					ASSERT(0);

					return -EFSCORRUPTED;

				}

				xfs_trans_log_inode(*tp, ili->ili_inode,

				xfs_trans_log_inode(tp, ili->ili_inode,

						    XFS_ILOG_CORE);

				iplist[ipcount++] = ili->ili_inode;

			}
@@ -271,39 +266,30 @@ xfs_defer_trans_roll( 
		}

	}



	trace_xfs_defer_trans_roll((*tp)->t_mountp, (*tp)->t_dfops, _RET_IP_);

	trace_xfs_defer_trans_roll(tp->t_mountp, tp->t_dfops, _RET_IP_);



	/* Roll the transaction. */

	error = xfs_trans_roll(tp);

	error = xfs_trans_roll(tpp);

	tp = *tpp;

	if (error) {

		trace_xfs_defer_trans_roll_error((*tp)->t_mountp,

						 (*tp)->t_dfops, error);

		xfs_defer_trans_abort(*tp,  error);

		trace_xfs_defer_trans_roll_error(tp->t_mountp,

						 tp->t_dfops, error);

		return error;

	}



	/* Rejoin the joined inodes. */

	for (i = 0; i < ipcount; i++)

		xfs_trans_ijoin(*tp, iplist[i], 0);

		xfs_trans_ijoin(tp, iplist[i], 0);



	/* Rejoin the buffers and dirty them so the log moves forward. */

	for (i = 0; i < bpcount; i++) {

		xfs_trans_bjoin(*tp, bplist[i]);

		xfs_trans_bhold(*tp, bplist[i]);

		xfs_trans_bjoin(tp, bplist[i]);

		xfs_trans_bhold(tp, bplist[i]);

	}



	return error;

}



/* Do we have any work items to finish? */

bool

xfs_defer_has_unfinished_work(

	struct xfs_trans		*tp)

{

	return !list_empty(&tp->t_dfops->dop_pending) ||

		!list_empty(&tp->t_dfops->dop_intake);

}



/*

 * Reset an already used dfops after finish.

 */
@@ -311,7 +297,7 @@ static void 
xfs_defer_reset(

	struct xfs_trans	*tp)

{

	ASSERT(!xfs_defer_has_unfinished_work(tp));

	ASSERT(list_empty(&tp->t_dfops->dop_intake));



	/*

	 * Low mode state transfers across transaction rolls to mirror dfops
@@ -320,6 +306,36 @@ xfs_defer_reset( 
	tp->t_flags &= ~XFS_TRANS_LOWMODE;

}



/*

 * Free up any items left in the list.

 */

static void

xfs_defer_cancel_list(

	struct xfs_mount		*mp,

	struct list_head		*dop_list)

{

	struct xfs_defer_pending	*dfp;

	struct xfs_defer_pending	*pli;

	struct list_head		*pwi;

	struct list_head		*n;



	/*

	 * Free the pending items.  Caller should already have arranged

	 * for the intent items to be released.

	 */

	list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) {

		trace_xfs_defer_cancel_list(mp, dfp);

		list_del(&dfp->dfp_list);

		list_for_each_safe(pwi, n, &dfp->dfp_work) {

			list_del(pwi);

			dfp->dfp_count--;

			dfp->dfp_type->cancel_item(pwi);

		}

		ASSERT(dfp->dfp_count == 0);

		kmem_free(dfp);

	}

}



/*

 * Finish all the pending work.  This involves logging intent items for

 * any work items that wandered in since the last transaction roll (if
@@ -338,15 +354,19 @@ xfs_defer_finish_noroll( 
	void				*state;

	int				error = 0;

	void				(*cleanup_fn)(struct xfs_trans *, void *, int);

	LIST_HEAD(dop_pending);



	ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);



	trace_xfs_defer_finish((*tp)->t_mountp, (*tp)->t_dfops, _RET_IP_);



	/* Until we run out of pending work to finish... */

	while (xfs_defer_has_unfinished_work(*tp)) {

		/* Log intents for work items sitting in the intake. */

		xfs_defer_intake_work(*tp);

	while (!list_empty(&dop_pending) ||

	       !list_empty(&(*tp)->t_dfops->dop_intake)) {

		/* log intents and pull in intake items */

		xfs_defer_create_intents(*tp);

		list_splice_tail_init(&(*tp)->t_dfops->dop_intake,

				      &dop_pending);



		/*

		 * Roll the transaction.
@@ -356,8 +376,8 @@ xfs_defer_finish_noroll( 
			goto out;



		/* Log an intent-done item for the first pending item. */

		dfp = list_first_entry(&(*tp)->t_dfops->dop_pending,

				struct xfs_defer_pending, dfp_list);

		dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,

				       dfp_list);

		trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp);

		dfp->dfp_done = dfp->dfp_type->create_done(*tp, dfp->dfp_intent,

				dfp->dfp_count);
@@ -387,7 +407,6 @@ xfs_defer_finish_noroll( 
				 */

				if (cleanup_fn)

					cleanup_fn(*tp, state, error);

				xfs_defer_trans_abort(*tp, error);

				goto out;

			}

		}
@@ -417,8 +436,11 @@ xfs_defer_finish_noroll( 


out:

	if (error) {

		xfs_defer_trans_abort(*tp, &dop_pending);

		xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE);

		trace_xfs_defer_finish_error((*tp)->t_mountp, (*tp)->t_dfops,

					     error);

		xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending);

		xfs_defer_cancel(*tp);

		return error;

	}
@@ -442,54 +464,24 @@ xfs_defer_finish( 
		return error;

	if ((*tp)->t_flags & XFS_TRANS_DIRTY) {

		error = xfs_defer_trans_roll(tp);

		if (error)

		if (error) {

			xfs_force_shutdown((*tp)->t_mountp,

					   SHUTDOWN_CORRUPT_INCORE);

			return error;

		}

	}

	xfs_defer_reset(*tp);

	return 0;

}



/*

 * Free up any items left in the list.

 */

void

xfs_defer_cancel(

	struct xfs_trans	*tp)

{

	struct xfs_defer_ops		*dop = tp->t_dfops;

	struct xfs_defer_pending	*dfp;

	struct xfs_defer_pending	*pli;

	struct list_head		*pwi;

	struct list_head		*n;



	trace_xfs_defer_cancel(NULL, dop, _RET_IP_);

	struct xfs_mount	*mp = tp->t_mountp;



	/*

	 * Free the pending items.  Caller should already have arranged

	 * for the intent items to be released.

	 */

	list_for_each_entry_safe(dfp, pli, &dop->dop_intake, dfp_list) {

		trace_xfs_defer_intake_cancel(NULL, dfp);

		list_del(&dfp->dfp_list);

		list_for_each_safe(pwi, n, &dfp->dfp_work) {

			list_del(pwi);

			dfp->dfp_count--;

			dfp->dfp_type->cancel_item(pwi);

		}

		ASSERT(dfp->dfp_count == 0);

		kmem_free(dfp);

	}

	list_for_each_entry_safe(dfp, pli, &dop->dop_pending, dfp_list) {

		trace_xfs_defer_pending_cancel(NULL, dfp);

		list_del(&dfp->dfp_list);

		list_for_each_safe(pwi, n, &dfp->dfp_work) {

			list_del(pwi);

			dfp->dfp_count--;

			dfp->dfp_type->cancel_item(pwi);

		}

		ASSERT(dfp->dfp_count == 0);

		kmem_free(dfp);

	}

	trace_xfs_defer_cancel(mp, tp->t_dfops, _RET_IP_);

	xfs_defer_cancel_list(mp, &tp->t_dfops->dop_intake);

}



/* Add an item for later deferred processing. */
@@ -547,7 +539,6 @@ xfs_defer_init( 


	memset(dop, 0, sizeof(struct xfs_defer_ops));

	INIT_LIST_HEAD(&dop->dop_intake);

	INIT_LIST_HEAD(&dop->dop_pending);

	if (tp) {

		ASSERT(tp->t_firstblock == NULLFSBLOCK);

		tp->t_dfops = dop;
@@ -571,7 +562,6 @@ xfs_defer_move( 
	ASSERT(dst != src);



	list_splice_init(&src->dop_intake, &dst->dop_intake);

	list_splice_init(&src->dop_pending, &dst->dop_pending);



	/*

	 * Low free space mode was historically controlled by a dfops field.

fs/xfs/libxfs/xfs_defer.h

+0 −1
Original line number Diff line number Diff line
@@ -41,7 +41,6 @@ int xfs_defer_finish_noroll(struct xfs_trans **tp); 
int xfs_defer_finish(struct xfs_trans **tp);

void xfs_defer_cancel(struct xfs_trans *);

void xfs_defer_init(struct xfs_trans *tp, struct xfs_defer_ops *dop);

bool xfs_defer_has_unfinished_work(struct xfs_trans *tp);

void xfs_defer_move(struct xfs_trans *dtp, struct xfs_trans *stp);



/* Description of a deferred type. */

fs/xfs/xfs_trace.h

+2 −3
Original line number Diff line number Diff line
@@ -2392,9 +2392,8 @@ DEFINE_DEFER_EVENT(xfs_defer_finish_done); 
DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error);

DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error);



DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_work);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_cancel);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_cancel);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_create_intent);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish);

DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort);

fs/xfs/xfs_trans.c

+1 −1
Original line number Diff line number Diff line
@@ -929,7 +929,7 @@ __xfs_trans_commit( 
	 * Finish deferred items on final commit. Only permanent transactions

	 * should ever have deferred ops.

	 */

	WARN_ON_ONCE(xfs_defer_has_unfinished_work(tp) &&

	WARN_ON_ONCE(!list_empty(&tp->t_dfops->dop_intake) &&

		     !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));

	if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {

		error = xfs_defer_finish_noroll(&tp);

fs/xfs/xfs_trans.h

+0 −1
Original line number Diff line number Diff line
@@ -96,7 +96,6 @@ void xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item, 
#define XFS_DEFER_OPS_NR_BUFS	2	/* join up to two buffers */

struct xfs_defer_ops {

	struct list_head	dop_intake;	/* unlogged pending work */

	struct list_head	dop_pending;	/* logged pending work */

};



/*

CRA Git | Maintained and supported by SUSTech CRA and CCSE