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