OSCL-LXR linux-6.0.1/​fs/​xfs/​scrub/​repair.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (C) 2018 Oracle.  All Rights Reserved.
  * Author: Darrick J. Wong <darrick.wong@oracle.com>
  */
 #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_btree.h"
 #include "xfs_log_format.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_inode.h"
 #include "xfs_alloc.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_rmap.h"
 #include "xfs_rmap_btree.h"
 #include "xfs_refcount_btree.h"
 #include "xfs_extent_busy.h"
 #include "xfs_ag.h"
 #include "xfs_ag_resv.h"
 #include "xfs_quota.h"
 #include "xfs_qm.h"
 #include "scrub/scrub.h"
 #include "scrub/common.h"
 #include "scrub/trace.h"
 #include "scrub/repair.h"
 #include "scrub/bitmap.h"
 
 /*
  * Attempt to repair some metadata, if the metadata is corrupt and userspace
  * told us to fix it.  This function returns -EAGAIN to mean "re-run scrub",
  * and will set *fixed to true if it thinks it repaired anything.
  */
 int
 xrep_attempt(
     struct xfs_scrub    *sc)
 {
     int         error = 0;
 
     trace_xrep_attempt(XFS_I(file_inode(sc->file)), sc->sm, error);
 
     xchk_ag_btcur_free(&sc->sa);
 
     /* Repair whatever's broken. */
     ASSERT(sc->ops->repair);
     error = sc->ops->repair(sc);
     trace_xrep_done(XFS_I(file_inode(sc->file)), sc->sm, error);
     switch (error) {
     case 0:
         /*
          * Repair succeeded.  Commit the fixes and perform a second
          * scrub so that we can tell userspace if we fixed the problem.
          */
         sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT;
         sc->flags |= XREP_ALREADY_FIXED;
         return -EAGAIN;
     case -EDEADLOCK:
     case -EAGAIN:
         /* Tell the caller to try again having grabbed all the locks. */
         if (!(sc->flags & XCHK_TRY_HARDER)) {
             sc->flags |= XCHK_TRY_HARDER;
             return -EAGAIN;
         }
         /*
          * We tried harder but still couldn't grab all the resources
          * we needed to fix it.  The corruption has not been fixed,
          * so report back to userspace.
          */
         return -EFSCORRUPTED;
     default:
         return error;
     }
 }
 
 /*
  * Complain about unfixable problems in the filesystem.  We don't log
  * corruptions when IFLAG_REPAIR wasn't set on the assumption that the driver
  * program is xfs_scrub, which will call back with IFLAG_REPAIR set if the
  * administrator isn't running xfs_scrub in no-repairs mode.
  *
  * Use this helper function because _ratelimited silently declares a static
  * structure to track rate limiting information.
  */
 void
 xrep_failure(
     struct xfs_mount    *mp)
 {
     xfs_alert_ratelimited(mp,
 "Corruption not fixed during online repair.  Unmount and run xfs_repair.");
 }
 
 /*
  * Repair probe -- userspace uses this to probe if we're willing to repair a
  * given mountpoint.
  */
 int
 xrep_probe(
     struct xfs_scrub    *sc)
 {
     int         error = 0;
 
     if (xchk_should_terminate(sc, &error))
         return error;
 
     return 0;
 }
 
 /*
  * Roll a transaction, keeping the AG headers locked and reinitializing
  * the btree cursors.
  */
 int
 xrep_roll_ag_trans(
     struct xfs_scrub    *sc)
 {
     int         error;
 
     /* Keep the AG header buffers locked so we can keep going. */
     if (sc->sa.agi_bp)
         xfs_trans_bhold(sc->tp, sc->sa.agi_bp);
     if (sc->sa.agf_bp)
         xfs_trans_bhold(sc->tp, sc->sa.agf_bp);
     if (sc->sa.agfl_bp)
         xfs_trans_bhold(sc->tp, sc->sa.agfl_bp);
 
     /*
      * Roll the transaction.  We still own the buffer and the buffer lock
      * regardless of whether or not the roll succeeds.  If the roll fails,
      * the buffers will be released during teardown on our way out of the
      * kernel.  If it succeeds, we join them to the new transaction and
      * move on.
      */
     error = xfs_trans_roll(&sc->tp);
     if (error)
         return error;
 
     /* Join AG headers to the new transaction. */
     if (sc->sa.agi_bp)
         xfs_trans_bjoin(sc->tp, sc->sa.agi_bp);
     if (sc->sa.agf_bp)
         xfs_trans_bjoin(sc->tp, sc->sa.agf_bp);
     if (sc->sa.agfl_bp)
         xfs_trans_bjoin(sc->tp, sc->sa.agfl_bp);
 
     return 0;
 }
 
 /*
  * Does the given AG have enough space to rebuild a btree?  Neither AG
  * reservation can be critical, and we must have enough space (factoring
  * in AG reservations) to construct a whole btree.
  */
 bool
 xrep_ag_has_space(
     struct xfs_perag    *pag,
     xfs_extlen_t        nr_blocks,
     enum xfs_ag_resv_type   type)
 {
     return  !xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) &&
         !xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA) &&
         pag->pagf_freeblks > xfs_ag_resv_needed(pag, type) + nr_blocks;
 }
 
 /*
  * Figure out how many blocks to reserve for an AG repair.  We calculate the
  * worst case estimate for the number of blocks we'd need to rebuild one of
  * any type of per-AG btree.
  */
 xfs_extlen_t
 xrep_calc_ag_resblks(
     struct xfs_scrub        *sc)
 {
     struct xfs_mount        *mp = sc->mp;
     struct xfs_scrub_metadata   *sm = sc->sm;
     struct xfs_perag        *pag;
     struct xfs_buf          *bp;
     xfs_agino_t         icount = NULLAGINO;
     xfs_extlen_t            aglen = NULLAGBLOCK;
     xfs_extlen_t            usedlen;
     xfs_extlen_t            freelen;
     xfs_extlen_t            bnobt_sz;
     xfs_extlen_t            inobt_sz;
     xfs_extlen_t            rmapbt_sz;
     xfs_extlen_t            refcbt_sz;
     int             error;
 
     if (!(sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR))
         return 0;
 
     pag = xfs_perag_get(mp, sm->sm_agno);
     if (pag->pagi_init) {
         /* Use in-core icount if possible. */
         icount = pag->pagi_count;
     } else {
         /* Try to get the actual counters from disk. */
         error = xfs_ialloc_read_agi(pag, NULL, &bp);
         if (!error) {
             icount = pag->pagi_count;
             xfs_buf_relse(bp);
         }
     }
 
     /* Now grab the block counters from the AGF. */
     error = xfs_alloc_read_agf(pag, NULL, 0, &bp);
     if (error) {
         aglen = pag->block_count;
         freelen = aglen;
         usedlen = aglen;
     } else {
         struct xfs_agf  *agf = bp->b_addr;
 
         aglen = be32_to_cpu(agf->agf_length);
         freelen = be32_to_cpu(agf->agf_freeblks);
         usedlen = aglen - freelen;
         xfs_buf_relse(bp);
     }
 
     /* If the icount is impossible, make some worst-case assumptions. */
     if (icount == NULLAGINO ||
         !xfs_verify_agino(pag, icount)) {
         icount = pag->agino_max - pag->agino_min + 1;
     }
 
     /* If the block counts are impossible, make worst-case assumptions. */
     if (aglen == NULLAGBLOCK ||
         aglen != pag->block_count ||
         freelen >= aglen) {
         aglen = pag->block_count;
         freelen = aglen;
         usedlen = aglen;
     }
     xfs_perag_put(pag);
 
     trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
             freelen, usedlen);
 
     /*
      * Figure out how many blocks we'd need worst case to rebuild
      * each type of btree.  Note that we can only rebuild the
      * bnobt/cntbt or inobt/finobt as pairs.
      */
     bnobt_sz = 2 * xfs_allocbt_calc_size(mp, freelen);
     if (xfs_has_sparseinodes(mp))
         inobt_sz = xfs_iallocbt_calc_size(mp, icount /
                 XFS_INODES_PER_HOLEMASK_BIT);
     else
         inobt_sz = xfs_iallocbt_calc_size(mp, icount /
                 XFS_INODES_PER_CHUNK);
     if (xfs_has_finobt(mp))
         inobt_sz *= 2;
     if (xfs_has_reflink(mp))
         refcbt_sz = xfs_refcountbt_calc_size(mp, usedlen);
     else
         refcbt_sz = 0;
     if (xfs_has_rmapbt(mp)) {
         /*
          * Guess how many blocks we need to rebuild the rmapbt.
          * For non-reflink filesystems we can't have more records than
          * used blocks.  However, with reflink it's possible to have
          * more than one rmap record per AG block.  We don't know how
          * many rmaps there could be in the AG, so we start off with
          * what we hope is an generous over-estimation.
          */
         if (xfs_has_reflink(mp))
             rmapbt_sz = xfs_rmapbt_calc_size(mp,
                     (unsigned long long)aglen * 2);
         else
             rmapbt_sz = xfs_rmapbt_calc_size(mp, usedlen);
     } else {
         rmapbt_sz = 0;
     }
 
     trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
             inobt_sz, rmapbt_sz, refcbt_sz);
 
     return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz));
 }
 
 /* Allocate a block in an AG. */
 int
 xrep_alloc_ag_block(
     struct xfs_scrub        *sc,
     const struct xfs_owner_info *oinfo,
     xfs_fsblock_t           *fsbno,
     enum xfs_ag_resv_type       resv)
 {
     struct xfs_alloc_arg        args = {0};
     xfs_agblock_t           bno;
     int             error;
 
     switch (resv) {
     case XFS_AG_RESV_AGFL:
     case XFS_AG_RESV_RMAPBT:
         error = xfs_alloc_get_freelist(sc->sa.pag, sc->tp,
                 sc->sa.agf_bp, &bno, 1);
         if (error)
             return error;
         if (bno == NULLAGBLOCK)
             return -ENOSPC;
         xfs_extent_busy_reuse(sc->mp, sc->sa.pag, bno, 1, false);
         *fsbno = XFS_AGB_TO_FSB(sc->mp, sc->sa.pag->pag_agno, bno);
         if (resv == XFS_AG_RESV_RMAPBT)
             xfs_ag_resv_rmapbt_alloc(sc->mp, sc->sa.pag->pag_agno);
         return 0;
     default:
         break;
     }
 
     args.tp = sc->tp;
     args.mp = sc->mp;
     args.oinfo = *oinfo;
     args.fsbno = XFS_AGB_TO_FSB(args.mp, sc->sa.pag->pag_agno, 0);
     args.minlen = 1;
     args.maxlen = 1;
     args.prod = 1;
     args.type = XFS_ALLOCTYPE_THIS_AG;
     args.resv = resv;
 
     error = xfs_alloc_vextent(&args);
     if (error)
         return error;
     if (args.fsbno == NULLFSBLOCK)
         return -ENOSPC;
     ASSERT(args.len == 1);
     *fsbno = args.fsbno;
 
     return 0;
 }
 
 /* Initialize a new AG btree root block with zero entries. */
 int
 xrep_init_btblock(
     struct xfs_scrub        *sc,
     xfs_fsblock_t           fsb,
     struct xfs_buf          **bpp,
     xfs_btnum_t         btnum,
     const struct xfs_buf_ops    *ops)
 {
     struct xfs_trans        *tp = sc->tp;
     struct xfs_mount        *mp = sc->mp;
     struct xfs_buf          *bp;
     int             error;
 
     trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
             XFS_FSB_TO_AGBNO(mp, fsb), btnum);
 
     ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.pag->pag_agno);
     error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
             XFS_FSB_TO_DADDR(mp, fsb), XFS_FSB_TO_BB(mp, 1), 0,
             &bp);
     if (error)
         return error;
     xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
     xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.pag->pag_agno);
     xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);
     xfs_trans_log_buf(tp, bp, 0, BBTOB(bp->b_length) - 1);
     bp->b_ops = ops;
     *bpp = bp;
 
     return 0;
 }
 
 /*
  * Reconstructing per-AG Btrees
  *
  * When a space btree is corrupt, we don't bother trying to fix it.  Instead,
  * we scan secondary space metadata to derive the records that should be in
  * the damaged btree, initialize a fresh btree root, and insert the records.
  * Note that for rebuilding the rmapbt we scan all the primary data to
  * generate the new records.
  *
  * However, that leaves the matter of removing all the metadata describing the
  * old broken structure.  For primary metadata we use the rmap data to collect
  * every extent with a matching rmap owner (bitmap); we then iterate all other
  * metadata structures with the same rmap owner to collect the extents that
  * cannot be removed (sublist).  We then subtract sublist from bitmap to
  * derive the blocks that were used by the old btree.  These blocks can be
  * reaped.
  *
  * For rmapbt reconstructions we must use different tactics for extent
  * collection.  First we iterate all primary metadata (this excludes the old
  * rmapbt, obviously) to generate new rmap records.  The gaps in the rmap
  * records are collected as bitmap.  The bnobt records are collected as
  * sublist.  As with the other btrees we subtract sublist from bitmap, and the
  * result (since the rmapbt lives in the free space) are the blocks from the
  * old rmapbt.
  *
  * Disposal of Blocks from Old per-AG Btrees
  *
  * Now that we've constructed a new btree to replace the damaged one, we want
  * to dispose of the blocks that (we think) the old btree was using.
  * Previously, we used the rmapbt to collect the extents (bitmap) with the
  * rmap owner corresponding to the tree we rebuilt, collected extents for any
  * blocks with the same rmap owner that are owned by another data structure
  * (sublist), and subtracted sublist from bitmap.  In theory the extents
  * remaining in bitmap are the old btree's blocks.
  *
  * Unfortunately, it's possible that the btree was crosslinked with other
  * blocks on disk.  The rmap data can tell us if there are multiple owners, so
  * if the rmapbt says there is an owner of this block other than @oinfo, then
  * the block is crosslinked.  Remove the reverse mapping and continue.
  *
  * If there is one rmap record, we can free the block, which removes the
  * reverse mapping but doesn't add the block to the free space.  Our repair
  * strategy is to hope the other metadata objects crosslinked on this block
  * will be rebuilt (atop different blocks), thereby removing all the cross
  * links.
  *
  * If there are no rmap records at all, we also free the block.  If the btree
  * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't
  * supposed to be a rmap record and everything is ok.  For other btrees there
  * had to have been an rmap entry for the block to have ended up on @bitmap,
  * so if it's gone now there's something wrong and the fs will shut down.
  *
  * Note: If there are multiple rmap records with only the same rmap owner as
  * the btree we're trying to rebuild and the block is indeed owned by another
  * data structure with the same rmap owner, then the block will be in sublist
  * and therefore doesn't need disposal.  If there are multiple rmap records
  * with only the same rmap owner but the block is not owned by something with
  * the same rmap owner, the block will be freed.
  *
  * The caller is responsible for locking the AG headers for the entire rebuild
  * operation so that nothing else can sneak in and change the AG state while
  * we're not looking.  We also assume that the caller already invalidated any
  * buffers associated with @bitmap.
  */
 
 /*
  * Invalidate buffers for per-AG btree blocks we're dumping.  This function
  * is not intended for use with file data repairs; we have bunmapi for that.
  */
 int
 xrep_invalidate_blocks(
     struct xfs_scrub    *sc,
     struct xbitmap      *bitmap)
 {
     struct xbitmap_range    *bmr;
     struct xbitmap_range    *n;
     struct xfs_buf      *bp;
     xfs_fsblock_t       fsbno;
 
     /*
      * For each block in each extent, see if there's an incore buffer for
      * exactly that block; if so, invalidate it.  The buffer cache only
      * lets us look for one buffer at a time, so we have to look one block
      * at a time.  Avoid invalidating AG headers and post-EOFS blocks
      * because we never own those; and if we can't TRYLOCK the buffer we
      * assume it's owned by someone else.
      */
     for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
         int     error;
 
         /* Skip AG headers and post-EOFS blocks */
         if (!xfs_verify_fsbno(sc->mp, fsbno))
             continue;
         error = xfs_buf_incore(sc->mp->m_ddev_targp,
                 XFS_FSB_TO_DADDR(sc->mp, fsbno),
                 XFS_FSB_TO_BB(sc->mp, 1), XBF_TRYLOCK, &bp);
         if (error)
             continue;
 
         xfs_trans_bjoin(sc->tp, bp);
         xfs_trans_binval(sc->tp, bp);
     }
 
     return 0;
 }
 
 /* Ensure the freelist is the correct size. */
 int
 xrep_fix_freelist(
     struct xfs_scrub    *sc,
     bool            can_shrink)
 {
     struct xfs_alloc_arg    args = {0};
 
     args.mp = sc->mp;
     args.tp = sc->tp;
     args.agno = sc->sa.pag->pag_agno;
     args.alignment = 1;
     args.pag = sc->sa.pag;
 
     return xfs_alloc_fix_freelist(&args,
             can_shrink ? 0 : XFS_ALLOC_FLAG_NOSHRINK);
 }
 
 /*
  * Put a block back on the AGFL.
  */
 STATIC int
 xrep_put_freelist(
     struct xfs_scrub    *sc,
     xfs_agblock_t       agbno)
 {
     int         error;
 
     /* Make sure there's space on the freelist. */
     error = xrep_fix_freelist(sc, true);
     if (error)
         return error;
 
     /*
      * Since we're "freeing" a lost block onto the AGFL, we have to
      * create an rmap for the block prior to merging it or else other
      * parts will break.
      */
     error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1,
             &XFS_RMAP_OINFO_AG);
     if (error)
         return error;
 
     /* Put the block on the AGFL. */
     error = xfs_alloc_put_freelist(sc->sa.pag, sc->tp, sc->sa.agf_bp,
             sc->sa.agfl_bp, agbno, 0);
     if (error)
         return error;
     xfs_extent_busy_insert(sc->tp, sc->sa.pag, agbno, 1,
             XFS_EXTENT_BUSY_SKIP_DISCARD);
 
     return 0;
 }
 
 /* Dispose of a single block. */
 STATIC int
 xrep_reap_block(
     struct xfs_scrub        *sc,
     xfs_fsblock_t           fsbno,
     const struct xfs_owner_info *oinfo,
     enum xfs_ag_resv_type       resv)
 {
     struct xfs_btree_cur        *cur;
     struct xfs_buf          *agf_bp = NULL;
     xfs_agblock_t           agbno;
     bool                has_other_rmap;
     int             error;
 
     agbno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);
     ASSERT(XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.pag->pag_agno);
 
     /*
      * If we are repairing per-inode metadata, we need to read in the AGF
      * buffer.  Otherwise, we're repairing a per-AG structure, so reuse
      * the AGF buffer that the setup functions already grabbed.
      */
     if (sc->ip) {
         error = xfs_alloc_read_agf(sc->sa.pag, sc->tp, 0, &agf_bp);
         if (error)
             return error;
     } else {
         agf_bp = sc->sa.agf_bp;
     }
     cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf_bp, sc->sa.pag);
 
     /* Can we find any other rmappings? */
     error = xfs_rmap_has_other_keys(cur, agbno, 1, oinfo, &has_other_rmap);
     xfs_btree_del_cursor(cur, error);
     if (error)
         goto out_free;
 
     /*
      * If there are other rmappings, this block is cross linked and must
      * not be freed.  Remove the reverse mapping and move on.  Otherwise,
      * we were the only owner of the block, so free the extent, which will
      * also remove the rmap.
      *
      * XXX: XFS doesn't support detecting the case where a single block
      * metadata structure is crosslinked with a multi-block structure
      * because the buffer cache doesn't detect aliasing problems, so we
      * can't fix 100% of crosslinking problems (yet).  The verifiers will
      * blow on writeout, the filesystem will shut down, and the admin gets
      * to run xfs_repair.
      */
     if (has_other_rmap)
         error = xfs_rmap_free(sc->tp, agf_bp, sc->sa.pag, agbno,
                     1, oinfo);
     else if (resv == XFS_AG_RESV_AGFL)
         error = xrep_put_freelist(sc, agbno);
     else
         error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv);
     if (agf_bp != sc->sa.agf_bp)
         xfs_trans_brelse(sc->tp, agf_bp);
     if (error)
         return error;
 
     if (sc->ip)
         return xfs_trans_roll_inode(&sc->tp, sc->ip);
     return xrep_roll_ag_trans(sc);
 
 out_free:
     if (agf_bp != sc->sa.agf_bp)
         xfs_trans_brelse(sc->tp, agf_bp);
     return error;
 }
 
 /* Dispose of every block of every extent in the bitmap. */
 int
 xrep_reap_extents(
     struct xfs_scrub        *sc,
     struct xbitmap          *bitmap,
     const struct xfs_owner_info *oinfo,
     enum xfs_ag_resv_type       type)
 {
     struct xbitmap_range        *bmr;
     struct xbitmap_range        *n;
     xfs_fsblock_t           fsbno;
     int             error = 0;
 
     ASSERT(xfs_has_rmapbt(sc->mp));
 
     for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
         ASSERT(sc->ip != NULL ||
                XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.pag->pag_agno);
         trace_xrep_dispose_btree_extent(sc->mp,
                 XFS_FSB_TO_AGNO(sc->mp, fsbno),
                 XFS_FSB_TO_AGBNO(sc->mp, fsbno), 1);
 
         error = xrep_reap_block(sc, fsbno, oinfo, type);
         if (error)
             break;
     }
 
     return error;
 }
 
 /*
  * Finding per-AG Btree Roots for AGF/AGI Reconstruction
  *
  * If the AGF or AGI become slightly corrupted, it may be necessary to rebuild
  * the AG headers by using the rmap data to rummage through the AG looking for
  * btree roots.  This is not guaranteed to work if the AG is heavily damaged
  * or the rmap data are corrupt.
  *
  * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
  * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
  * AGI is being rebuilt.  It must maintain these locks until it's safe for
  * other threads to change the btrees' shapes.  The caller provides
  * information about the btrees to look for by passing in an array of
  * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
  * The (root, height) fields will be set on return if anything is found.  The
  * last element of the array should have a NULL buf_ops to mark the end of the
  * array.
  *
  * For every rmapbt record matching any of the rmap owners in btree_info,
  * read each block referenced by the rmap record.  If the block is a btree
  * block from this filesystem matching any of the magic numbers and has a
  * level higher than what we've already seen, remember the block and the
  * height of the tree required to have such a block.  When the call completes,
  * we return the highest block we've found for each btree description; those
  * should be the roots.
  */
 
 struct xrep_findroot {
     struct xfs_scrub        *sc;
     struct xfs_buf          *agfl_bp;
     struct xfs_agf          *agf;
     struct xrep_find_ag_btree   *btree_info;
 };
 
 /* See if our block is in the AGFL. */
 STATIC int
 xrep_findroot_agfl_walk(
     struct xfs_mount    *mp,
     xfs_agblock_t       bno,
     void            *priv)
 {
     xfs_agblock_t       *agbno = priv;
 
     return (*agbno == bno) ? -ECANCELED : 0;
 }
 
 /* Does this block match the btree information passed in? */
 STATIC int
 xrep_findroot_block(
     struct xrep_findroot        *ri,
     struct xrep_find_ag_btree   *fab,
     uint64_t            owner,
     xfs_agblock_t           agbno,
     bool                *done_with_block)
 {
     struct xfs_mount        *mp = ri->sc->mp;
     struct xfs_buf          *bp;
     struct xfs_btree_block      *btblock;
     xfs_daddr_t         daddr;
     int             block_level;
     int             error = 0;
 
     daddr = XFS_AGB_TO_DADDR(mp, ri->sc->sa.pag->pag_agno, agbno);
 
     /*
      * Blocks in the AGFL have stale contents that might just happen to
      * have a matching magic and uuid.  We don't want to pull these blocks
      * in as part of a tree root, so we have to filter out the AGFL stuff
      * here.  If the AGFL looks insane we'll just refuse to repair.
      */
     if (owner == XFS_RMAP_OWN_AG) {
         error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp,
                 xrep_findroot_agfl_walk, &agbno);
         if (error == -ECANCELED)
             return 0;
         if (error)
             return error;
     }
 
     /*
      * Read the buffer into memory so that we can see if it's a match for
      * our btree type.  We have no clue if it is beforehand, and we want to
      * avoid xfs_trans_read_buf's behavior of dumping the DONE state (which
      * will cause needless disk reads in subsequent calls to this function)
      * and logging metadata verifier failures.
      *
      * Therefore, pass in NULL buffer ops.  If the buffer was already in
      * memory from some other caller it will already have b_ops assigned.
      * If it was in memory from a previous unsuccessful findroot_block
      * call, the buffer won't have b_ops but it should be clean and ready
      * for us to try to verify if the read call succeeds.  The same applies
      * if the buffer wasn't in memory at all.
      *
      * Note: If we never match a btree type with this buffer, it will be
      * left in memory with NULL b_ops.  This shouldn't be a problem unless
      * the buffer gets written.
      */
     error = xfs_trans_read_buf(mp, ri->sc->tp, mp->m_ddev_targp, daddr,
             mp->m_bsize, 0, &bp, NULL);
     if (error)
         return error;
 
     /* Ensure the block magic matches the btree type we're looking for. */
     btblock = XFS_BUF_TO_BLOCK(bp);
     ASSERT(fab->buf_ops->magic[1] != 0);
     if (btblock->bb_magic != fab->buf_ops->magic[1])
         goto out;
 
     /*
      * If the buffer already has ops applied and they're not the ones for
      * this btree type, we know this block doesn't match the btree and we
      * can bail out.
      *
      * If the buffer ops match ours, someone else has already validated
      * the block for us, so we can move on to checking if this is a root
      * block candidate.
      *
      * If the buffer does not have ops, nobody has successfully validated
      * the contents and the buffer cannot be dirty.  If the magic, uuid,
      * and structure match this btree type then we'll move on to checking
      * if it's a root block candidate.  If there is no match, bail out.
      */
     if (bp->b_ops) {
         if (bp->b_ops != fab->buf_ops)
             goto out;
     } else {
         ASSERT(!xfs_trans_buf_is_dirty(bp));
         if (!uuid_equal(&btblock->bb_u.s.bb_uuid,
                 &mp->m_sb.sb_meta_uuid))
             goto out;
         /*
          * Read verifiers can reference b_ops, so we set the pointer
          * here.  If the verifier fails we'll reset the buffer state
          * to what it was before we touched the buffer.
          */
         bp->b_ops = fab->buf_ops;
         fab->buf_ops->verify_read(bp);
         if (bp->b_error) {
             bp->b_ops = NULL;
             bp->b_error = 0;
             goto out;
         }
 
         /*
          * Some read verifiers will (re)set b_ops, so we must be
          * careful not to change b_ops after running the verifier.
          */
     }
 
     /*
      * This block passes the magic/uuid and verifier tests for this btree
      * type.  We don't need the caller to try the other tree types.
      */
     *done_with_block = true;
 
     /*
      * Compare this btree block's level to the height of the current
      * candidate root block.
      *
      * If the level matches the root we found previously, throw away both
      * blocks because there can't be two candidate roots.
      *
      * If level is lower in the tree than the root we found previously,
      * ignore this block.
      */
     block_level = xfs_btree_get_level(btblock);
     if (block_level + 1 == fab->height) {
         fab->root = NULLAGBLOCK;
         goto out;
     } else if (block_level < fab->height) {
         goto out;
     }
 
     /*
      * This is the highest block in the tree that we've found so far.
      * Update the btree height to reflect what we've learned from this
      * block.
      */
     fab->height = block_level + 1;
 
     /*
      * If this block doesn't have sibling pointers, then it's the new root
      * block candidate.  Otherwise, the root will be found farther up the
      * tree.
      */
     if (btblock->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) &&
         btblock->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK))
         fab->root = agbno;
     else
         fab->root = NULLAGBLOCK;
 
     trace_xrep_findroot_block(mp, ri->sc->sa.pag->pag_agno, agbno,
             be32_to_cpu(btblock->bb_magic), fab->height - 1);
 out:
     xfs_trans_brelse(ri->sc->tp, bp);
     return error;
 }
 
 /*
  * Do any of the blocks in this rmap record match one of the btrees we're
  * looking for?
  */
 STATIC int
 xrep_findroot_rmap(
     struct xfs_btree_cur        *cur,
     const struct xfs_rmap_irec  *rec,
     void                *priv)
 {
     struct xrep_findroot        *ri = priv;
     struct xrep_find_ag_btree   *fab;
     xfs_agblock_t           b;
     bool                done;
     int             error = 0;
 
     /* Ignore anything that isn't AG metadata. */
     if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner))
         return 0;
 
     /* Otherwise scan each block + btree type. */
     for (b = 0; b < rec->rm_blockcount; b++) {
         done = false;
         for (fab = ri->btree_info; fab->buf_ops; fab++) {
             if (rec->rm_owner != fab->rmap_owner)
                 continue;
             error = xrep_findroot_block(ri, fab,
                     rec->rm_owner, rec->rm_startblock + b,
                     &done);
             if (error)
                 return error;
             if (done)
                 break;
         }
     }
 
     return 0;
 }
 
 /* Find the roots of the per-AG btrees described in btree_info. */
 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)
 {
     struct xfs_mount        *mp = sc->mp;
     struct xrep_findroot        ri;
     struct xrep_find_ag_btree   *fab;
     struct xfs_btree_cur        *cur;
     int             error;
 
     ASSERT(xfs_buf_islocked(agf_bp));
     ASSERT(agfl_bp == NULL || xfs_buf_islocked(agfl_bp));
 
     ri.sc = sc;
     ri.btree_info = btree_info;
     ri.agf = agf_bp->b_addr;
     ri.agfl_bp = agfl_bp;
     for (fab = btree_info; fab->buf_ops; fab++) {
         ASSERT(agfl_bp || fab->rmap_owner != XFS_RMAP_OWN_AG);
         ASSERT(XFS_RMAP_NON_INODE_OWNER(fab->rmap_owner));
         fab->root = NULLAGBLOCK;
         fab->height = 0;
     }
 
     cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);
     error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri);
     xfs_btree_del_cursor(cur, error);
 
     return error;
 }
 
 /* Force a quotacheck the next time we mount. */
 void
 xrep_force_quotacheck(
     struct xfs_scrub    *sc,
     xfs_dqtype_t        type)
 {
     uint            flag;
 
     flag = xfs_quota_chkd_flag(type);
     if (!(flag & sc->mp->m_qflags))
         return;
 
     mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock);
     sc->mp->m_qflags &= ~flag;
     spin_lock(&sc->mp->m_sb_lock);
     sc->mp->m_sb.sb_qflags &= ~flag;
     spin_unlock(&sc->mp->m_sb_lock);
     xfs_log_sb(sc->tp);
     mutex_unlock(&sc->mp->m_quotainfo->qi_quotaofflock);
 }
 
 /*
  * Attach dquots to this inode, or schedule quotacheck to fix them.
  *
  * 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.
  */
 int
 xrep_ino_dqattach(
     struct xfs_scrub    *sc)
 {
     int         error;
 
     error = xfs_qm_dqattach_locked(sc->ip, false);
     switch (error) {
     case -EFSBADCRC:
     case -EFSCORRUPTED:
     case -ENOENT:
         xfs_err_ratelimited(sc->mp,
 "inode %llu repair encountered quota error %d, quotacheck forced.",
                 (unsigned long long)sc->ip->i_ino, error);
         if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
             xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
         if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
             xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
         if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
             xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
         fallthrough;
     case -ESRCH:
         error = 0;
         break;
     default:
         break;
     }
 
     return error;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team