iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xfs: refactor intent item iop_recover calls

Browse Source 
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: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
This commit is contained in:
Darrick J. Wong 2020-05-01 16:00:55 -07:00
parent 889eb55dd6
commit 96b60f8267
5 changed files with 55 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
fs/xfs/xfs_bmap_item.c
View File

@ -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;
enum xfs_bmap_intent_type 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;
enum xfs_bmap_intent_type type;
bool op_ok;
unsigned int bui_type;
int whichfork;
int error = 0;
ASSERT(!test_bit(XFS_LI_RECOVERED, &buip->bui_item.li_flags));
@ -555,29 +556,6 @@ err_inode:
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,

44
fs/xfs/xfs_extfree_item.c
View File

@ -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_efd_log_item *efdp;
struct xfs_trans *tp;
int i;
int error = 0;
xfs_extent_t *extp;
xfs_fsblock_t startblock_fsb;
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;
ASSERT(!test_bit(XFS_LI_RECOVERED, &efip->efi_item.li_flags));
@ -641,30 +643,6 @@ abort_error:
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,

8
fs/xfs/xfs_log_recover.c
View File

@ -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!
*/
error = lip->li_ops->iop_recover(lip, parent_tp);
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);

46
fs/xfs/xfs_refcount_item.c
View File

@ -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 @@ abort_error:
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,

45
fs/xfs/xfs_rmap_item.c
View File

@ -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 @@ abort_error:
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,