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

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

xfs: use transaction for intent recovery instead of raw dfops 



Log intent recovery is the last user of an external (on-stack)
dfops. The pattern exists because the dfops is used to collect
additional deferred operations queued during the whole recovery
sequence. The dfops is finished with a new transaction after intent
recovery completes.

We already have a mechanism to create an empty, container-like
transaction to support the scrub infrastructure. We can reuse that
mechanism here to drop the final user of external dfops. This
facilitates folding dfops state (i.e., dop_low) into the
transaction, the elimination of now unused external dfops support
and also eliminates the only caller of __xfs_defer_cancel().

Replace the on-stack dfops with an empty transaction and pass it
around to the various helpers that queue and finish deferred
operations during intent recovery.

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 98719051

fs/xfs/xfs_bmap_item.c

+6 −6
Original line number Original line Diff line number Diff line
@@ -375,9 +375,8 @@ xfs_bud_init( 
 */

 */

int

int

xfs_bui_recover(

xfs_bui_recover(

	struct xfs_mount		*mp,

	struct xfs_trans		*parent_tp,

	struct xfs_bui_log_item		*buip,

	struct xfs_bui_log_item		*buip)

	struct xfs_defer_ops		*dfops)

{

{

	int				error = 0;

	int				error = 0;

	unsigned int			bui_type;

	unsigned int			bui_type;
@@ -393,6 +392,7 @@ xfs_bui_recover( 
	struct xfs_trans		*tp;

	struct xfs_trans		*tp;

	struct xfs_inode		*ip = NULL;

	struct xfs_inode		*ip = NULL;

	struct xfs_bmbt_irec		irec;

	struct xfs_bmbt_irec		irec;

	struct xfs_mount		*mp = parent_tp->t_mountp;





	ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));

	ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));
@@ -446,7 +446,7 @@ xfs_bui_recover( 
	 * finishes them on completion. Transfer current dfops state to this

	 * finishes them on completion. Transfer current dfops state to this

	 * transaction and transfer the result back before we return.

	 * transaction and transfer the result back before we return.

	 */

	 */

	xfs_defer_move(tp->t_dfops, dfops);

	xfs_defer_move(tp->t_dfops, parent_tp->t_dfops);

	budp = xfs_trans_get_bud(tp, buip);

	budp = xfs_trans_get_bud(tp, buip);





	/* Grab the inode. */

	/* Grab the inode. */
@@ -494,7 +494,7 @@ xfs_bui_recover( 
	}

	}





	set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);

	set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);

	xfs_defer_move(dfops, tp->t_dfops);

	xfs_defer_move(parent_tp->t_dfops, tp->t_dfops);

	error = xfs_trans_commit(tp);

	error = xfs_trans_commit(tp);

	xfs_iunlock(ip, XFS_ILOCK_EXCL);

	xfs_iunlock(ip, XFS_ILOCK_EXCL);

	xfs_irele(ip);

	xfs_irele(ip);
