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