xfs: scrub/repair update health tracking
v3 cover xfs: scrub/repair update health tracking
Hi all,
This series enhances the online scrub and repair code to report their findings to the health tracking subsystem. For now, only scrub gets to record corruption problems, though in principle a metadata read encountering corruption could also set a sick flag.
Online repair will clear the appropriate sick flags when metadata passes its inspection after a repair attempt.
The first three patches rework the scrub context management code to remove some clunkiness when we decide that we have to start the scrub over.
Patch #4 actually teaches scrub to update the health subsystem.
Patch #5 teaches scrub to skip cross-referencing with known corrupt metadata.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-health-tracking
PATCH v3 1/5 xfs: refactor scrub context initialization
From: Darrick J. Wong <[email protected]>
It's a little silly how the memset in scrub context initialization forces us to declare stack variables to preserve context variables across a retry. Since the teardown functions already null out most of the ephemeral state (buffer pointers, btree cursors, etc.), just skip the memset and move the initialization as needed.
--- fs/xfs/scrub/scrub.c | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-)
fs/xfs/scrub/scrub.c +18 -13
@@ -186,8 +186,10 @@ xchk_teardown(xfs_irele (sc->ip); sc->ip =NULL ; } -if (sc->has_quotaofflock) +if (sc->has_quotaofflock) {mutex_unlock (&sc->mp->m_quotainfo->qi_quotaofflock); + sc->has_quotaofflock = false; + }if (sc->buf) {kmem_free (sc->buf); sc->buf =NULL ;
@@ -466,9 +468,14 @@ xfs_scrub_metadata(struct xfs_inode *ip, struct xfs_scrub_metadata *sm) { - struct xfs_scrub sc; + struct xfs_scrub sc = { + .mp = ip->i_mount, + .sm = sm, + .sa = { + .agno =NULLAGNUMBER , + }, + };struct xfs_mount *mp = ip->i_mount; -bool try_harder = false;bool already_fixed = false;int error =0 ;
@@ -491,21 +498,16 @@ xfs_scrub_metadata(xchk_experimental_warning (mp); + sc.ops = &meta_scrub_ops[sm->sm_type]; retry_op:/* Set up for the operation. */ -memset (&sc,0 ,sizeof (sc)); - sc.mp = ip->i_mount; - sc.sm = sm; - sc.ops = &meta_scrub_ops[sm->sm_type]; - sc.try_harder = try_harder; - sc.sa.agno =NULLAGNUMBER ; error = sc.ops->setup (&sc, ip);if (error) goto out_teardown;/* Scrub for errors. */ error = sc.ops->scrub (&sc); -if (!try_harder && error == -EDEADLOCK ) { +if (!sc.try_harder && error == -EDEADLOCK ) {/* * Scrubbers return -EDEADLOCK to mean 'try harder'. * Tear down everything we hold, then set up again with
@@ -514,7 +516,7 @@ xfs_scrub_metadata( error =xchk_teardown (&sc, ip,0 );if (error) goto out; - try_harder = true; + sc.try_harder = true; goto retry_op; }else if (error) goto out_teardown;
@@ -544,8 +546,11 @@ xfs_scrub_metadata(*/ error =xrep_attempt (ip, &sc, &already_fixed);if (error == -EAGAIN ) { -if (sc.try_harder) - try_harder = true; +/* +* Either the repair function succeeded or it couldn't +* get all the resources it needs; either way, we go +* back to the beginning and call the scrub function. +*/ error =xchk_teardown (&sc, ip,0 );if (error) {xrep_failure (mp);
Re: [PATCH 1/5] xfs: refactor scrub context initialization
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
It's a little silly how the memset in scrub context initialization forces us to declare stack variables to preserve context variables across a retry. Since the teardown functions already null out most of the ephemeral state (buffer pointers, btree cursors, etc.), just skip the memset and move the initialization as needed.
Signed-off-by Darrick J. Wong <[email protected]>
Looks sane
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 2/5 xfs: collapse scrub bool state flags into a single unsigned int
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Combine all the boolean state flags in struct xfs_scrub into a single unsigned int, because we're going to be adding more state flags soon.
--- fs/xfs/scrub/ialloc.c | 4 ++-- fs/xfs/scrub/parent.c | 2 +- fs/xfs/scrub/quota.c | 2 +- fs/xfs/scrub/repair.c | 4 ++-- fs/xfs/scrub/scrub.c | 8 ++++---- fs/xfs/scrub/scrub.h | 9 +++++++-- 6 files changed, 17 insertions(+), 12 deletions(-)
fs/xfs/scrub/ialloc.c +2 -2
@@ -39,7 +39,7 @@ xchk_setup_ag_iallocbt(struct xfs_scrub *sc, struct xfs_inode *ip) { - return xchk_setup_ag_btree(sc, ip, sc->try_harder); + return xchk_setup_ag_btree(sc, ip, sc->flags & XCHK_TRY_HARDER); }/* Inode btree scrubber. */
@@ -185,7 +185,7 @@ xchk_iallocbt_check_cluster_ifree(if (error == -ENODATA ) {/* Not cached, just read the disk buffer */ freemask_ok = irec_free ^ !!(dip->di_mode); -if (!bs->sc->try_harder && !freemask_ok) +if (!(bs->sc->flags &XCHK_TRY_HARDER ) && !freemask_ok)return -EDEADLOCK ; }else if (error <0 ) {/*
fs/xfs/scrub/parent.c +1 -1
@@ -320,7 +320,7 @@ xchk_parent(* If we failed to lock the parent inode even after a retry, just mark * this scrub incomplete and return. */ -if (sc->try_harder && error == -EDEADLOCK ) { +if ((sc->flags &XCHK_TRY_HARDER ) && error == -EDEADLOCK ) { error =0 ;xchk_set_incomplete (sc); }
fs/xfs/scrub/quota.c +1 -1
@@ -60,7 +60,7 @@ xchk_setup_quota( dqtype =xchk_quota_to_dqtype (sc);if (dqtype ==0 )return -EINVAL ; - sc->has_quotaofflock = true; + sc->flags |=XCHK_HAS_QUOTAOFFLOCK ;mutex_lock (&sc->mp->m_quotainfo->qi_quotaofflock);if (!xfs_this_quota_on (sc->mp, dqtype))return -ENOENT ;
fs/xfs/scrub/repair.c +2 -2
@@ -71,8 +71,8 @@ xrep_attempt(case -EDEADLOCK :case -EAGAIN :/* Tell the caller to try again having grabbed all the locks. */ -if (!sc->try_harder) { - sc->try_harder = true; +if (!(sc->flags &XCHK_TRY_HARDER )) { + sc->flags |=XCHK_TRY_HARDER ;return -EAGAIN ; }/*
fs/xfs/scrub/scrub.c +4 -4
@@ -186,9 +186,9 @@ xchk_teardown(xfs_irele (sc->ip); sc->ip =NULL ; } -if (sc->has_quotaofflock) { +if (sc->flags &XCHK_HAS_QUOTAOFFLOCK ) {mutex_unlock (&sc->mp->m_quotainfo->qi_quotaofflock); - sc->has_quotaofflock = false; + sc->flags &= ~XCHK_HAS_QUOTAOFFLOCK ; }if (sc->buf) {kmem_free (sc->buf);
@@ -507,7 +507,7 @@ xfs_scrub_metadata(/* Scrub for errors. */ error = sc.ops->scrub (&sc); -if (!sc.try_harder && error == -EDEADLOCK ) { +if (!(sc.flags &XCHK_TRY_HARDER ) && error == -EDEADLOCK ) {/* * Scrubbers return -EDEADLOCK to mean 'try harder'. * Tear down everything we hold, then set up again with
@@ -516,7 +516,7 @@ xfs_scrub_metadata( error =xchk_teardown (&sc, ip,0 );if (error) goto out; - sc.try_harder = true; + sc.flags |=XCHK_TRY_HARDER ; goto retry_op; }else if (error) goto out_teardown;
fs/xfs/scrub/scrub.h +7 -2
@@ -62,13 +62,18 @@ struct xfs_scrub {struct xfs_inode *ip;void *buf;uint ilock_flags; -bool try_harder; -bool has_quotaofflock; + +/* See the XCHK state flags below. */ +unsigned int flags;/* State tracking for single-AG operations. */ struct xchk_ag sa; }; +/* XCHK state flags */ +#define XCHK_TRY_HARDER (1 << 0)/* can't get resources, try again */ +#define XCHK_HAS_QUOTAOFFLOCK (1 << 1)/* we hold the quotaoff lock */ +/* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);int xchk_superblock (struct xfs_scrub *sc);
Re: [PATCH 2/5] xfs: collapse scrub bool state flags into a single unsigned int
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Combine all the boolean state flags in struct
xfs_scrubinto a single unsigned int, because we're going to be adding more state flags soon.Signed-off-by Darrick J. Wong <[email protected]>
Looks good.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 3/5 xfs: hoist the already_fixed variable to the scrub context
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we no longer memset the scrub context, we can move the already_fixed variable into the scrub context's state flags instead of passing around pointers to separate stack variables.
--- fs/xfs/scrub/repair.c | 5 ++--- fs/xfs/scrub/repair.h | 5 ++--- fs/xfs/scrub/scrub.c | 6 +++--- fs/xfs/scrub/scrub.h | 5 +++-- 4 files changed, 10 insertions(+), 11 deletions(-)
fs/xfs/scrub/repair.c +2 -3
@@ -46,8 +46,7 @@int xrep_attempt (struct xfs_inode *ip, -struct xfs_scrub *sc, -bool *fixed) +struct xfs_scrub *sc) {int error =0 ;
@@ -66,7 +65,7 @@ xrep_attempt(* scrub so that we can tell userspace if we fixed the problem. */ sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT ; - *fixed = true; + sc->flags |=XREP_ALREADY_FIXED ;return -EAGAIN ;case -EDEADLOCK :case -EAGAIN :
fs/xfs/scrub/repair.h +2 -3
@@ -15,7 +15,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)/* Repair helpers */ -int xrep_attempt (struct xfs_inode *ip,struct xfs_scrub *sc,bool *fixed); +int xrep_attempt (struct xfs_inode *ip,struct xfs_scrub *sc);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc); bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
@@ -64,8 +64,7 @@ int xrep_agi(struct xfs_scrub *sc);static inline int xrep_attempt (struct xfs_inode *ip, -struct xfs_scrub *sc, -bool *fixed) +struct xfs_scrub *sc) {return -EOPNOTSUPP ; }
fs/xfs/scrub/scrub.c +3 -3
@@ -476,7 +476,6 @@ xfs_scrub_metadata( }, };struct xfs_mount *mp = ip->i_mount; -bool already_fixed = false;int error =0 ; BUILD_BUG_ON(sizeof(meta_scrub_ops) !=
@@ -521,7 +520,8 @@ xfs_scrub_metadata( }else if (error) goto out_teardown; -if ((sc.sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && !already_fixed) { +if ((sc.sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && + !(sc.flags &XREP_ALREADY_FIXED )) {bool needs_fix;/* Let debug users force us into the repair routines. */
@@ -544,7 +544,7 @@ xfs_scrub_metadata(* If it's broken, userspace wants us to fix it, and we haven't * already tried to fix it, then attempt a repair. */ - error =xrep_attempt (ip, &sc, &already_fixed); + error =xrep_attempt (ip, &sc);if (error == -EAGAIN ) {/* * Either the repair function succeeded or it couldn't
fs/xfs/scrub/scrub.h +3 -2
@@ -63,16 +63,17 @@ struct xfs_scrub {void *buf;uint ilock_flags; -/* See the XCHK state flags below. */ +/* See the XCHK/XREP state flags below. */ unsigned int flags;/* State tracking for single-AG operations. */ struct xchk_ag sa; }; -/* XCHK state flags */ +/* XCHK/XREP state flags */ #define XCHK_TRY_HARDER (1 << 0)/* can't get resources, try again */ #define XCHK_HAS_QUOTAOFFLOCK (1 << 1)/* we hold the quotaoff lock */ +#define XREP_ALREADY_FIXED (1 << 31)/* checking our repair work */ /* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);
Re: [PATCH 3/5] xfs: hoist the already_fixed variable to the scrub context
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we no longer memset the scrub context, we can move the
already_fixedvariable into the scrub context's state flags instead of passing around pointers to separate stack variables.Signed-off-by Darrick J. Wong <[email protected]>
Minor comment below, otherwise
Quoted 12 lines
fs/xfs/scrub/scrub.h +1
-1@@ -63,16 +63,17 @@ struct xfs_scrub {void *buf;uint ilock_flags; -/* See the XCHK state flags below. */ +/* See the XCHK/XREP state flags below. */ unsigned int flags;
fs/xfs/scrub/scrub.h struct xfs_scrub { · line 77
Quoted 10 lines
fs/xfs/scrub/scrub.h +2
-1/* State tracking for single-AG operations. */ struct xchk_ag sa; }; -/* XCHK state flags */ +/* XCHK/XREP state flags */ #define XCHK_TRY_HARDER (1 << 0)/* can't get resources, try again */ #define XCHK_HAS_QUOTAOFFLOCK (1 << 1)/* we hold the quotaoff lock */ +#define XREP_ALREADY_FIXED (1 << 31)/* checking our repair work */
Can you just put a comment here saying xchk flags grow from the bottom up, XREP grow from the top down?
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/5] xfs: hoist the already_fixed variable to the scrub context
Quoted 29 lines · Dave Chinner
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we no longer memset the scrub context, we can move the
already_fixedvariable into the scrub context's state flags instead of passing around pointers to separate stack variables.Signed-off-by Darrick J. Wong <[email protected]>Minor comment below, otherwise
Reviewed-by Dave Chinner <[email protected]>Quoted 16 lines
fs/xfs/scrub/scrub.h +1
-1@@ -63,16 +63,17 @@ struct xfs_scrub {void *buf;uint ilock_flags; -/* See the XCHK state flags below. */ +/* See the XCHK/XREP state flags below. */ unsigned int flags;/* State tracking for single-AG operations. */ struct xchk_ag sa; };
Quoted 9 lines
fs/xfs/scrub/scrub.h struct xfs_scrub { · line 77
Quoted 6 lines
fs/xfs/scrub/scrub.h +2
-1-/* XCHK state flags */ +/* XCHK/XREP state flags */ #define XCHK_TRY_HARDER (1 << 0)/* can't get resources, try again */ #define XCHK_HAS_QUOTAOFFLOCK (1 << 1)/* we hold the quotaoff lock */ +#define XREP_ALREADY_FIXED (1 << 31)/* checking our repair work */ Can you just put a comment here saying xchk flags grow from the bottom up, XREP grow from the top down?
Ok, will do.
--D
Quoted 6 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 4/5 xfs: scrub/repair should update filesystem metadata health
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we have the ability to track sick metadata in-core, make scrub and repair update those health assessments after doing work.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/health.c | 176 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/health.h | 12 +++ fs/xfs/scrub/scrub.c | 4 + fs/xfs/scrub/scrub.h | 7 ++ 5 files changed, 200 insertions(+) create mode 100644 fs/xfs/scrub/health.c create mode 100644 fs/xfs/scrub/health.h
fs/xfs/Makefile +1 -0
@@ -143,6 +143,7 @@ xfs-y += $(addprefix scrub/, \ common.o \ dabtree.o \ dir.o \ + health.o \ ialloc.o \ inode.o \ parent.o \
fs/xfs/scrub/health.c new file +176 -0
176 lines not on this page · raw message
fs/xfs/scrub/health.h new file +12 -0
@@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* +* Copyright (C) 2019 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_HEALTH_H__ +#define __XFS_SCRUB_HEALTH_H__ + +unsigned int xchk_health_mask_for_scrub_type (__u32 scrub_type); +void xchk_update_health (struct xfs_scrub *sc); + +#endif /* __XFS_SCRUB_HEALTH_H__ */
fs/xfs/scrub/scrub.c +4 -0
@@ -40,6 +40,7 @@#include "scrub/trace.h" #include "scrub/btree.h" #include "scrub/repair.h" +#include "scrub/health.h" /* * Online Scrub and Repair
@@ -498,6 +499,7 @@ xfs_scrub_metadata(xchk_experimental_warning (mp); sc.ops = &meta_scrub_ops[sm->sm_type]; + sc.sick_mask_update =xchk_health_mask_for_scrub_type (sm->sm_type); retry_op:/* Set up for the operation. */ error = sc.ops->setup (&sc, ip);
@@ -520,6 +522,8 @@ xfs_scrub_metadata( }else if (error) goto out_teardown; +xchk_update_health (&sc); +if ((sc.sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && !(sc.flags &XREP_ALREADY_FIXED )) {bool needs_fix;
fs/xfs/scrub/scrub.h +7 -0
@@ -66,6 +66,13 @@ struct xfs_scrub {/* See the XCHK/XREP state flags below. */ unsigned int flags; +/* +* The XFS_SICK_* flags that correspond to the metadata being scrubbed +* or repaired. We will use this mask to update the in-core fs health +* status with whatever we find. +*/ +unsigned int sick_mask_update; +/* State tracking for single-AG operations. */ struct xchk_ag sa; };
Re: [PATCH 4/5] xfs: scrub/repair should update filesystem metadata health
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we have the ability to track sick metadata in-core, make scrub and repair update those health assessments after doing work.
Signed-off-by Darrick J. Wong <[email protected]>
...
Quoted 8 lines
+/*
+ * Scrub and In-Core Filesystem Health Assessments
+ * ===============================================
+ *
+ * Online scrub and repair have the time and the ability to perform stronger
+ * checks than we can do from the metadata verifiers, because they can
+ * cross-reference records between data structures. Therefore, scrub is in a
+ * good position to update the online filesystem health assessments to reflect
Quoted 8 lines
+ * the good/bad state of the data structure.
+ *
+ * We therefore extend scrub in the following ways to achieve this:
+ *
+ * 1. Create a "sick_mask_update" field in the scrub context. When we're
+ * setting up a scrub call, set this to the default XFS_SICK_* flag(s) for the
+ * selected scrub type (call it A). Scrub and repair functions can override
+ * the defaultsick_mask_updatevalue if they choose.
The name of this field seems ... non-obvious. It's the current health state of the object as the scrubber has scanned it, right? And that if the scrubber has detected an error, it will contain the things that wrong with the object?
I guess it's the "update" part of the name that I don't quite understand. "update" is an action, not a state. we update the object with the current sickness state mask, the mask itself is not doing any updating. Just calling it "sick_mask" gets rid of that icky feeling I have about it's name....
Quoted 9 lines
+ * 2. If the scrubber returns a runtime error code, we exit making no changes
+ * to the incore sick state.
+ *
+ * 3. If the scrubber finds that A is clean, usesick_mask_updateto clear the
+ * incore sick flags before exiting.
+ *
+ * 4. If the scrubber finds that A is corrupt, usesick_mask_updateto set the
+ * incore sick flags. If the user didn't want to repair then we exit, leaving
+ * the metadata structure unfixed and the sick flag set.
Quoted 8 lines
+ *
+ * 5. Now we know that A is corrupt and the user wants to repair, so run the
+ * repairer. If the repairer returns an error code, we exit with that error
+ * code, having made no further changes to the incore sick state.
+ *
+ * 6. If repair rebuilds A correctly and the subsequent re-scrub of A is
+ * clean, usesick_mask_updateto clear the incore sick flags. This should
+ * have the effect that A is no longer marked sick.
.... so it really does hold "current state" and not an "update" operation :)
Quoted 7 lines
+ * 7. If repair rebuilds A incorrectly, the re-scrub will find it corrupt and
+ * usesick_mask_updateto set the incore sick flags. This should have no
+ * externally visible effect since we already set them in step (4).
+ *
+ * There are some complications to this story, however. For certain types of
+ * complementary metadata indices (e.g. inobt/finobt), it is easier to rebuild
+ * both structures at the same time. The following principles apply to this
Quoted 8 lines
+ * type of repair strategy:
+ *
+ * 8. Any repair function that rebuilds multiple structures should update
+ *sick_mask_visibleto reflect whatever other structures are rebuilt, and
+ * verify that all the rebuilt structures can pass a scrub check. The
+ * outcomes of 5-7 still apply, but with asick_mask_updatethat covers
+ * everything being rebuilt.
+ */
Otherwise this all makes sense and the patch is pretty straight forward...
Quoted 15 lines
fs/xfs/scrub/health.c new file +15
-0+static const struct xchk_health_map type_to_health_flag[XFS_SCRUB_TYPE_NR ] = { + [XFS_SCRUB_TYPE_SB ] = {XHG_AG ,XFS_SICK_AG_SB }, + [XFS_SCRUB_TYPE_AGF ] = {XHG_AG ,XFS_SICK_AG_AGF }, + [XFS_SCRUB_TYPE_AGFL ] = {XHG_AG ,XFS_SICK_AG_AGFL }, + [XFS_SCRUB_TYPE_AGI ] = {XHG_AG ,XFS_SICK_AG_AGI }, + [XFS_SCRUB_TYPE_BNOBT ] = {XHG_AG ,XFS_SICK_AG_BNOBT }, + [XFS_SCRUB_TYPE_CNTBT ] = {XHG_AG ,XFS_SICK_AG_CNTBT }, + [XFS_SCRUB_TYPE_INOBT ] = {XHG_AG ,XFS_SICK_AG_INOBT }, + [XFS_SCRUB_TYPE_FINOBT ] = {XHG_AG ,XFS_SICK_AG_FINOBT }, + [XFS_SCRUB_TYPE_RMAPBT ] = {XHG_AG ,XFS_SICK_AG_RMAPBT }, + [XFS_SCRUB_TYPE_REFCNTBT ] = {XHG_AG ,XFS_SICK_AG_REFCNTBT }, + [XFS_SCRUB_TYPE_INODE ] = {XHG_INO ,XFS_SICK_INO_CORE }, + [XFS_SCRUB_TYPE_BMBTD ] = {XHG_INO ,XFS_SICK_INO_BMBTD }, + [XFS_SCRUB_TYPE_BMBTA ] = {XHG_INO ,XFS_SICK_INO_BMBTA }, + [XFS_SCRUB_TYPE_BMBTC ] = {XHG_INO ,XFS_SICK_INO_BMBTC },
fs/xfs/scrub/health.c line 112
Quoted 10 lines
fs/xfs/scrub/health.c new file +10
-0+ [XFS_SCRUB_TYPE_DIR] = { XHG_INO, XFS_SICK_INO_DIR }, + [XFS_SCRUB_TYPE_XATTR] = { XHG_INO, XFS_SICK_INO_XATTR }, + [XFS_SCRUB_TYPE_SYMLINK] = { XHG_INO, XFS_SICK_INO_SYMLINK }, + [XFS_SCRUB_TYPE_PARENT] = { XHG_INO, XFS_SICK_INO_PARENT }, + [XFS_SCRUB_TYPE_RTBITMAP] = { XHG_RT, XFS_SICK_RT_BITMAP }, + [XFS_SCRUB_TYPE_RTSUM] = { XHG_RT, XFS_SICK_RT_SUMMARY }, + [XFS_SCRUB_TYPE_UQUOTA] = { XHG_FS, XFS_SICK_FS_UQUOTA }, + [XFS_SCRUB_TYPE_GQUOTA] = { XHG_FS, XFS_SICK_FS_GQUOTA }, + [XFS_SCRUB_TYPE_PQUOTA] = { XHG_FS, XFS_SICK_FS_PQUOTA }, +};
/me wonders if the primary superblock is XHG_FS or XHG_AG....
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 4/5] xfs: scrub/repair should update filesystem metadata health
Quoted 30 lines · Dave Chinner
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we have the ability to track sick metadata in-core, make scrub and repair update those health assessments after doing work.
Signed-off-by Darrick J. Wong <[email protected]>...
Quoted 8 lines
+/*
+ * Scrub and In-Core Filesystem Health Assessments
+ * ===============================================
+ *
+ * Online scrub and repair have the time and the ability to perform stronger
+ * checks than we can do from the metadata verifiers, because they can
+ * cross-reference records between data structures. Therefore, scrub is in a
+ * good position to update the online filesystem health assessments to reflectQuoted 8 lines
+ * the good/bad state of the data structure.
+ *
+ * We therefore extend scrub in the following ways to achieve this:
+ *
+ * 1. Create a "sick_mask_update" field in the scrub context. When we're
+ * setting up a scrub call, set this to the default XFS_SICK_* flag(s) for the
+ * selected scrub type (call it A). Scrub and repair functions can override
+ * the defaultsick_mask_updatevalue if they choose.The name of this field seems ... non-obvious. It's the current health state of the object as the scrubber has scanned it, right? And that if the scrubber has detected an error, it will contain the things that wrong with the object?
Quoted 5 lines
I guess it's the "update" part of the name that I don't quite understand. "update" is an action, not a state. we update the object with the current sickness state mask, the mask itself is not doing any updating. Just calling it "
sick_mask" gets rid of that icky feeling I have about it's name....
Fair enough, that was the name I used originally.
Quoted 18 lines
Quoted 9 lines
+ * 2. If the scrubber returns a runtime error code, we exit making no changes
+ * to the incore sick state.
+ *
+ * 3. If the scrubber finds that A is clean, usesick_mask_updateto clear the
+ * incore sick flags before exiting.
+ *
+ * 4. If the scrubber finds that A is corrupt, usesick_mask_updateto set the
+ * incore sick flags. If the user didn't want to repair then we exit, leaving
+ * the metadata structure unfixed and the sick flag set.Quoted 8 lines
+ *
+ * 5. Now we know that A is corrupt and the user wants to repair, so run the
+ * repairer. If the repairer returns an error code, we exit with that error
+ * code, having made no further changes to the incore sick state.
+ *
+ * 6. If repair rebuilds A correctly and the subsequent re-scrub of A is
+ * clean, usesick_mask_updateto clear the incore sick flags. This should
+ * have the effect that A is no longer marked sick.
Quoted 2 lines
.... so it really does hold "current state" and not an "update" operation :)
Yes. I mean... xfs_scrub.sick_mask holds the current known state (as worked out by the scrub code) which we then use to update the health record. But I think we're arguing the same side of the coin now, more or less.
Quoted 38 lines
Quoted 7 lines
+ * 7. If repair rebuilds A incorrectly, the re-scrub will find it corrupt and
+ * usesick_mask_updateto set the incore sick flags. This should have no
+ * externally visible effect since we already set them in step (4).
+ *
+ * There are some complications to this story, however. For certain types of
+ * complementary metadata indices (e.g. inobt/finobt), it is easier to rebuild
+ * both structures at the same time. The following principles apply to thisQuoted 8 lines
+ * type of repair strategy:
+ *
+ * 8. Any repair function that rebuilds multiple structures should update
+ *sick_mask_visibleto reflect whatever other structures are rebuilt, and
+ * verify that all the rebuilt structures can pass a scrub check. The
+ * outcomes of 5-7 still apply, but with asick_mask_updatethat covers
+ * everything being rebuilt.
+ */Otherwise this all makes sense and the patch is pretty straight forward...
Quoted 19 lines
fs/xfs/scrub/health.c new file +19
-0+static const struct xchk_health_map type_to_health_flag[XFS_SCRUB_TYPE_NR ] = { + [XFS_SCRUB_TYPE_SB ] = {XHG_AG ,XFS_SICK_AG_SB }, + [XFS_SCRUB_TYPE_AGF ] = {XHG_AG ,XFS_SICK_AG_AGF }, + [XFS_SCRUB_TYPE_AGFL ] = {XHG_AG ,XFS_SICK_AG_AGFL }, + [XFS_SCRUB_TYPE_AGI ] = {XHG_AG ,XFS_SICK_AG_AGI }, + [XFS_SCRUB_TYPE_BNOBT ] = {XHG_AG ,XFS_SICK_AG_BNOBT }, + [XFS_SCRUB_TYPE_CNTBT ] = {XHG_AG ,XFS_SICK_AG_CNTBT }, + [XFS_SCRUB_TYPE_INOBT ] = {XHG_AG ,XFS_SICK_AG_INOBT }, + [XFS_SCRUB_TYPE_FINOBT ] = {XHG_AG ,XFS_SICK_AG_FINOBT }, + [XFS_SCRUB_TYPE_RMAPBT ] = {XHG_AG ,XFS_SICK_AG_RMAPBT }, + [XFS_SCRUB_TYPE_REFCNTBT ] = {XHG_AG ,XFS_SICK_AG_REFCNTBT }, + [XFS_SCRUB_TYPE_INODE ] = {XHG_INO ,XFS_SICK_INO_CORE }, + [XFS_SCRUB_TYPE_BMBTD ] = {XHG_INO ,XFS_SICK_INO_BMBTD }, + [XFS_SCRUB_TYPE_BMBTA ] = {XHG_INO ,XFS_SICK_INO_BMBTA }, + [XFS_SCRUB_TYPE_BMBTC ] = {XHG_INO ,XFS_SICK_INO_BMBTC }, + [XFS_SCRUB_TYPE_DIR ] = {XHG_INO ,XFS_SICK_INO_DIR }, + [XFS_SCRUB_TYPE_XATTR ] = {XHG_INO ,XFS_SICK_INO_XATTR }, + [XFS_SCRUB_TYPE_SYMLINK ] = {XHG_INO ,XFS_SICK_INO_SYMLINK }, + [XFS_SCRUB_TYPE_PARENT ] = {XHG_INO ,XFS_SICK_INO_PARENT },
Quoted 8 lines
fs/xfs/scrub/health.c line 112
Quoted 6 lines
fs/xfs/scrub/health.c new file +6
-0+ [XFS_SCRUB_TYPE_RTBITMAP] = { XHG_RT, XFS_SICK_RT_BITMAP }, + [XFS_SCRUB_TYPE_RTSUM] = { XHG_RT, XFS_SICK_RT_SUMMARY }, + [XFS_SCRUB_TYPE_UQUOTA] = { XHG_FS, XFS_SICK_FS_UQUOTA }, + [XFS_SCRUB_TYPE_GQUOTA] = { XHG_FS, XFS_SICK_FS_GQUOTA }, + [XFS_SCRUB_TYPE_PQUOTA] = { XHG_FS, XFS_SICK_FS_PQUOTA }, +};/me wonders if the primary superblock is
XHG_FSorXHG_AG....
It's per-AG because we can scrub each AG's superblock individually, and therefore I designed the health status tracking to track superblocks individually too.
There's also an assumption that we're evaluating how well the filesystem metadata fits in the world as seen by the primary superblock, or else we wouldn't have mounted successfully in the first place.
--D
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v2 4/5 xfs: scrub/repair should update filesystem metadata health
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we have the ability to track sick metadata in-core, make scrub and repair update those health assessments after doing work.
---
v2: rename sick_mask_update to sick_mask.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/health.c | 176 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/health.h | 12 +++ fs/xfs/scrub/scrub.c | 4 + fs/xfs/scrub/scrub.h | 7 ++ 5 files changed, 200 insertions(+) create mode 100644 fs/xfs/scrub/health.c create mode 100644 fs/xfs/scrub/health.h
fs/xfs/Makefile +1 -0
@@ -150,6 +150,7 @@ xfs-y += $(addprefix scrub/, \ common.o \ dabtree.o \ dir.o \ + health.o \ ialloc.o \ inode.o \ parent.o \
fs/xfs/scrub/health.c new file +176 -0
176 lines not on this page · raw message
fs/xfs/scrub/health.h new file +12 -0
@@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* +* Copyright (C) 2019 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_HEALTH_H__ +#define __XFS_SCRUB_HEALTH_H__ + +unsigned int xchk_health_mask_for_scrub_type (__u32 scrub_type); +void xchk_update_health (struct xfs_scrub *sc); + +#endif /* __XFS_SCRUB_HEALTH_H__ */
fs/xfs/scrub/scrub.c +4 -0
@@ -40,6 +40,7 @@#include "scrub/trace.h" #include "scrub/btree.h" #include "scrub/repair.h" +#include "scrub/health.h" /* * Online Scrub and Repair
@@ -498,6 +499,7 @@ xfs_scrub_metadata(xchk_experimental_warning (mp); sc.ops = &meta_scrub_ops[sm->sm_type]; + sc.sick_mask =xchk_health_mask_for_scrub_type (sm->sm_type); retry_op:/* Set up for the operation. */ error = sc.ops->setup (&sc, ip);
@@ -520,6 +522,8 @@ xfs_scrub_metadata( }else if (error) goto out_teardown; +xchk_update_health (&sc); +if ((sc.sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && !(sc.flags &XREP_ALREADY_FIXED )) {bool needs_fix;
fs/xfs/scrub/scrub.h +7 -0
@@ -66,6 +66,13 @@ struct xfs_scrub {/* See the XCHK/XREP state flags below. */ unsigned int flags; +/* +* The XFS_SICK_* flags that correspond to the metadata being scrubbed +* or repaired. We will use this mask to update the in-core fs health +* status with whatever we find. +*/ +unsigned int sick_mask; +/* State tracking for single-AG operations. */ struct xchk_ag sa; };
Re: [PATCH v2 4/5] xfs: scrub/repair should update filesystem metadata health
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we have the ability to track sick metadata in-core, make scrub and repair update those health assessments after doing work.
Signed-off-by Darrick J. Wong <[email protected]>---
v2: renamesick_mask_updatetosick_mask.
---
LGTM.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 5/5 xfs: scrub should only cross-reference with healthy btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Skip cross-referencing with a btree if the health report tells us that it's known to be bad. This should reduce the dmesg spew considerably.
--- fs/xfs/scrub/common.c | 20 ++++++++++--- fs/xfs/scrub/health.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/health.h | 2 + 3 files changed, 93 insertions(+), 5 deletions(-)
fs/xfs/scrub/common.c +15 -5
@@ -38,6 +38,7 @@#include "scrub/trace.h" #include "scrub/btree.h" #include "scrub/repair.h" +#include "scrub/health.h" /* Common code for the metadata scrubbers. */
@@ -458,13 +459,18 @@ xchk_ag_btcur_init(struct xfs_mount *mp = sc->mp;xfs_agnumber_t agno = sa->agno; -if (sa->agf_bp) { +xchk_perag_get (sc->mp, sa); +if (sa->agf_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_BNO )) {/* Set up a bnobt cursor for cross-referencing. */ sa->bno_cur =xfs_allocbt_init_cursor (mp, sc->tp, sa->agf_bp, agno,XFS_BTNUM_BNO );if (!sa->bno_cur) goto err; + } +if (sa->agf_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_CNT )) {/* Set up a cntbt cursor for cross-referencing. */ sa->cnt_cur =xfs_allocbt_init_cursor (mp, sc->tp, sa->agf_bp, agno,XFS_BTNUM_CNT );
@@ -473,7 +479,8 @@ xchk_ag_btcur_init( }/* Set up a inobt cursor for cross-referencing. */ -if (sa->agi_bp) { +if (sa->agi_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_INO )) { sa->ino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, agno,XFS_BTNUM_INO );if (!sa->ino_cur)
@@ -481,7 +488,8 @@ xchk_ag_btcur_init( }/* Set up a finobt cursor for cross-referencing. */ -if (sa->agi_bp &&xfs_sb_version_hasfinobt (&mp->m_sb)) { +if (sa->agi_bp &&xfs_sb_version_hasfinobt (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_FINO )) { sa->fino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, agno,XFS_BTNUM_FINO );if (!sa->fino_cur)
@@ -489,7 +497,8 @@ xchk_ag_btcur_init( }/* Set up a rmapbt cursor for cross-referencing. */ -if (sa->agf_bp &&xfs_sb_version_hasrmapbt (&mp->m_sb)) { +if (sa->agf_bp &&xfs_sb_version_hasrmapbt (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_RMAP )) { sa->rmap_cur =xfs_rmapbt_init_cursor (mp, sc->tp, sa->agf_bp, agno);if (!sa->rmap_cur)
@@ -497,7 +506,8 @@ xchk_ag_btcur_init( }/* Set up a refcountbt cursor for cross-referencing. */ -if (sa->agf_bp &&xfs_sb_version_hasreflink (&mp->m_sb)) { +if (sa->agf_bp &&xfs_sb_version_hasreflink (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_REFC )) { sa->refc_cur =xfs_refcountbt_init_cursor (mp, sc->tp, sa->agf_bp, agno);if (!sa->refc_cur)
fs/xfs/scrub/health.c +76 -0
79 lines not on this page · raw message
fs/xfs/scrub/health.h +2 -0
@@ -8,5 +8,7 @@unsigned int xchk_health_mask_for_scrub_type (__u32 scrub_type);void xchk_update_health (struct xfs_scrub *sc); +bool xchk_ag_btree_healthy_enough (struct xfs_scrub *sc,struct xfs_perag *pag, +xfs_btnum_t btnum);#endif /* __XFS_SCRUB_HEALTH_H__ */
Re: [PATCH 5/5] xfs: scrub should only cross-reference with healthy btrees
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Skip cross-referencing with a btree if the health report tells us that it's known to be bad. This should reduce the dmesg spew considerably.
Signed-off-by Darrick J. Wong <[email protected]>
....
Quoted 71 lines
fs/xfs/scrub/health.c +65
-0@@ -174,3 +174,79 @@ xchk_update_health(break ; } } + +/* Is the given per-AG btree healthy enough for scanning? */ +bool +xchk_ag_btree_healthy_enough ( +struct xfs_scrub *sc, +struct xfs_perag *pag, +xfs_btnum_t btnum) +{ +unsigned int mask =0 ; + +/* +* We always want the cursor if it's the same type as whatever we're +* scrubbing, even if we already know the structure is corrupt. +*/ +switch (sc->sm->sm_type) { +case XFS_SCRUB_TYPE_BNOBT : +if (btnum ==XFS_BTNUM_BNO ) +return true; +break ; +case XFS_SCRUB_TYPE_CNTBT : +if (btnum ==XFS_BTNUM_CNT ) +return true; +break ; +case XFS_SCRUB_TYPE_INOBT : +if (btnum ==XFS_BTNUM_INO ) +return true; +break ; +case XFS_SCRUB_TYPE_FINOBT : +if (btnum ==XFS_BTNUM_FINO ) +return true; +break ; +case XFS_SCRUB_TYPE_RMAPBT : +if (btnum ==XFS_BTNUM_RMAP ) +return true; +break ; +case XFS_SCRUB_TYPE_REFCNTBT : +if (btnum ==XFS_BTNUM_REFC ) +return true; +break ; + } + +/* +* Otherwise, we're only interested in the btree for cross-referencing. +* If we know the btree is bad then don't bother, just set XFAIL. +*/ +switch (btnum) { +case XFS_BTNUM_BNO : + mask =XFS_SICK_AG_BNOBT ; +break ; +case XFS_BTNUM_CNT : + mask =XFS_SICK_AG_CNTBT ; +break ; +case XFS_BTNUM_INO : + mask =XFS_SICK_AG_INOBT ; +break ; +case XFS_BTNUM_FINO : + mask =XFS_SICK_AG_FINOBT ; +break ; +case XFS_BTNUM_RMAP : + mask =XFS_SICK_AG_RMAPBT ; +break ; +case XFS_BTNUM_REFC : + mask =XFS_SICK_AG_REFCNTBT ; +break ; +default :
fs/xfs/scrub/health.c xchk_update_health( · line 251
Quoted 10 lines
fs/xfs/scrub/health.c +10
-0+ASSERT (0 ); +return true; + } + +if (xfs_ag_has_sickness (pag, mask)) { + sc->sm->sm_flags |=XFS_SCRUB_OFLAG_XFAIL ; +return false; + } + +return true;
THis could be done with a single switch statement:
switch (btnum) {
case XFS_BTNUM_BNO:
if (sc->sm->sm_type == XFS_SCRUB_TYPE_BNOBT)
return true;
mask = XFS_SICK_AG_BNOBT;
break;
case XFS_BTNUM_CNT:
if (sc->sm->sm_type == XFS_SCRUB_TYPE_CNTBT)
return true;
mask = XFS_SICK_AG_CNTBT;
break;.....
Otherwise it is fine.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v2 5/5 xfs: scrub should only cross-reference with healthy btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Skip cross-referencing with a btree if the health report tells us that it's known to be bad. This should reduce the dmesg spew considerably.
---
v2: condense the switch cases per dchinner suggestion
--- fs/xfs/scrub/common.c | 20 ++++++++++++---- fs/xfs/scrub/health.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/health.h | 2 ++ 3 files changed, 77 insertions(+), 5 deletions(-)
fs/xfs/scrub/common.c +15 -5
@@ -38,6 +38,7 @@#include "scrub/trace.h" #include "scrub/btree.h" #include "scrub/repair.h" +#include "scrub/health.h" /* Common code for the metadata scrubbers. */
@@ -458,13 +459,18 @@ xchk_ag_btcur_init(struct xfs_mount *mp = sc->mp;xfs_agnumber_t agno = sa->agno; -if (sa->agf_bp) { +xchk_perag_get (sc->mp, sa); +if (sa->agf_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_BNO )) {/* Set up a bnobt cursor for cross-referencing. */ sa->bno_cur =xfs_allocbt_init_cursor (mp, sc->tp, sa->agf_bp, agno,XFS_BTNUM_BNO );if (!sa->bno_cur) goto err; + } +if (sa->agf_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_CNT )) {/* Set up a cntbt cursor for cross-referencing. */ sa->cnt_cur =xfs_allocbt_init_cursor (mp, sc->tp, sa->agf_bp, agno,XFS_BTNUM_CNT );
@@ -473,7 +479,8 @@ xchk_ag_btcur_init( }/* Set up a inobt cursor for cross-referencing. */ -if (sa->agi_bp) { +if (sa->agi_bp && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_INO )) { sa->ino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, agno,XFS_BTNUM_INO );if (!sa->ino_cur)
@@ -481,7 +488,8 @@ xchk_ag_btcur_init( }/* Set up a finobt cursor for cross-referencing. */ -if (sa->agi_bp &&xfs_sb_version_hasfinobt (&mp->m_sb)) { +if (sa->agi_bp &&xfs_sb_version_hasfinobt (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_FINO )) { sa->fino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, agno,XFS_BTNUM_FINO );if (!sa->fino_cur)
@@ -489,7 +497,8 @@ xchk_ag_btcur_init( }/* Set up a rmapbt cursor for cross-referencing. */ -if (sa->agf_bp &&xfs_sb_version_hasrmapbt (&mp->m_sb)) { +if (sa->agf_bp &&xfs_sb_version_hasrmapbt (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_RMAP )) { sa->rmap_cur =xfs_rmapbt_init_cursor (mp, sc->tp, sa->agf_bp, agno);if (!sa->rmap_cur)
@@ -497,7 +506,8 @@ xchk_ag_btcur_init( }/* Set up a refcountbt cursor for cross-referencing. */ -if (sa->agf_bp &&xfs_sb_version_hasreflink (&mp->m_sb)) { +if (sa->agf_bp &&xfs_sb_version_hasreflink (&mp->m_sb) && +xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_REFC )) { sa->refc_cur =xfs_refcountbt_init_cursor (mp, sc->tp, sa->agf_bp, agno);if (!sa->refc_cur)
fs/xfs/scrub/health.c +60 -0
63 lines not on this page · raw message
fs/xfs/scrub/health.h +2 -0
@@ -8,5 +8,7 @@unsigned int xchk_health_mask_for_scrub_type (__u32 scrub_type);void xchk_update_health (struct xfs_scrub *sc); +bool xchk_ag_btree_healthy_enough (struct xfs_scrub *sc,struct xfs_perag *pag, +xfs_btnum_t btnum);#endif /* __XFS_SCRUB_HEALTH_H__ */
Re: [PATCH v2 5/5] xfs: scrub should only cross-reference with healthy btrees
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Skip cross-referencing with a btree if the health report tells us that it's known to be bad. This should reduce the dmesg spew considerably.
Signed-off-by Darrick J. Wong <[email protected]>---
v2: condense the switch cases per dchinner suggestion
Much nicer :)
Signature · 2 lines
Dave Chinner [email protected]