linux/fs/xfs/scrub/common.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2017 Oracle.  All Rights Reserved.
   4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_trans_resv.h"
  11#include "xfs_mount.h"
  12#include "xfs_btree.h"
  13#include "xfs_log_format.h"
  14#include "xfs_trans.h"
  15#include "xfs_inode.h"
  16#include "xfs_icache.h"
  17#include "xfs_alloc.h"
  18#include "xfs_alloc_btree.h"
  19#include "xfs_ialloc.h"
  20#include "xfs_ialloc_btree.h"
  21#include "xfs_refcount_btree.h"
  22#include "xfs_rmap.h"
  23#include "xfs_rmap_btree.h"
  24#include "xfs_log.h"
  25#include "xfs_trans_priv.h"
  26#include "xfs_attr.h"
  27#include "xfs_reflink.h"
  28#include "xfs_ag.h"
  29#include "scrub/scrub.h"
  30#include "scrub/common.h"
  31#include "scrub/trace.h"
  32#include "scrub/repair.h"
  33#include "scrub/health.h"
  34
  35/* Common code for the metadata scrubbers. */
  36
  37/*
  38 * Handling operational errors.
  39 *
  40 * The *_process_error() family of functions are used to process error return
  41 * codes from functions called as part of a scrub operation.
  42 *
  43 * If there's no error, we return true to tell the caller that it's ok
  44 * to move on to the next check in its list.
  45 *
  46 * For non-verifier errors (e.g. ENOMEM) we return false to tell the
  47 * caller that something bad happened, and we preserve *error so that
  48 * the caller can return the *error up the stack to userspace.
  49 *
  50 * Verifier errors (EFSBADCRC/EFSCORRUPTED) are recorded by setting
  51 * OFLAG_CORRUPT in sm_flags and the *error is cleared.  In other words,
  52 * we track verifier errors (and failed scrub checks) via OFLAG_CORRUPT,
  53 * not via return codes.  We return false to tell the caller that
  54 * something bad happened.  Since the error has been cleared, the caller
  55 * will (presumably) return that zero and scrubbing will move on to
  56 * whatever's next.
  57 *
  58 * ftrace can be used to record the precise metadata location and the
  59 * approximate code location of the failed operation.
  60 */
  61
  62/* Check for operational errors. */
  63static bool
  64__xchk_process_error(
  65        struct xfs_scrub        *sc,
  66        xfs_agnumber_t          agno,
  67        xfs_agblock_t           bno,
  68        int                     *error,
  69        __u32                   errflag,
  70        void                    *ret_ip)
  71{
  72        switch (*error) {
  73        case 0:
  74                return true;
  75        case -EDEADLOCK:
  76                /* Used to restart an op with deadlock avoidance. */
  77                trace_xchk_deadlock_retry(
  78                                sc->ip ? sc->ip : XFS_I(file_inode(sc->file)),
  79                                sc->sm, *error);
  80                break;
  81        case -EFSBADCRC:
  82        case -EFSCORRUPTED:
  83                /* Note the badness but don't abort. */
  84                sc->sm->sm_flags |= errflag;
  85                *error = 0;
  86                fallthrough;
  87        default:
  88                trace_xchk_op_error(sc, agno, bno, *error,
  89                                ret_ip);
  90                break;
  91        }
  92        return false;
  93}
  94
  95bool
  96xchk_process_error(
  97        struct xfs_scrub        *sc,
  98        xfs_agnumber_t          agno,
  99        xfs_agblock_t           bno,
 100        int                     *error)
 101{
 102        return __xchk_process_error(sc, agno, bno, error,
 103                        XFS_SCRUB_OFLAG_CORRUPT, __return_address);
 104}
 105
 106bool
 107xchk_xref_process_error(
 108        struct xfs_scrub        *sc,
 109        xfs_agnumber_t          agno,
 110        xfs_agblock_t           bno,
 111        int                     *error)
 112{
 113        return __xchk_process_error(sc, agno, bno, error,
 114                        XFS_SCRUB_OFLAG_XFAIL, __return_address);
 115}
 116
 117/* Check for operational errors for a file offset. */
 118static bool
 119__xchk_fblock_process_error(
 120        struct xfs_scrub        *sc,
 121        int                     whichfork,
 122        xfs_fileoff_t           offset,
 123        int                     *error,
 124        __u32                   errflag,
 125        void                    *ret_ip)
 126{
 127        switch (*error) {
 128        case 0:
 129                return true;
 130        case -EDEADLOCK:
 131                /* Used to restart an op with deadlock avoidance. */
 132                trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
 133                break;
 134        case -EFSBADCRC:
 135        case -EFSCORRUPTED:
 136                /* Note the badness but don't abort. */
 137                sc->sm->sm_flags |= errflag;
 138                *error = 0;
 139                fallthrough;
 140        default:
 141                trace_xchk_file_op_error(sc, whichfork, offset, *error,
 142                                ret_ip);
 143                break;
 144        }
 145        return false;
 146}
 147
 148bool
 149xchk_fblock_process_error(
 150        struct xfs_scrub        *sc,
 151        int                     whichfork,
 152        xfs_fileoff_t           offset,
 153        int                     *error)
 154{
 155        return __xchk_fblock_process_error(sc, whichfork, offset, error,
 156                        XFS_SCRUB_OFLAG_CORRUPT, __return_address);
 157}
 158
 159bool
 160xchk_fblock_xref_process_error(
 161        struct xfs_scrub        *sc,
 162        int                     whichfork,
 163        xfs_fileoff_t           offset,
 164        int                     *error)
 165{
 166        return __xchk_fblock_process_error(sc, whichfork, offset, error,
 167                        XFS_SCRUB_OFLAG_XFAIL, __return_address);
 168}
 169
 170/*
 171 * Handling scrub corruption/optimization/warning checks.
 172 *
 173 * The *_set_{corrupt,preen,warning}() family of functions are used to
 174 * record the presence of metadata that is incorrect (corrupt), could be
 175 * optimized somehow (preen), or should be flagged for administrative
 176 * review but is not incorrect (warn).
 177 *
 178 * ftrace can be used to record the precise metadata location and
 179 * approximate code location of the failed check.
 180 */
 181
 182/* Record a block which could be optimized. */
 183void
 184xchk_block_set_preen(
 185        struct xfs_scrub        *sc,
 186        struct xfs_buf          *bp)
 187{
 188        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
 189        trace_xchk_block_preen(sc, bp->b_bn, __return_address);
 190}
 191
 192/*
 193 * Record an inode which could be optimized.  The trace data will
 194 * include the block given by bp if bp is given; otherwise it will use
 195 * the block location of the inode record itself.
 196 */
 197void
 198xchk_ino_set_preen(
 199        struct xfs_scrub        *sc,
 200        xfs_ino_t               ino)
 201{
 202        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
 203        trace_xchk_ino_preen(sc, ino, __return_address);
 204}
 205
 206/* Record something being wrong with the filesystem primary superblock. */
 207void
 208xchk_set_corrupt(
 209        struct xfs_scrub        *sc)
 210{
 211        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 212        trace_xchk_fs_error(sc, 0, __return_address);
 213}
 214
 215/* Record a corrupt block. */
 216void
 217xchk_block_set_corrupt(
 218        struct xfs_scrub        *sc,
 219        struct xfs_buf          *bp)
 220{
 221        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 222        trace_xchk_block_error(sc, bp->b_bn, __return_address);
 223}
 224
 225/* Record a corruption while cross-referencing. */
 226void
 227xchk_block_xref_set_corrupt(
 228        struct xfs_scrub        *sc,
 229        struct xfs_buf          *bp)
 230{
 231        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
 232        trace_xchk_block_error(sc, bp->b_bn, __return_address);
 233}
 234
 235/*
 236 * Record a corrupt inode.  The trace data will include the block given
 237 * by bp if bp is given; otherwise it will use the block location of the
 238 * inode record itself.
 239 */
 240void
 241xchk_ino_set_corrupt(
 242        struct xfs_scrub        *sc,
 243        xfs_ino_t               ino)
 244{
 245        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 246        trace_xchk_ino_error(sc, ino, __return_address);
 247}
 248
 249/* Record a corruption while cross-referencing with an inode. */
 250void
 251xchk_ino_xref_set_corrupt(
 252        struct xfs_scrub        *sc,
 253        xfs_ino_t               ino)
 254{
 255        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
 256        trace_xchk_ino_error(sc, ino, __return_address);
 257}
 258
 259/* Record corruption in a block indexed by a file fork. */
 260void
 261xchk_fblock_set_corrupt(
 262        struct xfs_scrub        *sc,
 263        int                     whichfork,
 264        xfs_fileoff_t           offset)
 265{
 266        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 267        trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
 268}
 269
 270/* Record a corruption while cross-referencing a fork block. */
 271void
 272xchk_fblock_xref_set_corrupt(
 273        struct xfs_scrub        *sc,
 274        int                     whichfork,
 275        xfs_fileoff_t           offset)
 276{
 277        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
 278        trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
 279}
 280
 281/*
 282 * Warn about inodes that need administrative review but is not
 283 * incorrect.
 284 */
 285void
 286xchk_ino_set_warning(
 287        struct xfs_scrub        *sc,
 288        xfs_ino_t               ino)
 289{
 290        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
 291        trace_xchk_ino_warning(sc, ino, __return_address);
 292}
 293
 294/* Warn about a block indexed by a file fork that needs review. */
 295void
 296xchk_fblock_set_warning(
 297        struct xfs_scrub        *sc,
 298        int                     whichfork,
 299        xfs_fileoff_t           offset)
 300{
 301        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
 302        trace_xchk_fblock_warning(sc, whichfork, offset, __return_address);
 303}
 304
 305/* Signal an incomplete scrub. */
 306void
 307xchk_set_incomplete(
 308        struct xfs_scrub        *sc)
 309{
 310        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_INCOMPLETE;
 311        trace_xchk_incomplete(sc, __return_address);
 312}
 313
 314/*
 315 * rmap scrubbing -- compute the number of blocks with a given owner,
 316 * at least according to the reverse mapping data.
 317 */
 318
 319struct xchk_rmap_ownedby_info {
 320        const struct xfs_owner_info     *oinfo;
 321        xfs_filblks_t                   *blocks;
 322};
 323
 324STATIC int
 325xchk_count_rmap_ownedby_irec(
 326        struct xfs_btree_cur            *cur,
 327        struct xfs_rmap_irec            *rec,
 328        void                            *priv)
 329{
 330        struct xchk_rmap_ownedby_info   *sroi = priv;
 331        bool                            irec_attr;
 332        bool                            oinfo_attr;
 333
 334        irec_attr = rec->rm_flags & XFS_RMAP_ATTR_FORK;
 335        oinfo_attr = sroi->oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK;
 336
 337        if (rec->rm_owner != sroi->oinfo->oi_owner)
 338                return 0;
 339
 340        if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) || irec_attr == oinfo_attr)
 341                (*sroi->blocks) += rec->rm_blockcount;
 342
 343        return 0;
 344}
 345
 346/*
 347 * Calculate the number of blocks the rmap thinks are owned by something.
 348 * The caller should pass us an rmapbt cursor.
 349 */
 350int
 351xchk_count_rmap_ownedby_ag(
 352        struct xfs_scrub                *sc,
 353        struct xfs_btree_cur            *cur,
 354        const struct xfs_owner_info     *oinfo,
 355        xfs_filblks_t                   *blocks)
 356{
 357        struct xchk_rmap_ownedby_info   sroi = {
 358                .oinfo                  = oinfo,
 359                .blocks                 = blocks,
 360        };
 361
 362        *blocks = 0;
 363        return xfs_rmap_query_all(cur, xchk_count_rmap_ownedby_irec,
 364                        &sroi);
 365}
 366
 367/*
 368 * AG scrubbing
 369 *
 370 * These helpers facilitate locking an allocation group's header
 371 * buffers, setting up cursors for all btrees that are present, and
 372 * cleaning everything up once we're through.
 373 */
 374
 375/* Decide if we want to return an AG header read failure. */
 376static inline bool
 377want_ag_read_header_failure(
 378        struct xfs_scrub        *sc,
 379        unsigned int            type)
 380{
 381        /* Return all AG header read failures when scanning btrees. */
 382        if (sc->sm->sm_type != XFS_SCRUB_TYPE_AGF &&
 383            sc->sm->sm_type != XFS_SCRUB_TYPE_AGFL &&
 384            sc->sm->sm_type != XFS_SCRUB_TYPE_AGI)
 385                return true;
 386        /*
 387         * If we're scanning a given type of AG header, we only want to
 388         * see read failures from that specific header.  We'd like the
 389         * other headers to cross-check them, but this isn't required.
 390         */
 391        if (sc->sm->sm_type == type)
 392                return true;
 393        return false;
 394}
 395
 396/*
 397 * Grab all the headers for an AG.
 398 *
 399 * The headers should be released by xchk_ag_free, but as a fail
 400 * safe we attach all the buffers we grab to the scrub transaction so
 401 * they'll all be freed when we cancel it.
 402 */
 403int
 404xchk_ag_read_headers(
 405        struct xfs_scrub        *sc,
 406        xfs_agnumber_t          agno,
 407        struct xchk_ag          *sa)
 408{
 409        struct xfs_mount        *mp = sc->mp;
 410        int                     error;
 411
 412        sa->agno = agno;
 413
 414        error = xfs_ialloc_read_agi(mp, sc->tp, agno, &sa->agi_bp);
 415        if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGI))
 416                goto out;
 417
 418        error = xfs_alloc_read_agf(mp, sc->tp, agno, 0, &sa->agf_bp);
 419        if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGF))
 420                goto out;
 421
 422        error = xfs_alloc_read_agfl(mp, sc->tp, agno, &sa->agfl_bp);
 423        if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGFL))
 424                goto out;
 425        error = 0;
 426out:
 427        return error;
 428}
 429
 430/* Release all the AG btree cursors. */
 431void
 432xchk_ag_btcur_free(
 433        struct xchk_ag          *sa)
 434{
 435        if (sa->refc_cur)
 436                xfs_btree_del_cursor(sa->refc_cur, XFS_BTREE_ERROR);
 437        if (sa->rmap_cur)
 438                xfs_btree_del_cursor(sa->rmap_cur, XFS_BTREE_ERROR);
 439        if (sa->fino_cur)
 440                xfs_btree_del_cursor(sa->fino_cur, XFS_BTREE_ERROR);
 441        if (sa->ino_cur)
 442                xfs_btree_del_cursor(sa->ino_cur, XFS_BTREE_ERROR);
 443        if (sa->cnt_cur)
 444                xfs_btree_del_cursor(sa->cnt_cur, XFS_BTREE_ERROR);
 445        if (sa->bno_cur)
 446                xfs_btree_del_cursor(sa->bno_cur, XFS_BTREE_ERROR);
 447
 448        sa->refc_cur = NULL;
 449        sa->rmap_cur = NULL;
 450        sa->fino_cur = NULL;
 451        sa->ino_cur = NULL;
 452        sa->bno_cur = NULL;
 453        sa->cnt_cur = NULL;
 454}
 455
 456/* Initialize all the btree cursors for an AG. */
 457void
 458xchk_ag_btcur_init(
 459        struct xfs_scrub        *sc,
 460        struct xchk_ag          *sa)
 461{
 462        struct xfs_mount        *mp = sc->mp;
 463
 464        xchk_perag_get(sc->mp, sa);
 465        if (sa->agf_bp &&
 466            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_BNO)) {
 467                /* Set up a bnobt cursor for cross-referencing. */
 468                sa->bno_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
 469                                sa->pag, XFS_BTNUM_BNO);
 470        }
 471
 472        if (sa->agf_bp &&
 473            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_CNT)) {
 474                /* Set up a cntbt cursor for cross-referencing. */
 475                sa->cnt_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
 476                                sa->pag, XFS_BTNUM_CNT);
 477        }
 478
 479        /* Set up a inobt cursor for cross-referencing. */
 480        if (sa->agi_bp &&
 481            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_INO)) {
 482                sa->ino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
 483                                sa->pag, XFS_BTNUM_INO);
 484        }
 485
 486        /* Set up a finobt cursor for cross-referencing. */
 487        if (sa->agi_bp && xfs_sb_version_hasfinobt(&mp->m_sb) &&
 488            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_FINO)) {
 489                sa->fino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
 490                                sa->pag, XFS_BTNUM_FINO);
 491        }
 492
 493        /* Set up a rmapbt cursor for cross-referencing. */
 494        if (sa->agf_bp && xfs_sb_version_hasrmapbt(&mp->m_sb) &&
 495            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_RMAP)) {
 496                sa->rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, sa->agf_bp,
 497                                sa->pag);
 498        }
 499
 500        /* Set up a refcountbt cursor for cross-referencing. */
 501        if (sa->agf_bp && xfs_sb_version_hasreflink(&mp->m_sb) &&
 502            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_REFC)) {
 503                sa->refc_cur = xfs_refcountbt_init_cursor(mp, sc->tp,
 504                                sa->agf_bp, sa->pag);
 505        }
 506}
 507
 508/* Release the AG header context and btree cursors. */
 509void
 510xchk_ag_free(
 511        struct xfs_scrub        *sc,
 512        struct xchk_ag          *sa)
 513{
 514        xchk_ag_btcur_free(sa);
 515        if (sa->agfl_bp) {
 516                xfs_trans_brelse(sc->tp, sa->agfl_bp);
 517                sa->agfl_bp = NULL;
 518        }
 519        if (sa->agf_bp) {
 520                xfs_trans_brelse(sc->tp, sa->agf_bp);
 521                sa->agf_bp = NULL;
 522        }
 523        if (sa->agi_bp) {
 524                xfs_trans_brelse(sc->tp, sa->agi_bp);
 525                sa->agi_bp = NULL;
 526        }
 527        if (sa->pag) {
 528                xfs_perag_put(sa->pag);
 529                sa->pag = NULL;
 530        }
 531        sa->agno = NULLAGNUMBER;
 532}
 533
 534/*
 535 * For scrub, grab the AGI and the AGF headers, in that order.  Locking
 536 * order requires us to get the AGI before the AGF.  We use the
 537 * transaction to avoid deadlocking on crosslinked metadata buffers;
 538 * either the caller passes one in (bmap scrub) or we have to create a
 539 * transaction ourselves.
 540 */
 541int
 542xchk_ag_init(
 543        struct xfs_scrub        *sc,
 544        xfs_agnumber_t          agno,
 545        struct xchk_ag          *sa)
 546{
 547        int                     error;
 548
 549        error = xchk_ag_read_headers(sc, agno, sa);
 550        if (error)
 551                return error;
 552
 553        xchk_ag_btcur_init(sc, sa);
 554        return 0;
 555}
 556
 557/*
 558 * Grab the per-ag structure if we haven't already gotten it.  Teardown of the
 559 * xchk_ag will release it for us.
 560 */
 561void
 562xchk_perag_get(
 563        struct xfs_mount        *mp,
 564        struct xchk_ag          *sa)
 565{
 566        if (!sa->pag)
 567                sa->pag = xfs_perag_get(mp, sa->agno);
 568}
 569
 570/* Per-scrubber setup functions */
 571
 572/*
 573 * Grab an empty transaction so that we can re-grab locked buffers if
 574 * one of our btrees turns out to be cyclic.
 575 *
 576 * If we're going to repair something, we need to ask for the largest possible
 577 * log reservation so that we can handle the worst case scenario for metadata
 578 * updates while rebuilding a metadata item.  We also need to reserve as many
 579 * blocks in the head transaction as we think we're going to need to rebuild
 580 * the metadata object.
 581 */
 582int
 583xchk_trans_alloc(
 584        struct xfs_scrub        *sc,
 585        uint                    resblks)
 586{
 587        if (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR)
 588                return xfs_trans_alloc(sc->mp, &M_RES(sc->mp)->tr_itruncate,
 589                                resblks, 0, 0, &sc->tp);
 590
 591        return xfs_trans_alloc_empty(sc->mp, &sc->tp);
 592}
 593
 594/* Set us up with a transaction and an empty context. */
 595int
 596xchk_setup_fs(
 597        struct xfs_scrub        *sc)
 598{
 599        uint                    resblks;
 600
 601        resblks = xrep_calc_ag_resblks(sc);
 602        return xchk_trans_alloc(sc, resblks);
 603}
 604
 605/* Set us up with AG headers and btree cursors. */
 606int
 607xchk_setup_ag_btree(
 608        struct xfs_scrub        *sc,
 609        bool                    force_log)
 610{
 611        struct xfs_mount        *mp = sc->mp;
 612        int                     error;
 613
 614        /*
 615         * If the caller asks us to checkpont the log, do so.  This
 616         * expensive operation should be performed infrequently and only
 617         * as a last resort.  Any caller that sets force_log should
 618         * document why they need to do so.
 619         */
 620        if (force_log) {
 621                error = xchk_checkpoint_log(mp);
 622                if (error)
 623                        return error;
 624        }
 625
 626        error = xchk_setup_fs(sc);
 627        if (error)
 628                return error;
 629
 630        return xchk_ag_init(sc, sc->sm->sm_agno, &sc->sa);
 631}
 632
 633/* Push everything out of the log onto disk. */
 634int
 635xchk_checkpoint_log(
 636        struct xfs_mount        *mp)
 637{
 638        int                     error;
 639
 640        error = xfs_log_force(mp, XFS_LOG_SYNC);
 641        if (error)
 642                return error;
 643        xfs_ail_push_all_sync(mp->m_ail);
 644        return 0;
 645}
 646
 647/*
 648 * Given an inode and the scrub control structure, grab either the
 649 * inode referenced in the control structure or the inode passed in.
 650 * The inode is not locked.
 651 */
 652int
 653xchk_get_inode(
 654        struct xfs_scrub        *sc)
 655{
 656        struct xfs_imap         imap;
 657        struct xfs_mount        *mp = sc->mp;
 658        struct xfs_inode        *ip_in = XFS_I(file_inode(sc->file));
 659        struct xfs_inode        *ip = NULL;
 660        int                     error;
 661
 662        /* We want to scan the inode we already had opened. */
 663        if (sc->sm->sm_ino == 0 || sc->sm->sm_ino == ip_in->i_ino) {
 664                sc->ip = ip_in;
 665                return 0;
 666        }
 667
 668        /* Look up the inode, see if the generation number matches. */
 669        if (xfs_internal_inum(mp, sc->sm->sm_ino))
 670                return -ENOENT;
 671        error = xfs_iget(mp, NULL, sc->sm->sm_ino,
 672                        XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE, 0, &ip);
 673        switch (error) {
 674        case -ENOENT:
 675                /* Inode doesn't exist, just bail out. */
 676                return error;
 677        case 0:
 678                /* Got an inode, continue. */
 679                break;
 680        case -EINVAL:
 681                /*
 682                 * -EINVAL with IGET_UNTRUSTED could mean one of several
 683                 * things: userspace gave us an inode number that doesn't
 684                 * correspond to fs space, or doesn't have an inobt entry;
 685                 * or it could simply mean that the inode buffer failed the
 686                 * read verifiers.
 687                 *
 688                 * Try just the inode mapping lookup -- if it succeeds, then
 689                 * the inode buffer verifier failed and something needs fixing.
 690                 * Otherwise, we really couldn't find it so tell userspace
 691                 * that it no longer exists.
 692                 */
 693                error = xfs_imap(sc->mp, sc->tp, sc->sm->sm_ino, &imap,
 694                                XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE);
 695                if (error)
 696                        return -ENOENT;
 697                error = -EFSCORRUPTED;
 698                fallthrough;
 699        default:
 700                trace_xchk_op_error(sc,
 701                                XFS_INO_TO_AGNO(mp, sc->sm->sm_ino),
 702                                XFS_INO_TO_AGBNO(mp, sc->sm->sm_ino),
 703                                error, __return_address);
 704                return error;
 705        }
 706        if (VFS_I(ip)->i_generation != sc->sm->sm_gen) {
 707                xfs_irele(ip);
 708                return -ENOENT;
 709        }
 710
 711        sc->ip = ip;
 712        return 0;
 713}
 714
 715/* Set us up to scrub a file's contents. */
 716int
 717xchk_setup_inode_contents(
 718        struct xfs_scrub        *sc,
 719        unsigned int            resblks)
 720{
 721        int                     error;
 722
 723        error = xchk_get_inode(sc);
 724        if (error)
 725                return error;
 726
 727        /* Got the inode, lock it and we're ready to go. */
 728        sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
 729        xfs_ilock(sc->ip, sc->ilock_flags);
 730        error = xchk_trans_alloc(sc, resblks);
 731        if (error)
 732                goto out;
 733        sc->ilock_flags |= XFS_ILOCK_EXCL;
 734        xfs_ilock(sc->ip, XFS_ILOCK_EXCL);
 735
 736out:
 737        /* scrub teardown will unlock and release the inode for us */
 738        return error;
 739}
 740
 741/*
 742 * Predicate that decides if we need to evaluate the cross-reference check.
 743 * If there was an error accessing the cross-reference btree, just delete
 744 * the cursor and skip the check.
 745 */
 746bool
 747xchk_should_check_xref(
 748        struct xfs_scrub        *sc,
 749        int                     *error,
 750        struct xfs_btree_cur    **curpp)
 751{
 752        /* No point in xref if we already know we're corrupt. */
 753        if (xchk_skip_xref(sc->sm))
 754                return false;
 755
 756        if (*error == 0)
 757                return true;
 758
 759        if (curpp) {
 760                /* If we've already given up on xref, just bail out. */
 761                if (!*curpp)
 762                        return false;
 763
 764                /* xref error, delete cursor and bail out. */
 765                xfs_btree_del_cursor(*curpp, XFS_BTREE_ERROR);
 766                *curpp = NULL;
 767        }
 768
 769        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XFAIL;
 770        trace_xchk_xref_error(sc, *error, __return_address);
 771
 772        /*
 773         * Errors encountered during cross-referencing with another
 774         * data structure should not cause this scrubber to abort.
 775         */
 776        *error = 0;
 777        return false;
 778}
 779
 780/* Run the structure verifiers on in-memory buffers to detect bad memory. */
 781void
 782xchk_buffer_recheck(
 783        struct xfs_scrub        *sc,
 784        struct xfs_buf          *bp)
 785{
 786        xfs_failaddr_t          fa;
 787
 788        if (bp->b_ops == NULL) {
 789                xchk_block_set_corrupt(sc, bp);
 790                return;
 791        }
 792        if (bp->b_ops->verify_struct == NULL) {
 793                xchk_set_incomplete(sc);
 794                return;
 795        }
 796        fa = bp->b_ops->verify_struct(bp);
 797        if (!fa)
 798                return;
 799        sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 800        trace_xchk_block_error(sc, bp->b_bn, fa);
 801}
 802
 803/*
 804 * Scrub the attr/data forks of a metadata inode.  The metadata inode must be
 805 * pointed to by sc->ip and the ILOCK must be held.
 806 */
 807int
 808xchk_metadata_inode_forks(
 809        struct xfs_scrub        *sc)
 810{
 811        __u32                   smtype;
 812        bool                    shared;
 813        int                     error;
 814
 815        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 816                return 0;
 817
 818        /* Metadata inodes don't live on the rt device. */
 819        if (sc->ip->i_diflags & XFS_DIFLAG_REALTIME) {
 820                xchk_ino_set_corrupt(sc, sc->ip->i_ino);
 821                return 0;
 822        }
 823
 824        /* They should never participate in reflink. */
 825        if (xfs_is_reflink_inode(sc->ip)) {
 826                xchk_ino_set_corrupt(sc, sc->ip->i_ino);
 827                return 0;
 828        }
 829
 830        /* They also should never have extended attributes. */
 831        if (xfs_inode_hasattr(sc->ip)) {
 832                xchk_ino_set_corrupt(sc, sc->ip->i_ino);
 833                return 0;
 834        }
 835
 836        /* Invoke the data fork scrubber. */
 837        smtype = sc->sm->sm_type;
 838        sc->sm->sm_type = XFS_SCRUB_TYPE_BMBTD;
 839        error = xchk_bmap_data(sc);
 840        sc->sm->sm_type = smtype;
 841        if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 842                return error;
 843
 844        /* Look for incorrect shared blocks. */
 845        if (xfs_sb_version_hasreflink(&sc->mp->m_sb)) {
 846                error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
 847                                &shared);
 848                if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0,
 849                                &error))
 850                        return error;
 851                if (shared)
 852                        xchk_ino_set_corrupt(sc, sc->ip->i_ino);
 853        }
 854
 855        return error;
 856}
 857
 858/*
 859 * Try to lock an inode in violation of the usual locking order rules.  For
 860 * example, trying to get the IOLOCK while in transaction context, or just
 861 * plain breaking AG-order or inode-order inode locking rules.  Either way,
 862 * the only way to avoid an ABBA deadlock is to use trylock and back off if
 863 * we can't.
 864 */
 865int
 866xchk_ilock_inverted(
 867        struct xfs_inode        *ip,
 868        uint                    lock_mode)
 869{
 870        int                     i;
 871
 872        for (i = 0; i < 20; i++) {
 873                if (xfs_ilock_nowait(ip, lock_mode))
 874                        return 0;
 875                delay(1);
 876        }
 877        return -EDEADLOCK;
 878}
 879
 880/* Pause background reaping of resources. */
 881void
 882xchk_stop_reaping(
 883        struct xfs_scrub        *sc)
 884{
 885        sc->flags |= XCHK_REAPING_DISABLED;
 886        xfs_blockgc_stop(sc->mp);
 887}
 888
 889/* Restart background reaping of resources. */
 890void
 891xchk_start_reaping(
 892        struct xfs_scrub        *sc)
 893{
 894        xfs_blockgc_start(sc->mp);
 895        sc->flags &= ~XCHK_REAPING_DISABLED;
 896}
 897
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.