xfs: strengthen log intent validation
cover xfs: strengthen log intent validation
Hi all,
This patchset hoists the code that checks log intent record validation into separate functions, and reworks them to use the standard field validation predicates instead of open-coding them. This strengthens log recovery against (some) fuzzed log items.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=fix-recovered-log-intent-validation-5.11
--- fs/xfs/xfs_bmap_item.c | 75 ++++++++++++++++++++++++++++---------------- fs/xfs/xfs_extfree_item.c | 31 ++++++++++++------ fs/xfs/xfs_log_recover.c | 5 ++- fs/xfs/xfs_refcount_item.c | 61 ++++++++++++++++++++++-------------- fs/xfs/xfs_rmap_item.c | 75 ++++++++++++++++++++++++++++---------------- fs/xfs/xfs_trace.h | 19 +++++++++++ 6 files changed, 178 insertions(+), 88 deletions(-)
PATCH 1/10 xfs: hoist recovered bmap intent checks out of xfs_bui_item_recover
From: Darrick J. Wong <[email protected]>
When we recover a bmap intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
--- fs/xfs/xfs_bmap_item.c | 71 ++++++++++++++++++++++++++++++------------------ 1 file changed, 44 insertions(+), 27 deletions(-)
fs/xfs/xfs_bmap_item.c +44 -27
@@ -417,6 +417,49 @@ const struct xfs_defer_op_type xfs_bmap_update_defer_type = { .cancel_item = xfs_bmap_update_cancel_item, }; +/* Is this recovered BUI ok? */ +static inline bool +xfs_bui_validate ( +struct xfs_mount *mp, +struct xfs_bui_log_item *buip) +{ +struct xfs_map_extent *bmap; +xfs_fsblock_t startblock_fsb; +xfs_fsblock_t inode_fsb; + +/* Only one mapping operation per BUI... */ +if (buip->bui_format.bui_nextents !=XFS_BUI_MAX_FAST_EXTENTS ) +return false; + + bmap = &buip->bui_format.bui_extents[0 ]; + startblock_fsb =XFS_BB_TO_FSB (mp, +XFS_FSB_TO_DADDR (mp, bmap->me_startblock)); + inode_fsb =XFS_BB_TO_FSB (mp,XFS_FSB_TO_DADDR (mp, +XFS_INO_TO_FSB (mp, bmap->me_owner))); + +if (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS ) +return false; + +switch (bmap->me_flags &XFS_BMAP_EXTENT_TYPE_MASK ) { +case XFS_BMAP_MAP : +case XFS_BMAP_UNMAP : +break ; +default : +return false; + } + +if (startblock_fsb ==0 || + bmap->me_len ==0 || + inode_fsb ==0 || + startblock_fsb >= mp->m_sb.sb_dblocks || + bmap->me_len >= mp->m_sb.sb_agblocks || + inode_fsb >= mp->m_sb.sb_dblocks || + (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS )) +return false; + +return true; +} +/* * Process a bmap update intent item that was recovered from the log. * We need to update some inode's bmbt.
@@ -433,47 +476,21 @@ xfs_bui_item_recover(struct xfs_mount *mp = lip->li_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;xfs_exntst_t state;unsigned int bui_type;int whichfork;int error =0 ; -/* Only one mapping operation per BUI... */ -if (buip->bui_format.bui_nextents !=XFS_BUI_MAX_FAST_EXTENTS ) +if (!xfs_bui_validate (mp, buip))return -EFSCORRUPTED ; -/* -* First check the validity of the extent described by the -* BUI. If anything is bad, then toss the BUI. -*/ bmap = &buip->bui_format.bui_extents[0 ]; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, bmap->me_startblock)); - inode_fsb =XFS_BB_TO_FSB (mp,XFS_FSB_TO_DADDR (mp, -XFS_INO_TO_FSB (mp, bmap->me_owner))); state = (bmap->me_flags &XFS_BMAP_EXTENT_UNWRITTEN ) ?XFS_EXT_UNWRITTEN :XFS_EXT_NORM ; whichfork = (bmap->me_flags &XFS_BMAP_EXTENT_ATTR_FORK ) ?XFS_ATTR_FORK :XFS_DATA_FORK ; bui_type = bmap->me_flags &XFS_BMAP_EXTENT_TYPE_MASK ; -switch (bui_type) { -case XFS_BMAP_MAP : -case XFS_BMAP_UNMAP : -break ; -default : -return -EFSCORRUPTED ; - } -if (startblock_fsb ==0 || - bmap->me_len ==0 || - inode_fsb ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - bmap->me_len >= mp->m_sb.sb_agblocks || - inode_fsb >= mp->m_sb.sb_dblocks || - (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS )) -return -EFSCORRUPTED ;/* Grab the inode. */ error =xfs_iget (mp,NULL , bmap->me_owner,0 ,0 , &ip);
Re: [PATCH 01/10] xfs: hoist recovered bmap intent checks out of xfs_bui_item_recover
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When we recover a bmap intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,
PATCH 2/10 xfs: improve the code that checks recovered bmap intent items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The code that validates recovered bmap intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
--- fs/xfs/xfs_bmap_item.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
fs/xfs/xfs_bmap_item.c +13 -13
@@ -424,18 +424,13 @@ xfs_bui_validate( struct xfs_bui_log_item *buip) {struct xfs_map_extent *bmap; -xfs_fsblock_t startblock_fsb; -xfs_fsblock_t inode_fsb; +xfs_fsblock_t end;/* Only one mapping operation per BUI... */ if (buip->bui_format.bui_nextents !=XFS_BUI_MAX_FAST_EXTENTS )return false; bmap = &buip->bui_format.bui_extents[0 ]; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, bmap->me_startblock)); - inode_fsb =XFS_BB_TO_FSB (mp,XFS_FSB_TO_DADDR (mp, -XFS_INO_TO_FSB (mp, bmap->me_owner)));if (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS )return false;
@@ -448,13 +443,18 @@ xfs_bui_validate(return false; } -if (startblock_fsb ==0 || - bmap->me_len ==0 || - inode_fsb ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - bmap->me_len >= mp->m_sb.sb_agblocks || - inode_fsb >= mp->m_sb.sb_dblocks || - (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS )) +if (!xfs_verify_ino (mp, bmap->me_owner)) +return false; + +if (bmap->me_startoff + bmap->me_len <= bmap->me_startoff) +return false; + +if (bmap->me_startblock + bmap->me_len <= bmap->me_startblock) +return false; + + end = bmap->me_startblock + bmap->me_len -1 ; +if (!xfs_verify_fsbno (mp, bmap->me_startblock) || + !xfs_verify_fsbno (mp, end))return false;return true;
Re: [PATCH 02/10] xfs: improve the code that checks recovered bmap intent items
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
The code that validates recovered bmap intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
Signed-off-by Darrick J. Wong <[email protected]>---
Looks good,
PATCH 3/10 xfs: hoist recovered rmap intent checks out of xfs_rui_item_recover
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we recover a rmap intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
--- fs/xfs/xfs_rmap_item.c | 65 ++++++++++++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 27 deletions(-)
fs/xfs/xfs_rmap_item.c +38 -27
@@ -460,6 +460,42 @@ const struct xfs_defer_op_type xfs_rmap_update_defer_type = { .cancel_item = xfs_rmap_update_cancel_item, }; +/* Is this recovered RUI ok? */ +static inline bool +xfs_rui_validate_map ( +struct xfs_mount *mp, +struct xfs_map_extent *rmap) +{ +xfs_fsblock_t startblock_fsb; +bool op_ok; + + startblock_fsb =XFS_BB_TO_FSB (mp, +XFS_FSB_TO_DADDR (mp, rmap->me_startblock)); +switch (rmap->me_flags &XFS_RMAP_EXTENT_TYPE_MASK ) { +case XFS_RMAP_EXTENT_MAP : +case XFS_RMAP_EXTENT_MAP_SHARED : +case XFS_RMAP_EXTENT_UNMAP : +case XFS_RMAP_EXTENT_UNMAP_SHARED : +case XFS_RMAP_EXTENT_CONVERT : +case XFS_RMAP_EXTENT_CONVERT_SHARED : +case XFS_RMAP_EXTENT_ALLOC : +case XFS_RMAP_EXTENT_FREE : + op_ok = true; +break ; +default : + op_ok = false; +break ; + } +if (!op_ok || startblock_fsb ==0 || + rmap->me_len ==0 || + startblock_fsb >= mp->m_sb.sb_dblocks || + rmap->me_len >= mp->m_sb.sb_agblocks || + (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS )) +return false; + +return true; +} +/* * Process an rmap update intent item that was recovered from the log. * We need to update the rmapbt.
@@ -475,10 +511,8 @@ xfs_rui_item_recover(struct xfs_trans *tp;struct xfs_btree_cur *rcur =NULL ;struct xfs_mount *mp = lip->li_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 ;
@@ -488,32 +522,9 @@ xfs_rui_item_recover(* RUI. If any are bad, then assume that all are bad and * just toss the RUI. */ -for (i =0 ; i < ruip->rui_format.rui_nextents; i++) { - rmap = &ruip->rui_format.rui_extents[i]; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, rmap->me_startblock)); -switch (rmap->me_flags &XFS_RMAP_EXTENT_TYPE_MASK ) { -case XFS_RMAP_EXTENT_MAP : -case XFS_RMAP_EXTENT_MAP_SHARED : -case XFS_RMAP_EXTENT_UNMAP : -case XFS_RMAP_EXTENT_UNMAP_SHARED : -case XFS_RMAP_EXTENT_CONVERT : -case XFS_RMAP_EXTENT_CONVERT_SHARED : -case XFS_RMAP_EXTENT_ALLOC : -case XFS_RMAP_EXTENT_FREE : - op_ok = true; -break ; -default : - op_ok = false; -break ; - } -if (!op_ok || startblock_fsb ==0 || - rmap->me_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - rmap->me_len >= mp->m_sb.sb_agblocks || - (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS )) +for (i =0 ; i < ruip->rui_format.rui_nextents; i++) +if (!xfs_rui_validate_map (mp, &ruip->rui_format.rui_extents[i]))return -EFSCORRUPTED ; - } error =xfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate, mp->m_rmap_maxlevels,0 ,XFS_TRANS_RESERVE , &tp);
Re: [PATCH 03/10] xfs: hoist recovered rmap intent checks out of xfs_rui_item_recover
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When we recover a rmap intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,
PATCH 4/10 xfs: improve the code that checks recovered rmap intent items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The code that validates recovered rmap intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
--- fs/xfs/xfs_rmap_item.c | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-)
fs/xfs/xfs_rmap_item.c +19 -12
@@ -466,11 +466,11 @@ xfs_rui_validate_map(struct xfs_mount *mp, struct xfs_map_extent *rmap) { - xfs_fsblock_t startblock_fsb; -bool op_ok; + xfs_fsblock_t end; + +if (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS ) +return false; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, rmap->me_startblock));switch (rmap->me_flags &XFS_RMAP_EXTENT_TYPE_MASK ) {case XFS_RMAP_EXTENT_MAP :case XFS_RMAP_EXTENT_MAP_SHARED :
@@ -480,17 +480,24 @@ xfs_rui_validate_map(case XFS_RMAP_EXTENT_CONVERT_SHARED :case XFS_RMAP_EXTENT_ALLOC :case XFS_RMAP_EXTENT_FREE : - op_ok = true;break ;default : - op_ok = false; -break ; +return false; } -if (!op_ok || startblock_fsb ==0 || - rmap->me_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - rmap->me_len >= mp->m_sb.sb_agblocks || - (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS )) + +if (!xfs_verify_ino (mp, rmap->me_owner) && + !XFS_RMAP_NON_INODE_OWNER (rmap->me_owner)) +return false; + +if (rmap->me_startoff + rmap->me_len <= rmap->me_startoff) +return false; + +if (rmap->me_startblock + rmap->me_len <= rmap->me_startblock) +return false; + + end = rmap->me_startblock + rmap->me_len -1 ; +if (!xfs_verify_fsbno (mp, rmap->me_startblock) || + !xfs_verify_fsbno (mp, end))return false;return true;
Re: [PATCH 04/10] xfs: improve the code that checks recovered rmap intent items
fs/xfs/xfs_rmap_item.c xfs_rui_validate_map( · line 490
Quoted 3 lines · Darrick J. Wong
fs/xfs/xfs_rmap_item.c +3
-0+if (!xfs_verify_ino (mp, rmap->me_owner) && + !XFS_RMAP_NON_INODE_OWNER (rmap->me_owner)) +return false;
Wouldn't it make sense to reverse the order of the checks here?
fs/xfs/xfs_rmap_item.c xfs_rui_validate_map( · line 501
Quoted 4 lines
fs/xfs/xfs_rmap_item.c +3
-0+ end = rmap->me_startblock + rmap->me_len -1 ; +if (!xfs_verify_fsbno (mp, rmap->me_startblock) || + !xfs_verify_fsbno (mp, end))return false;
Nit: why not simply:
if (!xfs_verify_fsbno(mp, rmap->me_startblock)) return false; if (!xfs_verify_fsbno(mp, rmap->me_startblock + rmap->me_len - 1)) return false;
?
Re: [PATCH 04/10] xfs: improve the code that checks recovered rmap intent items
Quoted 6 lines · Christoph Hellwig
fs/xfs/xfs_rmap_item.c xfs_rui_validate_map( · line 490
Quoted 3 lines · Darrick J. Wong
fs/xfs/xfs_rmap_item.c +3
-0+if (!xfs_verify_ino (mp, rmap->me_owner) && + !XFS_RMAP_NON_INODE_OWNER (rmap->me_owner)) +return false;Wouldn't it make sense to reverse the order of the checks here?
Yep. Fixed.
Quoted 7 lines
fs/xfs/xfs_rmap_item.c xfs_rui_validate_map( · line 501
Quoted 4 lines
fs/xfs/xfs_rmap_item.c +3
-0+ end = rmap->me_startblock + rmap->me_len -1 ; +if (!xfs_verify_fsbno (mp, rmap->me_startblock) || + !xfs_verify_fsbno (mp, end))return false;Nit: why not simply:
Quoted 6 lines
if (!xfs_verify_fsbno(mp, rmap->me_startblock)) return false; if (!xfs_verify_fsbno(mp, rmap->me_startblock + rmap->me_len - 1)) return false;?
Yeah.
--D
PATCH v2 4/10 xfs: improve the code that checks recovered rmap intent items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The code that validates recovered rmap intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
---
v2: reverse the owner tests, simplify the startblock checks
--- fs/xfs/xfs_rmap_item.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-)
fs/xfs/xfs_rmap_item.c +18 -12
@@ -466,11 +466,9 @@ xfs_rui_validate_map( struct xfs_mount *mp, struct xfs_map_extent *rmap) { - xfs_fsblock_t startblock_fsb; -bool op_ok; +if (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS ) +return false; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, rmap->me_startblock));switch (rmap->me_flags &XFS_RMAP_EXTENT_TYPE_MASK ) {case XFS_RMAP_EXTENT_MAP :case XFS_RMAP_EXTENT_MAP_SHARED :
@@ -480,17 +478,25 @@ xfs_rui_validate_map(case XFS_RMAP_EXTENT_CONVERT_SHARED :case XFS_RMAP_EXTENT_ALLOC :case XFS_RMAP_EXTENT_FREE : - op_ok = true;break ;default : - op_ok = false; -break ; +return false; } -if (!op_ok || startblock_fsb ==0 || - rmap->me_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - rmap->me_len >= mp->m_sb.sb_agblocks || - (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS )) + +if (!XFS_RMAP_NON_INODE_OWNER (rmap->me_owner) && + !xfs_verify_ino (mp, rmap->me_owner)) +return false; + +if (rmap->me_startoff + rmap->me_len <= rmap->me_startoff) +return false; + +if (rmap->me_startblock + rmap->me_len <= rmap->me_startblock) +return false; + +if (!xfs_verify_fsbno (mp, rmap->me_startblock)) +return false; + +if (!xfs_verify_fsbno (mp, rmap->me_startblock + rmap->me_len -1 ))return false;return true;
PATCH 5/10 xfs: hoist recovered refcount intent checks out of xfs_cui_item_recover
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we recover a refcount intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
--- fs/xfs/xfs_refcount_item.c | 58 +++++++++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 23 deletions(-)
fs/xfs/xfs_refcount_item.c +35 -23
@@ -417,6 +417,38 @@ const struct xfs_defer_op_type xfs_refcount_update_defer_type = { .cancel_item = xfs_refcount_update_cancel_item, }; +/* Is this recovered CUI ok? */ +static inline bool +xfs_cui_validate_phys ( +struct xfs_mount *mp, +struct xfs_phys_extent *refc) +{ +xfs_fsblock_t startblock_fsb; +bool op_ok; + + startblock_fsb =XFS_BB_TO_FSB (mp, +XFS_FSB_TO_DADDR (mp, refc->pe_startblock)); +switch (refc->pe_flags &XFS_REFCOUNT_EXTENT_TYPE_MASK ) { +case XFS_REFCOUNT_INCREASE : +case XFS_REFCOUNT_DECREASE : +case XFS_REFCOUNT_ALLOC_COW : +case XFS_REFCOUNT_FREE_COW : + op_ok = true; +break ; +default : + op_ok = false; +break ; + } +if (!op_ok || startblock_fsb ==0 || + refc->pe_len ==0 || + startblock_fsb >= mp->m_sb.sb_dblocks || + refc->pe_len >= mp->m_sb.sb_agblocks || + (refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS )) +return false; + +return true; +} +/* * Process a refcount update intent item that was recovered from the log. * We need to update the refcountbt.
@@ -433,11 +465,9 @@ xfs_cui_item_recover(struct xfs_trans *tp;struct xfs_btree_cur *rcur =NULL ;struct xfs_mount *mp = lip->li_mountp; -xfs_fsblock_t startblock_fsb;xfs_fsblock_t new_fsb;xfs_extlen_t new_len;unsigned int refc_type; -bool op_ok;bool requeue_only = false;enum xfs_refcount_intent_type type;int i;
@@ -448,28 +478,10 @@ xfs_cui_item_recover(* CUI. If any are bad, then assume that all are bad and * just toss the CUI. */ -for (i =0 ; i < cuip->cui_format.cui_nextents; i++) { - refc = &cuip->cui_format.cui_extents[i]; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, refc->pe_startblock)); -switch (refc->pe_flags &XFS_REFCOUNT_EXTENT_TYPE_MASK ) { -case XFS_REFCOUNT_INCREASE : -case XFS_REFCOUNT_DECREASE : -case XFS_REFCOUNT_ALLOC_COW : -case XFS_REFCOUNT_FREE_COW : - op_ok = true; -break ; -default : - op_ok = false; -break ; - } -if (!op_ok || startblock_fsb ==0 || - refc->pe_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - refc->pe_len >= mp->m_sb.sb_agblocks || - (refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS )) +for (i =0 ; i < cuip->cui_format.cui_nextents; i++) +if (!xfs_cui_validate_phys (mp, + &cuip->cui_format.cui_extents[i]))return -EFSCORRUPTED ; - }/* * Under normal operation, refcount updates are deferred, so we
Re: [PATCH 05/10] xfs: hoist recovered refcount intent checks out of xfs_cui_item_recover
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When we recover a refcount intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,
PATCH 6/10 xfs: improve the code that checks recovered refcount intent items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The code that validates recovered refcount intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
--- fs/xfs/xfs_refcount_item.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
fs/xfs/xfs_refcount_item.c +12 -12
@@ -423,27 +423,27 @@ xfs_cui_validate_phys(struct xfs_mount *mp, struct xfs_phys_extent *refc) { - xfs_fsblock_t startblock_fsb; -bool op_ok; + xfs_fsblock_t end; + +if (refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS ) +return false; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, refc->pe_startblock));switch (refc->pe_flags &XFS_REFCOUNT_EXTENT_TYPE_MASK ) {case XFS_REFCOUNT_INCREASE :case XFS_REFCOUNT_DECREASE :case XFS_REFCOUNT_ALLOC_COW :case XFS_REFCOUNT_FREE_COW : - op_ok = true;break ;default : - op_ok = false; -break ; +return false; } -if (!op_ok || startblock_fsb ==0 || - refc->pe_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - refc->pe_len >= mp->m_sb.sb_agblocks || - (refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS )) + +if (refc->pe_startblock + refc->pe_len <= refc->pe_startblock) +return false; + + end = refc->pe_startblock + refc->pe_len -1 ; +if (!xfs_verify_fsbno (mp, refc->pe_startblock) || + !xfs_verify_fsbno (mp, end))return false;return true;
Re: [PATCH 06/10] xfs: improve the code that checks recovered refcount intent items
Looks good (minus the same nitpick as for the other one):
PATCH 7/10 xfs: hoist recovered extent-free intent checks out of xfs_efi_item_recover
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we recover a extent-free intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
--- fs/xfs/xfs_extfree_item.c | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-)
fs/xfs/xfs_extfree_item.c +21 -10
@@ -578,6 +578,25 @@ const struct xfs_defer_op_type xfs_agfl_free_defer_type = { .cancel_item = xfs_extent_free_cancel_item, }; +/* Is this recovered EFI ok? */ +static inline bool +xfs_efi_validate_ext ( +struct xfs_mount *mp, +struct xfs_extent *extp) +{ +xfs_fsblock_t startblock_fsb; + + startblock_fsb =XFS_BB_TO_FSB (mp, +XFS_FSB_TO_DADDR (mp, extp->ext_start)); +if (startblock_fsb ==0 || + extp->ext_len ==0 || + startblock_fsb >= mp->m_sb.sb_dblocks || + extp->ext_len >= mp->m_sb.sb_agblocks) +return false; + +return true; +} +/* * Process an extent free intent item that was recovered from * the log. We need to free the extents that it describes.
@@ -592,7 +611,6 @@ xfs_efi_item_recover(struct xfs_efd_log_item *efdp;struct xfs_trans *tp;struct xfs_extent *extp; -xfs_fsblock_t startblock_fsb;int i;int error =0 ;
@@ -601,16 +619,9 @@ xfs_efi_item_recover(* EFI. If any are bad, then assume that all are bad and * just toss the EFI. */ -for (i =0 ; i < efip->efi_format.efi_nextents; i++) { - extp = &efip->efi_format.efi_extents[i]; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, extp->ext_start)); -if (startblock_fsb ==0 || - extp->ext_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - extp->ext_len >= mp->m_sb.sb_agblocks) +for (i =0 ; i < efip->efi_format.efi_nextents; i++) +if (!xfs_efi_validate_ext (mp, &efip->efi_format.efi_extents[i]))return -EFSCORRUPTED ; - } error =xfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate,0 ,0 ,0 , &tp);if (error)
Re: [PATCH 07/10] xfs: hoist recovered extent-free intent checks out of xfs_efi_item_recover
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When we recover a extent-free intent from the log, we need to validate its contents before we try to replay them. Hoist the checking code into a separate function in preparation to refactor this code to use validation helpers.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,
PATCH 8/10 xfs: improve the code that checks recovered extent-free intent items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The code that validates recovered extent-free intent items is kind of a mess -- it doesn't use the standard xfs type validators, and it doesn't check for things that it should. Fix the validator function to use the standard validation helpers and look for more types of obvious errors.
--- fs/xfs/xfs_extfree_item.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
fs/xfs/xfs_extfree_item.c +7 -7
@@ -584,14 +584,14 @@ xfs_efi_validate_ext(struct xfs_mount *mp, struct xfs_extent *extp) { - xfs_fsblock_t startblock_fsb; + xfs_fsblock_t end; - startblock_fsb =XFS_BB_TO_FSB (mp, -XFS_FSB_TO_DADDR (mp, extp->ext_start)); -if (startblock_fsb ==0 || - extp->ext_len ==0 || - startblock_fsb >= mp->m_sb.sb_dblocks || - extp->ext_len >= mp->m_sb.sb_agblocks) +if (extp->ext_start + extp->ext_len <= extp->ext_start) +return false; + + end = extp->ext_start + extp->ext_len -1 ; +if (!xfs_verify_fsbno (mp, extp->ext_start) || + !xfs_verify_fsbno (mp, end))return false;return true;
Re: [PATCH 08/10] xfs: improve the code that checks recovered extent-free intent items
Looks good modulo the end nitpick:
PATCH 9/10 xfs: validate feature support when recovering rmap/refcount/bmap intents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The bmap, rmap, and refcount log intent items were added to support the rmap and reflink features. Because these features come with changes to the ondisk format, the log items aren't tied to a log incompat flags.
However, the log recovery routines don't actually check for those feature flags. The kernel has no business replayng an intent item for a feature that isn't enabled, so check that as part of recovered log item validation. (Note that kernels pre-dating rmap and reflink will fail the mount on the unknown log item type code.)
--- fs/xfs/xfs_bmap_item.c | 4 ++++ fs/xfs/xfs_refcount_item.c | 3 +++ fs/xfs/xfs_rmap_item.c | 3 +++ 3 files changed, 10 insertions(+)
fs/xfs/xfs_bmap_item.c +4 -0
@@ -426,6 +426,10 @@ xfs_bui_validate(struct xfs_map_extent *bmap;xfs_fsblock_t end; +if (!xfs_sb_version_hasrmapbt (&mp->m_sb) && + !xfs_sb_version_hasreflink (&mp->m_sb)) +return false; +/* Only one mapping operation per BUI... */ if (buip->bui_format.bui_nextents !=XFS_BUI_MAX_FAST_EXTENTS )return false;
fs/xfs/xfs_refcount_item.c +3 -0
@@ -425,6 +425,9 @@ xfs_cui_validate_phys( {xfs_fsblock_t end; +if (!xfs_sb_version_hasreflink (&mp->m_sb)) +return false; +if (refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS )return false;
fs/xfs/xfs_rmap_item.c +3 -0
@@ -468,6 +468,9 @@ xfs_rui_validate_map( {xfs_fsblock_t end; +if (!xfs_sb_version_hasrmapbt (&mp->m_sb)) +return false; +if (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS )return false;
Re: [PATCH 09/10] xfs: validate feature support when recovering rmap/refcount/bmap intents
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
The bmap, rmap, and refcount log intent items were added to support the rmap and reflink features. Because these features come with changes to the ondisk format, the log items aren't tied to a log incompat flags.
Quoted 7 lines
However, the log recovery routines don't actually check for those feature flags. The kernel has no business replayng an intent item for a feature that isn't enabled, so check that as part of recovered log item validation. (Note that kernels pre-dating rmap and reflink will fail the mount on the unknown log item type code.)
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,
PATCH 10/10 xfs: trace log intent item recovery failures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a trace point so that we can capture when a recovered log intent item fails to recover.
--- fs/xfs/xfs_log_recover.c | 5 ++++- fs/xfs/xfs_trace.h | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-)
fs/xfs/xfs_log_recover.c +4 -1
@@ -2559,8 +2559,11 @@ xlog_recover_process_intents(spin_unlock (&ailp->ail_lock); error = lip->li_ops->iop_recover (lip, &capture_list);spin_lock (&ailp->ail_lock); -if (error) +if (error) { +trace_xfs_error_return (log->l_mp, error, + lip->li_ops->iop_recover);break ; + } }xfs_trans_ail_cursor_done (&cur);
fs/xfs/xfs_trace.h +19 -0
@@ -103,6 +103,25 @@ DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound);DEFINE_ATTR_LIST_EVENT (xfs_attr_leaf_list);DEFINE_ATTR_LIST_EVENT (xfs_attr_node_list); +TRACE_EVENT (xfs_error_return, + TP_PROTO(struct xfs_mount *mp, int error, void *caller_ip), +TP_ARGS (mp, error, caller_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(int, error) + __field(void *, caller_ip) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->error = error; + __entry->caller_ip = caller_ip; + ), +TP_printk ("dev %d:%d error %d caller %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->error, __entry->caller_ip) + +); + DECLARE_EVENT_CLASS(xfs_perag_class, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int refcount, unsigned long caller_ip),
Re: [PATCH 10/10] xfs: trace log intent item recovery failures
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add a trace point so that we can capture when a recovered log intent item fails to recover.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good,