diff options
author | Darrick J. Wong <djwong@kernel.org> | 2021-09-01 11:25:37 -0700 |
---|---|---|
committer | Darrick J. Wong <djwong@kernel.org> | 2021-12-15 17:29:28 -0800 |
commit | a57c1081b033ebde45b4535a961a16a748115418 (patch) | |
tree | 2ac30524a1d4d4d810525fcc2e629f25c6807a6d | |
parent | 83ab5f54660561bbd5bac55eb5e8241dc00b99f3 (diff) |
xfs: teach repair to fix file nlinksscrub-nlinks_2021-12-15
Fix the nlinks now too.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
-rw-r--r-- | fs/xfs/Makefile | 1 | ||||
-rw-r--r-- | fs/xfs/scrub/nlinks.c | 7 | ||||
-rw-r--r-- | fs/xfs/scrub/nlinks.h | 3 | ||||
-rw-r--r-- | fs/xfs/scrub/nlinks_repair.c | 201 | ||||
-rw-r--r-- | fs/xfs/scrub/repair.h | 4 | ||||
-rw-r--r-- | fs/xfs/scrub/scrub.c | 2 | ||||
-rw-r--r-- | fs/xfs/scrub/trace.h | 3 |
7 files changed, 220 insertions, 1 deletions
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile index d8167db4bac4..be2ed265c367 100644 --- a/fs/xfs/Makefile +++ b/fs/xfs/Makefile @@ -189,6 +189,7 @@ xfs-y += $(addprefix scrub/, \ fscounters_repair.o \ ialloc_repair.o \ inode_repair.o \ + nlinks_repair.o \ orphanage.o \ parent_repair.o \ refcount_repair.o \ diff --git a/fs/xfs/scrub/nlinks.c b/fs/xfs/scrub/nlinks.c index aa5a3237a34f..356b2fcf6768 100644 --- a/fs/xfs/scrub/nlinks.c +++ b/fs/xfs/scrub/nlinks.c @@ -53,6 +53,13 @@ int xchk_setup_nlinks( struct xfs_scrub *sc) { + int error; + + if (xchk_could_repair(sc)) { + error = xrep_setup_nlinks(sc); + if (error) + return error; + } sc->buf = kmem_zalloc(sizeof(struct xchk_nlink_ctrs), KM_NOFS | KM_MAYFAIL); if (!sc->buf) diff --git a/fs/xfs/scrub/nlinks.h b/fs/xfs/scrub/nlinks.h index 0ece2ab5dd38..5552c4180117 100644 --- a/fs/xfs/scrub/nlinks.h +++ b/fs/xfs/scrub/nlinks.h @@ -44,6 +44,9 @@ struct xchk_nlink { /* This data item was seen by the check-time compare function. */ #define XCHK_NLINK_COMPARE_SCANNED (1U << 0) +/* Item was modified by the repair function. */ +#define XREP_NLINK_DIRTY (1U << 1) + /* Compute total link count, using large enough variables to detect overflow. */ static inline uint64_t xchk_nlink_total(const struct xchk_nlink *live) diff --git a/fs/xfs/scrub/nlinks_repair.c b/fs/xfs/scrub/nlinks_repair.c new file mode 100644 index 000000000000..7d561aa28cfb --- /dev/null +++ b/fs/xfs/scrub/nlinks_repair.c @@ -0,0 +1,201 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2021 Oracle. All Rights Reserved. + * Author: Darrick J. Wong <djwong@kernel.org> + */ +#include "xfs.h" +#include "xfs_fs.h" +#include "xfs_shared.h" +#include "xfs_format.h" +#include "xfs_trans_resv.h" +#include "xfs_mount.h" +#include "xfs_log_format.h" +#include "xfs_trans.h" +#include "xfs_inode.h" +#include "xfs_icache.h" +#include "xfs_bmap_util.h" +#include "xfs_iwalk.h" +#include "xfs_ialloc.h" +#include "xfs_sb.h" +#include "scrub/scrub.h" +#include "scrub/common.h" +#include "scrub/repair.h" +#include "scrub/xfarray.h" +#include "scrub/iscan.h" +#include "scrub/nlinks.h" +#include "scrub/trace.h" +#include "scrub/orphanage.h" + +/* + * Live Inode Link Count Repair + * ============================ + * + * Use the live inode link count information that we collected to replace the + * nlink values of the incore inodes. A scrub->repair cycle should have left + * the live data and hooks active, so this is safe so long as we make sure the + * inode is locked. + */ + +/* Set up to repair inode link counts. */ +int +xrep_setup_nlinks( + struct xfs_scrub *sc) +{ + return xrep_orphanage_try_create(sc); +} + +/* + * Correct the link count of the given inode. Because we have to grab locks + * and resources in a certain order, it's possible that this will be a no-op. + */ +STATIC int +xrep_nlinks_repair_inode( + struct xchk_nlink_ctrs *xnc) +{ + struct xchk_nlink obs; + struct xfs_scrub *sc = xnc->sc; + struct xfs_mount *mp = sc->mp; + struct xfs_inode *ip = sc->ip; + uint64_t total_links; + unsigned int actual_nlink; + int error; + + xfs_ilock(ip, XFS_IOLOCK_EXCL); + + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &sc->tp); + if (error) + goto out_iolock; + + xfs_ilock(ip, XFS_ILOCK_EXCL); + xfs_trans_ijoin(sc->tp, ip, 0); + + mutex_lock(&xnc->lock); + + if (xchk_iscan_aborted(&xnc->collect_iscan)) { + error = -ECANCELED; + goto out_scanlock; + } + + error = xfarray_load_sparse(xnc->nlinks, ip->i_ino, &obs); + if (error) + goto out_scanlock; + total_links = xchk_nlink_total(&obs); + actual_nlink = VFS_I(ip)->i_nlink; + + /* Cannot set more than the maxiumum possible link count. */ + if (total_links > U32_MAX) { + trace_xrep_nlinks_unfixable_inode(mp, ip, &obs); + goto out_scanlock; + } + + /* + * Linked directories should have at least one "child" (the dot entry) + * pointing up to them. + */ + if (S_ISDIR(VFS_I(ip)->i_mode) && actual_nlink > 0 && obs.child == 0) { + trace_xrep_nlinks_unfixable_inode(mp, ip, &obs); + goto out_scanlock; + } + + /* Non-directories cannot have directories pointing up to them. */ + if (!S_ISDIR(VFS_I(ip)->i_mode) && obs.child != 0) { + trace_xrep_nlinks_unfixable_inode(mp, ip, &obs); + goto out_scanlock; + } + + /* + * We did not find any links to this inode. If the inode agrees, we + * have nothing further to do. If not, the inode has a nonzero link + * count and we don't have anywhere to graft the child onto. Dropping + * a live inode's link count to zero can cause unexpected shutdowns in + * inactivation, so leave it alone. + */ + if (total_links == 0) { + if (actual_nlink != 0) + trace_xrep_nlinks_unfixable_inode(mp, ip, &obs); + goto out_scanlock; + } + + /* Perfect match means we're done. */ + if (total_links == actual_nlink) + goto out_scanlock; + mutex_unlock(&xnc->lock); + + /* Commit the new link count. */ + trace_xrep_nlinks_update_inode(mp, ip, &obs); + + set_nlink(VFS_I(ip), total_links); + xfs_trans_log_inode(sc->tp, ip, XFS_ILOG_CORE); + error = xfs_trans_commit(sc->tp); + sc->tp = NULL; + if (error) + goto out_ilock; + + xfs_iunlock(ip, XFS_ILOCK_EXCL); + xfs_iunlock(ip, XFS_IOLOCK_EXCL); + return 0; + +out_scanlock: + mutex_unlock(&xnc->lock); + xchk_trans_cancel(sc); +out_ilock: + xfs_iunlock(ip, XFS_ILOCK_EXCL); +out_iolock: + xfs_iunlock(ip, XFS_IOLOCK_EXCL); + return error; +} + +/* Commit the new inode link counters. */ +int +xrep_nlinks( + struct xfs_scrub *sc) +{ + struct xchk_nlink_ctrs *xnc = sc->buf; + int error; + + /* + * Use the inobt to walk all allocated inodes to compare and fix the + * link counts. If we can't iget the inode, we cannot repair it. + */ + xnc->compare_iscan.iget_tries = 20; + xnc->compare_iscan.iget_retry_delay = HZ / 10; + xchk_iscan_start(&xnc->compare_iscan); + while ((error = xchk_iscan_advance(sc, &xnc->compare_iscan)) == 1) { + ASSERT(sc->ip == NULL); + + error = xchk_iscan_iget(sc, &xnc->compare_iscan, &sc->ip); + if (error == -EAGAIN || error == -ECANCELED) + continue; + if (error) + break; + + /* + * Commit the scrub transaction so that we can create repair + * transactions with the correct reservations. + */ + xchk_trans_cancel(sc); + + error = xrep_nlinks_repair_inode(xnc); + xchk_iscan_mark_visited(&xnc->compare_iscan, sc->ip); + xchk_irele(sc, sc->ip); + sc->ip = NULL; + if (error) + break; + + if (xchk_should_terminate(sc, &error)) + break; + + /* + * Create a new empty transaction so that we can advance the + * iscan cursor without deadlocking if the inobt has a cycle. + * We can only push the inactivation workqueues with an empty + * transaction. + */ + error = xchk_trans_alloc_empty(sc); + if (error) + break; + } + xchk_iscan_finish(&xnc->compare_iscan); + + return error; +} diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h index 74216b2ee7c7..242a12493d2a 100644 --- a/fs/xfs/scrub/repair.h +++ b/fs/xfs/scrub/repair.h @@ -82,6 +82,7 @@ int xrep_setup_directory(struct xfs_scrub *sc); int xrep_setup_parent(struct xfs_scrub *sc); int xrep_setup_rtbitmap(struct xfs_scrub *sc, unsigned int *resblks); int xrep_setup_rtrmapbt(struct xfs_scrub *sc); +int xrep_setup_nlinks(struct xfs_scrub *sc); int xrep_xattr_reset_fork(struct xfs_scrub *sc, struct xfs_inode *ip); @@ -146,6 +147,7 @@ int xrep_fscounters(struct xfs_scrub *sc); int xrep_xattr(struct xfs_scrub *sc); int xrep_directory(struct xfs_scrub *sc); int xrep_parent(struct xfs_scrub *sc); +int xrep_nlinks(struct xfs_scrub *sc); #ifdef CONFIG_XFS_QUOTA int xrep_quota(struct xfs_scrub *sc); @@ -277,6 +279,7 @@ xrep_setup_nothing( #define xrep_setup_directory xrep_setup_nothing #define xrep_setup_parent xrep_setup_nothing #define xrep_setup_rtrmapbt xrep_setup_nothing +#define xrep_setup_nlinks xrep_setup_nothing static inline int xrep_setup_rtsummary(struct xfs_scrub *sc, unsigned int *whatever) @@ -311,6 +314,7 @@ xrep_setup_rtsummary(struct xfs_scrub *sc, unsigned int *whatever) #define xrep_rtbitmap xrep_notsupported #define xrep_rtrmapbt xrep_notsupported #define xrep_rtrefcountbt xrep_notsupported +#define xrep_nlinks xrep_notsupported #endif /* CONFIG_XFS_ONLINE_REPAIR */ diff --git a/fs/xfs/scrub/scrub.c b/fs/xfs/scrub/scrub.c index efd44b31997d..104e27f0bc1c 100644 --- a/fs/xfs/scrub/scrub.c +++ b/fs/xfs/scrub/scrub.c @@ -397,7 +397,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_nlinks, .scrub = xchk_nlinks, - .repair = xrep_notsupported, + .repair = xrep_nlinks, }, }; diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h index 0ee0c7fd7400..e8f972dc5d85 100644 --- a/fs/xfs/scrub/trace.h +++ b/fs/xfs/scrub/trace.h @@ -2203,6 +2203,9 @@ TRACE_EVENT(xrep_rtrefc_found, __entry->refcount) ) +DEFINE_SCRUB_NLINK_DIFF_EVENT(xrep_nlinks_update_inode); +DEFINE_SCRUB_NLINK_DIFF_EVENT(xrep_nlinks_unfixable_inode); + #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ #endif /* _TRACE_XFS_SCRUB_TRACE_H */ |