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_btree.h" 13#include "xfs_sb.h" 14#include "xfs_alloc.h" 15#include "xfs_ialloc.h" 16#include "xfs_rmap.h" 17#include "scrub/scrub.h" 18#include "scrub/common.h" 19 20/* Superblock */ 21 22/* Cross-reference with the other btrees. */ 23STATIC void 24xchk_superblock_xref( 25 struct xfs_scrub *sc, 26 struct xfs_buf *bp) 27{ 28 struct xfs_mount *mp = sc->mp; 29 xfs_agnumber_t agno = sc->sm->sm_agno; 30 xfs_agblock_t agbno; 31 int error; 32 33 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 34 return; 35 36 agbno = XFS_SB_BLOCK(mp); 37 38 error = xchk_ag_init(sc, agno, &sc->sa); 39 if (!xchk_xref_process_error(sc, agno, agbno, &error)) 40 return; 41 42 xchk_xref_is_used_space(sc, agbno, 1); 43 xchk_xref_is_not_inode_chunk(sc, agbno, 1); 44 xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS); 45 xchk_xref_is_not_shared(sc, agbno, 1); 46 47 /* scrub teardown will take care of sc->sa for us */ 48} 49 50/* 51 * Scrub the filesystem superblock. 52 * 53 * Note: We do /not/ attempt to check AG 0's superblock. Mount is 54 * responsible for validating all the geometry information in sb 0, so 55 * if the filesystem is capable of initiating online scrub, then clearly 56 * sb 0 is ok and we can use its information to check everything else. 57 */ 58int 59xchk_superblock( 60 struct xfs_scrub *sc) 61{ 62 struct xfs_mount *mp = sc->mp; 63 struct xfs_buf *bp; 64 struct xfs_dsb *sb; 65 xfs_agnumber_t agno; 66 uint32_t v2_ok; 67 __be32 features_mask; 68 int error; 69 __be16 vernum_mask; 70 71 agno = sc->sm->sm_agno; 72 if (agno == 0) 73 return 0; 74 75 error = xfs_sb_read_secondary(mp, sc->tp, agno, &bp); 76 /* 77 * The superblock verifier can return several different error codes 78 * if it thinks the superblock doesn't look right. For a mount these 79 * would all get bounced back to userspace, but if we're here then the 80 * fs mounted successfully, which means that this secondary superblock 81 * is simply incorrect. Treat all these codes the same way we treat 82 * any corruption. 83 */ 84 switch (error) { 85 case -EINVAL: /* also -EWRONGFS */ 86 case -ENOSYS: 87 case -EFBIG: 88 error = -EFSCORRUPTED; 89 default: 90 break; 91 } 92 if (!xchk_process_error(sc, agno, XFS_SB_BLOCK(mp), &error)) 93 return error; 94 95 sb = bp->b_addr; 96 97 /* 98 * Verify the geometries match. Fields that are permanently 99 * set by mkfs are checked; fields that can be updated later 100 * (and are not propagated to backup superblocks) are preen 101 * checked. 102 */ 103 if (sb->sb_blocksize != cpu_to_be32(mp->m_sb.sb_blocksize)) 104 xchk_block_set_corrupt(sc, bp); 105 106 if (sb->sb_dblocks != cpu_to_be64(mp->m_sb.sb_dblocks)) 107 xchk_block_set_corrupt(sc, bp); 108 109 if (sb->sb_rblocks != cpu_to_be64(mp->m_sb.sb_rblocks)) 110 xchk_block_set_corrupt(sc, bp); 111 112 if (sb->sb_rextents != cpu_to_be64(mp->m_sb.sb_rextents)) 113 xchk_block_set_corrupt(sc, bp); 114 115 if (!uuid_equal(&sb->sb_uuid, &mp->m_sb.sb_uuid)) 116 xchk_block_set_preen(sc, bp); 117 118 if (sb->sb_logstart != cpu_to_be64(mp->m_sb.sb_logstart)) 119 xchk_block_set_corrupt(sc, bp); 120 121 if (sb->sb_rootino != cpu_to_be64(mp->m_sb.sb_rootino)) 122 xchk_block_set_preen(sc, bp); 123 124 if (sb->sb_rbmino != cpu_to_be64(mp->m_sb.sb_rbmino)) 125 xchk_block_set_preen(sc, bp); 126 127 if (sb->sb_rsumino != cpu_to_be64(mp->m_sb.sb_rsumino)) 128 xchk_block_set_preen(sc, bp); 129 130 if (sb->sb_rextsize != cpu_to_be32(mp->m_sb.sb_rextsize)) 131 xchk_block_set_corrupt(sc, bp); 132 133 if (sb->sb_agblocks != cpu_to_be32(mp->m_sb.sb_agblocks)) 134 xchk_block_set_corrupt(sc, bp); 135 136 if (sb->sb_agcount != cpu_to_be32(mp->m_sb.sb_agcount)) 137 xchk_block_set_corrupt(sc, bp); 138 139 if (sb->sb_rbmblocks != cpu_to_be32(mp->m_sb.sb_rbmblocks)) 140 xchk_block_set_corrupt(sc, bp); 141 142 if (sb->sb_logblocks != cpu_to_be32(mp->m_sb.sb_logblocks)) 143 xchk_block_set_corrupt(sc, bp); 144 145 /* Check sb_versionnum bits that are set at mkfs time. */ 146 vernum_mask = cpu_to_be16(~XFS_SB_VERSION_OKBITS | 147 XFS_SB_VERSION_NUMBITS | 148 XFS_SB_VERSION_ALIGNBIT | 149 XFS_SB_VERSION_DALIGNBIT | 150 XFS_SB_VERSION_SHAREDBIT | 151 XFS_SB_VERSION_LOGV2BIT | 152 XFS_SB_VERSION_SECTORBIT | 153 XFS_SB_VERSION_EXTFLGBIT | 154 XFS_SB_VERSION_DIRV2BIT); 155 if ((sb->sb_versionnum & vernum_mask) != 156 (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask)) 157 xchk_block_set_corrupt(sc, bp); 158 159 /* Check sb_versionnum bits that can be set after mkfs time. */ 160 vernum_mask = cpu_to_be16(XFS_SB_VERSION_ATTRBIT | 161 XFS_SB_VERSION_NLINKBIT | 162 XFS_SB_VERSION_QUOTABIT); 163 if ((sb->sb_versionnum & vernum_mask) != 164 (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask)) 165 xchk_block_set_preen(sc, bp); 166 167 if (sb->sb_sectsize != cpu_to_be16(mp->m_sb.sb_sectsize)) 168 xchk_block_set_corrupt(sc, bp); 169 170 if (sb->sb_inodesize != cpu_to_be16(mp->m_sb.sb_inodesize)) 171 xchk_block_set_corrupt(sc, bp); 172 173 if (sb->sb_inopblock != cpu_to_be16(mp->m_sb.sb_inopblock)) 174 xchk_block_set_corrupt(sc, bp); 175 176 if (memcmp(sb->sb_fname, mp->m_sb.sb_fname, sizeof(sb->sb_fname))) 177 xchk_block_set_preen(sc, bp); 178 179 if (sb->sb_blocklog != mp->m_sb.sb_blocklog) 180 xchk_block_set_corrupt(sc, bp); 181 182 if (sb->sb_sectlog != mp->m_sb.sb_sectlog) 183 xchk_block_set_corrupt(sc, bp); 184 185 if (sb->sb_inodelog != mp->m_sb.sb_inodelog) 186 xchk_block_set_corrupt(sc, bp); 187 188 if (sb->sb_inopblog != mp->m_sb.sb_inopblog) 189 xchk_block_set_corrupt(sc, bp); 190 191 if (sb->sb_agblklog != mp->m_sb.sb_agblklog) 192 xchk_block_set_corrupt(sc, bp); 193 194 if (sb->sb_rextslog != mp->m_sb.sb_rextslog) 195 xchk_block_set_corrupt(sc, bp); 196 197 if (sb->sb_imax_pct != mp->m_sb.sb_imax_pct) 198 xchk_block_set_preen(sc, bp); 199 200 /* 201 * Skip the summary counters since we track them in memory anyway. 202 * sb_icount, sb_ifree, sb_fdblocks, sb_frexents 203 */ 204 205 if (sb->sb_uquotino != cpu_to_be64(mp->m_sb.sb_uquotino)) 206 xchk_block_set_preen(sc, bp); 207 208 if (sb->sb_gquotino != cpu_to_be64(mp->m_sb.sb_gquotino)) 209 xchk_block_set_preen(sc, bp); 210 211 /* 212 * Skip the quota flags since repair will force quotacheck. 213 * sb_qflags 214 */ 215 216 if (sb->sb_flags != mp->m_sb.sb_flags) 217 xchk_block_set_corrupt(sc, bp); 218 219 if (sb->sb_shared_vn != mp->m_sb.sb_shared_vn) 220 xchk_block_set_corrupt(sc, bp); 221 222 if (sb->sb_inoalignmt != cpu_to_be32(mp->m_sb.sb_inoalignmt)) 223 xchk_block_set_corrupt(sc, bp); 224 225 if (sb->sb_unit != cpu_to_be32(mp->m_sb.sb_unit)) 226 xchk_block_set_preen(sc, bp); 227 228 if (sb->sb_width != cpu_to_be32(mp->m_sb.sb_width)) 229 xchk_block_set_preen(sc, bp); 230 231 if (sb->sb_dirblklog != mp->m_sb.sb_dirblklog) 232 xchk_block_set_corrupt(sc, bp); 233 234 if (sb->sb_logsectlog != mp->m_sb.sb_logsectlog) 235 xchk_block_set_corrupt(sc, bp); 236 237 if (sb->sb_logsectsize != cpu_to_be16(mp->m_sb.sb_logsectsize)) 238 xchk_block_set_corrupt(sc, bp); 239 240 if (sb->sb_logsunit != cpu_to_be32(mp->m_sb.sb_logsunit)) 241 xchk_block_set_corrupt(sc, bp); 242 243 /* Do we see any invalid bits in sb_features2? */ 244 if (!xfs_sb_version_hasmorebits(&mp->m_sb)) { 245 if (sb->sb_features2 != 0) 246 xchk_block_set_corrupt(sc, bp); 247 } else { 248 v2_ok = XFS_SB_VERSION2_OKBITS; 249 if (XFS_SB_VERSION_NUM(&mp->m_sb) >= XFS_SB_VERSION_5) 250 v2_ok |= XFS_SB_VERSION2_CRCBIT; 251 252 if (!!(sb->sb_features2 & cpu_to_be32(~v2_ok))) 253 xchk_block_set_corrupt(sc, bp); 254 255 if (sb->sb_features2 != sb->sb_bad_features2) 256 xchk_block_set_preen(sc, bp); 257 } 258 259 /* Check sb_features2 flags that are set at mkfs time. */ 260 features_mask = cpu_to_be32(XFS_SB_VERSION2_LAZYSBCOUNTBIT | 261 XFS_SB_VERSION2_PROJID32BIT | 262 XFS_SB_VERSION2_CRCBIT | 263 XFS_SB_VERSION2_FTYPE); 264 if ((sb->sb_features2 & features_mask) != 265 (cpu_to_be32(mp->m_sb.sb_features2) & features_mask)) 266 xchk_block_set_corrupt(sc, bp); 267 268 /* Check sb_features2 flags that can be set after mkfs time. */ 269 features_mask = cpu_to_be32(XFS_SB_VERSION2_ATTR2BIT); 270 if ((sb->sb_features2 & features_mask) != 271 (cpu_to_be32(mp->m_sb.sb_features2) & features_mask)) 272 xchk_block_set_corrupt(sc, bp); 273 274 if (!xfs_sb_version_hascrc(&mp->m_sb)) { 275 /* all v5 fields must be zero */ 276 if (memchr_inv(&sb->sb_features_compat, 0, 277 sizeof(struct xfs_dsb) - 278 offsetof(struct xfs_dsb, sb_features_compat))) 279 xchk_block_set_corrupt(sc, bp); 280 } else { 281 /* Check compat flags; all are set at mkfs time. */ 282 features_mask = cpu_to_be32(XFS_SB_FEAT_COMPAT_UNKNOWN); 283 if ((sb->sb_features_compat & features_mask) != 284 (cpu_to_be32(mp->m_sb.sb_features_compat) & features_mask)) 285 xchk_block_set_corrupt(sc, bp); 286 287 /* Check ro compat flags; all are set at mkfs time. */ 288 features_mask = cpu_to_be32(XFS_SB_FEAT_RO_COMPAT_UNKNOWN | 289 XFS_SB_FEAT_RO_COMPAT_FINOBT | 290 XFS_SB_FEAT_RO_COMPAT_RMAPBT | 291 XFS_SB_FEAT_RO_COMPAT_REFLINK); 292 if ((sb->sb_features_ro_compat & features_mask) != 293 (cpu_to_be32(mp->m_sb.sb_features_ro_compat) & 294 features_mask)) 295 xchk_block_set_corrupt(sc, bp); 296 297 /* Check incompat flags; all are set at mkfs time. */ 298 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_UNKNOWN | 299 XFS_SB_FEAT_INCOMPAT_FTYPE | 300 XFS_SB_FEAT_INCOMPAT_SPINODES | 301 XFS_SB_FEAT_INCOMPAT_META_UUID); 302 if ((sb->sb_features_incompat & features_mask) != 303 (cpu_to_be32(mp->m_sb.sb_features_incompat) & 304 features_mask)) 305 xchk_block_set_corrupt(sc, bp); 306 307 /* Check log incompat flags; all are set at mkfs time. */ 308 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN); 309 if ((sb->sb_features_log_incompat & features_mask) != 310 (cpu_to_be32(mp->m_sb.sb_features_log_incompat) & 311 features_mask)) 312 xchk_block_set_corrupt(sc, bp); 313 314 /* Don't care about sb_crc */ 315 316 if (sb->sb_spino_align != cpu_to_be32(mp->m_sb.sb_spino_align)) 317 xchk_block_set_corrupt(sc, bp); 318 319 if (sb->sb_pquotino != cpu_to_be64(mp->m_sb.sb_pquotino)) 320 xchk_block_set_preen(sc, bp); 321 322 /* Don't care about sb_lsn */ 323 } 324 325 if (xfs_sb_version_hasmetauuid(&mp->m_sb)) { 326 /* The metadata UUID must be the same for all supers */ 327 if (!uuid_equal(&sb->sb_meta_uuid, &mp->m_sb.sb_meta_uuid)) 328 xchk_block_set_corrupt(sc, bp); 329 } 330 331 /* Everything else must be zero. */ 332 if (memchr_inv(sb + 1, 0, 333 BBTOB(bp->b_length) - sizeof(struct xfs_dsb))) 334 xchk_block_set_corrupt(sc, bp); 335 336 xchk_superblock_xref(sc, bp); 337 338 return error; 339} 340 341/* AGF */ 342 343/* Tally freespace record lengths. */ 344STATIC int 345xchk_agf_record_bno_lengths( 346 struct xfs_btree_cur *cur, 347 struct xfs_alloc_rec_incore *rec, 348 void *priv) 349{ 350 xfs_extlen_t *blocks = priv; 351 352 (*blocks) += rec->ar_blockcount; 353 return 0; 354} 355 356/* Check agf_freeblks */ 357static inline void 358xchk_agf_xref_freeblks( 359 struct xfs_scrub *sc) 360{ 361 struct xfs_agf *agf = sc->sa.agf_bp->b_addr; 362 xfs_extlen_t blocks = 0; 363 int error; 364 365 if (!sc->sa.bno_cur) 366 return; 367 368 error = xfs_alloc_query_all(sc->sa.bno_cur, 369 xchk_agf_record_bno_lengths, &blocks); 370 if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur)) 371 return; 372 if (blocks != be32_to_cpu(agf->agf_freeblks)) 373 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 374} 375 376/* Cross reference the AGF with the cntbt (freespace by length btree) */ 377static inline void 378xchk_agf_xref_cntbt( 379 struct xfs_scrub *sc) 380{ 381 struct xfs_agf *agf = sc->sa.agf_bp->b_addr; 382 xfs_agblock_t agbno; 383 xfs_extlen_t blocks; 384 int have; 385 int error; 386 387 if (!sc->sa.cnt_cur) 388 return; 389 390 /* Any freespace at all? */ 391 error = xfs_alloc_lookup_le(sc->sa.cnt_cur, 0, -1U, &have); 392 if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur)) 393 return; 394 if (!have) { 395 if (agf->agf_freeblks != cpu_to_be32(0)) 396 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 397 return; 398 } 399 400 /* Check agf_longest */ 401 error = xfs_alloc_get_rec(sc->sa.cnt_cur, &agbno, &blocks, &have); 402 if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur)) 403 return; 404 if (!have || blocks != be32_to_cpu(agf->agf_longest)) 405 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 406} 407 408/* Check the btree block counts in the AGF against the btrees. */ 409STATIC void 410xchk_agf_xref_btreeblks( 411 struct xfs_scrub *sc) 412{ 413 struct xfs_agf *agf = sc->sa.agf_bp->b_addr; 414 struct xfs_mount *mp = sc->mp; 415 xfs_agblock_t blocks; 416 xfs_agblock_t btreeblks; 417 int error; 418 419 /* Check agf_rmap_blocks; set up for agf_btreeblks check */ 420 if (sc->sa.rmap_cur) { 421 error = xfs_btree_count_blocks(sc->sa.rmap_cur, &blocks); 422 if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur)) 423 return; 424 btreeblks = blocks - 1; 425 if (blocks != be32_to_cpu(agf->agf_rmap_blocks)) 426 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 427 } else { 428 btreeblks = 0; 429 } 430 431 /* 432 * No rmap cursor; we can't xref if we have the rmapbt feature. 433 * We also can't do it if we're missing the free space btree cursors. 434 */ 435 if ((xfs_sb_version_hasrmapbt(&mp->m_sb) && !sc->sa.rmap_cur) || 436 !sc->sa.bno_cur || !sc->sa.cnt_cur) 437 return; 438 439 /* Check agf_btreeblks */ 440 error = xfs_btree_count_blocks(sc->sa.bno_cur, &blocks); 441 if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur)) 442 return; 443 btreeblks += blocks - 1; 444 445 error = xfs_btree_count_blocks(sc->sa.cnt_cur, &blocks); 446 if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur)) 447 return; 448 btreeblks += blocks - 1; 449 450 if (btreeblks != be32_to_cpu(agf->agf_btreeblks)) 451 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 452} 453 454/* Check agf_refcount_blocks against tree size */ 455static inline void 456xchk_agf_xref_refcblks( 457 struct xfs_scrub *sc) 458{ 459 struct xfs_agf *agf = sc->sa.agf_bp->b_addr; 460 xfs_agblock_t blocks; 461 int error; 462 463 if (!sc->sa.refc_cur) 464 return; 465 466 error = xfs_btree_count_blocks(sc->sa.refc_cur, &blocks); 467 if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur)) 468 return; 469 if (blocks != be32_to_cpu(agf->agf_refcount_blocks)) 470 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp); 471} 472 473/* Cross-reference with the other btrees. */ 474STATIC void 475xchk_agf_xref( 476 struct xfs_scrub *sc) 477{ 478 struct xfs_mount *mp = sc->mp; 479 xfs_agblock_t agbno; 480 int error; 481 482 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 483 return; 484 485 agbno = XFS_AGF_BLOCK(mp); 486 487 error = xchk_ag_btcur_init(sc, &sc->sa); 488 if (error) 489 return; 490 491 xchk_xref_is_used_space(sc, agbno, 1); 492 xchk_agf_xref_freeblks(sc); 493 xchk_agf_xref_cntbt(sc); 494 xchk_xref_is_not_inode_chunk(sc, agbno, 1); 495 xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS); 496 xchk_agf_xref_btreeblks(sc); 497 xchk_xref_is_not_shared(sc, agbno, 1); 498 xchk_agf_xref_refcblks(sc); 499 500 /* scrub teardown will take care of sc->sa for us */ 501} 502 503/* Scrub the AGF. */ 504int 505xchk_agf( 506 struct xfs_scrub *sc) 507{ 508 struct xfs_mount *mp = sc->mp; 509 struct xfs_agf *agf; 510 struct xfs_perag *pag; 511 xfs_agnumber_t agno; 512 xfs_agblock_t agbno; 513 xfs_agblock_t eoag; 514 xfs_agblock_t agfl_first; 515 xfs_agblock_t agfl_last; 516 xfs_agblock_t agfl_count; 517 xfs_agblock_t fl_count; 518 int level; 519 int error = 0; 520 521 agno = sc->sa.agno = sc->sm->sm_agno; 522 error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp, 523 &sc->sa.agf_bp, &sc->sa.agfl_bp); 524 if (!xchk_process_error(sc, agno, XFS_AGF_BLOCK(sc->mp), &error)) 525 goto out; 526 xchk_buffer_recheck(sc, sc->sa.agf_bp); 527 528 agf = sc->sa.agf_bp->b_addr; 529 530 /* Check the AG length */ 531 eoag = be32_to_cpu(agf->agf_length); 532 if (eoag != xfs_ag_block_count(mp, agno)) 533 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 534 535 /* Check the AGF btree roots and levels */ 536 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]); 537 if (!xfs_verify_agbno(mp, agno, agbno)) 538 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 539 540 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]); 541 if (!xfs_verify_agbno(mp, agno, agbno)) 542 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 543 544 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]); 545 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 546 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 547 548 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]); 549 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 550 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 551 552 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) { 553 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_RMAP]); 554 if (!xfs_verify_agbno(mp, agno, agbno)) 555 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 556 557 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]); 558 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 559 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 560 } 561 562 if (xfs_sb_version_hasreflink(&mp->m_sb)) { 563 agbno = be32_to_cpu(agf->agf_refcount_root); 564 if (!xfs_verify_agbno(mp, agno, agbno)) 565 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 566 567 level = be32_to_cpu(agf->agf_refcount_level); 568 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 569 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 570 } 571 572 /* Check the AGFL counters */ 573 agfl_first = be32_to_cpu(agf->agf_flfirst); 574 agfl_last = be32_to_cpu(agf->agf_fllast); 575 agfl_count = be32_to_cpu(agf->agf_flcount); 576 if (agfl_last > agfl_first) 577 fl_count = agfl_last - agfl_first + 1; 578 else 579 fl_count = xfs_agfl_size(mp) - agfl_first + agfl_last + 1; 580 if (agfl_count != 0 && fl_count != agfl_count) 581 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 582 583 /* Do the incore counters match? */ 584 pag = xfs_perag_get(mp, agno); 585 if (pag->pagf_freeblks != be32_to_cpu(agf->agf_freeblks)) 586 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 587 if (pag->pagf_flcount != be32_to_cpu(agf->agf_flcount)) 588 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 589 if (pag->pagf_btreeblks != be32_to_cpu(agf->agf_btreeblks)) 590 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 591 xfs_perag_put(pag); 592 593 xchk_agf_xref(sc); 594out: 595 return error; 596} 597 598/* AGFL */ 599 600struct xchk_agfl_info { 601 unsigned int sz_entries; 602 unsigned int nr_entries; 603 xfs_agblock_t *entries; 604 struct xfs_scrub *sc; 605}; 606 607/* Cross-reference with the other btrees. */ 608STATIC void 609xchk_agfl_block_xref( 610 struct xfs_scrub *sc, 611 xfs_agblock_t agbno) 612{ 613 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 614 return; 615 616 xchk_xref_is_used_space(sc, agbno, 1); 617 xchk_xref_is_not_inode_chunk(sc, agbno, 1); 618 xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_AG); 619 xchk_xref_is_not_shared(sc, agbno, 1); 620} 621 622/* Scrub an AGFL block. */ 623STATIC int 624xchk_agfl_block( 625 struct xfs_mount *mp, 626 xfs_agblock_t agbno, 627 void *priv) 628{ 629 struct xchk_agfl_info *sai = priv; 630 struct xfs_scrub *sc = sai->sc; 631 xfs_agnumber_t agno = sc->sa.agno; 632 633 if (xfs_verify_agbno(mp, agno, agbno) && 634 sai->nr_entries < sai->sz_entries) 635 sai->entries[sai->nr_entries++] = agbno; 636 else 637 xchk_block_set_corrupt(sc, sc->sa.agfl_bp); 638 639 xchk_agfl_block_xref(sc, agbno); 640 641 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 642 return -ECANCELED; 643 644 return 0; 645} 646 647static int 648xchk_agblock_cmp( 649 const void *pa, 650 const void *pb) 651{ 652 const xfs_agblock_t *a = pa; 653 const xfs_agblock_t *b = pb; 654 655 return (int)*a - (int)*b; 656} 657 658/* Cross-reference with the other btrees. */ 659STATIC void 660xchk_agfl_xref( 661 struct xfs_scrub *sc) 662{ 663 struct xfs_mount *mp = sc->mp; 664 xfs_agblock_t agbno; 665 int error; 666 667 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 668 return; 669 670 agbno = XFS_AGFL_BLOCK(mp); 671 672 error = xchk_ag_btcur_init(sc, &sc->sa); 673 if (error) 674 return; 675 676 xchk_xref_is_used_space(sc, agbno, 1); 677 xchk_xref_is_not_inode_chunk(sc, agbno, 1); 678 xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS); 679 xchk_xref_is_not_shared(sc, agbno, 1); 680 681 /* 682 * Scrub teardown will take care of sc->sa for us. Leave sc->sa 683 * active so that the agfl block xref can use it too. 684 */ 685} 686 687/* Scrub the AGFL. */ 688int 689xchk_agfl( 690 struct xfs_scrub *sc) 691{ 692 struct xchk_agfl_info sai; 693 struct xfs_agf *agf; 694 xfs_agnumber_t agno; 695 unsigned int agflcount; 696 unsigned int i; 697 int error; 698 699 agno = sc->sa.agno = sc->sm->sm_agno; 700 error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp, 701 &sc->sa.agf_bp, &sc->sa.agfl_bp); 702 if (!xchk_process_error(sc, agno, XFS_AGFL_BLOCK(sc->mp), &error)) 703 goto out; 704 if (!sc->sa.agf_bp) 705 return -EFSCORRUPTED; 706 xchk_buffer_recheck(sc, sc->sa.agfl_bp); 707 708 xchk_agfl_xref(sc); 709 710 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 711 goto out; 712 713 /* Allocate buffer to ensure uniqueness of AGFL entries. */ 714 agf = sc->sa.agf_bp->b_addr; 715 agflcount = be32_to_cpu(agf->agf_flcount); 716 if (agflcount > xfs_agfl_size(sc->mp)) { 717 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 718 goto out; 719 } 720 memset(&sai, 0, sizeof(sai)); 721 sai.sc = sc; 722 sai.sz_entries = agflcount; 723 sai.entries = kmem_zalloc(sizeof(xfs_agblock_t) * agflcount, 724 KM_MAYFAIL); 725 if (!sai.entries) { 726 error = -ENOMEM; 727 goto out; 728 } 729 730 /* Check the blocks in the AGFL. */ 731 error = xfs_agfl_walk(sc->mp, sc->sa.agf_bp->b_addr, 732 sc->sa.agfl_bp, xchk_agfl_block, &sai); 733 if (error == -ECANCELED) { 734 error = 0; 735 goto out_free; 736 } 737 if (error) 738 goto out_free; 739 740 if (agflcount != sai.nr_entries) { 741 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 742 goto out_free; 743 } 744 745 /* Sort entries, check for duplicates. */ 746 sort(sai.entries, sai.nr_entries, sizeof(sai.entries[0]), 747 xchk_agblock_cmp, NULL); 748 for (i = 1; i < sai.nr_entries; i++) { 749 if (sai.entries[i] == sai.entries[i - 1]) { 750 xchk_block_set_corrupt(sc, sc->sa.agf_bp); 751 break; 752 } 753 } 754 755out_free: 756 kmem_free(sai.entries); 757out: 758 return error; 759} 760 761/* AGI */ 762 763/* Check agi_count/agi_freecount */ 764static inline void 765xchk_agi_xref_icounts( 766 struct xfs_scrub *sc) 767{ 768 struct xfs_agi *agi = sc->sa.agi_bp->b_addr; 769 xfs_agino_t icount; 770 xfs_agino_t freecount; 771 int error; 772 773 if (!sc->sa.ino_cur) 774 return; 775 776 error = xfs_ialloc_count_inodes(sc->sa.ino_cur, &icount, &freecount); 777 if (!xchk_should_check_xref(sc, &error, &sc->sa.ino_cur)) 778 return; 779 if (be32_to_cpu(agi->agi_count) != icount || 780 be32_to_cpu(agi->agi_freecount) != freecount) 781 xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp); 782} 783 784/* Check agi_[fi]blocks against tree size */ 785static inline void 786xchk_agi_xref_fiblocks( 787 struct xfs_scrub *sc) 788{ 789 struct xfs_agi *agi = sc->sa.agi_bp->b_addr; 790 xfs_agblock_t blocks; 791 int error = 0; 792 793 if (!xfs_sb_version_hasinobtcounts(&sc->mp->m_sb)) 794 return; 795 796 if (sc->sa.ino_cur) { 797 error = xfs_btree_count_blocks(sc->sa.ino_cur, &blocks); 798 if (!xchk_should_check_xref(sc, &error, &sc->sa.ino_cur)) 799 return; 800 if (blocks != be32_to_cpu(agi->agi_iblocks)) 801 xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp); 802 } 803 804 if (sc->sa.fino_cur) { 805 error = xfs_btree_count_blocks(sc->sa.fino_cur, &blocks); 806 if (!xchk_should_check_xref(sc, &error, &sc->sa.fino_cur)) 807 return; 808 if (blocks != be32_to_cpu(agi->agi_fblocks)) 809 xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp); 810 } 811} 812 813/* Cross-reference with the other btrees. */ 814STATIC void 815xchk_agi_xref( 816 struct xfs_scrub *sc) 817{ 818 struct xfs_mount *mp = sc->mp; 819 xfs_agblock_t agbno; 820 int error; 821 822 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 823 return; 824 825 agbno = XFS_AGI_BLOCK(mp); 826 827 error = xchk_ag_btcur_init(sc, &sc->sa); 828 if (error) 829 return; 830 831 xchk_xref_is_used_space(sc, agbno, 1); 832 xchk_xref_is_not_inode_chunk(sc, agbno, 1); 833 xchk_agi_xref_icounts(sc); 834 xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS); 835 xchk_xref_is_not_shared(sc, agbno, 1); 836 xchk_agi_xref_fiblocks(sc); 837 838 /* scrub teardown will take care of sc->sa for us */ 839} 840 841/* Scrub the AGI. */ 842int 843xchk_agi( 844 struct xfs_scrub *sc) 845{ 846 struct xfs_mount *mp = sc->mp; 847 struct xfs_agi *agi; 848 struct xfs_perag *pag; 849 xfs_agnumber_t agno; 850 xfs_agblock_t agbno; 851 xfs_agblock_t eoag; 852 xfs_agino_t agino; 853 xfs_agino_t first_agino; 854 xfs_agino_t last_agino; 855 xfs_agino_t icount; 856 int i; 857 int level; 858 int error = 0; 859 860 agno = sc->sa.agno = sc->sm->sm_agno; 861 error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp, 862 &sc->sa.agf_bp, &sc->sa.agfl_bp); 863 if (!xchk_process_error(sc, agno, XFS_AGI_BLOCK(sc->mp), &error)) 864 goto out; 865 xchk_buffer_recheck(sc, sc->sa.agi_bp); 866 867 agi = sc->sa.agi_bp->b_addr; 868 869 /* Check the AG length */ 870 eoag = be32_to_cpu(agi->agi_length); 871 if (eoag != xfs_ag_block_count(mp, agno)) 872 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 873 874 /* Check btree roots and levels */ 875 agbno = be32_to_cpu(agi->agi_root); 876 if (!xfs_verify_agbno(mp, agno, agbno)) 877 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 878 879 level = be32_to_cpu(agi->agi_level); 880 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 881 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 882 883 if (xfs_sb_version_hasfinobt(&mp->m_sb)) { 884 agbno = be32_to_cpu(agi->agi_free_root); 885 if (!xfs_verify_agbno(mp, agno, agbno)) 886 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 887 888 level = be32_to_cpu(agi->agi_free_level); 889 if (level <= 0 || level > XFS_BTREE_MAXLEVELS) 890 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 891 } 892 893 /* Check inode counters */ 894 xfs_agino_range(mp, agno, &first_agino, &last_agino); 895 icount = be32_to_cpu(agi->agi_count); 896 if (icount > last_agino - first_agino + 1 || 897 icount < be32_to_cpu(agi->agi_freecount)) 898 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 899 900 /* Check inode pointers */ 901 agino = be32_to_cpu(agi->agi_newino); 902 if (!xfs_verify_agino_or_null(mp, agno, agino)) 903 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 904 905 agino = be32_to_cpu(agi->agi_dirino); 906 if (!xfs_verify_agino_or_null(mp, agno, agino)) 907 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 908 909 /* Check unlinked inode buckets */ 910 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) { 911 agino = be32_to_cpu(agi->agi_unlinked[i]); 912 if (!xfs_verify_agino_or_null(mp, agno, agino)) 913 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 914 } 915 916 if (agi->agi_pad32 != cpu_to_be32(0)) 917 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 918 919 /* Do the incore counters match? */ 920 pag = xfs_perag_get(mp, agno); 921 if (pag->pagi_count != be32_to_cpu(agi->agi_count)) 922 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 923 if (pag->pagi_freecount != be32_to_cpu(agi->agi_freecount)) 924 xchk_block_set_corrupt(sc, sc->sa.agi_bp); 925 xfs_perag_put(pag); 926 927 xchk_agi_xref(sc); 928out: 929 return error; 930} 931