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 "xfs_ialloc.h" 21 #include "xfs_ialloc_btree.h" 22 #include "xfs_icache.h" 23 #include "xfs_rmap.h" 24 #include "xfs_log.h" 25 #include "xfs_trans_priv.h" 26 #include "scrub/xfs_scrub.h" 27 #include "scrub/scrub.h" 28 #include "scrub/common.h" 29 #include "scrub/btree.h" 30 #include "scrub/trace.h" 31 32 /* 33 * Set us up to scrub inode btrees. 34 * If we detect a discrepancy between the inobt and the inode, 35 * try again after forcing logged inode cores out to disk. 36 */ 37 int 38 xchk_setup_ag_iallocbt( 39 struct xfs_scrub *sc, 40 struct xfs_inode *ip) 41 { 42 return xchk_setup_ag_btree(sc, ip, sc->try_harder); 43 } 44 45 /* Inode btree scrubber. */ 46 47 struct xchk_iallocbt { 48 /* Number of inodes we see while scanning inobt. */ 49 unsigned long long inodes; 50 }; 51 52 /* 53 * If we're checking the finobt, cross-reference with the inobt. 54 * Otherwise we're checking the inobt; if there is an finobt, make sure 55 * we have a record or not depending on freecount. 56 */ 57 static inline void 58 xchk_iallocbt_chunk_xref_other( 59 struct xfs_scrub *sc, 60 struct xfs_inobt_rec_incore *irec, 61 xfs_agino_t agino) 62 { 63 struct xfs_btree_cur **pcur; 64 bool has_irec; 65 int error; 66 67 if (sc->sm->sm_type == XFS_SCRUB_TYPE_FINOBT) 68 pcur = &sc->sa.ino_cur; 69 else 70 pcur = &sc->sa.fino_cur; 71 if (!(*pcur)) 72 return; 73 error = xfs_ialloc_has_inode_record(*pcur, agino, agino, &has_irec); 74 if (!xchk_should_check_xref(sc, &error, pcur)) 75 return; 76 if (((irec->ir_freecount > 0 && !has_irec) || 77 (irec->ir_freecount == 0 && has_irec))) 78 xchk_btree_xref_set_corrupt(sc, *pcur, 0); 79 } 80 81 /* Cross-reference with the other btrees. */ 82 STATIC void 83 xchk_iallocbt_chunk_xref( 84 struct xfs_scrub *sc, 85 struct xfs_inobt_rec_incore *irec, 86 xfs_agino_t agino, 87 xfs_agblock_t agbno, 88 xfs_extlen_t len) 89 { 90 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) 91 return; 92 93 xchk_xref_is_used_space(sc, agbno, len); 94 xchk_iallocbt_chunk_xref_other(sc, irec, agino); 95 xchk_xref_is_owned_by(sc, agbno, len, &XFS_RMAP_OINFO_INODES); 96 xchk_xref_is_not_shared(sc, agbno, len); 97 } 98 99 /* Is this chunk worth checking? */ 100 STATIC bool 101 xchk_iallocbt_chunk( 102 struct xchk_btree *bs, 103 struct xfs_inobt_rec_incore *irec, 104 xfs_agino_t agino, 105 xfs_extlen_t len) 106 { 107 struct xfs_mount *mp = bs->cur->bc_mp; 108 xfs_agnumber_t agno = bs->cur->bc_private.a.agno; 109 xfs_agblock_t bno; 110 111 bno = XFS_AGINO_TO_AGBNO(mp, agino); 112 if (bno + len <= bno || 113 !xfs_verify_agbno(mp, agno, bno) || 114 !xfs_verify_agbno(mp, agno, bno + len - 1)) 115 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 116 117 xchk_iallocbt_chunk_xref(bs->sc, irec, agino, bno, len); 118 119 return true; 120 } 121 122 /* Count the number of free inodes. */ 123 static unsigned int 124 xchk_iallocbt_freecount( 125 xfs_inofree_t freemask) 126 { 127 BUILD_BUG_ON(sizeof(freemask) != sizeof(__u64)); 128 return hweight64(freemask); 129 } 130 131 /* Check a particular inode with ir_free. */ 132 STATIC int 133 xchk_iallocbt_check_cluster_freemask( 134 struct xchk_btree *bs, 135 xfs_ino_t fsino, 136 xfs_agino_t chunkino, 137 xfs_agino_t clusterino, 138 struct xfs_inobt_rec_incore *irec, 139 struct xfs_buf *bp) 140 { 141 struct xfs_dinode *dip; 142 struct xfs_mount *mp = bs->cur->bc_mp; 143 bool inode_is_free = false; 144 bool freemask_ok; 145 bool inuse; 146 int error = 0; 147 148 if (xchk_should_terminate(bs->sc, &error)) 149 return error; 150 151 dip = xfs_buf_offset(bp, clusterino * mp->m_sb.sb_inodesize); 152 if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC || 153 (dip->di_version >= 3 && 154 be64_to_cpu(dip->di_ino) != fsino + clusterino)) { 155 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 156 goto out; 157 } 158 159 if (irec->ir_free & XFS_INOBT_MASK(chunkino + clusterino)) 160 inode_is_free = true; 161 error = xfs_icache_inode_is_allocated(mp, bs->cur->bc_tp, 162 fsino + clusterino, &inuse); 163 if (error == -ENODATA) { 164 /* Not cached, just read the disk buffer */ 165 freemask_ok = inode_is_free ^ !!(dip->di_mode); 166 if (!bs->sc->try_harder && !freemask_ok) 167 return -EDEADLOCK; 168 } else if (error < 0) { 169 /* 170 * Inode is only half assembled, or there was an IO error, 171 * or the verifier failed, so don't bother trying to check. 172 * The inode scrubber can deal with this. 173 */ 174 goto out; 175 } else { 176 /* Inode is all there. */ 177 freemask_ok = inode_is_free ^ inuse; 178 } 179 if (!freemask_ok) 180 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 181 out: 182 return 0; 183 } 184 185 /* Make sure the free mask is consistent with what the inodes think. */ 186 STATIC int 187 xchk_iallocbt_check_freemask( 188 struct xchk_btree *bs, 189 struct xfs_inobt_rec_incore *irec) 190 { 191 struct xfs_imap imap; 192 struct xfs_mount *mp = bs->cur->bc_mp; 193 struct xfs_dinode *dip; 194 struct xfs_buf *bp; 195 xfs_ino_t fsino; 196 xfs_agino_t nr_inodes; 197 xfs_agino_t agino; 198 xfs_agino_t chunkino; 199 xfs_agino_t clusterino; 200 xfs_agblock_t agbno; 201 uint16_t holemask; 202 uint16_t ir_holemask; 203 int error = 0; 204 205 /* Make sure the freemask matches the inode records. */ 206 nr_inodes = mp->m_inodes_per_cluster; 207 208 for (agino = irec->ir_startino; 209 agino < irec->ir_startino + XFS_INODES_PER_CHUNK; 210 agino += mp->m_inodes_per_cluster) { 211 fsino = XFS_AGINO_TO_INO(mp, bs->cur->bc_private.a.agno, agino); 212 chunkino = agino - irec->ir_startino; 213 agbno = XFS_AGINO_TO_AGBNO(mp, agino); 214 215 /* Compute the holemask mask for this cluster. */ 216 for (clusterino = 0, holemask = 0; clusterino < nr_inodes; 217 clusterino += XFS_INODES_PER_HOLEMASK_BIT) 218 holemask |= XFS_INOBT_MASK((chunkino + clusterino) / 219 XFS_INODES_PER_HOLEMASK_BIT); 220 221 /* The whole cluster must be a hole or not a hole. */ 222 ir_holemask = (irec->ir_holemask & holemask); 223 if (ir_holemask != holemask && ir_holemask != 0) { 224 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 225 continue; 226 } 227 228 /* If any part of this is a hole, skip it. */ 229 if (ir_holemask) { 230 xchk_xref_is_not_owned_by(bs->sc, agbno, 231 mp->m_blocks_per_cluster, 232 &XFS_RMAP_OINFO_INODES); 233 continue; 234 } 235 236 xchk_xref_is_owned_by(bs->sc, agbno, mp->m_blocks_per_cluster, 237 &XFS_RMAP_OINFO_INODES); 238 239 /* Grab the inode cluster buffer. */ 240 imap.im_blkno = XFS_AGB_TO_DADDR(mp, bs->cur->bc_private.a.agno, 241 agbno); 242 imap.im_len = XFS_FSB_TO_BB(mp, mp->m_blocks_per_cluster); 243 imap.im_boffset = 0; 244 245 error = xfs_imap_to_bp(mp, bs->cur->bc_tp, &imap, 246 &dip, &bp, 0, 0); 247 if (!xchk_btree_xref_process_error(bs->sc, bs->cur, 0, 248 &error)) 249 continue; 250 251 /* Which inodes are free? */ 252 for (clusterino = 0; clusterino < nr_inodes; clusterino++) { 253 error = xchk_iallocbt_check_cluster_freemask(bs, 254 fsino, chunkino, clusterino, irec, bp); 255 if (error) { 256 xfs_trans_brelse(bs->cur->bc_tp, bp); 257 return error; 258 } 259 } 260 261 xfs_trans_brelse(bs->cur->bc_tp, bp); 262 } 263 264 return error; 265 } 266 267 /* Scrub an inobt/finobt record. */ 268 STATIC int 269 xchk_iallocbt_rec( 270 struct xchk_btree *bs, 271 union xfs_btree_rec *rec) 272 { 273 struct xfs_mount *mp = bs->cur->bc_mp; 274 struct xchk_iallocbt *iabt = bs->private; 275 struct xfs_inobt_rec_incore irec; 276 uint64_t holes; 277 xfs_agnumber_t agno = bs->cur->bc_private.a.agno; 278 xfs_agino_t agino; 279 xfs_agblock_t agbno; 280 xfs_extlen_t len; 281 int holecount; 282 int i; 283 int error = 0; 284 unsigned int real_freecount; 285 uint16_t holemask; 286 287 xfs_inobt_btrec_to_irec(mp, rec, &irec); 288 289 if (irec.ir_count > XFS_INODES_PER_CHUNK || 290 irec.ir_freecount > XFS_INODES_PER_CHUNK) 291 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 292 293 real_freecount = irec.ir_freecount + 294 (XFS_INODES_PER_CHUNK - irec.ir_count); 295 if (real_freecount != xchk_iallocbt_freecount(irec.ir_free)) 296 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 297 298 agino = irec.ir_startino; 299 /* Record has to be properly aligned within the AG. */ 300 if (!xfs_verify_agino(mp, agno, agino) || 301 !xfs_verify_agino(mp, agno, agino + XFS_INODES_PER_CHUNK - 1)) { 302 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 303 goto out; 304 } 305 306 /* Make sure this record is aligned to cluster and inoalignmnt size. */ 307 agbno = XFS_AGINO_TO_AGBNO(mp, irec.ir_startino); 308 if ((agbno & (mp->m_cluster_align - 1)) || 309 (agbno & (mp->m_blocks_per_cluster - 1))) 310 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 311 312 iabt->inodes += irec.ir_count; 313 314 /* Handle non-sparse inodes */ 315 if (!xfs_inobt_issparse(irec.ir_holemask)) { 316 len = XFS_B_TO_FSB(mp, 317 XFS_INODES_PER_CHUNK * mp->m_sb.sb_inodesize); 318 if (irec.ir_count != XFS_INODES_PER_CHUNK) 319 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 320 321 if (!xchk_iallocbt_chunk(bs, &irec, agino, len)) 322 goto out; 323 goto check_freemask; 324 } 325 326 /* Check each chunk of a sparse inode cluster. */ 327 holemask = irec.ir_holemask; 328 holecount = 0; 329 len = XFS_B_TO_FSB(mp, 330 XFS_INODES_PER_HOLEMASK_BIT * mp->m_sb.sb_inodesize); 331 holes = ~xfs_inobt_irec_to_allocmask(&irec); 332 if ((holes & irec.ir_free) != holes || 333 irec.ir_freecount > irec.ir_count) 334 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 335 336 for (i = 0; i < XFS_INOBT_HOLEMASK_BITS; i++) { 337 if (holemask & 1) 338 holecount += XFS_INODES_PER_HOLEMASK_BIT; 339 else if (!xchk_iallocbt_chunk(bs, &irec, agino, len)) 340 break; 341 holemask >>= 1; 342 agino += XFS_INODES_PER_HOLEMASK_BIT; 343 } 344 345 if (holecount > XFS_INODES_PER_CHUNK || 346 holecount + irec.ir_count != XFS_INODES_PER_CHUNK) 347 xchk_btree_set_corrupt(bs->sc, bs->cur, 0); 348 349 check_freemask: 350 error = xchk_iallocbt_check_freemask(bs, &irec); 351 if (error) 352 goto out; 353 354 out: 355 return error; 356 } 357 358 /* 359 * Make sure the inode btrees are as large as the rmap thinks they are. 360 * Don't bother if we're missing btree cursors, as we're already corrupt. 361 */ 362 STATIC void 363 xchk_iallocbt_xref_rmap_btreeblks( 364 struct xfs_scrub *sc, 365 int which) 366 { 367 xfs_filblks_t blocks; 368 xfs_extlen_t inobt_blocks = 0; 369 xfs_extlen_t finobt_blocks = 0; 370 int error; 371 372 if (!sc->sa.ino_cur || !sc->sa.rmap_cur || 373 (xfs_sb_version_hasfinobt(&sc->mp->m_sb) && !sc->sa.fino_cur) || 374 xchk_skip_xref(sc->sm)) 375 return; 376 377 /* Check that we saw as many inobt blocks as the rmap says. */ 378 error = xfs_btree_count_blocks(sc->sa.ino_cur, &inobt_blocks); 379 if (!xchk_process_error(sc, 0, 0, &error)) 380 return; 381 382 if (sc->sa.fino_cur) { 383 error = xfs_btree_count_blocks(sc->sa.fino_cur, &finobt_blocks); 384 if (!xchk_process_error(sc, 0, 0, &error)) 385 return; 386 } 387 388 error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, 389 &XFS_RMAP_OINFO_INOBT, &blocks); 390 if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur)) 391 return; 392 if (blocks != inobt_blocks + finobt_blocks) 393 xchk_btree_set_corrupt(sc, sc->sa.ino_cur, 0); 394 } 395 396 /* 397 * Make sure that the inobt records point to the same number of blocks as 398 * the rmap says are owned by inodes. 399 */ 400 STATIC void 401 xchk_iallocbt_xref_rmap_inodes( 402 struct xfs_scrub *sc, 403 int which, 404 unsigned long long inodes) 405 { 406 xfs_filblks_t blocks; 407 xfs_filblks_t inode_blocks; 408 int error; 409 410 if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm)) 411 return; 412 413 /* Check that we saw as many inode blocks as the rmap knows about. */ 414 error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, 415 &XFS_RMAP_OINFO_INODES, &blocks); 416 if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur)) 417 return; 418 inode_blocks = XFS_B_TO_FSB(sc->mp, inodes * sc->mp->m_sb.sb_inodesize); 419 if (blocks != inode_blocks) 420 xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0); 421 } 422 423 /* Scrub the inode btrees for some AG. */ 424 STATIC int 425 xchk_iallocbt( 426 struct xfs_scrub *sc, 427 xfs_btnum_t which) 428 { 429 struct xfs_btree_cur *cur; 430 struct xchk_iallocbt iabt = { 431 .inodes = 0, 432 }; 433 int error; 434 435 cur = which == XFS_BTNUM_INO ? sc->sa.ino_cur : sc->sa.fino_cur; 436 error = xchk_btree(sc, cur, xchk_iallocbt_rec, &XFS_RMAP_OINFO_INOBT, 437 &iabt); 438 if (error) 439 return error; 440 441 xchk_iallocbt_xref_rmap_btreeblks(sc, which); 442 443 /* 444 * If we're scrubbing the inode btree, inode_blocks is the number of 445 * blocks pointed to by all the inode chunk records. Therefore, we 446 * should compare to the number of inode chunk blocks that the rmap 447 * knows about. We can't do this for the finobt since it only points 448 * to inode chunks with free inodes. 449 */ 450 if (which == XFS_BTNUM_INO) 451 xchk_iallocbt_xref_rmap_inodes(sc, which, iabt.inodes); 452 453 return error; 454 } 455 456 int 457 xchk_inobt( 458 struct xfs_scrub *sc) 459 { 460 return xchk_iallocbt(sc, XFS_BTNUM_INO); 461 } 462 463 int 464 xchk_finobt( 465 struct xfs_scrub *sc) 466 { 467 return xchk_iallocbt(sc, XFS_BTNUM_FINO); 468 } 469 470 /* See if an inode btree has (or doesn't have) an inode chunk record. */ 471 static inline void 472 xchk_xref_inode_check( 473 struct xfs_scrub *sc, 474 xfs_agblock_t agbno, 475 xfs_extlen_t len, 476 struct xfs_btree_cur **icur, 477 bool should_have_inodes) 478 { 479 bool has_inodes; 480 int error; 481 482 if (!(*icur) || xchk_skip_xref(sc->sm)) 483 return; 484 485 error = xfs_ialloc_has_inodes_at_extent(*icur, agbno, len, &has_inodes); 486 if (!xchk_should_check_xref(sc, &error, icur)) 487 return; 488 if (has_inodes != should_have_inodes) 489 xchk_btree_xref_set_corrupt(sc, *icur, 0); 490 } 491 492 /* xref check that the extent is not covered by inodes */ 493 void 494 xchk_xref_is_not_inode_chunk( 495 struct xfs_scrub *sc, 496 xfs_agblock_t agbno, 497 xfs_extlen_t len) 498 { 499 xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, false); 500 xchk_xref_inode_check(sc, agbno, len, &sc->sa.fino_cur, false); 501 } 502 503 /* xref check that the extent is covered by inodes */ 504 void 505 xchk_xref_is_inode_chunk( 506 struct xfs_scrub *sc, 507 xfs_agblock_t agbno, 508 xfs_extlen_t len) 509 { 510 xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, true); 511 } 512