1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2018 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_log_format.h" 14 #include "xfs_trans.h" 15 #include "xfs_sb.h" 16 #include "xfs_alloc.h" 17 #include "xfs_alloc_btree.h" 18 #include "xfs_ialloc.h" 19 #include "xfs_ialloc_btree.h" 20 #include "xfs_rmap.h" 21 #include "xfs_rmap_btree.h" 22 #include "xfs_refcount_btree.h" 23 #include "xfs_ag.h" 24 #include "scrub/scrub.h" 25 #include "scrub/common.h" 26 #include "scrub/trace.h" 27 #include "scrub/repair.h" 28 #include "scrub/bitmap.h" 29 30 /* Superblock */ 31 32 /* Repair the superblock. */ 33 int 34 xrep_superblock( 35 struct xfs_scrub *sc) 36 { 37 struct xfs_mount *mp = sc->mp; 38 struct xfs_buf *bp; 39 xfs_agnumber_t agno; 40 int error; 41 42 /* Don't try to repair AG 0's sb; let xfs_repair deal with it. */ 43 agno = sc->sm->sm_agno; 44 if (agno == 0) 45 return -EOPNOTSUPP; 46 47 error = xfs_sb_get_secondary(mp, sc->tp, agno, &bp); 48 if (error) 49 return error; 50 51 /* Copy AG 0's superblock to this one. */ 52 xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); 53 xfs_sb_to_disk(bp->b_addr, &mp->m_sb); 54 55 /* Write this to disk. */ 56 xfs_trans_buf_set_type(sc->tp, bp, XFS_BLFT_SB_BUF); 57 xfs_trans_log_buf(sc->tp, bp, 0, BBTOB(bp->b_length) - 1); 58 return error; 59 } 60 61 /* AGF */ 62 63 struct xrep_agf_allocbt { 64 struct xfs_scrub *sc; 65 xfs_agblock_t freeblks; 66 xfs_agblock_t longest; 67 }; 68 69 /* Record free space shape information. */ 70 STATIC int 71 xrep_agf_walk_allocbt( 72 struct xfs_btree_cur *cur, 73 struct xfs_alloc_rec_incore *rec, 74 void *priv) 75 { 76 struct xrep_agf_allocbt *raa = priv; 77 int error = 0; 78 79 if (xchk_should_terminate(raa->sc, &error)) 80 return error; 81 82 raa->freeblks += rec->ar_blockcount; 83 if (rec->ar_blockcount > raa->longest) 84 raa->longest = rec->ar_blockcount; 85 return error; 86 } 87 88 /* Does this AGFL block look sane? */ 89 STATIC int 90 xrep_agf_check_agfl_block( 91 struct xfs_mount *mp, 92 xfs_agblock_t agbno, 93 void *priv) 94 { 95 struct xfs_scrub *sc = priv; 96 97 if (!xfs_verify_agbno(mp, sc->sa.agno, agbno)) 98 return -EFSCORRUPTED; 99 return 0; 100 } 101 102 /* 103 * Offset within the xrep_find_ag_btree array for each btree type. Avoid the 104 * XFS_BTNUM_ names here to avoid creating a sparse array. 105 */ 106 enum { 107 XREP_AGF_BNOBT = 0, 108 XREP_AGF_CNTBT, 109 XREP_AGF_RMAPBT, 110 XREP_AGF_REFCOUNTBT, 111 XREP_AGF_END, 112 XREP_AGF_MAX 113 }; 114 115 /* Check a btree root candidate. */ 116 static inline bool 117 xrep_check_btree_root( 118 struct xfs_scrub *sc, 119 struct xrep_find_ag_btree *fab) 120 { 121 struct xfs_mount *mp = sc->mp; 122 xfs_agnumber_t agno = sc->sm->sm_agno; 123 124 return xfs_verify_agbno(mp, agno, fab->root) && 125 fab->height <= XFS_BTREE_MAXLEVELS; 126 } 127 128 /* 129 * Given the btree roots described by *fab, find the roots, check them for 130 * sanity, and pass the root data back out via *fab. 131 * 132 * This is /also/ a chicken and egg problem because we have to use the rmapbt 133 * (rooted in the AGF) to find the btrees rooted in the AGF. We also have no 134 * idea if the btrees make any sense. If we hit obvious corruptions in those 135 * btrees we'll bail out. 136 */ 137 STATIC int 138 xrep_agf_find_btrees( 139 struct xfs_scrub *sc, 140 struct xfs_buf *agf_bp, 141 struct xrep_find_ag_btree *fab, 142 struct xfs_buf *agfl_bp) 143 { 144 struct xfs_agf *old_agf = agf_bp->b_addr; 145 int error; 146 147 /* Go find the root data. */ 148 error = xrep_find_ag_btree_roots(sc, agf_bp, fab, agfl_bp); 149 if (error) 150 return error; 151 152 /* We must find the bnobt, cntbt, and rmapbt roots. */ 153 if (!xrep_check_btree_root(sc, &fab[XREP_AGF_BNOBT]) || 154 !xrep_check_btree_root(sc, &fab[XREP_AGF_CNTBT]) || 155 !xrep_check_btree_root(sc, &fab[XREP_AGF_RMAPBT])) 156 return -EFSCORRUPTED; 157 158 /* 159 * We relied on the rmapbt to reconstruct the AGF. If we get a 160 * different root then something's seriously wrong. 161 */ 162 if (fab[XREP_AGF_RMAPBT].root != 163 be32_to_cpu(old_agf->agf_roots[XFS_BTNUM_RMAPi])) 164 return -EFSCORRUPTED; 165 166 /* We must find the refcountbt root if that feature is enabled. */ 167 if (xfs_sb_version_hasreflink(&sc->mp->m_sb) && 168 !xrep_check_btree_root(sc, &fab[XREP_AGF_REFCOUNTBT])) 169 return -EFSCORRUPTED; 170 171 return 0; 172 } 173 174 /* 175 * Reinitialize the AGF header, making an in-core copy of the old contents so 176 * that we know which in-core state needs to be reinitialized. 177 */ 178 STATIC void 179 xrep_agf_init_header( 180 struct xfs_scrub *sc, 181 struct xfs_buf *agf_bp, 182 struct xfs_agf *old_agf) 183 { 184 struct xfs_mount *mp = sc->mp; 185 struct xfs_agf *agf = agf_bp->b_addr; 186 187 memcpy(old_agf, agf, sizeof(*old_agf)); 188 memset(agf, 0, BBTOB(agf_bp->b_length)); 189 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC); 190 agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION); 191 agf->agf_seqno = cpu_to_be32(sc->sa.agno); 192 agf->agf_length = cpu_to_be32(xfs_ag_block_count(mp, sc->sa.agno)); 193 agf->agf_flfirst = old_agf->agf_flfirst; 194 agf->agf_fllast = old_agf->agf_fllast; 195 agf->agf_flcount = old_agf->agf_flcount; 196 if (xfs_sb_version_hascrc(&mp->m_sb)) 197 uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid); 198 199 /* Mark the incore AGF data stale until we're done fixing things. */ 200 ASSERT(sc->sa.pag->pagf_init); 201 sc->sa.pag->pagf_init = 0; 202 } 203 204 /* Set btree root information in an AGF. */ 205 STATIC void 206 xrep_agf_set_roots( 207 struct xfs_scrub *sc, 208 struct xfs_agf *agf, 209 struct xrep_find_ag_btree *fab) 210 { 211 agf->agf_roots[XFS_BTNUM_BNOi] = 212 cpu_to_be32(fab[XREP_AGF_BNOBT].root); 213 agf->agf_levels[XFS_BTNUM_BNOi] = 214 cpu_to_be32(fab[XREP_AGF_BNOBT].height); 215 216 agf->agf_roots[XFS_BTNUM_CNTi] = 217 cpu_to_be32(fab[XREP_AGF_CNTBT].root); 218 agf->agf_levels[XFS_BTNUM_CNTi] = 219 cpu_to_be32(fab[XREP_AGF_CNTBT].height); 220 221 agf->agf_roots[XFS_BTNUM_RMAPi] = 222 cpu_to_be32(fab[XREP_AGF_RMAPBT].root); 223 agf->agf_levels[XFS_BTNUM_RMAPi] = 224 cpu_to_be32(fab[XREP_AGF_RMAPBT].height); 225 226 if (xfs_sb_version_hasreflink(&sc->mp->m_sb)) { 227 agf->agf_refcount_root = 228 cpu_to_be32(fab[XREP_AGF_REFCOUNTBT].root); 229 agf->agf_refcount_level = 230 cpu_to_be32(fab[XREP_AGF_REFCOUNTBT].height); 231 } 232 } 233 234 /* Update all AGF fields which derive from btree contents. */ 235 STATIC int 236 xrep_agf_calc_from_btrees( 237 struct xfs_scrub *sc, 238 struct xfs_buf *agf_bp) 239 { 240 struct xrep_agf_allocbt raa = { .sc = sc }; 241 struct xfs_btree_cur *cur = NULL; 242 struct xfs_agf *agf = agf_bp->b_addr; 243 struct xfs_mount *mp = sc->mp; 244 xfs_agblock_t btreeblks; 245 xfs_agblock_t blocks; 246 int error; 247 248 /* Update the AGF counters from the bnobt. */ 249 cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, 250 sc->sa.pag, XFS_BTNUM_BNO); 251 error = xfs_alloc_query_all(cur, xrep_agf_walk_allocbt, &raa); 252 if (error) 253 goto err; 254 error = xfs_btree_count_blocks(cur, &blocks); 255 if (error) 256 goto err; 257 xfs_btree_del_cursor(cur, error); 258 btreeblks = blocks - 1; 259 agf->agf_freeblks = cpu_to_be32(raa.freeblks); 260 agf->agf_longest = cpu_to_be32(raa.longest); 261 262 /* Update the AGF counters from the cntbt. */ 263 cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, 264 sc->sa.pag, XFS_BTNUM_CNT); 265 error = xfs_btree_count_blocks(cur, &blocks); 266 if (error) 267 goto err; 268 xfs_btree_del_cursor(cur, error); 269 btreeblks += blocks - 1; 270 271 /* Update the AGF counters from the rmapbt. */ 272 cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag); 273 error = xfs_btree_count_blocks(cur, &blocks); 274 if (error) 275 goto err; 276 xfs_btree_del_cursor(cur, error); 277 agf->agf_rmap_blocks = cpu_to_be32(blocks); 278 btreeblks += blocks - 1; 279 280 agf->agf_btreeblks = cpu_to_be32(btreeblks); 281 282 /* Update the AGF counters from the refcountbt. */ 283 if (xfs_sb_version_hasreflink(&mp->m_sb)) { 284 cur = xfs_refcountbt_init_cursor(mp, sc->tp, agf_bp, 285 sc->sa.pag); 286 error = xfs_btree_count_blocks(cur, &blocks); 287 if (error) 288 goto err; 289 xfs_btree_del_cursor(cur, error); 290 agf->agf_refcount_blocks = cpu_to_be32(blocks); 291 } 292 293 return 0; 294 err: 295 xfs_btree_del_cursor(cur, error); 296 return error; 297 } 298 299 /* Commit the new AGF and reinitialize the incore state. */ 300 STATIC int 301 xrep_agf_commit_new( 302 struct xfs_scrub *sc, 303 struct xfs_buf *agf_bp) 304 { 305 struct xfs_perag *pag; 306 struct xfs_agf *agf = agf_bp->b_addr; 307 308 /* Trigger fdblocks recalculation */ 309 xfs_force_summary_recalc(sc->mp); 310 311 /* Write this to disk. */ 312 xfs_trans_buf_set_type(sc->tp, agf_bp, XFS_BLFT_AGF_BUF); 313 xfs_trans_log_buf(sc->tp, agf_bp, 0, BBTOB(agf_bp->b_length) - 1); 314 315 /* Now reinitialize the in-core counters we changed. */ 316 pag = sc->sa.pag; 317 pag->pagf_btreeblks = be32_to_cpu(agf->agf_btreeblks); 318 pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks); 319 pag->pagf_longest = be32_to_cpu(agf->agf_longest); 320 pag->pagf_levels[XFS_BTNUM_BNOi] = 321 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNOi]); 322 pag->pagf_levels[XFS_BTNUM_CNTi] = 323 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]); 324 pag->pagf_levels[XFS_BTNUM_RMAPi] = 325 be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAPi]); 326 pag->pagf_refcount_level = be32_to_cpu(agf->agf_refcount_level); 327 pag->pagf_init = 1; 328 329 return 0; 330 } 331 332 /* Repair the AGF. v5 filesystems only. */ 333 int 334 xrep_agf( 335 struct xfs_scrub *sc) 336 { 337 struct xrep_find_ag_btree fab[XREP_AGF_MAX] = { 338 [XREP_AGF_BNOBT] = { 339 .rmap_owner = XFS_RMAP_OWN_AG, 340 .buf_ops = &xfs_bnobt_buf_ops, 341 }, 342 [XREP_AGF_CNTBT] = { 343 .rmap_owner = XFS_RMAP_OWN_AG, 344 .buf_ops = &xfs_cntbt_buf_ops, 345 }, 346 [XREP_AGF_RMAPBT] = { 347 .rmap_owner = XFS_RMAP_OWN_AG, 348 .buf_ops = &xfs_rmapbt_buf_ops, 349 }, 350 [XREP_AGF_REFCOUNTBT] = { 351 .rmap_owner = XFS_RMAP_OWN_REFC, 352 .buf_ops = &xfs_refcountbt_buf_ops, 353 }, 354 [XREP_AGF_END] = { 355 .buf_ops = NULL, 356 }, 357 }; 358 struct xfs_agf old_agf; 359 struct xfs_mount *mp = sc->mp; 360 struct xfs_buf *agf_bp; 361 struct xfs_buf *agfl_bp; 362 struct xfs_agf *agf; 363 int error; 364 365 /* We require the rmapbt to rebuild anything. */ 366 if (!xfs_sb_version_hasrmapbt(&mp->m_sb)) 367 return -EOPNOTSUPP; 368 369 xchk_perag_get(sc->mp, &sc->sa); 370 /* 371 * Make sure we have the AGF buffer, as scrub might have decided it 372 * was corrupt after xfs_alloc_read_agf failed with -EFSCORRUPTED. 373 */ 374 error = xfs_trans_read_buf(mp, sc->tp, mp->m_ddev_targp, 375 XFS_AG_DADDR(mp, sc->sa.agno, XFS_AGF_DADDR(mp)), 376 XFS_FSS_TO_BB(mp, 1), 0, &agf_bp, NULL); 377 if (error) 378 return error; 379 agf_bp->b_ops = &xfs_agf_buf_ops; 380 agf = agf_bp->b_addr; 381 382 /* 383 * Load the AGFL so that we can screen out OWN_AG blocks that are on 384 * the AGFL now; these blocks might have once been part of the 385 * bno/cnt/rmap btrees but are not now. This is a chicken and egg 386 * problem: the AGF is corrupt, so we have to trust the AGFL contents 387 * because we can't do any serious cross-referencing with any of the 388 * btrees rooted in the AGF. If the AGFL contents are obviously bad 389 * then we'll bail out. 390 */ 391 error = xfs_alloc_read_agfl(mp, sc->tp, sc->sa.agno, &agfl_bp); 392 if (error) 393 return error; 394 395 /* 396 * Spot-check the AGFL blocks; if they're obviously corrupt then 397 * there's nothing we can do but bail out. 398 */ 399 error = xfs_agfl_walk(sc->mp, agf_bp->b_addr, agfl_bp, 400 xrep_agf_check_agfl_block, sc); 401 if (error) 402 return error; 403 404 /* 405 * Find the AGF btree roots. This is also a chicken-and-egg situation; 406 * see the function for more details. 407 */ 408 error = xrep_agf_find_btrees(sc, agf_bp, fab, agfl_bp); 409 if (error) 410 return error; 411 412 /* Start rewriting the header and implant the btrees we found. */ 413 xrep_agf_init_header(sc, agf_bp, &old_agf); 414 xrep_agf_set_roots(sc, agf, fab); 415 error = xrep_agf_calc_from_btrees(sc, agf_bp); 416 if (error) 417 goto out_revert; 418 419 /* Commit the changes and reinitialize incore state. */ 420 return xrep_agf_commit_new(sc, agf_bp); 421 422 out_revert: 423 /* Mark the incore AGF state stale and revert the AGF. */ 424 sc->sa.pag->pagf_init = 0; 425 memcpy(agf, &old_agf, sizeof(old_agf)); 426 return error; 427 } 428 429 /* AGFL */ 430 431 struct xrep_agfl { 432 /* Bitmap of other OWN_AG metadata blocks. */ 433 struct xbitmap agmetablocks; 434 435 /* Bitmap of free space. */ 436 struct xbitmap *freesp; 437 438 struct xfs_scrub *sc; 439 }; 440 441 /* Record all OWN_AG (free space btree) information from the rmap data. */ 442 STATIC int 443 xrep_agfl_walk_rmap( 444 struct xfs_btree_cur *cur, 445 struct xfs_rmap_irec *rec, 446 void *priv) 447 { 448 struct xrep_agfl *ra = priv; 449 xfs_fsblock_t fsb; 450 int error = 0; 451 452 if (xchk_should_terminate(ra->sc, &error)) 453 return error; 454 455 /* Record all the OWN_AG blocks. */ 456 if (rec->rm_owner == XFS_RMAP_OWN_AG) { 457 fsb = XFS_AGB_TO_FSB(cur->bc_mp, cur->bc_ag.pag->pag_agno, 458 rec->rm_startblock); 459 error = xbitmap_set(ra->freesp, fsb, rec->rm_blockcount); 460 if (error) 461 return error; 462 } 463 464 return xbitmap_set_btcur_path(&ra->agmetablocks, cur); 465 } 466 467 /* 468 * Map out all the non-AGFL OWN_AG space in this AG so that we can deduce 469 * which blocks belong to the AGFL. 470 * 471 * Compute the set of old AGFL blocks by subtracting from the list of OWN_AG 472 * blocks the list of blocks owned by all other OWN_AG metadata (bnobt, cntbt, 473 * rmapbt). These are the old AGFL blocks, so return that list and the number 474 * of blocks we're actually going to put back on the AGFL. 475 */ 476 STATIC int 477 xrep_agfl_collect_blocks( 478 struct xfs_scrub *sc, 479 struct xfs_buf *agf_bp, 480 struct xbitmap *agfl_extents, 481 xfs_agblock_t *flcount) 482 { 483 struct xrep_agfl ra; 484 struct xfs_mount *mp = sc->mp; 485 struct xfs_btree_cur *cur; 486 int error; 487 488 ra.sc = sc; 489 ra.freesp = agfl_extents; 490 xbitmap_init(&ra.agmetablocks); 491 492 /* Find all space used by the free space btrees & rmapbt. */ 493 cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag); 494 error = xfs_rmap_query_all(cur, xrep_agfl_walk_rmap, &ra); 495 if (error) 496 goto err; 497 xfs_btree_del_cursor(cur, error); 498 499 /* Find all blocks currently being used by the bnobt. */ 500 cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, 501 sc->sa.pag, XFS_BTNUM_BNO); 502 error = xbitmap_set_btblocks(&ra.agmetablocks, cur); 503 if (error) 504 goto err; 505 xfs_btree_del_cursor(cur, error); 506 507 /* Find all blocks currently being used by the cntbt. */ 508 cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, 509 sc->sa.pag, XFS_BTNUM_CNT); 510 error = xbitmap_set_btblocks(&ra.agmetablocks, cur); 511 if (error) 512 goto err; 513 514 xfs_btree_del_cursor(cur, error); 515 516 /* 517 * Drop the freesp meta blocks that are in use by btrees. 518 * The remaining blocks /should/ be AGFL blocks. 519 */ 520 error = xbitmap_disunion(agfl_extents, &ra.agmetablocks); 521 xbitmap_destroy(&ra.agmetablocks); 522 if (error) 523 return error; 524 525 /* 526 * Calculate the new AGFL size. If we found more blocks than fit in 527 * the AGFL we'll free them later. 528 */ 529 *flcount = min_t(uint64_t, xbitmap_hweight(agfl_extents), 530 xfs_agfl_size(mp)); 531 return 0; 532 533 err: 534 xbitmap_destroy(&ra.agmetablocks); 535 xfs_btree_del_cursor(cur, error); 536 return error; 537 } 538 539 /* Update the AGF and reset the in-core state. */ 540 STATIC void 541 xrep_agfl_update_agf( 542 struct xfs_scrub *sc, 543 struct xfs_buf *agf_bp, 544 xfs_agblock_t flcount) 545 { 546 struct xfs_agf *agf = agf_bp->b_addr; 547 548 ASSERT(flcount <= xfs_agfl_size(sc->mp)); 549 550 /* Trigger fdblocks recalculation */ 551 xfs_force_summary_recalc(sc->mp); 552 553 /* Update the AGF counters. */ 554 if (sc->sa.pag->pagf_init) 555 sc->sa.pag->pagf_flcount = flcount; 556 agf->agf_flfirst = cpu_to_be32(0); 557 agf->agf_flcount = cpu_to_be32(flcount); 558 agf->agf_fllast = cpu_to_be32(flcount - 1); 559 560 xfs_alloc_log_agf(sc->tp, agf_bp, 561 XFS_AGF_FLFIRST | XFS_AGF_FLLAST | XFS_AGF_FLCOUNT); 562 } 563 564 /* Write out a totally new AGFL. */ 565 STATIC void 566 xrep_agfl_init_header( 567 struct xfs_scrub *sc, 568 struct xfs_buf *agfl_bp, 569 struct xbitmap *agfl_extents, 570 xfs_agblock_t flcount) 571 { 572 struct xfs_mount *mp = sc->mp; 573 __be32 *agfl_bno; 574 struct xbitmap_range *br; 575 struct xbitmap_range *n; 576 struct xfs_agfl *agfl; 577 xfs_agblock_t agbno; 578 unsigned int fl_off; 579 580 ASSERT(flcount <= xfs_agfl_size(mp)); 581 582 /* 583 * Start rewriting the header by setting the bno[] array to 584 * NULLAGBLOCK, then setting AGFL header fields. 585 */ 586 agfl = XFS_BUF_TO_AGFL(agfl_bp); 587 memset(agfl, 0xFF, BBTOB(agfl_bp->b_length)); 588 agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC); 589 agfl->agfl_seqno = cpu_to_be32(sc->sa.agno); 590 uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid); 591 592 /* 593 * Fill the AGFL with the remaining blocks. If agfl_extents has more 594 * blocks than fit in the AGFL, they will be freed in a subsequent 595 * step. 596 */ 597 fl_off = 0; 598 agfl_bno = xfs_buf_to_agfl_bno(agfl_bp); 599 for_each_xbitmap_extent(br, n, agfl_extents) { 600 agbno = XFS_FSB_TO_AGBNO(mp, br->start); 601 602 trace_xrep_agfl_insert(mp, sc->sa.agno, agbno, br->len); 603 604 while (br->len > 0 && fl_off < flcount) { 605 agfl_bno[fl_off] = cpu_to_be32(agbno); 606 fl_off++; 607 agbno++; 608 609 /* 610 * We've now used br->start by putting it in the AGFL, 611 * so bump br so that we don't reap the block later. 612 */ 613 br->start++; 614 br->len--; 615 } 616 617 if (br->len) 618 break; 619 list_del(&br->list); 620 kmem_free(br); 621 } 622 623 /* Write new AGFL to disk. */ 624 xfs_trans_buf_set_type(sc->tp, agfl_bp, XFS_BLFT_AGFL_BUF); 625 xfs_trans_log_buf(sc->tp, agfl_bp, 0, BBTOB(agfl_bp->b_length) - 1); 626 } 627 628 /* Repair the AGFL. */ 629 int 630 xrep_agfl( 631 struct xfs_scrub *sc) 632 { 633 struct xbitmap agfl_extents; 634 struct xfs_mount *mp = sc->mp; 635 struct xfs_buf *agf_bp; 636 struct xfs_buf *agfl_bp; 637 xfs_agblock_t flcount; 638 int error; 639 640 /* We require the rmapbt to rebuild anything. */ 641 if (!xfs_sb_version_hasrmapbt(&mp->m_sb)) 642 return -EOPNOTSUPP; 643 644 xchk_perag_get(sc->mp, &sc->sa); 645 xbitmap_init(&agfl_extents); 646 647 /* 648 * Read the AGF so that we can query the rmapbt. We hope that there's 649 * nothing wrong with the AGF, but all the AG header repair functions 650 * have this chicken-and-egg problem. 651 */ 652 error = xfs_alloc_read_agf(mp, sc->tp, sc->sa.agno, 0, &agf_bp); 653 if (error) 654 return error; 655 656 /* 657 * Make sure we have the AGFL buffer, as scrub might have decided it 658 * was corrupt after xfs_alloc_read_agfl failed with -EFSCORRUPTED. 659 */ 660 error = xfs_trans_read_buf(mp, sc->tp, mp->m_ddev_targp, 661 XFS_AG_DADDR(mp, sc->sa.agno, XFS_AGFL_DADDR(mp)), 662 XFS_FSS_TO_BB(mp, 1), 0, &agfl_bp, NULL); 663 if (error) 664 return error; 665 agfl_bp->b_ops = &xfs_agfl_buf_ops; 666 667 /* Gather all the extents we're going to put on the new AGFL. */ 668 error = xrep_agfl_collect_blocks(sc, agf_bp, &agfl_extents, &flcount); 669 if (error) 670 goto err; 671 672 /* 673 * Update AGF and AGFL. We reset the global free block counter when 674 * we adjust the AGF flcount (which can fail) so avoid updating any 675 * buffers until we know that part works. 676 */ 677 xrep_agfl_update_agf(sc, agf_bp, flcount); 678 xrep_agfl_init_header(sc, agfl_bp, &agfl_extents, flcount); 679 680 /* 681 * Ok, the AGFL should be ready to go now. Roll the transaction to 682 * make the new AGFL permanent before we start using it to return 683 * freespace overflow to the freespace btrees. 684 */ 685 sc->sa.agf_bp = agf_bp; 686 sc->sa.agfl_bp = agfl_bp; 687 error = xrep_roll_ag_trans(sc); 688 if (error) 689 goto err; 690 691 /* Dump any AGFL overflow. */ 692 error = xrep_reap_extents(sc, &agfl_extents, &XFS_RMAP_OINFO_AG, 693 XFS_AG_RESV_AGFL); 694 err: 695 xbitmap_destroy(&agfl_extents); 696 return error; 697 } 698 699 /* AGI */ 700 701 /* 702 * Offset within the xrep_find_ag_btree array for each btree type. Avoid the 703 * XFS_BTNUM_ names here to avoid creating a sparse array. 704 */ 705 enum { 706 XREP_AGI_INOBT = 0, 707 XREP_AGI_FINOBT, 708 XREP_AGI_END, 709 XREP_AGI_MAX 710 }; 711 712 /* 713 * Given the inode btree roots described by *fab, find the roots, check them 714 * for sanity, and pass the root data back out via *fab. 715 */ 716 STATIC int 717 xrep_agi_find_btrees( 718 struct xfs_scrub *sc, 719 struct xrep_find_ag_btree *fab) 720 { 721 struct xfs_buf *agf_bp; 722 struct xfs_mount *mp = sc->mp; 723 int error; 724 725 /* Read the AGF. */ 726 error = xfs_alloc_read_agf(mp, sc->tp, sc->sa.agno, 0, &agf_bp); 727 if (error) 728 return error; 729 730 /* Find the btree roots. */ 731 error = xrep_find_ag_btree_roots(sc, agf_bp, fab, NULL); 732 if (error) 733 return error; 734 735 /* We must find the inobt root. */ 736 if (!xrep_check_btree_root(sc, &fab[XREP_AGI_INOBT])) 737 return -EFSCORRUPTED; 738 739 /* We must find the finobt root if that feature is enabled. */ 740 if (xfs_sb_version_hasfinobt(&mp->m_sb) && 741 !xrep_check_btree_root(sc, &fab[XREP_AGI_FINOBT])) 742 return -EFSCORRUPTED; 743 744 return 0; 745 } 746 747 /* 748 * Reinitialize the AGI header, making an in-core copy of the old contents so 749 * that we know which in-core state needs to be reinitialized. 750 */ 751 STATIC void 752 xrep_agi_init_header( 753 struct xfs_scrub *sc, 754 struct xfs_buf *agi_bp, 755 struct xfs_agi *old_agi) 756 { 757 struct xfs_agi *agi = agi_bp->b_addr; 758 struct xfs_mount *mp = sc->mp; 759 760 memcpy(old_agi, agi, sizeof(*old_agi)); 761 memset(agi, 0, BBTOB(agi_bp->b_length)); 762 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC); 763 agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION); 764 agi->agi_seqno = cpu_to_be32(sc->sa.agno); 765 agi->agi_length = cpu_to_be32(xfs_ag_block_count(mp, sc->sa.agno)); 766 agi->agi_newino = cpu_to_be32(NULLAGINO); 767 agi->agi_dirino = cpu_to_be32(NULLAGINO); 768 if (xfs_sb_version_hascrc(&mp->m_sb)) 769 uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid); 770 771 /* We don't know how to fix the unlinked list yet. */ 772 memcpy(&agi->agi_unlinked, &old_agi->agi_unlinked, 773 sizeof(agi->agi_unlinked)); 774 775 /* Mark the incore AGF data stale until we're done fixing things. */ 776 ASSERT(sc->sa.pag->pagi_init); 777 sc->sa.pag->pagi_init = 0; 778 } 779 780 /* Set btree root information in an AGI. */ 781 STATIC void 782 xrep_agi_set_roots( 783 struct xfs_scrub *sc, 784 struct xfs_agi *agi, 785 struct xrep_find_ag_btree *fab) 786 { 787 agi->agi_root = cpu_to_be32(fab[XREP_AGI_INOBT].root); 788 agi->agi_level = cpu_to_be32(fab[XREP_AGI_INOBT].height); 789 790 if (xfs_sb_version_hasfinobt(&sc->mp->m_sb)) { 791 agi->agi_free_root = cpu_to_be32(fab[XREP_AGI_FINOBT].root); 792 agi->agi_free_level = cpu_to_be32(fab[XREP_AGI_FINOBT].height); 793 } 794 } 795 796 /* Update the AGI counters. */ 797 STATIC int 798 xrep_agi_calc_from_btrees( 799 struct xfs_scrub *sc, 800 struct xfs_buf *agi_bp) 801 { 802 struct xfs_btree_cur *cur; 803 struct xfs_agi *agi = agi_bp->b_addr; 804 struct xfs_mount *mp = sc->mp; 805 xfs_agino_t count; 806 xfs_agino_t freecount; 807 int error; 808 809 cur = xfs_inobt_init_cursor(mp, sc->tp, agi_bp, 810 sc->sa.pag, XFS_BTNUM_INO); 811 error = xfs_ialloc_count_inodes(cur, &count, &freecount); 812 if (error) 813 goto err; 814 if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) { 815 xfs_agblock_t blocks; 816 817 error = xfs_btree_count_blocks(cur, &blocks); 818 if (error) 819 goto err; 820 agi->agi_iblocks = cpu_to_be32(blocks); 821 } 822 xfs_btree_del_cursor(cur, error); 823 824 agi->agi_count = cpu_to_be32(count); 825 agi->agi_freecount = cpu_to_be32(freecount); 826 827 if (xfs_sb_version_hasfinobt(&mp->m_sb) && 828 xfs_sb_version_hasinobtcounts(&mp->m_sb)) { 829 xfs_agblock_t blocks; 830 831 cur = xfs_inobt_init_cursor(mp, sc->tp, agi_bp, 832 sc->sa.pag, XFS_BTNUM_FINO); 833 error = xfs_btree_count_blocks(cur, &blocks); 834 if (error) 835 goto err; 836 xfs_btree_del_cursor(cur, error); 837 agi->agi_fblocks = cpu_to_be32(blocks); 838 } 839 840 return 0; 841 err: 842 xfs_btree_del_cursor(cur, error); 843 return error; 844 } 845 846 /* Trigger reinitialization of the in-core data. */ 847 STATIC int 848 xrep_agi_commit_new( 849 struct xfs_scrub *sc, 850 struct xfs_buf *agi_bp) 851 { 852 struct xfs_perag *pag; 853 struct xfs_agi *agi = agi_bp->b_addr; 854 855 /* Trigger inode count recalculation */ 856 xfs_force_summary_recalc(sc->mp); 857 858 /* Write this to disk. */ 859 xfs_trans_buf_set_type(sc->tp, agi_bp, XFS_BLFT_AGI_BUF); 860 xfs_trans_log_buf(sc->tp, agi_bp, 0, BBTOB(agi_bp->b_length) - 1); 861 862 /* Now reinitialize the in-core counters if necessary. */ 863 pag = sc->sa.pag; 864 pag->pagi_count = be32_to_cpu(agi->agi_count); 865 pag->pagi_freecount = be32_to_cpu(agi->agi_freecount); 866 pag->pagi_init = 1; 867 868 return 0; 869 } 870 871 /* Repair the AGI. */ 872 int 873 xrep_agi( 874 struct xfs_scrub *sc) 875 { 876 struct xrep_find_ag_btree fab[XREP_AGI_MAX] = { 877 [XREP_AGI_INOBT] = { 878 .rmap_owner = XFS_RMAP_OWN_INOBT, 879 .buf_ops = &xfs_inobt_buf_ops, 880 }, 881 [XREP_AGI_FINOBT] = { 882 .rmap_owner = XFS_RMAP_OWN_INOBT, 883 .buf_ops = &xfs_finobt_buf_ops, 884 }, 885 [XREP_AGI_END] = { 886 .buf_ops = NULL 887 }, 888 }; 889 struct xfs_agi old_agi; 890 struct xfs_mount *mp = sc->mp; 891 struct xfs_buf *agi_bp; 892 struct xfs_agi *agi; 893 int error; 894 895 /* We require the rmapbt to rebuild anything. */ 896 if (!xfs_sb_version_hasrmapbt(&mp->m_sb)) 897 return -EOPNOTSUPP; 898 899 xchk_perag_get(sc->mp, &sc->sa); 900 /* 901 * Make sure we have the AGI buffer, as scrub might have decided it 902 * was corrupt after xfs_ialloc_read_agi failed with -EFSCORRUPTED. 903 */ 904 error = xfs_trans_read_buf(mp, sc->tp, mp->m_ddev_targp, 905 XFS_AG_DADDR(mp, sc->sa.agno, XFS_AGI_DADDR(mp)), 906 XFS_FSS_TO_BB(mp, 1), 0, &agi_bp, NULL); 907 if (error) 908 return error; 909 agi_bp->b_ops = &xfs_agi_buf_ops; 910 agi = agi_bp->b_addr; 911 912 /* Find the AGI btree roots. */ 913 error = xrep_agi_find_btrees(sc, fab); 914 if (error) 915 return error; 916 917 /* Start rewriting the header and implant the btrees we found. */ 918 xrep_agi_init_header(sc, agi_bp, &old_agi); 919 xrep_agi_set_roots(sc, agi, fab); 920 error = xrep_agi_calc_from_btrees(sc, agi_bp); 921 if (error) 922 goto out_revert; 923 924 /* Reinitialize in-core state. */ 925 return xrep_agi_commit_new(sc, agi_bp); 926 927 out_revert: 928 /* Mark the incore AGI state stale and revert the AGI. */ 929 sc->sa.pag->pagi_init = 0; 930 memcpy(agi, &old_agi, sizeof(old_agi)); 931 return error; 932 } 933