fs/xfs/scrub/btree.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_alloc.h"
  20 #include "scrub/scrub.h"
  21 #include "scrub/common.h"
  22 #include "scrub/btree.h"
  23 #include "scrub/trace.h"
  24
  25 /* btree scrubbing */
  26
  27 /*
  28  * Check for btree operation errors.  See the section about handling
  29  * operational errors in common.c.
  30  */
  31 static bool
  32 __xchk_btree_process_error(
  33         struct xfs_scrub        *sc,
  34         struct xfs_btree_cur    *cur,
  35         int                     level,
  36         int                     *error,
  37         __u32                   errflag,
  38         void                    *ret_ip)
  39 {
  40         if (*error == 0)
  41                 return true;
  42
  43         switch (*error) {
  44         case -EDEADLOCK:
  45                 /* Used to restart an op with deadlock avoidance. */
  46                 trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
  47                 break;
  48         case -EFSBADCRC:
  49         case -EFSCORRUPTED:
  50                 /* Note the badness but don't abort. */
  51                 sc->sm->sm_flags |= errflag;
  52                 *error = 0;
  53                 /* fall through */
  54         default:
  55                 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
  56                         trace_xchk_ifork_btree_op_error(sc, cur, level,
  57                                         *error, ret_ip);
  58                 else
  59                         trace_xchk_btree_op_error(sc, cur, level,
  60                                         *error, ret_ip);
  61                 break;
  62         }
  63         return false;
  64 }
  65
  66 bool
  67 xchk_btree_process_error(
  68         struct xfs_scrub        *sc,
  69         struct xfs_btree_cur    *cur,
  70         int                     level,
  71         int                     *error)
  72 {
  73         return __xchk_btree_process_error(sc, cur, level, error,
  74                         XFS_SCRUB_OFLAG_CORRUPT, __return_address);
  75 }
  76
  77 bool
  78 xchk_btree_xref_process_error(
  79         struct xfs_scrub        *sc,
  80         struct xfs_btree_cur    *cur,
  81         int                     level,
  82         int                     *error)
  83 {
  84         return __xchk_btree_process_error(sc, cur, level, error,
  85                         XFS_SCRUB_OFLAG_XFAIL, __return_address);
  86 }
  87
  88 /* Record btree block corruption. */
  89 static void
  90 __xchk_btree_set_corrupt(
  91         struct xfs_scrub        *sc,
  92         struct xfs_btree_cur    *cur,
  93         int                     level,
  94         __u32                   errflag,
  95         void                    *ret_ip)
  96 {
  97         sc->sm->sm_flags |= errflag;
  98
  99         if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
 100                 trace_xchk_ifork_btree_error(sc, cur, level,
 101                                 ret_ip);
 102         else
 103                 trace_xchk_btree_error(sc, cur, level,
 104                                 ret_ip);
 105 }
 106
 107 void
 108 xchk_btree_set_corrupt(
 109         struct xfs_scrub        *sc,
 110         struct xfs_btree_cur    *cur,
 111         int                     level)
 112 {
 113         __xchk_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_CORRUPT,
 114                         __return_address);
 115 }
 116
 117 void
 118 xchk_btree_xref_set_corrupt(
 119         struct xfs_scrub        *sc,
 120         struct xfs_btree_cur    *cur,
 121         int                     level)
 122 {
 123         __xchk_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_XCORRUPT,
 124                         __return_address);
 125 }
 126
 127 /*
 128  * Make sure this record is in order and doesn't stray outside of the parent
 129  * keys.
 130  */
 131 STATIC void
 132 xchk_btree_rec(
 133         struct xchk_btree       *bs)
 134 {
 135         struct xfs_btree_cur    *cur = bs->cur;
 136         union xfs_btree_rec     *rec;
 137         union xfs_btree_key     key;
 138         union xfs_btree_key     hkey;
 139         union xfs_btree_key     *keyp;
 140         struct xfs_btree_block  *block;
 141         struct xfs_btree_block  *keyblock;
 142         struct xfs_buf          *bp;
 143
 144         block = xfs_btree_get_block(cur, 0, &bp);
 145         rec = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
 146
 147         trace_xchk_btree_rec(bs->sc, cur, 0);
 148
 149         /* If this isn't the first record, are they in order? */
 150         if (!bs->firstrec && !cur->bc_ops->recs_inorder(cur, &bs->lastrec, rec))
 151                 xchk_btree_set_corrupt(bs->sc, cur, 0);
 152         bs->firstrec = false;
 153         memcpy(&bs->lastrec, rec, cur->bc_ops->rec_len);
 154
 155         if (cur->bc_nlevels == 1)
 156                 return;
 157
 158         /* Is this at least as large as the parent low key? */
 159         cur->bc_ops->init_key_from_rec(&key, rec);
 160         keyblock = xfs_btree_get_block(cur, 1, &bp);
 161         keyp = xfs_btree_key_addr(cur, cur->bc_ptrs[1], keyblock);
 162         if (cur->bc_ops->diff_two_keys(cur, &key, keyp) < 0)
 163                 xchk_btree_set_corrupt(bs->sc, cur, 1);
 164
 165         if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
 166                 return;
 167
 168         /* Is this no larger than the parent high key? */
 169         cur->bc_ops->init_high_key_from_rec(&hkey, rec);
 170         keyp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[1], keyblock);
 171         if (cur->bc_ops->diff_two_keys(cur, keyp, &hkey) < 0)
 172                 xchk_btree_set_corrupt(bs->sc, cur, 1);
 173 }
 174
 175 /*
 176  * Make sure this key is in order and doesn't stray outside of the parent
 177  * keys.
 178  */
 179 STATIC void
 180 xchk_btree_key(
 181         struct xchk_btree       *bs,
 182         int                     level)
 183 {
 184         struct xfs_btree_cur    *cur = bs->cur;
 185         union xfs_btree_key     *key;
 186         union xfs_btree_key     *keyp;
 187         struct xfs_btree_block  *block;
 188         struct xfs_btree_block  *keyblock;
 189         struct xfs_buf          *bp;
 190
 191         block = xfs_btree_get_block(cur, level, &bp);
 192         key = xfs_btree_key_addr(cur, cur->bc_ptrs[level], block);
 193
 194         trace_xchk_btree_key(bs->sc, cur, level);
 195
 196         /* If this isn't the first key, are they in order? */
 197         if (!bs->firstkey[level] &&
 198             !cur->bc_ops->keys_inorder(cur, &bs->lastkey[level], key))
 199                 xchk_btree_set_corrupt(bs->sc, cur, level);
 200         bs->firstkey[level] = false;
 201         memcpy(&bs->lastkey[level], key, cur->bc_ops->key_len);
 202
 203         if (level + 1 >= cur->bc_nlevels)
 204                 return;
 205
 206         /* Is this at least as large as the parent low key? */
 207         keyblock = xfs_btree_get_block(cur, level + 1, &bp);
 208         keyp = xfs_btree_key_addr(cur, cur->bc_ptrs[level + 1], keyblock);
 209         if (cur->bc_ops->diff_two_keys(cur, key, keyp) < 0)
 210                 xchk_btree_set_corrupt(bs->sc, cur, level);
 211
 212         if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
 213                 return;
 214
 215         /* Is this no larger than the parent high key? */
 216         key = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level], block);
 217         keyp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level + 1], keyblock);
 218         if (cur->bc_ops->diff_two_keys(cur, keyp, key) < 0)
 219                 xchk_btree_set_corrupt(bs->sc, cur, level);
 220 }
 221
 222 /*
 223  * Check a btree pointer.  Returns true if it's ok to use this pointer.
 224  * Callers do not need to set the corrupt flag.
 225  */
 226 static bool
 227 xchk_btree_ptr_ok(
 228         struct xchk_btree       *bs,
 229         int                     level,
 230         union xfs_btree_ptr     *ptr)
 231 {
 232         bool                    res;
 233
 234         /* A btree rooted in an inode has no block pointer to the root. */
 235         if ((bs->cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
 236             level == bs->cur->bc_nlevels)
 237                 return true;
 238
 239         /* Otherwise, check the pointers. */
 240         if (bs->cur->bc_flags & XFS_BTREE_LONG_PTRS)
 241                 res = xfs_btree_check_lptr(bs->cur, be64_to_cpu(ptr->l), level);
 242         else
 243                 res = xfs_btree_check_sptr(bs->cur, be32_to_cpu(ptr->s), level);
 244         if (!res)
 245                 xchk_btree_set_corrupt(bs->sc, bs->cur, level);
 246
 247         return res;
 248 }
 249
 250 /* Check that a btree block's sibling matches what we expect it. */
 251 STATIC int
 252 xchk_btree_block_check_sibling(
 253         struct xchk_btree       *bs,
 254         int                     level,
 255         int                     direction,
 256         union xfs_btree_ptr     *sibling)
 257 {
 258         struct xfs_btree_cur    *cur = bs->cur;
 259         struct xfs_btree_block  *pblock;
 260         struct xfs_buf          *pbp;
 261         struct xfs_btree_cur    *ncur = NULL;
 262         union xfs_btree_ptr     *pp;
 263         int                     success;
 264         int                     error;
 265
 266         error = xfs_btree_dup_cursor(cur, &ncur);
 267         if (!xchk_btree_process_error(bs->sc, cur, level + 1, &error) ||
 268             !ncur)
 269                 return error;
 270
 271         /*
 272          * If the pointer is null, we shouldn't be able to move the upper
 273          * level pointer anywhere.
 274          */
 275         if (xfs_btree_ptr_is_null(cur, sibling)) {
 276                 if (direction > 0)
 277                         error = xfs_btree_increment(ncur, level + 1, &success);
 278                 else
 279                         error = xfs_btree_decrement(ncur, level + 1, &success);
 280                 if (error == 0 && success)
 281                         xchk_btree_set_corrupt(bs->sc, cur, level);
 282                 error = 0;
 283                 goto out;
 284         }
 285
 286         /* Increment upper level pointer. */
 287         if (direction > 0)
 288                 error = xfs_btree_increment(ncur, level + 1, &success);
 289         else
 290                 error = xfs_btree_decrement(ncur, level + 1, &success);
 291         if (!xchk_btree_process_error(bs->sc, cur, level + 1, &error))
 292                 goto out;
 293         if (!success) {
 294                 xchk_btree_set_corrupt(bs->sc, cur, level + 1);
 295                 goto out;
 296         }
 297
 298         /* Compare upper level pointer to sibling pointer. */
 299         pblock = xfs_btree_get_block(ncur, level + 1, &pbp);
 300         pp = xfs_btree_ptr_addr(ncur, ncur->bc_ptrs[level + 1], pblock);
 301         if (!xchk_btree_ptr_ok(bs, level + 1, pp))
 302                 goto out;
 303         if (pbp)
 304                 xchk_buffer_recheck(bs->sc, pbp);
 305
 306         if (xfs_btree_diff_two_ptrs(cur, pp, sibling))
 307                 xchk_btree_set_corrupt(bs->sc, cur, level);
 308 out:
 309         xfs_btree_del_cursor(ncur, XFS_BTREE_ERROR);
 310         return error;
 311 }
 312
 313 /* Check the siblings of a btree block. */
 314 STATIC int
 315 xchk_btree_block_check_siblings(
 316         struct xchk_btree       *bs,
 317         struct xfs_btree_block  *block)
 318 {
 319         struct xfs_btree_cur    *cur = bs->cur;
 320         union xfs_btree_ptr     leftsib;
 321         union xfs_btree_ptr     rightsib;
 322         int                     level;
 323         int                     error = 0;
 324
 325         xfs_btree_get_sibling(cur, block, &leftsib, XFS_BB_LEFTSIB);
 326         xfs_btree_get_sibling(cur, block, &rightsib, XFS_BB_RIGHTSIB);
 327         level = xfs_btree_get_level(block);
 328
 329         /* Root block should never have siblings. */
 330         if (level == cur->bc_nlevels - 1) {
 331                 if (!xfs_btree_ptr_is_null(cur, &leftsib) ||
 332                     !xfs_btree_ptr_is_null(cur, &rightsib))
 333                         xchk_btree_set_corrupt(bs->sc, cur, level);
 334                 goto out;
 335         }
 336
 337         /*
 338          * Does the left & right sibling pointers match the adjacent
 339          * parent level pointers?
 340          * (These function absorbs error codes for us.)
 341          */
 342         error = xchk_btree_block_check_sibling(bs, level, -1, &leftsib);
 343         if (error)
 344                 return error;
 345         error = xchk_btree_block_check_sibling(bs, level, 1, &rightsib);
 346         if (error)
 347                 return error;
 348 out:
 349         return error;
 350 }
 351
 352 struct check_owner {
 353         struct list_head        list;
 354         xfs_daddr_t             daddr;
 355         int                     level;
 356 };
 357
 358 /*
 359  * Make sure this btree block isn't in the free list and that there's
 360  * an rmap record for it.
 361  */
 362 STATIC int
 363 xchk_btree_check_block_owner(
 364         struct xchk_btree       *bs,
 365         int                     level,
 366         xfs_daddr_t             daddr)
 367 {
 368         xfs_agnumber_t          agno;
 369         xfs_agblock_t           agbno;
 370         xfs_btnum_t             btnum;
 371         bool                    init_sa;
 372         int                     error = 0;
 373
 374         if (!bs->cur)
 375                 return 0;
 376
 377         btnum = bs->cur->bc_btnum;
 378         agno = xfs_daddr_to_agno(bs->cur->bc_mp, daddr);
 379         agbno = xfs_daddr_to_agbno(bs->cur->bc_mp, daddr);
 380
 381         init_sa = bs->cur->bc_flags & XFS_BTREE_LONG_PTRS;
 382         if (init_sa) {
 383                 error = xchk_ag_init(bs->sc, agno, &bs->sc->sa);
 384                 if (!xchk_btree_xref_process_error(bs->sc, bs->cur,
 385                                 level, &error))
 386                         return error;
 387         }
 388
 389         xchk_xref_is_used_space(bs->sc, agbno, 1);
 390         /*
 391          * The bnobt scrubber aliases bs->cur to bs->sc->sa.bno_cur, so we
 392          * have to nullify it (to shut down further block owner checks) if
 393          * self-xref encounters problems.
 394          */
 395         if (!bs->sc->sa.bno_cur && btnum == XFS_BTNUM_BNO)
 396                 bs->cur = NULL;
 397
 398         xchk_xref_is_owned_by(bs->sc, agbno, 1, bs->oinfo);
 399         if (!bs->sc->sa.rmap_cur && btnum == XFS_BTNUM_RMAP)
 400                 bs->cur = NULL;
 401
 402         if (init_sa)
 403                 xchk_ag_free(bs->sc, &bs->sc->sa);
 404
 405         return error;
 406 }
 407
 408 /* Check the owner of a btree block. */
 409 STATIC int
 410 xchk_btree_check_owner(
 411         struct xchk_btree       *bs,
 412         int                     level,
 413         struct xfs_buf          *bp)
 414 {
 415         struct xfs_btree_cur    *cur = bs->cur;
 416         struct check_owner      *co;
 417
 418         if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) && bp == NULL)
 419                 return 0;
 420
 421         /*
 422          * We want to cross-reference each btree block with the bnobt
 423          * and the rmapbt.  We cannot cross-reference the bnobt or
 424          * rmapbt while scanning the bnobt or rmapbt, respectively,
 425          * because we cannot alter the cursor and we'd prefer not to
 426          * duplicate cursors.  Therefore, save the buffer daddr for
 427          * later scanning.
 428          */
 429         if (cur->bc_btnum == XFS_BTNUM_BNO || cur->bc_btnum == XFS_BTNUM_RMAP) {
 430                 co = kmem_alloc(sizeof(struct check_owner),
 431                                 KM_MAYFAIL);
 432                 if (!co)
 433                         return -ENOMEM;
 434                 co->level = level;
 435                 co->daddr = XFS_BUF_ADDR(bp);
 436                 list_add_tail(&co->list, &bs->to_check);
 437                 return 0;
 438         }
 439
 440         return xchk_btree_check_block_owner(bs, level, XFS_BUF_ADDR(bp));
 441 }
 442
 443 /*
 444  * Check that this btree block has at least minrecs records or is one of the
 445  * special blocks that don't require that.
 446  */
 447 STATIC void
 448 xchk_btree_check_minrecs(
 449         struct xchk_btree       *bs,
 450         int                     level,
 451         struct xfs_btree_block  *block)
 452 {
 453         unsigned int            numrecs;
 454         int                     ok_level;
 455
 456         numrecs = be16_to_cpu(block->bb_numrecs);
 457
 458         /* More records than minrecs means the block is ok. */
 459         if (numrecs >= bs->cur->bc_ops->get_minrecs(bs->cur, level))
 460                 return;
 461
 462         /*
 463          * Certain btree blocks /can/ have fewer than minrecs records.  Any
 464          * level greater than or equal to the level of the highest dedicated
 465          * btree block are allowed to violate this constraint.
 466          *
 467          * For a btree rooted in a block, the btree root can have fewer than
 468          * minrecs records.  If the btree is rooted in an inode and does not
 469          * store records in the root, the direct children of the root and the
 470          * root itself can have fewer than minrecs records.
 471          */
 472         ok_level = bs->cur->bc_nlevels - 1;
 473         if (bs->cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
 474                 ok_level--;
 475         if (level >= ok_level)
 476                 return;
 477
 478         xchk_btree_set_corrupt(bs->sc, bs->cur, level);
 479 }
 480
 481 /*
 482  * Grab and scrub a btree block given a btree pointer.  Returns block
 483  * and buffer pointers (if applicable) if they're ok to use.
 484  */
 485 STATIC int
 486 xchk_btree_get_block(
 487         struct xchk_btree       *bs,
 488         int                     level,
 489         union xfs_btree_ptr     *pp,
 490         struct xfs_btree_block  **pblock,
 491         struct xfs_buf          **pbp)
 492 {
 493         xfs_failaddr_t          failed_at;
 494         int                     error;
 495
 496         *pblock = NULL;
 497         *pbp = NULL;
 498
 499         error = xfs_btree_lookup_get_block(bs->cur, level, pp, pblock);
 500         if (!xchk_btree_process_error(bs->sc, bs->cur, level, &error) ||
 501             !*pblock)
 502                 return error;
 503
 504         xfs_btree_get_block(bs->cur, level, pbp);
 505         if (bs->cur->bc_flags & XFS_BTREE_LONG_PTRS)
 506                 failed_at = __xfs_btree_check_lblock(bs->cur, *pblock,
 507                                 level, *pbp);
 508         else
 509                 failed_at = __xfs_btree_check_sblock(bs->cur, *pblock,
 510                                  level, *pbp);
 511         if (failed_at) {
 512                 xchk_btree_set_corrupt(bs->sc, bs->cur, level);
 513                 return 0;
 514         }
 515         if (*pbp)
 516                 xchk_buffer_recheck(bs->sc, *pbp);
 517
 518         xchk_btree_check_minrecs(bs, level, *pblock);
 519
 520         /*
 521          * Check the block's owner; this function absorbs error codes
 522          * for us.
 523          */
 524         error = xchk_btree_check_owner(bs, level, *pbp);
 525         if (error)
 526                 return error;
 527
 528         /*
 529          * Check the block's siblings; this function absorbs error codes
 530          * for us.
 531          */
 532         return xchk_btree_block_check_siblings(bs, *pblock);
 533 }
 534
 535 /*
 536  * Check that the low and high keys of this block match the keys stored
 537  * in the parent block.
 538  */
 539 STATIC void
 540 xchk_btree_block_keys(
 541         struct xchk_btree       *bs,
 542         int                     level,
 543         struct xfs_btree_block  *block)
 544 {
 545         union xfs_btree_key     block_keys;
 546         struct xfs_btree_cur    *cur = bs->cur;
 547         union xfs_btree_key     *high_bk;
 548         union xfs_btree_key     *parent_keys;
 549         union xfs_btree_key     *high_pk;
 550         struct xfs_btree_block  *parent_block;
 551         struct xfs_buf          *bp;
 552
 553         if (level >= cur->bc_nlevels - 1)
 554                 return;
 555
 556         /* Calculate the keys for this block. */
 557         xfs_btree_get_keys(cur, block, &block_keys);
 558
 559         /* Obtain the parent's copy of the keys for this block. */
 560         parent_block = xfs_btree_get_block(cur, level + 1, &bp);
 561         parent_keys = xfs_btree_key_addr(cur, cur->bc_ptrs[level + 1],
 562                         parent_block);
 563
 564         if (cur->bc_ops->diff_two_keys(cur, &block_keys, parent_keys) != 0)
 565                 xchk_btree_set_corrupt(bs->sc, cur, 1);
 566
 567         if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
 568                 return;
 569
 570         /* Get high keys */
 571         high_bk = xfs_btree_high_key_from_key(cur, &block_keys);
 572         high_pk = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level + 1],
 573                         parent_block);
 574
 575         if (cur->bc_ops->diff_two_keys(cur, high_bk, high_pk) != 0)
 576                 xchk_btree_set_corrupt(bs->sc, cur, 1);
 577 }
 578
 579 /*
 580  * Visit all nodes and leaves of a btree.  Check that all pointers and
 581  * records are in order, that the keys reflect the records, and use a callback
 582  * so that the caller can verify individual records.
 583  */
 584 int
 585 xchk_btree(
 586         struct xfs_scrub                *sc,
 587         struct xfs_btree_cur            *cur,
 588         xchk_btree_rec_fn               scrub_fn,
 589         const struct xfs_owner_info     *oinfo,
 590         void                            *private)
 591 {
 592         struct xchk_btree               bs = {
 593                 .cur                    = cur,
 594                 .scrub_rec              = scrub_fn,
 595                 .oinfo                  = oinfo,
 596                 .firstrec               = true,
 597                 .private                = private,
 598                 .sc                     = sc,
 599         };
 600         union xfs_btree_ptr             ptr;
 601         union xfs_btree_ptr             *pp;
 602         union xfs_btree_rec             *recp;
 603         struct xfs_btree_block          *block;
 604         int                             level;
 605         struct xfs_buf                  *bp;
 606         struct check_owner              *co;
 607         struct check_owner              *n;
 608         int                             i;
 609         int                             error = 0;
 610
 611         /* Initialize scrub state */
 612         for (i = 0; i < XFS_BTREE_MAXLEVELS; i++)
 613                 bs.firstkey[i] = true;
 614         INIT_LIST_HEAD(&bs.to_check);
 615
 616         /* Don't try to check a tree with a height we can't handle. */
 617         if (cur->bc_nlevels > XFS_BTREE_MAXLEVELS) {
 618                 xchk_btree_set_corrupt(sc, cur, 0);
 619                 goto out;
 620         }
 621
 622         /*
 623          * Load the root of the btree.  The helper function absorbs
 624          * error codes for us.
 625          */
 626         level = cur->bc_nlevels - 1;
 627         cur->bc_ops->init_ptr_from_cur(cur, &ptr);
 628         if (!xchk_btree_ptr_ok(&bs, cur->bc_nlevels, &ptr))
 629                 goto out;
 630         error = xchk_btree_get_block(&bs, level, &ptr, &block, &bp);
 631         if (error || !block)
 632                 goto out;
 633
 634         cur->bc_ptrs[level] = 1;
 635
 636         while (level < cur->bc_nlevels) {
 637                 block = xfs_btree_get_block(cur, level, &bp);
 638
 639                 if (level == 0) {
 640                         /* End of leaf, pop back towards the root. */
 641                         if (cur->bc_ptrs[level] >
 642                             be16_to_cpu(block->bb_numrecs)) {
 643                                 xchk_btree_block_keys(&bs, level, block);
 644                                 if (level < cur->bc_nlevels - 1)
 645                                         cur->bc_ptrs[level + 1]++;
 646                                 level++;
 647                                 continue;
 648                         }
 649
 650                         /* Records in order for scrub? */
 651                         xchk_btree_rec(&bs);
 652
 653                         /* Call out to the record checker. */
 654                         recp = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
 655                         error = bs.scrub_rec(&bs, recp);
 656                         if (error)
 657                                 break;
 658                         if (xchk_should_terminate(sc, &error) ||
 659                             (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 660                                 break;
 661
 662                         cur->bc_ptrs[level]++;
 663                         continue;
 664                 }
 665
 666                 /* End of node, pop back towards the root. */
 667                 if (cur->bc_ptrs[level] > be16_to_cpu(block->bb_numrecs)) {
 668                         xchk_btree_block_keys(&bs, level, block);
 669                         if (level < cur->bc_nlevels - 1)
 670                                 cur->bc_ptrs[level + 1]++;
 671                         level++;
 672                         continue;
 673                 }
 674
 675                 /* Keys in order for scrub? */
 676                 xchk_btree_key(&bs, level);
 677
 678                 /* Drill another level deeper. */
 679                 pp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[level], block);
 680                 if (!xchk_btree_ptr_ok(&bs, level, pp)) {
 681                         cur->bc_ptrs[level]++;
 682                         continue;
 683                 }
 684                 level--;
 685                 error = xchk_btree_get_block(&bs, level, pp, &block, &bp);
 686                 if (error || !block)
 687                         goto out;
 688
 689                 cur->bc_ptrs[level] = 1;
 690         }
 691
 692 out:
 693         /* Process deferred owner checks on btree blocks. */
 694         list_for_each_entry_safe(co, n, &bs.to_check, list) {
 695                 if (!error && bs.cur)
 696                         error = xchk_btree_check_block_owner(&bs,
 697                                         co->level, co->daddr);
 698                 list_del(&co->list);
 699                 kmem_free(co);
 700         }
 701
 702         return error;
 703 }