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_inode_fork.h" 20 #include "xfs_alloc.h" 21 #include "xfs_rtalloc.h" 22 #include "xfs_bmap.h" 23 #include "xfs_bmap_util.h" 24 #include "xfs_bmap_btree.h" 25 #include "xfs_rmap.h" 26 #include "xfs_rmap_btree.h" 27 #include "xfs_refcount.h" 28 #include "scrub/xfs_scrub.h" 29 #include "scrub/scrub.h" 30 #include "scrub/common.h" 31 #include "scrub/btree.h" 32 #include "scrub/trace.h" 33 34 /* Set us up with an inode's bmap. */ 35 int 36 xchk_setup_inode_bmap( 37 struct xfs_scrub *sc, 38 struct xfs_inode *ip) 39 { 40 int error; 41 42 error = xchk_get_inode(sc, ip); 43 if (error) 44 goto out; 45 46 sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL; 47 xfs_ilock(sc->ip, sc->ilock_flags); 48 49 /* 50 * We don't want any ephemeral data fork updates sitting around 51 * while we inspect block mappings, so wait for directio to finish 52 * and flush dirty data if we have delalloc reservations. 53 */ 54 if (S_ISREG(VFS_I(sc->ip)->i_mode) && 55 sc->sm->sm_type == XFS_SCRUB_TYPE_BMBTD) { 56 inode_dio_wait(VFS_I(sc->ip)); 57 error = filemap_write_and_wait(VFS_I(sc->ip)->i_mapping); 58 if (error) 59 goto out; 60 } 61 62 /* Got the inode, lock it and we're ready to go. */ 63 error = xchk_trans_alloc(sc, 0); 64 if (error) 65 goto out; 66 sc->ilock_flags |= XFS_ILOCK_EXCL; 67 xfs_ilock(sc->ip, XFS_ILOCK_EXCL); 68 69 out: 70 /* scrub teardown will unlock and release the inode */ 71 return error; 72 } 73 74 /* 75 * Inode fork block mapping (BMBT) scrubber. 76 * More complex than the others because we have to scrub 77 * all the extents regardless of whether or not the fork 78 * is in btree format. 79 */ 80 81 struct xchk_bmap_info { 82 struct xfs_scrub *sc; 83 xfs_fileoff_t lastoff; 84 bool is_rt; 85 bool is_shared; 86 int whichfork; 87 }; 88 89 /* Look for a corresponding rmap for this irec. */ 90 static inline bool 91 xchk_bmap_get_rmap( 92 struct xchk_bmap_info *info, 93 struct xfs_bmbt_irec *irec, 94 xfs_agblock_t agbno, 95 uint64_t owner, 96 struct xfs_rmap_irec *rmap) 97 { 98 xfs_fileoff_t offset; 99 unsigned int rflags = 0; 100 int has_rmap; 101 int error; 102 103 if (info->whichfork == XFS_ATTR_FORK) 104 rflags |= XFS_RMAP_ATTR_FORK; 105 106 /* 107 * CoW staging extents are owned (on disk) by the refcountbt, so 108 * their rmaps do not have offsets. 109 */ 110 if (info->whichfork == XFS_COW_FORK) 111 offset = 0; 112 else 113 offset = irec->br_startoff; 114 115 /* 116 * If the caller thinks this could be a shared bmbt extent (IOWs, 117 * any data fork extent of a reflink inode) then we have to use the 118 * range rmap lookup to make sure we get the correct owner/offset. 119 */ 120 if (info->is_shared) { 121 error = xfs_rmap_lookup_le_range(info->sc->sa.rmap_cur, agbno, 122 owner, offset, rflags, rmap, &has_rmap); 123 if (!xchk_should_check_xref(info->sc, &error, 124 &info->sc->sa.rmap_cur)) 125 return false; 126 goto out; 127 } 128 129 /* 130 * Otherwise, use the (faster) regular lookup. 131 */ 132 error = xfs_rmap_lookup_le(info->sc->sa.rmap_cur, agbno, 0, owner, 133 offset, rflags, &has_rmap); 134 if (!xchk_should_check_xref(info->sc, &error, 135 &info->sc->sa.rmap_cur)) 136 return false; 137 if (!has_rmap) 138 goto out; 139 140 error = xfs_rmap_get_rec(info->sc->sa.rmap_cur, rmap, &has_rmap); 141 if (!xchk_should_check_xref(info->sc, &error, 142 &info->sc->sa.rmap_cur)) 143 return false; 144 145 out: 146 if (!has_rmap) 147 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 148 irec->br_startoff); 149 return has_rmap; 150 } 151 152 /* Make sure that we have rmapbt records for this extent. */ 153 STATIC void 154 xchk_bmap_xref_rmap( 155 struct xchk_bmap_info *info, 156 struct xfs_bmbt_irec *irec, 157 xfs_agblock_t agbno) 158 { 159 struct xfs_rmap_irec rmap; 160 unsigned long long rmap_end; 161 uint64_t owner; 162 163 if (!info->sc->sa.rmap_cur || xchk_skip_xref(info->sc->sm)) 164 return; 165 166 if (info->whichfork == XFS_COW_FORK) 167 owner = XFS_RMAP_OWN_COW; 168 else 169 owner = info->sc->ip->i_ino; 170 171 /* Find the rmap record for this irec. */ 172 if (!xchk_bmap_get_rmap(info, irec, agbno, owner, &rmap)) 173 return; 174 175 /* Check the rmap. */ 176 rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount; 177 if (rmap.rm_startblock > agbno || 178 agbno + irec->br_blockcount > rmap_end) 179 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 180 irec->br_startoff); 181 182 /* 183 * Check the logical offsets if applicable. CoW staging extents 184 * don't track logical offsets since the mappings only exist in 185 * memory. 186 */ 187 if (info->whichfork != XFS_COW_FORK) { 188 rmap_end = (unsigned long long)rmap.rm_offset + 189 rmap.rm_blockcount; 190 if (rmap.rm_offset > irec->br_startoff || 191 irec->br_startoff + irec->br_blockcount > rmap_end) 192 xchk_fblock_xref_set_corrupt(info->sc, 193 info->whichfork, irec->br_startoff); 194 } 195 196 if (rmap.rm_owner != owner) 197 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 198 irec->br_startoff); 199 200 /* 201 * Check for discrepancies between the unwritten flag in the irec and 202 * the rmap. Note that the (in-memory) CoW fork distinguishes between 203 * unwritten and written extents, but we don't track that in the rmap 204 * records because the blocks are owned (on-disk) by the refcountbt, 205 * which doesn't track unwritten state. 206 */ 207 if (owner != XFS_RMAP_OWN_COW && 208 irec->br_state == XFS_EXT_UNWRITTEN && 209 !(rmap.rm_flags & XFS_RMAP_UNWRITTEN)) 210 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 211 irec->br_startoff); 212 213 if (info->whichfork == XFS_ATTR_FORK && 214 !(rmap.rm_flags & XFS_RMAP_ATTR_FORK)) 215 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 216 irec->br_startoff); 217 if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK) 218 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork, 219 irec->br_startoff); 220 } 221 222 /* Cross-reference a single rtdev extent record. */ 223 STATIC void 224 xchk_bmap_rt_extent_xref( 225 struct xchk_bmap_info *info, 226 struct xfs_inode *ip, 227 struct xfs_btree_cur *cur, 228 struct xfs_bmbt_irec *irec) 229 { 230 if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 231 return; 232 233 xchk_xref_is_used_rt_space(info->sc, irec->br_startblock, 234 irec->br_blockcount); 235 } 236 237 /* Cross-reference a single datadev extent record. */ 238 STATIC void 239 xchk_bmap_extent_xref( 240 struct xchk_bmap_info *info, 241 struct xfs_inode *ip, 242 struct xfs_btree_cur *cur, 243 struct xfs_bmbt_irec *irec) 244 { 245 struct xfs_mount *mp = info->sc->mp; 246 xfs_agnumber_t agno; 247 xfs_agblock_t agbno; 248 xfs_extlen_t len; 249 int error; 250 251 if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 252 return; 253 254 agno = XFS_FSB_TO_AGNO(mp, irec->br_startblock); 255 agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock); 256 len = irec->br_blockcount; 257 258 error = xchk_ag_init(info->sc, agno, &info->sc->sa); 259 if (!xchk_fblock_process_error(info->sc, info->whichfork, 260 irec->br_startoff, &error)) 261 return; 262 263 xchk_xref_is_used_space(info->sc, agbno, len); 264 xchk_xref_is_not_inode_chunk(info->sc, agbno, len); 265 xchk_bmap_xref_rmap(info, irec, agbno); 266 switch (info->whichfork) { 267 case XFS_DATA_FORK: 268 if (xfs_is_reflink_inode(info->sc->ip)) 269 break; 270 /* fall through */ 271 case XFS_ATTR_FORK: 272 xchk_xref_is_not_shared(info->sc, agbno, 273 irec->br_blockcount); 274 break; 275 case XFS_COW_FORK: 276 xchk_xref_is_cow_staging(info->sc, agbno, 277 irec->br_blockcount); 278 break; 279 } 280 281 xchk_ag_free(info->sc, &info->sc->sa); 282 } 283 284 /* Scrub a single extent record. */ 285 STATIC int 286 xchk_bmap_extent( 287 struct xfs_inode *ip, 288 struct xfs_btree_cur *cur, 289 struct xchk_bmap_info *info, 290 struct xfs_bmbt_irec *irec) 291 { 292 struct xfs_mount *mp = info->sc->mp; 293 struct xfs_buf *bp = NULL; 294 xfs_filblks_t end; 295 int error = 0; 296 297 if (cur) 298 xfs_btree_get_block(cur, 0, &bp); 299 300 /* 301 * Check for out-of-order extents. This record could have come 302 * from the incore list, for which there is no ordering check. 303 */ 304 if (irec->br_startoff < info->lastoff) 305 xchk_fblock_set_corrupt(info->sc, info->whichfork, 306 irec->br_startoff); 307 308 /* There should never be a "hole" extent in either extent list. */ 309 if (irec->br_startblock == HOLESTARTBLOCK) 310 xchk_fblock_set_corrupt(info->sc, info->whichfork, 311 irec->br_startoff); 312 313 /* 314 * Check for delalloc extents. We never iterate the ones in the 315 * in-core extent scan, and we should never see these in the bmbt. 316 */ 317 if (isnullstartblock(irec->br_startblock)) 318 xchk_fblock_set_corrupt(info->sc, info->whichfork, 319 irec->br_startoff); 320 321 /* Make sure the extent points to a valid place. */ 322 if (irec->br_blockcount > MAXEXTLEN) 323 xchk_fblock_set_corrupt(info->sc, info->whichfork, 324 irec->br_startoff); 325 if (irec->br_startblock + irec->br_blockcount <= irec->br_startblock) 326 xchk_fblock_set_corrupt(info->sc, info->whichfork, 327 irec->br_startoff); 328 end = irec->br_startblock + irec->br_blockcount - 1; 329 if (info->is_rt && 330 (!xfs_verify_rtbno(mp, irec->br_startblock) || 331 !xfs_verify_rtbno(mp, end))) 332 xchk_fblock_set_corrupt(info->sc, info->whichfork, 333 irec->br_startoff); 334 if (!info->is_rt && 335 (!xfs_verify_fsbno(mp, irec->br_startblock) || 336 !xfs_verify_fsbno(mp, end) || 337 XFS_FSB_TO_AGNO(mp, irec->br_startblock) != 338 XFS_FSB_TO_AGNO(mp, end))) 339 xchk_fblock_set_corrupt(info->sc, info->whichfork, 340 irec->br_startoff); 341 342 /* We don't allow unwritten extents on attr forks. */ 343 if (irec->br_state == XFS_EXT_UNWRITTEN && 344 info->whichfork == XFS_ATTR_FORK) 345 xchk_fblock_set_corrupt(info->sc, info->whichfork, 346 irec->br_startoff); 347 348 if (info->is_rt) 349 xchk_bmap_rt_extent_xref(info, ip, cur, irec); 350 else 351 xchk_bmap_extent_xref(info, ip, cur, irec); 352 353 info->lastoff = irec->br_startoff + irec->br_blockcount; 354 return error; 355 } 356 357 /* Scrub a bmbt record. */ 358 STATIC int 359 xchk_bmapbt_rec( 360 struct xchk_btree *bs, 361 union xfs_btree_rec *rec) 362 { 363 struct xfs_bmbt_irec irec; 364 struct xchk_bmap_info *info = bs->private; 365 struct xfs_inode *ip = bs->cur->bc_private.b.ip; 366 struct xfs_buf *bp = NULL; 367 struct xfs_btree_block *block; 368 uint64_t owner; 369 int i; 370 371 /* 372 * Check the owners of the btree blocks up to the level below 373 * the root since the verifiers don't do that. 374 */ 375 if (xfs_sb_version_hascrc(&bs->cur->bc_mp->m_sb) && 376 bs->cur->bc_ptrs[0] == 1) { 377 for (i = 0; i < bs->cur->bc_nlevels - 1; i++) { 378 block = xfs_btree_get_block(bs->cur, i, &bp); 379 owner = be64_to_cpu(block->bb_u.l.bb_owner); 380 if (owner != ip->i_ino) 381 xchk_fblock_set_corrupt(bs->sc, 382 info->whichfork, 0); 383 } 384 } 385 386 /* Set up the in-core record and scrub it. */ 387 xfs_bmbt_disk_get_all(&rec->bmbt, &irec); 388 return xchk_bmap_extent(ip, bs->cur, info, &irec); 389 } 390 391 /* Scan the btree records. */ 392 STATIC int 393 xchk_bmap_btree( 394 struct xfs_scrub *sc, 395 int whichfork, 396 struct xchk_bmap_info *info) 397 { 398 struct xfs_owner_info oinfo; 399 struct xfs_mount *mp = sc->mp; 400 struct xfs_inode *ip = sc->ip; 401 struct xfs_btree_cur *cur; 402 int error; 403 404 cur = xfs_bmbt_init_cursor(mp, sc->tp, ip, whichfork); 405 xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 406 error = xchk_btree(sc, cur, xchk_bmapbt_rec, &oinfo, info); 407 xfs_btree_del_cursor(cur, error); 408 return error; 409 } 410 411 struct xchk_bmap_check_rmap_info { 412 struct xfs_scrub *sc; 413 int whichfork; 414 struct xfs_iext_cursor icur; 415 }; 416 417 /* Can we find bmaps that fit this rmap? */ 418 STATIC int 419 xchk_bmap_check_rmap( 420 struct xfs_btree_cur *cur, 421 struct xfs_rmap_irec *rec, 422 void *priv) 423 { 424 struct xfs_bmbt_irec irec; 425 struct xchk_bmap_check_rmap_info *sbcri = priv; 426 struct xfs_ifork *ifp; 427 struct xfs_scrub *sc = sbcri->sc; 428 bool have_map; 429 430 /* Is this even the right fork? */ 431 if (rec->rm_owner != sc->ip->i_ino) 432 return 0; 433 if ((sbcri->whichfork == XFS_ATTR_FORK) ^ 434 !!(rec->rm_flags & XFS_RMAP_ATTR_FORK)) 435 return 0; 436 if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK) 437 return 0; 438 439 /* Now look up the bmbt record. */ 440 ifp = XFS_IFORK_PTR(sc->ip, sbcri->whichfork); 441 if (!ifp) { 442 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 443 rec->rm_offset); 444 goto out; 445 } 446 have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset, 447 &sbcri->icur, &irec); 448 if (!have_map) 449 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 450 rec->rm_offset); 451 /* 452 * bmap extent record lengths are constrained to 2^21 blocks in length 453 * because of space constraints in the on-disk metadata structure. 454 * However, rmap extent record lengths are constrained only by AG 455 * length, so we have to loop through the bmbt to make sure that the 456 * entire rmap is covered by bmbt records. 457 */ 458 while (have_map) { 459 if (irec.br_startoff != rec->rm_offset) 460 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 461 rec->rm_offset); 462 if (irec.br_startblock != XFS_AGB_TO_FSB(sc->mp, 463 cur->bc_private.a.agno, rec->rm_startblock)) 464 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 465 rec->rm_offset); 466 if (irec.br_blockcount > rec->rm_blockcount) 467 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 468 rec->rm_offset); 469 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 470 break; 471 rec->rm_startblock += irec.br_blockcount; 472 rec->rm_offset += irec.br_blockcount; 473 rec->rm_blockcount -= irec.br_blockcount; 474 if (rec->rm_blockcount == 0) 475 break; 476 have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec); 477 if (!have_map) 478 xchk_fblock_set_corrupt(sc, sbcri->whichfork, 479 rec->rm_offset); 480 } 481 482 out: 483 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 484 return XFS_BTREE_QUERY_RANGE_ABORT; 485 return 0; 486 } 487 488 /* Make sure each rmap has a corresponding bmbt entry. */ 489 STATIC int 490 xchk_bmap_check_ag_rmaps( 491 struct xfs_scrub *sc, 492 int whichfork, 493 xfs_agnumber_t agno) 494 { 495 struct xchk_bmap_check_rmap_info sbcri; 496 struct xfs_btree_cur *cur; 497 struct xfs_buf *agf; 498 int error; 499 500 error = xfs_alloc_read_agf(sc->mp, sc->tp, agno, 0, &agf); 501 if (error) 502 return error; 503 504 cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf, agno); 505 if (!cur) { 506 error = -ENOMEM; 507 goto out_agf; 508 } 509 510 sbcri.sc = sc; 511 sbcri.whichfork = whichfork; 512 error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri); 513 if (error == XFS_BTREE_QUERY_RANGE_ABORT) 514 error = 0; 515 516 xfs_btree_del_cursor(cur, error); 517 out_agf: 518 xfs_trans_brelse(sc->tp, agf); 519 return error; 520 } 521 522 /* Make sure each rmap has a corresponding bmbt entry. */ 523 STATIC int 524 xchk_bmap_check_rmaps( 525 struct xfs_scrub *sc, 526 int whichfork) 527 { 528 loff_t size; 529 xfs_agnumber_t agno; 530 int error; 531 532 if (!xfs_sb_version_hasrmapbt(&sc->mp->m_sb) || 533 whichfork == XFS_COW_FORK || 534 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) 535 return 0; 536 537 /* Don't support realtime rmap checks yet. */ 538 if (XFS_IS_REALTIME_INODE(sc->ip) && whichfork == XFS_DATA_FORK) 539 return 0; 540 541 /* 542 * Only do this for complex maps that are in btree format, or for 543 * situations where we would seem to have a size but zero extents. 544 * The inode repair code can zap broken iforks, which means we have 545 * to flag this bmap as corrupt if there are rmaps that need to be 546 * reattached. 547 */ 548 switch (whichfork) { 549 case XFS_DATA_FORK: 550 size = i_size_read(VFS_I(sc->ip)); 551 break; 552 case XFS_ATTR_FORK: 553 size = XFS_IFORK_Q(sc->ip); 554 break; 555 default: 556 size = 0; 557 break; 558 } 559 if (XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_BTREE && 560 (size == 0 || XFS_IFORK_NEXTENTS(sc->ip, whichfork) > 0)) 561 return 0; 562 563 for (agno = 0; agno < sc->mp->m_sb.sb_agcount; agno++) { 564 error = xchk_bmap_check_ag_rmaps(sc, whichfork, agno); 565 if (error) 566 return error; 567 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 568 break; 569 } 570 571 return 0; 572 } 573 574 /* 575 * Scrub an inode fork's block mappings. 576 * 577 * First we scan every record in every btree block, if applicable. 578 * Then we unconditionally scan the incore extent cache. 579 */ 580 STATIC int 581 xchk_bmap( 582 struct xfs_scrub *sc, 583 int whichfork) 584 { 585 struct xfs_bmbt_irec irec; 586 struct xchk_bmap_info info = { NULL }; 587 struct xfs_mount *mp = sc->mp; 588 struct xfs_inode *ip = sc->ip; 589 struct xfs_ifork *ifp; 590 xfs_fileoff_t endoff; 591 struct xfs_iext_cursor icur; 592 int error = 0; 593 594 ifp = XFS_IFORK_PTR(ip, whichfork); 595 596 info.is_rt = whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip); 597 info.whichfork = whichfork; 598 info.is_shared = whichfork == XFS_DATA_FORK && xfs_is_reflink_inode(ip); 599 info.sc = sc; 600 601 switch (whichfork) { 602 case XFS_COW_FORK: 603 /* Non-existent CoW forks are ignorable. */ 604 if (!ifp) 605 goto out; 606 /* No CoW forks on non-reflink inodes/filesystems. */ 607 if (!xfs_is_reflink_inode(ip)) { 608 xchk_ino_set_corrupt(sc, sc->ip->i_ino); 609 goto out; 610 } 611 break; 612 case XFS_ATTR_FORK: 613 if (!ifp) 614 goto out_check_rmap; 615 if (!xfs_sb_version_hasattr(&mp->m_sb) && 616 !xfs_sb_version_hasattr2(&mp->m_sb)) 617 xchk_ino_set_corrupt(sc, sc->ip->i_ino); 618 break; 619 default: 620 ASSERT(whichfork == XFS_DATA_FORK); 621 break; 622 } 623 624 /* Check the fork values */ 625 switch (XFS_IFORK_FORMAT(ip, whichfork)) { 626 case XFS_DINODE_FMT_UUID: 627 case XFS_DINODE_FMT_DEV: 628 case XFS_DINODE_FMT_LOCAL: 629 /* No mappings to check. */ 630 goto out; 631 case XFS_DINODE_FMT_EXTENTS: 632 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 633 xchk_fblock_set_corrupt(sc, whichfork, 0); 634 goto out; 635 } 636 break; 637 case XFS_DINODE_FMT_BTREE: 638 if (whichfork == XFS_COW_FORK) { 639 xchk_fblock_set_corrupt(sc, whichfork, 0); 640 goto out; 641 } 642 643 error = xchk_bmap_btree(sc, whichfork, &info); 644 if (error) 645 goto out; 646 break; 647 default: 648 xchk_fblock_set_corrupt(sc, whichfork, 0); 649 goto out; 650 } 651 652 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 653 goto out; 654 655 /* Now try to scrub the in-memory extent list. */ 656 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 657 error = xfs_iread_extents(sc->tp, ip, whichfork); 658 if (!xchk_fblock_process_error(sc, whichfork, 0, &error)) 659 goto out; 660 } 661 662 /* Find the offset of the last extent in the mapping. */ 663 error = xfs_bmap_last_offset(ip, &endoff, whichfork); 664 if (!xchk_fblock_process_error(sc, whichfork, 0, &error)) 665 goto out; 666 667 /* Scrub extent records. */ 668 info.lastoff = 0; 669 ifp = XFS_IFORK_PTR(ip, whichfork); 670 for_each_xfs_iext(ifp, &icur, &irec) { 671 if (xchk_should_terminate(sc, &error) || 672 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) 673 break; 674 if (isnullstartblock(irec.br_startblock)) 675 continue; 676 if (irec.br_startoff >= endoff) { 677 xchk_fblock_set_corrupt(sc, whichfork, 678 irec.br_startoff); 679 goto out; 680 } 681 error = xchk_bmap_extent(ip, NULL, &info, &irec); 682 if (error) 683 goto out; 684 } 685 686 out_check_rmap: 687 error = xchk_bmap_check_rmaps(sc, whichfork); 688 if (!xchk_fblock_xref_process_error(sc, whichfork, 0, &error)) 689 goto out; 690 out: 691 return error; 692 } 693 694 /* Scrub an inode's data fork. */ 695 int 696 xchk_bmap_data( 697 struct xfs_scrub *sc) 698 { 699 return xchk_bmap(sc, XFS_DATA_FORK); 700 } 701 702 /* Scrub an inode's attr fork. */ 703 int 704 xchk_bmap_attr( 705 struct xfs_scrub *sc) 706 { 707 return xchk_bmap(sc, XFS_ATTR_FORK); 708 } 709 710 /* Scrub an inode's CoW fork. */ 711 int 712 xchk_bmap_cow( 713 struct xfs_scrub *sc) 714 { 715 if (!xfs_is_reflink_inode(sc->ip)) 716 return -ENOENT; 717 718 return xchk_bmap(sc, XFS_COW_FORK); 719 } 720