Commit 96b60f82 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: refactor intent item iop_recover calls 



Now that we've made the recovered item tests all the same, we can hoist
the test and the ail locking code to the ->iop_recover caller and call
the recovery function directly.

Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarChandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
parent 889eb55d

fs/xfs/xfs_bmap_item.c

+13 −35
Original line number Diff line number Diff line
@@ -421,25 +421,26 @@ const struct xfs_defer_op_type xfs_bmap_update_defer_type = { 
 * We need to update some inode's bmbt.

 */

STATIC int

xfs_bui_recover(

	struct xfs_trans		*parent_tp,

	struct xfs_bui_log_item		*buip)

xfs_bui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*parent_tp)

{

	int				error = 0;

	unsigned int			bui_type;

	struct xfs_bmbt_irec		irec;

	struct xfs_bui_log_item		*buip = BUI_ITEM(lip);

	struct xfs_trans		*tp;

	struct xfs_inode		*ip = NULL;

	struct xfs_mount		*mp = parent_tp->t_mountp;

	struct xfs_map_extent		*bmap;

	struct xfs_bud_log_item		*budp;

	xfs_fsblock_t			startblock_fsb;

	xfs_fsblock_t			inode_fsb;

	xfs_filblks_t			count;

	bool				op_ok;

	struct xfs_bud_log_item		*budp;

	xfs_exntst_t			state;

	enum xfs_bmap_intent_type	type;

	bool				op_ok;

	unsigned int			bui_type;

	int				whichfork;

	xfs_exntst_t			state;

	struct xfs_trans		*tp;

	struct xfs_inode		*ip = NULL;

	struct xfs_bmbt_irec		irec;

	struct xfs_mount		*mp = parent_tp->t_mountp;

	int				error = 0;



	ASSERT(!test_bit(XFS_LI_RECOVERED, &buip->bui_item.li_flags));
@@ -555,29 +556,6 @@ xfs_bui_recover( 
	return error;

}



/* Recover the BUI if necessary. */

STATIC int

xfs_bui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*tp)

{

	struct xfs_ail			*ailp = lip->li_ailp;

	struct xfs_bui_log_item		*buip = BUI_ITEM(lip);

	int				error;



	/*

	 * Skip BUIs that we've already processed.

	 */

	if (test_bit(XFS_LI_RECOVERED, &buip->bui_item.li_flags))

		return 0;



	spin_unlock(&ailp->ail_lock);

	error = xfs_bui_recover(tp, buip);

	spin_lock(&ailp->ail_lock);



	return error;

}



STATIC bool

