xfs: online repair, second part of part 1
Subsystems (2)
PATCH v27 1/1 xfs: online repair, second part of part 1
Hi everyone,
I've rebased the online fsck development branches atop 6.6, applied the changes requested during the review of v26, and reworked the automatic space reaping code to avoid open-coding EFI log item handling.
In other words, I'm formally submitting part 1 for inclusion in 6.7.
Just like the last review, I would like people to focus the following:
- Are the major subsystems sufficiently documented that you could figure out what the code does?
- Do you see any problems that are severe enough to cause long term support hassles? (e.g. bad API design, writing weird metadata to disk)
- Can you spot mis-interactions between the subsystems?
- What were my blind spots in devising this feature?
- Are there missing pieces that you'd like to help build?
- Can I just merge all of this?
The one thing that is /not/ in scope for this review are requests for more refactoring of existing subsystems. I'm still running QA round the clock. To spare vger, I'm only sending ~38 patches in this batch.
--D
cover xfs: prevent livelocks in xchk_iget
Hi all,
Prevent scrub from live locking in xchk_iget if there's a cycle in the inobt by allocating an empty transaction.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=scrub-livelock-prevention
--- fs/xfs/scrub/common.c | 6 ++++-- fs/xfs/scrub/common.h | 19 +++++++++++++++++++ fs/xfs/scrub/inode.c | 4 ++-- 3 files changed, 25 insertions(+), 4 deletions(-)
PATCH 1/1 xfs: make xchk_iget safer in the presence of corrupt inode btrees
From: Darrick J. Wong <[email protected]>
When scrub is trying to iget na inode, ensure that it won't end up deadlocked on a cycle in the inode btree by using an empty transaction to store all the buffers.
--- fs/xfs/scrub/common.c | 6 ++++-- fs/xfs/scrub/common.h | 19 +++++++++++++++++++ fs/xfs/scrub/inode.c | 4 ++-- 3 files changed, 25 insertions(+), 4 deletions(-)
fs/xfs/scrub/common.c +4 -2
@@ -733,6 +733,8 @@ xchk_iget(xfs_ino_t inum, struct xfs_inode **ipp) { + ASSERT(sc->tp != NULL); +return xfs_iget (sc->mp, sc->tp, inum,XFS_IGET_UNTRUSTED ,0 , ipp); }
@@ -882,8 +884,8 @@ xchk_iget_for_scrubbing(if (!xfs_verify_ino (sc->mp, sc->sm->sm_ino))return -ENOENT ; -/* Try a regular untrusted iget. */ - error =xchk_iget (sc, sc->sm->sm_ino, &ip); +/* Try a safe untrusted iget. */ + error =xchk_iget_safe (sc, sc->sm->sm_ino, &ip);if (!error)return xchk_install_handle_inode (sc, ip);if (error == -ENOENT )
fs/xfs/scrub/common.h +19 -0
@@ -157,6 +157,25 @@ int xchk_iget_agi(struct xfs_scrub *sc, xfs_ino_t inum,void xchk_irele (struct xfs_scrub *sc,struct xfs_inode *ip);int xchk_install_handle_inode (struct xfs_scrub *sc,struct xfs_inode *ip); +/* +* Safe version of (untrusted) xchk_iget that uses an empty transaction to +* avoid deadlocking on loops in the inobt. +*/ +static inline int +xchk_iget_safe (struct xfs_scrub *sc,xfs_ino_t inum,struct xfs_inode **ipp) +{ +int error; + +ASSERT (sc->tp ==NULL ); + + error =xchk_trans_alloc (sc,0 ); +if (error) +return error; + error =xchk_iget (sc, inum, ipp); +xchk_trans_cancel (sc); +return error; +} +/* * Don't bother cross-referencing if we already found corruption or cross * referencing discrepancies.
fs/xfs/scrub/inode.c +2 -2
@@ -94,8 +94,8 @@ xchk_setup_inode(if (!xfs_verify_ino (sc->mp, sc->sm->sm_ino))return -ENOENT ; -/* Try a regular untrusted iget. */ - error =xchk_iget (sc, sc->sm->sm_ino, &ip); +/* Try a safe untrusted iget. */ + error =xchk_iget_safe (sc, sc->sm->sm_ino, &ip);if (!error)return xchk_install_handle_iscrub (sc, ip);if (error == -ENOENT )
Re: [PATCH 1/1] xfs: make xchk_iget safer in the presence of corrupt inode btrees
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When scrub is trying to iget na inode, ensure that it won't end up deadlocked on a cycle in the inode btree by using an empty transaction to store all the buffers.
Quoted 6 lines
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/common.c | 6 ++++-- fs/xfs/scrub/common.h | 19 +++++++++++++++++++ fs/xfs/scrub/inode.c | 4 ++-- 3 files changed, 25 insertions(+), 4 deletions(-)
Looks reasonable.
Further question on loops in btrees because I can't remember if this case is handled: if the loop goes round and round the same level, how is that detected? i.e. how do we avoid recursion count overflows if we keep walking over the same sibling block pattern?
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 1/1] xfs: make xchk_iget safer in the presence of corrupt inode btrees
Quoted 14 lines · Dave Chinner
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When scrub is trying to iget na inode, ensure that it won't end up deadlocked on a cycle in the inode btree by using an empty transaction to store all the buffers.
Quoted 6 lines
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/common.c | 6 ++++-- fs/xfs/scrub/common.h | 19 +++++++++++++++++++ fs/xfs/scrub/inode.c | 4 ++-- 3 files changed, 25 insertions(+), 4 deletions(-)
Quoted 8 lines
Looks reasonable.
Reviewed-by Dave Chinner <[email protected]>Further question on loops in btrees because I can't remember if this case is handled: if the loop goes round and round the same level, how is that detected? i.e. how do we avoid recursion count overflows if we keep walking over the same sibling block pattern?
I think regular btree walks are partially vulnerable to loops in a btree level. A while back, you patched the self-referential case of a block that points back to itself, but there isn't any robust checking of loops such as:
A -> B -> A
Loops involving blocks from multiple levels are caught by checking whether the btree block level matches what we were expecting given the direction of travel.
AFAICT nobody's systematically fixed the problem for btree users that don't attach a transaction to the cursor. Without a transaction there's no central place to collect locked buffers, so the buffer cache will try to re-lock a buffer that the caller already locked. We've partially fixed this for GETFSMAP, but I think we're still missing that when reading the bmbt into memory and for looking things up in dir/attr btrees.
Scrub, however, protects itself from loops in the btree structure. The tree walking in scrub/btree.c finds sibling blocks by looking at the next pointer in the parent level. Each block's sibling pointers are easily checked, so it'll notice things like:
A
/ | \
B -> C -+ D
^-------+
When we load C, xchk_btree_block_check_sibling will notice that C.rightsib doesn't point at D. It'll set the CORRUPT flag, and return from the btree walk.
Scrub will also notice corruption like:
A
/ | \
B C B
by computing the keyspace covered by the records in each block and compares that to corresponding key in the parent. It also checks that the records of each level are in increasing order. Just in case B and C are both filled with the same record.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: reserve disk space for online repairs
In reply to Darrick J. WongHi all,
Online repair fixes metadata structures by writing a new copy out to disk and atomically committing the new structure into the filesystem. For this to work, we need to reserve all the space we're going to need ahead of time so that the atomic commit transaction is as small as possible. We also require the reserved space to be freed if the system goes down, or if we decide not to commit the repair, or if we reserve too much space.
To keep the atomic commit transaction as small as possible, we would like to allocate some space and simultaneously schedule automatic reaping of the reserved space, even on log recovery. EFIs are the mechanism to get us there, but we need to use them in a novel manner. Once we allocate the space, we want to hold on to the EFI (relogging as necessary) until we can commit or cancel the repair. EFIs for written committed blocks need to go away, but unwritten or uncommitted blocks can be freed like normal.
Earlier versions of this patchset directly manipulated the log items, but Dave thought that to be a layering violation. For v27, I've modified the defer ops handling code to be capable of pausing a deferred work item. Log intent items are created as they always have been, but paused items are pushed onto a side list when finishing deferred work items, and pushed back onto the transaction after that. Log intent done item are not created for paused work.
The second part adds a "stale" flag to the EFI so that the repair reservation code can dispose of an EFI the normal way, but without the space actually being freed.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-auto-reap-space-reservations
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-auto-reap-space-reservations
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.c | 2 fs/xfs/libxfs/xfs_alloc.c | 102 +++++++ fs/xfs/libxfs/xfs_alloc.h | 22 +- fs/xfs/libxfs/xfs_bmap.c | 4 fs/xfs/libxfs/xfs_bmap_btree.c | 2 fs/xfs/libxfs/xfs_btree_staging.h | 7 fs/xfs/libxfs/xfs_defer.c | 229 ++++++++++++++-- fs/xfs/libxfs/xfs_defer.h | 20 + fs/xfs/libxfs/xfs_ialloc.c | 5 fs/xfs/libxfs/xfs_ialloc_btree.c | 2 fs/xfs/libxfs/xfs_refcount.c | 6 fs/xfs/libxfs/xfs_refcount_btree.c | 2 fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 510 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 65 +++++ fs/xfs/scrub/reap.c | 7 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ fs/xfs/xfs_extfree_item.c | 13 + fs/xfs/xfs_reflink.c | 2 fs/xfs/xfs_trace.h | 13 + 23 files changed, 991 insertions(+), 64 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
PATCH 1/7 xfs: don't append work items to logged xfs_defer_pending objects
From: Darrick J. Wong <[email protected]>
When someone tries to add a deferred work item to xfs_defer_add, it will try to attach the work item to the most recently added xfs_defer_pending object attached to the transaction. However, it doesn't check if the pending object has a log intent item attached to it. This is incorrect behavior because we cannot add more work to an object that has already been committed to the ondisk log.
Therefore, change the behavior not to append to pending items with a non null dfp_intent. In practice this has not been an issue because the only way xfs_defer_add gets called after log intent items have been committed is from the defer ops ->finish_item functions themselves, and the @dop_pending isolation in xfs_defer_finish_noroll protects the pending items that have already been logged.
However, the next patch will add the ability to pause a deferred extent free object during online btree rebuilding, and any new extfree work items need to have their own pending event.
While we're at it, hoist the predicate to its own static inline function for readability.
--- fs/xfs/libxfs/xfs_defer.c | 48 ++++++++++++++++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 12 deletions(-)
fs/xfs/libxfs/xfs_defer.c +36 -12
@@ -617,6 +617,40 @@ xfs_defer_cancel(xfs_defer_cancel_list (mp, &tp->t_dfops); } +/* +* Decide if we can add a deferred work item to the last dfops item attached +* to the transaction. +*/ +static inline struct xfs_defer_pending * +xfs_defer_try_append ( +struct xfs_trans *tp, +enum xfs_defer_ops_type type, +const struct xfs_defer_op_type *ops) +{ +struct xfs_defer_pending *dfp =NULL ; + +/* No dfops at all? */ +if (list_empty (&tp->t_dfops)) +return NULL ; + + dfp = list_last_entry(&tp->t_dfops, struct xfs_defer_pending, + dfp_list); + +/* Wrong type? */ +if (dfp->dfp_type != type) +return NULL ; + +/* Already logged? */ +if (dfp->dfp_intent) +return NULL ; + +/* Already full? */ +if (ops->max_items && dfp->dfp_count >= ops->max_items) +return NULL ; + +return dfp; +} +/* Add an item for later deferred processing. */ void xfs_defer_add(
@@ -630,19 +664,9 @@ xfs_defer_add(ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES );BUILD_BUG_ON (ARRAY_SIZE (defer_op_types) !=XFS_DEFER_OPS_TYPE_MAX ); -/* -* Add the item to a pending item at the end of the intake list. -* If the last pending item has the same type, reuse it. Else, -* create a new pending item at the end of the intake list. -*/ -if (!list_empty (&tp->t_dfops)) { - dfp =list_last_entry (&tp->t_dfops, - struct xfs_defer_pending, dfp_list); -if (dfp->dfp_type != type || - (ops->max_items && dfp->dfp_count >= ops->max_items)) - dfp =NULL ; - } + dfp =xfs_defer_try_append (tp, type, ops);if (!dfp) { +/* Create a new pending item at the end of the intake list. */ dfp =kmem_cache_zalloc (xfs_defer_pending_cache,GFP_NOFS | __GFP_NOFAIL); dfp->dfp_type = type;
Re: [PATCH 1/7] xfs: don't append work items to logged xfs_defer_pending objects
Quoted 20 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When someone tries to add a deferred work item to
xfs_defer_add, it will try to attach the work item to the most recently addedxfs_defer_pendingobject attached to the transaction. However, it doesn't check if the pending object has a log intent item attached to it. This is incorrect behavior because we cannot add more work to an object that has already been committed to the ondisk log.Therefore, change the behavior not to append to pending items with a non null
dfp_intent. In practice this has not been an issue because the only wayxfs_defer_addgets called after log intent items have been committed is from the defer ops ->finish_item functions themselves, and the @dop_pending isolation inxfs_defer_finish_norollprotects the pending items that have already been logged.However, the next patch will add the ability to pause a deferred extent free object during online btree rebuilding, and any new extfree work items need to have their own pending event.
Quoted 7 lines
While we're at it, hoist the predicate to its own static inline function for readability.
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_defer.c | 48 ++++++++++++++++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 12 deletions(-)
Looks fine.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 2/7 xfs: allow pausing of pending deferred work items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Traditionally, all pending deferred work attached to a transaction is finished when one of the xfs_defer_finish* functions is called. However, online repair wants to be able to allocate space for a new data structure, format a new metadata structure into the allocated space, and commit that into the filesystem.
As a hedge against system crashes during repairs, we also want to log some EFI items for the allocated space speculatively, and cancel them if we elect to commit the new data structure.
Therefore, introduce the idea of pausing a pending deferred work item. Log intent items are still created for paused items and relogged as necessary. However, paused items are pushed onto a side list before we start calling ->finish_item, and the whole list is reattach to the transaction afterwards. New work items are never attached to paused pending items.
Modify xfs_defer_cancel to clean up pending deferred work items holding a log intent item but not a log intent done item, since that is now possible.
--- fs/xfs/libxfs/xfs_defer.c | 98 +++++++++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_defer.h | 17 +++++++- fs/xfs/xfs_trace.h | 13 +++++- 3 files changed, 112 insertions(+), 16 deletions(-)
fs/xfs/libxfs/xfs_defer.c +86 -12
@@ -410,7 +410,7 @@ xfs_defer_cancel_list(* done item to release the intent item; and then log a new intent item. * The caller should provide a fresh transaction and roll it after we're done. */ -static int +static void xfs_defer_relog (struct xfs_trans **tpp,struct list_head *dfops)
@@ -451,10 +451,6 @@ xfs_defer_relog(XFS_STATS_INC ((*tpp)->t_mountp, defer_relog); dfp->dfp_intent =xfs_trans_item_relog (dfp->dfp_intent, *tpp); } - -if ((*tpp)->t_flags &XFS_TRANS_DIRTY ) -return xfs_defer_trans_roll (tpp); -return 0 ; }/*
@@ -510,6 +506,24 @@ xfs_defer_finish_one(return error; } +/* Move all paused deferred work from @tp to @paused_list. */ +static void +xfs_defer_isolate_paused ( +struct xfs_trans *tp, +struct list_head *paused_list) +{ +struct xfs_defer_pending *dfp; +struct xfs_defer_pending *pli; + +list_for_each_entry_safe (dfp, pli, &tp->t_dfops, dfp_list) { +if (!(dfp->dfp_flags &XFS_DEFER_PAUSED )) +continue ; + +list_move_tail (&dfp->dfp_list, paused_list); +trace_xfs_defer_isolate_paused (tp->t_mountp, dfp); + } +} +/* * Finish all the pending work. This involves logging intent items for * any work items that wandered in since the last transaction roll (if
@@ -525,6 +539,7 @@ xfs_defer_finish_noroll(struct xfs_defer_pending *dfp =NULL ;int error =0 ;LIST_HEAD (dop_pending); +LIST_HEAD (dop_paused);ASSERT ((*tp)->t_flags &XFS_TRANS_PERM_LOG_RES );
@@ -543,6 +558,8 @@ xfs_defer_finish_noroll(*/ int has_intents =xfs_defer_create_intents (*tp); +xfs_defer_isolate_paused (*tp, &dop_paused); +list_splice_init (&(*tp)->t_dfops, &dop_pending);if (has_intents <0 ) {
@@ -555,22 +572,33 @@ xfs_defer_finish_noroll( goto out_shutdown;/* Relog intent items to keep the log moving. */ - error =xfs_defer_relog (tp, &dop_pending); -if (error) - goto out_shutdown; +xfs_defer_relog (tp, &dop_pending); +xfs_defer_relog (tp, &dop_paused); + +if ((*tp)->t_flags &XFS_TRANS_DIRTY ) { + error =xfs_defer_trans_roll (tp); +if (error) + goto out_shutdown; + } } - dfp = list_first_entry(&dop_pending, struct xfs_defer_pending, - dfp_list); + dfp =list_first_entry_or_null (&dop_pending, + struct xfs_defer_pending, dfp_list); +if (!dfp) +break ; error =xfs_defer_finish_one (*tp, dfp);if (error && error != -EAGAIN ) goto out_shutdown; } +/* Requeue the paused items in the outgoing transaction. */ +list_splice_tail_init (&dop_paused, &(*tp)->t_dfops); +trace_xfs_defer_finish_done (*tp, _RET_IP_);return 0 ; out_shutdown: +list_splice_tail_init (&dop_paused, &dop_pending);xfs_defer_trans_abort (*tp, &dop_pending);xfs_force_shutdown ((*tp)->t_mountp,SHUTDOWN_CORRUPT_INCORE );trace_xfs_defer_finish_error (*tp, error);
@@ -583,6 +611,9 @@ intxfs_defer_finish ( struct xfs_trans **tp) { +#ifdef DEBUG +struct xfs_defer_pending *dfp; +#endif int error;/*
@@ -602,7 +633,10 @@ xfs_defer_finish( }/* Reset LOWMODE now that we've finished all the dfops. */ -ASSERT (list_empty (&(*tp)->t_dfops)); +#ifdef DEBUG +list_for_each_entry (dfp, &(*tp)->t_dfops, dfp_list) +ASSERT (dfp->dfp_flags &XFS_DEFER_PAUSED ); +#endif (*tp)->t_flags &= ~XFS_TRANS_LOWMODE ;return 0 ; }
@@ -614,6 +648,7 @@ xfs_defer_cancel(struct xfs_mount *mp = tp->t_mountp;trace_xfs_defer_cancel (tp, _RET_IP_); +xfs_defer_trans_abort (tp, &tp->t_dfops);xfs_defer_cancel_list (mp, &tp->t_dfops); }
@@ -644,6 +679,10 @@ xfs_defer_try_append(if (dfp->dfp_intent)return NULL ; +/* Paused items cannot absorb more work */ +if (dfp->dfp_flags &XFS_DEFER_PAUSED ) +return NULL ; +/* Already full? */ if (ops->max_items && dfp->dfp_count >= ops->max_items)return NULL ;
@@ -652,7 +691,7 @@ xfs_defer_try_append( }/* Add an item for later deferred processing. */ -void +struct xfs_defer_pending * xfs_defer_add( struct xfs_trans *tp, enum xfs_defer_ops_type type,
@@ -680,6 +719,8 @@ xfs_defer_add(list_add_tail (li, &dfp->dfp_work);trace_xfs_defer_add_item (tp->t_mountp, dfp, li); dfp->dfp_count++; + +return dfp; }/*
@@ -954,3 +995,36 @@ xfs_defer_destroy_item_caches(void)xfs_rmap_intent_destroy_cache ();xfs_defer_destroy_cache (); } + +/* +* Mark a deferred work item so that it will be requeued indefinitely without +* being finished. Caller must ensure there are no data dependencies on this +* work item in the meantime. +*/ +void +xfs_defer_item_pause ( +struct xfs_trans *tp, +struct xfs_defer_pending *dfp) +{ +ASSERT (!(dfp->dfp_flags &XFS_DEFER_PAUSED )); + + dfp->dfp_flags |=XFS_DEFER_PAUSED ; + +trace_xfs_defer_item_pause (tp->t_mountp, dfp); +} + +/* +* Release a paused deferred work item so that it will be finished during the +* next transaction roll. +*/ +void +xfs_defer_item_unpause ( +struct xfs_trans *tp, +struct xfs_defer_pending *dfp) +{ +ASSERT (dfp->dfp_flags &XFS_DEFER_PAUSED ); + + dfp->dfp_flags &= ~XFS_DEFER_PAUSED ; + +trace_xfs_defer_item_unpause (tp->t_mountp, dfp); +}
fs/xfs/libxfs/xfs_defer.h +15 -2
@@ -34,11 +34,24 @@ struct xfs_defer_pending {struct xfs_log_item *dfp_intent;/* log intent item */ struct xfs_log_item *dfp_done;/* log done item */ unsigned int dfp_count;/* # extent items */ +unsigned int dfp_flags;enum xfs_defer_ops_type dfp_type; }; -void xfs_defer_add (struct xfs_trans *tp,enum xfs_defer_ops_type type, -struct list_head *h); +/* +* Create a log intent item for this deferred item, but don't actually finish +* the work. Caller must clear this before the final transaction commit. +*/ +#define XFS_DEFER_PAUSED (1U << 0) + +#define XFS_DEFER_PENDING_STRINGS \ + { XFS_DEFER_PAUSED, "paused" } + +void xfs_defer_item_pause (struct xfs_trans *tp,struct xfs_defer_pending *dfp); +void xfs_defer_item_unpause (struct xfs_trans *tp,struct xfs_defer_pending *dfp); + +struct xfs_defer_pending *xfs_defer_add (struct xfs_trans *tp, +enum xfs_defer_ops_type type,struct list_head *h);int xfs_defer_finish_noroll (struct xfs_trans **tp);int xfs_defer_finish (struct xfs_trans **tp);void xfs_defer_cancel (struct xfs_trans *);
fs/xfs/xfs_trace.h +11 -2
@@ -2551,6 +2551,7 @@ DECLARE_EVENT_CLASS(xfs_defer_pending_class, __field(dev_t, dev) __field(int, type) __field(void *, intent) + __field(unsigned int, flags) __field(char, committed) __field(int, nr) ),
@@ -2558,13 +2559,15 @@ DECLARE_EVENT_CLASS(xfs_defer_pending_class, __entry->dev = mp ? mp->m_super->s_dev :0 ; __entry->type = dfp->dfp_type; __entry->intent = dfp->dfp_intent; + __entry->flags = dfp->dfp_flags; __entry->committed = dfp->dfp_done !=NULL ; __entry->nr = dfp->dfp_count; ), -TP_printk ("dev %d:%d optype %d intent %p committed %d nr %d" , +TP_printk ("dev %d:%d optype %d intent %p flags %s committed %d nr %d" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->type, __entry->intent, +__print_flags (__entry->flags,"|" ,XFS_DEFER_PENDING_STRINGS ), __entry->committed, __entry->nr) )
@@ -2675,6 +2678,9 @@ DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list);DEFINE_DEFER_PENDING_EVENT (xfs_defer_pending_finish);DEFINE_DEFER_PENDING_EVENT (xfs_defer_pending_abort);DEFINE_DEFER_PENDING_EVENT (xfs_defer_relog_intent); +DEFINE_DEFER_PENDING_EVENT (xfs_defer_isolate_paused); +DEFINE_DEFER_PENDING_EVENT (xfs_defer_item_pause); +DEFINE_DEFER_PENDING_EVENT (xfs_defer_item_unpause);#define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENTDEFINE_BMAP_FREE_DEFERRED_EVENT (xfs_bmap_free_defer);
@@ -2692,6 +2698,7 @@ DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, __field(void *, intent) __field(void *, item) __field(char, committed) + __field(unsigned int, flags) __field(int, nr) ), TP_fast_assign(
@@ -2700,13 +2707,15 @@ DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, __entry->intent = dfp->dfp_intent; __entry->item = item; __entry->committed = dfp->dfp_done !=NULL ; + __entry->flags = dfp->dfp_flags; __entry->nr = dfp->dfp_count; ), -TP_printk ("dev %d:%d optype %d intent %p item %p committed %d nr %d" , +TP_printk ("dev %d:%d optype %d intent %p item %p flags %s committed %d nr %d" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->type, __entry->intent, __entry->item, +__print_flags (__entry->flags,"|" ,XFS_DEFER_PENDING_STRINGS ), __entry->committed, __entry->nr) )
Re: [PATCH 2/7] xfs: allow pausing of pending deferred work items
Quoted 23 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Traditionally, all pending deferred work attached to a transaction is finished when one of the xfs_defer_finish* functions is called. However, online repair wants to be able to allocate space for a new data structure, format a new metadata structure into the allocated space, and commit that into the filesystem.
As a hedge against system crashes during repairs, we also want to log some EFI items for the allocated space speculatively, and cancel them if we elect to commit the new data structure.
Therefore, introduce the idea of pausing a pending deferred work item. Log intent items are still created for paused items and relogged as necessary. However, paused items are pushed onto a side list before we start calling ->finish_item, and the whole list is reattach to the transaction afterwards. New work items are never attached to paused pending items.
Modify
xfs_defer_cancelto clean up pending deferred work items holding a log intent item but not a log intent done item, since that is now possible.
Quoted 6 lines
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_defer.c | 98 +++++++++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_defer.h | 17 +++++++- fs/xfs/xfs_trace.h | 13 +++++- 3 files changed, 112 insertions(+), 16 deletions(-)
Not 100% certain how this will be used, but the mechanism itself looks fine.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 3/7 xfs: remove __xfs_free_extent_later
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
xfs_free_extent_later is a trivial helper, so remove it to reduce the amount of thinking required to understand the deferred freeing interface. This will make it easier to introduce automatic reaping of speculative allocations in the next patch.
--- fs/xfs/libxfs/xfs_ag.c | 2 +- fs/xfs/libxfs/xfs_alloc.c | 2 +- fs/xfs/libxfs/xfs_alloc.h | 14 +------------- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- fs/xfs/libxfs/xfs_bmap_btree.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 5 +++-- fs/xfs/libxfs/xfs_ialloc_btree.c | 2 +- fs/xfs/libxfs/xfs_refcount.c | 6 +++--- fs/xfs/libxfs/xfs_refcount_btree.c | 2 +- fs/xfs/scrub/reap.c | 2 +- fs/xfs/xfs_extfree_item.c | 2 +- fs/xfs/xfs_reflink.c | 2 +- 12 files changed, 17 insertions(+), 28 deletions(-)
fs/xfs/libxfs/xfs_ag.c +1 -1
@@ -984,7 +984,7 @@ xfs_ag_shrink_space(if (err2 != -ENOSPC ) goto resv_err; - err2 =__xfs_free_extent_later (*tpp, args.fsbno, delta,NULL , + err2 =xfs_free_extent_later (*tpp, args.fsbno, delta,NULL ,XFS_AG_RESV_NONE , true);if (err2) goto resv_err;
fs/xfs/libxfs/xfs_alloc.c +1 -1
@@ -2502,7 +2502,7 @@ xfs_defer_agfl_block(* The list is maintained sorted (by block number). */ int -__xfs_free_extent_later( +xfs_free_extent_later( struct xfs_trans *tp, xfs_fsblock_t bno, xfs_filblks_t len,
fs/xfs/libxfs/xfs_alloc.h +1 -13
@@ -231,7 +231,7 @@ xfs_buf_to_agfl_bno(return bp->b_addr; } -int __xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno, +int xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type,bool skip_discard);
@@ -256,18 +256,6 @@ void xfs_extent_free_get_group(struct xfs_mount *mp,#define XFS_EFI_ATTR_FORK (1U << 1)/* freeing attr fork block */ #define XFS_EFI_BMBT_BLOCK (1U << 2)/* freeing bmap btree block */ -static inline int -xfs_free_extent_later ( -struct xfs_trans *tp, -xfs_fsblock_t bno, -xfs_filblks_t len, -const struct xfs_owner_info *oinfo, -enum xfs_ag_resv_type type) -{ -return __xfs_free_extent_later (tp, bno, len, oinfo, type, false); -} - -extern struct kmem_cache *xfs_extfree_item_cache;int __init xfs_extfree_intent_init_cache (void );
fs/xfs/libxfs/xfs_bmap.c +2 -2
@@ -575,7 +575,7 @@ xfs_bmap_btree_to_extents(xfs_rmap_ino_bmbt_owner (&oinfo, ip->i_ino, whichfork); error =xfs_free_extent_later (cur->bc_tp, cbno,1 , &oinfo, -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error)return error;
@@ -5235,7 +5235,7 @@ xfs_bmap_del_extent_real(if (xfs_is_reflink_inode (ip) && whichfork ==XFS_DATA_FORK ) {xfs_refcount_decrease_extent (tp, del); }else { - error = __xfs_free_extent_later(tp, del->br_startblock, + error = xfs_free_extent_later(tp, del->br_startblock, del->br_blockcount, NULL, XFS_AG_RESV_NONE, ((bflags & XFS_BMAPI_NODISCARD) ||
fs/xfs/libxfs/xfs_bmap_btree.c +1 -1
@@ -272,7 +272,7 @@ xfs_bmbt_free_block(xfs_rmap_ino_bmbt_owner (&oinfo, ip->i_ino, cur->bc_ino.whichfork); error =xfs_free_extent_later (cur->bc_tp, fsbno,1 , &oinfo, -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error)return error;
fs/xfs/libxfs/xfs_ialloc.c +3 -2
@@ -1854,7 +1854,7 @@ xfs_difree_inode_chunk(return xfs_free_extent_later (tp,XFS_AGB_TO_FSB (mp, agno, sagbno),M_IGEO (mp)->ialloc_blks, &XFS_RMAP_OINFO_INODES , -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false); }/* holemask is only 16-bits (fits in an unsigned long) */
@@ -1900,7 +1900,8 @@ xfs_difree_inode_chunk(ASSERT (contigblk % mp->m_sb.sb_spino_align ==0 ); error =xfs_free_extent_later (tp,XFS_AGB_TO_FSB (mp, agno, agbno), contigblk, - &XFS_RMAP_OINFO_INODES ,XFS_AG_RESV_NONE ); + &XFS_RMAP_OINFO_INODES ,XFS_AG_RESV_NONE , + false);if (error)return error;
fs/xfs/libxfs/xfs_ialloc_btree.c +1 -1
@@ -161,7 +161,7 @@ __xfs_inobt_free_block(xfs_inobt_mod_blockcount (cur,-1 ); fsbno =XFS_DADDR_TO_FSB (cur->bc_mp,xfs_buf_daddr (bp));return xfs_free_extent_later (cur->bc_tp, fsbno,1 , - &XFS_RMAP_OINFO_INOBT , resv); + &XFS_RMAP_OINFO_INOBT , resv, false); }STATIC int
fs/xfs/libxfs/xfs_refcount.c +3 -3
@@ -1153,7 +1153,7 @@ xfs_refcount_adjust_extents( tmp.rc_startblock); error =xfs_free_extent_later (cur->bc_tp, fsbno, tmp.rc_blockcount,NULL , -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error) goto out_error; }
@@ -1215,7 +1215,7 @@ xfs_refcount_adjust_extents( ext.rc_startblock); error =xfs_free_extent_later (cur->bc_tp, fsbno, ext.rc_blockcount,NULL , -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error) goto out_error; }
@@ -1985,7 +1985,7 @@ xfs_refcount_recover_cow_leftovers(/* Free the block. */ error =xfs_free_extent_later (tp, fsb, rr->rr_rrec.rc_blockcount,NULL , -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error) goto out_trans;
fs/xfs/libxfs/xfs_refcount_btree.c +1 -1
@@ -112,7 +112,7 @@ xfs_refcountbt_free_block(be32_add_cpu (&agf->agf_refcount_blocks,-1 );xfs_alloc_log_agf (cur->bc_tp, agbp,XFS_AGF_REFCOUNT_BLOCKS );return xfs_free_extent_later (cur->bc_tp, fsbno,1 , - &XFS_RMAP_OINFO_REFC ,XFS_AG_RESV_METADATA ); + &XFS_RMAP_OINFO_REFC ,XFS_AG_RESV_METADATA , false); }STATIC int
fs/xfs/scrub/reap.c +1 -1
@@ -410,7 +410,7 @@ xreap_agextent_iter(* Use deferred frees to get rid of the old btree blocks to try to * minimize the window in which we could crash and lose the old blocks. */ - error =__xfs_free_extent_later (sc->tp, fsbno, *aglenp, rs->oinfo, + error =xfs_free_extent_later (sc->tp, fsbno, *aglenp, rs->oinfo, rs->resv, true);if (error)return error;
fs/xfs/xfs_extfree_item.c +1 -1
@@ -717,7 +717,7 @@ xfs_efi_item_recover( error =xfs_free_extent_later (tp, fake.xefi_startblock, fake.xefi_blockcount, &XFS_RMAP_OINFO_ANY_OWNER , - fake.xefi_agresv); + fake.xefi_agresv, false);if (!error) { requeue_only = true;continue ;
fs/xfs/xfs_reflink.c +1 -1
@@ -618,7 +618,7 @@ xfs_reflink_cancel_cow_blocks( error =xfs_free_extent_later (*tpp, del.br_startblock, del.br_blockcount,NULL , -XFS_AG_RESV_NONE ); +XFS_AG_RESV_NONE , false);if (error)break ;
Re: [PATCH 3/7] xfs: remove __xfs_free_extent_later
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
xfs_free_extent_lateris a trivial helper, so remove it to reduce the amount of thinking required to understand the deferred freeing interface. This will make it easier to introduce automatic reaping of speculative allocations in the next patch.Signed-off-by Darrick J. Wong <[email protected]>
Quoted 14 lines
--- fs/xfs/libxfs/xfs_ag.c | 2 +- fs/xfs/libxfs/xfs_alloc.c | 2 +- fs/xfs/libxfs/xfs_alloc.h | 14 +------------- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- fs/xfs/libxfs/xfs_bmap_btree.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 5 +++-- fs/xfs/libxfs/xfs_ialloc_btree.c | 2 +- fs/xfs/libxfs/xfs_refcount.c | 6 +++--- fs/xfs/libxfs/xfs_refcount_btree.c | 2 +- fs/xfs/scrub/reap.c | 2 +- fs/xfs/xfs_extfree_item.c | 2 +- fs/xfs/xfs_reflink.c | 2 +- 12 files changed, 17 insertions(+), 28 deletions(-)
Ok.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 4/7 xfs: automatic freeing of freshly allocated unwritten space
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
As mentioned in the previous commit, online repair wants to allocate space to write out a new metadata structure, and it also wants to hedge against system crashes during repairs by logging (and later cancelling) EFIs to free the space if we crash before committing the new data structure.
Therefore, create a trio of functions to schedule automatic reaping of freshly allocated unwritten space. xfs_alloc_schedule_autoreap creates a paused EFI representing the space we just allocated. Once the allocations are made and the autoreaps scheduled, we can start writing to disk.
If the writes succeed, xfs_alloc_cancel_autoreap marks the EFI work items as stale and unpauses the pending deferred work item. Assuming that's done in the same transaction that commits the new structure into the filesystem, we guarantee that either the new object is fully visible, or that all the space gets reclaimed.
If the writes succeed but only part of an extent was used, repair must call the same _cancel_autoreap function to kill the first EFI and then log a new EFI to free the unused space. The first EFI is already committed, so it cannot be changed.
For full extents that aren't used, xfs_alloc_commit_autoreap will unpause the EFI, which results in the space being freed during the next _defer_finish cycle.
--- fs/xfs/libxfs/xfs_alloc.c | 104 +++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_alloc.h | 12 +++++ fs/xfs/xfs_extfree_item.c | 11 +++-- 3 files changed, 120 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +100 -4
@@ -2501,14 +2501,15 @@ xfs_defer_agfl_block(* Add the extent to the list of extents to be free at transaction end. * The list is maintained sorted (by block number). */ -int -xfs_free_extent_later ( +static int +__xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type, -bool skip_discard) +bool skip_discard, +struct xfs_defer_pending **dfpp) {struct xfs_extent_free_item *xefi;struct xfs_mount *mp = tp->t_mountp;
@@ -2556,10 +2557,105 @@ xfs_free_extent_later( XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);xfs_extent_free_get_group (mp, xefi); -xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list); + *dfpp =xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list);return 0 ; } +int +xfs_free_extent_later ( +struct xfs_trans *tp, +xfs_fsblock_t bno, +xfs_filblks_t len, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type, +bool skip_discard) +{ +struct xfs_defer_pending *dontcare =NULL ; + +return __xfs_free_extent_later (tp, bno, len, oinfo, type, skip_discard, + &dontcare); +} + +/* +* Set up automatic freeing of unwritten space in the filesystem. +* +* This function attached a paused deferred extent free item to the +* transaction. Pausing means that the EFI will be logged in the next +* transaction commit, but the pending EFI will not be finished until the +* pending item is unpaused. +* +* If the system goes down after the EFI has been persisted to the log but +* before the pending item is unpaused, log recovery will find the EFI, fail to +* find the EFD, and free the space. +* +* If the pending item is unpaused, the next transaction commit will log an EFD +* without freeing the space. +* +* Caller must ensure that the tp, fsbno, len, oinfo, and resv flags of the +* @args structure are set to the relevant values. +*/ +int +xfs_alloc_schedule_autoreap ( +const struct xfs_alloc_arg *args, +bool skip_discard, +struct xfs_alloc_autoreap *aarp) +{ +int error; + + error =__xfs_free_extent_later (args->tp, args->fsbno, args->len, + &args->oinfo, args->resv, skip_discard, &aarp->dfp); +if (error) +return error; + +xfs_defer_item_pause (args->tp, aarp->dfp); +return 0 ; +} + +/* +* Cancel automatic freeing of unwritten space in the filesystem. +* +* Earlier, we created a paused deferred extent free item and attached it to +* this transaction so that we could automatically roll back a new space +* allocation if the system went down. Now we want to cancel the paused work +* item by marking the EFI stale so we don't actually free the space, unpausing +* the pending item and logging an EFD. +* +* The caller generally should have already mapped the space into the ondisk +* filesystem. If the reserved space was partially used, the caller must call +* xfs_free_extent_later to create a new EFI to free the unused space. +*/ +void +xfs_alloc_cancel_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +struct xfs_defer_pending *dfp = aarp->dfp; +struct xfs_extent_free_item *xefi; + +if (!dfp) +return ; + +list_for_each_entry (xefi, &dfp->dfp_work, xefi_list) + xefi->xefi_flags |=XFS_EFI_STALE ; + +xfs_defer_item_unpause (tp, dfp); +} + +/* +* Commit automatic freeing of unwritten space in the filesystem. +* +* This unpauses an earlier _schedule_autoreap and commits to freeing the +* allocated space. Call this if none of the reserved space was used. +*/ +void +xfs_alloc_commit_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +if (aarp->dfp) +xfs_defer_item_unpause (tp, aarp->dfp); +} +#ifdef DEBUG /* * Check if an AGF has a free extent record whose length is equal to
fs/xfs/libxfs/xfs_alloc.h +12 -0
@@ -255,6 +255,18 @@ void xfs_extent_free_get_group(struct xfs_mount *mp,#define XFS_EFI_SKIP_DISCARD (1U << 0)/* don't issue discard */ #define XFS_EFI_ATTR_FORK (1U << 1)/* freeing attr fork block */ #define XFS_EFI_BMBT_BLOCK (1U << 2)/* freeing bmap btree block */ +#define XFS_EFI_STALE (1U << 3)/* dont actually free the space */ + +struct xfs_alloc_autoreap { +struct xfs_defer_pending *dfp; +}; + +int xfs_alloc_schedule_autoreap (const struct xfs_alloc_arg *args, +bool skip_discard,struct xfs_alloc_autoreap *aarp); +void xfs_alloc_cancel_autoreap (struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp); +void xfs_alloc_commit_autoreap (struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp);extern struct kmem_cache *xfs_extfree_item_cache;
fs/xfs/xfs_extfree_item.c +8 -3
@@ -392,9 +392,14 @@ xfs_trans_free_extent(trace_xfs_bmap_free_deferred (tp->t_mountp, xefi->xefi_pag->pag_agno,0 , agbno, xefi->xefi_blockcount); - error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, - xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, - xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); +if (xefi->xefi_flags &XFS_EFI_STALE ) { + error =0 ; + }else { + error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, + xefi->xefi_blockcount, &oinfo, + xefi->xefi_agresv, + xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); + }/* * Mark the transaction dirty, even on error. This ensures the
Re: [PATCH 4/7] xfs: automatic freeing of freshly allocated unwritten space
Quoted 47 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
As mentioned in the previous commit, online repair wants to allocate space to write out a new metadata structure, and it also wants to hedge against system crashes during repairs by logging (and later cancelling) EFIs to free the space if we crash before committing the new data structure.
Therefore, create a trio of functions to schedule automatic reaping of freshly allocated unwritten space.
xfs_alloc_schedule_autoreapcreates a paused EFI representing the space we just allocated. Once the allocations are made and the autoreaps scheduled, we can start writing to disk.If the writes succeed,
xfs_alloc_cancel_autoreapmarks the EFI work items as stale and unpauses the pending deferred work item. Assuming that's done in the same transaction that commits the new structure into the filesystem, we guarantee that either the new object is fully visible, or that all the space gets reclaimed.If the writes succeed but only part of an extent was used, repair must call the same
_cancel_autoreapfunction to kill the first EFI and then log a new EFI to free the unused space. The first EFI is already committed, so it cannot be changed.For full extents that aren't used,
xfs_alloc_commit_autoreapwill unpause the EFI, which results in the space being freed during the next_defer_finishcycle.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 104 +++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_alloc.h | 12 +++++ fs/xfs/xfs_extfree_item.c | 11 +++-- 3 files changed, 120 insertions(+), 7 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-2@@ -2501,14 +2501,15 @@ xfs_defer_agfl_block(* Add the extent to the list of extents to be free at transaction end. * The list is maintained sorted (by block number). */ -int -xfs_free_extent_later(
fs/xfs/libxfs/xfs_alloc.c xfs_defer_agfl_block( · line 2512
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +4
-1+static int +__xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type, - bool skip_discard) +bool skip_discard, +struct xfs_defer_pending **dfpp)
I was happy that __xfs_free_extent_later() went away in the last patch.
I am sad that it has immediately come back....
Can we please name this after what it does? Sayxfs_defer_extent_free()?
Quoted 51 lines
fs/xfs/libxfs/xfs_alloc.c +40
-1{struct xfs_extent_free_item *xefi;struct xfs_mount *mp = tp->t_mountp;@@ -2556,10 +2557,105 @@ xfs_free_extent_later( XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);xfs_extent_free_get_group (mp, xefi); -xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list); + *dfpp =xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list);return 0 ; } +int +xfs_free_extent_later ( +struct xfs_trans *tp, +xfs_fsblock_t bno, +xfs_filblks_t len, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type, +bool skip_discard) +{ +struct xfs_defer_pending *dontcare =NULL ; + +return __xfs_free_extent_later (tp, bno, len, oinfo, type, skip_discard, + &dontcare); +} + +/* +* Set up automatic freeing of unwritten space in the filesystem. +* +* This function attached a paused deferred extent free item to the +* transaction. Pausing means that the EFI will be logged in the next +* transaction commit, but the pending EFI will not be finished until the +* pending item is unpaused. +* +* If the system goes down after the EFI has been persisted to the log but +* before the pending item is unpaused, log recovery will find the EFI, fail to +* find the EFD, and free the space. +* +* If the pending item is unpaused, the next transaction commit will log an EFD +* without freeing the space. +* +* Caller must ensure that the tp, fsbno, len, oinfo, and resv flags of the +* @args structure are set to the relevant values. +*/ +int +xfs_alloc_schedule_autoreap ( +const struct xfs_alloc_arg *args, +bool skip_discard, +struct xfs_alloc_autoreap *aarp) +{
fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2612
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +10
-0+int error; + + error =__xfs_free_extent_later (args->tp, args->fsbno, args->len, + &args->oinfo, args->resv, skip_discard, &aarp->dfp); +if (error) +return error; + +xfs_defer_item_pause (args->tp, aarp->dfp); +return 0 ; +}
Then this becomes much more readable - xfs_defer_free_extent() returns the defer_pending work item for the EFI, which we then immediately pause....
Quoted 20 lines
fs/xfs/libxfs/xfs_alloc.c +20
-0+ +/* +* Cancel automatic freeing of unwritten space in the filesystem. +* +* Earlier, we created a paused deferred extent free item and attached it to +* this transaction so that we could automatically roll back a new space +* allocation if the system went down. Now we want to cancel the paused work +* item by marking the EFI stale so we don't actually free the space, unpausing +* the pending item and logging an EFD. +* +* The caller generally should have already mapped the space into the ondisk +* filesystem. If the reserved space was partially used, the caller must call +* xfs_free_extent_later to create a new EFI to free the unused space. +*/ +void +xfs_alloc_cancel_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +struct xfs_defer_pending *dfp = aarp->dfp;
fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2642
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +10
-0+struct xfs_extent_free_item *xefi; + +if (!dfp) +return ; + +list_for_each_entry (xefi, &dfp->dfp_work, xefi_list) + xefi->xefi_flags |=XFS_EFI_STALE ; + +xfs_defer_item_unpause (tp, dfp); +}
Hmmmm. I see what you are trying to do here, though I'm not sure that "stale" is the right word to describe it. The EFI has been cancelled, so we want and EFD to be logged without freeing the extent.
To me, "stale" means "contents longer valid, do not touch" as per XFS_ISTALE, xfs_buf_stale(), etc
Whereas we use "cancelled" to indicate that the pending operations on the buffer should not be actioned, such as XFS_BLF_CANCEL buffer items in log recovery to indicate the buffer has been freed and while it is cancelled we should not replay the changes found in the log for that buffer....
Hence I think this is better named XFS_EFI_CANCELLED, and it also matches what the calling function is doing - cancelling the autoreap of the extent....
Quoted 9 lines
fs/xfs/xfs_extfree_item.c +0
-1@@ -392,9 +392,14 @@ xfs_trans_free_extent(trace_xfs_bmap_free_deferred (tp->t_mountp, xefi->xefi_pag->pag_agno,0 , agbno, xefi->xefi_blockcount); - error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,
fs/xfs/xfs_extfree_item.c xfs_trans_free_extent( · line 402
Quoted 10 lines
fs/xfs/xfs_extfree_item.c +8
-2- xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, - xefi->xefi_flags & XFS_EFI_SKIP_DISCARD); +if (xefi->xefi_flags &XFS_EFI_STALE ) { + error =0 ; + }else { + error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, + xefi->xefi_blockcount, &oinfo, + xefi->xefi_agresv, + xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); + }
Just init error to 0 when it is declared, then this becomes:
if (!(xefi->xefi_flags & XFS_EFI_CANCELLED)) {
error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,
xefi->xefi_blockcount, &oinfo,
xefi->xefi_agresv,
xefi->xefi_flags & XFS_EFI_SKIP_DISCARD);
}Otherwise the code looks ok.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 4/7] xfs: automatic freeing of freshly allocated unwritten space
Quoted 62 lines · Dave Chinner
Quoted 47 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
As mentioned in the previous commit, online repair wants to allocate space to write out a new metadata structure, and it also wants to hedge against system crashes during repairs by logging (and later cancelling) EFIs to free the space if we crash before committing the new data structure.
Therefore, create a trio of functions to schedule automatic reaping of freshly allocated unwritten space.
xfs_alloc_schedule_autoreapcreates a paused EFI representing the space we just allocated. Once the allocations are made and the autoreaps scheduled, we can start writing to disk.If the writes succeed,
xfs_alloc_cancel_autoreapmarks the EFI work items as stale and unpauses the pending deferred work item. Assuming that's done in the same transaction that commits the new structure into the filesystem, we guarantee that either the new object is fully visible, or that all the space gets reclaimed.If the writes succeed but only part of an extent was used, repair must call the same
_cancel_autoreapfunction to kill the first EFI and then log a new EFI to free the unused space. The first EFI is already committed, so it cannot be changed.For full extents that aren't used,
xfs_alloc_commit_autoreapwill unpause the EFI, which results in the space being freed during the next_defer_finishcycle.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 104 +++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_alloc.h | 12 +++++ fs/xfs/xfs_extfree_item.c | 11 +++-- 3 files changed, 120 insertions(+), 7 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-2@@ -2501,14 +2501,15 @@ xfs_defer_agfl_block(* Add the extent to the list of extents to be free at transaction end. * The list is maintained sorted (by block number). */ -int -xfs_free_extent_later(fs/xfs/libxfs/xfs_alloc.c xfs_defer_agfl_block( · line 2512
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +4
-1+static int +__xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type, - bool skip_discard) +bool skip_discard, +struct xfs_defer_pending **dfpp)I was happy that
__xfs_free_extent_later()went away in the last patch.
Quoted 4 lines
I am sad that it has immediately come back....
Can we please name this after what it does? Say
xfs_defer_extent_free()?
Done. Thank you for a better name! :)
Quoted 57 lines
Quoted 57 lines
fs/xfs/libxfs/xfs_alloc.c +46
-1{struct xfs_extent_free_item *xefi;struct xfs_mount *mp = tp->t_mountp;@@ -2556,10 +2557,105 @@ xfs_free_extent_later( XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);xfs_extent_free_get_group (mp, xefi); -xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list); + *dfpp =xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list);return 0 ; } +int +xfs_free_extent_later ( +struct xfs_trans *tp, +xfs_fsblock_t bno, +xfs_filblks_t len, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type, +bool skip_discard) +{ +struct xfs_defer_pending *dontcare =NULL ; + +return __xfs_free_extent_later (tp, bno, len, oinfo, type, skip_discard, + &dontcare); +} + +/* +* Set up automatic freeing of unwritten space in the filesystem. +* +* This function attached a paused deferred extent free item to the +* transaction. Pausing means that the EFI will be logged in the next +* transaction commit, but the pending EFI will not be finished until the +* pending item is unpaused. +* +* If the system goes down after the EFI has been persisted to the log but +* before the pending item is unpaused, log recovery will find the EFI, fail to +* find the EFD, and free the space. +* +* If the pending item is unpaused, the next transaction commit will log an EFD +* without freeing the space. +* +* Caller must ensure that the tp, fsbno, len, oinfo, and resv flags of the +* @args structure are set to the relevant values. +*/ +int +xfs_alloc_schedule_autoreap ( +const struct xfs_alloc_arg *args, +bool skip_discard, +struct xfs_alloc_autoreap *aarp) +{ +int error; + + error =__xfs_free_extent_later (args->tp, args->fsbno, args->len, + &args->oinfo, args->resv, skip_discard, &aarp->dfp); +if (error) +return error;
Quoted 8 lines
fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2612
Quoted 4 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ +xfs_defer_item_pause (args->tp, aarp->dfp); +return 0 ; +}Then this becomes much more readable -
xfs_defer_free_extent()returns thedefer_pendingwork item for the EFI, which we then immediately pause....
<nod>
Quoted 45 lines
Quoted 20 lines
fs/xfs/libxfs/xfs_alloc.c +20
-0+ +/* +* Cancel automatic freeing of unwritten space in the filesystem. +* +* Earlier, we created a paused deferred extent free item and attached it to +* this transaction so that we could automatically roll back a new space +* allocation if the system went down. Now we want to cancel the paused work +* item by marking the EFI stale so we don't actually free the space, unpausing +* the pending item and logging an EFD. +* +* The caller generally should have already mapped the space into the ondisk +* filesystem. If the reserved space was partially used, the caller must call +* xfs_free_extent_later to create a new EFI to free the unused space. +*/ +void +xfs_alloc_cancel_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +struct xfs_defer_pending *dfp = aarp->dfp;fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2642
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +10
-0+struct xfs_extent_free_item *xefi; + +if (!dfp) +return ; + +list_for_each_entry (xefi, &dfp->dfp_work, xefi_list) + xefi->xefi_flags |=XFS_EFI_STALE ; + +xfs_defer_item_unpause (tp, dfp); +}Hmmmm. I see what you are trying to do here, though I'm not sure that "stale" is the right word to describe it. The EFI has been cancelled, so we want and EFD to be logged without freeing the extent.
To me, "stale" means "contents longer valid, do not touch" as per
XFS_ISTALE,xfs_buf_stale(), etcWhereas we use "cancelled" to indicate that the pending operations on the buffer should not be actioned, such as
XFS_BLF_CANCELbuffer items in log recovery to indicate the buffer has been freed and while it is cancelled we should not replay the changes found in the log for that buffer....
Quoted 3 lines
Hence I think this is better named
XFS_EFI_CANCELLED, and it also matches what the calling function is doing - cancelling the autoreap of the extent....
Funny story -- CANCELLED was the original name for this flag. I'll put it back.
Quoted 22 lines
Quoted 9 lines
fs/xfs/xfs_extfree_item.c +0
-1@@ -392,9 +392,14 @@ xfs_trans_free_extent(trace_xfs_bmap_free_deferred (tp->t_mountp, xefi->xefi_pag->pag_agno,0 , agbno, xefi->xefi_blockcount); - error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,fs/xfs/xfs_extfree_item.c xfs_trans_free_extent( · line 402
Quoted 10 lines
fs/xfs/xfs_extfree_item.c +8
-2- xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, - xefi->xefi_flags & XFS_EFI_SKIP_DISCARD); +if (xefi->xefi_flags &XFS_EFI_STALE ) { + error =0 ; + }else { + error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, + xefi->xefi_blockcount, &oinfo, + xefi->xefi_agresv, + xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); + }Just init error to 0 when it is declared, then this becomes:
Quoted 6 lines
if (!(xefi->xefi_flags & XFS_EFI_CANCELLED)) {
error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,
xefi->xefi_blockcount, &oinfo,
xefi->xefi_agresv,
xefi->xefi_flags & XFS_EFI_SKIP_DISCARD);
}<nod> Eventually the rt reflink patch will trip over this (since rtdev vs. datadev selection is also an xefi_flag) but that'll come later.
Quoted 1 line
Otherwise the code looks ok.
Yay!
--D
Quoted 3 lines
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 4/7] xfs: automatic freeing of freshly allocated unwritten space
Quoted 219 lines · Darrick J. Wong
Quoted 62 lines · Dave Chinner
Quoted 47 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
As mentioned in the previous commit, online repair wants to allocate space to write out a new metadata structure, and it also wants to hedge against system crashes during repairs by logging (and later cancelling) EFIs to free the space if we crash before committing the new data structure.
Therefore, create a trio of functions to schedule automatic reaping of freshly allocated unwritten space.
xfs_alloc_schedule_autoreapcreates a paused EFI representing the space we just allocated. Once the allocations are made and the autoreaps scheduled, we can start writing to disk.If the writes succeed,
xfs_alloc_cancel_autoreapmarks the EFI work items as stale and unpauses the pending deferred work item. Assuming that's done in the same transaction that commits the new structure into the filesystem, we guarantee that either the new object is fully visible, or that all the space gets reclaimed.If the writes succeed but only part of an extent was used, repair must call the same
_cancel_autoreapfunction to kill the first EFI and then log a new EFI to free the unused space. The first EFI is already committed, so it cannot be changed.For full extents that aren't used,
xfs_alloc_commit_autoreapwill unpause the EFI, which results in the space being freed during the next_defer_finishcycle.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 104 +++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_alloc.h | 12 +++++ fs/xfs/xfs_extfree_item.c | 11 +++-- 3 files changed, 120 insertions(+), 7 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-2@@ -2501,14 +2501,15 @@ xfs_defer_agfl_block(* Add the extent to the list of extents to be free at transaction end. * The list is maintained sorted (by block number). */ -int -xfs_free_extent_later(fs/xfs/libxfs/xfs_alloc.c xfs_defer_agfl_block( · line 2512
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +4
-1+static int +__xfs_free_extent_later (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type, - bool skip_discard) +bool skip_discard, +struct xfs_defer_pending **dfpp)I was happy that
__xfs_free_extent_later()went away in the last patch.Quoted 4 lines
I am sad that it has immediately come back....
Can we please name this after what it does? Say
xfs_defer_extent_free()?Done. Thank you for a better name! :)
Quoted 57 lines
Quoted 57 lines
fs/xfs/libxfs/xfs_alloc.c +46
-1{struct xfs_extent_free_item *xefi;struct xfs_mount *mp = tp->t_mountp;@@ -2556,10 +2557,105 @@ xfs_free_extent_later( XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);xfs_extent_free_get_group (mp, xefi); -xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list); + *dfpp =xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list);return 0 ; } +int +xfs_free_extent_later ( +struct xfs_trans *tp, +xfs_fsblock_t bno, +xfs_filblks_t len, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type, +bool skip_discard) +{ +struct xfs_defer_pending *dontcare =NULL ; + +return __xfs_free_extent_later (tp, bno, len, oinfo, type, skip_discard, + &dontcare); +} + +/* +* Set up automatic freeing of unwritten space in the filesystem. +* +* This function attached a paused deferred extent free item to the +* transaction. Pausing means that the EFI will be logged in the next +* transaction commit, but the pending EFI will not be finished until the +* pending item is unpaused. +* +* If the system goes down after the EFI has been persisted to the log but +* before the pending item is unpaused, log recovery will find the EFI, fail to +* find the EFD, and free the space. +* +* If the pending item is unpaused, the next transaction commit will log an EFD +* without freeing the space. +* +* Caller must ensure that the tp, fsbno, len, oinfo, and resv flags of the +* @args structure are set to the relevant values. +*/ +int +xfs_alloc_schedule_autoreap ( +const struct xfs_alloc_arg *args, +bool skip_discard, +struct xfs_alloc_autoreap *aarp) +{ +int error; + + error =__xfs_free_extent_later (args->tp, args->fsbno, args->len, + &args->oinfo, args->resv, skip_discard, &aarp->dfp); +if (error) +return error;Quoted 8 lines
fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2612
Quoted 4 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ +xfs_defer_item_pause (args->tp, aarp->dfp); +return 0 ; +}Then this becomes much more readable -
xfs_defer_free_extent()returns thedefer_pendingwork item for the EFI, which we then immediately pause....<nod>
Quoted 45 lines
Quoted 20 lines
fs/xfs/libxfs/xfs_alloc.c +20
-0+ +/* +* Cancel automatic freeing of unwritten space in the filesystem. +* +* Earlier, we created a paused deferred extent free item and attached it to +* this transaction so that we could automatically roll back a new space +* allocation if the system went down. Now we want to cancel the paused work +* item by marking the EFI stale so we don't actually free the space, unpausing +* the pending item and logging an EFD. +* +* The caller generally should have already mapped the space into the ondisk +* filesystem. If the reserved space was partially used, the caller must call +* xfs_free_extent_later to create a new EFI to free the unused space. +*/ +void +xfs_alloc_cancel_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +struct xfs_defer_pending *dfp = aarp->dfp;fs/xfs/libxfs/xfs_alloc.c xfs_free_extent_later( · line 2642
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +10
-0+struct xfs_extent_free_item *xefi; + +if (!dfp) +return ; + +list_for_each_entry (xefi, &dfp->dfp_work, xefi_list) + xefi->xefi_flags |=XFS_EFI_STALE ; + +xfs_defer_item_unpause (tp, dfp); +}Hmmmm. I see what you are trying to do here, though I'm not sure that "stale" is the right word to describe it. The EFI has been cancelled, so we want and EFD to be logged without freeing the extent.
To me, "stale" means "contents longer valid, do not touch" as per
XFS_ISTALE,xfs_buf_stale(), etcWhereas we use "cancelled" to indicate that the pending operations on the buffer should not be actioned, such as
XFS_BLF_CANCELbuffer items in log recovery to indicate the buffer has been freed and while it is cancelled we should not replay the changes found in the log for that buffer....Quoted 3 lines
Hence I think this is better named
XFS_EFI_CANCELLED, and it also matches what the calling function is doing - cancelling the autoreap of the extent....Funny story -- CANCELLED was the original name for this flag. I'll put it back.
Quoted 22 lines
Quoted 9 lines
fs/xfs/xfs_extfree_item.c +0
-1@@ -392,9 +392,14 @@ xfs_trans_free_extent(trace_xfs_bmap_free_deferred (tp->t_mountp, xefi->xefi_pag->pag_agno,0 , agbno, xefi->xefi_blockcount); - error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,fs/xfs/xfs_extfree_item.c xfs_trans_free_extent( · line 402
Quoted 10 lines
fs/xfs/xfs_extfree_item.c +8
-2- xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, - xefi->xefi_flags & XFS_EFI_SKIP_DISCARD); +if (xefi->xefi_flags &XFS_EFI_STALE ) { + error =0 ; + }else { + error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, + xefi->xefi_blockcount, &oinfo, + xefi->xefi_agresv, + xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); + }Just init error to 0 when it is declared, then this becomes:
Quoted 6 lines
if (!(xefi->xefi_flags & XFS_EFI_CANCELLED)) { error = __xfs_free_extent(tp, xefi->xefi_pag, agbno, xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, xefi->xefi_flags & XFS_EFI_SKIP_DISCARD); }
Quoted 2 lines
<nod> Eventually the rt reflink patch will trip over this (since rtdev vs. datadev selection is also an
xefi_flag) but that'll come later.
...only now it won't, since hch and I have been hacking on getting rt modernization reviewed; and that involved splitting out the rt paths so that the the existing functions aren't littered with conditionals.
--D
Quoted 9 lines
Quoted 1 line
Otherwise the code looks ok.
Yay!
--D
Quoted 3 lines
Signature · 2 lines
Dave Chinner [email protected]
PATCH 4/7 xfs: automatic freeing of freshly allocated unwritten space
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
As mentioned in the previous commit, online repair wants to allocate space to write out a new metadata structure, and it also wants to hedge against system crashes during repairs by logging (and later cancelling) EFIs to free the space if we crash before committing the new data structure.
Therefore, create a trio of functions to schedule automatic reaping of freshly allocated unwritten space. xfs_alloc_schedule_autoreap creates a paused EFI representing the space we just allocated. Once the allocations are made and the autoreaps scheduled, we can start writing to disk.
If the writes succeed, xfs_alloc_cancel_autoreap marks the EFI work items as stale and unpauses the pending deferred work item. Assuming that's done in the same transaction that commits the new structure into the filesystem, we guarantee that either the new object is fully visible, or that all the space gets reclaimed.
If the writes succeed but only part of an extent was used, repair must call the same _cancel_autoreap function to kill the first EFI and then log a new EFI to free the unused space. The first EFI is already committed, so it cannot be changed.
For full extents that aren't used, xfs_alloc_commit_autoreap will unpause the EFI, which results in the space being freed during the next _defer_finish cycle.
---
v27.1: fix some things that dave asked for; actually send this as a correct reply this time
--- fs/xfs/libxfs/xfs_alloc.c | 104 +++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_alloc.h | 12 +++++ fs/xfs/xfs_extfree_item.c | 10 +++- 3 files changed, 118 insertions(+), 8 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +100 -4
@@ -2501,14 +2501,15 @@ xfs_defer_agfl_block(* Add the extent to the list of extents to be free at transaction end. * The list is maintained sorted (by block number). */ -int -xfs_free_extent_later ( +static int +xfs_defer_extent_free (struct xfs_trans *tp,xfs_fsblock_t bno,xfs_filblks_t len,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type, -bool skip_discard) +bool skip_discard, +struct xfs_defer_pending **dfpp) {struct xfs_extent_free_item *xefi;struct xfs_mount *mp = tp->t_mountp;
@@ -2556,10 +2557,105 @@ xfs_free_extent_later( XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);xfs_extent_free_get_group (mp, xefi); -xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list); + *dfpp =xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_FREE , &xefi->xefi_list);return 0 ; } +int +xfs_free_extent_later ( +struct xfs_trans *tp, +xfs_fsblock_t bno, +xfs_filblks_t len, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type, +bool skip_discard) +{ +struct xfs_defer_pending *dontcare =NULL ; + +return xfs_defer_extent_free (tp, bno, len, oinfo, type, skip_discard, + &dontcare); +} + +/* +* Set up automatic freeing of unwritten space in the filesystem. +* +* This function attached a paused deferred extent free item to the +* transaction. Pausing means that the EFI will be logged in the next +* transaction commit, but the pending EFI will not be finished until the +* pending item is unpaused. +* +* If the system goes down after the EFI has been persisted to the log but +* before the pending item is unpaused, log recovery will find the EFI, fail to +* find the EFD, and free the space. +* +* If the pending item is unpaused, the next transaction commit will log an EFD +* without freeing the space. +* +* Caller must ensure that the tp, fsbno, len, oinfo, and resv flags of the +* @args structure are set to the relevant values. +*/ +int +xfs_alloc_schedule_autoreap ( +const struct xfs_alloc_arg *args, +bool skip_discard, +struct xfs_alloc_autoreap *aarp) +{ +int error; + + error =xfs_defer_extent_free (args->tp, args->fsbno, args->len, + &args->oinfo, args->resv, skip_discard, &aarp->dfp); +if (error) +return error; + +xfs_defer_item_pause (args->tp, aarp->dfp); +return 0 ; +} + +/* +* Cancel automatic freeing of unwritten space in the filesystem. +* +* Earlier, we created a paused deferred extent free item and attached it to +* this transaction so that we could automatically roll back a new space +* allocation if the system went down. Now we want to cancel the paused work +* item by marking the EFI stale so we don't actually free the space, unpausing +* the pending item and logging an EFD. +* +* The caller generally should have already mapped the space into the ondisk +* filesystem. If the reserved space was partially used, the caller must call +* xfs_free_extent_later to create a new EFI to free the unused space. +*/ +void +xfs_alloc_cancel_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +struct xfs_defer_pending *dfp = aarp->dfp; +struct xfs_extent_free_item *xefi; + +if (!dfp) +return ; + +list_for_each_entry (xefi, &dfp->dfp_work, xefi_list) + xefi->xefi_flags |=XFS_EFI_CANCELLED ; + +xfs_defer_item_unpause (tp, dfp); +} + +/* +* Commit automatic freeing of unwritten space in the filesystem. +* +* This unpauses an earlier _schedule_autoreap and commits to freeing the +* allocated space. Call this if none of the reserved space was used. +*/ +void +xfs_alloc_commit_autoreap ( +struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp) +{ +if (aarp->dfp) +xfs_defer_item_unpause (tp, aarp->dfp); +} +#ifdef DEBUG /* * Check if an AGF has a free extent record whose length is equal to
fs/xfs/libxfs/xfs_alloc.h +12 -0
@@ -255,6 +255,18 @@ void xfs_extent_free_get_group(struct xfs_mount *mp,#define XFS_EFI_SKIP_DISCARD (1U << 0)/* don't issue discard */ #define XFS_EFI_ATTR_FORK (1U << 1)/* freeing attr fork block */ #define XFS_EFI_BMBT_BLOCK (1U << 2)/* freeing bmap btree block */ +#define XFS_EFI_CANCELLED (1U << 3)/* dont actually free the space */ + +struct xfs_alloc_autoreap { +struct xfs_defer_pending *dfp; +}; + +int xfs_alloc_schedule_autoreap (const struct xfs_alloc_arg *args, +bool skip_discard,struct xfs_alloc_autoreap *aarp); +void xfs_alloc_cancel_autoreap (struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp); +void xfs_alloc_commit_autoreap (struct xfs_trans *tp, +struct xfs_alloc_autoreap *aarp);extern struct kmem_cache *xfs_extfree_item_cache;
fs/xfs/xfs_extfree_item.c +6 -4
@@ -381,7 +381,7 @@ xfs_trans_free_extent(uint next_extent;xfs_agblock_t agbno =XFS_FSB_TO_AGBNO (mp, xefi->xefi_startblock); -int error; +int error =0 ; oinfo.oi_owner = xefi->xefi_owner;if (xefi->xefi_flags &XFS_EFI_ATTR_FORK )
@@ -392,9 +392,11 @@ xfs_trans_free_extent(trace_xfs_bmap_free_deferred (tp->t_mountp, xefi->xefi_pag->pag_agno,0 , agbno, xefi->xefi_blockcount); - error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, - xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv, - xefi->xefi_flags &XFS_EFI_SKIP_DISCARD ); +if (!(xefi->xefi_flags &XFS_EFI_CANCELLED )) + error =__xfs_free_extent (tp, xefi->xefi_pag, agbno, + xefi->xefi_blockcount, &oinfo, + xefi->xefi_agresv, + xefi->xefi_flags &XFS_EFI_SKIP_DISCARD );/* * Mark the transaction dirty, even on error. This ensures the
PATCH 5/7 xfs: implement block reservation accounting for btrees we're staging
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new xrep_newbt structure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree_staging.h | 7 - fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 492 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 62 +++++ fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ 8 files changed, 598 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
fs/xfs/Makefile +1 -0
@@ -181,6 +181,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ + newbt.o \ reap.o \ repair.o \ )
fs/xfs/libxfs/xfs_btree_staging.h +2 -5
@@ -38,11 +38,8 @@ struct xbtree_ifakeroot {/* Number of bytes available for this fork in the inode. */ unsigned int if_fork_size; -/* Fork format. */ -unsigned int if_format; - -/* Number of records. */ -unsigned int if_extents; +/* Which fork is this btree being built for? */ +int if_whichfork; };/* Cursor interactions with fake roots for inode-rooted btrees. */
fs/xfs/scrub/agheader_repair.c +1 -0
@@ -10,6 +10,7 @@#include "xfs_trans_resv.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_log_format.h" #include "xfs_trans.h" #include "xfs_sb.h"
fs/xfs/scrub/common.c +1 -0
@@ -10,6 +10,7 @@#include "xfs_trans_resv.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_log_format.h" #include "xfs_trans.h" #include "xfs_inode.h"
fs/xfs/scrub/newbt.c new file +492 -0
492 lines not on this page · raw message
fs/xfs/scrub/newbt.h new file +62 -0
62 lines not on this page · raw message
fs/xfs/scrub/scrub.c +2 -0
@@ -17,6 +17,8 @@#include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_scrub.h" +#include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
fs/xfs/scrub/trace.h +37 -0
@@ -1331,6 +1331,43 @@ TRACE_EVENT(xrep_ialloc_insert, __entry->freemask) ) +DECLARE_EVENT_CLASS (xrep_newbt_extent_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + xfs_agblock_t agbno, xfs_extlen_t len, + int64_t owner), +TP_ARGS (mp, agno, agbno, len, owner), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(xfs_extlen_t, len) +__field (int64_t, owner) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->agbno = agbno; + __entry->len = len; + __entry->owner = owner; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->agbno, + __entry->len, + __entry->owner) +); +#define DEFINE_NEWBT_EXTENT_EVENT (name) \ +DEFINE_EVENT(xrep_newbt_extent_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + xfs_agblock_t agbno, xfs_extlen_t len, \ + int64_t owner), \ + TP_ARGS(mp, agno, agbno, len, owner)) +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_alloc_ag_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_alloc_file_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_free_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_claim_block); +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ #endif /* _TRACE_XFS_SCRUB_TRACE_H */
Re: [PATCH 5/7] xfs: implement block reservation accounting for btrees we're staging
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xrep_newbtstructure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.Signed-off-by Darrick J. Wong <[email protected]>
Quoted 12 lines
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree_staging.h | 7 - fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 492 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 62 +++++ fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ 8 files changed, 598 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
Looks reasonable to me. It all makes sense and nothing is obviously wrong.
Some notes on the extent allocation API bits - the rework of the high level allocation primitives I just posted intersects with this code in some interesting ways....
Quoted 18 lines
fs/xfs/scrub/newbt.c new file +18
-0+ +/* Allocate disk space for a new per-AG btree. */ +STATIC int +xrep_newbt_alloc_ag_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +struct xfs_mount *mp = sc->mp; +int error =0 ; + +ASSERT (sc->sa.pag !=NULL ); + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = mp, + .oinfo = xnr->oinfo,
fs/xfs/scrub/newbt.c line 196
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+ .minlen = 1, + .maxlen = nr_blocks, + .prod = 1, + .resv = xnr->resv, + }; +xfs_agnumber_t agno; + +xrep_newbt_validate_ag_alloc_hint (xnr); + + error =xfs_alloc_vextent_near_bno (&args, xnr->alloc_hint);
This would require a perag to be held by the caller (sc->sa.pag) and attached to the args. The target also changes to an agbno (IIRC).
fs/xfs/scrub/newbt.c line 200
Quoted 4 lines
fs/xfs/scrub/newbt.c new file +4
-0+if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ;
This will need to change to handling ENOSPC as the error directly on failure.
fs/xfs/scrub/newbt.c line 211
Quoted 11 lines
fs/xfs/scrub/newbt.c new file +11
-0+ + agno =XFS_FSB_TO_AGNO (mp, args.fsbno); + +trace_xrep_newbt_alloc_ag_blocks (mp, agno, +XFS_FSB_TO_AGBNO (mp, args.fsbno), args.len, + xnr->oinfo.oi_owner); + +if (agno != sc->sa.pag->pag_agno) { +ASSERT (agno == sc->sa.pag->pag_agno); +return -EFSCORRUPTED ; + }
This can go away, because it simply isn't possible - it will allocate a block in sc->sa.pag or fail with ENOSPC.
Hence this will probably simplify down a bit.
Quoted 49 lines
fs/xfs/scrub/newbt.c new file +49
-0+ + error =xrep_newbt_add_blocks (xnr, sc->sa.pag, &args); +if (error) +return error; + + nr_blocks -= args.len; + xnr->alloc_hint = args.fsbno + args.len; + + error =xrep_defer_finish (sc); +if (error) +return error; + } + +return 0 ; +} + +/* Don't let our allocation hint take us beyond EOFS */ +static inline void +xrep_newbt_validate_file_alloc_hint ( +struct xrep_newbt *xnr) +{ +struct xfs_scrub *sc = xnr->sc; + +if (xfs_verify_fsbno (sc->mp, xnr->alloc_hint)) +return ; + + xnr->alloc_hint =XFS_AGB_TO_FSB (sc->mp,0 ,XFS_AGFL_BLOCK (sc->mp) +1 ); +} + +/* Allocate disk space for our new file-based btree. */ +STATIC int +xrep_newbt_alloc_file_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +struct xfs_mount *mp = sc->mp; +int error =0 ; + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = mp, + .oinfo = xnr->oinfo, + .minlen =1 , + .maxlen = nr_blocks, + .prod =1 , + .resv = xnr->resv, + };
fs/xfs/scrub/newbt.c line 270
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+struct xfs_perag *pag; +xfs_agnumber_t agno; + +xrep_newbt_validate_file_alloc_hint (xnr); + + error =xfs_alloc_vextent_start_ag (&args, xnr->alloc_hint); +if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ;
Similar target/errno changes will be needed here, and ....
Quoted 7 lines
fs/xfs/scrub/newbt.c new file +7
-0+ + agno =XFS_FSB_TO_AGNO (mp, args.fsbno); + +trace_xrep_newbt_alloc_file_blocks (mp, agno, +XFS_FSB_TO_AGBNO (mp, args.fsbno), args.len, + xnr->oinfo.oi_owner); +
fs/xfs/scrub/newbt.c line 287
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+ pag =xfs_perag_get (mp, agno); +if (!pag) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + + error =xrep_newbt_add_blocks (xnr, pag, &args); +xfs_perag_put (pag); +if (error) +return error;
I suspect it might be useful to have xfs_alloc_vextent_start_ag() be able to return the referenced perag that the allocation occurred in rather than having to split the result and look it up again....
Hust a heads up for now, thought, we can deal with these issues when merging for one or the other happens...
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 5/7] xfs: implement block reservation accounting for btrees we're staging
Quoted 21 lines · Dave Chinner
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xrep_newbtstructure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.Signed-off-by Darrick J. Wong <[email protected]>Quoted 12 lines
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree_staging.h | 7 - fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 492 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 62 +++++ fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ 8 files changed, 598 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
Quoted 4 lines
Looks reasonable to me. It all makes sense and nothing is obviously wrong.
Reviewed-by Dave Chinner <[email protected]>
Thanks!
Quoted 29 lines
Some notes on the extent allocation API bits - the rework of the high level allocation primitives I just posted intersects with this code in some interesting ways....
Quoted 24 lines
fs/xfs/scrub/newbt.c new file +24
-0+ +/* Allocate disk space for a new per-AG btree. */ +STATIC int +xrep_newbt_alloc_ag_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +struct xfs_mount *mp = sc->mp; +int error =0 ; + +ASSERT (sc->sa.pag !=NULL ); + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = mp, + .oinfo = xnr->oinfo, + .minlen =1 , + .maxlen = nr_blocks, + .prod =1 , + .resv = xnr->resv, + }; +xfs_agnumber_t agno;
Quoted 8 lines
fs/xfs/scrub/newbt.c line 196
Quoted 4 lines
fs/xfs/scrub/newbt.c new file +4
-0+ +xrep_newbt_validate_ag_alloc_hint (xnr); + + error =xfs_alloc_vextent_near_bno (&args, xnr->alloc_hint);This would require a perag to be held by the caller (
sc->sa.pag) and attached to the args. The target also changes to an agbno (IIRC).
<nod> Pretty straightforward.
Quoted 7 lines
fs/xfs/scrub/newbt.c line 200
Quoted 4 lines
fs/xfs/scrub/newbt.c new file +4
-0+if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ;This will need to change to handling ENOSPC as the error directly on failure.
<nod>
Quoted 15 lines
fs/xfs/scrub/newbt.c line 211
Quoted 11 lines
fs/xfs/scrub/newbt.c new file +11
-0+ + agno =XFS_FSB_TO_AGNO (mp, args.fsbno); + +trace_xrep_newbt_alloc_ag_blocks (mp, agno, +XFS_FSB_TO_AGBNO (mp, args.fsbno), args.len, + xnr->oinfo.oi_owner); + +if (agno != sc->sa.pag->pag_agno) { +ASSERT (agno == sc->sa.pag->pag_agno); +return -EFSCORRUPTED ; + }This can go away, because it simply isn't possible - it will allocate a block in
sc->sa.pagor fail with ENOSPC.
Quoted 1 line
Hence this will probably simplify down a bit.
Yessssssss
Quoted 74 lines
Quoted 49 lines
fs/xfs/scrub/newbt.c new file +49
-0+ + error =xrep_newbt_add_blocks (xnr, sc->sa.pag, &args); +if (error) +return error; + + nr_blocks -= args.len; + xnr->alloc_hint = args.fsbno + args.len; + + error =xrep_defer_finish (sc); +if (error) +return error; + } + +return 0 ; +} + +/* Don't let our allocation hint take us beyond EOFS */ +static inline void +xrep_newbt_validate_file_alloc_hint ( +struct xrep_newbt *xnr) +{ +struct xfs_scrub *sc = xnr->sc; + +if (xfs_verify_fsbno (sc->mp, xnr->alloc_hint)) +return ; + + xnr->alloc_hint =XFS_AGB_TO_FSB (sc->mp,0 ,XFS_AGFL_BLOCK (sc->mp) +1 ); +} + +/* Allocate disk space for our new file-based btree. */ +STATIC int +xrep_newbt_alloc_file_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +struct xfs_mount *mp = sc->mp; +int error =0 ; + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = mp, + .oinfo = xnr->oinfo, + .minlen =1 , + .maxlen = nr_blocks, + .prod =1 , + .resv = xnr->resv, + };fs/xfs/scrub/newbt.c line 270
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+struct xfs_perag *pag; +xfs_agnumber_t agno; + +xrep_newbt_validate_file_alloc_hint (xnr); + + error =xfs_alloc_vextent_start_ag (&args, xnr->alloc_hint); +if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ;Similar target/errno changes will be needed here, and ....
Quoted 13 lines
fs/xfs/scrub/newbt.c new file +13
-0+ + agno =XFS_FSB_TO_AGNO (mp, args.fsbno); + +trace_xrep_newbt_alloc_file_blocks (mp, agno, +XFS_FSB_TO_AGBNO (mp, args.fsbno), args.len, + xnr->oinfo.oi_owner); + + pag =xfs_perag_get (mp, agno); +if (!pag) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } +
Quoted 8 lines
fs/xfs/scrub/newbt.c line 287
Quoted 4 lines
fs/xfs/scrub/newbt.c new file +4
-0+ error =xrep_newbt_add_blocks (xnr, pag, &args); +xfs_perag_put (pag); +if (error) +return error;I suspect it might be useful to have
xfs_alloc_vextent_start_ag()be able to return the referenced perag that the allocation occurred in rather than having to split the result and look it up again....
Yeah, I think it's reasonable to return an active(?) reference to the perag that we picked and the space allocated from that AG.
Quoted 2 lines
Hust a heads up for now, thought, we can deal with these issues when merging for one or the other happens...
Ok.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 6/7 xfs: log EFIs for all btree blocks being used to stage a btree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Use the autoreaping mechanism provided by the previous patch to attach paused freeing work to the scrub transaction. We can then mark the EFIs stale if we decide to commit the new btree, or we can unpause the EFIs if we decide to abort the repair.
--- fs/xfs/scrub/newbt.c | 34 ++++++++++++++++++++++++++-------- fs/xfs/scrub/newbt.h | 3 +++ 2 files changed, 29 insertions(+), 8 deletions(-)
fs/xfs/scrub/newbt.c +26 -8
@@ -136,6 +136,7 @@ xrep_newbt_add_blocks( {struct xfs_mount *mp = xnr->sc->mp;struct xrep_newbt_resv *resv; +int error; resv =kmalloc (sizeof (struct xrep_newbt_resv ),XCHK_GFP_FLAGS );if (!resv)
@@ -147,8 +148,18 @@ xrep_newbt_add_blocks( resv->used =0 ; resv->pag =xfs_perag_hold (pag); +ASSERT (xnr->oinfo.oi_offset ==0 ); + + error =xfs_alloc_schedule_autoreap (args, true, &resv->autoreap); +if (error) + goto out_pag; +list_add_tail (&resv->list, &xnr->resv_list);return 0 ; +out_pag: +xfs_perag_put (resv->pag); +kfree (resv); +return error; }/* Don't let our allocation hint take us beyond this AG */
@@ -327,16 +338,21 @@ xrep_newbt_free_extent(if (!btree_committed || resv->used ==0 ) {/* * If we're not committing a new btree or we didn't use the -* space reservation, free the entire space extent. +* space reservation, let the existing EFI free the entire +* space extent. */ - goto free; +trace_xrep_newbt_free_blocks (sc->mp, resv->pag->pag_agno, + free_agbno, free_aglen, xnr->oinfo.oi_owner); +xfs_alloc_commit_autoreap (sc->tp, &resv->autoreap); +return 1 ; }/* -* We used space and committed the btree. Remove the written blocks -* from the reservation and possibly log a new EFI to free any unused -* reservation space. +* We used space and committed the btree. Cancel the autoreap, remove +* the written blocks from the reservation, and possibly log a new EFI +* to free any unused reservation space. */ +xfs_alloc_cancel_autoreap (sc->tp, &resv->autoreap); free_agbno += resv->used; free_aglen -= resv->used;
@@ -348,7 +364,6 @@ xrep_newbt_free_extent(ASSERT (xnr->resv !=XFS_AG_RESV_AGFL ); -free:/* * Use EFIs to free the reservations. This reduces the chance * that we leak blocks if the system goes down.
@@ -408,9 +423,10 @@ xrep_newbt_free(/* * If we still have reservations attached to @newbt, cleanup must have * failed and the filesystem is about to go down. Clean up the incore -* reservations. +* reservations and try to commit to freeing the space we used. */ list_for_each_entry_safe (resv, n, &xnr->resv_list, list) { +xfs_alloc_commit_autoreap (sc->tp, &resv->autoreap);list_del (&resv->list);xfs_perag_put (resv->pag);kfree (resv);
@@ -488,5 +504,7 @@ xrep_newbt_claim_block( agbno)); else ptr->s = cpu_to_be32(agbno); -return 0 ; + +/* Relog all the EFIs. */ +return xrep_defer_finish (xnr->sc); }
fs/xfs/scrub/newbt.h +3 -0
@@ -12,6 +12,9 @@ struct xrep_newbt_resv {struct xfs_perag *pag; +/* Auto-freeing this reservation if we don't commit. */ +struct xfs_alloc_autoreap autoreap; +/* AG block of the extent we reserved. */ xfs_agblock_t agbno;
Re: [PATCH 6/7] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Use the autoreaping mechanism provided by the previous patch to attach paused freeing work to the scrub transaction. We can then mark the EFIs stale if we decide to commit the new btree, or we can unpause the EFIs if we decide to abort the repair.
Quoted 5 lines
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/newbt.c | 34 ++++++++++++++++++++++++++-------- fs/xfs/scrub/newbt.h | 3 +++ 2 files changed, 29 insertions(+), 8 deletions(-)
Looks ok.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 7/7 xfs: force small EFIs for reaping btree extents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Introduce the concept of a defer ops barrier to separate consecutively queued pending work items of the same type. With a barrier in place, the two work items will be tracked separately, and receive separate log intent items. The goal here is to prevent reaping of old metadata blocks from creating unnecessarily huge EFIs that could then run the risk of overflowing the scrub transaction.
--- fs/xfs/libxfs/xfs_defer.c | 83 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_defer.h | 3 ++ fs/xfs/scrub/reap.c | 5 +++ 3 files changed, 91 insertions(+)
fs/xfs/libxfs/xfs_defer.c +83 -0
@@ -181,6 +181,58 @@ static struct kmem_cache *xfs_defer_pending_cache;* Note that the continuation requested between t2 and t3 is likely to * reoccur. */ +STATIC struct xfs_log_item * +xfs_defer_barrier_create_intent ( +struct xfs_trans *tp, +struct list_head *items, +unsigned int count, +bool sort) +{ +return NULL ; +} + +STATIC void +xfs_defer_barrier_abort_intent ( +struct xfs_log_item *intent) +{ +/* empty */ +} + +STATIC struct xfs_log_item * +xfs_defer_barrier_create_done ( +struct xfs_trans *tp, +struct xfs_log_item *intent, +unsigned int count) +{ +return NULL ; +} + +STATIC int +xfs_defer_barrier_finish_item ( +struct xfs_trans *tp, +struct xfs_log_item *done, +struct list_head *item, +struct xfs_btree_cur **state) +{ +ASSERT (0 ); +return -EFSCORRUPTED ; +} + +STATIC void +xfs_defer_barrier_cancel_item ( +struct list_head *item) +{ +ASSERT (0 ); +} + +static const struct xfs_defer_op_type xfs_barrier_defer_type = { + .max_items =1 , + .create_intent = xfs_defer_barrier_create_intent, + .abort_intent = xfs_defer_barrier_abort_intent, + .create_done = xfs_defer_barrier_create_done, + .finish_item = xfs_defer_barrier_finish_item, + .cancel_item = xfs_defer_barrier_cancel_item, +};static const struct xfs_defer_op_type *defer_op_types[] = { [XFS_DEFER_OPS_TYPE_BMAP ] = &xfs_bmap_update_defer_type,
@@ -189,6 +241,7 @@ static const struct xfs_defer_op_type *defer_op_types[] = { [XFS_DEFER_OPS_TYPE_FREE] = &xfs_extent_free_defer_type, [XFS_DEFER_OPS_TYPE_AGFL_FREE] = &xfs_agfl_free_defer_type, [XFS_DEFER_OPS_TYPE_ATTR] = &xfs_attr_defer_type, + [XFS_DEFER_OPS_TYPE_BARRIER] = &xfs_barrier_defer_type, };/*
@@ -1028,3 +1081,33 @@ xfs_defer_item_unpause(trace_xfs_defer_item_unpause (tp->t_mountp, dfp); } + +/* +* Add a defer ops barrier to force two otherwise adjacent deferred work items +* to be tracked separately and have separate log items. +*/ +void +xfs_defer_add_barrier ( +struct xfs_trans *tp) +{ +struct xfs_defer_pending *dfp; + +ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES ); + +/* If the last defer op added was a barrier, we're done. */ +if (!list_empty (&tp->t_dfops)) { + dfp =list_last_entry (&tp->t_dfops, + struct xfs_defer_pending, dfp_list); +if (dfp->dfp_type ==XFS_DEFER_OPS_TYPE_BARRIER ) +return ; + } + + dfp =kmem_cache_zalloc (xfs_defer_pending_cache, +GFP_NOFS | __GFP_NOFAIL); + dfp->dfp_type =XFS_DEFER_OPS_TYPE_BARRIER ; +INIT_LIST_HEAD (&dfp->dfp_work); +list_add_tail (&dfp->dfp_list, &tp->t_dfops); + +trace_xfs_defer_add_item (tp->t_mountp, dfp,NULL ); + dfp->dfp_count++; +}
fs/xfs/libxfs/xfs_defer.h +3 -0
@@ -20,6 +20,7 @@ enum xfs_defer_ops_type {XFS_DEFER_OPS_TYPE_FREE ,XFS_DEFER_OPS_TYPE_AGFL_FREE ,XFS_DEFER_OPS_TYPE_ATTR , +XFS_DEFER_OPS_TYPE_BARRIER , XFS_DEFER_OPS_TYPE_MAX, };
@@ -141,4 +142,6 @@ void xfs_defer_resources_rele(struct xfs_defer_resources *dres);int __init xfs_defer_init_item_caches (void );void xfs_defer_destroy_item_caches (void ); +void xfs_defer_add_barrier (struct xfs_trans *tp); +#endif /* __XFS_DEFER_H__ */
fs/xfs/scrub/reap.c +5 -0
@@ -31,6 +31,7 @@#include "xfs_da_btree.h" #include "xfs_attr.h" #include "xfs_attr_remote.h" +#include "xfs_defer.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -409,6 +410,8 @@ xreap_agextent_iter(/* * Use deferred frees to get rid of the old btree blocks to try to * minimize the window in which we could crash and lose the old blocks. +* Add a defer ops barrier every other extent to avoid stressing the +* system with large EFIs. */ error =xfs_free_extent_later (sc->tp, fsbno, *aglenp, rs->oinfo, rs->resv, true);
@@ -416,6 +419,8 @@ xreap_agextent_iter(return error; rs->deferred++; +if (rs->deferred %2 ==0 ) +xfs_defer_add_barrier (sc->tp);return 0 ; }
Re: [PATCH 7/7] xfs: force small EFIs for reaping btree extents
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Introduce the concept of a defer ops barrier to separate consecutively queued pending work items of the same type. With a barrier in place, the two work items will be tracked separately, and receive separate log intent items. The goal here is to prevent reaping of old metadata blocks from creating unnecessarily huge EFIs that could then run the risk of overflowing the scrub transaction.
Quoted 6 lines
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_defer.c | 83 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_defer.h | 3 ++ fs/xfs/scrub/reap.c | 5 +++ 3 files changed, 91 insertions(+)
Looks good.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCHSET v27.0 0/7] xfs: reserve disk space for online repairs
In reply to Darrick J. WongQuoted 9 lines · Darrick J. Wong
Hi all,
Online repair fixes metadata structures by writing a new copy out to disk and atomically committing the new structure into the filesystem. For this to work, we need to reserve all the space we're going to need ahead of time so that the atomic commit transaction is as small as possible. We also require the reserved space to be freed if the system goes down, or if we decide not to commit the repair, or if we reserve too much space.
Just a heads up -- I rebased my development branch on 6.6-rc4 and uploaded the whole mess to kernel.org. These earlier patchsets are more or less the same, but wanted people to be able to build the branch with the latest (xfs/iomap) bugfixes.
In the meantime, I'll go look through Dave's allocator reorg series and figure out how that meshes with the forcealign series that John sent.
--D
Quoted 62 lines
To keep the atomic commit transaction as small as possible, we would like to allocate some space and simultaneously schedule automatic reaping of the reserved space, even on log recovery. EFIs are the mechanism to get us there, but we need to use them in a novel manner. Once we allocate the space, we want to hold on to the EFI (relogging as necessary) until we can commit or cancel the repair. EFIs for written committed blocks need to go away, but unwritten or uncommitted blocks can be freed like normal.
Earlier versions of this patchset directly manipulated the log items, but Dave thought that to be a layering violation. For v27, I've modified the defer ops handling code to be capable of pausing a deferred work item. Log intent items are created as they always have been, but paused items are pushed onto a side list when finishing deferred work items, and pushed back onto the transaction after that. Log intent done item are not created for paused work.
The second part adds a "stale" flag to the EFI so that the repair reservation code can dispose of an EFI the normal way, but without the space actually being freed.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-auto-reap-space-reservationsxfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-auto-reap-space-reservations--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.c | 2 fs/xfs/libxfs/xfs_alloc.c | 102 +++++++ fs/xfs/libxfs/xfs_alloc.h | 22 +- fs/xfs/libxfs/xfs_bmap.c | 4 fs/xfs/libxfs/xfs_bmap_btree.c | 2 fs/xfs/libxfs/xfs_btree_staging.h | 7 fs/xfs/libxfs/xfs_defer.c | 229 ++++++++++++++-- fs/xfs/libxfs/xfs_defer.h | 20 + fs/xfs/libxfs/xfs_ialloc.c | 5 fs/xfs/libxfs/xfs_ialloc_btree.c | 2 fs/xfs/libxfs/xfs_refcount.c | 6 fs/xfs/libxfs/xfs_refcount_btree.c | 2 fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 510 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 65 +++++ fs/xfs/scrub/reap.c | 7 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ fs/xfs/xfs_extfree_item.c | 13 + fs/xfs/xfs_reflink.c | 2 fs/xfs/xfs_trace.h | 13 + 23 files changed, 991 insertions(+), 64 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
cover xfs: online repair of AG btrees
In reply to Darrick J. WongHi all,
Now that we've spent a lot of time reworking common code in online fsck, we're ready to start rebuilding the AG space btrees. This series implements repair functions for the free space, inode, and refcount btrees. Rebuilding the reverse mapping btree is much more intense and is left for a subsequent patchset. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-ag-btrees
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-ag-btrees
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-ag-btrees
--- fs/xfs/Makefile | 3 fs/xfs/libxfs/xfs_ag.h | 10 fs/xfs/libxfs/xfs_ag_resv.c | 2 fs/xfs/libxfs/xfs_alloc.c | 18 - fs/xfs/libxfs/xfs_alloc.h | 2 fs/xfs/libxfs/xfs_alloc_btree.c | 13 - fs/xfs/libxfs/xfs_btree.c | 26 + fs/xfs/libxfs/xfs_btree.h | 2 fs/xfs/libxfs/xfs_ialloc.c | 41 +- fs/xfs/libxfs/xfs_ialloc.h | 3 fs/xfs/libxfs/xfs_refcount.c | 18 - fs/xfs/libxfs/xfs_refcount.h | 2 fs/xfs/libxfs/xfs_refcount_btree.c | 13 - fs/xfs/libxfs/xfs_types.h | 7 fs/xfs/scrub/agheader_repair.c | 9 fs/xfs/scrub/alloc.c | 16 + fs/xfs/scrub/alloc_repair.c | 914 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.c | 1 fs/xfs/scrub/common.h | 19 + fs/xfs/scrub/ialloc_repair.c | 874 ++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.c | 48 ++ fs/xfs/scrub/newbt.h | 6 fs/xfs/scrub/refcount_repair.c | 793 +++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 128 +++++ fs/xfs/scrub/repair.h | 43 ++ fs/xfs/scrub/scrub.c | 22 + fs/xfs/scrub/scrub.h | 9 fs/xfs/scrub/trace.h | 112 +++- fs/xfs/scrub/xfarray.h | 22 + fs/xfs/xfs_extent_busy.c | 13 + fs/xfs/xfs_extent_busy.h | 2 31 files changed, 3103 insertions(+), 88 deletions(-) create mode 100644 fs/xfs/scrub/alloc_repair.c create mode 100644 fs/xfs/scrub/ialloc_repair.c create mode 100644 fs/xfs/scrub/refcount_repair.c
PATCH 1/4 xfs: roll the scrub transaction after completing a repair
From: Darrick J. Wong <[email protected]>
When we've finished repairing an AG header, roll the scrub transaction. This ensure that any failures caused by defer ops failing are captured by the xrep_done tracepoint and that any stacktraces that occur will point to the repair code that caused it, instead of xchk_teardown.
Going forward, repair functions should commit the transaction if they're going to return success. Usually the space reaping functions that run after a successful atomic commit of the new metadata will take care of that for us.
--- fs/xfs/scrub/agheader_repair.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
fs/xfs/scrub/agheader_repair.c +6 -3
@@ -73,7 +73,7 @@ xrep_superblock(/* Write this to disk. */ xfs_trans_buf_set_type (sc->tp, bp,XFS_BLFT_SB_BUF );xfs_trans_log_buf (sc->tp, bp,0 ,BBTOB (bp->b_length) -1 ); -return error; +return 0 ; }/* AGF */
@@ -342,7 +342,7 @@ xrep_agf_commit_new( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level);set_bit (XFS_AGSTATE_AGF_INIT , &pag->pag_opstate); -return 0 ; +return xrep_roll_ag_trans (sc); }/* Repair the AGF. v5 filesystems only. */
@@ -790,6 +790,9 @@ xrep_agfl(/* Dump any AGFL overflow. */ error =xrep_reap_agblocks (sc, &agfl_extents, &XFS_RMAP_OINFO_AG ,XFS_AG_RESV_AGFL ); +if (error) + goto err; + err:xagb_bitmap_destroy (&agfl_extents);return error;
@@ -963,7 +966,7 @@ xrep_agi_commit_new( pag->pagi_freecount =be32_to_cpu (agi->agi_freecount);set_bit (XFS_AGSTATE_AGI_INIT , &pag->pag_opstate); -return 0 ; +return xrep_roll_ag_trans (sc); }/* Repair the AGI. */
PATCH 2/4 xfs: repair free space btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Rebuild the free space btrees from the gaps in the rmap btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.h | 9 fs/xfs/libxfs/xfs_ag_resv.c | 2 fs/xfs/libxfs/xfs_alloc.c | 18 + fs/xfs/libxfs/xfs_alloc.h | 2 fs/xfs/libxfs/xfs_alloc_btree.c | 13 + fs/xfs/libxfs/xfs_types.h | 7 fs/xfs/scrub/alloc.c | 16 + fs/xfs/scrub/alloc_repair.c | 914 +++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 19 + fs/xfs/scrub/newbt.c | 48 ++ fs/xfs/scrub/newbt.h | 6 fs/xfs/scrub/repair.c | 69 +++ fs/xfs/scrub/repair.h | 24 + fs/xfs/scrub/scrub.c | 14 - fs/xfs/scrub/scrub.h | 8 fs/xfs/scrub/trace.h | 24 + fs/xfs/scrub/xfarray.h | 22 + fs/xfs/xfs_extent_busy.c | 13 + fs/xfs/xfs_extent_busy.h | 2 20 files changed, 1212 insertions(+), 19 deletions(-) create mode 100644 fs/xfs/scrub/alloc_repair.c
fs/xfs/Makefile +1 -0
@@ -181,6 +181,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ + alloc_repair.o \ newbt.o \ reap.o \ repair.o \
fs/xfs/libxfs/xfs_ag.h +9 -0
@@ -80,6 +80,15 @@ struct xfs_perag {*/ uint16_t pag_checked;uint16_t pag_sick; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Alternate btree heights so that online repair won't trip the write +* verifiers while rebuilding the AG btrees. +*/ +uint8_t pagf_alt_levels[XFS_BTNUM_AGF ]; +#endif +spinlock_t pag_state_lock;spinlock_t pagb_lock;/* lock for pagb_tree */
fs/xfs/libxfs/xfs_ag_resv.c +2 -0
@@ -411,6 +411,8 @@ xfs_ag_resv_free_extent( fallthrough;case XFS_AG_RESV_NONE :xfs_trans_mod_sb (tp,XFS_TRANS_SB_FDBLOCKS , (int64_t )len); + fallthrough; +case XFS_AG_RESV_IGNORE :return ; }
fs/xfs/libxfs/xfs_alloc.c +12 -6
@@ -243,14 +243,11 @@ xfs_alloc_btrec_to_irec( irec->ar_blockcount =be32_to_cpu (rec->alloc.ar_blockcount); } -/* Simple checks for free space records. */ -xfs_failaddr_t -xfs_alloc_check_irec ( -struct xfs_btree_cur *cur, +inline xfs_failaddr_t +xfs_alloc_check_perag_irec ( +struct xfs_perag *pag,const struct xfs_alloc_rec_incore *irec) { -struct xfs_perag *pag = cur->bc_ag.pag; -if (irec->ar_blockcount ==0 )return __this_address;
@@ -261,6 +258,15 @@ xfs_alloc_check_irec(return NULL ; } +/* Simple checks for free space records. */ +xfs_failaddr_t +xfs_alloc_check_irec ( +struct xfs_btree_cur *cur, +const struct xfs_alloc_rec_incore *irec) +{ +return xfs_alloc_check_perag_irec (cur->bc_ag.pag, irec); +} + static inline int xfs_alloc_complain_bad_rec( struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_alloc.h +2 -0
@@ -185,6 +185,8 @@ xfs_alloc_get_rec(union xfs_btree_rec ;void xfs_alloc_btrec_to_irec (const union xfs_btree_rec *rec,struct xfs_alloc_rec_incore *irec); +xfs_failaddr_t xfs_alloc_check_perag_irec (struct xfs_perag *pag, +const struct xfs_alloc_rec_incore *irec);xfs_failaddr_t xfs_alloc_check_irec (struct xfs_btree_cur *cur,const struct xfs_alloc_rec_incore *irec);
fs/xfs/libxfs/xfs_alloc_btree.c +12 -1
@@ -323,7 +323,18 @@ xfs_allocbt_verify(if (bp->b_ops->magic[0 ] ==cpu_to_be32 (XFS_ABTC_MAGIC )) btnum = XFS_BTNUM_CNTi;if (pag &&xfs_perag_initialised_agf (pag)) { -if (level >= pag->pagf_levels[btnum]) +unsigned int maxlevel = pag->pagf_levels[btnum]; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Online repair could be rewriting the free space btrees, so +* we'll validate against the larger of either tree while this +* is going on. +*/ + maxlevel = max_t(unsigned int, maxlevel, + pag->pagf_alt_levels[btnum]); +#endif +if (level >= maxlevel)return __this_address; }else if (level >= mp->m_alloc_maxlevels)return __this_address;
fs/xfs/libxfs/xfs_types.h +7 -0
@@ -202,6 +202,13 @@ enum xfs_ag_resv_type {XFS_AG_RESV_AGFL ,XFS_AG_RESV_METADATA ,XFS_AG_RESV_RMAPBT , + +/* +* Don't increase fdblocks when freeing extent. This is a pony for +* the bnobt repair functions to re-free the free space without +* altering fdblocks. If you think you need this you're wrong. +*/ + XFS_AG_RESV_IGNORE, };/* Results of scanning a btree keyspace to check occupancy. */
fs/xfs/scrub/alloc.c +14 -2
@@ -9,13 +9,16 @@#include "xfs_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h" +#include "xfs_log_format.h" +#include "xfs_trans.h" #include "xfs_btree.h" #include "xfs_alloc.h" #include "xfs_rmap.h" +#include "xfs_ag.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/btree.h" -#include "xfs_ag.h" +#include "scrub/repair.h" /* * Set us up to scrub free space btrees.
@@ -24,10 +27,19 @@ intxchk_setup_ag_allocbt ( struct xfs_scrub *sc) { +int error; +if (xchk_need_intent_drain (sc))xchk_fsgates_enable (sc,XCHK_FSGATES_DRAIN ); -return xchk_setup_ag_btree (sc, false); + error =xchk_setup_ag_btree (sc, false); +if (error) +return error; + +if (xchk_could_repair (sc)) +return xrep_setup_ag_allocbt (sc); + +return 0 ; }/* Free space btree scrubber. */
fs/xfs/scrub/alloc_repair.c new file +914 -0
914 lines not on this page · raw message
fs/xfs/scrub/common.h +19 -0
@@ -194,8 +194,21 @@ static inline bool xchk_needs_repair(const struct xfs_scrub_metadata *sm)XFS_SCRUB_OFLAG_XCORRUPT | XFS_SCRUB_OFLAG_PREEN); } + +/* +* "Should we prepare for a repair?" +* +* Return true if the caller permits us to repair metadata and we're not +* setting up for a post-repair evaluation. +*/ +static inline bool xchk_could_repair (const struct xfs_scrub *sc) +{ +return (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && + !(sc->flags &XREP_ALREADY_FIXED ); +}#else # define xchk_needs_repair (sc) (false) +# define xchk_could_repair (sc) (false)#endif /* CONFIG_XFS_ONLINE_REPAIR */ int xchk_metadata_inode_forks (struct xfs_scrub *sc);
@@ -207,6 +220,12 @@ int xchk_metadata_inode_forks(struct xfs_scrub *sc);#define xchk_xfile_descr (sc, fmt, ...) \ kasprintf(XCHK_GFP_FLAGS, "XFS (%s): " fmt, \ (sc)->mp->m_super->s_id, ##__VA_ARGS__) +#define xchk_xfile_ag_descr (sc, fmt, ...) \ + kasprintf(XCHK_GFP_FLAGS, "XFS (%s): AG 0x%x " fmt, \ + (sc)->mp->m_super->s_id, \ + (sc)->sa.pag ? (sc)->sa.pag->pag_agno : (sc)->sm->sm_agno, \ + ##__VA_ARGS__) +/* * Setting up a hook to wait for intents to drain is costly -- we have to take
fs/xfs/scrub/newbt.c +44 -4
70 lines not on this page · raw message
fs/xfs/scrub/newbt.h +6 -0
@@ -50,6 +50,9 @@ struct xrep_newbt {enum xfs_ag_resv_type resv; }; +#define for_each_xrep_newbt_reservation (xnr, resv, n) \ + list_for_each_entry_safe((resv), (n), &(xnr)->resv_list, list) +void xrep_newbt_init_bare (struct xrep_newbt *xnr,struct xfs_scrub *sc); void xrep_newbt_init_ag(struct xrep_newbt *xnr, struct xfs_scrub *sc, const struct xfs_owner_info *oinfo, xfs_fsblock_t alloc_hint,
@@ -57,9 +60,12 @@ void xrep_newbt_init_ag(struct xrep_newbt *xnr, struct xfs_scrub *sc,int xrep_newbt_init_inode (struct xrep_newbt *xnr,struct xfs_scrub *sc,int whichfork,const struct xfs_owner_info *oinfo);int xrep_newbt_alloc_blocks (struct xrep_newbt *xnr,uint64_t nr_blocks); +int xrep_newbt_add_extent (struct xrep_newbt *xnr,struct xfs_perag *pag, +xfs_agblock_t agbno,xfs_extlen_t len);void xrep_newbt_cancel (struct xrep_newbt *xnr);int xrep_newbt_commit (struct xrep_newbt *xnr);int xrep_newbt_claim_block (struct xfs_btree_cur *cur,struct xrep_newbt *xnr,union xfs_btree_ptr *ptr); +unsigned int xrep_newbt_unused_blocks (struct xrep_newbt *xnr);#endif /* __XFS_SCRUB_NEWBT_H__ */
fs/xfs/scrub/repair.c +69 -0
72 lines not on this page · raw message
fs/xfs/scrub/repair.h +24 -0
@@ -60,6 +60,15 @@ int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp,void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +/* Repair setup functions */ +int xrep_setup_ag_allocbt (struct xfs_scrub *sc); + +void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa); + +/* Metadata revalidators */ + +int xrep_revalidate_allocbt (struct xfs_scrub *sc); +/* Metadata repairers */ int xrep_probe (struct xfs_scrub *sc);
@@ -67,6 +76,9 @@ int xrep_superblock(struct xfs_scrub *sc);int xrep_agf (struct xfs_scrub *sc);int xrep_agfl (struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc); +int xrep_allocbt (struct xfs_scrub *sc); + +int xrep_reinit_pagf (struct xfs_scrub *sc);#else
@@ -87,11 +99,23 @@ xrep_calc_ag_resblks( return 0; } +/* repair setup functions for no-repair */ +static inline int +xrep_setup_nothing ( +struct xfs_scrub *sc) +{ +return 0 ; +} +#define xrep_setup_ag_allocbt xrep_setup_nothing + +#define xrep_revalidate_allocbt (NULL) +#define xrep_probe xrep_notsupported#define xrep_superblock xrep_notsupported#define xrep_agf xrep_notsupported#define xrep_agfl xrep_notsupported#define xrep_agi xrep_notsupported +#define xrep_allocbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +9 -5
@@ -241,13 +241,15 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_PERAG, .setup = xchk_setup_ag_allocbt, .scrub = xchk_bnobt, - .repair = xrep_notsupported, + .repair = xrep_allocbt, + .repair_eval = xrep_revalidate_allocbt, }, [XFS_SCRUB_TYPE_CNTBT] = { /* cntbt */ .type = ST_PERAG, .setup = xchk_setup_ag_allocbt, .scrub = xchk_cntbt, - .repair = xrep_notsupported, + .repair = xrep_allocbt, + .repair_eval = xrep_revalidate_allocbt, }, [XFS_SCRUB_TYPE_INOBT] = { /* inobt */ .type = ST_PERAG,
@@ -533,7 +535,10 @@ xfs_scrub_metadata(/* Scrub for errors. */ check_start =xchk_stats_now (); - error = sc->ops->scrub (sc); +if ((sc->flags &XREP_ALREADY_FIXED ) && sc->ops->repair_eval !=NULL ) + error = sc->ops->repair_eval (sc); +else + error = sc->ops->scrub (sc); run.scrub_ns +=xchk_stats_elapsed_ns (check_start);if (error == -EDEADLOCK && !(sc->flags &XCHK_TRY_HARDER )) goto try_harder;
@@ -544,8 +549,7 @@ xfs_scrub_metadata(xchk_update_health (sc); -if ((sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && - !(sc->flags &XREP_ALREADY_FIXED )) { +if (xchk_could_repair (sc)) {bool needs_fix =xchk_needs_repair (sc->sm);/* Userspace asked us to rebuild the structure regardless. */
fs/xfs/scrub/scrub.h +8 -0
@@ -35,6 +35,14 @@ struct xchk_meta_ops {/* Repair or optimize the metadata. */ int (*repair)(struct xfs_scrub *); +/* +* Re-scrub the metadata we repaired, in case there's extra work that +* we need to do to check our repair work. If this is NULL, we'll use +* the ->scrub function pointer, assuming that the regular scrub is +* sufficient. +*/ +int (*repair_eval)(struct xfs_scrub *sc); +/* Decide if we even have this piece of metadata. */ bool (*has)(struct xfs_mount *);
fs/xfs/scrub/trace.h +23 -1
@@ -1171,11 +1171,33 @@ DEFINE_EVENT(xrep_rmap_class, name, \ xfs_agblock_t agbno, xfs_extlen_t len, \ uint64_t owner, uint64_t offset, unsigned int flags), \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) -DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn); DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);DEFINE_REPAIR_RMAP_EVENT (xrep_rmap_extent_fn);DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_extent_fn); +TRACE_EVENT (xrep_abt_found, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + const struct xfs_alloc_rec_incore *rec), +TP_ARGS (mp, agno, rec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, startblock) +__field (xfs_extlen_t, blockcount) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->startblock = rec->ar_startblock; + __entry->blockcount = rec->ar_blockcount; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->startblock, + __entry->blockcount) +) + TRACE_EVENT(xrep_refcount_extent_fn, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, struct xfs_refcount_irec *irec),
fs/xfs/scrub/xfarray.h +22 -0
@@ -54,6 +54,28 @@ static inline int xfarray_append(struct xfarray *array, const void *ptr)uint64_t xfarray_length (struct xfarray *array);int xfarray_load_next (struct xfarray *array,xfarray_idx_t *idx,void *rec); +/* +* Iterate the non-null elements in a sparse xfarray. Callers should +* initialize *idx to XFARRAY_CURSOR_INIT before the first call; on return, it +* will be set to one more than the index of the record that was retrieved. +* Returns 1 if a record was retrieved, 0 if there weren't any more records, or +* a negative errno. +*/ +static inline int +xfarray_iter ( +struct xfarray *array, +xfarray_idx_t *idx, +void *rec) +{ +int ret =xfarray_load_next (array, idx, rec); + +if (ret == -ENODATA ) +return 0 ; +if (ret ==0 ) +return 1 ; +return ret; +} +/* Declarations for xfile array sort functionality. */ typedef cmp_func_t xfarray_cmp_fn ;
fs/xfs/xfs_extent_busy.c +13 -0
@@ -655,3 +655,16 @@ xfs_extent_busy_ag_cmp( diff = b1->bno - b2->bno;return diff; } + +/* Are there any busy extents in this AG? */ +bool +xfs_extent_busy_list_empty ( +struct xfs_perag *pag) +{ +bool res; + +spin_lock (&pag->pagb_lock); + res =RB_EMPTY_ROOT (&pag->pagb_tree); +spin_unlock (&pag->pagb_lock); +return res; +}
fs/xfs/xfs_extent_busy.h +2 -0
@@ -67,4 +67,6 @@ static inline void xfs_extent_busy_sort(struct list_head *list) list_sort(NULL, list, xfs_extent_busy_ag_cmp); } +bool xfs_extent_busy_list_empty (struct xfs_perag *pag); +#endif /* __XFS_EXTENT_BUSY_H__ */
PATCH 3/4 xfs: repair inode btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the rmapbt to find inode chunks, query the chunks to compute hole and free masks, and with that information rebuild the inobt and finobt.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ialloc.c | 41 +- fs/xfs/libxfs/xfs_ialloc.h | 3 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/ialloc_repair.c | 874 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 59 +++ fs/xfs/scrub/repair.h | 17 + fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/scrub.h | 1 fs/xfs/scrub/trace.h | 68 ++- 10 files changed, 1022 insertions(+), 49 deletions(-) create mode 100644 fs/xfs/scrub/ialloc_repair.c
fs/xfs/Makefile +1 -0
@@ -182,6 +182,7 @@ ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ + ialloc_repair.o \ newbt.o \ reap.o \ repair.o \
fs/xfs/libxfs/xfs_ialloc.c +28 -13
63 lines not on this page · raw message
fs/xfs/libxfs/xfs_ialloc.h +3 -0
@@ -79,6 +79,7 @@ int xfs_inobt_lookup(struct xfs_btree_cur *cur, xfs_agino_t ino,*/ int xfs_inobt_get_rec (struct xfs_btree_cur *cur,xfs_inobt_rec_incore_t *rec,int *stat); +uint8_t xfs_inobt_rec_freecount (const struct xfs_inobt_rec_incore *irec);/* * Inode chunk initialisation routine
@@ -93,6 +94,8 @@ union xfs_btree_rec;void xfs_inobt_btrec_to_irec (struct xfs_mount *mp,const union xfs_btree_rec *rec,struct xfs_inobt_rec_incore *irec); +xfs_failaddr_t xfs_inobt_check_perag_irec (struct xfs_perag *pag, +const struct xfs_inobt_rec_incore *irec);xfs_failaddr_t xfs_inobt_check_irec (struct xfs_btree_cur *cur,const struct xfs_inobt_rec_incore *irec); int xfs_ialloc_has_inodes_at_extent(struct xfs_btree_cur *cur,
fs/xfs/scrub/common.c +1 -0
@@ -605,6 +605,7 @@ xchk_ag_free( struct xchk_ag *sa) {xchk_ag_btcur_free (sa); +xrep_reset_perag_resv (sc);if (sa->agf_bp) {xfs_trans_brelse (sc->tp, sa->agf_bp); sa->agf_bp =NULL ;
fs/xfs/scrub/ialloc_repair.c new file +874 -0
874 lines not on this page · raw message
fs/xfs/scrub/repair.c +59 -0
62 lines not on this page · raw message
fs/xfs/scrub/repair.h +17 -0
@@ -59,6 +59,7 @@ int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp, struct xrep_find_ag_btree *btree_info, struct xfs_buf *agfl_bp);void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc);
@@ -68,6 +69,7 @@ void xrep_ag_btcur_init(struct xfs_scrub *sc, struct xchk_ag *sa);/* Metadata revalidators */ int xrep_revalidate_allocbt (struct xfs_scrub *sc); +int xrep_revalidate_iallocbt (struct xfs_scrub *sc);/* Metadata repairers */
@@ -77,8 +79,10 @@ int xrep_agf(struct xfs_scrub *sc);int xrep_agfl (struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc); +int xrep_iallocbt (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc); +int xrep_reinit_pagi (struct xfs_scrub *sc);#else
@@ -99,6 +103,17 @@ xrep_calc_ag_resblks(return 0 ; } +static inline int +xrep_reset_perag_resv ( +struct xfs_scrub *sc) +{ +if (!(sc->flags &XREP_RESET_PERAG_RESV )) +return 0 ; + +ASSERT (0 ); +return -EOPNOTSUPP ; +} +/* repair setup functions for no-repair */ static inline int xrep_setup_nothing(
@@ -109,6 +124,7 @@ xrep_setup_nothing(#define xrep_setup_ag_allocbt xrep_setup_nothing#define xrep_revalidate_allocbt (NULL) +#define xrep_revalidate_iallocbt (NULL)#define xrep_probe xrep_notsupported#define xrep_superblock xrep_notsupported
@@ -116,6 +132,7 @@ xrep_setup_nothing(#define xrep_agfl xrep_notsupported#define xrep_agi xrep_notsupported#define xrep_allocbt xrep_notsupported +#define xrep_iallocbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +4 -2
@@ -255,14 +255,16 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_PERAG, .setup = xchk_setup_ag_iallocbt, .scrub = xchk_inobt, - .repair = xrep_notsupported, + .repair = xrep_iallocbt, + .repair_eval = xrep_revalidate_iallocbt, }, [XFS_SCRUB_TYPE_FINOBT] = { /* finobt */ .type = ST_PERAG, .setup = xchk_setup_ag_iallocbt, .scrub = xchk_finobt, .has = xfs_has_finobt, - .repair = xrep_notsupported, + .repair = xrep_iallocbt, + .repair_eval = xrep_revalidate_iallocbt, }, [XFS_SCRUB_TYPE_RMAPBT] = { /* rmapbt */ .type = ST_PERAG,
fs/xfs/scrub/scrub.h +1 -0
@@ -121,6 +121,7 @@ struct xfs_scrub {#define XCHK_HAVE_FREEZE_PROT (1U << 1)/* do we have freeze protection? */ #define XCHK_FSGATES_DRAIN (1U << 2)/* defer ops draining enabled */ #define XCHK_NEED_DRAIN (1U << 3)/* scrub needs to drain defer ops */ +#define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */ /*
fs/xfs/scrub/trace.h +34 -34
92 lines not on this page · raw message
PATCH 4/4 xfs: repair refcount btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Reconstruct the refcount data from the rmap btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.h | 1 fs/xfs/libxfs/xfs_btree.c | 26 + fs/xfs/libxfs/xfs_btree.h | 2 fs/xfs/libxfs/xfs_refcount.c | 18 + fs/xfs/libxfs/xfs_refcount.h | 2 fs/xfs/libxfs/xfs_refcount_btree.c | 13 + fs/xfs/scrub/refcount_repair.c | 793 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 22 + 11 files changed, 864 insertions(+), 18 deletions(-) create mode 100644 fs/xfs/scrub/refcount_repair.c
fs/xfs/Makefile +1 -0
@@ -185,6 +185,7 @@ xfs-y += $(addprefix scrub/, \ ialloc_repair.o \ newbt.o \ reap.o \ + refcount_repair.o \ repair.o \ ) endif
fs/xfs/libxfs/xfs_ag.h +1 -0
@@ -87,6 +87,7 @@ struct xfs_perag {* verifiers while rebuilding the AG btrees. */ uint8_t pagf_alt_levels[XFS_BTNUM_AGF ]; +uint8_t pagf_alt_refcount_level;#endif spinlock_t pag_state_lock;
fs/xfs/libxfs/xfs_btree.c +26 -0
@@ -5212,3 +5212,29 @@ xfs_btree_destroy_cur_caches(void)xfs_rmapbt_destroy_cur_cache ();xfs_refcountbt_destroy_cur_cache (); } + +/* Move the btree cursor before the first record. */ +int +xfs_btree_goto_left_edge ( +struct xfs_btree_cur *cur) +{ +int stat =0 ; +int error; + +memset (&cur->bc_rec,0 ,sizeof (cur->bc_rec)); + error =xfs_btree_lookup (cur,XFS_LOOKUP_LE , &stat); +if (error) +return error; +if (!stat) +return 0 ; + + error =xfs_btree_decrement (cur,0 , &stat); +if (error) +return error; +if (stat !=0 ) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +return 0 ; +}
fs/xfs/libxfs/xfs_btree.h +2 -0
@@ -738,4 +738,6 @@ xfs_btree_alloc_cursor(int __init xfs_btree_init_cur_caches (void );void xfs_btree_destroy_cur_caches (void ); +int xfs_btree_goto_left_edge (struct xfs_btree_cur *cur); +#endif /* __XFS_BTREE_H__ */
fs/xfs/libxfs/xfs_refcount.c +12 -6
@@ -120,14 +120,11 @@ xfs_refcount_btrec_to_irec( irec->rc_refcount =be32_to_cpu (rec->refc.rc_refcount); } -/* Simple checks for refcount records. */ -xfs_failaddr_t -xfs_refcount_check_irec ( -struct xfs_btree_cur *cur, +inline xfs_failaddr_t +xfs_refcount_check_perag_irec ( +struct xfs_perag *pag,const struct xfs_refcount_irec *irec) { -struct xfs_perag *pag = cur->bc_ag.pag; -if (irec->rc_blockcount ==0 || irec->rc_blockcount >MAXREFCEXTLEN )return __this_address;
@@ -144,6 +141,15 @@ xfs_refcount_check_irec(return NULL ; } +/* Simple checks for refcount records. */ +xfs_failaddr_t +xfs_refcount_check_irec ( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *irec) +{ +return xfs_refcount_check_perag_irec (cur->bc_ag.pag, irec); +} + static inline int xfs_refcount_complain_bad_rec( struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_refcount.h +2 -0
@@ -117,6 +117,8 @@ extern int xfs_refcount_has_records(struct xfs_btree_cur *cur,union xfs_btree_rec ;extern void xfs_refcount_btrec_to_irec (const union xfs_btree_rec *rec,struct xfs_refcount_irec *irec); +xfs_failaddr_t xfs_refcount_check_perag_irec (struct xfs_perag *pag, +const struct xfs_refcount_irec *irec);xfs_failaddr_t xfs_refcount_check_irec (struct xfs_btree_cur *cur,const struct xfs_refcount_irec *irec); extern int xfs_refcount_insert(struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_refcount_btree.c +12 -1
@@ -226,7 +226,18 @@ xfs_refcountbt_verify( level =be16_to_cpu (block->bb_level);if (pag &&xfs_perag_initialised_agf (pag)) { -if (level >= pag->pagf_refcount_level) +unsigned int maxlevel = pag->pagf_refcount_level; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Online repair could be rewriting the refcount btree, so +* we'll validate against the larger of either tree while this +* is going on. +*/ + maxlevel = max_t(unsigned int, maxlevel, + pag->pagf_alt_refcount_level); +#endif +if (level >= maxlevel)return __this_address; }else if (level >= mp->m_refc_maxlevels)return __this_address;
fs/xfs/scrub/refcount_repair.c new file +793 -0
793 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -80,6 +80,7 @@ int xrep_agfl(struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc); +int xrep_refcountbt (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -133,6 +134,7 @@ xrep_setup_nothing(#define xrep_agi xrep_notsupported#define xrep_allocbt xrep_notsupported#define xrep_iallocbt xrep_notsupported +#define xrep_refcountbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -278,7 +278,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .setup = xchk_setup_ag_refcountbt, .scrub = xchk_refcountbt, .has = xfs_has_reflink, - .repair = xrep_notsupported, + .repair = xrep_refcountbt, }, [XFS_SCRUB_TYPE_INODE] = { /* inode record */ .type = ST_INODE,
fs/xfs/scrub/trace.h +12 -10
@@ -1231,27 +1231,29 @@ TRACE_EVENT(xrep_ibt_found, __entry->freemask) ) -TRACE_EVENT (xrep_refcount_extent_fn, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, - struct xfs_refcount_irec *irec), -TP_ARGS (mp, agno, irec), +TRACE_EVENT (xrep_refc_found, + TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *rec), +TP_ARGS (pag, rec),TP_STRUCT__entry ( __field(dev_t, dev) __field(xfs_agnumber_t, agno) + __field(enum xfs_refc_domain, domain) __field(xfs_agblock_t, startblock) __field(xfs_extlen_t, blockcount)__field (xfs_nlink_t, refcount) ),TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->startblock = irec->rc_startblock; - __entry->blockcount = irec->rc_blockcount; - __entry->refcount = irec->rc_refcount; + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->agno = pag->pag_agno; + __entry->domain = rec->rc_domain; + __entry->startblock = rec->rc_startblock; + __entry->blockcount = rec->rc_blockcount; + __entry->refcount = rec->rc_refcount; ), -TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x refcount %u" , +TP_printk ("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->agno, +__print_symbolic (__entry->domain,XFS_REFC_DOMAIN_STRINGS ), __entry->startblock, __entry->blockcount, __entry->refcount)
cover xfs: online repair of inodes and forks
In reply to Darrick J. WongHi all,
In this series, online repair gains the ability to repair inode records. To do this, we must repair the ondisk inode and fork information enough to pass the iget verifiers and hence make the inode igettable again. Once that's done, we can perform higher level repairs on the incore inode. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-inodes
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-inodes
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-inodes
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_attr_leaf.c | 32 - fs/xfs/libxfs/xfs_attr_leaf.h | 2 fs/xfs/libxfs/xfs_bmap.c | 22 fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_dir2_priv.h | 2 fs/xfs/libxfs/xfs_dir2_sf.c | 29 - fs/xfs/libxfs/xfs_format.h | 3 fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/libxfs/xfs_symlink_remote.c | 21 fs/xfs/scrub/bmap.c | 48 + fs/xfs/scrub/common.c | 26 + fs/xfs/scrub/common.h | 8 fs/xfs/scrub/dir.c | 21 fs/xfs/scrub/inode.c | 14 fs/xfs/scrub/inode_repair.c | 1650 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/parent.c | 17 fs/xfs/scrub/repair.c | 57 + fs/xfs/scrub/repair.h | 29 + fs/xfs/scrub/rtbitmap.c | 4 fs/xfs/scrub/rtsummary.c | 4 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 174 ++++ 23 files changed, 2119 insertions(+), 50 deletions(-) create mode 100644 fs/xfs/scrub/inode_repair.c
PATCH 1/7 xfs: disable online repair quota helpers when quota not enabled
From: Darrick J. Wong <[email protected]>
Don't compile the quota helper functions if quota isn't being built into the XFS module.
--- fs/xfs/scrub/repair.c | 2 ++ fs/xfs/scrub/repair.h | 9 +++++++++ 2 files changed, 11 insertions(+)
fs/xfs/scrub/repair.c +2 -0
@@ -673,6 +673,7 @@ xrep_find_ag_btree_roots(return error; } +#ifdef CONFIG_XFS_QUOTA /* Force a quotacheck the next time we mount. */ void xrep_force_quotacheck(
@@ -734,6 +735,7 @@ xrep_ino_dqattach( return error; } +#endif /* CONFIG_XFS_QUOTA */ /* Initialize all the btree cursors for an AG repair. */ void
fs/xfs/scrub/repair.h +9 -0
@@ -57,8 +57,15 @@ struct xrep_find_ag_btree {int xrep_find_ag_btree_roots (struct xfs_scrub *sc,struct xfs_buf *agf_bp,struct xrep_find_ag_btree *btree_info,struct xfs_buf *agfl_bp); + +#ifdef CONFIG_XFS_QUOTA void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +#else +# define xrep_force_quotacheck (sc, type) ((void)0) +# define xrep_ino_dqattach (sc) (0) +#endif /* CONFIG_XFS_QUOTA */ +int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */
@@ -87,6 +94,8 @@ int xrep_reinit_pagi(struct xfs_scrub *sc);#else +#define xrep_ino_dqattach (sc) (0) + static inline int xrep_attempt( struct xfs_scrub *sc,
PATCH 2/7 xfs: try to attach dquots to files before repairing them
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Inode resource usage is tracked in the quota metadata. Repairing a file might change the resources used by that file, which means that we need to attach dquots to the file that we're examining before accessing anything in the file protected by the ILOCK.
However, there's a twist: a dquot cache miss requires the dquot to be read in from the quota file, during which we drop the ILOCK on the file being examined. This means that we *must* try to attach the dquots before taking the ILOCK.
Therefore, dquots must be attached to files in the scrub setup function. If doing so yields corruption errors (or unknown dquot errors), we instead clear the quotachecked status, which will cause a quotacheck on next mount. A future series will make this trigger live quotacheck.
While we're here, change the xrep_ino_dqattach function to use the unlocked dqattach functions so that we avoid cycling the ILOCK if the inode already has dquots attached. This makes the naming and locking requirements consistent with the rest of the filesystem.
--- fs/xfs/scrub/bmap.c | 4 ++++ fs/xfs/scrub/common.c | 25 +++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 ++++++ fs/xfs/scrub/inode.c | 4 ++++ fs/xfs/scrub/repair.c | 13 ++++++++----- fs/xfs/scrub/rtbitmap.c | 4 ++++ fs/xfs/scrub/rtsummary.c | 4 ++++ 7 files changed, 55 insertions(+), 5 deletions(-)
fs/xfs/scrub/bmap.c +4 -0
@@ -78,6 +78,10 @@ xchk_setup_inode_bmap(if (error) goto out; + error =xchk_ino_dqattach (sc); +if (error) + goto out; +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode */
fs/xfs/scrub/common.c +25 -0
@@ -820,6 +820,26 @@ xchk_iget_agi(return 0 ; } +#ifdef CONFIG_XFS_QUOTA +/* +* Try to attach dquots to this inode if we think we might want to repair it. +* Callers must not hold any ILOCKs. If the dquots are broken and cannot be +* attached, a quotacheck will be scheduled. +*/ +int +xchk_ino_dqattach ( +struct xfs_scrub *sc) +{ +ASSERT (sc->tp !=NULL ); +ASSERT (sc->ip !=NULL ); + +if (!xchk_could_repair (sc)) +return 0 ; + +return xrep_ino_dqattach (sc); +} +#endif +/* Install an inode that we opened by handle for scrubbing. */ int xchk_install_handle_inode(
@@ -1031,6 +1051,11 @@ xchk_setup_inode_contents( error =xchk_trans_alloc (sc, resblks);if (error) goto out; + + error =xchk_ino_dqattach (sc); +if (error) + goto out; +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode for us */
fs/xfs/scrub/common.h +6 -0
@@ -103,9 +103,15 @@ xchk_setup_rtsummary(struct xfs_scrub *sc) }#endif #ifdef CONFIG_XFS_QUOTA +int xchk_ino_dqattach (struct xfs_scrub *sc);int xchk_setup_quota (struct xfs_scrub *sc);#else static inline int +xchk_ino_dqattach (struct xfs_scrub *sc) +{ +return 0 ; +} +static inline int xchk_setup_quota (struct xfs_scrub *sc) {return -ENOENT ;
fs/xfs/scrub/inode.c +4 -0
@@ -38,6 +38,10 @@ xchk_prepare_iscrub(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +xchk_ilock (sc,XFS_ILOCK_EXCL );return 0 ; }
fs/xfs/scrub/repair.c +8 -5
@@ -700,10 +700,10 @@ xrep_force_quotacheck(* * This function ensures that the appropriate dquots are attached to an inode. * We cannot allow the dquot code to allocate an on-disk dquot block here -* because we're already in transaction context with the inode locked. The -* on-disk dquot should already exist anyway. If the quota code signals -* corruption or missing quota information, schedule quotacheck, which will -* repair corruptions in the quota metadata. +* because we're already in transaction context. The on-disk dquot should +* already exist anyway. If the quota code signals corruption or missing quota +* information, schedule quotacheck, which will repair corruptions in the quota +* metadata. */ int xrep_ino_dqattach(
@@ -711,7 +711,10 @@ xrep_ino_dqattach( {int error; - error =xfs_qm_dqattach_locked (sc->ip, false); +ASSERT (sc->tp !=NULL ); +ASSERT (sc->ip !=NULL ); + + error =xfs_qm_dqattach (sc->ip);switch (error) {case -EFSBADCRC :case -EFSCORRUPTED :
fs/xfs/scrub/rtbitmap.c +4 -0
@@ -32,6 +32,10 @@ xchk_setup_rtbitmap(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP );return 0 ; }
fs/xfs/scrub/rtsummary.c +4 -0
@@ -63,6 +63,10 @@ xchk_setup_rtsummary(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +/* * Locking order requires us to take the rtbitmap first. We must be * careful to unlock it ourselves when we are done with the rtbitmap
PATCH 3/7 xfs: repair inode records
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If an inode is so badly damaged that it cannot be loaded into the cache, fix the ondisk metadata and try again. If there /is/ a cached inode, fix any problems and apply any optimizations that can be solved incore.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_format.h | 3 fs/xfs/scrub/inode.c | 10 - fs/xfs/scrub/inode_repair.c | 795 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 42 ++ fs/xfs/scrub/repair.h | 20 + fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 129 +++++++ 8 files changed, 999 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/inode_repair.c
fs/xfs/Makefile +1 -0
@@ -183,6 +183,7 @@ xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ ialloc_repair.o \ + inode_repair.o \ newbt.o \ reap.o \ refcount_repair.o \
fs/xfs/libxfs/xfs_format.h +2 -1
@@ -996,7 +996,8 @@ enum xfs_dinode_fmt {#define XFS_DFORK_APTR (dip) \ (XFS_DFORK_DPTR(dip) + XFS_DFORK_BOFF(dip))#define XFS_DFORK_PTR (dip,w) \ - ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip)) + ((void *)((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : \ + XFS_DFORK_APTR(dip)))#define XFS_DFORK_FORMAT (dip,w) \ ((w) == XFS_DATA_FORK ? \
fs/xfs/scrub/inode.c +9 -1
@@ -24,6 +24,7 @@#include "scrub/common.h" #include "scrub/btree.h" #include "scrub/trace.h" +#include "scrub/repair.h" /* Prepare the attached inode for scrubbing. */ static inline int
@@ -184,8 +185,11 @@ xchk_setup_inode(* saying the inode is allocated and the icache being unable to load * the inode until we can flag the corruption in xchk_inode. The * scrub function has to note the corruption, since we're not really -* supposed to do that from the setup function. +* supposed to do that from the setup function. Save the mapping to +* make repairs to the ondisk inode buffer. */ +if (xchk_could_repair (sc)) +xrep_setup_inode (sc, &imap);return 0 ; out_cancel:
@@ -341,6 +345,10 @@ xchk_inode_flags2(if (xfs_dinode_has_bigtime (dip) && !xfs_has_bigtime (mp)) goto bad; +/* no large extent counts without the filesystem feature */ +if ((flags2 &XFS_DIFLAG2_NREXT64 ) && !xfs_has_large_extent_counts (mp)) + goto bad; +return ; bad:xchk_ino_set_corrupt (sc, ino);
fs/xfs/scrub/inode_repair.c new file +795 -0
795 lines not on this page · raw message
fs/xfs/scrub/repair.c +42 -0
54 lines not on this page · raw message
fs/xfs/scrub/repair.h +20 -0
@@ -30,11 +30,22 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)int xrep_attempt (struct xfs_scrub *sc,struct xchk_stats_run *run);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc); +int xrep_roll_trans (struct xfs_scrub *sc);int xrep_defer_finish (struct xfs_scrub *sc);bool xrep_ag_has_space (struct xfs_perag *pag,xfs_extlen_t nr_blocks,enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc); +static inline int +xrep_trans_commit ( +struct xfs_scrub *sc) +{ +int error =xfs_trans_commit (sc->tp); + + sc->tp =NULL ; +return error; +} +struct xbitmap ;struct xagb_bitmap ;
@@ -66,11 +77,16 @@ int xrep_ino_dqattach(struct xfs_scrub *sc);# define xrep_ino_dqattach (sc) (0)#endif /* CONFIG_XFS_QUOTA */ +int xrep_ino_ensure_extent_count (struct xfs_scrub *sc,int whichfork, +xfs_extnum_t nextents);int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc); +struct xfs_imap ; +int xrep_setup_inode (struct xfs_scrub *sc,struct xfs_imap *imap); +void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa);/* Metadata revalidators */
@@ -88,6 +104,7 @@ int xrep_agi(struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc);int xrep_refcountbt (struct xfs_scrub *sc); +int xrep_inode (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -133,6 +150,8 @@ xrep_setup_nothing( }#define xrep_setup_ag_allocbt xrep_setup_nothing +#define xrep_setup_inode (sc, imap) ((void)0) +#define xrep_revalidate_allocbt (NULL)#define xrep_revalidate_iallocbt (NULL)
@@ -144,6 +163,7 @@ xrep_setup_nothing(#define xrep_allocbt xrep_notsupported#define xrep_iallocbt xrep_notsupported#define xrep_refcountbt xrep_notsupported +#define xrep_inode xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -284,7 +284,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode, .scrub = xchk_inode, - .repair = xrep_notsupported, + .repair = xrep_inode, }, [XFS_SCRUB_TYPE_BMBTD] = { /* inode data fork */ .type = ST_INODE,
fs/xfs/scrub/trace.h +129 -0
135 lines not on this page · raw message
PATCH 4/7 xfs: zap broken inode forks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Determine if inode fork damage is responsible for the inode being unable to pass the ifork verifiers in xfs_iget and zap the fork contents if this is true. Once this is done the fork will be empty but we'll be able to construct an in-core inode, and a subsequent call to the inode fork repair ioctl will search the rmapbt to rebuild the records that were in the fork.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 32 +- fs/xfs/libxfs/xfs_attr_leaf.h | 2 fs/xfs/libxfs/xfs_bmap.c | 22 + fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_dir2_priv.h | 2 fs/xfs/libxfs/xfs_dir2_sf.c | 29 +- fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/libxfs/xfs_symlink_remote.c | 21 + fs/xfs/scrub/inode_repair.c | 696 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/trace.h | 42 ++ 10 files changed, 812 insertions(+), 37 deletions(-)
fs/xfs/libxfs/xfs_attr_leaf.c +21 -11
@@ -1040,23 +1040,16 @@ xfs_attr_shortform_allfit(return xfs_attr_shortform_bytesfit (dp, bytes); } -/* Verify the consistency of an inline attribute fork. */ +/* Verify the consistency of a raw inline attribute fork. */ xfs_failaddr_t -xfs_attr_shortform_verify ( -struct xfs_inode *ip) +xfs_attr_shortform_verify_struct ( +struct xfs_attr_shortform *sfp, +size_t size) { -struct xfs_attr_shortform *sfp;struct xfs_attr_sf_entry *sfep;struct xfs_attr_sf_entry *next_sfep;char *endp; -struct xfs_ifork *ifp;int i; -int64_t size; - -ASSERT (ip->i_af.if_format ==XFS_DINODE_FMT_LOCAL ); - ifp =xfs_ifork_ptr (ip,XFS_ATTR_FORK ); - sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data; - size = ifp->if_bytes;/* * Give up if the attribute is way too short.
@@ -1116,6 +1109,23 @@ xfs_attr_shortform_verify(return NULL ; } +/* Verify the consistency of an inline attribute fork. */ +xfs_failaddr_t +xfs_attr_shortform_verify ( +struct xfs_inode *ip) +{ +struct xfs_attr_shortform *sfp; +struct xfs_ifork *ifp; +int64_t size; + +ASSERT (ip->i_af.if_format ==XFS_DINODE_FMT_LOCAL ); + ifp =xfs_ifork_ptr (ip,XFS_ATTR_FORK ); + sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data; + size = ifp->if_bytes; + +return xfs_attr_shortform_verify_struct (sfp, size); +} +/* * Convert a leaf attribute list to shortform attribute list */
fs/xfs/libxfs/xfs_attr_leaf.h +2 -0
@@ -56,6 +56,8 @@ int xfs_attr_sf_findname(struct xfs_da_args *args, unsigned int *basep);int xfs_attr_shortform_allfit (struct xfs_buf *bp,struct xfs_inode *dp);int xfs_attr_shortform_bytesfit (struct xfs_inode *dp,int bytes); +xfs_failaddr_t xfs_attr_shortform_verify_struct (struct xfs_attr_shortform *sfp, +size_t size);xfs_failaddr_t xfs_attr_shortform_verify (struct xfs_inode *ip);void xfs_attr_fork_remove (struct xfs_inode *ip,struct xfs_trans *tp);
fs/xfs/libxfs/xfs_bmap.c +16 -6
@@ -6196,19 +6196,18 @@ xfs_bmap_finish_one(return error; } -/* Check that an inode's extent does not have invalid flags or bad ranges. */ +/* Check that an extent does not have invalid flags or bad ranges. */ xfs_failaddr_t -xfs_bmap_validate_extent ( -struct xfs_inode *ip, +xfs_bmap_validate_extent_raw ( +struct xfs_mount *mp, +bool rtfile,int whichfork,struct xfs_bmbt_irec *irec) { -struct xfs_mount *mp = ip->i_mount; -if (!xfs_verify_fileext (mp, irec->br_startoff, irec->br_blockcount))return __this_address; -if (XFS_IS_REALTIME_INODE (ip) && whichfork ==XFS_DATA_FORK ) { +if (rtfile && whichfork ==XFS_DATA_FORK ) {if (!xfs_verify_rtext (mp, irec->br_startblock, irec->br_blockcount))return __this_address;
@@ -6238,3 +6237,14 @@ xfs_bmap_intent_destroy_cache(void)kmem_cache_destroy (xfs_bmap_intent_cache); xfs_bmap_intent_cache =NULL ; } + +/* Check that an inode's extent does not have invalid flags or bad ranges. */ +xfs_failaddr_t +xfs_bmap_validate_extent ( +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *irec) +{ +return xfs_bmap_validate_extent_raw (ip->i_mount, +XFS_IS_REALTIME_INODE (ip), whichfork, irec); +}
fs/xfs/libxfs/xfs_bmap.h +2 -0
@@ -263,6 +263,8 @@ static inline uint32_t xfs_bmap_fork_to_state(int whichfork) } } +xfs_failaddr_t xfs_bmap_validate_extent_raw (struct xfs_mount *mp,bool rtfile, +int whichfork,struct xfs_bmbt_irec *irec);xfs_failaddr_t xfs_bmap_validate_extent (struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *irec); int xfs_bmap_complain_bad_rec(struct xfs_inode *ip, int whichfork,
fs/xfs/libxfs/xfs_dir2_priv.h +2 -0
@@ -175,6 +175,8 @@ extern int xfs_dir2_sf_create(struct xfs_da_args *args, xfs_ino_t pino);extern int xfs_dir2_sf_lookup (struct xfs_da_args *args);extern int xfs_dir2_sf_removename (struct xfs_da_args *args);extern int xfs_dir2_sf_replace (struct xfs_da_args *args); +extern xfs_failaddr_t xfs_dir2_sf_verify_struct (struct xfs_mount *mp, +struct xfs_dir2_sf_hdr *sfp,int64_t size);extern xfs_failaddr_t xfs_dir2_sf_verify (struct xfs_inode *ip);int xfs_dir2_sf_entsize (struct xfs_mount *mp,struct xfs_dir2_sf_hdr *hdr,int len);
fs/xfs/libxfs/xfs_dir2_sf.c +18 -11
@@ -706,12 +706,11 @@ xfs_dir2_sf_check(/* Verify the consistency of an inline directory. */ xfs_failaddr_t -xfs_dir2_sf_verify ( -struct xfs_inode *ip) +xfs_dir2_sf_verify_struct ( +struct xfs_mount *mp, +struct xfs_dir2_sf_hdr *sfp, +int64_t size) { -struct xfs_mount *mp = ip->i_mount; -struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); -struct xfs_dir2_sf_hdr *sfp;struct xfs_dir2_sf_entry *sfep;struct xfs_dir2_sf_entry *next_sfep;char *endp;
@@ -719,15 +718,9 @@ xfs_dir2_sf_verify(int i;int i8count;int offset; -int64_t size;int error;uint8_t filetype; -ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); - - sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data; - size = ifp->if_bytes; -/* * Give up if the directory is way too short. */
@@ -803,6 +796,20 @@ xfs_dir2_sf_verify(return NULL ; } +xfs_failaddr_t +xfs_dir2_sf_verify ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +struct xfs_dir2_sf_hdr *sfp; + +ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); + + sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data; +return xfs_dir2_sf_verify_struct (mp, sfp, ifp->if_bytes); +} +/* * Create a new (shortform) directory. */
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -139,6 +139,7 @@ bool xfs_symlink_hdr_ok(xfs_ino_t ino, uint32_t offset, uint32_t size, struct xfs_buf *bp);void xfs_symlink_local_to_remote (struct xfs_trans *tp,struct xfs_buf *bp,struct xfs_inode *ip,struct xfs_ifork *ifp); +xfs_failaddr_t xfs_symlink_sf_verify_struct (void *sfp,int64_t size);xfs_failaddr_t xfs_symlink_shortform_verify (struct xfs_inode *ip);/* Computed inode geometry for the filesystem. */
fs/xfs/libxfs/xfs_symlink_remote.c +14 -7
@@ -201,16 +201,12 @@ xfs_symlink_local_to_remote(* does not do on-disk format checks. */ xfs_failaddr_t -xfs_symlink_shortform_verify ( -struct xfs_inode *ip) +xfs_symlink_sf_verify_struct ( +void *sfp, +int64_t size) { -struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); -char *sfp = (char *)ifp->if_u1.if_data; -int size = ifp->if_bytes;char *endp = sfp + size; -ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); -/* * Zero length symlinks should never occur in memory as they are * never allowed to exist on disk.
@@ -231,3 +227,14 @@ xfs_symlink_shortform_verify(return __this_address;return NULL ; } + +xfs_failaddr_t +xfs_symlink_shortform_verify ( +struct xfs_inode *ip) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); + +ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); + +return xfs_symlink_sf_verify_struct (ifp->if_u1.if_data, ifp->if_bytes); +}
fs/xfs/scrub/inode_repair.c +694 -2
754 lines not on this page · raw message
fs/xfs/scrub/trace.h +42 -0
54 lines not on this page · raw message
PATCH 5/7 xfs: abort directory parent scrub scans if we encounter a zapped directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In the previous patch, we added some code to perform sufficient repairs to an ondisk inode record such that the inode cache would be willing to load the inode. If the broken inode was a shortform directory, it will reset the directory to something plausible, which is to say an empty subdirectory of the root. The telltale signs that something is seriously wrong is the broken link count.
Such directories look clean, but they shouldn't participate in a filesystem scan to find or confirm a directory parent pointer. Create a predicate that identifies such directories and abort the scrub.
Found by fuzzing xfs/1554 with multithreaded xfs_scrub enabled and u3.bmx[0].startblock = zeroes.
--- fs/xfs/scrub/common.c | 1 + fs/xfs/scrub/common.h | 2 ++ fs/xfs/scrub/dir.c | 21 +++++++++++++++++++++ fs/xfs/scrub/parent.c | 17 +++++++++++++++++ 4 files changed, 41 insertions(+)
fs/xfs/scrub/common.c +1 -0
@@ -26,6 +26,7 @@#include "xfs_trans_priv.h" #include "xfs_da_format.h" #include "xfs_da_btree.h" +#include "xfs_dir2_priv.h" #include "xfs_attr.h" #include "xfs_reflink.h" #include "xfs_ag.h"
fs/xfs/scrub/common.h +2 -0
@@ -192,6 +192,8 @@ static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm) XFS_SCRUB_OFLAG_XCORRUPT); } +bool xchk_dir_looks_zapped (struct xfs_inode *dp); +#ifdef CONFIG_XFS_ONLINE_REPAIR /* Decide if a repair is required. */ static inline bool xchk_needs_repair (const struct xfs_scrub_metadata *sm)
fs/xfs/scrub/dir.c +21 -0
@@ -788,3 +788,24 @@ xchk_directory( error =0 ;return error; } + +/* +* Decide if this directory has been zapped to satisfy the inode and ifork +* verifiers. Checking and repairing should be postponed until the directory +* is fixed. +*/ +bool +xchk_dir_looks_zapped ( +struct xfs_inode *dp) +{ +/* +* If the dinode repair found a bad data fork, it will reset the fork +* to extents format with zero records and wait for the bmapbtd +* scrubber to reconstruct the block mappings. Directories always +* contain some content, so this is a clear sign of a zapped directory. +*/ +if (dp->i_df.if_format ==XFS_DINODE_FMT_EXTENTS ) +return dp->i_df.if_nextents ==0 ; + +return false; +}
fs/xfs/scrub/parent.c +17 -0
@@ -156,6 +156,16 @@ xchk_parent_validate( goto out_rele; } +/* +* We cannot yet validate this parent pointer if the directory looks as +* though it has been zapped by the inode record repair code. +*/ +if (xchk_dir_looks_zapped (dp)) { + error = -EBUSY ; +xchk_set_incomplete (sc); + goto out_unlock; + } +/* Look for a directory entry in the parent pointing to the child. */ error =xchk_dir_walk (sc, dp, xchk_parent_actor, &spc);if (!xchk_fblock_xref_process_error (sc,XFS_DATA_FORK ,0 , &error))
@@ -217,6 +227,13 @@ xchk_parent(*/ error =xchk_parent_validate (sc, parent_ino); }while (error == -EAGAIN ); +if (error == -EBUSY ) { +/* +* We could not scan a directory, so we marked the check +* incomplete. No further error return is necessary. +*/ +return 0 ; + }return error; }
PATCH 6/7 xfs: skip the rmapbt search on an empty attr fork unless we know it was zapped
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The attribute fork scrubber can optionally scan the reverse mapping records of the filesystem to determine if the fork is missing mappings that it should have. However, this is a very expensive operation, so we only want to do this if we suspect that the fork is missing records. For attribute forks the criteria for suspicion is that the attr fork is in EXTENTS format and has zero extents.
However, there are several ways that a file can end up in this state through regular filesystem usage. For example, an LSM can set a s_security hook but then decide not to set an ACL; or an attr set can create the attr fork but then the actual set operation fails with ENOSPC; or we can delete all the attrs on a file whose data fork is in btree format, in which case we do not delete the attr fork. We don't want to run the expensive check for any case that can be arrived at through regular operations.
However.
When online inode repair decides to zap an attribute fork, it cannot determine if it is zapping ACL information. As a precaution it removes all the discretionary access control permissions and sets the user and group ids to zero. Check these three additional conditions to decide if we want to scan the rmap records.
--- fs/xfs/scrub/bmap.c | 44 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 7 deletions(-)
fs/xfs/scrub/bmap.c +37 -7
@@ -662,16 +662,46 @@ xchk_bmap_want_check_rmaps(* The inode repair code zaps broken inode forks by resetting them back * to EXTENTS format and zero extent records. If we encounter a fork * in this state along with evidence that the fork isn't supposed to be -* empty, we need to scan the reverse mappings to decide if we're going -* to rebuild the fork. Data forks with nonzero file size are scanned. -* xattr forks are never empty of content, so they are always scanned. +* empty, we might want scan the reverse mappings to decide if we're +* going to rebuild the fork. */ ifp =xfs_ifork_ptr (sc->ip, info->whichfork);if (ifp->if_format ==XFS_DINODE_FMT_EXTENTS && ifp->if_nextents ==0 ) { -if (info->whichfork ==XFS_DATA_FORK && -i_size_read (VFS_I (sc->ip)) ==0 ) -return false; - +switch (info->whichfork) { +case XFS_DATA_FORK : +/* +* Data forks with zero file size are presumed not to +* have any written data blocks. Skip the scan. +*/ +if (i_size_read (VFS_I (sc->ip)) ==0 ) +return false; +break ; +case XFS_ATTR_FORK : +/* +* Files can have an attr fork in EXTENTS format with +* zero records for several reasons: +* +* a) an attr set created a fork but ran out of space +* b) attr replace deleted an old attr but failed +* during the set step +* c) the data fork was in btree format when all attrs +* were deleted, so the fork was left in place +* d) the inode repair code zapped the fork +* +* Only in case (d) do we want to scan the rmapbt to +* see if we need to rebuild the attr fork. The fork +* zap code clears all DAC permission bits and zeroes +* the uid and gid, so avoid the scan if any of those +* three conditions are not met. +*/ +if ((VFS_I (sc->ip)->i_mode &0777 ) !=0 ) +return false; +if (!uid_eq (VFS_I (sc->ip)->i_uid,GLOBAL_ROOT_UID )) +return false; +if (!gid_eq (VFS_I (sc->ip)->i_gid,GLOBAL_ROOT_GID )) +return false; +break ; + }return true; }
PATCH 7/7 xfs: repair obviously broken inode modes
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Building off the rmap scanner that we added in the previous patch, we can now find block 0 and try to use the information contained inside of it to guess the mode of an inode if it's totally improper.
--- fs/xfs/scrub/inode_repair.c | 181 +++++++++++++++++++++++++++++++++++++++++-- fs/xfs/scrub/trace.h | 11 ++- 2 files changed, 179 insertions(+), 13 deletions(-)
fs/xfs/scrub/inode_repair.c +172 -9
@@ -55,10 +55,13 @@* fix things on live incore inodes. The inode repair functions make decisions * with security and usability implications when reviving a file: * -* - Files with zero di_mode or a garbage di_mode are converted to regular file -* that only root can read. This file may not actually contain user data, -* if the file was not previously a regular file. Setuid and setgid bits -* are cleared. +* - Files with zero di_mode or a garbage di_mode are converted to a file +* that only root can read. If the immediate data fork area or block 0 of +* the data fork look like a directory, the file type will be set to a +* directory. If the immediate data fork area has no nulls, it will be +* turned into a symbolic link. Otherwise, it is turned into a regular file. +* This file may not actually contain user data, if the file was not +* previously a regular file. Setuid and setgid bits are cleared. * * - Zero-size directories can be truncated to look empty. It is necessary to * run the bmapbtd and directory repair functions to fully rebuild the
@@ -106,6 +109,9 @@ struct xrep_inode {/* Blocks in use by the attr fork. */ xfs_rfsblock_t attr_blocks; +/* Physical block containing data block 0. */ +xfs_fsblock_t block0; +/* Number of data device extents for the data fork. */ xfs_extnum_t data_extents;
@@ -145,6 +151,7 @@ xrep_setup_inode( ri = sc->buf;memcpy (&ri->imap, imap,sizeof (struct xfs_imap )); ri->sc = sc; + ri->block0 =NULLFSBLOCK ;return 0 ; }
@@ -220,12 +227,159 @@ xrep_dinode_header( dip->di_gen =cpu_to_be32 (sc->sm->sm_gen); } +/* Parse enough of the directory block header to guess if this is a dir. */ +static inline bool +xrep_dinode_is_dir ( +xfs_ino_t ino, +xfs_daddr_t daddr, +struct xfs_buf *bp) +{ +struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; +struct xfs_dir2_data_free *bf; +struct xfs_mount *mp = bp->b_mount; +xfs_lsn_t lsn =be64_to_cpu (hdr3->lsn); + +/* Does the dir3 header match the filesystem? */ +if (hdr3->magic !=cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ) && + hdr3->magic !=cpu_to_be32 (XFS_DIR3_DATA_MAGIC )) +return false; + +if (be64_to_cpu (hdr3->owner) != ino) +return false; + +if (!uuid_equal (&hdr3->uuid, &mp->m_sb.sb_meta_uuid)) +return false; + +if (be64_to_cpu (hdr3->blkno) != daddr) +return false; + +/* Directory blocks are always logged and must have a valid LSN. */ +if (lsn ==NULLCOMMITLSN ) +return false; +if (!xlog_valid_lsn (mp->m_log, lsn)) +return false; + +/* +* bestfree information lives immediately after the end of the header, +* so we won't run off the end of the buffer. +*/ + bf =xfs_dir2_data_bestfree_p (mp, bp->b_addr); +if (!bf[0 ].length && bf[0 ].offset) +return false; +if (!bf[1 ].length && bf[1 ].offset) +return false; +if (!bf[2 ].length && bf[2 ].offset) +return false; + +if (be16_to_cpu (bf[0 ].length) <be16_to_cpu (bf[1 ].length)) +return false; +if (be16_to_cpu (bf[1 ].length) <be16_to_cpu (bf[2 ].length)) +return false; + +return true; +} + +/* Guess the mode of this file from the contents. */ +STATIC uint16_t +xrep_dinode_guess_mode ( +struct xrep_inode *ri, +struct xfs_dinode *dip) +{ +struct xfs_buf *bp; +struct xfs_mount *mp = ri->sc->mp; +xfs_daddr_t daddr; +uint64_t fsize =be64_to_cpu (dip->di_size); +unsigned int dfork_sz =XFS_DFORK_DSIZE (dip, mp); +uint16_t mode =S_IFREG ; +int error; + +switch (dip->di_format) { +case XFS_DINODE_FMT_LOCAL : +/* +* If the data fork is local format, the size of the data area +* is reasonable and is big enough to contain the entire file, +* we can guess the file type from the local data. +* +* If there are no nulls, guess this is a symbolic link. +* Otherwise, this is probably a shortform directory. +*/ +if (dfork_sz <=XFS_LITINO (mp) && dfork_sz >= fsize) { +if (!memchr (XFS_DFORK_DPTR (dip),0 , fsize)) +return S_IFLNK ; +return S_IFDIR ; + } + +/* By default, we guess regular file. */ +return S_IFREG ; +case XFS_DINODE_FMT_DEV : +/* +* If the data fork is dev format, the size of the data area is +* reasonable and large enough to store a dev_t, and the file +* size is zero, this could be a blockdev, a chardev, a fifo, +* or a socket. There is no solid way to distinguish between +* those choices, so we guess blockdev if the device number is +* nonzero and chardev if it's zero (aka whiteout). +*/ +if (dfork_sz <=XFS_LITINO (mp) && + dfork_sz >=sizeof (__be32) && fsize ==0 ) { +xfs_dev_t dev =xfs_dinode_get_rdev (dip); + +return dev !=0 ?S_IFBLK :S_IFCHR ; + } + +/* By default, we guess regular file. */ +return S_IFREG ; +case XFS_DINODE_FMT_EXTENTS : +case XFS_DINODE_FMT_BTREE : +/* There are data blocks to examine below. */ +break ; +default : +/* Everything else is considered a regular file. */ +return S_IFREG ; + } + +/* There are no zero-length directories. */ +if (fsize ==0 ) +return S_IFREG ; + +/* +* If we didn't find a written mapping for file block zero, we'll guess +* that it's a sparse regular file. +*/ +if (ri->block0 ==NULLFSBLOCK ) +return S_IFREG ; + +/* Directories can't have rt extents. */ +if (ri->rt_extents >0 ) +return S_IFREG ; + +/* +* Read the first block of the file. Since we have no idea what kind +* of file geometry (e.g. dirblock size) we might be reading into, use +* an uncached buffer so that we don't pollute the buffer cache. We +* can't do uncached mapped buffers, so the best we can do is guess +* from the directory header. +*/ + daddr =XFS_FSB_TO_DADDR (mp, ri->block0); + error =xfs_buf_read_uncached (mp->m_ddev_targp, daddr, +XFS_FSS_TO_BB (mp,1 ),0 , &bp,NULL ); +if (error) +return S_IFREG ; + +if (xrep_dinode_is_dir (ri->sc->sm->sm_ino, daddr, bp)) + mode =S_IFDIR ; + +xfs_buf_relse (bp); +return mode; +} +/* Turn di_mode into /something/ recognizable. */ STATIC voidxrep_dinode_mode ( -struct xfs_scrub *sc, +struct xrep_inode *ri,struct xfs_dinode *dip) { +struct xfs_scrub *sc = ri->sc;uint16_t mode;trace_xrep_dinode_mode (sc, dip);
@@ -235,7 +389,7 @@ xrep_dinode_mode(return ;/* bad mode, so we set it to a file that only root can read */ - mode =S_IFREG ; + mode =xrep_dinode_guess_mode (ri, dip); dip->di_mode =cpu_to_be16 (mode); dip->di_uid =0 ; dip->di_gid =0 ;
@@ -442,9 +596,17 @@ xrep_dinode_walk_rmap( } ri->data_blocks += rec->rm_blockcount; -if (!(rec->rm_flags &XFS_RMAP_BMBT_BLOCK )) +if (!(rec->rm_flags &XFS_RMAP_BMBT_BLOCK )) { ri->data_extents++; +if (rec->rm_offset ==0 && + !(rec->rm_flags &XFS_RMAP_UNWRITTEN )) { +if (ri->block0 !=NULLFSBLOCK ) +return -EFSCORRUPTED ; + ri->block0 = rec->rm_startblock; + } + } +return 0 ; }
@@ -495,7 +657,8 @@ xrep_dinode_count_rmaps(trace_xrep_dinode_count_rmaps (ri->sc, ri->data_blocks, ri->rt_blocks, ri->attr_blocks, - ri->data_extents, ri->rt_extents, ri->attr_extents); + ri->data_extents, ri->rt_extents, ri->attr_extents, + ri->block0);return 0 ; }
@@ -1089,7 +1252,7 @@ xrep_dinode_core(/* Fix everything the verifier will complain about. */ dip =xfs_buf_offset (bp, ri->imap.im_boffset);xrep_dinode_header (sc, dip); -xrep_dinode_mode (sc, dip); +xrep_dinode_mode (ri, dip);xrep_dinode_flags (sc, dip, ri->rt_extents >0 );xrep_dinode_size (sc, dip);xrep_dinode_extsize_hints (sc, dip);
fs/xfs/scrub/trace.h +7 -4
@@ -1529,9 +1529,9 @@ TRACE_EVENT(xrep_dinode_count_rmaps, TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks, xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks, xfs_extnum_t data_extents, xfs_extnum_t rt_extents, - xfs_aextnum_t attr_extents), + xfs_aextnum_t attr_extents, xfs_fsblock_t block0),TP_ARGS (sc, data_blocks, rt_blocks, attr_blocks, data_extents, - rt_extents, attr_extents), + rt_extents, attr_extents, block0), TP_STRUCT__entry( __field(dev_t, dev) __field(xfs_ino_t, ino)
@@ -1541,6 +1541,7 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __field(xfs_extnum_t, data_extents) __field(xfs_extnum_t, rt_extents) __field(xfs_aextnum_t, attr_extents) +__field (xfs_fsblock_t, block0) ),TP_fast_assign ( __entry->dev = sc->mp->m_super->s_dev;
@@ -1551,8 +1552,9 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __entry->data_extents = data_extents; __entry->rt_extents = rt_extents; __entry->attr_extents = attr_extents; + __entry->block0 = block0; ), - TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u", + TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u startblock0 0x%llx", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->data_blocks,
@@ -1560,7 +1562,8 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __entry->attr_blocks, __entry->data_extents, __entry->rt_extents, - __entry->attr_extents) + __entry->attr_extents, + __entry->block0) );#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
cover xfs: online repair of file fork mappings
In reply to Darrick J. WongHi all,
In this series, online repair gains the ability to rebuild data and attr fork mappings from the reverse mapping information. It is at this point where we reintroduce the ability to reap file extents.
Repair of CoW forks is a little different -- on disk, CoW staging extents are owned by the refcount btree and cannot be mapped back to individual files. Hence we can only detect staging extents that don't quite look right (missing reverse mappings, shared staging extents) and replace them with fresh allocations.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-file-mappings
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-file-mappings
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-file-mappings
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_bmap_btree.c | 112 ++++- fs/xfs/libxfs/xfs_bmap_btree.h | 5 fs/xfs/libxfs/xfs_btree_staging.c | 11 fs/xfs/libxfs/xfs_btree_staging.h | 2 fs/xfs/libxfs/xfs_iext_tree.c | 23 + fs/xfs/libxfs/xfs_inode_fork.c | 1 fs/xfs/libxfs/xfs_inode_fork.h | 3 fs/xfs/libxfs/xfs_refcount.c | 41 ++ fs/xfs/libxfs/xfs_refcount.h | 10 fs/xfs/scrub/bitmap.h | 56 ++ fs/xfs/scrub/bmap.c | 18 + fs/xfs/scrub/bmap_repair.c | 846 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 fs/xfs/scrub/cow_repair.c | 609 +++++++++++++++++++++++++++ fs/xfs/scrub/reap.c | 152 ++++++- fs/xfs/scrub/reap.h | 2 fs/xfs/scrub/repair.c | 50 ++ fs/xfs/scrub/repair.h | 11 fs/xfs/scrub/scrub.c | 20 - fs/xfs/scrub/trace.h | 118 +++++ fs/xfs/xfs_trans.c | 95 ++++ fs/xfs/xfs_trans.h | 4 23 files changed, 2151 insertions(+), 46 deletions(-) create mode 100644 fs/xfs/scrub/bmap_repair.c create mode 100644 fs/xfs/scrub/cow_repair.c
PATCH 1/5 xfs: reintroduce reaping of file metadata blocks to xrep_reap_extents
From: Darrick J. Wong <[email protected]>
Reintroduce to xrep_reap_extents the ability to reap extents from any AG. We dropped this before because it was buggy, but in the next patch we will gain the ability to reap old bmap btrees, which can have blocks in any AG. To do this, we require that sc->sa is uninitialized, so that we can use it to hold all the per-AG context for a given extent.
--- fs/xfs/scrub/bitmap.h | 28 +++++++++++ fs/xfs/scrub/reap.c | 120 +++++++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/scrub/reap.h | 2 + fs/xfs/scrub/repair.h | 1 4 files changed, 147 insertions(+), 4 deletions(-)
fs/xfs/scrub/bitmap.h +28 -0
@@ -105,4 +105,32 @@ int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,int xagb_bitmap_set_btcur_path (struct xagb_bitmap *bitmap,struct xfs_btree_cur *cur); +/* Bitmaps, but for type-checked for xfs_fsblock_t */ + +struct xfsb_bitmap { +struct xbitmap fsbitmap; +}; + +static inline void xfsb_bitmap_init (struct xfsb_bitmap *bitmap) +{ +xbitmap_init (&bitmap->fsbitmap); +} + +static inline void xfsb_bitmap_destroy (struct xfsb_bitmap *bitmap) +{ +xbitmap_destroy (&bitmap->fsbitmap); +} + +static inline int xfsb_bitmap_set (struct xfsb_bitmap *bitmap, +xfs_fsblock_t start,xfs_filblks_t len) +{ +return xbitmap_set (&bitmap->fsbitmap, start, len); +} + +static inline int xfsb_bitmap_walk (struct xfsb_bitmap *bitmap, +xbitmap_walk_fn fn,void *priv) +{ +return xbitmap_walk (&bitmap->fsbitmap, fn, priv); +} +#endif /* __XFS_SCRUB_BITMAP_H__ */
fs/xfs/scrub/reap.c +116 -4
129 lines not on this page · raw message
fs/xfs/scrub/reap.h +2 -0
@@ -8,5 +8,7 @@int xrep_reap_agblocks (struct xfs_scrub *sc,struct xagb_bitmap *bitmap,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type); +int xrep_reap_fsblocks (struct xfs_scrub *sc,struct xfsb_bitmap *bitmap, +const struct xfs_owner_info *oinfo);#endif /* __XFS_SCRUB_REAP_H__ */
fs/xfs/scrub/repair.h +1 -0
@@ -48,6 +48,7 @@ xrep_trans_commit(struct xbitmap ;struct xagb_bitmap ; +struct xfsb_bitmap ;int xrep_fix_freelist (struct xfs_scrub *sc,bool can_shrink);
PATCH 2/5 xfs: repair inode fork block mapping data structures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the reverse-mapping btree information to rebuild an inode block map. Update the btree bulk loading code as necessary to support inode rooted btrees and fix some bitrot problems.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap_btree.c | 112 ++++- fs/xfs/libxfs/xfs_bmap_btree.h | 5 fs/xfs/libxfs/xfs_btree_staging.c | 11 fs/xfs/libxfs/xfs_btree_staging.h | 2 fs/xfs/libxfs/xfs_iext_tree.c | 23 + fs/xfs/libxfs/xfs_inode_fork.c | 1 fs/xfs/libxfs/xfs_inode_fork.h | 3 fs/xfs/scrub/bmap.c | 18 + fs/xfs/scrub/bmap_repair.c | 846 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 fs/xfs/scrub/repair.c | 28 + fs/xfs/scrub/repair.h | 6 fs/xfs/scrub/scrub.c | 4 fs/xfs/scrub/trace.h | 34 + fs/xfs/xfs_trans.c | 95 ++++ fs/xfs/xfs_trans.h | 4 17 files changed, 1171 insertions(+), 28 deletions(-) create mode 100644 fs/xfs/scrub/bmap_repair.c
fs/xfs/Makefile +1 -0
@@ -182,6 +182,7 @@ ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ + bmap_repair.o \ ialloc_repair.o \ inode_repair.o \ newbt.o \
fs/xfs/libxfs/xfs_bmap_btree.c +98 -14
160 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap_btree.h +5 -0
@@ -11,6 +11,7 @@ struct xfs_btree_block;struct xfs_mount ;struct xfs_inode ;struct xfs_trans ; +struct xbtree_ifakeroot ;/* * Btree block header size depends on a superblock flag.
@@ -106,6 +107,10 @@ extern int xfs_bmbt_change_owner(struct xfs_trans *tp, struct xfs_inode *ip,extern struct xfs_btree_cur *xfs_bmbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_inode *,int ); +struct xfs_btree_cur *xfs_bmbt_stage_cursor (struct xfs_mount *mp, +struct xfs_inode *ip,struct xbtree_ifakeroot *ifake); +void xfs_bmbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,int whichfork);extern unsigned long long xfs_bmbt_calc_size (struct xfs_mount *mp,unsigned long long len);
fs/xfs/libxfs/xfs_btree_staging.c +9 -2
@@ -399,7 +399,7 @@ xfs_btree_bload_prep_block(ASSERT (*bpp ==NULL );/* Allocate a new incore btree root block. */ - new_size = bbl->iroot_size (cur, nr_this_block, priv); + new_size = bbl->iroot_size (cur, level, nr_this_block, priv); ifp->if_broot =kmem_zalloc (new_size,0 ); ifp->if_broot_bytes = (int )new_size;
@@ -585,7 +585,14 @@ xfs_btree_bload_level_geometry(unsigned int desired_npb;unsigned int maxnr; - maxnr = cur->bc_ops->get_maxrecs (cur, level); +/* +* Compute the absolute maximum number of records that we can store in +* the ondisk block or inode root. +*/ +if (cur->bc_ops->get_dmaxrecs) + maxnr = cur->bc_ops->get_dmaxrecs (cur, level); +else + maxnr = cur->bc_ops->get_maxrecs (cur, level);/* * Compute the number of blocks we need to fill each block with the
fs/xfs/libxfs/xfs_btree_staging.h +1 -1
@@ -56,7 +56,7 @@ typedef int (*xfs_btree_bload_get_records_fn)(struct xfs_btree_cur *cur,typedef int (*xfs_btree_bload_claim_block_fn )(struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr,void *priv);typedef size_t (*xfs_btree_bload_iroot_size_fn )(struct xfs_btree_cur *cur, -unsigned int nr_this_level,void *priv); +unsigned int level,unsigned int nr_this_level,void *priv);struct xfs_btree_bload {/*
fs/xfs/libxfs/xfs_iext_tree.c +16 -7
@@ -622,13 +622,11 @@ static inline void xfs_iext_inc_seq(struct xfs_ifork *ifp) }void -xfs_iext_insert ( -struct xfs_inode *ip, +xfs_iext_insert_raw ( +struct xfs_ifork *ifp,struct xfs_iext_cursor *cur, -struct xfs_bmbt_irec *irec, -int state) +struct xfs_bmbt_irec *irec) { -struct xfs_ifork *ifp =xfs_iext_state_to_fork (ip, state);xfs_fileoff_t offset = irec->br_startoff;struct xfs_iext_leaf *new =NULL ;int nr_entries, i;
@@ -662,12 +660,23 @@ xfs_iext_insert(xfs_iext_set (cur_rec (cur), irec); ifp->if_bytes +=sizeof (struct xfs_iext_rec ); -trace_xfs_iext_insert (ip, cur, state, _RET_IP_); -if (new)xfs_iext_insert_node (ifp,xfs_iext_leaf_key (new,0 ), new,2 ); } +void +xfs_iext_insert ( +struct xfs_inode *ip, +struct xfs_iext_cursor *cur, +struct xfs_bmbt_irec *irec, +int state) +{ +struct xfs_ifork *ifp =xfs_iext_state_to_fork (ip, state); + +xfs_iext_insert_raw (ifp, cur, irec); +trace_xfs_iext_insert (ip, cur, state, _RET_IP_); +} +static struct xfs_iext_node * xfs_iext_rebalance_node( struct xfs_iext_node *parent,
fs/xfs/libxfs/xfs_inode_fork.c +1 -0
@@ -520,6 +520,7 @@ xfs_idata_realloc( ifp->if_bytes = new_size; } +/* Free all memory and reset a fork back to its initial state. */ void xfs_idestroy_fork (struct xfs_ifork *ifp)
fs/xfs/libxfs/xfs_inode_fork.h +3 -0
@@ -180,6 +180,9 @@ void xfs_init_local_fork(struct xfs_inode *ip, int whichfork, const void *data, int64_t size);xfs_extnum_t xfs_iext_count (struct xfs_ifork *ifp); +void xfs_iext_insert_raw (struct xfs_ifork *ifp, +struct xfs_iext_cursor *cur, +struct xfs_bmbt_irec *irec);void xfs_iext_insert (struct xfs_inode *,struct xfs_iext_cursor *cur,struct xfs_bmbt_irec *,int ); void xfs_iext_remove(struct xfs_inode *, struct xfs_iext_cursor *,
fs/xfs/scrub/bmap.c +18 -0
@@ -48,9 +48,18 @@ xchk_setup_inode_bmap(if (S_ISREG (VFS_I (sc->ip)->i_mode) && sc->sm->sm_type !=XFS_SCRUB_TYPE_BMBTA ) {struct address_space *mapping =VFS_I (sc->ip)->i_mapping; +bool is_repair =xchk_could_repair (sc);xchk_ilock (sc,XFS_MMAPLOCK_EXCL ); +/* Break all our leases, we're going to mess with things. */ +if (is_repair) { + error =xfs_break_layouts (VFS_I (sc->ip), + &sc->ilock_flags,BREAK_WRITE ); +if (error) + goto out; + } +inode_dio_wait (VFS_I (sc->ip));/*
@@ -71,6 +80,15 @@ xchk_setup_inode_bmap( error =filemap_fdatawait_keep_errors (mapping);if (error && (error != -ENOSPC && error != -EIO )) goto out; + +/* Drop the page cache if we're repairing block mappings. */ +if (is_repair) { + error =invalidate_inode_pages2 ( +VFS_I (sc->ip)->i_mapping); +if (error) + goto out; + } + }/* Got the inode, lock it and we're ready to go. */
fs/xfs/scrub/bmap_repair.c new file +846 -0
846 lines not on this page · raw message
fs/xfs/scrub/common.h +5 -1
@@ -233,7 +233,11 @@ int xchk_metadata_inode_forks(struct xfs_scrub *sc); (sc)->mp->m_super->s_id, \ (sc)->sa.pag ? (sc)->sa.pag->pag_agno : (sc)->sm->sm_agno, \ ##__VA_ARGS__) - +#define xchk_xfile_ino_descr (sc, fmt, ...) \ + kasprintf(XCHK_GFP_FLAGS, "XFS (%s): inode 0x%llx " fmt, \ + (sc)->mp->m_super->s_id, \ + (sc)->ip ? (sc)->ip->i_ino : (sc)->sm->sm_ino, \ + ##__VA_ARGS__)/* * Setting up a hook to wait for intents to drain is costly -- we have to take
fs/xfs/scrub/repair.c +28 -0
@@ -880,6 +880,34 @@ xrep_reinit_pagi(return 0 ; } +/* +* Given an active reference to a perag structure, load AG headers and cursors. +* This should only be called to scan an AG while repairing file-based metadata. +*/ +int +xrep_ag_init ( +struct xfs_scrub *sc, +struct xfs_perag *pag, +struct xchk_ag *sa) +{ +int error; + +ASSERT (!sa->pag); + + error =xfs_ialloc_read_agi (pag, sc->tp, &sa->agi_bp); +if (error) +return error; + + error =xfs_alloc_read_agf (pag, sc->tp,0 , &sa->agf_bp); +if (error) +return error; + +/* Grab our own passive reference from the caller's ref. */ + sa->pag =xfs_perag_hold (pag); +xrep_ag_btcur_init (sc, sa); +return 0 ; +} +/* Reinitialize the per-AG block reservation for the AG we just fixed. */ int xrep_reset_perag_resv(
fs/xfs/scrub/repair.h +6 -0
@@ -89,6 +89,8 @@ struct xfs_imap;int xrep_setup_inode (struct xfs_scrub *sc,struct xfs_imap *imap);void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa); +int xrep_ag_init (struct xfs_scrub *sc,struct xfs_perag *pag, +struct xchk_ag *sa);/* Metadata revalidators */
@@ -106,6 +108,8 @@ int xrep_allocbt(struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc);int xrep_refcountbt (struct xfs_scrub *sc);int xrep_inode (struct xfs_scrub *sc); +int xrep_bmap_data (struct xfs_scrub *sc); +int xrep_bmap_attr (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -165,6 +169,8 @@ xrep_setup_nothing(#define xrep_iallocbt xrep_notsupported#define xrep_refcountbt xrep_notsupported#define xrep_inode xrep_notsupported +#define xrep_bmap_data xrep_notsupported +#define xrep_bmap_attr xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +2 -2
@@ -290,13 +290,13 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_data, - .repair = xrep_notsupported, + .repair = xrep_bmap_data, }, [XFS_SCRUB_TYPE_BMBTA] = { /* inode attr fork */ .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_attr, - .repair = xrep_notsupported, + .repair = xrep_bmap_attr, }, [XFS_SCRUB_TYPE_BMBTC] = { /* inode CoW fork */ .type = ST_INODE,
fs/xfs/scrub/trace.h +33 -1
@@ -1174,7 +1174,7 @@ DEFINE_EVENT(xrep_rmap_class, name, \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags))DEFINE_REPAIR_RMAP_EVENT (xrep_ibt_walk_rmap);DEFINE_REPAIR_RMAP_EVENT (xrep_rmap_extent_fn); -DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_extent_fn); +DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_walk_rmap); TRACE_EVENT(xrep_abt_found, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
@@ -1259,6 +1259,38 @@ TRACE_EVENT(xrep_refc_found, __entry->refcount) ) +TRACE_EVENT (xrep_bmap_found, + TP_PROTO(struct xfs_inode *ip, int whichfork, + struct xfs_bmbt_irec *irec), +TP_ARGS (ip, whichfork, irec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(int, whichfork) + __field(xfs_fileoff_t, lblk) + __field(xfs_filblks_t, len) + __field(xfs_fsblock_t, pblk) +__field (int, state) + ), +TP_fast_assign ( + __entry->dev = VFS_I(ip)->i_sb->s_dev; + __entry->ino = ip->i_ino; + __entry->whichfork = whichfork; + __entry->lblk = irec->br_startoff; + __entry->len = irec->br_blockcount; + __entry->pblk = irec->br_startblock; + __entry->state = irec->br_state; + ), +TP_printk ("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, +__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), + __entry->lblk, + __entry->len, + __entry->pblk, + __entry->state) +); + TRACE_EVENT(xrep_findroot_block, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, uint32_t magic, uint16_t level),
fs/xfs/xfs_trans.c +95 -0
107 lines not on this page · raw message
fs/xfs/xfs_trans.h +4 -0
@@ -168,6 +168,8 @@ typedef struct xfs_trans {int xfs_trans_alloc (struct xfs_mount *mp,struct xfs_trans_res *resp,uint blocks,uint rtextents,uint flags,struct xfs_trans **tpp); +int xfs_trans_reserve_more (struct xfs_trans *tp, +unsigned int blocks,unsigned int rtextents);int xfs_trans_alloc_empty (struct xfs_mount *mp,struct xfs_trans **tpp);void xfs_trans_mod_sb (xfs_trans_t *,uint ,int64_t );
@@ -260,6 +262,8 @@ struct xfs_dquot;int xfs_trans_alloc_inode (struct xfs_inode *ip,struct xfs_trans_res *resv,unsigned int dblocks,unsigned int rblocks,bool force,struct xfs_trans **tpp); +int xfs_trans_reserve_more_inode (struct xfs_trans *tp,struct xfs_inode *ip, +unsigned int dblocks,unsigned int rblocks,bool force_quota); int xfs_trans_alloc_icreate(struct xfs_mount *mp, struct xfs_trans_res *resv, struct xfs_dquot *udqp, struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, unsigned int dblocks,
PATCH 3/5 xfs: refactor repair forcing tests into a repair.c helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
There are a couple of conditions that userspace can set to force repairs of metadata. These really belong in the repair code and not open-coded into the check code, so refactor them into a helper.
--- fs/xfs/scrub/repair.c | 22 ++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 ++ fs/xfs/scrub/scrub.c | 14 +------------- 3 files changed, 25 insertions(+), 13 deletions(-)
fs/xfs/scrub/repair.c +22 -0
@@ -27,6 +27,8 @@#include "xfs_quota.h" #include "xfs_qm.h" #include "xfs_defer.h" +#include "xfs_errortag.h" +#include "xfs_error.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -937,3 +939,23 @@ xrep_reset_perag_resv( out:return error; } + +/* Decide if we are going to call the repair function for a scrub type. */ +bool +xrep_will_attempt ( +struct xfs_scrub *sc) +{ +/* Userspace asked us to rebuild the structure regardless. */ +if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) +return true; + +/* Let debug users force us into the repair routines. */ +if (XFS_TEST_ERROR (false, sc->mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) +return true; + +/* Metadata is corrupt or failed cross-referencing. */ +if (xchk_needs_repair (sc->sm)) +return true; + +return false; +}
fs/xfs/scrub/repair.h +2 -0
@@ -28,6 +28,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)/* Repair helpers */ int xrep_attempt (struct xfs_scrub *sc,struct xchk_stats_run *run); +bool xrep_will_attempt (struct xfs_scrub *sc);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc);int xrep_roll_trans (struct xfs_scrub *sc);
@@ -117,6 +118,7 @@ int xrep_reinit_pagi(struct xfs_scrub *sc);#else #define xrep_ino_dqattach (sc) (0) +#define xrep_will_attempt (sc) (false)static inline int xrep_attempt(
fs/xfs/scrub/scrub.c +1 -13
@@ -14,8 +14,6 @@#include "xfs_inode.h" #include "xfs_quota.h" #include "xfs_qm.h" -#include "xfs_errortag.h" -#include "xfs_error.h" #include "xfs_scrub.h" #include "xfs_btree.h" #include "xfs_btree_staging.h"
@@ -552,21 +550,11 @@ xfs_scrub_metadata(xchk_update_health (sc);if (xchk_could_repair (sc)) { -bool needs_fix =xchk_needs_repair (sc->sm); - -/* Userspace asked us to rebuild the structure regardless. */ -if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) - needs_fix = true; - -/* Let debug users force us into the repair routines. */ -if (XFS_TEST_ERROR (needs_fix, mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) - needs_fix = true; -/* * If userspace asked for a repair but it wasn't necessary, * report that back to userspace. */ -if (!needs_fix) { +if (!xrep_will_attempt (sc)) { sc->sm->sm_flags |=XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ; goto out_nofix; }
PATCH 4/5 xfs: create a ranged query function for refcount btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Implement ranged queries for refcount records. The next patch will use this to scan refcount data.
--- fs/xfs/libxfs/xfs_refcount.c | 41 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_refcount.h | 10 ++++++++++ 2 files changed, 51 insertions(+)
fs/xfs/libxfs/xfs_refcount.c +41 -0
@@ -2039,6 +2039,47 @@ xfs_refcount_has_records(return xfs_btree_has_records (cur, &low, &high,NULL , outcome); } +struct xfs_refcount_query_range_info { +xfs_refcount_query_range_fn fn; +void *priv; +}; + +/* Format btree record and pass to our callback. */ +STATIC int +xfs_refcount_query_range_helper ( +struct xfs_btree_cur *cur, +const union xfs_btree_rec *rec, +void *priv) +{ +struct xfs_refcount_query_range_info *query = priv; +struct xfs_refcount_irec irec; +xfs_failaddr_t fa; + +xfs_refcount_btrec_to_irec (rec, &irec); + fa =xfs_refcount_check_irec (cur, &irec); +if (fa) +return xfs_refcount_complain_bad_rec (cur, fa, &irec); + +return query->fn (cur, &irec, query->priv); +} + +/* Find all refcount records between two keys. */ +int +xfs_refcount_query_range ( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *low_rec, +const struct xfs_refcount_irec *high_rec, +xfs_refcount_query_range_fn fn, +void *priv) +{ +union xfs_btree_irec low_brec = { .rc = *low_rec }; +union xfs_btree_irec high_brec = { .rc = *high_rec }; +struct xfs_refcount_query_range_info query = { .priv = priv, .fn = fn }; + +return xfs_btree_query_range (cur, &low_brec, &high_brec, + xfs_refcount_query_range_helper, &query); +} +int __init xfs_refcount_intent_init_cache (void ) {
fs/xfs/libxfs/xfs_refcount.h +10 -0
@@ -129,4 +129,14 @@ extern struct kmem_cache *xfs_refcount_intent_cache;int __init xfs_refcount_intent_init_cache (void );void xfs_refcount_intent_destroy_cache (void ); +typedef int (*xfs_refcount_query_range_fn )( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *rec, +void *priv); + +int xfs_refcount_query_range (struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *low_rec, +const struct xfs_refcount_irec *high_rec, +xfs_refcount_query_range_fn fn,void *priv); +#endif /* __XFS_REFCOUNT_H__ */
PATCH 5/5 xfs: repair problems in CoW forks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Try to repair errors that we see in file CoW forks so that we don't do stupid things like remap garbage into a file. There's not a lot we can do with the COW fork -- the ondisk metadata record only that the COW staging extents are owned by the refcount btree, which effectively means that we can't reconstruct this incore structure from scratch.
Actually, this is even worse -- we can't touch written extents, because those map space that are actively under writeback, and there's not much to do with delalloc reservations. Hence we can only detect crosslinked unwritten extents and fix them by punching out the problematic parts and replacing them with delalloc extents.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/bitmap.h | 28 ++ fs/xfs/scrub/cow_repair.c | 609 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/reap.c | 32 ++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 84 ++++++ 7 files changed, 757 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/scrub/cow_repair.c
fs/xfs/Makefile +1 -0
@@ -183,6 +183,7 @@ xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ bmap_repair.o \ + cow_repair.o \ ialloc_repair.o \ inode_repair.o \ newbt.o \
fs/xfs/scrub/bitmap.h +28 -0
@@ -133,4 +133,32 @@ static inline int xfsb_bitmap_walk(struct xfsb_bitmap *bitmap, return xbitmap_walk(&bitmap->fsbitmap, fn, priv); } +/* Bitmaps, but for type-checked for xfs_fileoff_t */ + +struct xfo_bitmap { +struct xbitmap fobitmap; +}; + +static inline void xfo_bitmap_init (struct xfo_bitmap *bitmap) +{ +xbitmap_init (&bitmap->fobitmap); +} + +static inline void xfo_bitmap_destroy (struct xfo_bitmap *bitmap) +{ +xbitmap_destroy (&bitmap->fobitmap); +} + +static inline int xfo_bitmap_set (struct xfo_bitmap *bitmap, +xfs_fileoff_t off,xfs_filblks_t len) +{ +return xbitmap_set (&bitmap->fobitmap, off, len); +} + +static inline int xfo_bitmap_walk (struct xfo_bitmap *bitmap, +xbitmap_walk_fn fn,void *priv) +{ +return xbitmap_walk (&bitmap->fobitmap, fn, priv); +} +#endif /* __XFS_SCRUB_BITMAP_H__ */
fs/xfs/scrub/cow_repair.c new file +609 -0
609 lines not on this page · raw message
fs/xfs/scrub/reap.c +32 -0
@@ -20,6 +20,7 @@#include "xfs_ialloc_btree.h" #include "xfs_rmap.h" #include "xfs_rmap_btree.h" +#include "xfs_refcount.h" #include "xfs_refcount_btree.h" #include "xfs_extent_busy.h" #include "xfs_ag.h"
@@ -378,6 +379,17 @@ xreap_agextent_iter(trace_xreap_dispose_unmap_extent (sc->sa.pag, agbno, *aglenp); rs->force_roll = true; + +if (rs->oinfo == &XFS_RMAP_OINFO_COW ) { +/* +* If we're unmapping CoW staging extents, remove the +* records from the refcountbt, which will remove the +* rmap record as well. +*/ +xfs_refcount_free_cow_extent (sc->tp, fsbno, *aglenp); +return 0 ; + } +return xfs_rmap_free (sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, *aglenp, rs->oinfo); }
@@ -396,6 +408,26 @@ xreap_agextent_iter(return 0 ; } +/* +* If we're getting rid of CoW staging extents, use deferred work items +* to remove the refcountbt records (which removes the rmap records) +* and free the extent. We're not worried about the system going down +* here because log recovery walks the refcount btree to clean out the +* CoW staging extents. +*/ +if (rs->oinfo == &XFS_RMAP_OINFO_COW ) { +ASSERT (rs->resv ==XFS_AG_RESV_NONE ); + +xfs_refcount_free_cow_extent (sc->tp, fsbno, *aglenp); + error =xfs_free_extent_later (sc->tp, fsbno, *aglenp,NULL , + rs->resv, true); +if (error) +return error; + + rs->force_roll = true; +return 0 ; + } +/* Put blocks back on the AGFL one at a time. */ if (rs->resv ==XFS_AG_RESV_AGFL ) {ASSERT (*aglenp ==1 );
fs/xfs/scrub/repair.h +2 -0
@@ -111,6 +111,7 @@ int xrep_refcountbt(struct xfs_scrub *sc);int xrep_inode (struct xfs_scrub *sc);int xrep_bmap_data (struct xfs_scrub *sc);int xrep_bmap_attr (struct xfs_scrub *sc); +int xrep_bmap_cow (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -173,6 +174,7 @@ xrep_setup_nothing(#define xrep_inode xrep_notsupported#define xrep_bmap_data xrep_notsupported#define xrep_bmap_attr xrep_notsupported +#define xrep_bmap_cow xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -300,7 +300,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_cow, - .repair = xrep_notsupported, + .repair = xrep_bmap_cow, }, [XFS_SCRUB_TYPE_DIR] = { /* directory */ .type = ST_INODE,
fs/xfs/scrub/trace.h +84 -0
90 lines not on this page · raw message
cover xfs: prepare repair for bulk loading
In reply to Darrick J. WongHi all,
Before we start merging the online repair functions, let's improve the bulk loading code a bit. First, we need to fix a misinteraction between the AIL and the btree bulkloader wherein the delwri at the end of the bulk load fails to queue a buffer for writeback if it happens to be on the AIL list.
Second, we introduce a defer ops barrier object so that the process of reaping blocks after a repair cannot queue more than two extents per EFI log item. This increases our exposure to leaking blocks if the system goes down during a reap, but also should prevent transaction overflows, which result in the system going down.
Third, we change the bulkloader itself to copy multiple records into a block if possible, and add some debugging knobs so that developers can control the slack factors, just like they can do for xfs_repair.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-prep-for-bulk-loading
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-prep-for-bulk-loading
--- fs/xfs/libxfs/xfs_btree.c | 2 + fs/xfs/libxfs/xfs_btree.h | 3 ++ fs/xfs/libxfs/xfs_btree_staging.c | 67 +++++++++++++++++++++++++------------ fs/xfs/libxfs/xfs_btree_staging.h | 25 +++++++++++--- fs/xfs/scrub/newbt.c | 11 ++++-- fs/xfs/xfs_buf.c | 47 ++++++++++++++++++++++++-- fs/xfs/xfs_buf.h | 1 + fs/xfs/xfs_globals.c | 12 +++++++ fs/xfs/xfs_sysctl.h | 2 + fs/xfs/xfs_sysfs.c | 54 ++++++++++++++++++++++++++++++ 10 files changed, 189 insertions(+), 35 deletions(-)
PATCH 1/4 xfs: force all buffers to be written during btree bulk load
From: Darrick J. Wong <[email protected]>
While stress-testing online repair of btrees, I noticed periodic assertion failures from the buffer cache about buffer readers encountering buffers with DELWRI_Q set, even though the btree bulk load had already committed and the buffer itself wasn't on any delwri list.
I traced this to a misunderstanding of how the delwri lists work, particularly with regards to the AIL's buffer list. If a buffer is logged and committed, the buffer can end up on that AIL buffer list. If btree repairs are run twice in rapid succession, it's possible that the first repair will invalidate the buffer and free it before the next time the AIL wakes up. This clears DELWRI_Q from the buffer state.
If the second repair allocates the same block, it will then recycle the buffer to start writing the new btree block. Meanwhile, if the AIL wakes up and walks the buffer list, it will ignore the buffer because it can't lock it, and go back to sleep.
When the second repair calls delwri_queue to put the buffer on the list of buffers to write before committing the new btree, it will set DELWRI_Q again, but since the buffer hasn't been removed from the AIL's buffer list, it won't add it to the bulkload buffer's list.
This is incorrect, because the bulkload caller relies on delwri_submit to ensure that all the buffers have been sent to disk /before/ committing the new btree root pointer. This ordering requirement is required for data consistency.
Worse, the AIL won't clear DELWRI_Q from the buffer when it does finally drop it, so the next thread to walk through the btree will trip over a debug assertion on that flag.
To fix this, create a new function that waits for the buffer to be removed from any other delwri lists before adding the buffer to the caller's delwri list. By waiting for the buffer to clear both the delwri list and any potential delwri wait list, we can be sure that repair will initiate writes of all buffers and report all write errors back to userspace instead of committing the new structure.
--- fs/xfs/libxfs/xfs_btree_staging.c | 4 +-- fs/xfs/xfs_buf.c | 47 ++++++++++++++++++++++++++++++++++--- fs/xfs/xfs_buf.h | 1 + 3 files changed, 45 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_btree_staging.c +1 -3
@@ -342,9 +342,7 @@ xfs_btree_bload_drop_buf(if (*bpp ==NULL )return ; -if (!xfs_buf_delwri_queue (*bpp, buffers_list)) -ASSERT (0 ); - +xfs_buf_delwri_queue_here (*bpp, buffers_list);xfs_buf_relse (*bpp); *bpp =NULL ; }
fs/xfs/xfs_buf.c +43 -4
83 lines not on this page · raw message
fs/xfs/xfs_buf.h +1 -0
@@ -318,6 +318,7 @@ extern void xfs_buf_stale(struct xfs_buf *bp);/* Delayed Write Buffer Routines */ extern void xfs_buf_delwri_cancel (struct list_head *);extern bool xfs_buf_delwri_queue (struct xfs_buf *,struct list_head *); +void xfs_buf_delwri_queue_here (struct xfs_buf *bp,struct list_head *bl);extern int xfs_buf_delwri_submit (struct list_head *);extern int xfs_buf_delwri_submit_nowait (struct list_head *);extern int xfs_buf_delwri_pushbuf (struct xfs_buf *,struct list_head *);
PATCH 2/4 xfs: add debug knobs to control btree bulk load slack factors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some debug knobs so that we can control the leaf and node block slack when rebuilding btrees.
--- fs/xfs/scrub/newbt.c | 10 ++++++--- fs/xfs/xfs_globals.c | 12 +++++++++++ fs/xfs/xfs_sysctl.h | 2 ++ fs/xfs/xfs_sysfs.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 75 insertions(+), 3 deletions(-)
fs/xfs/scrub/newbt.c +7 -3
@@ -47,9 +47,13 @@ xrep_newbt_estimate_slack(uint64_t free;uint64_t sz; -/* Let the btree code compute the default slack values. */ - bload->leaf_slack =-1 ; - bload->node_slack =-1 ; +/* +* The xfs_globals values are set to -1 (i.e. take the bload defaults) +* unless someone has set them otherwise, so we just pull the values +* here. +*/ + bload->leaf_slack = xfs_globals.bload_leaf_slack; + bload->node_slack = xfs_globals.bload_node_slack;if (sc->ops->type ==ST_PERAG ) { free = sc->sa.pag->pagf_freeblks;
fs/xfs/xfs_globals.c +12 -0
@@ -44,4 +44,16 @@ struct xfs_globals xfs_globals = { .pwork_threads = -1, /* automatic thread detection */ .larp = false, /* log attribute replay */#endif + +/* +* Leave this many record slots empty when bulk loading btrees. By +* default we load new btree leaf blocks 75% full. +*/ + .bload_leaf_slack = -1, + +/* +* Leave this many key/ptr slots empty when bulk loading btrees. By +* default we load new btree node blocks 75% full. +*/ + .bload_node_slack = -1, };
fs/xfs/xfs_sysctl.h +2 -0
@@ -85,6 +85,8 @@ struct xfs_globals {int pwork_threads;/* parallel workqueue threads */ bool larp;/* log attribute replay */ #endif +int bload_leaf_slack;/* btree bulk load leaf slack */ +int bload_node_slack;/* btree bulk load node slack */ int log_recovery_delay;/* log recovery delay (secs) */ int mount_delay;/* mount setup delay (secs) */ bool bug_on_assert;/* BUG() the kernel on assert failure */
fs/xfs/xfs_sysfs.c +54 -0
66 lines not on this page · raw message
PATCH 3/4 xfs: move btree bulkload record initialization to ->get_record implementations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're performing a bulk load of a btree, move the code that actually stores the btree record in the new btree block out of the generic code and into the individual ->get_record implementations. This is preparation for being able to store multiple records with a single indirect call.
--- fs/xfs/libxfs/xfs_btree_staging.c | 17 +++++++---------- fs/xfs/libxfs/xfs_btree_staging.h | 15 ++++++++++----- 2 files changed, 17 insertions(+), 15 deletions(-)
fs/xfs/libxfs/xfs_btree_staging.c +7 -10
@@ -434,22 +434,19 @@ STATIC intxfs_btree_bload_leaf ( struct xfs_btree_cur *cur, unsigned int recs_this_block, - xfs_btree_bload_get_record_fn get_record, + xfs_btree_bload_get_records_fn get_records, struct xfs_btree_block *block, void *priv) { - unsigned int j; + unsigned int j = 1;int ret;/* Fill the leaf block with records. */ -for (j =1 ; j <= recs_this_block; j++) { -union xfs_btree_rec *block_rec; - - ret =get_record (cur, priv); -if (ret) +while (j <= recs_this_block) { + ret =get_records (cur, j, block, recs_this_block - j +1 , priv); +if (ret <0 )return ret; - block_rec =xfs_btree_rec_addr (cur, j, block); - cur->bc_ops->init_rec_from_cur (cur, block_rec); + j += ret; }return 0 ;
@@ -787,7 +784,7 @@ xfs_btree_bload(trace_xfs_btree_bload_block (cur, level, i, blocks, &ptr, nr_this_block); - ret =xfs_btree_bload_leaf (cur, nr_this_block, bbl->get_record, + ret =xfs_btree_bload_leaf (cur, nr_this_block, bbl->get_records, block, priv);if (ret) goto out;
fs/xfs/libxfs/xfs_btree_staging.h +10 -5
@@ -50,7 +50,9 @@ void xfs_btree_commit_ifakeroot(struct xfs_btree_cur *cur, struct xfs_trans *tp, int whichfork, const struct xfs_btree_ops *ops);/* Bulk loading of staged btrees. */ -typedef int (*xfs_btree_bload_get_record_fn )(struct xfs_btree_cur *cur,void *priv); +typedef int (*xfs_btree_bload_get_records_fn )(struct xfs_btree_cur *cur, +unsigned int idx,struct xfs_btree_block *block, +unsigned int nr_wanted,void *priv);typedef int (*xfs_btree_bload_claim_block_fn )(struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr,void *priv); typedef size_t (*xfs_btree_bload_iroot_size_fn)(struct xfs_btree_cur *cur,
@@ -58,11 +60,14 @@ typedef size_t (*xfs_btree_bload_iroot_size_fn)(struct xfs_btree_cur *cur,struct xfs_btree_bload {/* -* This function will be called nr_records times to load records into -* the btree. The function does this by setting the cursor's bc_rec -* field in in-core format. Records must be returned in sort order. +* This function will be called to load @nr_wanted records into the +* btree. The implementation does this by setting the cursor's bc_rec +* field in in-core format and using init_rec_from_cur to set the +* records in the btree block. Records must be returned in sort order. +* The function must return the number of records loaded or the usual +* negative errno. */ -xfs_btree_bload_get_record_fn get_record; +xfs_btree_bload_get_records_fn get_records;/* * This function will be called nr_blocks times to obtain a pointer
PATCH 4/4 xfs: constrain dirty buffers while formatting a staged btree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Constrain the number of dirty buffers that are locked by the btree staging code at any given time by establishing a threshold at which we put them all on the delwri queue and push them to disk. This limits memory consumption while writing out new btrees.
--- fs/xfs/libxfs/xfs_btree.c | 2 + fs/xfs/libxfs/xfs_btree.h | 3 ++ fs/xfs/libxfs/xfs_btree_staging.c | 50 +++++++++++++++++++++++++++++-------- fs/xfs/libxfs/xfs_btree_staging.h | 10 +++++++ fs/xfs/scrub/newbt.c | 1 + 5 files changed, 54 insertions(+), 12 deletions(-)
fs/xfs/libxfs/xfs_btree.c +1 -1
@@ -1330,7 +1330,7 @@ xfs_btree_get_buf_block(* Read in the buffer at the given ptr and return the buffer and * the block pointer within the buffer. */ -STATIC int +int xfs_btree_read_buf_block( struct xfs_btree_cur *cur, const union xfs_btree_ptr *ptr,
fs/xfs/libxfs/xfs_btree.h +3 -0
@@ -700,6 +700,9 @@ void xfs_btree_set_ptr_null(struct xfs_btree_cur *cur,int xfs_btree_get_buf_block (struct xfs_btree_cur *cur,const union xfs_btree_ptr *ptr,struct xfs_btree_block **block,struct xfs_buf **bpp); +int xfs_btree_read_buf_block (struct xfs_btree_cur *cur, +const union xfs_btree_ptr *ptr,int flags, +struct xfs_btree_block **block,struct xfs_buf **bpp);void xfs_btree_set_sibling (struct xfs_btree_cur *cur,struct xfs_btree_block *block,const union xfs_btree_ptr *ptr,int lr);
fs/xfs/libxfs/xfs_btree_staging.c +39 -11
91 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree_staging.h +10 -0
@@ -115,6 +115,16 @@ struct xfs_btree_bload {* height of the new btree. */ unsigned int btree_height; + +/* +* Flush the new btree block buffer list to disk after this many blocks +* have been formatted. Zero prohibits writing any buffers until all +* blocks have been formatted. +*/ +uint16_t max_dirty; + +/* Number of dirty buffers. */ +uint16_t nr_dirty; }; int xfs_btree_bload_compute_geometry(struct xfs_btree_cur *cur,
fs/xfs/scrub/newbt.c +1 -0
@@ -89,6 +89,7 @@ xrep_newbt_init_ag( xnr->alloc_hint = alloc_hint; xnr->resv = resv;INIT_LIST_HEAD (&xnr->resv_list); + xnr->bload.max_dirty =XFS_B_TO_FSBT (sc->mp,256U <<10 );/* 256K */ xrep_newbt_estimate_slack (xnr); }
cover xfs: online repair of rt bitmap file
In reply to Darrick J. WongHi all,
Add in the necessary infrastructure to check the inode and data forks of metadata files, then apply that to the realtime bitmap file. We won't be able to reconstruct the contents of the rtbitmap file until rmapbt is added for realtime volumes, but we can at least get the basics started.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-rtbitmap
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-rtbitmap
--- fs/xfs/Makefile | 4 + fs/xfs/libxfs/xfs_bmap.c | 39 ++++++++++ fs/xfs/libxfs/xfs_bmap.h | 2 + fs/xfs/scrub/bmap_repair.c | 17 +++-- fs/xfs/scrub/repair.c | 151 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 15 ++++ fs/xfs/scrub/rtbitmap.c | 10 ++- fs/xfs/scrub/rtbitmap_repair.c | 56 +++++++++++++++ fs/xfs/scrub/scrub.c | 4 - fs/xfs/xfs_inode.c | 24 +----- 10 files changed, 294 insertions(+), 28 deletions(-) create mode 100644 fs/xfs/scrub/rtbitmap_repair.c
PATCH 1/4 xfs: repair the inode core and forks of a metadata inode
From: Darrick J. Wong <[email protected]>
Add a helper function to repair the core and forks of a metadata inode, so that we can get move onto the task of repairing higher level metadata that lives in an inode.
--- fs/xfs/scrub/bmap_repair.c | 17 ++++- fs/xfs/scrub/repair.c | 151 ++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 + 3 files changed, 166 insertions(+), 4 deletions(-)
fs/xfs/scrub/bmap_repair.c +13 -4
@@ -78,6 +78,9 @@ struct xrep_bmap {/* Are there shared extents? */ bool shared_extents; + +/* Do we allow unwritten extents? */ +bool allow_unwritten; };/* Is this space extent shared? Flag the inode if it is. */
@@ -272,6 +275,10 @@ xrep_bmap_walk_rmap( !(rec->rm_flags & XFS_RMAP_ATTR_FORK))return 0 ; +/* Reject unwritten extents if we don't allow those. */ +if ((rec->rm_flags &XFS_RMAP_UNWRITTEN ) && !rb->allow_unwritten) +return -EFSCORRUPTED ; + fsbno =XFS_AGB_TO_FSB (mp, cur->bc_ag.pag->pag_agno, rec->rm_startblock);
@@ -762,10 +769,11 @@ xrep_bmap_check_inputs( }/* Repair an inode fork. */ -STATIC int +int xrep_bmap (struct xfs_scrub *sc, -int whichfork) +int whichfork, +bool allow_unwritten) {struct xrep_bmap *rb;char *descr;
@@ -784,6 +792,7 @@ xrep_bmap(return -ENOMEM ; rb->sc = sc; rb->whichfork = whichfork; + rb->allow_unwritten = allow_unwritten;/* * No need to waste time scanning for shared extents if the inode is
@@ -834,7 +843,7 @@ intxrep_bmap_data ( struct xfs_scrub *sc) { -return xrep_bmap (sc,XFS_DATA_FORK ); +return xrep_bmap (sc,XFS_DATA_FORK , true); }/* Repair an inode's attr fork. */
@@ -842,5 +851,5 @@ intxrep_bmap_attr ( struct xfs_scrub *sc) { -return xrep_bmap (sc,XFS_ATTR_FORK ); +return xrep_bmap (sc,XFS_ATTR_FORK , false); }
fs/xfs/scrub/repair.c +151 -0
160 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -82,6 +82,8 @@ int xrep_ino_dqattach(struct xfs_scrub *sc);int xrep_ino_ensure_extent_count (struct xfs_scrub *sc,int whichfork,xfs_extnum_t nextents);int xrep_reset_perag_resv (struct xfs_scrub *sc); +int xrep_bmap (struct xfs_scrub *sc,int whichfork,bool allow_unwritten); +int xrep_metadata_inode_forks (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc);
PATCH 2/4 xfs: create a new inode fork block unmap helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new helper to unmap blocks from an inode's fork.
--- fs/xfs/libxfs/xfs_bmap.c | 39 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_bmap.h | 2 ++ fs/xfs/xfs_inode.c | 24 ++++-------------------- 3 files changed, 45 insertions(+), 20 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +39 -0
@@ -6248,3 +6248,42 @@ xfs_bmap_validate_extent(return xfs_bmap_validate_extent_raw (ip->i_mount,XFS_IS_REALTIME_INODE (ip), whichfork, irec); } + +/* +* Used in xfs_itruncate_extents(). This is the maximum number of extents +* freed from a file in a single transaction. +*/ +#define XFS_ITRUNC_MAX_EXTENTS 2 + +/* +* Unmap every extent in part of an inode's fork. We don't do any higher level +* invalidation work at all. +*/ +int +xfs_bunmapi_range ( +struct xfs_trans **tpp, +struct xfs_inode *ip, +uint32_t flags, +xfs_fileoff_t startoff, +xfs_fileoff_t endoff) +{ +xfs_filblks_t unmap_len = endoff - startoff +1 ; +int error =0 ; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); + +while (unmap_len >0 ) { +ASSERT ((*tpp)->t_highest_agno ==NULLAGNUMBER ); + error =__xfs_bunmapi (*tpp, ip, startoff, &unmap_len, flags, +XFS_ITRUNC_MAX_EXTENTS ); +if (error) + goto out; + +/* free the just unmapped extents */ + error =xfs_defer_finish (tpp); +if (error) + goto out; + } +out: +return error; +}
fs/xfs/libxfs/xfs_bmap.h +2 -0
@@ -273,6 +273,8 @@ int xfs_bmap_complain_bad_rec(struct xfs_inode *ip, int whichfork,int xfs_bmapi_remap (struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t bno,xfs_filblks_t len,xfs_fsblock_t startblock,uint32_t flags); +int xfs_bunmapi_range (struct xfs_trans **tpp,struct xfs_inode *ip, +uint32_t flags,xfs_fileoff_t startoff,xfs_fileoff_t endoff);extern struct kmem_cache *xfs_bmap_intent_cache;
fs/xfs/xfs_inode.c +4 -20
@@ -40,12 +40,6 @@struct kmem_cache *xfs_inode_cache; -/* -* Used in xfs_itruncate_extents(). This is the maximum number of extents -* freed from a file in a single transaction. -*/ -#define XFS_ITRUNC_MAX_EXTENTS 2 - STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *); STATIC int xfs_iunlink_remove(struct xfs_trans *tp, struct xfs_perag *pag,struct xfs_inode *);
@@ -1332,7 +1326,6 @@ xfs_itruncate_extents_flags(struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp = *tpp;xfs_fileoff_t first_unmap_block; -xfs_filblks_t unmap_len;int error =0 ;ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));
@@ -1364,19 +1357,10 @@ xfs_itruncate_extents_flags(return 0 ; } - unmap_len =XFS_MAX_FILEOFF - first_unmap_block +1 ; -while (unmap_len >0 ) { -ASSERT (tp->t_highest_agno ==NULLAGNUMBER ); - error =__xfs_bunmapi (tp, ip, first_unmap_block, &unmap_len, - flags,XFS_ITRUNC_MAX_EXTENTS ); -if (error) - goto out; - -/* free the just unmapped extents */ - error =xfs_defer_finish (&tp); -if (error) - goto out; - } + error =xfs_bunmapi_range (&tp, ip, flags, first_unmap_block, +XFS_MAX_FILEOFF ); +if (error) + goto out;if (whichfork ==XFS_DATA_FORK ) {/* Remove all pending CoW reservations. */
PATCH 3/4 xfs: always check the rtbitmap and rtsummary files
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
XFS filesystems always have a realtime bitmap and summary file, even if there has never been a realtime volume attached. Always check them.
--- fs/xfs/scrub/scrub.c | 2 -- 1 file changed, 2 deletions(-)
fs/xfs/scrub/scrub.c +0 -2
@@ -330,14 +330,12 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_rtbitmap, .scrub = xchk_rtbitmap, - .has = xfs_has_realtime, .repair = xrep_notsupported, }, [XFS_SCRUB_TYPE_RTSUM] = { /* realtime summary */ .type = ST_FS, .setup = xchk_setup_rtsummary, .scrub = xchk_rtsummary, - .has = xfs_has_realtime, .repair = xrep_notsupported, }, [XFS_SCRUB_TYPE_UQUOTA] = { /* user quota */
PATCH 4/4 xfs: online repair of realtime bitmaps
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Rebuild the realtime bitmap from the realtime rmap btree.
--- fs/xfs/Makefile | 4 +++ fs/xfs/scrub/repair.h | 13 +++++++++ fs/xfs/scrub/rtbitmap.c | 10 ++++++- fs/xfs/scrub/rtbitmap_repair.c | 56 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 2 + 5 files changed, 83 insertions(+), 2 deletions(-) create mode 100644 fs/xfs/scrub/rtbitmap_repair.c
fs/xfs/Makefile +4 -0
@@ -191,5 +191,9 @@ xfs-y += $(addprefix scrub/, \ refcount_repair.o \ repair.o \ ) + +xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ + rtbitmap_repair.o \ + ) endif endif
fs/xfs/scrub/repair.h +13 -0
@@ -90,6 +90,7 @@ int xrep_setup_ag_allocbt(struct xfs_scrub *sc);struct xfs_imap ;int xrep_setup_inode (struct xfs_scrub *sc,struct xfs_imap *imap); +int xrep_setup_rtbitmap (struct xfs_scrub *sc,unsigned int *resblks);void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa); int xrep_ag_init(struct xfs_scrub *sc, struct xfs_perag *pag,
@@ -115,6 +116,12 @@ int xrep_bmap_data(struct xfs_scrub *sc);int xrep_bmap_attr (struct xfs_scrub *sc);int xrep_bmap_cow (struct xfs_scrub *sc); +#ifdef CONFIG_XFS_RT +int xrep_rtbitmap (struct xfs_scrub *sc); +#else +# define xrep_rtbitmap xrep_notsupported +#endif /* CONFIG_XFS_RT */ +int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -162,6 +169,11 @@ xrep_setup_nothing(#define xrep_setup_inode (sc, imap) ((void)0) +static inline int xrep_setup_rtbitmap (struct xfs_scrub *sc,unsigned int *x) +{ +return 0 ; +} +#define xrep_revalidate_allocbt (NULL)#define xrep_revalidate_iallocbt (NULL)
@@ -177,6 +189,7 @@ xrep_setup_nothing(#define xrep_bmap_data xrep_notsupported#define xrep_bmap_attr xrep_notsupported#define xrep_bmap_cow xrep_notsupported +#define xrep_rtbitmap xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/rtbitmap.c +9 -1
@@ -16,15 +16,23 @@#include "xfs_bmap.h" #include "scrub/scrub.h" #include "scrub/common.h" +#include "scrub/repair.h" /* Set us up with the realtime metadata locked. */ int xchk_setup_rtbitmap (struct xfs_scrub *sc) { +unsigned int resblks =0 ;int error; - error =xchk_trans_alloc (sc,0 ); +if (xchk_could_repair (sc)) { + error =xrep_setup_rtbitmap (sc, &resblks); +if (error) +return error; + } + + error =xchk_trans_alloc (sc, resblks);if (error)return error;
fs/xfs/scrub/rtbitmap_repair.c new file +56 -0
56 lines not on this page · raw message
fs/xfs/scrub/scrub.c +1 -1
@@ -330,7 +330,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_rtbitmap, .scrub = xchk_rtbitmap, - .repair = xrep_notsupported, + .repair = xrep_rtbitmap, }, [XFS_SCRUB_TYPE_RTSUM] = { /* realtime summary */ .type = ST_FS,
cover xfs: online repair of quota and rt metadata files
In reply to Darrick J. WongHi all,
XFS stores quota records and free space bitmap information in files. Add the necessary infrastructure to enable repairing metadata inodes and their forks, and then make it so that we can repair the file metadata for the rtbitmap. Repairing the bitmap contents (and the summary file) is left for subsequent patchsets.
We also add the ability to repair file metadata the quota files. As part of these repairs, we also reinitialize the ondisk dquot records as necessary to get the incore dquots working. We can also correct obviously bad dquot record attributes, but we leave checking the resource usage counts for the next patchsets.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. 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=repair-quota
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-quota
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-quota
--- fs/xfs/Makefile | 9 + fs/xfs/libxfs/xfs_format.h | 3 fs/xfs/scrub/dqiterate.c | 211 ++++++++++++++++ fs/xfs/scrub/quota.c | 107 +++++++- fs/xfs/scrub/quota.h | 36 +++ fs/xfs/scrub/quota_repair.c | 572 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 7 + fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/trace.c | 3 fs/xfs/scrub/trace.h | 78 ++++++ fs/xfs/xfs_dquot.c | 37 --- fs/xfs/xfs_dquot.h | 8 - 12 files changed, 1023 insertions(+), 54 deletions(-) create mode 100644 fs/xfs/scrub/dqiterate.c create mode 100644 fs/xfs/scrub/quota.h create mode 100644 fs/xfs/scrub/quota_repair.c
PATCH 1/5 xfs: check the ondisk space mapping behind a dquot
From: Darrick J. Wong <[email protected]>
Each xfs_dquot object caches the file offset and daddr of the ondisk block that backs the dquot. Make sure these cached values are the same as the bmapi data, and that the block state is written.
--- fs/xfs/scrub/quota.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
fs/xfs/scrub/quota.c +58 -0
@@ -6,6 +6,7 @@#include "xfs.h" #include "xfs_fs.h" #include "xfs_shared.h" +#include "xfs_bit.h" #include "xfs_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h"
@@ -75,6 +76,47 @@ struct xchk_quota_info {xfs_dqid_t last_id; }; +/* There's a written block backing this dquot, right? */ +STATIC int +xchk_quota_item_bmap ( +struct xfs_scrub *sc, +struct xfs_dquot *dq, +xfs_fileoff_t offset) +{ +struct xfs_bmbt_irec irec; +struct xfs_mount *mp = sc->mp; +int nmaps =1 ; +int error; + +if (!xfs_verify_fileoff (mp, offset)) { +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); +return 0 ; + } + +if (dq->q_fileoffset != offset) { +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); +return 0 ; + } + + error =xfs_bmapi_read (sc->ip, offset,1 , &irec, &nmaps,0 ); +if (error) +return error; + +if (nmaps !=1 ) { +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); +return 0 ; + } + +if (!xfs_verify_fsbno (mp, irec.br_startblock)) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); +if (XFS_FSB_TO_DADDR (mp, irec.br_startblock) != dq->q_blkno) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); +if (!xfs_bmap_is_written_extent (&irec)) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); + +return 0 ; +} +/* Scrub the fields in an individual quota item. */ STATIC int xchk_quota_item(
@@ -93,6 +135,17 @@ xchk_quota_item(if (xchk_should_terminate (sc, &error))return error; +/* +* We want to validate the bmap record for the storage backing this +* dquot, so we need to lock the dquot and the quota file. For quota +* operations, the locking order is first the ILOCK and then the dquot. +* However, dqiterate gave us a locked dquot, so drop the dquot lock to +* get the ILOCK. +*/ +xfs_dqunlock (dq); +xchk_ilock (sc,XFS_ILOCK_SHARED ); +xfs_dqlock (dq); +/* * Except for the root dquot, the actual dquot we got must either have * the same or higher id as we saw before.
@@ -103,6 +156,11 @@ xchk_quota_item( sqi->last_id = dq->q_id; + error =xchk_quota_item_bmap (sc, dq, offset); +xchk_iunlock (sc,XFS_ILOCK_SHARED ); +if (!xchk_fblock_process_error (sc,XFS_DATA_FORK , offset, &error)) +return error; +/* * Warn if the hard limits are larger than the fs. * Administrators can do this, though in production this seems
PATCH 2/5 xfs: check dquot resource timers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
For each dquot resource, ensure either (a) the resource usage is over the soft limit and there is a nonzero timer; or (b) usage is at or under the soft limit and the timer is unset. (a) is redundant with the dquot buffer verifier, but (b) isn't checked anywhere.
Found by fuzzing xfs/426 and noticing that diskdq.btimer = add didn't trip any kind of warning for having a timer set even with no limits.
--- fs/xfs/scrub/quota.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
fs/xfs/scrub/quota.c +21 -0
@@ -117,6 +117,23 @@ xchk_quota_item_bmap(return 0 ; } +/* Complain if a quota timer is incorrectly set. */ +static inline void +xchk_quota_item_timer ( +struct xfs_scrub *sc, +xfs_fileoff_t offset, +const struct xfs_dquot_res *res) +{ +if ((res->softlimit && res->count > res->softlimit) || + (res->hardlimit && res->count > res->hardlimit)) { +if (!res->timer) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); + }else { +if (res->timer) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); + } +} +/* Scrub the fields in an individual quota item. */ STATIC int xchk_quota_item(
@@ -224,6 +241,10 @@ xchk_quota_item( dq->q_rtb.count > dq->q_rtb.hardlimit)xchk_fblock_set_warning (sc,XFS_DATA_FORK , offset); +xchk_quota_item_timer (sc, offset, &dq->q_blk); +xchk_quota_item_timer (sc, offset, &dq->q_ino); +xchk_quota_item_timer (sc, offset, &dq->q_rtb); + out:if (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT )return -ECANCELED ;
PATCH 3/5 xfs: pull xfs_qm_dqiterate back into scrub
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
There aren't any other users of this code outside of online fsck, so pull it back in there.
--- fs/xfs/Makefile | 5 ++++ fs/xfs/scrub/dqiterate.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/quota.c | 3 ++- fs/xfs/scrub/quota.h | 14 ++++++++++++ fs/xfs/xfs_dquot.c | 31 --------------------------- fs/xfs/xfs_dquot.h | 5 ---- 6 files changed, 72 insertions(+), 38 deletions(-) create mode 100644 fs/xfs/scrub/dqiterate.c create mode 100644 fs/xfs/scrub/quota.h
fs/xfs/Makefile +4 -1
@@ -175,7 +175,10 @@ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ rtsummary.o \ ) -xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o +xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \ + dqiterate.o \ + quota.o \ + ) # online repair ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y)
fs/xfs/scrub/dqiterate.c new file +52 -0
52 lines not on this page · raw message
fs/xfs/scrub/quota.c +2 -1
@@ -18,6 +18,7 @@#include "xfs_bmap.h" #include "scrub/scrub.h" #include "scrub/common.h" +#include "scrub/quota.h" /* Convert a scrub type code to a DQ flag, or return 0 if error. */ static inline xfs_dqtype_t
@@ -320,7 +321,7 @@ xchk_quota(xchk_iunlock (sc, sc->ilock_flags); sqi.sc = sc; sqi.last_id =0 ; - error =xfs_qm_dqiterate (mp, dqtype, xchk_quota_item, &sqi); + error =xchk_dqiterate (mp, dqtype, xchk_quota_item, &sqi);xchk_ilock (sc,XFS_ILOCK_EXCL );if (error == -ECANCELED ) error =0 ;
fs/xfs/scrub/quota.h new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (C) 2018-2023 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_QUOTA_H__ +#define __XFS_SCRUB_QUOTA_H__ + +typedef int (*xchk_dqiterate_fn )(struct xfs_dquot *dq, +xfs_dqtype_t type,void *priv); +int xchk_dqiterate (struct xfs_mount *mp,xfs_dqtype_t type, +xchk_dqiterate_fn iter_fn,void *priv); + +#endif /* __XFS_SCRUB_QUOTA_H__ */
fs/xfs/xfs_dquot.c +0 -31
@@ -1361,34 +1361,3 @@ xfs_qm_exit(void)kmem_cache_destroy (xfs_dqtrx_cache);kmem_cache_destroy (xfs_dquot_cache); } - -/* -* Iterate every dquot of a particular type. The caller must ensure that the -* particular quota type is active. iter_fn can return negative error codes, -* or -ECANCELED to indicate that it wants to stop iterating. -*/ -int -xfs_qm_dqiterate ( -struct xfs_mount *mp, -xfs_dqtype_t type, -xfs_qm_dqiterate_fn iter_fn, -void *priv) -{ -struct xfs_dquot *dq; -xfs_dqid_t id =0 ; -int error; - -do { - error =xfs_qm_dqget_next (mp, id, type, &dq); -if (error == -ENOENT ) -return 0 ; -if (error) -return error; - - error =iter_fn (dq, type, priv); - id = dq->q_id +1 ; -xfs_qm_dqput (dq); - }while (error ==0 && id !=0 ); - -return error; -}
fs/xfs/xfs_dquot.h +0 -5
@@ -234,11 +234,6 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)return dqp; } -typedef int (*xfs_qm_dqiterate_fn )(struct xfs_dquot *dq, -xfs_dqtype_t type,void *priv); -int xfs_qm_dqiterate (struct xfs_mount *mp,xfs_dqtype_t type, -xfs_qm_dqiterate_fn iter_fn,void *priv); -time64_t xfs_dquot_set_timeout (struct xfs_mount *mp,time64_t timeout);time64_t xfs_dquot_set_grace_period (time64_t grace);
PATCH 4/5 xfs: improve dquot iteration for scrub
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Upon a closer inspection of the quota record scrubber, I noticed that dqiterate wasn't actually walking all possible dquots for the mapped blocks in the quota file. This is due to xfs_qm_dqget_next skipping all XFS_IS_DQUOT_UNINITIALIZED dquots.
For a fsck program, we really want to look at all the dquots, even if all counters and limits in the dquot record are zero. Rewrite the implementation to do this, as well as switching to an iterator paradigm to reduce the number of indirect calls.
--- fs/xfs/libxfs/xfs_format.h | 3 + fs/xfs/scrub/dqiterate.c | 195 ++++++++++++++++++++++++++++++++++++++++---- fs/xfs/scrub/quota.c | 24 +++-- fs/xfs/scrub/quota.h | 28 +++++- fs/xfs/scrub/trace.c | 2 fs/xfs/scrub/trace.h | 49 +++++++++++ 6 files changed, 270 insertions(+), 31 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -0
@@ -1271,6 +1271,9 @@ static inline time64_t xfs_dq_bigtime_to_unix(uint32_t ondisk_seconds)#define XFS_DQ_GRACE_MIN ((int64_t)0)#define XFS_DQ_GRACE_MAX ((int64_t)U32_MAX) +/* Maximum id value for a quota record */ +#define XFS_DQ_ID_MAX (U32_MAX) +/* * This is the main portion of the on-disk representation of quota information * for a user. We pad this with some more expansion room to construct the on
fs/xfs/scrub/dqiterate.c +177 -18
211 lines not on this page · raw message
fs/xfs/scrub/quota.c +15 -9
@@ -138,11 +138,9 @@ xchk_quota_item_timer(/* Scrub the fields in an individual quota item. */ STATIC intxchk_quota_item ( -struct xfs_dquot *dq, -xfs_dqtype_t dqtype, -void *priv) +struct xchk_quota_info *sqi, +struct xfs_dquot *dq) { -struct xchk_quota_info *sqi = priv;struct xfs_scrub *sc = sqi->sc;struct xfs_mount *mp = sc->mp;struct xfs_quotainfo *qi = mp->m_quotainfo;
@@ -271,7 +269,7 @@ xchk_quota_data_fork(return error;/* Check for data fork problems that apply only to quota files. */ - max_dqid_off = ((xfs_dqid_t)-1 ) / qi->qi_dqperchunk; + max_dqid_off =XFS_DQ_ID_MAX / qi->qi_dqperchunk; ifp =xfs_ifork_ptr (sc->ip,XFS_DATA_FORK );for_each_xfs_iext (ifp, &icur, &irec) {if (xchk_should_terminate (sc, &error))
@@ -298,9 +296,11 @@ intxchk_quota ( struct xfs_scrub *sc) { -struct xchk_quota_info sqi; +struct xchk_dqiter cursor = { }; +struct xchk_quota_info sqi = { .sc = sc };struct xfs_mount *mp = sc->mp;struct xfs_quotainfo *qi = mp->m_quotainfo; +struct xfs_dquot *dq;xfs_dqtype_t dqtype;int error =0 ;
@@ -319,9 +319,15 @@ xchk_quota(* functions. */ xchk_iunlock (sc, sc->ilock_flags); - sqi.sc = sc; - sqi.last_id =0 ; - error =xchk_dqiterate (mp, dqtype, xchk_quota_item, &sqi); + +/* Now look for things that the quota verifiers won't complain about. */ +xchk_dqiter_init (&cursor, sc, dqtype); +while ((error =xchk_dquot_iter (&cursor, &dq)) ==1 ) { + error =xchk_quota_item (&sqi, dq); +xfs_qm_dqput (dq); +if (error) +break ; + }xchk_ilock (sc,XFS_ILOCK_EXCL );if (error == -ECANCELED ) error =0 ;
fs/xfs/scrub/quota.h +24 -4
@@ -6,9 +6,29 @@#ifndef __XFS_SCRUB_QUOTA_H__#define __XFS_SCRUB_QUOTA_H__ -typedef int (*xchk_dqiterate_fn )(struct xfs_dquot *dq, -xfs_dqtype_t type,void *priv); -int xchk_dqiterate (struct xfs_mount *mp,xfs_dqtype_t type, -xchk_dqiterate_fn iter_fn,void *priv); +/* dquot iteration code */ + +struct xchk_dqiter { +struct xfs_scrub *sc; + +/* Quota file that we're walking. */ +struct xfs_inode *quota_ip; + +/* Cached data fork mapping for the dquot. */ +struct xfs_bmbt_irec bmap; + +/* The next dquot to scan. */ +uint64_t id; + +/* Quota type (user/group/project). */ +xfs_dqtype_t dqtype; + +/* Data fork sequence number to detect stale mappings. */ +unsigned int if_seq; +}; + +void xchk_dqiter_init (struct xchk_dqiter *cursor,struct xfs_scrub *sc, +xfs_dqtype_t dqtype); +int xchk_dquot_iter (struct xchk_dqiter *cursor,struct xfs_dquot **dqpp);#endif /* __XFS_SCRUB_QUOTA_H__ */
fs/xfs/scrub/trace.c +2 -0
@@ -13,9 +13,11 @@#include "xfs_inode.h" #include "xfs_btree.h" #include "xfs_ag.h" +#include "xfs_quota.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h" +#include "scrub/quota.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
fs/xfs/scrub/trace.h +49 -0
61 lines not on this page · raw message
PATCH 5/5 xfs: repair quotas
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Fix anything that causes the quota verifiers to fail.
--- fs/xfs/Makefile | 4 fs/xfs/scrub/quota.c | 3 fs/xfs/scrub/quota.h | 2 fs/xfs/scrub/quota_repair.c | 572 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 7 + fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 29 ++ fs/xfs/xfs_dquot.c | 6 fs/xfs/xfs_dquot.h | 3 10 files changed, 625 insertions(+), 8 deletions(-) create mode 100644 fs/xfs/scrub/quota_repair.c
fs/xfs/Makefile +4 -0
@@ -198,5 +198,9 @@ xfs-y += $(addprefix scrub/, \ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ rtbitmap_repair.o \ ) + +xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \ + quota_repair.o \ + ) endif endif
fs/xfs/scrub/quota.c +1 -2
@@ -21,7 +21,7 @@#include "scrub/quota.h" /* Convert a scrub type code to a DQ flag, or return 0 if error. */ -static inline xfs_dqtype_t +xfs_dqtype_t xchk_quota_to_dqtype (struct xfs_scrub *sc) {
@@ -328,7 +328,6 @@ xchk_quota(if (error)break ; } -xchk_ilock (sc,XFS_ILOCK_EXCL );if (error == -ECANCELED ) error =0 ; if (!xchk_fblock_process_error(sc, XFS_DATA_FORK,
fs/xfs/scrub/quota.h +2 -0
@@ -6,6 +6,8 @@#ifndef __XFS_SCRUB_QUOTA_H__#define __XFS_SCRUB_QUOTA_H__ +xfs_dqtype_t xchk_quota_to_dqtype (struct xfs_scrub *sc); +/* dquot iteration code */ struct xchk_dqiter {
fs/xfs/scrub/quota_repair.c new file +572 -0
572 lines not on this page · raw message
fs/xfs/scrub/repair.h +7 -0
@@ -122,6 +122,12 @@ int xrep_rtbitmap(struct xfs_scrub *sc);# define xrep_rtbitmap xrep_notsupported#endif /* CONFIG_XFS_RT */ +#ifdef CONFIG_XFS_QUOTA +int xrep_quota (struct xfs_scrub *sc); +#else +# define xrep_quota xrep_notsupported +#endif /* CONFIG_XFS_QUOTA */ +int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -190,6 +196,7 @@ static inline int xrep_setup_rtbitmap(struct xfs_scrub *sc, unsigned int *x)#define xrep_bmap_attr xrep_notsupported#define xrep_bmap_cow xrep_notsupported#define xrep_rtbitmap xrep_notsupported +#define xrep_quota xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +3 -3
@@ -342,19 +342,19 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_quota, .scrub = xchk_quota, - .repair = xrep_notsupported, + .repair = xrep_quota, }, [XFS_SCRUB_TYPE_GQUOTA] = { /* group quota */ .type = ST_FS, .setup = xchk_setup_quota, .scrub = xchk_quota, - .repair = xrep_notsupported, + .repair = xrep_quota, }, [XFS_SCRUB_TYPE_PQUOTA] = { /* project quota */ .type = ST_FS, .setup = xchk_setup_quota, .scrub = xchk_quota, - .repair = xrep_notsupported, + .repair = xrep_quota, }, [XFS_SCRUB_TYPE_FSCOUNTERS] = { /* fs summary counters */ .type = ST_FS,
fs/xfs/scrub/trace.c +1 -0
@@ -14,6 +14,7 @@#include "xfs_btree.h" #include "xfs_ag.h" #include "xfs_quota.h" +#include "xfs_quota_defs.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h"
fs/xfs/scrub/trace.h +29 -0
@@ -1731,6 +1731,35 @@ TRACE_EVENT(xrep_cow_free_staging, __entry->blockcount) ); +#ifdef CONFIG_XFS_QUOTA +DECLARE_EVENT_CLASS (xrep_dquot_class, + TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), +TP_ARGS (mp, type, id), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(uint8_t, type) +__field (uint32_t, id) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->id = id; + __entry->type = type; + ), +TP_printk ("dev %d:%d type %s id 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), +__print_flags (__entry->type,"|" ,XFS_DQTYPE_STRINGS ), + __entry->id) +); + +#define DEFINE_XREP_DQUOT_EVENT (name) \ +DEFINE_EVENT(xrep_dquot_class, name, \ + TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), \ + TP_ARGS(mp, type, id)) +DEFINE_XREP_DQUOT_EVENT (xrep_dquot_item); +DEFINE_XREP_DQUOT_EVENT (xrep_disk_dquot); +DEFINE_XREP_DQUOT_EVENT (xrep_dquot_item_fill_bmap_hole); +#endif /* CONFIG_XFS_QUOTA */ +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ #endif /* _TRACE_XFS_SCRUB_TRACE_H */
fs/xfs/xfs_dquot.c +3 -3
@@ -172,14 +172,14 @@ xfs_qm_adjust_dqtimers(/* * initialize a buffer full of dquots and log the whole thing */ -STATIC void +void xfs_qm_init_dquot_blk (struct xfs_trans *tp, -struct xfs_mount *mp,xfs_dqid_t id,xfs_dqtype_t type,struct xfs_buf *bp) { +struct xfs_mount *mp = tp->t_mountp;struct xfs_quotainfo *q = mp->m_quotainfo;struct xfs_dqblk *d;xfs_dqid_t curid;
@@ -353,7 +353,7 @@ xfs_dquot_disk_alloc(* Make a chunk of dquots out of this buffer and log * the entire thing. */ -xfs_qm_init_dquot_blk (tp, mp, dqp->q_id, qtype, bp); +xfs_qm_init_dquot_blk (tp, dqp->q_id, qtype, bp);xfs_buf_set_ref (bp,XFS_DQUOT_REF );/*
fs/xfs/xfs_dquot.h +3 -0
@@ -237,4 +237,7 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)time64_t xfs_dquot_set_timeout (struct xfs_mount *mp,time64_t timeout);time64_t xfs_dquot_set_grace_period (time64_t grace); +void xfs_qm_init_dquot_blk (struct xfs_trans *tp,xfs_dqid_t id,xfs_dqtype_t + type,struct xfs_buf *bp); +#endif /* __XFS_DQUOT_H__ */
PATCH v28 1/1 xfs: online repair, second part of part 1
In reply to Darrick J. WongHi everyone,
I've rebased the online fsck development branches atop 6.7, applied the changes requested during the review of v27, and reworked the automatic space reaping code to avoid open-coding EFI log item handling, and cleaned up a few other things.
In other words, I'm formally submitting part 1 for inclusion in 6.8.
Just like the last several submissions, I would like people to focus the following:
- Are the major subsystems sufficiently documented that you could figure out what the code does?
- Do you see any problems that are severe enough to cause long term support hassles? (e.g. bad API design, writing weird metadata to disk)
- Can you spot mis-interactions between the subsystems?
- What were my blind spots in devising this feature?
- Are there missing pieces that you'd like to help build?
- Can I just merge all of this?
The one thing that is /not/ in scope for this review are requests for more refactoring of existing subsystems. I'm still running QA round the clock. To spare vger, I'm only sending a few patchsets this time. I will of course stress test the new mailing infrastructure on 31 Dec with a full posting, like I always do.
--D