fs/xfs/scrub/agheader_repair.c

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