@@ -502,7 +502,7 @@ xfs_bui_recover( 
	return error;

	return error;





err_inode:

err_inode:

	xfs_defer_move(dfops, tp->t_dfops);

	xfs_defer_move(parent_tp->t_dfops, tp->t_dfops);

	xfs_trans_cancel(tp);

	xfs_trans_cancel(tp);

	if (ip) {

	if (ip) {

		xfs_iunlock(ip, XFS_ILOCK_EXCL);

		xfs_iunlock(ip, XFS_ILOCK_EXCL);

fs/xfs/xfs_bmap_item.h

+1 −2
Original line number Original line Diff line number Diff line
@@ -79,7 +79,6 @@ struct xfs_bud_log_item *xfs_bud_init(struct xfs_mount *, 
		struct xfs_bui_log_item *);

		struct xfs_bui_log_item *);

void xfs_bui_item_free(struct xfs_bui_log_item *);

void xfs_bui_item_free(struct xfs_bui_log_item *);

void xfs_bui_release(struct xfs_bui_log_item *);

void xfs_bui_release(struct xfs_bui_log_item *);

int xfs_bui_recover(struct xfs_mount *mp, struct xfs_bui_log_item *buip,

int xfs_bui_recover(struct xfs_trans *parent_tp, struct xfs_bui_log_item *buip);

		struct xfs_defer_ops *dfops);





#endif	/* __XFS_BMAP_ITEM_H__ */
 
#endif	/* __XFS_BMAP_ITEM_H__ */

fs/xfs/xfs_log_recover.c

+29 −22
Original line number Original line Diff line number Diff line
@@ -4733,10 +4733,9 @@ xlog_recover_cancel_rui( 
/* Recover the CUI if necessary. */

/* Recover the CUI if necessary. */

STATIC int

STATIC int

xlog_recover_process_cui(

xlog_recover_process_cui(

	struct xfs_mount		*mp,

	struct xfs_trans		*parent_tp,

	struct xfs_ail			*ailp,

	struct xfs_ail			*ailp,

	struct xfs_log_item		*lip,

	struct xfs_log_item		*lip)

	struct xfs_defer_ops		*dfops)

{

{

	struct xfs_cui_log_item		*cuip;

	struct xfs_cui_log_item		*cuip;

	int				error;

	int				error;
@@ -4749,7 +4748,7 @@ xlog_recover_process_cui( 
		return 0;

		return 0;





	spin_unlock(&ailp->ail_lock);

	spin_unlock(&ailp->ail_lock);

	error = xfs_cui_recover(mp, cuip, dfops);

	error = xfs_cui_recover(parent_tp, cuip);

	spin_lock(&ailp->ail_lock);

	spin_lock(&ailp->ail_lock);





	return error;

	return error;
@@ -4774,10 +4773,9 @@ xlog_recover_cancel_cui( 
/* Recover the BUI if necessary. */

/* Recover the BUI if necessary. */

STATIC int

STATIC int

xlog_recover_process_bui(

xlog_recover_process_bui(

	struct xfs_mount		*mp,

	struct xfs_trans		*parent_tp,

	struct xfs_ail			*ailp,

	struct xfs_ail			*ailp,

	struct xfs_log_item		*lip,

	struct xfs_log_item		*lip)

	struct xfs_defer_ops		*dfops)

{

{

	struct xfs_bui_log_item		*buip;

	struct xfs_bui_log_item		*buip;

	int				error;

	int				error;
@@ -4790,7 +4788,7 @@ xlog_recover_process_bui( 
		return 0;

		return 0;





	spin_unlock(&ailp->ail_lock);

	spin_unlock(&ailp->ail_lock);

	error = xfs_bui_recover(mp, buip, dfops);

	error = xfs_bui_recover(parent_tp, buip);

	spin_lock(&ailp->ail_lock);

	spin_lock(&ailp->ail_lock);





	return error;

	return error;
@@ -4829,9 +4827,9 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip) 
/* Take all the collected deferred ops and finish them in order. */

/* Take all the collected deferred ops and finish them in order. */

static int

static int

xlog_finish_defer_ops(

xlog_finish_defer_ops(

	struct xfs_mount	*mp,

	struct xfs_trans	*parent_tp)

	struct xfs_defer_ops	*dfops)

{

{

	struct xfs_mount	*mp = parent_tp->t_mountp;

	struct xfs_trans	*tp;

	struct xfs_trans	*tp;

	int64_t			freeblks;

	int64_t			freeblks;

	uint			resblks;

	uint			resblks;
@@ -4855,7 +4853,7 @@ xlog_finish_defer_ops( 
	if (error)

	if (error)

		return error;

		return error;

	/* transfer all collected dfops to this transaction */

	/* transfer all collected dfops to this transaction */

	xfs_defer_move(tp->t_dfops, dfops);

	xfs_defer_move(tp->t_dfops, parent_tp->t_dfops);





	return xfs_trans_commit(tp);

	return xfs_trans_commit(tp);

}

}
@@ -4880,22 +4878,34 @@ STATIC int 
xlog_recover_process_intents(

xlog_recover_process_intents(

	struct xlog		*log)

	struct xlog		*log)

{

{

	struct xfs_defer_ops	dfops;

	struct xfs_trans	*parent_tp;

	struct xfs_ail_cursor	cur;

	struct xfs_ail_cursor	cur;

	struct xfs_log_item	*lip;

	struct xfs_log_item	*lip;

	struct xfs_ail		*ailp;

	struct xfs_ail		*ailp;

	int			error = 0;

	int			error;

#if defined(DEBUG) || defined(XFS_WARN)

#if defined(DEBUG) || defined(XFS_WARN)

	xfs_lsn_t		last_lsn;

	xfs_lsn_t		last_lsn;

#endif

#endif





	/*

	 * The intent recovery handlers commit transactions to complete recovery

	 * for individual intents, but any new deferred operations that are

	 * queued during that process are held off until the very end. The

	 * purpose of this transaction is to serve as a container for deferred

	 * operations. Each intent recovery handler must transfer dfops here

	 * before its local transaction commits, and we'll finish the entire

	 * list below.

	 */

	error = xfs_trans_alloc_empty(log->l_mp, &parent_tp);

	if (error)

		return error;



	ailp = log->l_ailp;

	ailp = log->l_ailp;

	spin_lock(&ailp->ail_lock);

	spin_lock(&ailp->ail_lock);

	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);

	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);

#if defined(DEBUG) || defined(XFS_WARN)

#if defined(DEBUG) || defined(XFS_WARN)

	last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block);

	last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block);

#endif

#endif

	xfs_defer_init(NULL, &dfops);

	while (lip != NULL) {

	while (lip != NULL) {

		/*

		/*

		 * We're done when we see something other than an intent.

		 * We're done when we see something other than an intent.
@@ -4930,12 +4940,10 @@ xlog_recover_process_intents( 
			error = xlog_recover_process_rui(log->l_mp, ailp, lip);

			error = xlog_recover_process_rui(log->l_mp, ailp, lip);

			break;

			break;

		case XFS_LI_CUI:

		case XFS_LI_CUI:

			error = xlog_recover_process_cui(log->l_mp, ailp, lip,

			error = xlog_recover_process_cui(parent_tp, ailp, lip);

					&dfops);

			break;

			break;

		case XFS_LI_BUI:

		case XFS_LI_BUI:

			error = xlog_recover_process_bui(log->l_mp, ailp, lip,

			error = xlog_recover_process_bui(parent_tp, ailp, lip);

					&dfops);

			break;

			break;

		}

		}

		if (error)

		if (error)
@@ -4945,10 +4953,9 @@ xlog_recover_process_intents( 
out:

out:

	xfs_trans_ail_cursor_done(&cur);

	xfs_trans_ail_cursor_done(&cur);

	spin_unlock(&ailp->ail_lock);

	spin_unlock(&ailp->ail_lock);

	if (error)

	if (!error)

		__xfs_defer_cancel(&dfops);

		error = xlog_finish_defer_ops(parent_tp);

	else

	xfs_trans_cancel(parent_tp);

		error = xlog_finish_defer_ops(log->l_mp, &dfops);





	return error;

	return error;

}

}

fs/xfs/xfs_refcount_item.c

+6 −6
Original line number Original line Diff line number Diff line
@@ -380,9 +380,8 @@ xfs_cud_init( 
 */

 */

int

int

xfs_cui_recover(

xfs_cui_recover(

	struct xfs_mount		*mp,

	struct xfs_trans		*parent_tp,

	struct xfs_cui_log_item		*cuip,

	struct xfs_cui_log_item		*cuip)

	struct xfs_defer_ops		*dfops)

{

{

	int				i;

	int				i;

	int				error = 0;

	int				error = 0;
@@ -398,6 +397,7 @@ xfs_cui_recover( 
	xfs_extlen_t			new_len;

	xfs_extlen_t			new_len;

	struct xfs_bmbt_irec		irec;

	struct xfs_bmbt_irec		irec;

	bool				requeue_only = false;

	bool				requeue_only = false;

	struct xfs_mount		*mp = parent_tp->t_mountp;





	ASSERT(!test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags));

	ASSERT(!test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags));
@@ -457,7 +457,7 @@ xfs_cui_recover( 
	 * finishes them on completion. Transfer current dfops state to this

	 * finishes them on completion. Transfer current dfops state to this

	 * transaction and transfer the result back before we return.

	 * transaction and transfer the result back before we return.

	 */

	 */

	xfs_defer_move(tp->t_dfops, dfops);

	xfs_defer_move(tp->t_dfops, parent_tp->t_dfops);

	cudp = xfs_trans_get_cud(tp, cuip);

	cudp = xfs_trans_get_cud(tp, cuip);





	for (i = 0; i < cuip->cui_format.cui_nextents; i++) {

	for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
@@ -522,13 +522,13 @@ xfs_cui_recover( 




	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	set_bit(XFS_CUI_RECOVERED, &cuip->cui_flags);

	set_bit(XFS_CUI_RECOVERED, &cuip->cui_flags);

	xfs_defer_move(dfops, tp->t_dfops);

	xfs_defer_move(parent_tp->t_dfops, tp->t_dfops);

	error = xfs_trans_commit(tp);

	error = xfs_trans_commit(tp);

	return error;

	return error;





abort_error:

abort_error:

	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	xfs_defer_move(dfops, tp->t_dfops);

	xfs_defer_move(parent_tp->t_dfops, tp->t_dfops);

	xfs_trans_cancel(tp);

	xfs_trans_cancel(tp);

	return error;

	return error;

}
 
}

fs/xfs/xfs_refcount_item.h

+1 −2
Original line number Original line Diff line number Diff line
@@ -82,7 +82,6 @@ struct xfs_cud_log_item *xfs_cud_init(struct xfs_mount *, 
		struct xfs_cui_log_item *);

		struct xfs_cui_log_item *);

void xfs_cui_item_free(struct xfs_cui_log_item *);

void xfs_cui_item_free(struct xfs_cui_log_item *);

void xfs_cui_release(struct xfs_cui_log_item *);

void xfs_cui_release(struct xfs_cui_log_item *);

int xfs_cui_recover(struct xfs_mount *mp, struct xfs_cui_log_item *cuip,

int xfs_cui_recover(struct xfs_trans *parent_tp, struct xfs_cui_log_item *cuip);

		struct xfs_defer_ops *dfops);





#endif	/* __XFS_REFCOUNT_ITEM_H__ */
 
#endif	/* __XFS_REFCOUNT_ITEM_H__ */