diff options
author | Darrick J. Wong <djwong@kernel.org> | 2021-09-01 10:45:58 -0700 |
---|---|---|
committer | Darrick J. Wong <djwong@kernel.org> | 2021-10-22 16:40:38 -0700 |
commit | f60230e90f3026cecdc3b0d78feb2de8b527c6de (patch) | |
tree | aadfbc26294b6e34a30630f144f55c78369f9852 | |
parent | 83f0a58ef5497701b25ad52b78f68e38b28fa413 (diff) |
xfs: repair dquots based on live quotacheck resultsrepair-quota_2021-10-22
Use the shadow quota counters that live quotacheck creates to reset the
incore dquot counters.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
-rw-r--r-- | fs/xfs/Makefile | 1 | ||||
-rw-r--r-- | fs/xfs/scrub/quotacheck.c | 2 | ||||
-rw-r--r-- | fs/xfs/scrub/quotacheck.h | 6 | ||||
-rw-r--r-- | fs/xfs/scrub/quotacheck_repair.c | 262 | ||||
-rw-r--r-- | fs/xfs/scrub/repair.h | 3 | ||||
-rw-r--r-- | fs/xfs/scrub/scrub.c | 2 | ||||
-rw-r--r-- | fs/xfs/scrub/trace.h | 1 |
7 files changed, 275 insertions, 2 deletions
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile index 958a3244c808..4f55e9c94a1a 100644 --- a/fs/xfs/Makefile +++ b/fs/xfs/Makefile @@ -183,6 +183,7 @@ xfs-y += $(addprefix scrub/, \ xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \ quota_repair.o \ + quotacheck_repair.o \ ) endif diff --git a/fs/xfs/scrub/quotacheck.c b/fs/xfs/scrub/quotacheck.c index f52cd7e1bb36..3c19bc157a03 100644 --- a/fs/xfs/scrub/quotacheck.c +++ b/fs/xfs/scrub/quotacheck.c @@ -517,7 +517,7 @@ xqcheck_collect_counts( } /* Update an incore dquot state flags. */ -static int +int xqcheck_update_incore_state( struct xqcheck *xqc, struct xfarray *counts, diff --git a/fs/xfs/scrub/quotacheck.h b/fs/xfs/scrub/quotacheck.h index c2742791a7b3..bd998beb31c0 100644 --- a/fs/xfs/scrub/quotacheck.h +++ b/fs/xfs/scrub/quotacheck.h @@ -24,6 +24,9 @@ struct xqcheck_dquot { /* Already checked this dquot */ #define XQCHECK_DQUOT_COMPARE_SCANNED (1U << 0) +/* Already repaired this dquot */ +#define XQCHECK_DQUOT_REPAIR_SCANNED (1U << 1) + /* Live quotacheck control structure. */ struct xqcheck { struct xfs_scrub *sc; @@ -68,4 +71,7 @@ xqcheck_counters_for( int xqcheck_get_shadow_dquot(struct xfarray *counts, xfs_dqid_t id, struct xqcheck_dquot *xcdq); +int xqcheck_update_incore_state(struct xqcheck *xqc, struct xfarray *counts, + xfs_dqid_t id, struct xqcheck_dquot *xcdq); + #endif /* __XFS_SCRUB_QUOTACHECK_H__ */ diff --git a/fs/xfs/scrub/quotacheck_repair.c b/fs/xfs/scrub/quotacheck_repair.c new file mode 100644 index 000000000000..dace453f89ea --- /dev/null +++ b/fs/xfs/scrub/quotacheck_repair.c @@ -0,0 +1,262 @@ +// 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_quota.h" +#include "xfs_qm.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/quotacheck.h" +#include "scrub/trace.h" + +/* + * Live Quotacheck Repair + * ====================== + * + * Use the live quota counter information that we collected to replace the + * counter values in the incore dquots. A scrub->repair cycle should have left + * the live data and hooks active, so this is safe so long as we make sure the + * dquot is locked. + */ + +/* Commit new counters to a dquot. */ +static int +xqcheck_commit_dquot( + struct xfs_dquot *dqp, + xfs_dqtype_t dqtype, + void *priv) +{ + struct xqcheck_dquot xcdq; + struct xqcheck *xqc = priv; + struct xfarray *counts = xqcheck_counters_for(xqc, dqtype); + int64_t delta; + bool dirty = false; + int error = 0; + + /* Unlock the dquot just long enough to allocate a transaction. */ + xfs_dqunlock(dqp); + error = xchk_trans_alloc(xqc->sc, 0); + xfs_dqlock(dqp); + if (error) + return error; + + xfs_trans_dqjoin(xqc->sc->tp, dqp); + + if (xchk_iscan_aborted(&xqc->iscan)) { + error = -ECANCELED; + goto out_cancel; + } + + mutex_lock(&xqc->lock); + error = xqcheck_get_shadow_dquot(counts, dqp->q_id, &xcdq); + if (error) + goto out_unlock; + + /* Adjust counters as needed. */ + delta = (int64_t)xcdq.icount - dqp->q_ino.count; + if (delta) { + dqp->q_ino.reserved += delta; + dqp->q_ino.count += delta; + dirty = true; + } + + delta = (int64_t)xcdq.bcount - dqp->q_blk.count; + if (delta) { + dqp->q_blk.reserved += delta; + dqp->q_blk.count += delta; + dirty = true; + } + + delta = (int64_t)xcdq.rtbcount - dqp->q_rtb.count; + if (delta) { + dqp->q_rtb.reserved += delta; + dqp->q_rtb.count += delta; + dirty = true; + } + + xcdq.flags |= XQCHECK_DQUOT_REPAIR_SCANNED; + error = xqcheck_update_incore_state(xqc, counts, dqp->q_id, &xcdq); + mutex_unlock(&xqc->lock); + if (error || !dirty) + goto out_cancel; + + trace_xrep_quotacheck_dquot(xqc->sc->mp, dqp->q_type, dqp->q_id); + + /* Commit the dirty dquot to disk. */ + dqp->q_flags |= XFS_DQFLAG_DIRTY; + if (dqp->q_id) + xfs_qm_adjust_dqtimers(dqp); + xfs_trans_log_dquot(xqc->sc->tp, dqp); + + /* + * Transaction commit unlocks the dquot, so we must re-lock it so that + * the caller can put the reference (which apparently requires a locked + * dquot). + */ + error = xrep_trans_commit(xqc->sc); + xfs_dqlock(dqp); + return error; + +out_unlock: + mutex_unlock(&xqc->lock); +out_cancel: + xchk_trans_cancel(xqc->sc); + + /* Re-lock the dquot so the caller can put the reference. */ + xfs_dqlock(dqp); + return error; +} + +/* Commit new quota counters for a particular quota type. */ +STATIC int +xqcheck_commit_dqtype( + struct xqcheck *xqc, + unsigned int dqtype) +{ + struct xqcheck_dquot xcdq; + struct xfs_scrub *sc = xqc->sc; + struct xfs_mount *mp = sc->mp; + struct xfarray *counts = xqcheck_counters_for(xqc, dqtype); + struct xfs_dquot *dqp; + uint64_t nr = 0; + int error; + + /* + * Update the counters of every dquot that the quota file knows about. + */ + error = xfs_qm_dqiterate(mp, dqtype, xqcheck_commit_dquot, xqc); + if (error) + return error; + + /* + * Make a second pass to deal with the dquots that we know about but + * the quota file previously did not know about. + */ + mutex_lock(&xqc->lock); + while (!(error = xfarray_load_next(counts, &nr, &xcdq))) { + xfs_dqid_t id = nr - 1; + + if (xcdq.flags & XQCHECK_DQUOT_REPAIR_SCANNED) + continue; + + mutex_unlock(&xqc->lock); + + /* + * Grab the dquot, allowing for dquot block allocation in a + * separate transaction. We committed the scrub transaction + * in a previous step, so we will not be creating nested + * transactions here. + */ + error = xfs_qm_dqget(mp, id, dqtype, true, &dqp); + if (error) + return error; + + error = xqcheck_commit_dquot(dqp, dqtype, xqc); + xfs_qm_dqput(dqp); + if (error) + return error; + + mutex_lock(&xqc->lock); + } + mutex_unlock(&xqc->lock); + + /* ENODATA means we hit the end of the array. */ + if (error == -ENODATA) + return 0; + + return error; +} + +/* Figure out quota CHKD flags for the running quota types. */ +static inline unsigned int +xqcheck_chkd_flags( + struct xfs_mount *mp) +{ + unsigned int ret = 0; + + if (XFS_IS_UQUOTA_ON(mp)) + ret |= XFS_UQUOTA_CHKD; + if (XFS_IS_GQUOTA_ON(mp)) + ret |= XFS_GQUOTA_CHKD; + if (XFS_IS_PQUOTA_ON(mp)) + ret |= XFS_PQUOTA_CHKD; + return ret; +} + +/* Commit the new dquot counters. */ +int +xrep_quotacheck( + struct xfs_scrub *sc) +{ + struct xqcheck *xqc = sc->buf; + unsigned int qflags = xqcheck_chkd_flags(sc->mp); + int error; + + /* + * Clear the CHKD flag for this quota type and commit the scrub + * transaction so that we can allocate new quota block mappings if we + * have to. If we crash after this point, the sb still has the CHKD + * flags cleared, so mount quotacheck will fix all of this up. + */ + mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock); + spin_lock(&sc->mp->m_sb_lock); + sc->mp->m_qflags &= ~qflags; + sc->mp->m_sb.sb_qflags &= ~qflags; + spin_unlock(&sc->mp->m_sb_lock); + xfs_log_sb(sc->tp); + mutex_unlock(&sc->mp->m_quotainfo->qi_quotaofflock); + + error = xrep_trans_commit(sc); + if (error) + return error; + + /* Commit the new counters to the dquots. */ + if (xqc->ucounts) { + error = xqcheck_commit_dqtype(xqc, XFS_DQTYPE_USER); + if (error) + return error; + } + if (xqc->gcounts) { + error = xqcheck_commit_dqtype(xqc, XFS_DQTYPE_GROUP); + if (error) + return error; + } + if (xqc->pcounts) { + error = xqcheck_commit_dqtype(xqc, XFS_DQTYPE_PROJ); + if (error) + return error; + } + + /* Reinstate CHKD flags. */ + error = xchk_trans_alloc(sc, 0); + if (error) + return error; + + mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock); + spin_lock(&sc->mp->m_sb_lock); + sc->mp->m_qflags |= qflags; + sc->mp->m_sb.sb_qflags |= qflags; + spin_unlock(&sc->mp->m_sb_lock); + xfs_log_sb(sc->tp); + mutex_unlock(&sc->mp->m_quotainfo->qi_quotaofflock); + + return 0; +} diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h index 3f8a3da94d9d..3e48c41b1d8d 100644 --- a/fs/xfs/scrub/repair.h +++ b/fs/xfs/scrub/repair.h @@ -98,8 +98,10 @@ int xrep_symlink(struct xfs_scrub *sc); #ifdef CONFIG_XFS_QUOTA int xrep_quota(struct xfs_scrub *sc); +int xrep_quotacheck(struct xfs_scrub *sc); #else # define xrep_quota xrep_notsupported +# define xrep_quotacheck xrep_notsupported #endif /* CONFIG_XFS_QUOTA */ struct xrep_newbt_resv { @@ -204,6 +206,7 @@ xrep_reset_perag_resv( #define xrep_bmap_attr xrep_notsupported #define xrep_symlink xrep_notsupported #define xrep_quota xrep_notsupported +#define xrep_quotacheck xrep_notsupported #endif /* CONFIG_XFS_ONLINE_REPAIR */ diff --git a/fs/xfs/scrub/scrub.c b/fs/xfs/scrub/scrub.c index 928f25798a02..6feed5fc2b33 100644 --- a/fs/xfs/scrub/scrub.c +++ b/fs/xfs/scrub/scrub.c @@ -352,7 +352,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_quotacheck, .scrub = xchk_quotacheck, - .repair = xrep_notsupported, + .repair = xrep_quotacheck, }, }; diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h index 6c594e226495..f03dd968844f 100644 --- a/fs/xfs/scrub/trace.h +++ b/fs/xfs/scrub/trace.h @@ -1446,6 +1446,7 @@ DEFINE_EVENT(xrep_dquot_class, name, \ TP_ARGS(mp, type, id)) DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item); DEFINE_XREP_DQUOT_EVENT(xrep_disk_dquot); +DEFINE_XREP_DQUOT_EVENT(xrep_quotacheck_dquot); #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ |