| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * Copyright (C) 2018 Oracle. All Rights Reserved. |
| * Author: Darrick J. Wong <darrick.wong@oracle.com> |
| */ |
| #include "xfs.h" |
| #include "xfs_fs.h" |
| #include "xfs_shared.h" |
| #include "xfs_format.h" |
| #include "xfs_trans_resv.h" |
| #include "xfs_mount.h" |
| #include "xfs_btree.h" |
| #include "xfs_log_format.h" |
| #include "xfs_trans.h" |
| #include "xfs_sb.h" |
| #include "xfs_inode.h" |
| #include "xfs_alloc.h" |
| #include "xfs_alloc_btree.h" |
| #include "xfs_ialloc.h" |
| #include "xfs_ialloc_btree.h" |
| #include "xfs_rmap.h" |
| #include "xfs_rmap_btree.h" |
| #include "xfs_refcount_btree.h" |
| #include "xfs_extent_busy.h" |
| #include "xfs_ag.h" |
| #include "xfs_ag_resv.h" |
| #include "xfs_quota.h" |
| #include "scrub/scrub.h" |
| #include "scrub/common.h" |
| #include "scrub/trace.h" |
| #include "scrub/repair.h" |
| #include "scrub/bitmap.h" |
| |
| /* |
| * Attempt to repair some metadata, if the metadata is corrupt and userspace |
| * told us to fix it. This function returns -EAGAIN to mean "re-run scrub", |
| * and will set *fixed to true if it thinks it repaired anything. |
| */ |
| int |
| xrep_attempt( |
| struct xfs_scrub *sc) |
| { |
| int error = 0; |
| |
| trace_xrep_attempt(XFS_I(file_inode(sc->file)), sc->sm, error); |
| |
| xchk_ag_btcur_free(&sc->sa); |
| |
| /* Repair whatever's broken. */ |
| ASSERT(sc->ops->repair); |
| error = sc->ops->repair(sc); |
| trace_xrep_done(XFS_I(file_inode(sc->file)), sc->sm, error); |
| switch (error) { |
| case 0: |
| /* |
| * Repair succeeded. Commit the fixes and perform a second |
| * scrub so that we can tell userspace if we fixed the problem. |
| */ |
| sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT; |
| sc->flags |= XREP_ALREADY_FIXED; |
| return -EAGAIN; |
| case -EDEADLOCK: |
| case -EAGAIN: |
| /* Tell the caller to try again having grabbed all the locks. */ |
| if (!(sc->flags & XCHK_TRY_HARDER)) { |
| sc->flags |= XCHK_TRY_HARDER; |
| return -EAGAIN; |
| } |
| /* |
| * We tried harder but still couldn't grab all the resources |
| * we needed to fix it. The corruption has not been fixed, |
| * so report back to userspace. |
| */ |
| return -EFSCORRUPTED; |
| default: |
| return error; |
| } |
| } |
| |
| /* |
| * Complain about unfixable problems in the filesystem. We don't log |
| * corruptions when IFLAG_REPAIR wasn't set on the assumption that the driver |
| * program is xfs_scrub, which will call back with IFLAG_REPAIR set if the |
| * administrator isn't running xfs_scrub in no-repairs mode. |
| * |
| * Use this helper function because _ratelimited silently declares a static |
| * structure to track rate limiting information. |
| */ |
| void |
| xrep_failure( |
| struct xfs_mount *mp) |
| { |
| xfs_alert_ratelimited(mp, |
| "Corruption not fixed during online repair. Unmount and run xfs_repair."); |
| } |
| |
| /* |
| * Repair probe -- userspace uses this to probe if we're willing to repair a |
| * given mountpoint. |
| */ |
| int |
| xrep_probe( |
| struct xfs_scrub *sc) |
| { |
| int error = 0; |
| |
| if (xchk_should_terminate(sc, &error)) |
| return error; |
| |
| return 0; |
| } |
| |
| /* |
| * Roll a transaction, keeping the AG headers locked and reinitializing |
| * the btree cursors. |
| */ |
| int |
| xrep_roll_ag_trans( |
| struct xfs_scrub *sc) |
| { |
| int error; |
| |
| /* Keep the AG header buffers locked so we can keep going. */ |
| if (sc->sa.agi_bp) |
| xfs_trans_bhold(sc->tp, sc->sa.agi_bp); |
| if (sc->sa.agf_bp) |
| xfs_trans_bhold(sc->tp, sc->sa.agf_bp); |
| if (sc->sa.agfl_bp) |
| xfs_trans_bhold(sc->tp, sc->sa.agfl_bp); |
| |
| /* |
| * Roll the transaction. We still own the buffer and the buffer lock |
| * regardless of whether or not the roll succeeds. If the roll fails, |
| * the buffers will be released during teardown on our way out of the |
| * kernel. If it succeeds, we join them to the new transaction and |
| * move on. |
| */ |
| error = xfs_trans_roll(&sc->tp); |
| if (error) |
| return error; |
| |
| /* Join AG headers to the new transaction. */ |
| if (sc->sa.agi_bp) |
| xfs_trans_bjoin(sc->tp, sc->sa.agi_bp); |
| if (sc->sa.agf_bp) |
| xfs_trans_bjoin(sc->tp, sc->sa.agf_bp); |
| if (sc->sa.agfl_bp) |
| xfs_trans_bjoin(sc->tp, sc->sa.agfl_bp); |
| |
| return 0; |
| } |
| |
| /* |
| * Does the given AG have enough space to rebuild a btree? Neither AG |
| * reservation can be critical, and we must have enough space (factoring |
| * in AG reservations) to construct a whole btree. |
| */ |
| bool |
| xrep_ag_has_space( |
| struct xfs_perag *pag, |
| xfs_extlen_t nr_blocks, |
| enum xfs_ag_resv_type type) |
| { |
| return !xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) && |
| !xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA) && |
| pag->pagf_freeblks > xfs_ag_resv_needed(pag, type) + nr_blocks; |
| } |
| |
| /* |
| * Figure out how many blocks to reserve for an AG repair. We calculate the |
| * worst case estimate for the number of blocks we'd need to rebuild one of |
| * any type of per-AG btree. |
| */ |
| xfs_extlen_t |
| xrep_calc_ag_resblks( |
| struct xfs_scrub *sc) |
| { |
| struct xfs_mount *mp = sc->mp; |
| struct xfs_scrub_metadata *sm = sc->sm; |
| struct xfs_perag *pag; |
| struct xfs_buf *bp; |
| xfs_agino_t icount = NULLAGINO; |
| xfs_extlen_t aglen = NULLAGBLOCK; |
| xfs_extlen_t usedlen; |
| xfs_extlen_t freelen; |
| xfs_extlen_t bnobt_sz; |
| xfs_extlen_t inobt_sz; |
| xfs_extlen_t rmapbt_sz; |
| xfs_extlen_t refcbt_sz; |
| int error; |
| |
| if (!(sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR)) |
| return 0; |
| |
| pag = xfs_perag_get(mp, sm->sm_agno); |
| if (pag->pagi_init) { |
| /* Use in-core icount if possible. */ |
| icount = pag->pagi_count; |
| } else { |
| /* Try to get the actual counters from disk. */ |
| error = xfs_ialloc_read_agi(mp, NULL, sm->sm_agno, &bp); |
| if (!error) { |
| icount = pag->pagi_count; |
| xfs_buf_relse(bp); |
| } |
| } |
| |
| /* Now grab the block counters from the AGF. */ |
| error = xfs_alloc_read_agf(mp, NULL, sm->sm_agno, 0, &bp); |
| if (error) { |
| aglen = xfs_ag_block_count(mp, sm->sm_agno); |
| freelen = aglen; |
| usedlen = aglen; |
| } else { |
| struct xfs_agf *agf = bp->b_addr; |
| |
| aglen = be32_to_cpu(agf->agf_length); |
| freelen = be32_to_cpu(agf->agf_freeblks); |
| usedlen = aglen - freelen; |
| xfs_buf_relse(bp); |
| } |
| xfs_perag_put(pag); |
| |
| /* If the icount is impossible, make some worst-case assumptions. */ |
| if (icount == NULLAGINO || |
| !xfs_verify_agino(mp, sm->sm_agno, icount)) { |
| xfs_agino_t first, last; |
| |
| xfs_agino_range(mp, sm->sm_agno, &first, &last); |
| icount = last - first + 1; |
| } |
| |
| /* If the block counts are impossible, make worst-case assumptions. */ |
| if (aglen == NULLAGBLOCK || |
| aglen != xfs_ag_block_count(mp, sm->sm_agno) || |
| freelen >= aglen) { |
| aglen = xfs_ag_block_count(mp, sm->sm_agno); |
| freelen = aglen; |
| usedlen = aglen; |
| } |
| |
| trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen, |
| freelen, usedlen); |
| |
| /* |
| * Figure out how many blocks we'd need worst case to rebuild |
| * each type of btree. Note that we can only rebuild the |
| * bnobt/cntbt or inobt/finobt as pairs. |
| */ |
| bnobt_sz = 2 * xfs_allocbt_calc_size(mp, freelen); |
| if (xfs_sb_version_hassparseinodes(&mp->m_sb)) |
| inobt_sz = xfs_iallocbt_calc_size(mp, icount / |
| XFS_INODES_PER_HOLEMASK_BIT); |
| else |
| inobt_sz = xfs_iallocbt_calc_size(mp, icount / |
| XFS_INODES_PER_CHUNK); |
| if (xfs_sb_version_hasfinobt(&mp->m_sb)) |
| inobt_sz *= 2; |
| if (xfs_sb_version_hasreflink(&mp->m_sb)) |
| refcbt_sz = xfs_refcountbt_calc_size(mp, usedlen); |
| else |
| refcbt_sz = 0; |
| if (xfs_sb_version_hasrmapbt(&mp->m_sb)) { |
| /* |
| * Guess how many blocks we need to rebuild the rmapbt. |
| * For non-reflink filesystems we can't have more records than |
| * used blocks. However, with reflink it's possible to have |
| * more than one rmap record per AG block. We don't know how |
| * many rmaps there could be in the AG, so we start off with |
| * what we hope is an generous over-estimation. |
| */ |
| if (xfs_sb_version_hasreflink(&mp->m_sb)) |
| rmapbt_sz = xfs_rmapbt_calc_size(mp, |
| (unsigned long long)aglen * 2); |
| else |
| rmapbt_sz = xfs_rmapbt_calc_size(mp, usedlen); |
| } else { |
| rmapbt_sz = 0; |
| } |
| |
| trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz, |
| inobt_sz, rmapbt_sz, refcbt_sz); |
| |
| return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz)); |
| } |
| |
| /* Allocate a block in an AG. */ |
| int |
| xrep_alloc_ag_block( |
| struct xfs_scrub *sc, |
| const struct xfs_owner_info *oinfo, |
| xfs_fsblock_t *fsbno, |
| enum xfs_ag_resv_type resv) |
| { |
| struct xfs_alloc_arg args = {0}; |
| xfs_agblock_t bno; |
| int error; |
| |
| switch (resv) { |
| case XFS_AG_RESV_AGFL: |
| case XFS_AG_RESV_RMAPBT: |
| error = xfs_alloc_get_freelist(sc->tp, sc->sa.agf_bp, &bno, 1); |
| if (error) |
| return error; |
| if (bno == NULLAGBLOCK) |
| return -ENOSPC; |
| xfs_extent_busy_reuse(sc->mp, sc->sa.pag, bno, |
| 1, false); |
| *fsbno = XFS_AGB_TO_FSB(sc->mp, sc->sa.agno, bno); |
| if (resv == XFS_AG_RESV_RMAPBT) |
| xfs_ag_resv_rmapbt_alloc(sc->mp, sc->sa.agno); |
| return 0; |
| default: |
| break; |
| } |
| |
| args.tp = sc->tp; |
| args.mp = sc->mp; |
| args.oinfo = *oinfo; |
| args.fsbno = XFS_AGB_TO_FSB(args.mp, sc->sa.agno, 0); |
| args.minlen = 1; |
| args.maxlen = 1; |
| args.prod = 1; |
| args.type = XFS_ALLOCTYPE_THIS_AG; |
| args.resv = resv; |
| |
| error = xfs_alloc_vextent(&args); |
| if (error) |
| return error; |
| if (args.fsbno == NULLFSBLOCK) |
| return -ENOSPC; |
| ASSERT(args.len == 1); |
| *fsbno = args.fsbno; |
| |
| return 0; |
| } |
| |
| /* Initialize a new AG btree root block with zero entries. */ |
| int |
| xrep_init_btblock( |
| struct xfs_scrub *sc, |
| xfs_fsblock_t fsb, |
| struct xfs_buf **bpp, |
| xfs_btnum_t btnum, |
| const struct xfs_buf_ops *ops) |
| { |
| struct xfs_trans *tp = sc->tp; |
| struct xfs_mount *mp = sc->mp; |
| struct xfs_buf *bp; |
| int error; |
| |
| trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb), |
| XFS_FSB_TO_AGBNO(mp, fsb), btnum); |
| |
| ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.agno); |
| error = xfs_trans_get_buf(tp, mp->m_ddev_targp, |
| XFS_FSB_TO_DADDR(mp, fsb), XFS_FSB_TO_BB(mp, 1), 0, |
| &bp); |
| if (error) |
| return error; |
| xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); |
| xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.agno); |
| xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF); |
| xfs_trans_log_buf(tp, bp, 0, BBTOB(bp->b_length) - 1); |
| bp->b_ops = ops; |
| *bpp = bp; |
| |
| return 0; |
| } |
| |
| /* |
| * Reconstructing per-AG Btrees |
| * |
| * When a space btree is corrupt, we don't bother trying to fix it. Instead, |
| * we scan secondary space metadata to derive the records that should be in |
| * the damaged btree, initialize a fresh btree root, and insert the records. |
| * Note that for rebuilding the rmapbt we scan all the primary data to |
| * generate the new records. |
| * |
| * However, that leaves the matter of removing all the metadata describing the |
| * old broken structure. For primary metadata we use the rmap data to collect |
| * every extent with a matching rmap owner (bitmap); we then iterate all other |
| * metadata structures with the same rmap owner to collect the extents that |
| * cannot be removed (sublist). We then subtract sublist from bitmap to |
| * derive the blocks that were used by the old btree. These blocks can be |
| * reaped. |
| * |
| * For rmapbt reconstructions we must use different tactics for extent |
| * collection. First we iterate all primary metadata (this excludes the old |
| * rmapbt, obviously) to generate new rmap records. The gaps in the rmap |
| * records are collected as bitmap. The bnobt records are collected as |
| * sublist. As with the other btrees we subtract sublist from bitmap, and the |
| * result (since the rmapbt lives in the free space) are the blocks from the |
| * old rmapbt. |
| * |
| * Disposal of Blocks from Old per-AG Btrees |
| * |
| * Now that we've constructed a new btree to replace the damaged one, we want |
| * to dispose of the blocks that (we think) the old btree was using. |
| * Previously, we used the rmapbt to collect the extents (bitmap) with the |
| * rmap owner corresponding to the tree we rebuilt, collected extents for any |
| * blocks with the same rmap owner that are owned by another data structure |
| * (sublist), and subtracted sublist from bitmap. In theory the extents |
| * remaining in bitmap are the old btree's blocks. |
| * |
| * Unfortunately, it's possible that the btree was crosslinked with other |
| * blocks on disk. The rmap data can tell us if there are multiple owners, so |
| * if the rmapbt says there is an owner of this block other than @oinfo, then |
| * the block is crosslinked. Remove the reverse mapping and continue. |
| * |
| * If there is one rmap record, we can free the block, which removes the |
| * reverse mapping but doesn't add the block to the free space. Our repair |
| * strategy is to hope the other metadata objects crosslinked on this block |
| * will be rebuilt (atop different blocks), thereby removing all the cross |
| * links. |
| * |
| * If there are no rmap records at all, we also free the block. If the btree |
| * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't |
| * supposed to be a rmap record and everything is ok. For other btrees there |
| * had to have been an rmap entry for the block to have ended up on @bitmap, |
| * so if it's gone now there's something wrong and the fs will shut down. |
| * |
| * Note: If there are multiple rmap records with only the same rmap owner as |
| * the btree we're trying to rebuild and the block is indeed owned by another |
| * data structure with the same rmap owner, then the block will be in sublist |
| * and therefore doesn't need disposal. If there are multiple rmap records |
| * with only the same rmap owner but the block is not owned by something with |
| * the same rmap owner, the block will be freed. |
| * |
| * The caller is responsible for locking the AG headers for the entire rebuild |
| * operation so that nothing else can sneak in and change the AG state while |
| * we're not looking. We also assume that the caller already invalidated any |
| * buffers associated with @bitmap. |
| */ |
| |
| /* |
| * Invalidate buffers for per-AG btree blocks we're dumping. This function |
| * is not intended for use with file data repairs; we have bunmapi for that. |
| */ |
| int |
| xrep_invalidate_blocks( |
| struct xfs_scrub *sc, |
| struct xbitmap *bitmap) |
| { |
| struct xbitmap_range *bmr; |
| struct xbitmap_range *n; |
| struct xfs_buf *bp; |
| xfs_fsblock_t fsbno; |
| |
| /* |
| * For each block in each extent, see if there's an incore buffer for |
| * exactly that block; if so, invalidate it. The buffer cache only |
| * lets us look for one buffer at a time, so we have to look one block |
| * at a time. Avoid invalidating AG headers and post-EOFS blocks |
| * because we never own those; and if we can't TRYLOCK the buffer we |
| * assume it's owned by someone else. |
| */ |
| for_each_xbitmap_block(fsbno, bmr, n, bitmap) { |
| /* Skip AG headers and post-EOFS blocks */ |
| if (!xfs_verify_fsbno(sc->mp, fsbno)) |
| continue; |
| bp = xfs_buf_incore(sc->mp->m_ddev_targp, |
| XFS_FSB_TO_DADDR(sc->mp, fsbno), |
| XFS_FSB_TO_BB(sc->mp, 1), XBF_TRYLOCK); |
| if (bp) { |
| xfs_trans_bjoin(sc->tp, bp); |
| xfs_trans_binval(sc->tp, bp); |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* Ensure the freelist is the correct size. */ |
| int |
| xrep_fix_freelist( |
| struct xfs_scrub *sc, |
| bool can_shrink) |
| { |
| struct xfs_alloc_arg args = {0}; |
| |
| args.mp = sc->mp; |
| args.tp = sc->tp; |
| args.agno = sc->sa.agno; |
| args.alignment = 1; |
| args.pag = sc->sa.pag; |
| |
| return xfs_alloc_fix_freelist(&args, |
| can_shrink ? 0 : XFS_ALLOC_FLAG_NOSHRINK); |
| } |
| |
| /* |
| * Put a block back on the AGFL. |
| */ |
| STATIC int |
| xrep_put_freelist( |
| struct xfs_scrub *sc, |
| xfs_agblock_t agbno) |
| { |
| int error; |
| |
| /* Make sure there's space on the freelist. */ |
| error = xrep_fix_freelist(sc, true); |
| if (error) |
| return error; |
| |
| /* |
| * Since we're "freeing" a lost block onto the AGFL, we have to |
| * create an rmap for the block prior to merging it or else other |
| * parts will break. |
| */ |
| error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1, |
| &XFS_RMAP_OINFO_AG); |
| if (error) |
| return error; |
| |
| /* Put the block on the AGFL. */ |
| error = xfs_alloc_put_freelist(sc->tp, sc->sa.agf_bp, sc->sa.agfl_bp, |
| agbno, 0); |
| if (error) |
| return error; |
| xfs_extent_busy_insert(sc->tp, sc->sa.pag, agbno, 1, |
| XFS_EXTENT_BUSY_SKIP_DISCARD); |
| |
| return 0; |
| } |
| |
| /* Dispose of a single block. */ |
| STATIC int |
| xrep_reap_block( |
| struct xfs_scrub *sc, |
| xfs_fsblock_t fsbno, |
| const struct xfs_owner_info *oinfo, |
| enum xfs_ag_resv_type resv) |
| { |
| struct xfs_btree_cur *cur; |
| struct xfs_buf *agf_bp = NULL; |
| xfs_agnumber_t agno; |
| xfs_agblock_t agbno; |
| bool has_other_rmap; |
| int error; |
| |
| agno = XFS_FSB_TO_AGNO(sc->mp, fsbno); |
| agbno = XFS_FSB_TO_AGBNO(sc->mp, fsbno); |
| |
| /* |
| * If we are repairing per-inode metadata, we need to read in the AGF |
| * buffer. Otherwise, we're repairing a per-AG structure, so reuse |
| * the AGF buffer that the setup functions already grabbed. |
| */ |
| if (sc->ip) { |
| error = xfs_alloc_read_agf(sc->mp, sc->tp, agno, 0, &agf_bp); |
| if (error) |
| return error; |
| } else { |
| agf_bp = sc->sa.agf_bp; |
| } |
| cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf_bp, sc->sa.pag); |
| |
| /* Can we find any other rmappings? */ |
| error = xfs_rmap_has_other_keys(cur, agbno, 1, oinfo, &has_other_rmap); |
| xfs_btree_del_cursor(cur, error); |
| if (error) |
| goto out_free; |
| |
| /* |
| * If there are other rmappings, this block is cross linked and must |
| * not be freed. Remove the reverse mapping and move on. Otherwise, |
| * we were the only owner of the block, so free the extent, which will |
| * also remove the rmap. |
| * |
| * XXX: XFS doesn't support detecting the case where a single block |
| * metadata structure is crosslinked with a multi-block structure |
| * because the buffer cache doesn't detect aliasing problems, so we |
| * can't fix 100% of crosslinking problems (yet). The verifiers will |
| * blow on writeout, the filesystem will shut down, and the admin gets |
| * to run xfs_repair. |
| */ |
| if (has_other_rmap) |
| error = xfs_rmap_free(sc->tp, agf_bp, sc->sa.pag, agbno, |
| 1, oinfo); |
| else if (resv == XFS_AG_RESV_AGFL) |
| error = xrep_put_freelist(sc, agbno); |
| else |
| error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv); |
| if (agf_bp != sc->sa.agf_bp) |
| xfs_trans_brelse(sc->tp, agf_bp); |
| if (error) |
| return error; |
| |
| if (sc->ip) |
| return xfs_trans_roll_inode(&sc->tp, sc->ip); |
| return xrep_roll_ag_trans(sc); |
| |
| out_free: |
| if (agf_bp != sc->sa.agf_bp) |
| xfs_trans_brelse(sc->tp, agf_bp); |
| return error; |
| } |
| |
| /* Dispose of every block of every extent in the bitmap. */ |
| int |
| xrep_reap_extents( |
| struct xfs_scrub *sc, |
| struct xbitmap *bitmap, |
| const struct xfs_owner_info *oinfo, |
| enum xfs_ag_resv_type type) |
| { |
| struct xbitmap_range *bmr; |
| struct xbitmap_range *n; |
| xfs_fsblock_t fsbno; |
| int error = 0; |
| |
| ASSERT(xfs_sb_version_hasrmapbt(&sc->mp->m_sb)); |
| |
| for_each_xbitmap_block(fsbno, bmr, n, bitmap) { |
| ASSERT(sc->ip != NULL || |
| XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.agno); |
| trace_xrep_dispose_btree_extent(sc->mp, |
| XFS_FSB_TO_AGNO(sc->mp, fsbno), |
| XFS_FSB_TO_AGBNO(sc->mp, fsbno), 1); |
| |
| error = xrep_reap_block(sc, fsbno, oinfo, type); |
| if (error) |
| break; |
| } |
| |
| return error; |
| } |
| |
| /* |
| * Finding per-AG Btree Roots for AGF/AGI Reconstruction |
| * |
| * If the AGF or AGI become slightly corrupted, it may be necessary to rebuild |
| * the AG headers by using the rmap data to rummage through the AG looking for |
| * btree roots. This is not guaranteed to work if the AG is heavily damaged |
| * or the rmap data are corrupt. |
| * |
| * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL |
| * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the |
| * AGI is being rebuilt. It must maintain these locks until it's safe for |
| * other threads to change the btrees' shapes. The caller provides |
| * information about the btrees to look for by passing in an array of |
| * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set. |
| * The (root, height) fields will be set on return if anything is found. The |
| * last element of the array should have a NULL buf_ops to mark the end of the |
| * array. |
| * |
| * For every rmapbt record matching any of the rmap owners in btree_info, |
| * read each block referenced by the rmap record. If the block is a btree |
| * block from this filesystem matching any of the magic numbers and has a |
| * level higher than what we've already seen, remember the block and the |
| * height of the tree required to have such a block. When the call completes, |
| * we return the highest block we've found for each btree description; those |
| * should be the roots. |
| */ |
| |
| struct xrep_findroot { |
| struct xfs_scrub *sc; |
| struct xfs_buf *agfl_bp; |
| struct xfs_agf *agf; |
| struct xrep_find_ag_btree *btree_info; |
| }; |
| |
| /* See if our block is in the AGFL. */ |
| STATIC int |
| xrep_findroot_agfl_walk( |
| struct xfs_mount *mp, |
| xfs_agblock_t bno, |
| void *priv) |
| { |
| xfs_agblock_t *agbno = priv; |
| |
| return (*agbno == bno) ? -ECANCELED : 0; |
| } |
| |
| /* Does this block match the btree information passed in? */ |
| STATIC int |
| xrep_findroot_block( |
| struct xrep_findroot *ri, |
| struct xrep_find_ag_btree *fab, |
| uint64_t owner, |
| xfs_agblock_t agbno, |
| bool *done_with_block) |
| { |
| struct xfs_mount *mp = ri->sc->mp; |
| struct xfs_buf *bp; |
| struct xfs_btree_block *btblock; |
| xfs_daddr_t daddr; |
| int block_level; |
| int error = 0; |
| |
| daddr = XFS_AGB_TO_DADDR(mp, ri->sc->sa.agno, agbno); |
| |
| /* |
| * Blocks in the AGFL have stale contents that might just happen to |
| * have a matching magic and uuid. We don't want to pull these blocks |
| * in as part of a tree root, so we have to filter out the AGFL stuff |
| * here. If the AGFL looks insane we'll just refuse to repair. |
| */ |
| if (owner == XFS_RMAP_OWN_AG) { |
| error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp, |
| xrep_findroot_agfl_walk, &agbno); |
| if (error == -ECANCELED) |
| return 0; |
| if (error) |
| return error; |
| } |
| |
| /* |
| * Read the buffer into memory so that we can see if it's a match for |
| * our btree type. We have no clue if it is beforehand, and we want to |
| * avoid xfs_trans_read_buf's behavior of dumping the DONE state (which |
| * will cause needless disk reads in subsequent calls to this function) |
| * and logging metadata verifier failures. |
| * |
| * Therefore, pass in NULL buffer ops. If the buffer was already in |
| * memory from some other caller it will already have b_ops assigned. |
| * If it was in memory from a previous unsuccessful findroot_block |
| * call, the buffer won't have b_ops but it should be clean and ready |
| * for us to try to verify if the read call succeeds. The same applies |
| * if the buffer wasn't in memory at all. |
| * |
| * Note: If we never match a btree type with this buffer, it will be |
| * left in memory with NULL b_ops. This shouldn't be a problem unless |
| * the buffer gets written. |
| */ |
| error = xfs_trans_read_buf(mp, ri->sc->tp, mp->m_ddev_targp, daddr, |
| mp->m_bsize, 0, &bp, NULL); |
| if (error) |
| return error; |
| |
| /* Ensure the block magic matches the btree type we're looking for. */ |
| btblock = XFS_BUF_TO_BLOCK(bp); |
| ASSERT(fab->buf_ops->magic[1] != 0); |
| if (btblock->bb_magic != fab->buf_ops->magic[1]) |
| goto out; |
| |
| /* |
| * If the buffer already has ops applied and they're not the ones for |
| * this btree type, we know this block doesn't match the btree and we |
| * can bail out. |
| * |
| * If the buffer ops match ours, someone else has already validated |
| * the block for us, so we can move on to checking if this is a root |
| * block candidate. |
| * |
| * If the buffer does not have ops, nobody has successfully validated |
| * the contents and the buffer cannot be dirty. If the magic, uuid, |
| * and structure match this btree type then we'll move on to checking |
| * if it's a root block candidate. If there is no match, bail out. |
| */ |
| if (bp->b_ops) { |
| if (bp->b_ops != fab->buf_ops) |
| goto out; |
| } else { |
| ASSERT(!xfs_trans_buf_is_dirty(bp)); |
| if (!uuid_equal(&btblock->bb_u.s.bb_uuid, |
| &mp->m_sb.sb_meta_uuid)) |
| goto out; |
| /* |
| * Read verifiers can reference b_ops, so we set the pointer |
| * here. If the verifier fails we'll reset the buffer state |
| * to what it was before we touched the buffer. |
| */ |
| bp->b_ops = fab->buf_ops; |
| fab->buf_ops->verify_read(bp); |
| if (bp->b_error) { |
| bp->b_ops = NULL; |
| bp->b_error = 0; |
| goto out; |
| } |
| |
| /* |
| * Some read verifiers will (re)set b_ops, so we must be |
| * careful not to change b_ops after running the verifier. |
| */ |
| } |
| |
| /* |
| * This block passes the magic/uuid and verifier tests for this btree |
| * type. We don't need the caller to try the other tree types. |
| */ |
| *done_with_block = true; |
| |
| /* |
| * Compare this btree block's level to the height of the current |
| * candidate root block. |
| * |
| * If the level matches the root we found previously, throw away both |
| * blocks because there can't be two candidate roots. |
| * |
| * If level is lower in the tree than the root we found previously, |
| * ignore this block. |
| */ |
| block_level = xfs_btree_get_level(btblock); |
| if (block_level + 1 == fab->height) { |
| fab->root = NULLAGBLOCK; |
| goto out; |
| } else if (block_level < fab->height) { |
| goto out; |
| } |
| |
| /* |
| * This is the highest block in the tree that we've found so far. |
| * Update the btree height to reflect what we've learned from this |
| * block. |
| */ |
| fab->height = block_level + 1; |
| |
| /* |
| * If this block doesn't have sibling pointers, then it's the new root |
| * block candidate. Otherwise, the root will be found farther up the |
| * tree. |
| */ |
| if (btblock->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) && |
| btblock->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK)) |
| fab->root = agbno; |
| else |
| fab->root = NULLAGBLOCK; |
| |
| trace_xrep_findroot_block(mp, ri->sc->sa.agno, agbno, |
| be32_to_cpu(btblock->bb_magic), fab->height - 1); |
| out: |
| xfs_trans_brelse(ri->sc->tp, bp); |
| return error; |
| } |
| |
| /* |
| * Do any of the blocks in this rmap record match one of the btrees we're |
| * looking for? |
| */ |
| STATIC int |
| xrep_findroot_rmap( |
| struct xfs_btree_cur *cur, |
| struct xfs_rmap_irec *rec, |
| void *priv) |
| { |
| struct xrep_findroot *ri = priv; |
| struct xrep_find_ag_btree *fab; |
| xfs_agblock_t b; |
| bool done; |
| int error = 0; |
| |
| /* Ignore anything that isn't AG metadata. */ |
| if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner)) |
| return 0; |
| |
| /* Otherwise scan each block + btree type. */ |
| for (b = 0; b < rec->rm_blockcount; b++) { |
| done = false; |
| for (fab = ri->btree_info; fab->buf_ops; fab++) { |
| if (rec->rm_owner != fab->rmap_owner) |
| continue; |
| error = xrep_findroot_block(ri, fab, |
| rec->rm_owner, rec->rm_startblock + b, |
| &done); |
| if (error) |
| return error; |
| if (done) |
| break; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* Find the roots of the per-AG btrees described in btree_info. */ |
| int |
| xrep_find_ag_btree_roots( |
| struct xfs_scrub *sc, |
| struct xfs_buf *agf_bp, |
| struct xrep_find_ag_btree *btree_info, |
| struct xfs_buf *agfl_bp) |
| { |
| struct xfs_mount *mp = sc->mp; |
| struct xrep_findroot ri; |
| struct xrep_find_ag_btree *fab; |
| struct xfs_btree_cur *cur; |
| int error; |
| |
| ASSERT(xfs_buf_islocked(agf_bp)); |
| ASSERT(agfl_bp == NULL || xfs_buf_islocked(agfl_bp)); |
| |
| ri.sc = sc; |
| ri.btree_info = btree_info; |
| ri.agf = agf_bp->b_addr; |
| ri.agfl_bp = agfl_bp; |
| for (fab = btree_info; fab->buf_ops; fab++) { |
| ASSERT(agfl_bp || fab->rmap_owner != XFS_RMAP_OWN_AG); |
| ASSERT(XFS_RMAP_NON_INODE_OWNER(fab->rmap_owner)); |
| fab->root = NULLAGBLOCK; |
| fab->height = 0; |
| } |
| |
| cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag); |
| error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri); |
| xfs_btree_del_cursor(cur, error); |
| |
| return error; |
| } |
| |
| /* Force a quotacheck the next time we mount. */ |
| void |
| xrep_force_quotacheck( |
| struct xfs_scrub *sc, |
| xfs_dqtype_t type) |
| { |
| uint flag; |
| |
| flag = xfs_quota_chkd_flag(type); |
| if (!(flag & sc->mp->m_qflags)) |
| return; |
| |
| sc->mp->m_qflags &= ~flag; |
| spin_lock(&sc->mp->m_sb_lock); |
| sc->mp->m_sb.sb_qflags &= ~flag; |
| spin_unlock(&sc->mp->m_sb_lock); |
| xfs_log_sb(sc->tp); |
| } |
| |
| /* |
| * Attach dquots to this inode, or schedule quotacheck to fix them. |
| * |
| * This function ensures that the appropriate dquots are attached to an inode. |
| * We cannot allow the dquot code to allocate an on-disk dquot block here |
| * because we're already in transaction context with the inode locked. The |
| * on-disk dquot should already exist anyway. If the quota code signals |
| * corruption or missing quota information, schedule quotacheck, which will |
| * repair corruptions in the quota metadata. |
| */ |
| int |
| xrep_ino_dqattach( |
| struct xfs_scrub *sc) |
| { |
| int error; |
| |
| error = xfs_qm_dqattach_locked(sc->ip, false); |
| switch (error) { |
| case -EFSBADCRC: |
| case -EFSCORRUPTED: |
| case -ENOENT: |
| xfs_err_ratelimited(sc->mp, |
| "inode %llu repair encountered quota error %d, quotacheck forced.", |
| (unsigned long long)sc->ip->i_ino, error); |
| if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot) |
| xrep_force_quotacheck(sc, XFS_DQTYPE_USER); |
| if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot) |
| xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP); |
| if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot) |
| xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ); |
| fallthrough; |
| case -ESRCH: |
| error = 0; |
| break; |
| default: |
| break; |
| } |
| |
| return error; |
| } |