fs/xfs/scrub/common.c

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