OSCL-LXR linux-6.0.1/​fs/​xfs/​scrub/​common.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) 2017 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_inode.h"
 #include "xfs_icache.h"
 #include "xfs_alloc.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_refcount_btree.h"
 #include "xfs_rmap.h"
 #include "xfs_rmap_btree.h"
 #include "xfs_log.h"
 #include "xfs_trans_priv.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_reflink.h"
 #include "xfs_ag.h"
 #include "scrub/scrub.h"
 #include "scrub/common.h"
 #include "scrub/trace.h"
 #include "scrub/repair.h"
 #include "scrub/health.h"
 
 /* Common code for the metadata scrubbers. */
 
 /*
  * Handling operational errors.
  *
  * The *_process_error() family of functions are used to process error return
  * codes from functions called as part of a scrub operation.
  *
  * If there's no error, we return true to tell the caller that it's ok
  * to move on to the next check in its list.
  *
  * For non-verifier errors (e.g. ENOMEM) we return false to tell the
  * caller that something bad happened, and we preserve *error so that
  * the caller can return the *error up the stack to userspace.
  *
  * Verifier errors (EFSBADCRC/EFSCORRUPTED) are recorded by setting
  * OFLAG_CORRUPT in sm_flags and the *error is cleared.  In other words,
  * we track verifier errors (and failed scrub checks) via OFLAG_CORRUPT,
  * not via return codes.  We return false to tell the caller that
  * something bad happened.  Since the error has been cleared, the caller
  * will (presumably) return that zero and scrubbing will move on to
  * whatever's next.
  *
  * ftrace can be used to record the precise metadata location and the
  * approximate code location of the failed operation.
  */
 
 /* Check for operational errors. */
 static bool
 __xchk_process_error(
     struct xfs_scrub    *sc,
     xfs_agnumber_t      agno,
     xfs_agblock_t       bno,
     int         *error,
     __u32           errflag,
     void            *ret_ip)
 {
     switch (*error) {
     case 0:
         return true;
     case -EDEADLOCK:
         /* Used to restart an op with deadlock avoidance. */
         trace_xchk_deadlock_retry(
                 sc->ip ? sc->ip : XFS_I(file_inode(sc->file)),
                 sc->sm, *error);
         break;
     case -EFSBADCRC:
     case -EFSCORRUPTED:
         /* Note the badness but don't abort. */
         sc->sm->sm_flags |= errflag;
         *error = 0;
         fallthrough;
     default:
         trace_xchk_op_error(sc, agno, bno, *error,
                 ret_ip);
         break;
     }
     return false;
 }
 
 bool
 xchk_process_error(
     struct xfs_scrub    *sc,
     xfs_agnumber_t      agno,
     xfs_agblock_t       bno,
     int         *error)
 {
     return __xchk_process_error(sc, agno, bno, error,
             XFS_SCRUB_OFLAG_CORRUPT, __return_address);
 }
 
 bool
 xchk_xref_process_error(
     struct xfs_scrub    *sc,
     xfs_agnumber_t      agno,
     xfs_agblock_t       bno,
     int         *error)
 {
     return __xchk_process_error(sc, agno, bno, error,
             XFS_SCRUB_OFLAG_XFAIL, __return_address);
 }
 
 /* Check for operational errors for a file offset. */
 static bool
 __xchk_fblock_process_error(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset,
     int         *error,
     __u32           errflag,
     void            *ret_ip)
 {
     switch (*error) {
     case 0:
         return true;
     case -EDEADLOCK:
         /* Used to restart an op with deadlock avoidance. */
         trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
         break;
     case -EFSBADCRC:
     case -EFSCORRUPTED:
         /* Note the badness but don't abort. */
         sc->sm->sm_flags |= errflag;
         *error = 0;
         fallthrough;
     default:
         trace_xchk_file_op_error(sc, whichfork, offset, *error,
                 ret_ip);
         break;
     }
     return false;
 }
 
 bool
 xchk_fblock_process_error(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset,
     int         *error)
 {
     return __xchk_fblock_process_error(sc, whichfork, offset, error,
             XFS_SCRUB_OFLAG_CORRUPT, __return_address);
 }
 
 bool
 xchk_fblock_xref_process_error(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset,
     int         *error)
 {
     return __xchk_fblock_process_error(sc, whichfork, offset, error,
             XFS_SCRUB_OFLAG_XFAIL, __return_address);
 }
 
 /*
  * Handling scrub corruption/optimization/warning checks.
  *
  * The *_set_{corrupt,preen,warning}() family of functions are used to
  * record the presence of metadata that is incorrect (corrupt), could be
  * optimized somehow (preen), or should be flagged for administrative
  * review but is not incorrect (warn).
  *
  * ftrace can be used to record the precise metadata location and
  * approximate code location of the failed check.
  */
 
 /* Record a block which could be optimized. */
 void
 xchk_block_set_preen(
     struct xfs_scrub    *sc,
     struct xfs_buf      *bp)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
     trace_xchk_block_preen(sc, xfs_buf_daddr(bp), __return_address);
 }
 
 /*
  * Record an inode which could be optimized.  The trace data will
  * include the block given by bp if bp is given; otherwise it will use
  * the block location of the inode record itself.
  */
 void
 xchk_ino_set_preen(
     struct xfs_scrub    *sc,
     xfs_ino_t       ino)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
     trace_xchk_ino_preen(sc, ino, __return_address);
 }
 
 /* Record something being wrong with the filesystem primary superblock. */
 void
 xchk_set_corrupt(
     struct xfs_scrub    *sc)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
     trace_xchk_fs_error(sc, 0, __return_address);
 }
 
 /* Record a corrupt block. */
 void
 xchk_block_set_corrupt(
     struct xfs_scrub    *sc,
     struct xfs_buf      *bp)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
     trace_xchk_block_error(sc, xfs_buf_daddr(bp), __return_address);
 }
 
 /* Record a corruption while cross-referencing. */
 void
 xchk_block_xref_set_corrupt(
     struct xfs_scrub    *sc,
     struct xfs_buf      *bp)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
     trace_xchk_block_error(sc, xfs_buf_daddr(bp), __return_address);
 }
 
 /*
  * Record a corrupt inode.  The trace data will include the block given
  * by bp if bp is given; otherwise it will use the block location of the
  * inode record itself.
  */
 void
 xchk_ino_set_corrupt(
     struct xfs_scrub    *sc,
     xfs_ino_t       ino)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
     trace_xchk_ino_error(sc, ino, __return_address);
 }
 
 /* Record a corruption while cross-referencing with an inode. */
 void
 xchk_ino_xref_set_corrupt(
     struct xfs_scrub    *sc,
     xfs_ino_t       ino)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
     trace_xchk_ino_error(sc, ino, __return_address);
 }
 
 /* Record corruption in a block indexed by a file fork. */
 void
 xchk_fblock_set_corrupt(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
     trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
 }
 
 /* Record a corruption while cross-referencing a fork block. */
 void
 xchk_fblock_xref_set_corrupt(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
     trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
 }
 
 /*
  * Warn about inodes that need administrative review but is not
  * incorrect.
  */
 void
 xchk_ino_set_warning(
     struct xfs_scrub    *sc,
     xfs_ino_t       ino)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
     trace_xchk_ino_warning(sc, ino, __return_address);
 }
 
 /* Warn about a block indexed by a file fork that needs review. */
 void
 xchk_fblock_set_warning(
     struct xfs_scrub    *sc,
     int         whichfork,
     xfs_fileoff_t       offset)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
     trace_xchk_fblock_warning(sc, whichfork, offset, __return_address);
 }
 
 /* Signal an incomplete scrub. */
 void
 xchk_set_incomplete(
     struct xfs_scrub    *sc)
 {
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_INCOMPLETE;
     trace_xchk_incomplete(sc, __return_address);
 }
 
 /*
  * rmap scrubbing -- compute the number of blocks with a given owner,
  * at least according to the reverse mapping data.
  */
 
 struct xchk_rmap_ownedby_info {
     const struct xfs_owner_info *oinfo;
     xfs_filblks_t           *blocks;
 };
 
 STATIC int
 xchk_count_rmap_ownedby_irec(
     struct xfs_btree_cur        *cur,
     const struct xfs_rmap_irec  *rec,
     void                *priv)
 {
     struct xchk_rmap_ownedby_info   *sroi = priv;
     bool                irec_attr;
     bool                oinfo_attr;
 
     irec_attr = rec->rm_flags & XFS_RMAP_ATTR_FORK;
     oinfo_attr = sroi->oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK;
 
     if (rec->rm_owner != sroi->oinfo->oi_owner)
         return 0;
 
     if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) || irec_attr == oinfo_attr)
         (*sroi->blocks) += rec->rm_blockcount;
 
     return 0;
 }
 
 /*
  * Calculate the number of blocks the rmap thinks are owned by something.
  * The caller should pass us an rmapbt cursor.
  */
 int
 xchk_count_rmap_ownedby_ag(
     struct xfs_scrub        *sc,
     struct xfs_btree_cur        *cur,
     const struct xfs_owner_info *oinfo,
     xfs_filblks_t           *blocks)
 {
     struct xchk_rmap_ownedby_info   sroi = {
         .oinfo          = oinfo,
         .blocks         = blocks,
     };
 
     *blocks = 0;
     return xfs_rmap_query_all(cur, xchk_count_rmap_ownedby_irec,
             &sroi);
 }
 
 /*
  * AG scrubbing
  *
  * These helpers facilitate locking an allocation group's header
  * buffers, setting up cursors for all btrees that are present, and
  * cleaning everything up once we're through.
  */
 
 /* Decide if we want to return an AG header read failure. */
 static inline bool
 want_ag_read_header_failure(
     struct xfs_scrub    *sc,
     unsigned int        type)
 {
     /* Return all AG header read failures when scanning btrees. */
     if (sc->sm->sm_type != XFS_SCRUB_TYPE_AGF &&
         sc->sm->sm_type != XFS_SCRUB_TYPE_AGFL &&
         sc->sm->sm_type != XFS_SCRUB_TYPE_AGI)
         return true;
     /*
      * If we're scanning a given type of AG header, we only want to
      * see read failures from that specific header.  We'd like the
      * other headers to cross-check them, but this isn't required.
      */
     if (sc->sm->sm_type == type)
         return true;
     return false;
 }
 
 /*
  * Grab the perag structure and all the headers for an AG.
  *
  * The headers should be released by xchk_ag_free, but as a fail safe we attach
  * all the buffers we grab to the scrub transaction so they'll all be freed
  * when we cancel it.  Returns ENOENT if we can't grab the perag structure.
  */
 int
 xchk_ag_read_headers(
     struct xfs_scrub    *sc,
     xfs_agnumber_t      agno,
     struct xchk_ag      *sa)
 {
     struct xfs_mount    *mp = sc->mp;
     int         error;
 
     ASSERT(!sa->pag);
     sa->pag = xfs_perag_get(mp, agno);
     if (!sa->pag)
         return -ENOENT;
 
     error = xfs_ialloc_read_agi(sa->pag, sc->tp, &sa->agi_bp);
     if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGI))
         return error;
 
     error = xfs_alloc_read_agf(sa->pag, sc->tp, 0, &sa->agf_bp);
     if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGF))
         return error;
 
     error = xfs_alloc_read_agfl(sa->pag, sc->tp, &sa->agfl_bp);
     if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGFL))
         return error;
 
     return 0;
 }
 
 /* Release all the AG btree cursors. */
 void
 xchk_ag_btcur_free(
     struct xchk_ag      *sa)
 {
     if (sa->refc_cur)
         xfs_btree_del_cursor(sa->refc_cur, XFS_BTREE_ERROR);
     if (sa->rmap_cur)
         xfs_btree_del_cursor(sa->rmap_cur, XFS_BTREE_ERROR);
     if (sa->fino_cur)
         xfs_btree_del_cursor(sa->fino_cur, XFS_BTREE_ERROR);
     if (sa->ino_cur)
         xfs_btree_del_cursor(sa->ino_cur, XFS_BTREE_ERROR);
     if (sa->cnt_cur)
         xfs_btree_del_cursor(sa->cnt_cur, XFS_BTREE_ERROR);
     if (sa->bno_cur)
         xfs_btree_del_cursor(sa->bno_cur, XFS_BTREE_ERROR);
 
     sa->refc_cur = NULL;
     sa->rmap_cur = NULL;
     sa->fino_cur = NULL;
     sa->ino_cur = NULL;
     sa->bno_cur = NULL;
     sa->cnt_cur = NULL;
 }
 
 /* Initialize all the btree cursors for an AG. */
 void
 xchk_ag_btcur_init(
     struct xfs_scrub    *sc,
     struct xchk_ag      *sa)
 {
     struct xfs_mount    *mp = sc->mp;
 
     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,
                 sa->pag, XFS_BTNUM_BNO);
     }
 
     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,
                 sa->pag, XFS_BTNUM_CNT);
     }
 
     /* Set up a inobt cursor for cross-referencing. */
     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,
                 sa->pag, XFS_BTNUM_INO);
     }
 
     /* Set up a finobt cursor for cross-referencing. */
     if (sa->agi_bp && xfs_has_finobt(mp) &&
         xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_FINO)) {
         sa->fino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
                 sa->pag, XFS_BTNUM_FINO);
     }
 
     /* Set up a rmapbt cursor for cross-referencing. */
     if (sa->agf_bp && xfs_has_rmapbt(mp) &&
         xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_RMAP)) {
         sa->rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, sa->agf_bp,
                 sa->pag);
     }
 
     /* Set up a refcountbt cursor for cross-referencing. */
     if (sa->agf_bp && xfs_has_reflink(mp) &&
         xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_REFC)) {
         sa->refc_cur = xfs_refcountbt_init_cursor(mp, sc->tp,
                 sa->agf_bp, sa->pag);
     }
 }
 
 /* Release the AG header context and btree cursors. */
 void
 xchk_ag_free(
     struct xfs_scrub    *sc,
     struct xchk_ag      *sa)
 {
     xchk_ag_btcur_free(sa);
     if (sa->agfl_bp) {
         xfs_trans_brelse(sc->tp, sa->agfl_bp);
         sa->agfl_bp = NULL;
     }
     if (sa->agf_bp) {
         xfs_trans_brelse(sc->tp, sa->agf_bp);
         sa->agf_bp = NULL;
     }
     if (sa->agi_bp) {
         xfs_trans_brelse(sc->tp, sa->agi_bp);
         sa->agi_bp = NULL;
     }
     if (sa->pag) {
         xfs_perag_put(sa->pag);
         sa->pag = NULL;
     }
 }
 
 /*
  * For scrub, grab the perag structure, the AGI, and the AGF headers, in that
  * order.  Locking order requires us to get the AGI before the AGF.  We use the
  * transaction to avoid deadlocking on crosslinked metadata buffers; either the
  * caller passes one in (bmap scrub) or we have to create a transaction
  * ourselves.  Returns ENOENT if the perag struct cannot be grabbed.
  */
 int
 xchk_ag_init(
     struct xfs_scrub    *sc,
     xfs_agnumber_t      agno,
     struct xchk_ag      *sa)
 {
     int         error;
 
     error = xchk_ag_read_headers(sc, agno, sa);
     if (error)
         return error;
 
     xchk_ag_btcur_init(sc, sa);
     return 0;
 }
 
 /* Per-scrubber setup functions */
 
 /*
  * Grab an empty transaction so that we can re-grab locked buffers if
  * one of our btrees turns out to be cyclic.
  *
  * If we're going to repair something, we need to ask for the largest possible
  * log reservation so that we can handle the worst case scenario for metadata
  * updates while rebuilding a metadata item.  We also need to reserve as many
  * blocks in the head transaction as we think we're going to need to rebuild
  * the metadata object.
  */
 int
 xchk_trans_alloc(
     struct xfs_scrub    *sc,
     uint            resblks)
 {
     if (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR)
         return xfs_trans_alloc(sc->mp, &M_RES(sc->mp)->tr_itruncate,
                 resblks, 0, 0, &sc->tp);
 
     return xfs_trans_alloc_empty(sc->mp, &sc->tp);
 }
 
 /* Set us up with a transaction and an empty context. */
 int
 xchk_setup_fs(
     struct xfs_scrub    *sc)
 {
     uint            resblks;
 
     resblks = xrep_calc_ag_resblks(sc);
     return xchk_trans_alloc(sc, resblks);
 }
 
 /* Set us up with AG headers and btree cursors. */
 int
 xchk_setup_ag_btree(
     struct xfs_scrub    *sc,
     bool            force_log)
 {
     struct xfs_mount    *mp = sc->mp;
     int         error;
 
     /*
      * If the caller asks us to checkpont the log, do so.  This
      * expensive operation should be performed infrequently and only
      * as a last resort.  Any caller that sets force_log should
      * document why they need to do so.
      */
     if (force_log) {
         error = xchk_checkpoint_log(mp);
         if (error)
             return error;
     }
 
     error = xchk_setup_fs(sc);
     if (error)
         return error;
 
     return xchk_ag_init(sc, sc->sm->sm_agno, &sc->sa);
 }
 
 /* Push everything out of the log onto disk. */
 int
 xchk_checkpoint_log(
     struct xfs_mount    *mp)
 {
     int         error;
 
     error = xfs_log_force(mp, XFS_LOG_SYNC);
     if (error)
         return error;
     xfs_ail_push_all_sync(mp->m_ail);
     return 0;
 }
 
 /*
  * Given an inode and the scrub control structure, grab either the
  * inode referenced in the control structure or the inode passed in.
  * The inode is not locked.
  */
 int
 xchk_get_inode(
     struct xfs_scrub    *sc)
 {
     struct xfs_imap     imap;
     struct xfs_mount    *mp = sc->mp;
     struct xfs_inode    *ip_in = XFS_I(file_inode(sc->file));
     struct xfs_inode    *ip = NULL;
     int         error;
 
     /* We want to scan the inode we already had opened. */
     if (sc->sm->sm_ino == 0 || sc->sm->sm_ino == ip_in->i_ino) {
         sc->ip = ip_in;
         return 0;
     }
 
     /* Look up the inode, see if the generation number matches. */
     if (xfs_internal_inum(mp, sc->sm->sm_ino))
         return -ENOENT;
     error = xfs_iget(mp, NULL, sc->sm->sm_ino,
             XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE, 0, &ip);
     switch (error) {
     case -ENOENT:
         /* Inode doesn't exist, just bail out. */
         return error;
     case 0:
         /* Got an inode, continue. */
         break;
     case -EINVAL:
         /*
          * -EINVAL with IGET_UNTRUSTED could mean one of several
          * things: userspace gave us an inode number that doesn't
          * correspond to fs space, or doesn't have an inobt entry;
          * or it could simply mean that the inode buffer failed the
          * read verifiers.
          *
          * Try just the inode mapping lookup -- if it succeeds, then
          * the inode buffer verifier failed and something needs fixing.
          * Otherwise, we really couldn't find it so tell userspace
          * that it no longer exists.
          */
         error = xfs_imap(sc->mp, sc->tp, sc->sm->sm_ino, &imap,
                 XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE);
         if (error)
             return -ENOENT;
         error = -EFSCORRUPTED;
         fallthrough;
     default:
         trace_xchk_op_error(sc,
                 XFS_INO_TO_AGNO(mp, sc->sm->sm_ino),
                 XFS_INO_TO_AGBNO(mp, sc->sm->sm_ino),
                 error, __return_address);
         return error;
     }
     if (VFS_I(ip)->i_generation != sc->sm->sm_gen) {
         xfs_irele(ip);
         return -ENOENT;
     }
 
     sc->ip = ip;
     return 0;
 }
 
 /* Set us up to scrub a file's contents. */
 int
 xchk_setup_inode_contents(
     struct xfs_scrub    *sc,
     unsigned int        resblks)
 {
     int         error;
 
     error = xchk_get_inode(sc);
     if (error)
         return error;
 
     /* Got the inode, lock it and we're ready to go. */
     sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
     xfs_ilock(sc->ip, sc->ilock_flags);
     error = xchk_trans_alloc(sc, resblks);
     if (error)
         goto out;
     sc->ilock_flags |= XFS_ILOCK_EXCL;
     xfs_ilock(sc->ip, XFS_ILOCK_EXCL);
 
 out:
     /* scrub teardown will unlock and release the inode for us */
     return error;
 }
 
 /*
  * Predicate that decides if we need to evaluate the cross-reference check.
  * If there was an error accessing the cross-reference btree, just delete
  * the cursor and skip the check.
  */
 bool
 xchk_should_check_xref(
     struct xfs_scrub    *sc,
     int         *error,
     struct xfs_btree_cur    **curpp)
 {
     /* No point in xref if we already know we're corrupt. */
     if (xchk_skip_xref(sc->sm))
         return false;
 
     if (*error == 0)
         return true;
 
     if (curpp) {
         /* If we've already given up on xref, just bail out. */
         if (!*curpp)
             return false;
 
         /* xref error, delete cursor and bail out. */
         xfs_btree_del_cursor(*curpp, XFS_BTREE_ERROR);
         *curpp = NULL;
     }
 
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XFAIL;
     trace_xchk_xref_error(sc, *error, __return_address);
 
     /*
      * Errors encountered during cross-referencing with another
      * data structure should not cause this scrubber to abort.
      */
     *error = 0;
     return false;
 }
 
 /* Run the structure verifiers on in-memory buffers to detect bad memory. */
 void
 xchk_buffer_recheck(
     struct xfs_scrub    *sc,
     struct xfs_buf      *bp)
 {
     xfs_failaddr_t      fa;
 
     if (bp->b_ops == NULL) {
         xchk_block_set_corrupt(sc, bp);
         return;
     }
     if (bp->b_ops->verify_struct == NULL) {
         xchk_set_incomplete(sc);
         return;
     }
     fa = bp->b_ops->verify_struct(bp);
     if (!fa)
         return;
     sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
     trace_xchk_block_error(sc, xfs_buf_daddr(bp), fa);
 }
 
 /*
  * Scrub the attr/data forks of a metadata inode.  The metadata inode must be
  * pointed to by sc->ip and the ILOCK must be held.
  */
 int
 xchk_metadata_inode_forks(
     struct xfs_scrub    *sc)
 {
     __u32           smtype;
     bool            shared;
     int         error;
 
     if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
         return 0;
 
     /* Metadata inodes don't live on the rt device. */
     if (sc->ip->i_diflags & XFS_DIFLAG_REALTIME) {
         xchk_ino_set_corrupt(sc, sc->ip->i_ino);
         return 0;
     }
 
     /* They should never participate in reflink. */
     if (xfs_is_reflink_inode(sc->ip)) {
         xchk_ino_set_corrupt(sc, sc->ip->i_ino);
         return 0;
     }
 
     /* They also should never have extended attributes. */
     if (xfs_inode_hasattr(sc->ip)) {
         xchk_ino_set_corrupt(sc, sc->ip->i_ino);
         return 0;
     }
 
     /* Invoke the data fork scrubber. */
     smtype = sc->sm->sm_type;
     sc->sm->sm_type = XFS_SCRUB_TYPE_BMBTD;
     error = xchk_bmap_data(sc);
     sc->sm->sm_type = smtype;
     if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
         return error;
 
     /* Look for incorrect shared blocks. */
     if (xfs_has_reflink(sc->mp)) {
         error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
                 &shared);
         if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0,
                 &error))
             return error;
         if (shared)
             xchk_ino_set_corrupt(sc, sc->ip->i_ino);
     }
 
     return error;
 }
 
 /*
  * Try to lock an inode in violation of the usual locking order rules.  For
  * example, trying to get the IOLOCK while in transaction context, or just
  * plain breaking AG-order or inode-order inode locking rules.  Either way,
  * the only way to avoid an ABBA deadlock is to use trylock and back off if
  * we can't.
  */
 int
 xchk_ilock_inverted(
     struct xfs_inode    *ip,
     uint            lock_mode)
 {
     int         i;
 
     for (i = 0; i < 20; i++) {
         if (xfs_ilock_nowait(ip, lock_mode))
             return 0;
         delay(1);
     }
     return -EDEADLOCK;
 }
 
 /* Pause background reaping of resources. */
 void
 xchk_stop_reaping(
     struct xfs_scrub    *sc)
 {
     sc->flags |= XCHK_REAPING_DISABLED;
     xfs_blockgc_stop(sc->mp);
     xfs_inodegc_stop(sc->mp);
 }
 
 /* Restart background reaping of resources. */
 void
 xchk_start_reaping(
     struct xfs_scrub    *sc)
 {
     /*
      * Readonly filesystems do not perform inactivation or speculative
      * preallocation, so there's no need to restart the workers.
      */
     if (!xfs_is_readonly(sc->mp)) {
         xfs_inodegc_start(sc->mp);
         xfs_blockgc_start(sc->mp);
     }
     sc->flags &= ~XCHK_REAPING_DISABLED;
 }

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