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 xfs_scrub_setup_inode_bmap( 37 struct xfs_scrub_context *sc, 38 struct xfs_inode *ip) 39 { 40 int error; 41 42 error = xfs_scrub_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 = xfs_scrub_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 xfs_scrub_bmap_info { 82 struct xfs_scrub_context *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 xfs_scrub_bmap_get_rmap( 92 struct xfs_scrub_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 (!xfs_scrub_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 (!xfs_scrub_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 (!xfs_scrub_should_check_xref(info->sc, &error, 142 &info->sc->sa.rmap_cur)) 143 return false; 144 145 out: 146 if (!has_rmap) 147 xfs_scrub_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 xfs_scrub_bmap_xref_rmap( 155 struct xfs_scrub_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 || xfs_scrub_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 (!xfs_scrub_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 xfs_scrub_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 xfs_scrub_fblock_xref_set_corrupt(info->sc, 193 info->whichfork, irec->br_startoff); 194 } 195 196 if (rmap.rm_owner != owner) 197 xfs_scrub_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 xfs_scrub_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 xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork, 216 irec->br_startoff); 217 if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK) 218 xfs_scrub_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 xfs_scrub_bmap_rt_extent_xref( 225 struct xfs_scrub_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 xfs_scrub_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 xfs_scrub_bmap_extent_xref( 240 struct xfs_scrub_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 = xfs_scrub_ag_init(info->sc, agno, &info->sc->sa); 259 if (!xfs_scrub_fblock_process_error(info->sc, info->whichfork, 260 irec->br_startoff, &error)) 261 return; 262 263 xfs_scrub_xref_is_used_space(info->sc, agbno, len); 264 xfs_scrub_xref_is_not_inode_chunk(info->sc, agbno, len); 265 xfs_scrub_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 xfs_scrub_xref_is_not_shared(info->sc, agbno, 273 irec->br_blockcount); 274 break; 275 case XFS_COW_FORK: 276 xfs_scrub_xref_is_cow_staging(info->sc, agbno, 277 irec->br_blockcount); 278 break; 279 } 280 281 xfs_scrub_ag_free(info->sc, &info->sc->sa); 282 } 283 284 /* Scrub a single extent record. */ 285 STATIC int 286 xfs_scrub_bmap_extent( 287 struct xfs_inode *ip, 288 struct xfs_btree_cur *cur, 289 struct xfs_scrub_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 xfs_scrub_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 xfs_scrub_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 xfs_scrub_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 xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork, 324 irec->br_startoff); 325 if (irec->br_startblock + irec->br_blockcount <= irec->br_startblock) 326 xfs_scrub_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 xfs_scrub_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 xfs_scrub_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 xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork, 346 irec->br_startoff); 347 348 if (info->is_rt) 349 xfs_scrub_bmap_rt_extent_xref(info, ip, cur, irec); 350 else 351 xfs_scrub_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 xfs_scrub_bmapbt_rec( 360 struct xfs_scrub_btree *bs, 361 union xfs_btree_rec *rec) 362 { 363 struct xfs_bmbt_irec irec; 364 struct xfs_scrub_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 xfs_scrub_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 xfs_scrub_bmap_extent(ip, bs->cur, info, &irec); 389 } 390 391 /* Scan the btree records. */ 392 STATIC int 393 xfs_scrub_bmap_btree( 394 struct xfs_scrub_context *sc, 395 int whichfork, 396 struct xfs_scrub_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 = xfs_scrub_btree(sc, cur, xfs_scrub_bmapbt_rec, &oinfo, info); 407 xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : 408 XFS_BTREE_NOERROR); 409 return error; 410 } 411 412 struct xfs_scrub_bmap_check_rmap_info { 413 struct xfs_scrub_context *sc; 414 int whichfork; 415 struct xfs_iext_cursor icur; 416 }; 417 418 /* Can we find bmaps that fit this rmap? */ 419 STATIC int 420 xfs_scrub_bmap_check_rmap( 421 struct xfs_btree_cur *cur, 422 struct xfs_rmap_irec *rec, 423 void *priv) 424 { 425 struct xfs_bmbt_irec irec; 426 struct xfs_scrub_bmap_check_rmap_info *sbcri = priv; 427 struct xfs_ifork *ifp; 428 struct xfs_scrub_context *sc = sbcri->sc; 429 bool have_map; 430 431 /* Is this even the right fork? */ 432 if (rec->rm_owner != sc->ip->i_ino) 433 return 0; 434 if ((sbcri->whichfork == XFS_ATTR_FORK) ^ 435 !!(rec->rm_flags & XFS_RMAP_ATTR_FORK)) 436 return 0; 437 if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK) 438 return 0; 439 440 /* Now look up the bmbt record. */ 441 ifp = XFS_IFORK_PTR(sc->ip, sbcri->whichfork); 442 if (!ifp) { 443 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 444 rec->rm_offset); 445 goto out; 446 } 447 have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset, 448 &sbcri->icur, &irec); 449 if (!have_map) 450 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 451 rec->rm_offset); 452 /* 453 * bmap extent record lengths are constrained to 2^21 blocks in length 454 * because of space constraints in the on-disk metadata structure. 455 * However, rmap extent record lengths are constrained only by AG 456 * length, so we have to loop through the bmbt to make sure that the 457 * entire rmap is covered by bmbt records. 458 */ 459 while (have_map) { 460 if (irec.br_startoff != rec->rm_offset) 461 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 462 rec->rm_offset); 463 if (irec.br_startblock != XFS_AGB_TO_FSB(sc->mp, 464 cur->bc_private.a.agno, rec->rm_startblock)) 465 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 466 rec->rm_offset); 467 if (irec.br_blockcount > rec->rm_blockcount) 468 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 469 rec->rm_offset); 470 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 471 break; 472 rec->rm_startblock += irec.br_blockcount; 473 rec->rm_offset += irec.br_blockcount; 474 rec->rm_blockcount -= irec.br_blockcount; 475 if (rec->rm_blockcount == 0) 476 break; 477 have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec); 478 if (!have_map) 479 xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork, 480 rec->rm_offset); 481 } 482 483 out: 484 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 485 return XFS_BTREE_QUERY_RANGE_ABORT; 486 return 0; 487 } 488 489 /* Make sure each rmap has a corresponding bmbt entry. */ 490 STATIC int 491 xfs_scrub_bmap_check_ag_rmaps( 492 struct xfs_scrub_context *sc, 493 int whichfork, 494 xfs_agnumber_t agno) 495 { 496 struct xfs_scrub_bmap_check_rmap_info sbcri; 497 struct xfs_btree_cur *cur; 498 struct xfs_buf *agf; 499 int error; 500 501 error = xfs_alloc_read_agf(sc->mp, sc->tp, agno, 0, &agf); 502 if (error) 503 return error; 504 505 cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf, agno); 506 if (!cur) { 507 error = -ENOMEM; 508 goto out_agf; 509 } 510 511 sbcri.sc = sc; 512 sbcri.whichfork = whichfork; 513 error = xfs_rmap_query_all(cur, xfs_scrub_bmap_check_rmap, &sbcri); 514 if (error == XFS_BTREE_QUERY_RANGE_ABORT) 515 error = 0; 516 517 xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 518 out_agf: 519 xfs_trans_brelse(sc->tp, agf); 520 return error; 521 } 522 523 /* Make sure each rmap has a corresponding bmbt entry. */ 524 STATIC int 525 xfs_scrub_bmap_check_rmaps( 526 struct xfs_scrub_context *sc, 527 int whichfork) 528 { 529 loff_t size; 530 xfs_agnumber_t agno; 531 int error; 532 533 if (!xfs_sb_version_hasrmapbt(&sc->mp->m_sb) || 534 whichfork == XFS_COW_FORK || 535 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) 536 return 0; 537 538 /* Don't support realtime rmap checks yet. */ 539 if (XFS_IS_REALTIME_INODE(sc->ip) && whichfork == XFS_DATA_FORK) 540 return 0; 541 542 /* 543 * Only do this for complex maps that are in btree format, or for 544 * situations where we would seem to have a size but zero extents. 545 * The inode repair code can zap broken iforks, which means we have 546 * to flag this bmap as corrupt if there are rmaps that need to be 547 * reattached. 548 */ 549 switch (whichfork) { 550 case XFS_DATA_FORK: 551 size = i_size_read(VFS_I(sc->ip)); 552 break; 553 case XFS_ATTR_FORK: 554 size = XFS_IFORK_Q(sc->ip); 555 break; 556 default: 557 size = 0; 558 break; 559 } 560 if (XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_BTREE && 561 (size == 0 || XFS_IFORK_NEXTENTS(sc->ip, whichfork) > 0)) 562 return 0; 563 564 for (agno = 0; agno < sc->mp->m_sb.sb_agcount; agno++) { 565 error = xfs_scrub_bmap_check_ag_rmaps(sc, whichfork, agno); 566 if (error) 567 return error; 568 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 569 break; 570 } 571 572 return 0; 573 } 574 575 /* 576 * Scrub an inode fork's block mappings. 577 * 578 * First we scan every record in every btree block, if applicable. 579 * Then we unconditionally scan the incore extent cache. 580 */ 581 STATIC int 582 xfs_scrub_bmap( 583 struct xfs_scrub_context *sc, 584 int whichfork) 585 { 586 struct xfs_bmbt_irec irec; 587 struct xfs_scrub_bmap_info info = { NULL }; 588 struct xfs_mount *mp = sc->mp; 589 struct xfs_inode *ip = sc->ip; 590 struct xfs_ifork *ifp; 591 xfs_fileoff_t endoff; 592 struct xfs_iext_cursor icur; 593 int error = 0; 594 595 ifp = XFS_IFORK_PTR(ip, whichfork); 596 597 info.is_rt = whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip); 598 info.whichfork = whichfork; 599 info.is_shared = whichfork == XFS_DATA_FORK && xfs_is_reflink_inode(ip); 600 info.sc = sc; 601 602 switch (whichfork) { 603 case XFS_COW_FORK: 604 /* Non-existent CoW forks are ignorable. */ 605 if (!ifp) 606 goto out; 607 /* No CoW forks on non-reflink inodes/filesystems. */ 608 if (!xfs_is_reflink_inode(ip)) { 609 xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino); 610 goto out; 611 } 612 break; 613 case XFS_ATTR_FORK: 614 if (!ifp) 615 goto out_check_rmap; 616 if (!xfs_sb_version_hasattr(&mp->m_sb) && 617 !xfs_sb_version_hasattr2(&mp->m_sb)) 618 xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino); 619 break; 620 default: 621 ASSERT(whichfork == XFS_DATA_FORK); 622 break; 623 } 624 625 /* Check the fork values */ 626 switch (XFS_IFORK_FORMAT(ip, whichfork)) { 627 case XFS_DINODE_FMT_UUID: 628 case XFS_DINODE_FMT_DEV: 629 case XFS_DINODE_FMT_LOCAL: 630 /* No mappings to check. */ 631 goto out; 632 case XFS_DINODE_FMT_EXTENTS: 633 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 634 xfs_scrub_fblock_set_corrupt(sc, whichfork, 0); 635 goto out; 636 } 637 break; 638 case XFS_DINODE_FMT_BTREE: 639 if (whichfork == XFS_COW_FORK) { 640 xfs_scrub_fblock_set_corrupt(sc, whichfork, 0); 641 goto out; 642 } 643 644 error = xfs_scrub_bmap_btree(sc, whichfork, &info); 645 if (error) 646 goto out; 647 break; 648 default: 649 xfs_scrub_fblock_set_corrupt(sc, whichfork, 0); 650 goto out; 651 } 652 653 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 654 goto out; 655 656 /* Now try to scrub the in-memory extent list. */ 657 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 658 error = xfs_iread_extents(sc->tp, ip, whichfork); 659 if (!xfs_scrub_fblock_process_error(sc, whichfork, 0, &error)) 660 goto out; 661 } 662 663 /* Find the offset of the last extent in the mapping. */ 664 error = xfs_bmap_last_offset(ip, &endoff, whichfork); 665 if (!xfs_scrub_fblock_process_error(sc, whichfork, 0, &error)) 666 goto out; 667 668 /* Scrub extent records. */ 669 info.lastoff = 0; 670 ifp = XFS_IFORK_PTR(ip, whichfork); 671 for_each_xfs_iext(ifp, &icur, &irec) { 672 if (xfs_scrub_should_terminate(sc, &error) || 673 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) 674 break; 675 if (isnullstartblock(irec.br_startblock)) 676 continue; 677 if (irec.br_startoff >= endoff) { 678 xfs_scrub_fblock_set_corrupt(sc, whichfork, 679 irec.br_startoff); 680 goto out; 681 } 682 error = xfs_scrub_bmap_extent(ip, NULL, &info, &irec); 683 if (error) 684 goto out; 685 } 686 687 out_check_rmap: 688 error = xfs_scrub_bmap_check_rmaps(sc, whichfork); 689 if (!xfs_scrub_fblock_xref_process_error(sc, whichfork, 0, &error)) 690 goto out; 691 out: 692 return error; 693 } 694 695 /* Scrub an inode's data fork. */ 696 int 697 xfs_scrub_bmap_data( 698 struct xfs_scrub_context *sc) 699 { 700 return xfs_scrub_bmap(sc, XFS_DATA_FORK); 701 } 702 703 /* Scrub an inode's attr fork. */ 704 int 705 xfs_scrub_bmap_attr( 706 struct xfs_scrub_context *sc) 707 { 708 return xfs_scrub_bmap(sc, XFS_ATTR_FORK); 709 } 710 711 /* Scrub an inode's CoW fork. */ 712 int 713 xfs_scrub_bmap_cow( 714 struct xfs_scrub_context *sc) 715 { 716 if (!xfs_is_reflink_inode(sc->ip)) 717 return -ENOENT; 718 719 return xfs_scrub_bmap(sc, XFS_COW_FORK); 720 } 721