fs/xfs/scrub/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_inode.h"
  17 #include "xfs_alloc.h"
  18 #include "xfs_alloc_btree.h"
  19 #include "xfs_ialloc.h"
  20 #include "xfs_ialloc_btree.h"
  21 #include "xfs_rmap.h"
  22 #include "xfs_rmap_btree.h"
  23 #include "xfs_refcount_btree.h"
  24 #include "xfs_extent_busy.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_ag_resv.h"
  27 #include "xfs_quota.h"
  28 #include "xfs_qm.h"
  29 #include "scrub/scrub.h"
  30 #include "scrub/common.h"
  31 #include "scrub/trace.h"
  32 #include "scrub/repair.h"
  33 #include "scrub/bitmap.h"
  34
  35 /*
  36  * Attempt to repair some metadata, if the metadata is corrupt and userspace
  37  * told us to fix it.  This function returns -EAGAIN to mean "re-run scrub",
  38  * and will set *fixed to true if it thinks it repaired anything.
  39  */
  40 int
  41 xrep_attempt(
  42         struct xfs_scrub        *sc)
  43 {
  44         int                     error = 0;
  45
  46         trace_xrep_attempt(XFS_I(file_inode(sc->file)), sc->sm, error);
  47
  48         xchk_ag_btcur_free(&sc->sa);
  49
  50         /* Repair whatever's broken. */
  51         ASSERT(sc->ops->repair);
  52         error = sc->ops->repair(sc);
  53         trace_xrep_done(XFS_I(file_inode(sc->file)), sc->sm, error);
  54         switch (error) {
  55         case 0:
  56                 /*
  57                  * Repair succeeded.  Commit the fixes and perform a second
  58                  * scrub so that we can tell userspace if we fixed the problem.
  59                  */
  60                 sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT;
  61                 sc->flags |= XREP_ALREADY_FIXED;
  62                 return -EAGAIN;
  63         case -EDEADLOCK:
  64         case -EAGAIN:
  65                 /* Tell the caller to try again having grabbed all the locks. */
  66                 if (!(sc->flags & XCHK_TRY_HARDER)) {
  67                         sc->flags |= XCHK_TRY_HARDER;
  68                         return -EAGAIN;
  69                 }
  70                 /*
  71                  * We tried harder but still couldn't grab all the resources
  72                  * we needed to fix it.  The corruption has not been fixed,
  73                  * so report back to userspace.
  74                  */
  75                 return -EFSCORRUPTED;
  76         default:
  77                 return error;
  78         }
  79 }
  80
  81 /*
  82  * Complain about unfixable problems in the filesystem.  We don't log
  83  * corruptions when IFLAG_REPAIR wasn't set on the assumption that the driver
  84  * program is xfs_scrub, which will call back with IFLAG_REPAIR set if the
  85  * administrator isn't running xfs_scrub in no-repairs mode.
  86  *
  87  * Use this helper function because _ratelimited silently declares a static
  88  * structure to track rate limiting information.
  89  */
  90 void
  91 xrep_failure(
  92         struct xfs_mount        *mp)
  93 {
  94         xfs_alert_ratelimited(mp,
  95 "Corruption not fixed during online repair.  Unmount and run xfs_repair.");
  96 }
  97
  98 /*
  99  * Repair probe -- userspace uses this to probe if we're willing to repair a
 100  * given mountpoint.
 101  */
 102 int
 103 xrep_probe(
 104         struct xfs_scrub        *sc)
 105 {
 106         int                     error = 0;
 107
 108         if (xchk_should_terminate(sc, &error))
 109                 return error;
 110
 111         return 0;
 112 }
 113
 114 /*
 115  * Roll a transaction, keeping the AG headers locked and reinitializing
 116  * the btree cursors.
 117  */
 118 int
 119 xrep_roll_ag_trans(
 120         struct xfs_scrub        *sc)
 121 {
 122         int                     error;
 123
 124         /* Keep the AG header buffers locked so we can keep going. */
 125         if (sc->sa.agi_bp)
 126                 xfs_trans_bhold(sc->tp, sc->sa.agi_bp);
 127         if (sc->sa.agf_bp)
 128                 xfs_trans_bhold(sc->tp, sc->sa.agf_bp);
 129         if (sc->sa.agfl_bp)
 130                 xfs_trans_bhold(sc->tp, sc->sa.agfl_bp);
 131
 132         /*
 133          * Roll the transaction.  We still own the buffer and the buffer lock
 134          * regardless of whether or not the roll succeeds.  If the roll fails,
 135          * the buffers will be released during teardown on our way out of the
 136          * kernel.  If it succeeds, we join them to the new transaction and
 137          * move on.
 138          */
 139         error = xfs_trans_roll(&sc->tp);
 140         if (error)
 141                 return error;
 142
 143         /* Join AG headers to the new transaction. */
 144         if (sc->sa.agi_bp)
 145                 xfs_trans_bjoin(sc->tp, sc->sa.agi_bp);
 146         if (sc->sa.agf_bp)
 147                 xfs_trans_bjoin(sc->tp, sc->sa.agf_bp);
 148         if (sc->sa.agfl_bp)
 149                 xfs_trans_bjoin(sc->tp, sc->sa.agfl_bp);
 150
 151         return 0;
 152 }
 153
 154 /*
 155  * Does the given AG have enough space to rebuild a btree?  Neither AG
 156  * reservation can be critical, and we must have enough space (factoring
 157  * in AG reservations) to construct a whole btree.
 158  */
 159 bool
 160 xrep_ag_has_space(
 161         struct xfs_perag        *pag,
 162         xfs_extlen_t            nr_blocks,
 163         enum xfs_ag_resv_type   type)
 164 {
 165         return  !xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) &&
 166                 !xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA) &&
 167                 pag->pagf_freeblks > xfs_ag_resv_needed(pag, type) + nr_blocks;
 168 }
 169
 170 /*
 171  * Figure out how many blocks to reserve for an AG repair.  We calculate the
 172  * worst case estimate for the number of blocks we'd need to rebuild one of
 173  * any type of per-AG btree.
 174  */
 175 xfs_extlen_t
 176 xrep_calc_ag_resblks(
 177         struct xfs_scrub                *sc)
 178 {
 179         struct xfs_mount                *mp = sc->mp;
 180         struct xfs_scrub_metadata       *sm = sc->sm;
 181         struct xfs_perag                *pag;
 182         struct xfs_buf                  *bp;
 183         xfs_agino_t                     icount = NULLAGINO;
 184         xfs_extlen_t                    aglen = NULLAGBLOCK;
 185         xfs_extlen_t                    usedlen;
 186         xfs_extlen_t                    freelen;
 187         xfs_extlen_t                    bnobt_sz;
 188         xfs_extlen_t                    inobt_sz;
 189         xfs_extlen_t                    rmapbt_sz;
 190         xfs_extlen_t                    refcbt_sz;
 191         int                             error;
 192
 193         if (!(sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR))
 194                 return 0;
 195
 196         pag = xfs_perag_get(mp, sm->sm_agno);
 197         if (pag->pagi_init) {
 198                 /* Use in-core icount if possible. */
 199                 icount = pag->pagi_count;
 200         } else {
 201                 /* Try to get the actual counters from disk. */
 202                 error = xfs_ialloc_read_agi(pag, NULL, &bp);
 203                 if (!error) {
 204                         icount = pag->pagi_count;
 205                         xfs_buf_relse(bp);
 206                 }
 207         }
 208
 209         /* Now grab the block counters from the AGF. */
 210         error = xfs_alloc_read_agf(pag, NULL, 0, &bp);
 211         if (error) {
 212                 aglen = xfs_ag_block_count(mp, sm->sm_agno);
 213                 freelen = aglen;
 214                 usedlen = aglen;
 215         } else {
 216                 struct xfs_agf  *agf = bp->b_addr;
 217
 218                 aglen = be32_to_cpu(agf->agf_length);
 219                 freelen = be32_to_cpu(agf->agf_freeblks);
 220                 usedlen = aglen - freelen;
 221                 xfs_buf_relse(bp);
 222         }
 223
 224         /* If the icount is impossible, make some worst-case assumptions. */
 225         if (icount == NULLAGINO ||
 226             !xfs_verify_agino(pag, icount)) {
 227                 icount = pag->agino_max - pag->agino_min + 1;
 228         }
 229         xfs_perag_put(pag);
 230
 231         /* If the block counts are impossible, make worst-case assumptions. */
 232         if (aglen == NULLAGBLOCK ||
 233             aglen != xfs_ag_block_count(mp, sm->sm_agno) ||
 234             freelen >= aglen) {
 235                 aglen = xfs_ag_block_count(mp, sm->sm_agno);
 236                 freelen = aglen;
 237                 usedlen = aglen;
 238         }
 239
 240         trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
 241                         freelen, usedlen);
 242
 243         /*
 244          * Figure out how many blocks we'd need worst case to rebuild
 245          * each type of btree.  Note that we can only rebuild the
 246          * bnobt/cntbt or inobt/finobt as pairs.
 247          */
 248         bnobt_sz = 2 * xfs_allocbt_calc_size(mp, freelen);
 249         if (xfs_has_sparseinodes(mp))
 250                 inobt_sz = xfs_iallocbt_calc_size(mp, icount /
 251                                 XFS_INODES_PER_HOLEMASK_BIT);
 252         else
 253                 inobt_sz = xfs_iallocbt_calc_size(mp, icount /
 254                                 XFS_INODES_PER_CHUNK);
 255         if (xfs_has_finobt(mp))
 256                 inobt_sz *= 2;
 257         if (xfs_has_reflink(mp))
 258                 refcbt_sz = xfs_refcountbt_calc_size(mp, usedlen);
 259         else
 260                 refcbt_sz = 0;
 261         if (xfs_has_rmapbt(mp)) {
 262                 /*
 263                  * Guess how many blocks we need to rebuild the rmapbt.
 264                  * For non-reflink filesystems we can't have more records than
 265                  * used blocks.  However, with reflink it's possible to have
 266                  * more than one rmap record per AG block.  We don't know how
 267                  * many rmaps there could be in the AG, so we start off with
 268                  * what we hope is an generous over-estimation.
 269                  */
 270                 if (xfs_has_reflink(mp))
 271                         rmapbt_sz = xfs_rmapbt_calc_size(mp,
 272                                         (unsigned long long)aglen * 2);
 273                 else
 274                         rmapbt_sz = xfs_rmapbt_calc_size(mp, usedlen);
 275         } else {
 276                 rmapbt_sz = 0;
 277         }
 278
 279         trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
 280                         inobt_sz, rmapbt_sz, refcbt_sz);
 281
 282         return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz));
 283 }
 284
 285 /* Allocate a block in an AG. */
 286 int
 287 xrep_alloc_ag_block(
 288         struct xfs_scrub                *sc,
 289         const struct xfs_owner_info     *oinfo,
 290         xfs_fsblock_t                   *fsbno,
 291         enum xfs_ag_resv_type           resv)
 292 {
 293         struct xfs_alloc_arg            args = {0};
 294         xfs_agblock_t                   bno;
 295         int                             error;
 296
 297         switch (resv) {
 298         case XFS_AG_RESV_AGFL:
 299         case XFS_AG_RESV_RMAPBT:
 300                 error = xfs_alloc_get_freelist(sc->sa.pag, sc->tp,
 301                                 sc->sa.agf_bp, &bno, 1);
 302                 if (error)
 303                         return error;
 304                 if (bno == NULLAGBLOCK)
 305                         return -ENOSPC;
 306                 xfs_extent_busy_reuse(sc->mp, sc->sa.pag, bno, 1, false);
 307                 *fsbno = XFS_AGB_TO_FSB(sc->mp, sc->sa.pag->pag_agno, bno);
 308                 if (resv == XFS_AG_RESV_RMAPBT)
 309                         xfs_ag_resv_rmapbt_alloc(sc->mp, sc->sa.pag->pag_agno);
 310                 return 0;
 311         default:
 312                 break;
 313         }
 314
 315         args.tp = sc->tp;
 316         args.mp = sc->mp;
 317         args.oinfo = *oinfo;
 318         args.fsbno = XFS_AGB_TO_FSB(args.mp, sc->sa.pag->pag_agno, 0);
 319         args.minlen = 1;
 320         args.maxlen = 1;
 321         args.prod = 1;
 322         args.type = XFS_ALLOCTYPE_THIS_AG;
 323         args.resv = resv;
 324
 325         error = xfs_alloc_vextent(&args);
 326         if (error)
 327                 return error;
 328         if (args.fsbno == NULLFSBLOCK)
 329                 return -ENOSPC;
 330         ASSERT(args.len == 1);
 331         *fsbno = args.fsbno;
 332
 333         return 0;
 334 }
 335
 336 /* Initialize a new AG btree root block with zero entries. */
 337 int
 338 xrep_init_btblock(
 339         struct xfs_scrub                *sc,
 340         xfs_fsblock_t                   fsb,
 341         struct xfs_buf                  **bpp,
 342         xfs_btnum_t                     btnum,
 343         const struct xfs_buf_ops        *ops)
 344 {
 345         struct xfs_trans                *tp = sc->tp;
 346         struct xfs_mount                *mp = sc->mp;
 347         struct xfs_buf                  *bp;
 348         int                             error;
 349
 350         trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
 351                         XFS_FSB_TO_AGBNO(mp, fsb), btnum);
 352
 353         ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.pag->pag_agno);
 354         error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 355                         XFS_FSB_TO_DADDR(mp, fsb), XFS_FSB_TO_BB(mp, 1), 0,
 356                         &bp);
 357         if (error)
 358                 return error;
 359         xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
 360         xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.pag->pag_agno);
 361         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);
 362         xfs_trans_log_buf(tp, bp, 0, BBTOB(bp->b_length) - 1);
 363         bp->b_ops = ops;
 364         *bpp = bp;
 365
 366         return 0;
 367 }
 368
 369 /*
 370  * Reconstructing per-AG Btrees
 371  *
 372  * When a space btree is corrupt, we don't bother trying to fix it.  Instead,
 373  * we scan secondary space metadata to derive the records that should be in
 374  * the damaged btree, initialize a fresh btree root, and insert the records.
 375  * Note that for rebuilding the rmapbt we scan all the primary data to
 376  * generate the new records.
 377  *
 378  * However, that leaves the matter of removing all the metadata describing the
 379  * old broken structure.  For primary metadata we use the rmap data to collect
 380  * every extent with a matching rmap owner (bitmap); we then iterate all other
 381  * metadata structures with the same rmap owner to collect the extents that
 382  * cannot be removed (sublist).  We then subtract sublist from bitmap to
 383  * derive the blocks that were used by the old btree.  These blocks can be
 384  * reaped.
 385  *
 386  * For rmapbt reconstructions we must use different tactics for extent
 387  * collection.  First we iterate all primary metadata (this excludes the old
 388  * rmapbt, obviously) to generate new rmap records.  The gaps in the rmap
 389  * records are collected as bitmap.  The bnobt records are collected as
 390  * sublist.  As with the other btrees we subtract sublist from bitmap, and the
 391  * result (since the rmapbt lives in the free space) are the blocks from the
 392  * old rmapbt.
 393  *
 394  * Disposal of Blocks from Old per-AG Btrees
 395  *
 396  * Now that we've constructed a new btree to replace the damaged one, we want
 397  * to dispose of the blocks that (we think) the old btree was using.
 398  * Previously, we used the rmapbt to collect the extents (bitmap) with the
 399  * rmap owner corresponding to the tree we rebuilt, collected extents for any
 400  * blocks with the same rmap owner that are owned by another data structure
 401  * (sublist), and subtracted sublist from bitmap.  In theory the extents
 402  * remaining in bitmap are the old btree's blocks.
 403  *
 404  * Unfortunately, it's possible that the btree was crosslinked with other
 405  * blocks on disk.  The rmap data can tell us if there are multiple owners, so
 406  * if the rmapbt says there is an owner of this block other than @oinfo, then
 407  * the block is crosslinked.  Remove the reverse mapping and continue.
 408  *
 409  * If there is one rmap record, we can free the block, which removes the
 410  * reverse mapping but doesn't add the block to the free space.  Our repair
 411  * strategy is to hope the other metadata objects crosslinked on this block
 412  * will be rebuilt (atop different blocks), thereby removing all the cross
 413  * links.
 414  *
 415  * If there are no rmap records at all, we also free the block.  If the btree
 416  * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't
 417  * supposed to be a rmap record and everything is ok.  For other btrees there
 418  * had to have been an rmap entry for the block to have ended up on @bitmap,
 419  * so if it's gone now there's something wrong and the fs will shut down.
 420  *
 421  * Note: If there are multiple rmap records with only the same rmap owner as
 422  * the btree we're trying to rebuild and the block is indeed owned by another
 423  * data structure with the same rmap owner, then the block will be in sublist
 424  * and therefore doesn't need disposal.  If there are multiple rmap records
 425  * with only the same rmap owner but the block is not owned by something with
 426  * the same rmap owner, the block will be freed.
 427  *
 428  * The caller is responsible for locking the AG headers for the entire rebuild
 429  * operation so that nothing else can sneak in and change the AG state while
 430  * we're not looking.  We also assume that the caller already invalidated any
 431  * buffers associated with @bitmap.
 432  */
 433
 434 /*
 435  * Invalidate buffers for per-AG btree blocks we're dumping.  This function
 436  * is not intended for use with file data repairs; we have bunmapi for that.
 437  */
 438 int
 439 xrep_invalidate_blocks(
 440         struct xfs_scrub        *sc,
 441         struct xbitmap          *bitmap)
 442 {
 443         struct xbitmap_range    *bmr;
 444         struct xbitmap_range    *n;
 445         struct xfs_buf          *bp;
 446         xfs_fsblock_t           fsbno;
 447
 448         /*
 449          * For each block in each extent, see if there's an incore buffer for
 450          * exactly that block; if so, invalidate it.  The buffer cache only
 451          * lets us look for one buffer at a time, so we have to look one block
 452          * at a time.  Avoid invalidating AG headers and post-EOFS blocks
 453          * because we never own those; and if we can't TRYLOCK the buffer we
 454          * assume it's owned by someone else.
 455          */
 456         for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
 457                 /* Skip AG headers and post-EOFS blocks */
 458                 if (!xfs_verify_fsbno(sc->mp, fsbno))
 459                         continue;
 460                 bp = xfs_buf_incore(sc->mp->m_ddev_targp,
 461                                 XFS_FSB_TO_DADDR(sc->mp, fsbno),
 462                                 XFS_FSB_TO_BB(sc->mp, 1), XBF_TRYLOCK);
 463                 if (bp) {
 464                         xfs_trans_bjoin(sc->tp, bp);
 465                         xfs_trans_binval(sc->tp, bp);
 466                 }
 467         }
 468
 469         return 0;
 470 }
 471
 472 /* Ensure the freelist is the correct size. */
 473 int
 474 xrep_fix_freelist(
 475         struct xfs_scrub        *sc,
 476         bool                    can_shrink)
 477 {
 478         struct xfs_alloc_arg    args = {0};
 479
 480         args.mp = sc->mp;
 481         args.tp = sc->tp;
 482         args.agno = sc->sa.pag->pag_agno;
 483         args.alignment = 1;
 484         args.pag = sc->sa.pag;
 485
 486         return xfs_alloc_fix_freelist(&args,
 487                         can_shrink ? 0 : XFS_ALLOC_FLAG_NOSHRINK);
 488 }
 489
 490 /*
 491  * Put a block back on the AGFL.
 492  */
 493 STATIC int
 494 xrep_put_freelist(
 495         struct xfs_scrub        *sc,
 496         xfs_agblock_t           agbno)
 497 {
 498         int                     error;
 499
 500         /* Make sure there's space on the freelist. */
 501         error = xrep_fix_freelist(sc, true);
 502         if (error)
 503                 return error;
 504
 505         /*
 506          * Since we're "freeing" a lost block onto the AGFL, we have to
 507          * create an rmap for the block prior to merging it or else other
 508          * parts will break.
 509          */
 510         error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1,
 511                         &XFS_RMAP_OINFO_AG);
 512         if (error)
 513                 return error;
 514
 515         /* Put the block on the AGFL. */
 516         error = xfs_alloc_put_freelist(sc->sa.pag, sc->tp, sc->sa.agf_bp,
 517                         sc->sa.agfl_bp, agbno, 0);
 518         if (error)
 519                 return error;
 520         xfs_extent_busy_insert(sc->tp, sc->sa.pag, agbno, 1,
 521                         XFS_EXTENT_BUSY_SKIP_DISCARD);
 522
 523         return 0;
 524 }
 525
 526 /* Dispose of a single block. */
 527 STATIC int
 528 xrep_reap_block(
 529         struct xfs_scrub                *sc,
 530         xfs_fsblock_t                   fsbno,
 531         const struct xfs_owner_info     *oinfo,
 532         enum xfs_ag_resv_type           resv)
 533 {
 534         struct xfs_btree_cur            *cur;
 535         struct xfs_buf                  *agf_bp = NULL;
 536         xfs_agnumber_t                  agno;
 537         xfs_agblock_t                   agbno;
 538         bool                            has_other_rmap;
 539         int                             error;
 540
 541         agno = XFS_FSB_TO_AGNO(sc->mp, fsbno);
 542         agbno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);
 543         ASSERT(agno == sc->sa.pag->pag_agno);
 544
 545         /*
 546          * If we are repairing per-inode metadata, we need to read in the AGF
 547          * buffer.  Otherwise, we're repairing a per-AG structure, so reuse
 548          * the AGF buffer that the setup functions already grabbed.
 549          */
 550         if (sc->ip) {
 551                 error = xfs_alloc_read_agf(sc->sa.pag, sc->tp, 0, &agf_bp);
 552                 if (error)
 553                         return error;
 554         } else {
 555                 agf_bp = sc->sa.agf_bp;
 556         }
 557         cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf_bp, sc->sa.pag);
 558
 559         /* Can we find any other rmappings? */
 560         error = xfs_rmap_has_other_keys(cur, agbno, 1, oinfo, &has_other_rmap);
 561         xfs_btree_del_cursor(cur, error);
 562         if (error)
 563                 goto out_free;
 564
 565         /*
 566          * If there are other rmappings, this block is cross linked and must
 567          * not be freed.  Remove the reverse mapping and move on.  Otherwise,
 568          * we were the only owner of the block, so free the extent, which will
 569          * also remove the rmap.
 570          *
 571          * XXX: XFS doesn't support detecting the case where a single block
 572          * metadata structure is crosslinked with a multi-block structure
 573          * because the buffer cache doesn't detect aliasing problems, so we
 574          * can't fix 100% of crosslinking problems (yet).  The verifiers will
 575          * blow on writeout, the filesystem will shut down, and the admin gets
 576          * to run xfs_repair.
 577          */
 578         if (has_other_rmap)
 579                 error = xfs_rmap_free(sc->tp, agf_bp, sc->sa.pag, agbno,
 580                                         1, oinfo);
 581         else if (resv == XFS_AG_RESV_AGFL)
 582                 error = xrep_put_freelist(sc, agbno);
 583         else
 584                 error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv);
 585         if (agf_bp != sc->sa.agf_bp)
 586                 xfs_trans_brelse(sc->tp, agf_bp);
 587         if (error)
 588                 return error;
 589
 590         if (sc->ip)
 591                 return xfs_trans_roll_inode(&sc->tp, sc->ip);
 592         return xrep_roll_ag_trans(sc);
 593
 594 out_free:
 595         if (agf_bp != sc->sa.agf_bp)
 596                 xfs_trans_brelse(sc->tp, agf_bp);
 597         return error;
 598 }
 599
 600 /* Dispose of every block of every extent in the bitmap. */
 601 int
 602 xrep_reap_extents(
 603         struct xfs_scrub                *sc,
 604         struct xbitmap                  *bitmap,
 605         const struct xfs_owner_info     *oinfo,
 606         enum xfs_ag_resv_type           type)
 607 {
 608         struct xbitmap_range            *bmr;
 609         struct xbitmap_range            *n;
 610         xfs_fsblock_t                   fsbno;
 611         int                             error = 0;
 612
 613         ASSERT(xfs_has_rmapbt(sc->mp));
 614
 615         for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
 616                 ASSERT(sc->ip != NULL ||
 617                        XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.pag->pag_agno);
 618                 trace_xrep_dispose_btree_extent(sc->mp,
 619                                 XFS_FSB_TO_AGNO(sc->mp, fsbno),
 620                                 XFS_FSB_TO_AGBNO(sc->mp, fsbno), 1);
 621
 622                 error = xrep_reap_block(sc, fsbno, oinfo, type);
 623                 if (error)
 624                         break;
 625         }
 626
 627         return error;
 628 }
 629
 630 /*
 631  * Finding per-AG Btree Roots for AGF/AGI Reconstruction
 632  *
 633  * If the AGF or AGI become slightly corrupted, it may be necessary to rebuild
 634  * the AG headers by using the rmap data to rummage through the AG looking for
 635  * btree roots.  This is not guaranteed to work if the AG is heavily damaged
 636  * or the rmap data are corrupt.
 637  *
 638  * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
 639  * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
 640  * AGI is being rebuilt.  It must maintain these locks until it's safe for
 641  * other threads to change the btrees' shapes.  The caller provides
 642  * information about the btrees to look for by passing in an array of
 643  * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
 644  * The (root, height) fields will be set on return if anything is found.  The
 645  * last element of the array should have a NULL buf_ops to mark the end of the
 646  * array.
 647  *
 648  * For every rmapbt record matching any of the rmap owners in btree_info,
 649  * read each block referenced by the rmap record.  If the block is a btree
 650  * block from this filesystem matching any of the magic numbers and has a
 651  * level higher than what we've already seen, remember the block and the
 652  * height of the tree required to have such a block.  When the call completes,
 653  * we return the highest block we've found for each btree description; those
 654  * should be the roots.
 655  */
 656
 657 struct xrep_findroot {
 658         struct xfs_scrub                *sc;
 659         struct xfs_buf                  *agfl_bp;
 660         struct xfs_agf                  *agf;
 661         struct xrep_find_ag_btree       *btree_info;
 662 };
 663
 664 /* See if our block is in the AGFL. */
 665 STATIC int
 666 xrep_findroot_agfl_walk(
 667         struct xfs_mount        *mp,
 668         xfs_agblock_t           bno,
 669         void                    *priv)
 670 {
 671         xfs_agblock_t           *agbno = priv;
 672
 673         return (*agbno == bno) ? -ECANCELED : 0;
 674 }
 675
 676 /* Does this block match the btree information passed in? */
 677 STATIC int
 678 xrep_findroot_block(
 679         struct xrep_findroot            *ri,
 680         struct xrep_find_ag_btree       *fab,
 681         uint64_t                        owner,
 682         xfs_agblock_t                   agbno,
 683         bool                            *done_with_block)
 684 {
 685         struct xfs_mount                *mp = ri->sc->mp;
 686         struct xfs_buf                  *bp;
 687         struct xfs_btree_block          *btblock;
 688         xfs_daddr_t                     daddr;
 689         int                             block_level;
 690         int                             error = 0;
 691
 692         daddr = XFS_AGB_TO_DADDR(mp, ri->sc->sa.pag->pag_agno, agbno);
 693
 694         /*
 695          * Blocks in the AGFL have stale contents that might just happen to
 696          * have a matching magic and uuid.  We don't want to pull these blocks
 697          * in as part of a tree root, so we have to filter out the AGFL stuff
 698          * here.  If the AGFL looks insane we'll just refuse to repair.
 699          */
 700         if (owner == XFS_RMAP_OWN_AG) {
 701                 error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp,
 702                                 xrep_findroot_agfl_walk, &agbno);
 703                 if (error == -ECANCELED)
 704                         return 0;
 705                 if (error)
 706                         return error;
 707         }
 708
 709         /*
 710          * Read the buffer into memory so that we can see if it's a match for
 711          * our btree type.  We have no clue if it is beforehand, and we want to
 712          * avoid xfs_trans_read_buf's behavior of dumping the DONE state (which
 713          * will cause needless disk reads in subsequent calls to this function)
 714          * and logging metadata verifier failures.
 715          *
 716          * Therefore, pass in NULL buffer ops.  If the buffer was already in
 717          * memory from some other caller it will already have b_ops assigned.
 718          * If it was in memory from a previous unsuccessful findroot_block
 719          * call, the buffer won't have b_ops but it should be clean and ready
 720          * for us to try to verify if the read call succeeds.  The same applies
 721          * if the buffer wasn't in memory at all.
 722          *
 723          * Note: If we never match a btree type with this buffer, it will be
 724          * left in memory with NULL b_ops.  This shouldn't be a problem unless
 725          * the buffer gets written.
 726          */
 727         error = xfs_trans_read_buf(mp, ri->sc->tp, mp->m_ddev_targp, daddr,
 728                         mp->m_bsize, 0, &bp, NULL);
 729         if (error)
 730                 return error;
 731
 732         /* Ensure the block magic matches the btree type we're looking for. */
 733         btblock = XFS_BUF_TO_BLOCK(bp);
 734         ASSERT(fab->buf_ops->magic[1] != 0);
 735         if (btblock->bb_magic != fab->buf_ops->magic[1])
 736                 goto out;
 737
 738         /*
 739          * If the buffer already has ops applied and they're not the ones for
 740          * this btree type, we know this block doesn't match the btree and we
 741          * can bail out.
 742          *
 743          * If the buffer ops match ours, someone else has already validated
 744          * the block for us, so we can move on to checking if this is a root
 745          * block candidate.
 746          *
 747          * If the buffer does not have ops, nobody has successfully validated
 748          * the contents and the buffer cannot be dirty.  If the magic, uuid,
 749          * and structure match this btree type then we'll move on to checking
 750          * if it's a root block candidate.  If there is no match, bail out.
 751          */
 752         if (bp->b_ops) {
 753                 if (bp->b_ops != fab->buf_ops)
 754                         goto out;
 755         } else {
 756                 ASSERT(!xfs_trans_buf_is_dirty(bp));
 757                 if (!uuid_equal(&btblock->bb_u.s.bb_uuid,
 758                                 &mp->m_sb.sb_meta_uuid))
 759                         goto out;
 760                 /*
 761                  * Read verifiers can reference b_ops, so we set the pointer
 762                  * here.  If the verifier fails we'll reset the buffer state
 763                  * to what it was before we touched the buffer.
 764                  */
 765                 bp->b_ops = fab->buf_ops;
 766                 fab->buf_ops->verify_read(bp);
 767                 if (bp->b_error) {
 768                         bp->b_ops = NULL;
 769                         bp->b_error = 0;
 770                         goto out;
 771                 }
 772
 773                 /*
 774                  * Some read verifiers will (re)set b_ops, so we must be
 775                  * careful not to change b_ops after running the verifier.
 776                  */
 777         }
 778
 779         /*
 780          * This block passes the magic/uuid and verifier tests for this btree
 781          * type.  We don't need the caller to try the other tree types.
 782          */
 783         *done_with_block = true;
 784
 785         /*
 786          * Compare this btree block's level to the height of the current
 787          * candidate root block.
 788          *
 789          * If the level matches the root we found previously, throw away both
 790          * blocks because there can't be two candidate roots.
 791          *
 792          * If level is lower in the tree than the root we found previously,
 793          * ignore this block.
 794          */
 795         block_level = xfs_btree_get_level(btblock);
 796         if (block_level + 1 == fab->height) {
 797                 fab->root = NULLAGBLOCK;
 798                 goto out;
 799         } else if (block_level < fab->height) {
 800                 goto out;
 801         }
 802
 803         /*
 804          * This is the highest block in the tree that we've found so far.
 805          * Update the btree height to reflect what we've learned from this
 806          * block.
 807          */
 808         fab->height = block_level + 1;
 809
 810         /*
 811          * If this block doesn't have sibling pointers, then it's the new root
 812          * block candidate.  Otherwise, the root will be found farther up the
 813          * tree.
 814          */
 815         if (btblock->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) &&
 816             btblock->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK))
 817                 fab->root = agbno;
 818         else
 819                 fab->root = NULLAGBLOCK;
 820
 821         trace_xrep_findroot_block(mp, ri->sc->sa.pag->pag_agno, agbno,
 822                         be32_to_cpu(btblock->bb_magic), fab->height - 1);
 823 out:
 824         xfs_trans_brelse(ri->sc->tp, bp);
 825         return error;
 826 }
 827
 828 /*
 829  * Do any of the blocks in this rmap record match one of the btrees we're
 830  * looking for?
 831  */
 832 STATIC int
 833 xrep_findroot_rmap(
 834         struct xfs_btree_cur            *cur,
 835         const struct xfs_rmap_irec      *rec,
 836         void                            *priv)
 837 {
 838         struct xrep_findroot            *ri = priv;
 839         struct xrep_find_ag_btree       *fab;
 840         xfs_agblock_t                   b;
 841         bool                            done;
 842         int                             error = 0;
 843
 844         /* Ignore anything that isn't AG metadata. */
 845         if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner))
 846                 return 0;
 847
 848         /* Otherwise scan each block + btree type. */
 849         for (b = 0; b < rec->rm_blockcount; b++) {
 850                 done = false;
 851                 for (fab = ri->btree_info; fab->buf_ops; fab++) {
 852                         if (rec->rm_owner != fab->rmap_owner)
 853                                 continue;
 854                         error = xrep_findroot_block(ri, fab,
 855                                         rec->rm_owner, rec->rm_startblock + b,
 856                                         &done);
 857                         if (error)
 858                                 return error;
 859                         if (done)
 860                                 break;
 861                 }
 862         }
 863
 864         return 0;
 865 }
 866
 867 /* Find the roots of the per-AG btrees described in btree_info. */
 868 int
 869 xrep_find_ag_btree_roots(
 870         struct xfs_scrub                *sc,
 871         struct xfs_buf                  *agf_bp,
 872         struct xrep_find_ag_btree       *btree_info,
 873         struct xfs_buf                  *agfl_bp)
 874 {
 875         struct xfs_mount                *mp = sc->mp;
 876         struct xrep_findroot            ri;
 877         struct xrep_find_ag_btree       *fab;
 878         struct xfs_btree_cur            *cur;
 879         int                             error;
 880
 881         ASSERT(xfs_buf_islocked(agf_bp));
 882         ASSERT(agfl_bp == NULL || xfs_buf_islocked(agfl_bp));
 883
 884         ri.sc = sc;
 885         ri.btree_info = btree_info;
 886         ri.agf = agf_bp->b_addr;
 887         ri.agfl_bp = agfl_bp;
 888         for (fab = btree_info; fab->buf_ops; fab++) {
 889                 ASSERT(agfl_bp || fab->rmap_owner != XFS_RMAP_OWN_AG);
 890                 ASSERT(XFS_RMAP_NON_INODE_OWNER(fab->rmap_owner));
 891                 fab->root = NULLAGBLOCK;
 892                 fab->height = 0;
 893         }
 894
 895         cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);
 896         error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri);
 897         xfs_btree_del_cursor(cur, error);
 898
 899         return error;
 900 }
 901
 902 /* Force a quotacheck the next time we mount. */
 903 void
 904 xrep_force_quotacheck(
 905         struct xfs_scrub        *sc,
 906         xfs_dqtype_t            type)
 907 {
 908         uint                    flag;
 909
 910         flag = xfs_quota_chkd_flag(type);
 911         if (!(flag & sc->mp->m_qflags))
 912                 return;
 913
 914         mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock);
 915         sc->mp->m_qflags &= ~flag;
 916         spin_lock(&sc->mp->m_sb_lock);
 917         sc->mp->m_sb.sb_qflags &= ~flag;
 918         spin_unlock(&sc->mp->m_sb_lock);
 919         xfs_log_sb(sc->tp);
 920         mutex_unlock(&sc->mp->m_quotainfo->qi_quotaofflock);
 921 }
 922
 923 /*
 924  * Attach dquots to this inode, or schedule quotacheck to fix them.
 925  *
 926  * This function ensures that the appropriate dquots are attached to an inode.
 927  * We cannot allow the dquot code to allocate an on-disk dquot block here
 928  * because we're already in transaction context with the inode locked.  The
 929  * on-disk dquot should already exist anyway.  If the quota code signals
 930  * corruption or missing quota information, schedule quotacheck, which will
 931  * repair corruptions in the quota metadata.
 932  */
 933 int
 934 xrep_ino_dqattach(
 935         struct xfs_scrub        *sc)
 936 {
 937         int                     error;
 938
 939         error = xfs_qm_dqattach_locked(sc->ip, false);
 940         switch (error) {
 941         case -EFSBADCRC:
 942         case -EFSCORRUPTED:
 943         case -ENOENT:
 944                 xfs_err_ratelimited(sc->mp,
 945 "inode %llu repair encountered quota error %d, quotacheck forced.",
 946                                 (unsigned long long)sc->ip->i_ino, error);
 947                 if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
 948                         xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
 949                 if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
 950                         xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
 951                 if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
 952                         xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
 953                 fallthrough;
 954         case -ESRCH:
 955                 error = 0;
 956                 break;
 957         default:
 958                 break;
 959         }
 960
 961         return error;
 962 }