xfs_bui_item_match(

	struct xfs_log_item	*lip,

fs/xfs/xfs_extfree_item.c

+11 −33
Original line number Diff line number Diff line
@@ -581,16 +581,18 @@ const struct xfs_defer_op_type xfs_agfl_free_defer_type = { 
 * the log.  We need to free the extents that it describes.

 */

STATIC int

xfs_efi_recover(

	struct xfs_mount	*mp,

	struct xfs_efi_log_item	*efip)

xfs_efi_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*parent_tp)

{

	struct xfs_efi_log_item		*efip = EFI_ITEM(lip);

	struct xfs_mount		*mp = parent_tp->t_mountp;

	struct xfs_efd_log_item		*efdp;

	struct xfs_trans		*tp;

	struct xfs_extent		*extp;

	xfs_fsblock_t			startblock_fsb;

	int				i;

	int				error = 0;

	xfs_extent_t		*extp;

	xfs_fsblock_t		startblock_fsb;



	ASSERT(!test_bit(XFS_LI_RECOVERED, &efip->efi_item.li_flags));
@@ -641,30 +643,6 @@ xfs_efi_recover( 
	return error;

}



/* Recover the EFI if necessary. */

STATIC int

xfs_efi_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*tp)

{

	struct xfs_ail			*ailp = lip->li_ailp;

	struct xfs_efi_log_item		*efip;

	int				error;



	/*

	 * Skip EFIs that we've already processed.

	 */

	efip = container_of(lip, struct xfs_efi_log_item, efi_item);

	if (test_bit(XFS_LI_RECOVERED, &efip->efi_item.li_flags))

		return 0;



	spin_unlock(&ailp->ail_lock);

	error = xfs_efi_recover(tp->t_mountp, efip);

	spin_lock(&ailp->ail_lock);



	return error;

}



STATIC bool

xfs_efi_item_match(

	struct xfs_log_item	*lip,

fs/xfs/xfs_log_recover.c

+6 −2
Original line number Diff line number Diff line
@@ -2643,7 +2643,7 @@ xlog_recover_process_intents( 
	struct xfs_ail_cursor	cur;

	struct xfs_log_item	*lip;

	struct xfs_ail		*ailp;

	int			error;

	int			error = 0;

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

	xfs_lsn_t		last_lsn;

#endif
@@ -2693,7 +2693,11 @@ xlog_recover_process_intents( 
		 * this routine or else those subsequent intents will get

		 * replayed in the wrong order!

		 */

		if (!test_bit(XFS_LI_RECOVERED, &lip->li_flags)) {

			spin_unlock(&ailp->ail_lock);

			error = lip->li_ops->iop_recover(lip, parent_tp);

			spin_lock(&ailp->ail_lock);

		}

		if (error)

			goto out;

		lip = xfs_trans_ail_cursor_next(ailp, &cur);

fs/xfs/xfs_refcount_item.c

+12 −34
Original line number Diff line number Diff line
@@ -421,25 +421,26 @@ const struct xfs_defer_op_type xfs_refcount_update_defer_type = { 
 * We need to update the refcountbt.

 */

STATIC int

xfs_cui_recover(

	struct xfs_trans		*parent_tp,

	struct xfs_cui_log_item		*cuip)

xfs_cui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*parent_tp)

{

	int				i;

	int				error = 0;

	unsigned int			refc_type;

	struct xfs_bmbt_irec		irec;

	struct xfs_cui_log_item		*cuip = CUI_ITEM(lip);

	struct xfs_phys_extent		*refc;

	xfs_fsblock_t			startblock_fsb;

	bool				op_ok;

	struct xfs_cud_log_item		*cudp;

	struct xfs_trans		*tp;

	struct xfs_btree_cur		*rcur = NULL;

	enum xfs_refcount_intent_type	type;

	struct xfs_mount		*mp = parent_tp->t_mountp;

	xfs_fsblock_t			startblock_fsb;

	xfs_fsblock_t			new_fsb;

	xfs_extlen_t			new_len;

	struct xfs_bmbt_irec		irec;

	unsigned int			refc_type;

	bool				op_ok;

	bool				requeue_only = false;

	struct xfs_mount		*mp = parent_tp->t_mountp;

	enum xfs_refcount_intent_type	type;

	int				i;

	int				error = 0;



	ASSERT(!test_bit(XFS_LI_RECOVERED, &cuip->cui_item.li_flags));
@@ -568,29 +569,6 @@ xfs_cui_recover( 
	return error;

}



/* Recover the CUI if necessary. */

STATIC int

xfs_cui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*tp)

{

	struct xfs_ail			*ailp = lip->li_ailp;

	struct xfs_cui_log_item		*cuip = CUI_ITEM(lip);

	int				error;



	/*

	 * Skip CUIs that we've already processed.

	 */

	if (test_bit(XFS_LI_RECOVERED, &cuip->cui_item.li_flags))

		return 0;



	spin_unlock(&ailp->ail_lock);

	error = xfs_cui_recover(tp, cuip);

	spin_lock(&ailp->ail_lock);



	return error;

}



STATIC bool

xfs_cui_item_match(

	struct xfs_log_item	*lip,

fs/xfs/xfs_rmap_item.c

+12 −33
Original line number Diff line number Diff line
@@ -464,21 +464,23 @@ const struct xfs_defer_op_type xfs_rmap_update_defer_type = { 
 * We need to update the rmapbt.

 */

STATIC int

xfs_rui_recover(

	struct xfs_mount		*mp,

	struct xfs_rui_log_item		*ruip)

xfs_rui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*parent_tp)

{

	int				i;

	int				error = 0;

	struct xfs_rui_log_item		*ruip = RUI_ITEM(lip);

	struct xfs_map_extent		*rmap;

	xfs_fsblock_t			startblock_fsb;

	bool				op_ok;

	struct xfs_rud_log_item		*rudp;

	enum xfs_rmap_intent_type	type;

	int				whichfork;

	xfs_exntst_t			state;

	struct xfs_trans		*tp;

	struct xfs_btree_cur		*rcur = NULL;

	struct xfs_mount		*mp = parent_tp->t_mountp;

	xfs_fsblock_t			startblock_fsb;

	enum xfs_rmap_intent_type	type;

	xfs_exntst_t			state;

	bool				op_ok;

	int				i;

	int				whichfork;

	int				error = 0;



	ASSERT(!test_bit(XFS_LI_RECOVERED, &ruip->rui_item.li_flags));
@@ -583,29 +585,6 @@ xfs_rui_recover( 
	return error;

}



/* Recover the RUI if necessary. */

STATIC int

xfs_rui_item_recover(

	struct xfs_log_item		*lip,

	struct xfs_trans		*tp)

{

	struct xfs_ail			*ailp = lip->li_ailp;

	struct xfs_rui_log_item		*ruip = RUI_ITEM(lip);

	int				error;



	/*

	 * Skip RUIs that we've already processed.

	 */

	if (test_bit(XFS_LI_RECOVERED, &ruip->rui_item.li_flags))

		return 0;



	spin_unlock(&ailp->ail_lock);

	error = xfs_rui_recover(tp->t_mountp, ruip);

	spin_lock(&ailp->ail_lock);



	return error;

}



STATIC bool

xfs_rui_item_match(

	struct xfs_log_item	*lip,