xfs: online repair, part of part 1
Subsystems (2)
PATCH v26 1/1 xfs: online repair, part of part 1
Hi everyone,
I've rebased the online fsck development branches atop 6.5, applied the changes requested during the review of v25, and cleaned up the common code as needed to make online fsck part 2 work more smoothly. Part 2 has also grown a directory tree structure checker that can find and fix un-tree like things. I also added some simple performance counters that are accessible via debugfs.
In other words, I'm formally submitting part 1 for inclusion in 6.6.
For this review, I would like people to focus the following:
- Are the major subsystems sufficiently documented that you could figure out what the code does?
- Do you see any problems that are severe enough to cause long term support hassles? (e.g. bad API design, writing weird metadata to disk)
- Can you spot mis-interactions between the subsystems?
- What were my blind spots in devising this feature?
- Are there missing pieces that you'd like to help build?
- Can I just merge all of this?
The one thing that is /not/ in scope for this review are requests for more refactoring of existing subsystems.
I've been running daily online **repairs** of every computer I own for the last 16 months. So far, no damage has resulted from these operations.
Fuzz and stress testing of online repairs have been running well for a year now. As of this writing, online repair can fix slightly more things than offline repair, and the fsstress+repair long soak test has passed 250 million repairs with zero problems observed. All issues observed in that time have been corrected in this submission.
(For comparison, the long soak fsx test recently passed 103 billion file operations with only one corruption reported, so online fsck has a ways to go...)
This is actually an excerpt of the full megapatchset -- I'm only sending about 51 patches from the kernel branch, which is enough to rebuild the space management btrees that don't require special effort. I've left for another day the remaining ~400 patches in part 1.
--D
cover xfs: fix online repair block reaping
Hi all,
These patches fix a few problems that I noticed in the code that deals with old btree blocks after a successful repair.
First, I observed that it is possible for repair to incorrectly invalidate and delete old btree blocks if they were crosslinked. The solution here is to consult the reverse mappings for each block in the extent -- singly owned blocks are invalidated and freed, whereas for crosslinked blocks, we merely drop the incorrect reverse mapping.
A largeish change in this patchset is moving the reaping code to a separate file, because the code are mostly interrelated static functions. For now this also drops the ability to reap file blocks, which will return when we add the bmbt repair functions.
Second, we convert the reap function to use EFIs so that we can commit to freeing as many blocks in as few transactions as we dare. We would like to free as many old blocks as we can in the same transaction that commits the new structure to the ondisk filesystem to minimize the number of blocks that leak if the system crashes before the repair fully completes.
The third change made in this series is to avoid tripping buffer cache assertions if we're merely scanning the buffer cache for buffers to invalidate, and find a non-stale buffer of the wrong length. This is primarily cosmetic, but makes my life easier.
The fourth change restructures the reaping code to try to process as many blocks in one go as possible, to reduce logging traffic.
The last change switches the reaping mechanism to use per-AG bitmaps defined in a previous patchset. This should reduce type confusion when reading the source code.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-reap-fixes
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-reap-fixes
--- fs/xfs/Makefile | 1 fs/xfs/scrub/agheader_repair.c | 75 +++--- fs/xfs/scrub/bitmap.c | 78 ------ fs/xfs/scrub/bitmap.h | 10 - fs/xfs/scrub/reap.c | 499 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/reap.h | 12 + fs/xfs/scrub/repair.c | 366 ++++------------------------- fs/xfs/scrub/repair.h | 10 - fs/xfs/scrub/trace.h | 72 +++--- fs/xfs/xfs_buf.c | 9 + fs/xfs/xfs_buf.h | 13 + 11 files changed, 666 insertions(+), 479 deletions(-) create mode 100644 fs/xfs/scrub/reap.c create mode 100644 fs/xfs/scrub/reap.h
PATCH 1/9 xfs: cull repair code that will never get used
From: Darrick J. Wong <[email protected]>
These two functions date from the era when I thought that we could rebuild btrees by creating an alternate root and adding records one by one. In other words, they predate the btree bulk loader. They're not necessary now, so remove them.
--- fs/xfs/scrub/repair.c | 83 ------------------------------------------------- fs/xfs/scrub/repair.h | 6 ---- fs/xfs/scrub/trace.h | 22 ------------- 3 files changed, 111 deletions(-)
fs/xfs/scrub/repair.c +0 -83
@@ -297,89 +297,6 @@ xrep_calc_ag_resblks(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->sa.pag, 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.pag->pag_agno, bno); -if (resv ==XFS_AG_RESV_RMAPBT ) -xfs_ag_resv_rmapbt_alloc (sc->mp, sc->sa.pag->pag_agno); -return 0 ; -default : -break ; - } - - args.tp = sc->tp; - args.mp = sc->mp; - args.pag = sc->sa.pag; - args.oinfo = *oinfo; - args.minlen =1 ; - args.maxlen =1 ; - args.prod =1 ; - args.resv = resv; - - error =xfs_alloc_vextent_this_ag (&args, sc->sa.pag->pag_agno); -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.pag->pag_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.pag->pag_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 *
fs/xfs/scrub/repair.h +0 -6
@@ -23,12 +23,6 @@ int xrep_roll_ag_trans(struct xfs_scrub *sc);bool xrep_ag_has_space (struct xfs_perag *pag,xfs_extlen_t nr_blocks,enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc); -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); -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 xbitmap ;struct xagb_bitmap ;
fs/xfs/scrub/trace.h +0 -22
@@ -827,28 +827,6 @@ TRACE_EVENT(xrep_refcount_extent_fn, __entry->refcount) ) -TRACE_EVENT (xrep_init_btblock, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, - xfs_btnum_t btnum), -TP_ARGS (mp, agno, agbno, btnum), -TP_STRUCT__entry ( - __field(dev_t, dev) - __field(xfs_agnumber_t, agno) - __field(xfs_agblock_t, agbno) -__field (uint32_t, btnum) - ), -TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->agbno = agbno; - __entry->btnum = btnum; - ), -TP_printk ("dev %d:%d agno 0x%x agbno 0x%x btree %s" , -MAJOR (__entry->dev),MINOR (__entry->dev), - __entry->agno, - __entry->agbno, -__print_symbolic (__entry->btnum,XFS_BTNUM_STRINGS )) -) TRACE_EVENT(xrep_findroot_block, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, uint32_t magic, uint16_t level),
PATCH 2/9 xfs: move the post-repair block reaping code to a separate file
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Reaping blocks after a repair is a complicated affair involving a lot of rmap btree lookups and figuring out if we're going to unmap or free old metadata blocks that might be crosslinked. Eventually, we will need to be able to reap per-AG metadata blocks, bmbt blocks from inode forks, garbage CoW staging extents, and (even later) blocks from btrees rooted in inodes. This results in a lot of reaping code, so we might as well split that off while it's easy.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/reap.c | 268 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/reap.h | 13 ++ fs/xfs/scrub/repair.c | 232 ----------------------------------- fs/xfs/scrub/repair.h | 2 6 files changed, 283 insertions(+), 234 deletions(-) create mode 100644 fs/xfs/scrub/reap.c create mode 100644 fs/xfs/scrub/reap.h
fs/xfs/Makefile +1 -0
@@ -173,6 +173,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ + reap.o \ repair.o \ ) endif
fs/xfs/scrub/agheader_repair.c +1 -0
@@ -26,6 +26,7 @@#include "scrub/trace.h" #include "scrub/repair.h" #include "scrub/bitmap.h" +#include "scrub/reap.h" /* Superblock */
fs/xfs/scrub/reap.c new file +268 -0
268 lines not on this page · raw message
fs/xfs/scrub/reap.h new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (C) 2022-2023 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_REAP_H__ +#define __XFS_SCRUB_REAP_H__ + +int xrep_reap_extents (struct xfs_scrub *sc,struct xbitmap *bitmap, +const struct xfs_owner_info *oinfo, +enum xfs_ag_resv_type type); + +#endif /* __XFS_SCRUB_REAP_H__ */
fs/xfs/scrub/repair.c +0 -232
246 lines not on this page · raw message
fs/xfs/scrub/repair.h +0 -2
@@ -29,8 +29,6 @@ struct xagb_bitmap;int xrep_fix_freelist (struct xfs_scrub *sc,bool can_shrink);int xrep_invalidate_blocks (struct xfs_scrub *sc,struct xbitmap *btlist); -int xrep_reap_extents (struct xfs_scrub *sc,struct xbitmap *exlist, -const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type);struct xrep_find_ag_btree {/* in: rmap owner of the btree we're looking for */
PATCH 3/9 xfs: only invalidate blocks if we're going to free them
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're discarding old btree blocks after a repair, only invalidate the buffers for the ones that we're freeing -- if the metadata was crosslinked with another data structure, we don't want to touch it.
--- fs/xfs/scrub/reap.c | 96 +++++++++++++++++++++---------------------------- fs/xfs/scrub/repair.h | 1 - 2 files changed, 42 insertions(+), 55 deletions(-)
fs/xfs/scrub/reap.c +42 -54
@@ -70,54 +70,10 @@* * 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. +* we're not looking. We must also invalidate any buffers associated with +* @bitmap. */ -static int -xrep_invalidate_block ( -uint64_t fsbno, -void *priv) -{ -struct xfs_scrub *sc = priv; -struct xfs_buf *bp; -int error; - -/* Skip AG headers and post-EOFS blocks */ -if (!xfs_verify_fsbno (sc->mp, fsbno)) -return 0 ; - - error =xfs_buf_incore (sc->mp->m_ddev_targp, -XFS_FSB_TO_DADDR (sc->mp, fsbno), -XFS_FSB_TO_BB (sc->mp,1 ),XBF_TRYLOCK , &bp); -if (error) -return 0 ; - -xfs_trans_bjoin (sc->tp, bp); -xfs_trans_binval (sc->tp, bp); -return 0 ; -} - -/* -* 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) -{ -/* -* 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. -*/ -return xbitmap_walk_bits (bitmap, xrep_invalidate_block, sc); -} -/* Information about reaping extents after a repair. */ struct xrep_reap_state {struct xfs_scrub *sc;
@@ -127,9 +83,7 @@ struct xrep_reap_state {enum xfs_ag_resv_type resv; }; -/* -* Put a block back on the AGFL. -*/ +/* Put a block back on the AGFL. */ STATIC int xrep_put_freelist( struct xfs_scrub *sc,
@@ -168,6 +122,37 @@ xrep_put_freelist(return 0 ; } +/* Try to invalidate the incore buffer for a block that we're about to free. */ +STATIC void +xrep_block_reap_binval ( +struct xfs_scrub *sc, +xfs_fsblock_t fsbno) +{ +struct xfs_buf *bp =NULL ; +int error; + +/* +* If there's an incore buffer for exactly this block, invalidate it. +* Avoid invalidating AG headers and post-EOFS blocks because we never +* own those. +*/ +if (!xfs_verify_fsbno (sc->mp, fsbno)) +return ; + +/* +* We assume that the lack of any other known owners means that the +* buffer can be locked without risk of deadlocking. +*/ + error =xfs_buf_incore (sc->mp->m_ddev_targp, +XFS_FSB_TO_DADDR (sc->mp, fsbno), +XFS_FSB_TO_BB (sc->mp,1 ),0 , &bp); +if (error) +return ; + +xfs_trans_bjoin (sc->tp, bp); +xfs_trans_binval (sc->tp, bp); +} +/* Dispose of a single block. */ STATIC int xrep_reap_block(
@@ -225,14 +210,17 @@ xrep_reap_block(* 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 , rs->oinfo); -else if (rs->resv ==XFS_AG_RESV_AGFL ) +if (has_other_rmap) { + error =xfs_rmap_free (sc->tp, agf_bp, sc->sa.pag, agbno,1 , + rs->oinfo); + }else if (rs->resv ==XFS_AG_RESV_AGFL ) { +xrep_block_reap_binval (sc, fsbno); error =xrep_put_freelist (sc, agbno); -else + }else { +xrep_block_reap_binval (sc, fsbno); error =xfs_free_extent (sc->tp, sc->sa.pag, agbno,1 , rs->oinfo, rs->resv); + }if (agf_bp != sc->sa.agf_bp)xfs_trans_brelse (sc->tp, agf_bp);if (error)
fs/xfs/scrub/repair.h +0 -1
@@ -28,7 +28,6 @@ struct xbitmap;struct xagb_bitmap ;int xrep_fix_freelist (struct xfs_scrub *sc,bool can_shrink); -int xrep_invalidate_blocks (struct xfs_scrub *sc,struct xbitmap *btlist);struct xrep_find_ag_btree {/* in: rmap owner of the btree we're looking for */
PATCH 4/9 xfs: only allow reaping of per-AG blocks in xrep_reap_extents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we've refactored btree cursors to require the caller to pass in a perag structure, there are numerous problems in xrep_reap_extents if it's being called to reap extents for an inode metadata repair. We don't have any repair functions that can do that, so drop the support for now.
--- fs/xfs/scrub/reap.c | 45 +++++++++++++-------------------------------- 1 file changed, 13 insertions(+), 32 deletions(-)
fs/xfs/scrub/reap.c +13 -32
@@ -162,40 +162,30 @@ xrep_reap_block(struct xrep_reap_state *rs = priv;struct xfs_scrub *sc = rs->sc;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; -ASSERT (sc->ip !=NULL || -XFS_FSB_TO_AGNO (sc->mp, fsbno) == sc->sa.pag->pag_agno); -trace_xrep_dispose_btree_extent (sc->mp, -XFS_FSB_TO_AGNO (sc->mp, fsbno), -XFS_FSB_TO_AGBNO (sc->mp, fsbno),1 ); - + agno =XFS_FSB_TO_AGNO (sc->mp, fsbno); agbno =XFS_FSB_TO_AGBNO (sc->mp, fsbno); -ASSERT (XFS_FSB_TO_AGNO (sc->mp, fsbno) == sc->sa.pag->pag_agno); -/* -* 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->sa.pag, sc->tp,0 , &agf_bp); -if (error) -return error; - }else { - agf_bp = sc->sa.agf_bp; +trace_xrep_dispose_btree_extent (sc->mp, agno, agbno,1 ); + +/* We don't support reaping file extents yet. */ +if (sc->ip !=NULL || sc->sa.pag->pag_agno != agno) { +ASSERT (0 ); +return -EFSCORRUPTED ; } - cur =xfs_rmapbt_init_cursor (sc->mp, sc->tp, agf_bp, sc->sa.pag); + + cur =xfs_rmapbt_init_cursor (sc->mp, sc->tp, sc->sa.agf_bp, sc->sa.pag);/* Can we find any other rmappings? */ error =xfs_rmap_has_other_keys (cur, agbno,1 , rs->oinfo, &has_other_rmap);xfs_btree_del_cursor (cur, error);if (error) - goto out_free; +return error;/* * If there are other rmappings, this block is cross linked and must
@@ -211,8 +201,8 @@ xrep_reap_block(* to run xfs_repair. */ if (has_other_rmap) { - error =xfs_rmap_free (sc->tp, agf_bp, sc->sa.pag, agbno,1 , - rs->oinfo); + error =xfs_rmap_free (sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, +1 , rs->oinfo); }else if (rs->resv ==XFS_AG_RESV_AGFL ) {xrep_block_reap_binval (sc, fsbno); error =xrep_put_freelist (sc, agbno);
@@ -221,19 +211,10 @@ xrep_reap_block( error =xfs_free_extent (sc->tp, sc->sa.pag, agbno,1 , rs->oinfo, rs->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. */
PATCH 5/9 xfs: use deferred frees to reap old btree blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use deferred frees (EFIs) to reap the blocks of a btree that we just replaced. This helps us to shrink the window in which those old blocks could be lost due to a system crash, though we try to flush the EFIs every few hundred blocks so that we don't also overflow the transaction reservations during and after we commit the new btree.
--- fs/xfs/scrub/reap.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)
fs/xfs/scrub/reap.c +26 -4
@@ -26,6 +26,7 @@#include "xfs_ag_resv.h" #include "xfs_quota.h" #include "xfs_qm.h" +#include "xfs_bmap.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -81,6 +82,9 @@ struct xrep_reap_state {/* Reverse mapping owner and metadata reservation type. */ const struct xfs_owner_info *oinfo;enum xfs_ag_resv_type resv; + +/* Number of deferred reaps attached to the current transaction. */ +unsigned int deferred; };/* Put a block back on the AGFL. */
@@ -165,6 +169,7 @@ xrep_reap_block(xfs_agnumber_t agno;xfs_agblock_t agbno;bool has_other_rmap; +bool need_roll = true;int error; agno =XFS_FSB_TO_AGNO (sc->mp, fsbno);
@@ -207,13 +212,25 @@ xrep_reap_block(xrep_block_reap_binval (sc, fsbno); error =xrep_put_freelist (sc, agbno); }else { +/* +* Use deferred frees to get rid of the old btree blocks to try +* to minimize the window in which we could crash and lose the +* old blocks. However, we still need to roll the transaction +* every 100 or so EFIs so that we don't exceed the log +* reservation. +*/ xrep_block_reap_binval (sc, fsbno); - error =xfs_free_extent (sc->tp, sc->sa.pag, agbno,1 , rs->oinfo, - rs->resv); + error =__xfs_free_extent_later (sc->tp, fsbno,1 , rs->oinfo, + rs->resv, true); +if (error) +return error; + rs->deferred++; + need_roll = rs->deferred >100 ; } -if (error) +if (error || !need_roll)return error; + rs->deferred =0 ;return xrep_roll_ag_trans (sc); }
@@ -230,8 +247,13 @@ xrep_reap_extents( .oinfo = oinfo, .resv = type, }; +int error;ASSERT (xfs_has_rmapbt (sc->mp)); -return xbitmap_walk_bits (bitmap, xrep_reap_block, &rs); + error =xbitmap_walk_bits (bitmap, xrep_reap_block, &rs); +if (error || rs.deferred ==0 ) +return error; + +return xrep_roll_ag_trans (sc); }
PATCH 6/9 xfs: rearrange xrep_reap_block to make future code flow easier
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Rearrange the logic inside xrep_reap_block to make it more obvious that crosslinked metadata blocks are handled differently. Add a couple of tracepoints so that we can tell what's going on at the end of a btree rebuild operation.
--- fs/xfs/scrub/agheader_repair.c | 6 +++--- fs/xfs/scrub/reap.c | 19 ++++++++++++++----- fs/xfs/scrub/trace.h | 17 ++++++++--------- 3 files changed, 25 insertions(+), 17 deletions(-)
fs/xfs/scrub/agheader_repair.c +3 -3
@@ -646,13 +646,13 @@ xrep_agfl_fill(xfs_fsblock_t fsbno = start;int error; +trace_xrep_agfl_insert (sc->sa.pag,XFS_FSB_TO_AGBNO (sc->mp, start), + len); +while (fsbno < start + len && af->fl_off < af->flcount) af->agfl_bno[af->fl_off++] =cpu_to_be32 (XFS_FSB_TO_AGBNO (sc->mp, fsbno++)); -trace_xrep_agfl_insert (sc->mp, sc->sa.pag->pag_agno, -XFS_FSB_TO_AGBNO (sc->mp, start), len); - error =xbitmap_set (&af->used_extents, start, fsbno -1 );if (error)return error;
fs/xfs/scrub/reap.c +14 -5
@@ -175,8 +175,6 @@ xrep_reap_block( agno =XFS_FSB_TO_AGNO (sc->mp, fsbno); agbno =XFS_FSB_TO_AGBNO (sc->mp, fsbno); -trace_xrep_dispose_btree_extent (sc->mp, agno, agbno,1 ); -/* We don't support reaping file extents yet. */ if (sc->ip !=NULL || sc->sa.pag->pag_agno != agno) {ASSERT (0 );
@@ -206,10 +204,21 @@ xrep_reap_block(* to run xfs_repair. */ if (has_other_rmap) { +trace_xrep_dispose_unmap_extent (sc->sa.pag, agbno,1 ); + error =xfs_rmap_free (sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno,1 , rs->oinfo); - }else if (rs->resv ==XFS_AG_RESV_AGFL ) { -xrep_block_reap_binval (sc, fsbno); +if (error) +return error; + + goto roll_out; + } + +trace_xrep_dispose_free_extent (sc->sa.pag, agbno,1 ); + +xrep_block_reap_binval (sc, fsbno); + +if (rs->resv ==XFS_AG_RESV_AGFL ) { error =xrep_put_freelist (sc, agbno); }else {/*
@@ -219,7 +228,6 @@ xrep_reap_block(* every 100 or so EFIs so that we don't exceed the log * reservation. */ -xrep_block_reap_binval (sc, fsbno); error =__xfs_free_extent_later (sc->tp, fsbno,1 , rs->oinfo, rs->resv, true);if (error)
@@ -230,6 +238,7 @@ xrep_reap_block(if (error || !need_roll)return error; +roll_out: rs->deferred =0 ;return xrep_roll_ag_trans (sc); }
fs/xfs/scrub/trace.h +8 -9
@@ -729,9 +729,8 @@ TRACE_EVENT(xchk_refcount_incorrect,#if IS_ENABLED (CONFIG_XFS_ONLINE_REPAIR ) DECLARE_EVENT_CLASS(xrep_extent_class, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, - xfs_agblock_t agbno, xfs_extlen_t len), - TP_ARGS(mp, agno, agbno, len), + TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), + TP_ARGS(pag, agbno, len), TP_STRUCT__entry( __field(dev_t, dev) __field(xfs_agnumber_t, agno)
@@ -739,8 +738,8 @@ DECLARE_EVENT_CLASS(xrep_extent_class,__field (xfs_extlen_t, len) ),TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->agno = pag->pag_agno; __entry->agbno = agbno; __entry->len = len; ),
@@ -752,10 +751,10 @@ DECLARE_EVENT_CLASS(xrep_extent_class, );#define DEFINE_REPAIR_EXTENT_EVENT (name) \ DEFINE_EVENT(xrep_extent_class, name, \ - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ - xfs_agblock_t agbno, xfs_extlen_t len), \ - TP_ARGS(mp, agno, agbno, len)) -DEFINE_REPAIR_EXTENT_EVENT (xrep_dispose_btree_extent); + TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \ + TP_ARGS(pag, agbno, len)) +DEFINE_REPAIR_EXTENT_EVENT (xrep_dispose_unmap_extent); +DEFINE_REPAIR_EXTENT_EVENT (xrep_dispose_free_extent);DEFINE_REPAIR_EXTENT_EVENT (xrep_agfl_insert); DECLARE_EVENT_CLASS(xrep_rmap_class,
PATCH 7/9 xfs: allow scanning ranges of the buffer cache for live buffers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
After an online repair, we need to invalidate buffers representing the blocks from the old metadata that we're replacing. It's possible that parts of a tree that were previously cached in memory are no longer accessible due to media failure or other corruption on interior nodes, so repair figures out the old blocks from the reverse mapping data and scans the buffer cache directly.
In other words, online fsck needs to find all the live (i.e. non-stale) buffers for a range of fsblocks so that it can invalidate them.
Unfortunately, the current buffer cache code triggers asserts if the rhashtable lookup finds a non-stale buffer of a different length than the key we searched for. For regular operation this is desirable, but for this repair procedure, we don't care since we're going to forcibly stale the buffer anyway. Add an internal lookup flag to avoid the assert. Skip buffers that are already XBF_STALE.
--- fs/xfs/scrub/reap.c | 2 +- fs/xfs/xfs_buf.c | 9 ++++++++- fs/xfs/xfs_buf.h | 13 +++++++++++++ 3 files changed, 22 insertions(+), 2 deletions(-)
fs/xfs/scrub/reap.c +1 -1
@@ -149,7 +149,7 @@ xrep_block_reap_binval(*/ error =xfs_buf_incore (sc->mp->m_ddev_targp,XFS_FSB_TO_DADDR (sc->mp, fsbno), -XFS_FSB_TO_BB (sc->mp,1 ),0 , &bp); +XFS_FSB_TO_BB (sc->mp,1 ),XBF_LIVESCAN , &bp);if (error)return ;
fs/xfs/xfs_buf.c +8 -1
@@ -481,7 +481,8 @@ _xfs_buf_obj_cmp(* reallocating a busy extent. Skip this buffer and * continue searching for an exact match. */ -ASSERT (bp->b_flags &XBF_STALE ); +if (!(map->bm_flags &XBM_LIVESCAN )) +ASSERT (bp->b_flags &XBF_STALE );return 1 ; }return 0 ;
@@ -559,6 +560,10 @@ xfs_buf_find_lock(* intact here. */ if (bp->b_flags &XBF_STALE ) { +if (flags &XBF_LIVESCAN ) { +xfs_buf_unlock (bp); +return -ENOENT ; + }ASSERT ((bp->b_flags & _XBF_DELWRI_Q) ==0 ); bp->b_flags &= _XBF_KMEM | _XBF_PAGES; bp->b_ops =NULL ;
@@ -682,6 +687,8 @@ xfs_buf_get_map(int error;int i; +if (flags &XBF_LIVESCAN ) + cmap.bm_flags |=XBM_LIVESCAN ;for (i =0 ; i < nmaps; i++) cmap.bm_len += map[i].bm_len;
fs/xfs/xfs_buf.h +13 -0
@@ -44,6 +44,11 @@ struct xfs_buf;#define _XBF_DELWRI_Q (1u << 22)/* buffer on a delwri queue */ /* flags used only as arguments to access routines */ +/* +* Online fsck is scanning the buffer cache for live buffers. Do not warn +* about length mismatches during lookups and do not return stale buffers. +*/ +#define XBF_LIVESCAN (1u << 28)#define XBF_INCORE (1u << 29)/* lookup only, return if found in cache */ #define XBF_TRYLOCK (1u << 30)/* lock requested, but do not wait */ #define XBF_UNMAPPED (1u << 31)/* do not map the buffer */
@@ -67,6 +72,7 @@ typedef unsigned int xfs_buf_flags_t; { _XBF_KMEM, "KMEM" }, \ { _XBF_DELWRI_Q, "DELWRI_Q" }, \/* The following interface flags should never be set */ \ + { XBF_LIVESCAN, "LIVESCAN" }, \ { XBF_INCORE, "INCORE" }, \ { XBF_TRYLOCK, "TRYLOCK" }, \ { XBF_UNMAPPED, "UNMAPPED" }
@@ -114,8 +120,15 @@ typedef struct xfs_buftarg {struct xfs_buf_map {xfs_daddr_t bm_bn;/* block number for I/O */ int bm_len;/* size of I/O */ +unsigned int bm_flags; }; +/* +* Online fsck is scanning the buffer cache for live buffers. Do not warn +* about length mismatches during lookups and do not return stale buffers. +*/ +#define XBM_LIVESCAN (1U << 0) +#define DEFINE_SINGLE_BUF_MAP (map, blkno, numblk) \ struct xfs_buf_map (map) = { .bm_bn = (blkno), .bm_len = (numblk) };
PATCH 8/9 xfs: reap large AG metadata extents when possible
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're freeing extents that have been set in a bitmap, break the bitmap extent into multiple sub-extents organized by fate, and reap the extents. This enables us to dispose of old resources more efficiently than doing them block by block.
While we're at it, rename the reaping functions to make it clear that they're reaping per-AG extents.
--- fs/xfs/scrub/agheader_repair.c | 2 fs/xfs/scrub/bitmap.c | 37 ---- fs/xfs/scrub/bitmap.h | 4 fs/xfs/scrub/reap.c | 399 ++++++++++++++++++++++++++++++++-------- fs/xfs/scrub/reap.h | 2 fs/xfs/scrub/repair.c | 51 +++++ fs/xfs/scrub/repair.h | 1 fs/xfs/scrub/trace.h | 37 ++++ 8 files changed, 407 insertions(+), 126 deletions(-)
fs/xfs/scrub/agheader_repair.c +1 -1
@@ -775,7 +775,7 @@ xrep_agfl( goto err;/* Dump any AGFL overflow. */ - error =xrep_reap_extents (sc, &agfl_extents, &XFS_RMAP_OINFO_AG , + error =xrep_reap_ag_metadata (sc, &agfl_extents, &XFS_RMAP_OINFO_AG ,XFS_AG_RESV_AGFL ); err:xbitmap_destroy (&agfl_extents);
fs/xfs/scrub/bitmap.c +0 -37
@@ -385,43 +385,6 @@ xbitmap_walk(return error; } -struct xbitmap_walk_bits { -xbitmap_walk_bits_fn fn; -void *priv; -}; - -/* Walk all the bits in a run. */ -static int -xbitmap_walk_bits_in_run ( -uint64_t start, -uint64_t len, -void *priv) -{ -struct xbitmap_walk_bits *wb = priv; -uint64_t i; -int error =0 ; - -for (i = start; i < start + len; i++) { - error = wb->fn (i, wb->priv); -if (error) -break ; - } - -return error; -} - -/* Call a function for every set bit in this bitmap. */ -int -xbitmap_walk_bits ( -struct xbitmap *bitmap, -xbitmap_walk_bits_fn fn, -void *priv) -{ -struct xbitmap_walk_bits wb = {.fn = fn, .priv = priv}; - -return xbitmap_walk (bitmap, xbitmap_walk_bits_in_run, &wb); -} -/* Does this bitmap have no bits set at all? */ bool xbitmap_empty(
fs/xfs/scrub/bitmap.h +0 -4
@@ -33,10 +33,6 @@ typedef int (*xbitmap_walk_fn)(uint64_t start, uint64_t len, void *priv);int xbitmap_walk (struct xbitmap *bitmap,xbitmap_walk_fn fn,void *priv); -typedef int (*xbitmap_walk_bits_fn )(uint64_t bit,void *priv); -int xbitmap_walk_bits (struct xbitmap *bitmap,xbitmap_walk_bits_fn fn, -void *priv); -bool xbitmap_empty (struct xbitmap *bitmap);bool xbitmap_test (struct xbitmap *bitmap,uint64_t start,uint64_t *len);
fs/xfs/scrub/reap.c +318 -81
478 lines not on this page · raw message
fs/xfs/scrub/reap.h +1 -1
@@ -6,7 +6,7 @@#ifndef __XFS_SCRUB_REAP_H__#define __XFS_SCRUB_REAP_H__ -int xrep_reap_extents (struct xfs_scrub *sc,struct xbitmap *bitmap, +int xrep_reap_ag_metadata (struct xfs_scrub *sc,struct xbitmap *bitmap,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type);
fs/xfs/scrub/repair.c +51 -0
63 lines not on this page · raw message
fs/xfs/scrub/repair.h +1 -0
@@ -20,6 +20,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)int xrep_attempt (struct xfs_scrub *sc);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc); +int xrep_defer_finish (struct xfs_scrub *sc);bool xrep_ag_has_space (struct xfs_perag *pag,xfs_extlen_t nr_blocks,enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc);
fs/xfs/scrub/trace.h +35 -2
@@ -753,10 +753,43 @@ DECLARE_EVENT_CLASS(xrep_extent_class,DEFINE_EVENT (xrep_extent_class, name, \ TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \ TP_ARGS(pag, agbno, len)) -DEFINE_REPAIR_EXTENT_EVENT (xrep_dispose_unmap_extent); -DEFINE_REPAIR_EXTENT_EVENT (xrep_dispose_free_extent); +DEFINE_REPAIR_EXTENT_EVENT (xreap_dispose_unmap_extent); +DEFINE_REPAIR_EXTENT_EVENT (xreap_dispose_free_extent); +DEFINE_REPAIR_EXTENT_EVENT (xreap_agextent_binval);DEFINE_REPAIR_EXTENT_EVENT (xrep_agfl_insert); +DECLARE_EVENT_CLASS (xrep_reap_find_class, + TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, + bool crosslinked), +TP_ARGS (pag, agbno, len, crosslinked), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(xfs_extlen_t, len) +__field (bool, crosslinked) + ), +TP_fast_assign ( + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->agno = pag->pag_agno; + __entry->agbno = agbno; + __entry->len = len; + __entry->crosslinked = crosslinked; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x crosslinked %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->agbno, + __entry->len, + __entry->crosslinked ?1 :0 ) +); +#define DEFINE_REPAIR_REAP_FIND_EVENT (name) \ +DEFINE_EVENT(xrep_reap_find_class, name, \ + TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, \ + bool crosslinked), \ + TP_ARGS(pag, agbno, len, crosslinked)) +DEFINE_REPAIR_REAP_FIND_EVENT (xreap_agextent_select); + DECLARE_EVENT_CLASS(xrep_rmap_class, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, xfs_extlen_t len,
PATCH 9/9 xfs: use per-AG bitmaps to reap unused AG metadata blocks during repair
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The AGFL repair code uses a series of bitmaps to figure out where there are OWN_AG blocks that are not claimed by the free space and rmap btrees. These blocks become the new AGFL, and any overflow is reaped. The bitmaps current track xfs_fsblock_t even though we already know the AG number.
In the last patch, we introduced a new bitmap "type" for tracking xfs_agblock_t extents. Port the reaping code and the AGFL repair to use this new type, which makes it very obvious what we're tracking. This also eliminates a bunch of unnecessary agblock <-> fsblock conversions.
--- fs/xfs/scrub/agheader_repair.c | 74 ++++++++++++++++++---------------------- fs/xfs/scrub/bitmap.c | 41 ++-------------------- fs/xfs/scrub/bitmap.h | 6 +-- fs/xfs/scrub/reap.c | 14 ++------ fs/xfs/scrub/reap.h | 5 +-- 5 files changed, 45 insertions(+), 95 deletions(-)
fs/xfs/scrub/agheader_repair.c +34 -40
@@ -445,13 +445,13 @@ xrep_agf(struct xrep_agfl {/* Bitmap of alleged AGFL blocks that we're not going to add. */ -struct xbitmap crossed; +struct xagb_bitmap crossed;/* Bitmap of other OWN_AG metadata blocks. */ -struct xbitmap agmetablocks; +struct xagb_bitmap agmetablocks;/* Bitmap of free space. */ -struct xbitmap *freesp; +struct xagb_bitmap *freesp;/* rmapbt cursor for finding crosslinked blocks */ struct xfs_btree_cur *rmap_cur;
@@ -467,7 +467,6 @@ xrep_agfl_walk_rmap( void *priv) {struct xrep_agfl *ra = priv; -xfs_fsblock_t fsb;int error =0 ;if (xchk_should_terminate (ra->sc, &error))
@@ -475,14 +474,13 @@ xrep_agfl_walk_rmap(/* Record all the OWN_AG blocks. */ if (rec->rm_owner ==XFS_RMAP_OWN_AG ) { - fsb =XFS_AGB_TO_FSB (cur->bc_mp, cur->bc_ag.pag->pag_agno, - rec->rm_startblock); - error =xbitmap_set (ra->freesp, fsb, rec->rm_blockcount); + error =xagb_bitmap_set (ra->freesp, rec->rm_startblock, + rec->rm_blockcount);if (error)return error; } -return xbitmap_set_btcur_path (&ra->agmetablocks, cur); +return xagb_bitmap_set_btcur_path (&ra->agmetablocks, cur); }/* Strike out the blocks that are cross-linked according to the rmapbt. */
@@ -493,12 +491,10 @@ xrep_agfl_check_extent( void *priv) {struct xrep_agfl *ra = priv; -xfs_agblock_t agbno =XFS_FSB_TO_AGBNO (ra->sc->mp, start); +xfs_agblock_t agbno = start;xfs_agblock_t last_agbno = agbno + len -1 ;int error; -ASSERT (XFS_FSB_TO_AGNO (ra->sc->mp, start) == ra->sc->sa.pag->pag_agno); -while (agbno <= last_agbno) {bool other_owners;
@@ -508,7 +504,7 @@ xrep_agfl_check_extent(return error;if (other_owners) { - error =xbitmap_set (&ra->crossed, agbno,1 ); + error =xagb_bitmap_set (&ra->crossed, agbno,1 );if (error)return error; }
@@ -534,7 +530,7 @@ STATIC intxrep_agfl_collect_blocks ( struct xfs_scrub *sc, struct xfs_buf *agf_bp, - struct xbitmap *agfl_extents, + struct xagb_bitmap *agfl_extents, xfs_agblock_t *flcount) { struct xrep_agfl ra;
@@ -544,8 +540,8 @@ xrep_agfl_collect_blocks( ra.sc = sc; ra.freesp = agfl_extents; -xbitmap_init (&ra.agmetablocks); -xbitmap_init (&ra.crossed); +xagb_bitmap_init (&ra.agmetablocks); +xagb_bitmap_init (&ra.crossed);/* Find all space used by the free space btrees & rmapbt. */ cur =xfs_rmapbt_init_cursor (mp, sc->tp, agf_bp, sc->sa.pag);
@@ -557,7 +553,7 @@ xrep_agfl_collect_blocks(/* Find all blocks currently being used by the bnobt. */ cur =xfs_allocbt_init_cursor (mp, sc->tp, agf_bp, sc->sa.pag,XFS_BTNUM_BNO ); - error =xbitmap_set_btblocks (&ra.agmetablocks, cur); + error =xagb_bitmap_set_btblocks (&ra.agmetablocks, cur);xfs_btree_del_cursor (cur, error);if (error) goto out_bmp;
@@ -565,7 +561,7 @@ xrep_agfl_collect_blocks(/* Find all blocks currently being used by the cntbt. */ cur =xfs_allocbt_init_cursor (mp, sc->tp, agf_bp, sc->sa.pag,XFS_BTNUM_CNT ); - error =xbitmap_set_btblocks (&ra.agmetablocks, cur); + error =xagb_bitmap_set_btblocks (&ra.agmetablocks, cur);xfs_btree_del_cursor (cur, error);if (error) goto out_bmp;
@@ -574,17 +570,17 @@ xrep_agfl_collect_blocks(* Drop the freesp meta blocks that are in use by btrees. * The remaining blocks /should/ be AGFL blocks. */ - error =xbitmap_disunion (agfl_extents, &ra.agmetablocks); + error =xagb_bitmap_disunion (agfl_extents, &ra.agmetablocks);if (error) goto out_bmp;/* Strike out the blocks that are cross-linked. */ ra.rmap_cur =xfs_rmapbt_init_cursor (mp, sc->tp, agf_bp, sc->sa.pag); - error =xbitmap_walk (agfl_extents, xrep_agfl_check_extent, &ra); + error =xagb_bitmap_walk (agfl_extents, xrep_agfl_check_extent, &ra);xfs_btree_del_cursor (ra.rmap_cur, error);if (error) goto out_bmp; - error =xbitmap_disunion (agfl_extents, &ra.crossed); + error =xagb_bitmap_disunion (agfl_extents, &ra.crossed);if (error) goto out_bmp;
@@ -592,12 +588,12 @@ xrep_agfl_collect_blocks(* Calculate the new AGFL size. If we found more blocks than fit in * the AGFL we'll free them later. */ - *flcount =min_t (uint64_t,xbitmap_hweight (agfl_extents), + *flcount =min_t (uint64_t,xagb_bitmap_hweight (agfl_extents),xfs_agfl_size (mp)); out_bmp: -xbitmap_destroy (&ra.crossed); -xbitmap_destroy (&ra.agmetablocks); +xagb_bitmap_destroy (&ra.crossed); +xagb_bitmap_destroy (&ra.agmetablocks);return error; }
@@ -627,7 +623,7 @@ xrep_agfl_update_agf( }struct xrep_agfl_fill { -struct xbitmap used_extents; +struct xagb_bitmap used_extents;struct xfs_scrub *sc;__be32 *agfl_bno;xfs_agblock_t flcount;
@@ -643,17 +639,15 @@ xrep_agfl_fill( {struct xrep_agfl_fill *af = priv;struct xfs_scrub *sc = af->sc; -xfs_fsblock_t fsbno = start; +xfs_agblock_t agbno = start;int error; -trace_xrep_agfl_insert (sc->sa.pag,XFS_FSB_TO_AGBNO (sc->mp, start), - len); +trace_xrep_agfl_insert (sc->sa.pag, agbno, len); -while (fsbno < start + len && af->fl_off < af->flcount) - af->agfl_bno[af->fl_off++] = -cpu_to_be32 (XFS_FSB_TO_AGBNO (sc->mp, fsbno++)); +while (agbno < start + len && af->fl_off < af->flcount) + af->agfl_bno[af->fl_off++] =cpu_to_be32 (agbno++); - error =xbitmap_set (&af->used_extents, start, fsbno -1 ); + error =xagb_bitmap_set (&af->used_extents, start, agbno -1 );if (error)return error;
@@ -668,7 +662,7 @@ STATIC int xrep_agfl_init_header( struct xfs_scrub *sc, struct xfs_buf *agfl_bp, - struct xbitmap *agfl_extents, + struct xagb_bitmap *agfl_extents, xfs_agblock_t flcount) { struct xrep_agfl_fill af = {
@@ -696,17 +690,17 @@ xrep_agfl_init_header(* blocks than fit in the AGFL, they will be freed in a subsequent * step. */ -xbitmap_init (&af.used_extents); +xagb_bitmap_init (&af.used_extents); af.agfl_bno =xfs_buf_to_agfl_bno (agfl_bp), -xbitmap_walk (agfl_extents, xrep_agfl_fill, &af); - error =xbitmap_disunion (agfl_extents, &af.used_extents); +xagb_bitmap_walk (agfl_extents, xrep_agfl_fill, &af); + error =xagb_bitmap_disunion (agfl_extents, &af.used_extents);if (error)return error;/* Write new AGFL to disk. */ xfs_trans_buf_set_type (sc->tp, agfl_bp,XFS_BLFT_AGFL_BUF );xfs_trans_log_buf (sc->tp, agfl_bp,0 ,BBTOB (agfl_bp->b_length) -1 ); -xbitmap_destroy (&af.used_extents); +xagb_bitmap_destroy (&af.used_extents);return 0 ; }
@@ -715,7 +709,7 @@ intxrep_agfl ( struct xfs_scrub *sc) { -struct xbitmap agfl_extents; +struct xagb_bitmap agfl_extents;struct xfs_mount *mp = sc->mp;struct xfs_buf *agf_bp;struct xfs_buf *agfl_bp;
@@ -726,7 +720,7 @@ xrep_agfl(if (!xfs_has_rmapbt (mp))return -EOPNOTSUPP ; -xbitmap_init (&agfl_extents); +xagb_bitmap_init (&agfl_extents);/* * Read the AGF so that we can query the rmapbt. We hope that there's
@@ -775,10 +769,10 @@ xrep_agfl( goto err;/* Dump any AGFL overflow. */ - error =xrep_reap_ag_metadata (sc, &agfl_extents, &XFS_RMAP_OINFO_AG , + error =xrep_reap_agblocks (sc, &agfl_extents, &XFS_RMAP_OINFO_AG ,XFS_AG_RESV_AGFL ); err: -xbitmap_destroy (&agfl_extents); +xagb_bitmap_destroy (&agfl_extents);return error; }
fs/xfs/scrub/bitmap.c +3 -38
59 lines not on this page · raw message
fs/xfs/scrub/bitmap.h +2 -4
@@ -16,10 +16,6 @@ void xbitmap_destroy(struct xbitmap *bitmap);int xbitmap_clear (struct xbitmap *bitmap,uint64_t start,uint64_t len);int xbitmap_set (struct xbitmap *bitmap,uint64_t start,uint64_t len);int xbitmap_disunion (struct xbitmap *bitmap,struct xbitmap *sub); -int xbitmap_set_btcur_path (struct xbitmap *bitmap, -struct xfs_btree_cur *cur); -int xbitmap_set_btblocks (struct xbitmap *bitmap, -struct xfs_btree_cur *cur);uint64_t xbitmap_hweight (struct xbitmap *bitmap);/*
@@ -106,5 +102,7 @@ static inline int xagb_bitmap_walk(struct xagb_bitmap *bitmap,int xagb_bitmap_set_btblocks (struct xagb_bitmap *bitmap,struct xfs_btree_cur *cur); +int xagb_bitmap_set_btcur_path (struct xagb_bitmap *bitmap, +struct xfs_btree_cur *cur);#endif /* __XFS_SCRUB_BITMAP_H__ */
fs/xfs/scrub/reap.c +4 -10
@@ -432,19 +432,13 @@ xreap_agmeta_extent( {struct xreap_state *rs = priv;struct xfs_scrub *sc = rs->sc; -xfs_agnumber_t agno =XFS_FSB_TO_AGNO (sc->mp, fsbno); -xfs_agblock_t agbno =XFS_FSB_TO_AGBNO (sc->mp, fsbno); +xfs_agblock_t agbno = fsbno;xfs_agblock_t agbno_next = agbno + len;int error =0 ;ASSERT (len <=XFS_MAX_BMBT_EXTLEN );ASSERT (sc->ip ==NULL ); -if (agno != sc->sa.pag->pag_agno) { -ASSERT (sc->sa.pag->pag_agno == agno); -return -EFSCORRUPTED ; - } -while (agbno < agbno_next) {xfs_extlen_t aglen;bool crosslinked;
@@ -478,9 +472,9 @@ xreap_agmeta_extent(/* Dispose of every block of every AG metadata extent in the bitmap. */ int -xrep_reap_ag_metadata ( +xrep_reap_agblocks (struct xfs_scrub *sc, -struct xbitmap *bitmap, +struct xagb_bitmap *bitmap,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type) {
@@ -494,7 +488,7 @@ xrep_reap_ag_metadata(ASSERT (xfs_has_rmapbt (sc->mp));ASSERT (sc->ip ==NULL ); - error =xbitmap_walk (bitmap, xreap_agmeta_extent, &rs); + error =xagb_bitmap_walk (bitmap, xreap_agmeta_extent, &rs);if (error)return error;
fs/xfs/scrub/reap.h +2 -3
@@ -6,8 +6,7 @@#ifndef __XFS_SCRUB_REAP_H__#define __XFS_SCRUB_REAP_H__ -int xrep_reap_ag_metadata (struct xfs_scrub *sc,struct xbitmap *bitmap, -const struct xfs_owner_info *oinfo, -enum xfs_ag_resv_type type); +int xrep_reap_agblocks (struct xfs_scrub *sc,struct xagb_bitmap *bitmap, +const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type);#endif /* __XFS_SCRUB_REAP_H__ */
Re: [PATCHSET v26.0 0/9] xfs: fix online repair block reaping
In reply to Darrick J. WongQuoted 35 lines · Darrick J. Wong
Hi all,
These patches fix a few problems that I noticed in the code that deals with old btree blocks after a successful repair.
First, I observed that it is possible for repair to incorrectly invalidate and delete old btree blocks if they were crosslinked. The solution here is to consult the reverse mappings for each block in the extent -- singly owned blocks are invalidated and freed, whereas for crosslinked blocks, we merely drop the incorrect reverse mapping.
A largeish change in this patchset is moving the reaping code to a separate file, because the code are mostly interrelated static functions. For now this also drops the ability to reap file blocks, which will return when we add the bmbt repair functions.
Second, we convert the reap function to use EFIs so that we can commit to freeing as many blocks in as few transactions as we dare. We would like to free as many old blocks as we can in the same transaction that commits the new structure to the ondisk filesystem to minimize the number of blocks that leak if the system crashes before the repair fully completes.
The third change made in this series is to avoid tripping buffer cache assertions if we're merely scanning the buffer cache for buffers to invalidate, and find a non-stale buffer of the wrong length. This is primarily cosmetic, but makes my life easier.
The fourth change restructures the reaping code to try to process as many blocks in one go as possible, to reduce logging traffic.
The last change switches the reaping mechanism to use per-AG bitmaps defined in a previous patchset. This should reduce type confusion when reading the source code.
Quoted 5 lines
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
Overall I don't see any red flags, so from that perspective I think it's good to merge as is. THe buffer cache interactions are much neater this time around.
The main thing I noticed is that the deferred freeing mechanism ifo rbulk reaping will add up to 128 XEFIs to the transaction. That could result in a single EFI with up to 128 extents in it, right?
What happens when we try to free that many extents in a single transaction loop? The extent free processing doesn't have a "have we run out of transaction reservation" check in it like the refcount item processing does, so I don't think it can roll to renew the transaction reservation if it is needed. DO we need to catch this and renew the reservation by returning -EAGAIN from xfs_extent_free_finish_item() if there isn't enough of a reservation remaining to free an extent?
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCHSET v26.0 0/9] xfs: fix online repair block reaping
Quoted 39 lines · Dave Chinner
Quoted 38 lines · Darrick J. Wong
Hi all,
These patches fix a few problems that I noticed in the code that deals with old btree blocks after a successful repair.
First, I observed that it is possible for repair to incorrectly invalidate and delete old btree blocks if they were crosslinked. The solution here is to consult the reverse mappings for each block in the extent -- singly owned blocks are invalidated and freed, whereas for crosslinked blocks, we merely drop the incorrect reverse mapping.
A largeish change in this patchset is moving the reaping code to a separate file, because the code are mostly interrelated static functions. For now this also drops the ability to reap file blocks, which will return when we add the bmbt repair functions.
Second, we convert the reap function to use EFIs so that we can commit to freeing as many blocks in as few transactions as we dare. We would like to free as many old blocks as we can in the same transaction that commits the new structure to the ondisk filesystem to minimize the number of blocks that leak if the system crashes before the repair fully completes.
The third change made in this series is to avoid tripping buffer cache assertions if we're merely scanning the buffer cache for buffers to invalidate, and find a non-stale buffer of the wrong length. This is primarily cosmetic, but makes my life easier.
The fourth change restructures the reaping code to try to process as many blocks in one go as possible, to reduce logging traffic.
The last change switches the reaping mechanism to use per-AG bitmaps defined in a previous patchset. This should reduce type confusion when reading the source code.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
Quoted 8 lines
Quoted 2 lines
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
Overall I don't see any red flags, so from that perspective I think it's good to merge as is. THe buffer cache interactions are much neater this time around.
Reviewed-by Dave Chinner <[email protected]>
Thanks!
Quoted 3 lines
The main thing I noticed is that the deferred freeing mechanism ifo rbulk reaping will add up to 128 XEFIs to the transaction. That could result in a single EFI with up to 128 extents in it, right?
Welllp... the defer ops code only logs up to 16 extents per EFI log item due to my, er, butchering of max_items. So in the end, we log up to 8x EFI items, each of which has up to 16y EFIs...
Quoted 8 lines
What happens when we try to free that many extents in a single transaction loop? The extent free processing doesn't have a "have we run out of transaction reservation" check in it like the refcount item processing does, so I don't think it can roll to renew the transaction reservation if it is needed. DO we need to catch this and renew the reservation by returning
-EAGAINfromxfs_extent_free_finish_item()if there isn't enough of a reservation remaining to free an extent?
...and by my estimation, those eight items consume a fraction of the reservation available with tr_itruncate:
16 x xfs_extent_64_t = 256 bytes
1 x xfs_efi_log_format = 8 bytes
= 272 bytes per EFI
8 x EFI = 2176 bytes
So far, I haven't seen any overflows with the reaping code -- for the AG btree rebuilders, we end up logging and relogging the same bnobt/cntbt buffers over and over again. tr_itruncate gives us ~320K per transaction, and I haven't seen any overflows yet.
This might actually become more of a problem if we want to reap an inode-rooted btree, each block is in a different AG, and there are (say) more than 128 AGs... but I think the solution to that will be to xrep_defer_finish between AGs.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCHSET v26.0 0/9] xfs: fix online repair block reaping
Quoted 68 lines · Darrick J. Wong
Quoted 39 lines · Dave Chinner
Quoted 38 lines · Darrick J. Wong
Hi all,
These patches fix a few problems that I noticed in the code that deals with old btree blocks after a successful repair.
First, I observed that it is possible for repair to incorrectly invalidate and delete old btree blocks if they were crosslinked. The solution here is to consult the reverse mappings for each block in the extent -- singly owned blocks are invalidated and freed, whereas for crosslinked blocks, we merely drop the incorrect reverse mapping.
A largeish change in this patchset is moving the reaping code to a separate file, because the code are mostly interrelated static functions. For now this also drops the ability to reap file blocks, which will return when we add the bmbt repair functions.
Second, we convert the reap function to use EFIs so that we can commit to freeing as many blocks in as few transactions as we dare. We would like to free as many old blocks as we can in the same transaction that commits the new structure to the ondisk filesystem to minimize the number of blocks that leak if the system crashes before the repair fully completes.
The third change made in this series is to avoid tripping buffer cache assertions if we're merely scanning the buffer cache for buffers to invalidate, and find a non-stale buffer of the wrong length. This is primarily cosmetic, but makes my life easier.
The fourth change restructures the reaping code to try to process as many blocks in one go as possible, to reduce logging traffic.
The last change switches the reaping mechanism to use per-AG bitmaps defined in a previous patchset. This should reduce type confusion when reading the source code.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
Quoted 8 lines
Quoted 2 lines
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
Overall I don't see any red flags, so from that perspective I think it's good to merge as is. THe buffer cache interactions are much neater this time around.
Reviewed-by Dave Chinner <[email protected]>Thanks!
Quoted 3 lines
The main thing I noticed is that the deferred freeing mechanism ifo rbulk reaping will add up to 128 XEFIs to the transaction. That could result in a single EFI with up to 128 extents in it, right?
Welllp... the defer ops code only logs up to 16 extents per EFI log item due to my, er, butchering of
max_items. So in the end, we log up to 8x EFI items, each of which has up to 16y EFIs...Quoted 8 lines
What happens when we try to free that many extents in a single transaction loop? The extent free processing doesn't have a "have we run out of transaction reservation" check in it like the refcount item processing does, so I don't think it can roll to renew the transaction reservation if it is needed. DO we need to catch this and renew the reservation by returning
-EAGAINfromxfs_extent_free_finish_item()if there isn't enough of a reservation remaining to free an extent?
Quoted 8 lines
...and by my estimation, those eight items consume a fraction of the reservation available with
tr_itruncate:16 x
xfs_extent_64_t= 256 bytes
1 xxfs_efi_log_format= 8 bytes
= 272 bytes per EFI8 x EFI = 2176 bytes
I'm not worried by the EFIs themselves when they are created and committed, it's the processing of the XEFIs which are all done in a single transaction unless a ->finish_item() call returns -EAGAIN. i.e. it's the xfs_trans_free_extent() calls that are done one after another, and potential log different AG metadata blocks on each extent free operation....
And it's not just runtime we have to worry about - if we crash and have to recover on of these EFIs with 16 extents in it, we have the problem of processing a 16 extent EFI on a single transaction reservation, right?
Quoted 4 lines
So far, I haven't seen any overflows with the reaping code -- for the AG btree rebuilders, we end up logging and relogging the same bnobt/cntbt buffers over and over again.
tr_itruncategives us ~320K per transaction, and I haven't seen any overflows yet.
I suspect it might be different with aged filesystems where the extents being freed could be spread across many, many btree leaf nodes...
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCHSET v26.0 0/9] xfs: fix online repair block reaping
Quoted 76 lines · Dave Chinner
Quoted 75 lines · Darrick J. Wong
Quoted 39 lines · Dave Chinner
Quoted 38 lines · Darrick J. Wong
Hi all,
These patches fix a few problems that I noticed in the code that deals with old btree blocks after a successful repair.
First, I observed that it is possible for repair to incorrectly invalidate and delete old btree blocks if they were crosslinked. The solution here is to consult the reverse mappings for each block in the extent -- singly owned blocks are invalidated and freed, whereas for crosslinked blocks, we merely drop the incorrect reverse mapping.
A largeish change in this patchset is moving the reaping code to a separate file, because the code are mostly interrelated static functions. For now this also drops the ability to reap file blocks, which will return when we add the bmbt repair functions.
Second, we convert the reap function to use EFIs so that we can commit to freeing as many blocks in as few transactions as we dare. We would like to free as many old blocks as we can in the same transaction that commits the new structure to the ondisk filesystem to minimize the number of blocks that leak if the system crashes before the repair fully completes.
The third change made in this series is to avoid tripping buffer cache assertions if we're merely scanning the buffer cache for buffers to invalidate, and find a non-stale buffer of the wrong length. This is primarily cosmetic, but makes my life easier.
The fourth change restructures the reaping code to try to process as many blocks in one go as possible, to reduce logging traffic.
The last change switches the reaping mechanism to use per-AG bitmaps defined in a previous patchset. This should reduce type confusion when reading the source code.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
Quoted 8 lines
Quoted 2 lines
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
Overall I don't see any red flags, so from that perspective I think it's good to merge as is. THe buffer cache interactions are much neater this time around.
Reviewed-by Dave Chinner <[email protected]>Thanks!
Quoted 3 lines
The main thing I noticed is that the deferred freeing mechanism ifo rbulk reaping will add up to 128 XEFIs to the transaction. That could result in a single EFI with up to 128 extents in it, right?
Welllp... the defer ops code only logs up to 16 extents per EFI log item due to my, er, butchering of
max_items. So in the end, we log up to 8x EFI items, each of which has up to 16y EFIs...Quoted 8 lines
What happens when we try to free that many extents in a single transaction loop? The extent free processing doesn't have a "have we run out of transaction reservation" check in it like the refcount item processing does, so I don't think it can roll to renew the transaction reservation if it is needed. DO we need to catch this and renew the reservation by returning
-EAGAINfromxfs_extent_free_finish_item()if there isn't enough of a reservation remaining to free an extent?...and by my estimation, those eight items consume a fraction of the reservation available with
tr_itruncate:16 x
xfs_extent_64_t= 256 bytes
1 xxfs_efi_log_format= 8 bytes
= 272 bytes per EFI
Quoted 5 lines
Quoted 1 line
8 x EFI = 2176 bytes
I'm not worried by the EFIs themselves when they are created and committed, it's the processing of the XEFIs which are all done in a single transaction unless a ->finish_item() call returns
-EAGAIN.
*OH*. You're right, we don't really have a guarantee that someone won't queue 16 extents to an EFI logitem and then ->finish_item will blow out the reservation...
Quoted 8 lines
i.e. it's the
xfs_trans_free_extent()calls that are done one after another, and potential log different AG metadata blocks on each extent free operation....And it's not just runtime we have to worry about - if we crash and have to recover on of these EFIs with 16 extents in it, we have the problem of processing a 16 extent EFI on a single transaction reservation, right?
...so to answer your question, there isn't anything in the xfs_trans_free_extent codepath that would trigger a transaction roll, nor is there anything to prevent repair from logging a huge EFI.
I also don't see anything preventing *other* parts of the filesystem from logging a huge number of deferred frees and having them end up as one big EFI. Maybe I should monitor that to see what fstests comes up with?
The only situation where a lot of extents get queued to a single EFI logitem (I think) would be the xfs_refcount code, which could end up freeing a lot of small extents while decrementing one physical extent's refcount.
Quoted 8 lines
Quoted 4 lines
So far, I haven't seen any overflows with the reaping code -- for the AG btree rebuilders, we end up logging and relogging the same bnobt/cntbt buffers over and over again.
tr_itruncategives us ~320K per transaction, and I haven't seen any overflows yet.I suspect it might be different with aged filesystems where the extents being freed could be spread across many, many btree leaf nodes...
Hmm. I already think the refcount overhead calculation thing is sort of handwavy -- the estimates are (hopefully) deliberately overlarge to avoid triggering a shutdown. Last time I checked, there wasn't a good way to figure out how much of a transaction's reservation has actually been used, since we don't really know that until log item formatting time, right?
I wonder if we'd be better off lowering XFS_EFI_MAX_FAST_EXTENTS...?
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: prepare repair for bulk loading
In reply to Darrick J. WongHi all,
Before we start merging the online repair functions, let's improve the bulk loading code a bit. First, we need to fix a misinteraction between the AIL and the btree bulkloader wherein the delwri at the end of the bulk load fails to queue a buffer for writeback if it happens to be on the AIL list.
Second, we introduce EFIs in the btree bulkloader block allocator to to guarantee that staging blocks are freed if the filesystem goes down before committing the new btree.
Third, we change the bulkloader itself to copy multiple records into a block if possible, and add some debugging knobs so that developers can control the slack factors, just like they can do for xfs_repair.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-prep-for-bulk-loading
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-prep-for-bulk-loading
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree.c | 2 fs/xfs/libxfs/xfs_btree.h | 3 fs/xfs/libxfs/xfs_btree_staging.c | 67 +++- fs/xfs/libxfs/xfs_btree_staging.h | 32 +- fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 629 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 66 ++++ fs/xfs/scrub/repair.c | 10 + fs/xfs/scrub/repair.h | 1 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 ++ fs/xfs/xfs_buf.c | 47 +++ fs/xfs/xfs_buf.h | 1 fs/xfs/xfs_globals.c | 12 + fs/xfs/xfs_sysctl.h | 2 fs/xfs/xfs_sysfs.c | 54 +++ 18 files changed, 931 insertions(+), 37 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
PATCH 1/6 xfs: force all buffers to be written during btree bulk load
From: Darrick J. Wong <[email protected]>
While stress-testing online repair of btrees, I noticed periodic assertion failures from the buffer cache about buffer readers encountering buffers with DELWRI_Q set, even though the btree bulk load had already committed and the buffer itself wasn't on any delwri list.
I traced this to a misunderstanding of how the delwri lists work, particularly with regards to the AIL's buffer list. If a buffer is logged and committed, the buffer can end up on that AIL buffer list. If btree repairs are run twice in rapid succession, it's possible that the first repair will invalidate the buffer and free it before the next time the AIL wakes up. This clears DELWRI_Q from the buffer state.
If the second repair allocates the same block, it will then recycle the buffer to start writing the new btree block. Meanwhile, if the AIL wakes up and walks the buffer list, it will ignore the buffer because it can't lock it, and go back to sleep.
When the second repair calls delwri_queue to put the buffer on the list of buffers to write before committing the new btree, it will set DELWRI_Q again, but since the buffer hasn't been removed from the AIL's buffer list, it won't add it to the bulkload buffer's list.
This is incorrect, because the bulkload caller relies on delwri_submit to ensure that all the buffers have been sent to disk /before/ committing the new btree root pointer. This ordering requirement is required for data consistency.
Worse, the AIL won't clear DELWRI_Q from the buffer when it does finally drop it, so the next thread to walk through the btree will trip over a debug assertion on that flag.
To fix this, create a new function that waits for the buffer to be removed from any other delwri lists before adding the buffer to the caller's delwri list. By waiting for the buffer to clear both the delwri list and any potential delwri wait list, we can be sure that repair will initiate writes of all buffers and report all write errors back to userspace instead of committing the new structure.
--- fs/xfs/libxfs/xfs_btree_staging.c | 4 +-- fs/xfs/xfs_buf.c | 47 ++++++++++++++++++++++++++++++++++--- fs/xfs/xfs_buf.h | 1 + 3 files changed, 45 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_btree_staging.c +1 -3
@@ -342,9 +342,7 @@ xfs_btree_bload_drop_buf(if (*bpp ==NULL )return ; -if (!xfs_buf_delwri_queue (*bpp, buffers_list)) -ASSERT (0 ); - +xfs_buf_delwri_queue_here (*bpp, buffers_list);xfs_buf_relse (*bpp); *bpp =NULL ; }
fs/xfs/xfs_buf.c +43 -4
83 lines not on this page · raw message
fs/xfs/xfs_buf.h +1 -0
@@ -318,6 +318,7 @@ extern void xfs_buf_stale(struct xfs_buf *bp);/* Delayed Write Buffer Routines */ extern void xfs_buf_delwri_cancel (struct list_head *);extern bool xfs_buf_delwri_queue (struct xfs_buf *,struct list_head *); +void xfs_buf_delwri_queue_here (struct xfs_buf *bp,struct list_head *bl);extern int xfs_buf_delwri_submit (struct list_head *);extern int xfs_buf_delwri_submit_nowait (struct list_head *);extern int xfs_buf_delwri_pushbuf (struct xfs_buf *,struct list_head *);
PATCH 2/6 xfs: implement block reservation accounting for btrees we're staging
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new xrep_newbt structure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree_staging.h | 7 - fs/xfs/scrub/agheader_repair.c | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/newbt.c | 477 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 62 +++++ fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 37 +++ 8 files changed, 583 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/scrub/newbt.c create mode 100644 fs/xfs/scrub/newbt.h
fs/xfs/Makefile +1 -0
@@ -173,6 +173,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ + newbt.o \ reap.o \ repair.o \ )
fs/xfs/libxfs/xfs_btree_staging.h +2 -5
@@ -38,11 +38,8 @@ struct xbtree_ifakeroot {/* Number of bytes available for this fork in the inode. */ unsigned int if_fork_size; -/* Fork format. */ -unsigned int if_format; - -/* Number of records. */ -unsigned int if_extents; +/* Which fork is this btree being built for? */ +int if_whichfork; };/* Cursor interactions with fake roots for inode-rooted btrees. */
fs/xfs/scrub/agheader_repair.c +1 -0
@@ -10,6 +10,7 @@#include "xfs_trans_resv.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_log_format.h" #include "xfs_trans.h" #include "xfs_sb.h"
fs/xfs/scrub/common.c +1 -0
@@ -10,6 +10,7 @@#include "xfs_trans_resv.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_log_format.h" #include "xfs_trans.h" #include "xfs_inode.h"
fs/xfs/scrub/newbt.c new file +477 -0
477 lines not on this page · raw message
fs/xfs/scrub/newbt.h new file +62 -0
62 lines not on this page · raw message
fs/xfs/scrub/scrub.c +2 -0
@@ -17,6 +17,8 @@#include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_scrub.h" +#include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
fs/xfs/scrub/trace.h +37 -0
@@ -988,6 +988,43 @@ TRACE_EVENT(xrep_ialloc_insert, __entry->freemask) ) +DECLARE_EVENT_CLASS (xrep_newbt_extent_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + xfs_agblock_t agbno, xfs_extlen_t len, + int64_t owner), +TP_ARGS (mp, agno, agbno, len, owner), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(xfs_extlen_t, len) +__field (int64_t, owner) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->agbno = agbno; + __entry->len = len; + __entry->owner = owner; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->agbno, + __entry->len, + __entry->owner) +); +#define DEFINE_NEWBT_EXTENT_EVENT (name) \ +DEFINE_EVENT(xrep_newbt_extent_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + xfs_agblock_t agbno, xfs_extlen_t len, \ + int64_t owner), \ + TP_ARGS(mp, agno, agbno, len, owner)) +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_alloc_ag_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_alloc_file_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_free_blocks); +DEFINE_NEWBT_EXTENT_EVENT (xrep_newbt_claim_block); +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ #endif /* _TRACE_XFS_SCRUB_TRACE_H */
Re: [PATCH 2/6] xfs: implement block reservation accounting for btrees we're staging
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xrep_newbtstructure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.Signed-off-by Darrick J. Wong <[email protected]>
.....
Quoted 23 lines
fs/xfs/scrub/newbt.c new file +23
-0+/* Allocate disk space for our new file-based btree. */ +STATIC int +xrep_newbt_alloc_file_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +int error =0 ; + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = sc->mp, + .oinfo = xnr->oinfo, + .minlen =1 , + .maxlen = nr_blocks, + .prod =1 , + .resv = xnr->resv, + }; +struct xfs_perag *pag; + +xrep_newbt_validate_file_alloc_hint (xnr); +
fs/xfs/scrub/newbt.c line 264
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+ error =xfs_alloc_vextent_start_ag (&args, xnr->alloc_hint); +if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ; + +trace_xrep_newbt_alloc_file_blocks (sc->mp, args.agno, + args.agbno, args.len, xnr->oinfo.oi_owner); + + pag =xfs_perag_get (sc->mp, args.agno);
I don't think we should allow callers to trust args.agno and args.agbno after the allocation has completed. The result of the allocation is returned in args.fsbno, and there is no guarantee that args.agno and args.agbno will be valid at the completion of the allocation.
i.e. we set args.agno and args.agbno internally based on the target that is passed to xfs_alloc_vextent_start_ag(), and they change internally depending on the iterations being done during allocation. IOWs, those two fields are internal allocation state and not actually return values that the caller can rely on.
Hence I think this needs to do:
agno = XFS_FSB_TO_AGNO(mp, args.fsbno); agbno = XFS_FSB_TO_AGBNO(mp, args.fsbno);
before using those values.
fs/xfs/scrub/newbt.c line 302
Quoted 7 lines
fs/xfs/scrub/newbt.c new file +7
-0+ +/* +* How many extent freeing items can we attach to a transaction before we want +* to finish the chain so that unreserving new btree blocks doesn't overrun +* the transaction reservation? +*/ +#define XREP_REAP_MAX_NEWBT_EFIS (128)
Should there be a common define for this for repair operations?
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 2/6] xfs: implement block reservation accounting for btrees we're staging
Quoted 55 lines · Dave Chinner
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xrep_newbtstructure to encapsulate a fake root for creating a staged btree cursor as well as to track all the blocks that we need to reserve in order to build that btree.Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 23 lines
fs/xfs/scrub/newbt.c new file +23
-0+/* Allocate disk space for our new file-based btree. */ +STATIC int +xrep_newbt_alloc_file_blocks ( +struct xrep_newbt *xnr, +uint64_t nr_blocks) +{ +struct xfs_scrub *sc = xnr->sc; +int error =0 ; + +while (nr_blocks >0 ) { +struct xfs_alloc_arg args = { + .tp = sc->tp, + .mp = sc->mp, + .oinfo = xnr->oinfo, + .minlen =1 , + .maxlen = nr_blocks, + .prod =1 , + .resv = xnr->resv, + }; +struct xfs_perag *pag; + +xrep_newbt_validate_file_alloc_hint (xnr); +fs/xfs/scrub/newbt.c line 264
Quoted 10 lines
fs/xfs/scrub/newbt.c new file +10
-0+ error =xfs_alloc_vextent_start_ag (&args, xnr->alloc_hint); +if (error) +return error; +if (args.fsbno ==NULLFSBLOCK ) +return -ENOSPC ; + +trace_xrep_newbt_alloc_file_blocks (sc->mp, args.agno, + args.agbno, args.len, xnr->oinfo.oi_owner); + + pag =xfs_perag_get (sc->mp, args.agno);I don't think we should allow callers to trust args.agno and args.agbno after the allocation has completed. The result of the allocation is returned in args.fsbno, and there is no guarantee that args.agno and args.agbno will be valid at the completion of the allocation.
i.e. we set args.agno and args.agbno internally based on the target that is passed to
xfs_alloc_vextent_start_ag(), and they change internally depending on the iterations being done during allocation. IOWs, those two fields are internal allocation state and not actually return values that the caller can rely on.
Quoted 6 lines
Hence I think this needs to do:
agno = XFS_FSB_TO_AGNO(mp, args.fsbno); agbno = XFS_FSB_TO_AGBNO(mp, args.fsbno);before using those values.
Ok, fixed. At some point we ought to double-underscore all the private(ish) fields in xfs_alloc_args. I'll also fix xrep_newbt_alloc_ag_blocks.
Quoted 9 lines
fs/xfs/scrub/newbt.c line 302
Quoted 7 lines
fs/xfs/scrub/newbt.c new file +7
-0+ +/* +* How many extent freeing items can we attach to a transaction before we want +* to finish the chain so that unreserving new btree blocks doesn't overrun +* the transaction reservation? +*/ +#define XREP_REAP_MAX_NEWBT_EFIS (128)Should there be a common define for this for repair operations?
I had left them separate, but I don't think there's much of a point anymore, since the newbt(ree) and reaping code both use tr_itruncate.
/*
* This is the maximum number of deferred extent freeing item extents
* (EFIs) that we'll attach to a transaction without rolling the
* transaction to avoid overrunning a tr_itruncate reservation. */
#define XREP_MAX_ITRUNCATE_EFIS (128)
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 3/6 xfs: log EFIs for all btree blocks being used to stage a btree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
--- fs/xfs/scrub/newbt.c | 147 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.h | 4 + fs/xfs/scrub/repair.c | 10 +++ fs/xfs/scrub/repair.h | 1 4 files changed, 162 insertions(+)
fs/xfs/scrub/newbt.c +147 -0
@@ -13,12 +13,14 @@#include "xfs_btree_staging.h" #include "xfs_log_format.h" #include "xfs_trans.h" +#include "xfs_log.h" #include "xfs_sb.h" #include "xfs_inode.h" #include "xfs_alloc.h" #include "xfs_rmap.h" #include "xfs_ag.h" #include "xfs_defer.h" +#include "xfs_extfree_item.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -124,6 +126,139 @@ xrep_newbt_init_bare( XFS_AG_RESV_NONE); } +/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK ) + efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false); +ASSERT (lip !=NULL && !IS_ERR (lip)); + + resv->efi = lip; +return 0 ; +} + +/* +* Earlier, we logged EFIs for the extents that we allocated to hold the new +* btree so that we could automatically roll back those allocations if the +* system crashed. Now we log an EFD to cancel the EFI, either because the +* repair succeeded and the new blocks are in use; or because the repair was +* cancelled and we're about to free the extents directly. +*/ +static inline void +xrep_newbt_finish_autoreap ( +struct xfs_scrub *sc, +struct xrep_newbt_resv *resv) +{ +struct xfs_efd_log_item *efdp; +struct xfs_extent *extp; +struct xfs_log_item *efd_lip; + + efd_lip = xfs_extent_free_defer_type.create_done (sc->tp, resv->efi,1 ); + efdp = container_of(efd_lip, struct xfs_efd_log_item, efd_item); + extp = efdp->efd_format.efd_extents; + extp->ext_start =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); + extp->ext_len = resv->len; + efdp->efd_next_extent++; +set_bit (XFS_LI_DIRTY , &efd_lip->li_flags); +xfs_perag_intent_rele (resv->pag); +} + +/* Abort an EFI logged for a new btree block reservation. */ +static inline void +xrep_newbt_cancel_autoreap ( +struct xrep_newbt_resv *resv) +{ + xfs_extent_free_defer_type.abort_intent (resv->efi); +xfs_perag_intent_rele (resv->pag); +} + +/* +* Relog the EFIs attached to a staging btree so that we don't pin the log +* tail. Same logic as xfs_defer_relog. +*/ +int +xrep_newbt_relog_autoreap ( +struct xrep_newbt *xnr) +{ +struct xrep_newbt_resv *resv; +unsigned int efi_bytes =0 ; + +list_for_each_entry (resv, &xnr->resv_list, list) { +/* +* If the log intent item for this deferred op is in a +* different checkpoint, relog it to keep the log tail moving +* forward. We're ok with this being racy because an incorrect +* decision means we'll be a little slower at pushing the tail. +*/ +if (!resv->efi ||xfs_log_item_in_current_chkpt (resv->efi)) +continue ; + + resv->efi =xfs_trans_item_relog (resv->efi, xnr->sc->tp); + +/* +* If free space is very fragmented, it's possible that the new +* btree will be allocated a large number of small extents. +* On an active system, it's possible that so many of those +* EFIs will need relogging here that doing them all in one +* transaction will overflow the reservation. +* +* Each allocation for the new btree (xrep_newbt_resv) points +* to a unique single-mapping EFI, so each relog operation logs +* a single-mapping EFD followed by a new EFI. Each single +* mapping EF[ID] item consumes about 128 bytes, so we'll +* assume 256 bytes per relog. Roll if we consume more than +* half of the transaction reservation. +*/ + efi_bytes +=256 ; +if (efi_bytes > xnr->sc->tp->t_log_res /2 ) { +int error; + + error =xrep_roll_trans (xnr->sc); +if (error) +return error; + + efi_bytes =0 ; + } + } + +if (xnr->sc->tp->t_flags &XFS_TRANS_DIRTY ) +return xrep_roll_trans (xnr->sc); +return 0 ; +} +/* * Designate specific blocks to be used to build our new btree. @pag must be * a passive reference.
@@ -136,6 +271,7 @@ xrep_newbt_add_blocks( xfs_extlen_t len) {struct xrep_newbt_resv *resv; +int error; resv =kmalloc (sizeof (struct xrep_newbt_resv ),XCHK_GFP_FLAGS );if (!resv)
@@ -147,8 +283,16 @@ xrep_newbt_add_blocks( resv->used =0 ; resv->pag =xfs_perag_hold (pag); + error =xrep_newbt_schedule_autoreap (xnr, resv); +if (error) + goto out_pag; +list_add_tail (&resv->list, &xnr->resv_list);return 0 ; +out_pag: +xfs_perag_put (resv->pag); +kfree (resv); +return error; }/* Don't let our allocation hint take us beyond this AG */
@@ -326,6 +470,8 @@ xrep_newbt_free_extent( free_aglen -= resv->used; } +xrep_newbt_finish_autoreap (sc, resv); +if (free_aglen ==0 )return 0 ;
@@ -396,6 +542,7 @@ xrep_newbt_free(* reservations. */ list_for_each_entry_safe (resv, n, &xnr->resv_list, list) { +xrep_newbt_cancel_autoreap (resv);list_del (&resv->list);xfs_perag_put (resv->pag);kfree (resv);
fs/xfs/scrub/newbt.h +4 -0
@@ -12,6 +12,9 @@ struct xrep_newbt_resv {struct xfs_perag *pag; +/* EFI tracking this space reservation */ +struct xfs_log_item *efi; +/* AG block of the extent we reserved. */ xfs_agblock_t agbno;
@@ -58,5 +61,6 @@ void xrep_newbt_cancel(struct xrep_newbt *xnr);int xrep_newbt_commit (struct xrep_newbt *xnr);int xrep_newbt_claim_block (struct xfs_btree_cur *cur,struct xrep_newbt *xnr,union xfs_btree_ptr *ptr); +int xrep_newbt_relog_autoreap (struct xrep_newbt *xnr);#endif /* __XFS_SCRUB_NEWBT_H__ */
fs/xfs/scrub/repair.c +10 -0
@@ -167,6 +167,16 @@ xrep_roll_ag_trans(return 0 ; } +/* Roll the scrub transaction, holding the primary metadata locked. */ +int +xrep_roll_trans ( +struct xfs_scrub *sc) +{ +if (!sc->ip) +return xrep_roll_ag_trans (sc); +return xfs_trans_roll_inode (&sc->tp, sc->ip); +} +/* Finish all deferred work attached to the repair transaction. */ int xrep_defer_finish(
fs/xfs/scrub/repair.h +1 -0
@@ -20,6 +20,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)int xrep_attempt (struct xfs_scrub *sc);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc); +int xrep_roll_trans (struct xfs_scrub *sc);int xrep_defer_finish (struct xfs_scrub *sc);bool xrep_ag_has_space (struct xfs_perag *pag,xfs_extlen_t nr_blocks,enum xfs_ag_resv_type type);
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>
.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )
fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);
Hmmmm.
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 51 lines · Dave Chinner
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);Hmmmm.
Quoted 3 lines
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Yeah, I don't quite like manually tromping through the defer ops state machine here either. Everywhere /else/ in XFS logs an EFI and finishes it to free the space. Just to make sure we're on the same page, newbt will allocate space, log an EFI, and then:
1. Use the space and log an EFD for the space to cancel the EFI
2. Use some of the space, log an EFD for the space we used, immediately log a new EFI for the unused parts, and finish the new EFI manually
3. Don't use any of the space at all, and finish the EFI manually
Initially, I tried using the regular defer ops mechanism, but this got messy on account of having to extern most of xfs_defer.c so that I could manually modify the defer ops state. It's hard to generalize this, since there's only *one* place that actually needs manual flow control.
ISTR that was around the time bfoster and I were reworking log intent item recovery, and it was easier to do this outside of the defer ops code than try to refactor it and keep this exceptional piece working too.
Quoted 2 lines
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
That's the final form of it. The good news is that it's been stable enough despite me tearing into the EFI code again in the rt modernization patchset. Do you have any further suggestions?
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 66 lines · Darrick J. Wong
Quoted 51 lines · Dave Chinner
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);Hmmmm.
Quoted 3 lines
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Yeah, I don't quite like manually tromping through the defer ops state machine here either. Everywhere /else/ in XFS logs an EFI and finishes it to free the space. Just to make sure we're on the same page, newbt will allocate space, log an EFI, and then:
1. Use the space and log an EFD for the space to cancel the EFI
2. Use some of the space, log an EFD for the space we used, immediately log a new EFI for the unused parts, and finish the new EFI manually
3. Don't use any of the space at all, and finish the EFI manually
Quoted 4 lines
Initially, I tried using the regular defer ops mechanism, but this got messy on account of having to extern most of
xfs_defer.cso that I could manually modify the defer ops state. It's hard to generalize this, since there's only *one* place that actually needs manual flow control.
*nod*
But I can't help but think it's a manifestation of a generic optimisation that could allow us to avoid needing to use unwritten extents for new data alloations...
Quoted 11 lines
ISTR that was around the time bfoster and I were reworking log intent item recovery, and it was easier to do this outside of the defer ops code than try to refactor it and keep this exceptional piece working too.
Quoted 2 lines
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
That's the final form of it. The good news is that it's been stable enough despite me tearing into the EFI code again in the rt modernization patchset. Do you have any further suggestions?
Not for the patchset as it stands.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 72 lines · Dave Chinner
Quoted 66 lines · Darrick J. Wong
Quoted 51 lines · Dave Chinner
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);Hmmmm.
Quoted 3 lines
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Yeah, I don't quite like manually tromping through the defer ops state machine here either. Everywhere /else/ in XFS logs an EFI and finishes it to free the space. Just to make sure we're on the same page, newbt will allocate space, log an EFI, and then:
1. Use the space and log an EFD for the space to cancel the EFI
2. Use some of the space, log an EFD for the space we used, immediately log a new EFI for the unused parts, and finish the new EFI manually
3. Don't use any of the space at all, and finish the EFI manuallyQuoted 4 lines
Initially, I tried using the regular defer ops mechanism, but this got messy on account of having to extern most of
xfs_defer.cso that I could manually modify the defer ops state. It's hard to generalize this, since there's only *one* place that actually needs manual flow control.
Quoted 5 lines
*nod*
But I can't help but think it's a manifestation of a generic optimisation that could allow us to avoid needing to use unwritten extents for new data alloations...
I've thought about this usecase at various points in the lifetime of the newbt.c code. The usecases are indeed very similar -- speculatively allocate some disk blocks, write to them, and either map them into the data fork / btree root if the writes actually succeed; or free them because it failed.
However, I think we could eliminate the overhead of the speculative allocation out of the bnobt/cnbt (aka step 1) by boosting all of the tracking to the incore data structures. Handwaving sketch:
1. Find the extent we want from the free space btrees, and add a record to the busy extent list with some new state flag that signals "speculative write: do not DISCARD this extent, and allocating callers should move on".
(Not sure what happens if the allocating caller /never/ finds space? Does kicking writeback make sense here? I am not sure it does.)
2. Create a mapping in the cow fork for the speculatively allocated space, along with an annotation to that effect. Also need to absorb whatever space we reserved in the delalloc mapping for bmbt expansion.
3. Write the blocks.
4. If the write succeeds, we do the cow remap like we do now, but also remove the extent from the ondisk free space btrees and clear the space from the busy extent list.
5. If the write fails, clear the space from busy extent list. Maybe add the space to a badblocks list(??)
Under this scheme, the only ondisk metadata update is step 4. I really like the idea of porting newbt.c to use a mechanism like this, since the only time we touch the log is if the repair succeeds.
Too bad it doesn't exist yet! :)
For now, the oddball use of EFIs is limited to newbt.c, which means it's self-contained inside repair. Except for the "too many extents attached to an EFI" issue, I think it works well enough to put into use until you or I have time to figure out how to turn either of our "unwritten extent for new data allocation" sketches into reality.
(IOWs, I'm trying /not/ to go carving around in the allocator and the extent busy list when there's already so much to think about. ;))
Quoted 5 lines
Quoted 5 lines
ISTR that was around the time bfoster and I were reworking log intent item recovery, and it was easier to do this outside of the defer ops code than try to refactor it and keep this exceptional piece working too.
Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
That's the final form of it. The good news is that it's been stable enough despite me tearing into the EFI code again in the rt modernization patchset. Do you have any further suggestions?
Not for the patchset as it stands.
<nod> I'll add some monitoring to report the maximum extent counts that get added to EFIs, and work on something to constrain the number of extents that get added to a single EFI log item that's coming from repair.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
Quoted 137 lines · Darrick J. Wong
Quoted 72 lines · Dave Chinner
Quoted 66 lines · Darrick J. Wong
Quoted 51 lines · Dave Chinner
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);Hmmmm.
Quoted 3 lines
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Yeah, I don't quite like manually tromping through the defer ops state machine here either. Everywhere /else/ in XFS logs an EFI and finishes it to free the space. Just to make sure we're on the same page, newbt will allocate space, log an EFI, and then:
1. Use the space and log an EFD for the space to cancel the EFI
2. Use some of the space, log an EFD for the space we used, immediately log a new EFI for the unused parts, and finish the new EFI manually
3. Don't use any of the space at all, and finish the EFI manuallyQuoted 4 lines
Initially, I tried using the regular defer ops mechanism, but this got messy on account of having to extern most of
xfs_defer.cso that I could manually modify the defer ops state. It's hard to generalize this, since there's only *one* place that actually needs manual flow control.Quoted 5 lines
*nod*
But I can't help but think it's a manifestation of a generic optimisation that could allow us to avoid needing to use unwritten extents for new data alloations...
I've thought about this usecase at various points in the lifetime of the
newbt.ccode. The usecases are indeed very similar -- speculatively allocate some disk blocks, write to them, and either map them into the data fork / btree root if the writes actually succeed; or free them because it failed.However, I think we could eliminate the overhead of the speculative allocation out of the bnobt/cnbt (aka step 1) by boosting all of the tracking to the incore data structures. Handwaving sketch:
1. Find the extent we want from the free space btrees, and add a record to the busy extent list with some new state flag that signals "speculative write: do not DISCARD this extent, and allocating callers should move on".
(Not sure what happens if the allocating caller /never/ finds space? Does kicking writeback make sense here? I am not sure it does.)
2. Create a mapping in the cow fork for the speculatively allocated space, along with an annotation to that effect. Also need to absorb whatever space we reserved in the delalloc mapping for bmbt expansion.
3. Write the blocks.
4. If the write succeeds, we do the cow remap like we do now, but also remove the extent from the ondisk free space btrees and clear the space from the busy extent list.
5. If the write fails, clear the space from busy extent list. Maybe add the space to a badblocks list(??)
Under this scheme, the only ondisk metadata update is step 4. I really like the idea of porting
newbt.cto use a mechanism like this, since the only time we touch the log is if the repair succeeds.Too bad it doesn't exist yet! :)
For now, the oddball use of EFIs is limited to
newbt.c, which means it's self-contained inside repair. Except for the "too many extents attached to an EFI" issue, I think it works well enough to put into use until you or I have time to figure out how to turn either of our "unwritten extent for new data allocation" sketches into reality.(IOWs, I'm trying /not/ to go carving around in the allocator and the extent busy list when there's already so much to think about. ;))
Quoted 12 lines
Quoted 11 lines
ISTR that was around the time bfoster and I were reworking log intent item recovery, and it was easier to do this outside of the defer ops code than try to refactor it and keep this exceptional piece working too.
Quoted 2 lines
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
That's the final form of it. The good news is that it's been stable enough despite me tearing into the EFI code again in the rt modernization patchset. Do you have any further suggestions?
Quoted 6 lines
Quoted 1 line
Not for the patchset as it stands.
<nod> I'll add some monitoring to report the maximum extent counts that get added to EFIs, and work on something to constrain the number of extents that get added to a single EFI log item that's coming from repair.
My debug patch kept a per-mount maximum EFI extent count, and logged whenever an EFI got logged with a higher extent count. From last night's fstests run, I saw this:
11297 EFI MAX DEPTH bumped to 2 (RUNTIME)
8 EFI MAX DEPTH bumped to 2 (RECOVERY)
2598 EFI MAX DEPTH bumped to 3 (RUNTIME)
3 EFI MAX DEPTH bumped to 3 (RECOVERY)
216 EFI MAX DEPTH bumped to 4 (RUNTIME)
100 EFI MAX DEPTH bumped to 5 (RUNTIME)
862 EFI MAX DEPTH bumped to 6 (RUNTIME)
39 EFI MAX DEPTH bumped to 7 (RUNTIME)
22 EFI MAX DEPTH bumped to 8 (RUNTIME)
40 EFI MAX DEPTH bumped to 9 (RUNTIME)
26 EFI MAX DEPTH bumped to 10 (RUNTIME)
17 EFI MAX DEPTH bumped to 11 (RUNTIME)
14 EFI MAX DEPTH bumped to 12 (RUNTIME)
42 EFI MAX DEPTH bumped to 13 (RUNTIME)
5 EFI MAX DEPTH bumped to 14 (RUNTIME)
5 EFI MAX DEPTH bumped to 15 (RUNTIME)
509 EFI MAX DEPTH bumped to 16 (RUNTIME)
So I guess we /do/ see a healthy(?) number of EFIs with more than 4 extents attached, and more bumps to 16 than I expected. Granted there's a lot of mkfs action in fstests, so this still isn't capturing what might happen if there was fragmentation ahoy.
Well ok the alwayscow=1 profile did this:
170 EFI MAX DEPTH bumped to 2 (RUNTIME)
133 EFI MAX DEPTH bumped to 3 (RUNTIME)
24 EFI MAX DEPTH bumped to 4 (RUNTIME)
9 EFI MAX DEPTH bumped to 5 (RUNTIME)
29 EFI MAX DEPTH bumped to 6 (RUNTIME)
1 EFI MAX DEPTH bumped to 7 (RUNTIME)
2 EFI MAX DEPTH bumped to 9 (RUNTIME)
1 EFI MAX DEPTH bumped to 10 (RUNTIME)
1 EFI MAX DEPTH bumped to 11 (RUNTIME)
1 EFI MAX DEPTH bumped to 12 (RUNTIME)
1 EFI MAX DEPTH bumped to 16 (RUNTIME)
--D
Quoted 6 lines
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: log EFIs for all btree blocks being used to stage a btree
In reply to Dave ChinnerQuoted 51 lines · Dave Chinner
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
We need to log EFIs for every extent that we allocate for the purpose of staging a new btree so that if we fail then the blocks will be freed during log recovery. Add a function to relog the EFIs, so that repair can relog them all every time it creates a new btree block, which will help us to avoid pinning the log tail.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 27 lines
fs/xfs/scrub/newbt.c +27
-0+/* +* Set up automatic reaping of the blocks reserved for btree reconstruction in +* case we crash by logging a deferred free item for each extent we allocate so +* that we can get all of the space back if we crash before we can commit the +* new btree. This function returns a token that can be used to cancel +* automatic reaping if repair is successful. +*/ +static int +xrep_newbt_schedule_autoreap ( +struct xrep_newbt *xnr, +struct xrep_newbt_resv *resv) +{ +struct xfs_extent_free_item efi_item = { + .xefi_blockcount = resv->len, + .xefi_owner = xnr->oinfo.oi_owner, + .xefi_flags =XFS_EFI_SKIP_DISCARD , + .xefi_pag = resv->pag, + }; +struct xfs_scrub *sc = xnr->sc; +struct xfs_log_item *lip; +LIST_HEAD (items); + +ASSERT (xnr->oinfo.oi_offset ==0 ); + + efi_item.xefi_startblock =XFS_AGB_TO_FSB (sc->mp, resv->pag->pag_agno, + resv->agbno); +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_ATTR_FORK )fs/xfs/scrub/newbt.c xrep_newbt_init_bare( · line 165
Quoted 10 lines
fs/xfs/scrub/newbt.c +10
-0+ efi_item.xefi_flags |=XFS_EFI_ATTR_FORK ; +if (xnr->oinfo.oi_flags &XFS_OWNER_INFO_BMBT_BLOCK ) + efi_item.xefi_flags |=XFS_EFI_BMBT_BLOCK ; + +INIT_LIST_HEAD (&efi_item.xefi_list); +list_add (&efi_item.xefi_list, &items); + +xfs_perag_intent_hold (resv->pag); + lip = xfs_extent_free_defer_type.create_intent (sc->tp, &items,1 , + false);Hmmmm.
Quoted 6 lines
That triggered flashing lights and sirens - I'm not sure I really like the usage of the defer type arrays like this, nor the duplication of the defer mechanisms for relogging, etc.
Not that I have a better idea right now - is this the final form of this code, or is more stuff built on top of it or around it?
Soooo. Now that another month has passed, I've had the time to think about this topic some more.
I've flat-out rejected my own suggestion to leave the ondisk bnobt unchanged and stash the reservations in the extent busy tree, because the resulting IO sequence ends up being:
<read everything we need to synthesize records>
<write btree blocks to disk>
T0: commit btree root
<remove first extent we used for the btree from busy list>
T1: remove first extent from bnobt
T2: rmapbt updates for the first extent
<remove second extent we used for the btree from busy list>
T3: remove second extent from bnobt
T4: rmapbt updates for the second extent
...
Because we cannot risk having the system go down before we finish writing all these transactions. One could invent a new log intent items that capture promises to allocate blocks, but that only reduces the problem to:
T0: commit btree root
intent item for first extent
intent item for second extent
...
run out of transaction reservation
T1: more intent items
Same problem, just harder to hit. So. I'll requeue the "hide the space in the extent busy tree" for some day when writing to a hole becomes hot enough to make this important again.
---------------
However, I thought about what newbt.c really wants to do with EFIs. A transaction removes each extent from the bnobt (until we have enough blocks to write out the new btree) and logs an EFI to free that space.
If the new tree write succeeds and we reserved exactly enough blocks, then all we want to do is:
1) Log the EFDs to the same transaction where we commit the new btree root. We don't free the space.
If the new tree write succeeds and we reserved too many blocks, then we want the btree root commit transaction to:
1) same as above
2) For eextents that we only wrote partially, we want to log an EFD for the existing EFI at the same time that we log a new EFI to free whatever we didn't use.
3) For the extents that we completely didn't use, we want to log EFDs and free the space.
If the new tree write fails, then we want the last transaction in the chain to:
3) same as above
Also note that we want to relog EFIs if we need to move the log tail forward. Right now I copy and paste the xfs_defer_relog code into newbt.c, which is awful.
We could actually use the regular defer ops extent freeing mechanism for case (3) above, since that's already how xfs_extent_free_later works.
For case (1) and (2), we want a slight variation on deferred extent freeing. The EFI log item would still get created, but now we want to mark a deferred work item to be set aside when xfs_defer_finish is trying to call ->finish_item on tp->t_dfops.
When the btree write finishes, we mark the deferred extent free work item as stale and remove the mark we put on that item in the previous step. This enables the deferred extent free item to go through the usual xfs_defer_finish state machine so that an EFD gets created. The only difference is that now xfs_trans_free_extent doesn't call __xfs_free_extent.
This also means that each _claim_block function can now call xrep_defer_finish() to relog the EFIs between each btree block write.
----------------
As for the code that reaps old ondisk structures -- I created a new dfops type called "barrier" so that the reap code never writes out an EFI with more than two extents per log item.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 4/6 xfs: add debug knobs to control btree bulk load slack factors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some debug knobs so that we can control the leaf and node block slack when rebuilding btrees.
--- fs/xfs/scrub/newbt.c | 10 ++++++--- fs/xfs/xfs_globals.c | 12 +++++++++++ fs/xfs/xfs_sysctl.h | 2 ++ fs/xfs/xfs_sysfs.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 75 insertions(+), 3 deletions(-)
fs/xfs/scrub/newbt.c +7 -3
@@ -49,9 +49,13 @@ xrep_newbt_estimate_slack(uint64_t free;uint64_t sz; -/* Let the btree code compute the default slack values. */ - bload->leaf_slack =-1 ; - bload->node_slack =-1 ; +/* +* The xfs_globals values are set to -1 (i.e. take the bload defaults) +* unless someone has set them otherwise, so we just pull the values +* here. +*/ + bload->leaf_slack = xfs_globals.bload_leaf_slack; + bload->node_slack = xfs_globals.bload_node_slack;if (sc->ops->type ==ST_PERAG ) { free = sc->sa.pag->pagf_freeblks;
fs/xfs/xfs_globals.c +12 -0
@@ -44,4 +44,16 @@ struct xfs_globals xfs_globals = { .pwork_threads = -1, /* automatic thread detection */ .larp = false, /* log attribute replay */#endif + +/* +* Leave this many record slots empty when bulk loading btrees. By +* default we load new btree leaf blocks 75% full. +*/ + .bload_leaf_slack = -1, + +/* +* Leave this many key/ptr slots empty when bulk loading btrees. By +* default we load new btree node blocks 75% full. +*/ + .bload_node_slack = -1, };
fs/xfs/xfs_sysctl.h +2 -0
@@ -85,6 +85,8 @@ struct xfs_globals {int pwork_threads;/* parallel workqueue threads */ bool larp;/* log attribute replay */ #endif +int bload_leaf_slack;/* btree bulk load leaf slack */ +int bload_node_slack;/* btree bulk load node slack */ int log_recovery_delay;/* log recovery delay (secs) */ int mount_delay;/* mount setup delay (secs) */ bool bug_on_assert;/* BUG() the kernel on assert failure */
fs/xfs/xfs_sysfs.c +54 -0
66 lines not on this page · raw message
PATCH 5/6 xfs: move btree bulkload record initialization to ->get_record implementations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're performing a bulk load of a btree, move the code that actually stores the btree record in the new btree block out of the generic code and into the individual ->get_record implementations. This is preparation for being able to store multiple records with a single indirect call.
--- fs/xfs/libxfs/xfs_btree_staging.c | 17 +++++++---------- fs/xfs/libxfs/xfs_btree_staging.h | 15 ++++++++++----- 2 files changed, 17 insertions(+), 15 deletions(-)
fs/xfs/libxfs/xfs_btree_staging.c +7 -10
@@ -434,22 +434,19 @@ STATIC intxfs_btree_bload_leaf ( struct xfs_btree_cur *cur, unsigned int recs_this_block, - xfs_btree_bload_get_record_fn get_record, + xfs_btree_bload_get_records_fn get_records, struct xfs_btree_block *block, void *priv) { - unsigned int j; + unsigned int j = 1;int ret;/* Fill the leaf block with records. */ -for (j =1 ; j <= recs_this_block; j++) { -union xfs_btree_rec *block_rec; - - ret =get_record (cur, priv); -if (ret) +while (j <= recs_this_block) { + ret =get_records (cur, j, block, recs_this_block - j +1 , priv); +if (ret <0 )return ret; - block_rec =xfs_btree_rec_addr (cur, j, block); - cur->bc_ops->init_rec_from_cur (cur, block_rec); + j += ret; }return 0 ;
@@ -787,7 +784,7 @@ xfs_btree_bload(trace_xfs_btree_bload_block (cur, level, i, blocks, &ptr, nr_this_block); - ret =xfs_btree_bload_leaf (cur, nr_this_block, bbl->get_record, + ret =xfs_btree_bload_leaf (cur, nr_this_block, bbl->get_records, block, priv);if (ret) goto out;
fs/xfs/libxfs/xfs_btree_staging.h +10 -5
@@ -50,7 +50,9 @@ void xfs_btree_commit_ifakeroot(struct xfs_btree_cur *cur, struct xfs_trans *tp, int whichfork, const struct xfs_btree_ops *ops);/* Bulk loading of staged btrees. */ -typedef int (*xfs_btree_bload_get_record_fn )(struct xfs_btree_cur *cur,void *priv); +typedef int (*xfs_btree_bload_get_records_fn )(struct xfs_btree_cur *cur, +unsigned int idx,struct xfs_btree_block *block, +unsigned int nr_wanted,void *priv);typedef int (*xfs_btree_bload_claim_block_fn )(struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr,void *priv); typedef size_t (*xfs_btree_bload_iroot_size_fn)(struct xfs_btree_cur *cur,
@@ -58,11 +60,14 @@ typedef size_t (*xfs_btree_bload_iroot_size_fn)(struct xfs_btree_cur *cur,struct xfs_btree_bload {/* -* This function will be called nr_records times to load records into -* the btree. The function does this by setting the cursor's bc_rec -* field in in-core format. Records must be returned in sort order. +* This function will be called to load @nr_wanted records into the +* btree. The implementation does this by setting the cursor's bc_rec +* field in in-core format and using init_rec_from_cur to set the +* records in the btree block. Records must be returned in sort order. +* The function must return the number of records loaded or the usual +* negative errno. */ -xfs_btree_bload_get_record_fn get_record; +xfs_btree_bload_get_records_fn get_records;/* * This function will be called nr_blocks times to obtain a pointer
PATCH 6/6 xfs: constrain dirty buffers while formatting a staged btree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Constrain the number of dirty buffers that are locked by the btree staging code at any given time by establishing a threshold at which we put them all on the delwri queue and push them to disk. This limits memory consumption while writing out new btrees.
--- fs/xfs/libxfs/xfs_btree.c | 2 + fs/xfs/libxfs/xfs_btree.h | 3 ++ fs/xfs/libxfs/xfs_btree_staging.c | 50 +++++++++++++++++++++++++++++-------- fs/xfs/libxfs/xfs_btree_staging.h | 10 +++++++ fs/xfs/scrub/newbt.c | 1 + 5 files changed, 54 insertions(+), 12 deletions(-)
fs/xfs/libxfs/xfs_btree.c +1 -1
@@ -1330,7 +1330,7 @@ xfs_btree_get_buf_block(* Read in the buffer at the given ptr and return the buffer and * the block pointer within the buffer. */ -STATIC int +int xfs_btree_read_buf_block( struct xfs_btree_cur *cur, const union xfs_btree_ptr *ptr,
fs/xfs/libxfs/xfs_btree.h +3 -0
@@ -700,6 +700,9 @@ void xfs_btree_set_ptr_null(struct xfs_btree_cur *cur,int xfs_btree_get_buf_block (struct xfs_btree_cur *cur,const union xfs_btree_ptr *ptr,struct xfs_btree_block **block,struct xfs_buf **bpp); +int xfs_btree_read_buf_block (struct xfs_btree_cur *cur, +const union xfs_btree_ptr *ptr,int flags, +struct xfs_btree_block **block,struct xfs_buf **bpp);void xfs_btree_set_sibling (struct xfs_btree_cur *cur,struct xfs_btree_block *block,const union xfs_btree_ptr *ptr,int lr);
fs/xfs/libxfs/xfs_btree_staging.c +39 -11
91 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree_staging.h +10 -0
@@ -115,6 +115,16 @@ struct xfs_btree_bload {* height of the new btree. */ unsigned int btree_height; + +/* +* Flush the new btree block buffer list to disk after this many blocks +* have been formatted. Zero prohibits writing any buffers until all +* blocks have been formatted. +*/ +uint16_t max_dirty; + +/* Number of dirty buffers. */ +uint16_t nr_dirty; }; int xfs_btree_bload_compute_geometry(struct xfs_btree_cur *cur,
fs/xfs/scrub/newbt.c +1 -0
@@ -91,6 +91,7 @@ xrep_newbt_init_ag( xnr->alloc_hint = alloc_hint; xnr->resv = resv;INIT_LIST_HEAD (&xnr->resv_list); + xnr->bload.max_dirty =XFS_B_TO_FSBT (sc->mp,256U <<10 );/* 256K */ xrep_newbt_estimate_slack (xnr); }
cover xfs: stage repair information in pageable memory
In reply to Darrick J. WongHi all,
In general, online repair of an indexed record set walks the filesystem looking for records. These records are sorted and bulk-loaded into a new btree. To make this happen without pinning gigabytes of metadata in memory, first create an abstraction ('xfile') of memfd files so that kernel code can access paged memory, and then an array abstraction ('xfarray') based on xfiles so that online repair can create an array of new records without pinning memory.
These two data storage abstractions are critical for repair of space metadata -- the memory used is pageable, which helps us avoid pinning kernel memory and driving OOM problems; and they are byte-accessible enough that we can use them like (very slow and programmatic) memory buffers.
Later patchsets will build on this functionality to provide blob storage and btrees.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=big-array
--- fs/xfs/Kconfig | 1 fs/xfs/Makefile | 2 fs/xfs/scrub/trace.c | 4 fs/xfs/scrub/trace.h | 260 ++++++++++++ fs/xfs/scrub/xfarray.c | 1083 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfarray.h | 141 ++++++ fs/xfs/scrub/xfile.c | 420 +++++++++++++++++++ fs/xfs/scrub/xfile.h | 77 +++ 8 files changed, 1987 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/scrub/xfarray.c create mode 100644 fs/xfs/scrub/xfarray.h create mode 100644 fs/xfs/scrub/xfile.c create mode 100644 fs/xfs/scrub/xfile.h
PATCH 1/7 xfs: create a big array data structure
From: Darrick J. Wong <[email protected]>
Create a simple 'big array' data structure for storage of fixed-size metadata records that will be used to reconstruct a btree index. For repair operations, the most important operations are append, iterate, and sort.
Earlier implementations of the big array used linked lists and suffered from severe problems -- pinning all records in kernel memory was not a good idea and frequently lead to OOM situations; random access was very inefficient; and record overhead for the lists was unacceptably high at 40-60%.
Therefore, the big memory array relies on the 'xfile' abstraction, which creates a memfd file and stores the records in page cache pages. Since the memfd is created in tmpfs, the memory pages can be pushed out to disk if necessary and we have a built-in usage limit of 50% of physical memory.
--- fs/xfs/Kconfig | 1 fs/xfs/Makefile | 2 fs/xfs/scrub/trace.c | 4 - fs/xfs/scrub/trace.h | 121 ++++++++++++++++ fs/xfs/scrub/xfarray.c | 369 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfarray.h | 57 +++++++ fs/xfs/scrub/xfile.c | 312 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfile.h | 57 +++++++ 8 files changed, 922 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/scrub/xfarray.c create mode 100644 fs/xfs/scrub/xfarray.h create mode 100644 fs/xfs/scrub/xfile.c create mode 100644 fs/xfs/scrub/xfile.h
fs/xfs/Kconfig +1 -0
@@ -128,6 +128,7 @@ config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n depends on XFS_FS + depends on TMPFS && SHMEM select XFS_DRAIN_INTENTS help If you say Y here you will be able to check metadata on a
fs/xfs/Makefile +2 -0
@@ -164,6 +164,8 @@ xfs-y += $(addprefix scrub/, \ rmap.o \ scrub.o \ symlink.o \ + xfarray.o \ + xfile.o \ ) xfs-$(CONFIG_XFS_RT) += scrub/rtbitmap.o
fs/xfs/scrub/trace.c +3 -1
@@ -12,8 +12,10 @@#include "xfs_mount.h" #include "xfs_inode.h" #include "xfs_btree.h" -#include "scrub/scrub.h" #include "xfs_ag.h" +#include "scrub/scrub.h" +#include "scrub/xfile.h" +#include "scrub/xfarray.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
fs/xfs/scrub/trace.h +121 -0
133 lines not on this page · raw message
fs/xfs/scrub/xfarray.c new file +369 -0
369 lines not on this page · raw message
fs/xfs/scrub/xfarray.h new file +57 -0
57 lines not on this page · raw message
fs/xfs/scrub/xfile.c new file +312 -0
312 lines not on this page · raw message
fs/xfs/scrub/xfile.h new file +57 -0
57 lines not on this page · raw message
Re: [PATCH 1/7] xfs: create a big array data structure
fs/xfs/scrub/trace.h line 20
Quoted 10 lines · Darrick J. Wong
fs/xfs/scrub/trace.h +2
-0@@ -16,6 +16,9 @@#include <linux/tracepoint.h> #include "xfs_bit.h" +struct xfile ; +struct xfarray ;
You dereference both a struct xfile and a struct xfarray. Seems like you don't need these declarations?
fs/xfs/scrub/trace.h
Quoted 10 lines
fs/xfs/scrub/trace.h +10
-0+/* Compute array index given an xfile offset. */ +static xfarray_idx_t +xfarray_idx ( +struct xfarray *array, +loff_t pos) +{ +if (array->obj_size_log >=0 ) +return (xfarray_idx_t )pos >> array->obj_size_log; + +return div_u64 ((xfarray_idx_t )pos, array->obj_size);
If xfarray_idx_t is smaller than an loff_t, this will truncate pos, which isn't what you want.
fs/xfs/scrub/trace.h
Quoted 7 lines
fs/xfs/scrub/trace.h +7
-0+/* Compute xfile offset of array element. */ +static inline loff_t xfarray_pos (struct xfarray *array,xfarray_idx_t idx) +{ +if (array->obj_size_log >=0 ) +return idx << array->obj_size_log; + +return idx * array->obj_size;
Likewise, you need to promote idx to loff_t before shifting/multiplying.
Quoted 6 lines
fs/xfs/scrub/trace.h +6
-0+static inline bool +xfarray_is_unset ( +struct xfarray *array, +loff_t pos) +{ +void *temp =xfarray_scratch (array);
fs/xfs/scrub/trace.h
Quoted 10 lines
fs/xfs/scrub/trace.h +10
-0+int error; + +if (array->unset_slots ==0 ) +return false; + + error =xfile_obj_load (array->xfile, temp, array->obj_size, pos); +if (!error &&xfarray_element_is_null (array, temp)) +return true; + +return false;
Wouldn't this be clearer as:
return !error && xfarray_element_is_null(array, temp);
Quoted 17 lines
fs/xfs/scrub/trace.h +17
-0+int +xfarray_store_anywhere ( +struct xfarray *array, +const void *ptr) +{ +void *temp =xfarray_scratch (array); +loff_t endpos =xfarray_pos (array, array->nr); +loff_t pos; +int error; + +/* Find an unset slot to put it in. */ +for (pos =0 ; + pos < endpos && array->unset_slots >0 ; + pos += array->obj_size) { + error =xfile_obj_load (array->xfile, temp, array->obj_size, + pos); +if (error || !xfarray_element_is_null (array, temp))
fs/xfs/scrub/trace.h
Quoted 10 lines
fs/xfs/scrub/trace.h +10
-0+continue ; + + error =xfile_obj_store (array->xfile, ptr, array->obj_size, + pos); +if (error) +return error; + + array->unset_slots--; +return 0 ; + }
... how often is this called? This seems like it might be slow.
fs/xfs/scrub/trace.h
Quoted 11 lines
fs/xfs/scrub/trace.h +11
-0+/* +* Call SEEK_DATA on the last byte in the record we're about to read. +* If the record ends at (or crosses) the end of a page then we know +* that the first byte of the record is backed by pages and don't need +* to query it. If instead the record begins at the start of the page +* then we know that querying the last byte is just as good as querying +* the first byte, since records cannot be larger than a page. +* +* If the call returns the same file offset, we know this record is +* backed by real pages. We do not need to move the cursor. +*/
Clever.
Quoted 12 lines
fs/xfs/scrub/trace.h +12
-0+ssize_t +xfile_pread ( +struct xfile *xf, +void *buf, +size_t count, +loff_t pos) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping; +struct page *page =NULL ; +ssize_t read =0 ; +unsigned int pflags;
fs/xfs/scrub/trace.h
Quoted 10 lines
fs/xfs/scrub/trace.h +10
-0+int error =0 ; + +if (count >MAX_RW_COUNT ) +return -E2BIG ; +if (inode->i_sb->s_maxbytes - pos < count) +return -EFBIG ; + +trace_xfile_pread (xf, pos, count); + + pflags =memalloc_nofs_save ();
Should we be calling this here, or should this be done by the caller? Presumably it's the current caller that can't stand reclaim starting?
fs/xfs/scrub/trace.h
Quoted 13 lines
fs/xfs/scrub/trace.h +13
-0+while (count >0 ) { +void *p, *kaddr; +unsigned int len; + + len =min_t (ssize_t, count,PAGE_SIZE -offset_in_page (pos)); + +/* +* In-kernel reads of a shmem file cause it to allocate a page +* if the mapping shows a hole. Therefore, if we hit ENOMEM +* we can continue by zeroing the caller's buffer. +*/ + page =shmem_read_mapping_page_gfp (mapping, pos >>PAGE_SHIFT , + __GFP_NOWARN);
I'm kind of hoping to transition to shmem_read_folio_gfp(), but that doesn't have to happen before this gets merged.
fs/xfs/scrub/trace.h
Quoted 9 lines
fs/xfs/scrub/trace.h +9
-0+ssize_t +xfile_pwrite ( +struct xfile *xf, +const void *buf, +size_t count, +loff_t pos) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping;
I wonder if this shoudn't be xf->file->f_mapping?
Re: [PATCH 1/7] xfs: create a big array data structure
Quoted 9 lines · Matthew Wilcox
Quoted 8 lines · Darrick J. Wong
fs/xfs/scrub/trace.h +0
-0@@ -16,6 +16,9 @@#include <linux/tracepoint.h> #include "xfs_bit.h"
Quoted 5 lines
fs/xfs/scrub/trace.h line 20
Quoted 2 lines
fs/xfs/scrub/trace.h +2
-0+struct xfile ; +struct xfarray ;You dereference both a struct xfile and a struct xfarray. Seems like you don't need these declarations?
I suppose not.
Quoted 5 lines
Quoted 5 lines
fs/xfs/scrub/trace.h +5
-0+/* Compute array index given an xfile offset. */ +static xfarray_idx_t +xfarray_idx ( +struct xfarray *array, +loff_t pos)
Quoted 8 lines
fs/xfs/scrub/trace.h
Quoted 5 lines
fs/xfs/scrub/trace.h +5
-0+{ +if (array->obj_size_log >=0 ) +return (xfarray_idx_t )pos >> array->obj_size_log; + +return div_u64 ((xfarray_idx_t )pos, array->obj_size);If
xfarray_idx_tis smaller than anloff_t, this will truncate pos, which isn't what you want.
typedef uint64_t xfarray_idx_t;
This won't be smaller than loff_t until you port Linux to 128-bit integers in 2028.
Quoted 29 lines
fs/xfs/scrub/trace.h
Quoted 7 lines
fs/xfs/scrub/trace.h +7
-0+/* Compute xfile offset of array element. */ +static inline loff_t xfarray_pos (struct xfarray *array,xfarray_idx_t idx) +{ +if (array->obj_size_log >=0 ) +return idx << array->obj_size_log; + +return idx * array->obj_size;Likewise, you need to promote idx to
loff_tbefore shifting/multiplying.Quoted 6 lines
fs/xfs/scrub/trace.h +6
-0+static inline bool +xfarray_is_unset ( +struct xfarray *array, +loff_t pos) +{ +void *temp =xfarray_scratch (array);fs/xfs/scrub/trace.h
Quoted 10 lines
fs/xfs/scrub/trace.h +10
-0+int error; + +if (array->unset_slots ==0 ) +return false; + + error =xfile_obj_load (array->xfile, temp, array->obj_size, pos); +if (!error &&xfarray_element_is_null (array, temp)) +return true; + +return false;Wouldn't this be clearer as:
Quoted 1 line
return !error && xfarray_element_is_null(array, temp);
<shrug> don't care either way.
if (error) return false; return xfarray_element_is_null(...);
Quoted 21 lines
Quoted 21 lines
fs/xfs/scrub/trace.h +21
-0+int +xfarray_store_anywhere ( +struct xfarray *array, +const void *ptr) +{ +void *temp =xfarray_scratch (array); +loff_t endpos =xfarray_pos (array, array->nr); +loff_t pos; +int error; + +/* Find an unset slot to put it in. */ +for (pos =0 ; + pos < endpos && array->unset_slots >0 ; + pos += array->obj_size) { + error =xfile_obj_load (array->xfile, temp, array->obj_size, + pos); +if (error || !xfarray_element_is_null (array, temp)) +continue ; + + error =xfile_obj_store (array->xfile, ptr, array->obj_size, + pos);
Quoted 8 lines
fs/xfs/scrub/trace.h
Quoted 6 lines
fs/xfs/scrub/trace.h +6
-0+if (error) +return error; + + array->unset_slots--; +return 0 ; + }... how often is this called? This seems like it might be slow.
It's used in the refcount btree rebuilder patch, when it's trying to stack rmaps to compute the refcount of a given extent from the number of rmaps it's collected for that extent.
(Eventually I replace the xfarray with an indexed btree to eliminate the linear searching, but that won't happen until the part 2 of part 1 because I decided to send only the first 51 of 209 patches.)
Quoted 31 lines
fs/xfs/scrub/trace.h
Quoted 11 lines
fs/xfs/scrub/trace.h +11
-0+/* +* Call SEEK_DATA on the last byte in the record we're about to read. +* If the record ends at (or crosses) the end of a page then we know +* that the first byte of the record is backed by pages and don't need +* to query it. If instead the record begins at the start of the page +* then we know that querying the last byte is just as good as querying +* the first byte, since records cannot be larger than a page. +* +* If the call returns the same file offset, we know this record is +* backed by real pages. We do not need to move the cursor. +*/ Clever.
Quoted 17 lines
fs/xfs/scrub/trace.h +17
-0+ssize_t +xfile_pread ( +struct xfile *xf, +void *buf, +size_t count, +loff_t pos) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping; +struct page *page =NULL ; +ssize_t read =0 ; +unsigned int pflags; +int error =0 ; + +if (count >MAX_RW_COUNT ) +return -E2BIG ; +if (inode->i_sb->s_maxbytes - pos < count)
Quoted 8 lines
fs/xfs/scrub/trace.h
Quoted 5 lines
fs/xfs/scrub/trace.h +5
-0+return -EFBIG ; + +trace_xfile_pread (xf, pos, count); + + pflags =memalloc_nofs_save ();Should we be calling this here, or should this be done by the caller? Presumably it's the current caller that can't stand reclaim starting?
Well... here's the thing -- scrub already does this by attaching a (sometimes empty) transaction to the scrub context. In the context of "xfile as an xscrub infrastructure", it's unnecessary.
OTOH in the context of "xfile as something that may some day end up a general kernel tool", I don't think we want an xfile access to recurse into filesystems.
Quoted 8 lines
Quoted 8 lines
fs/xfs/scrub/trace.h +8
-0+while (count >0 ) { +void *p, *kaddr; +unsigned int len; + + len =min_t (ssize_t, count,PAGE_SIZE -offset_in_page (pos)); + +/* +* In-kernel reads of a shmem file cause it to allocate a page
Quoted 8 lines
fs/xfs/scrub/trace.h
Quoted 5 lines
fs/xfs/scrub/trace.h +5
-0+* if the mapping shows a hole. Therefore, if we hit ENOMEM +* we can continue by zeroing the caller's buffer. +*/ + page =shmem_read_mapping_page_gfp (mapping, pos >>PAGE_SHIFT , + __GFP_NOWARN);I'm kind of hoping to transition to
shmem_read_folio_gfp(), but that doesn't have to happen before this gets merged.
<nod> I haven't figured out if we care about large folios for xfiles yet. Scrub data is supposed to be ephemeral so it likely won't care, but I can imagine longer term uses for xfiles that might actually have an opinion.
Quoted 11 lines
fs/xfs/scrub/trace.h
Quoted 9 lines
fs/xfs/scrub/trace.h +9
-0+ssize_t +xfile_pwrite ( +struct xfile *xf, +const void *buf, +size_t count, +loff_t pos) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping;I wonder if this shoudn't be
xf->file->f_mapping?
<shrug> What's the difference for a tmpfs file?
--D
PATCH 2/7 xfs: enable sorting of xfile-backed arrays
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The btree bulk loading code requires that records be provided in the correct record sort order for the given btree type. In general, repair code cannot be required to collect records in order, and it is not feasible to insert new records in the middle of an array to maintain sort order.
Implement a sorting algorithm so that we can sort the records just prior to bulk loading. In principle, an xfarray could consume many gigabytes of memory and its backing pages can be sent out to disk at any time. This means that we cannot map the entire array into memory at once, so we must find a way to divide the work into smaller portions (e.g. a page) that /can/ be mapped into memory.
Quicksort seems like a reasonable fit for this purpose, since it uses a divide and conquer strategy to keep its average runtime logarithmic. The solution presented here is a port of the glibc implementation, which itself is derived from the median-of-three and tail call recursion strategies outlined by Sedgwick.
Subsequent patches will optimize the implementation further by utilizing the kernel's heapsort on directly-mapped memory whenever possible, and improving the quicksort pivot selection algorithm to try to avoid O(n^2) collapses.
Note: The sorting functionality gets its own patch because the basic big array mechanisms were plenty for a single code patch.
--- fs/xfs/scrub/trace.h | 114 ++++++++++ fs/xfs/scrub/xfarray.c | 569 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfarray.h | 67 ++++++ 3 files changed, 750 insertions(+)
fs/xfs/scrub/trace.h +114 -0
@@ -18,6 +18,7 @@struct xfile ;struct xfarray ; +struct xfarray_sortinfo ;/* * ftrace's __print_symbolic requires that all enum values be wrapped in the
@@ -846,6 +847,119 @@ TRACE_EVENT(xfarray_create, __entry->obj_size_log) ); +TRACE_EVENT (xfarray_isort, + TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), +TP_ARGS (si, lo, hi), +TP_STRUCT__entry ( + __field(unsigned long, ino) + __field(unsigned long long, lo) + __field(unsigned long long, hi) + ), +TP_fast_assign ( + __entry->ino = file_inode(si->array->xfile->file)->i_ino; + __entry->lo = lo; + __entry->hi = hi; + ), +TP_printk ("xfino 0x%lx lo %llu hi %llu elts %llu" , + __entry->ino, + __entry->lo, + __entry->hi, + __entry->hi - __entry->lo) +); + +TRACE_EVENT (xfarray_qsort, + TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), +TP_ARGS (si, lo, hi), +TP_STRUCT__entry ( + __field(unsigned long, ino) + __field(unsigned long long, lo) + __field(unsigned long long, hi) + __field(int, stack_depth) +__field (int, max_stack_depth) + ), +TP_fast_assign ( + __entry->ino = file_inode(si->array->xfile->file)->i_ino; + __entry->lo = lo; + __entry->hi = hi; + __entry->stack_depth = si->stack_depth; + __entry->max_stack_depth = si->max_stack_depth; + ), +TP_printk ("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d" , + __entry->ino, + __entry->lo, + __entry->hi, + __entry->hi - __entry->lo, + __entry->stack_depth, + __entry->max_stack_depth) +); + +TRACE_EVENT (xfarray_sort, + TP_PROTO(struct xfarray_sortinfo *si, size_t bytes), +TP_ARGS (si, bytes), +TP_STRUCT__entry ( + __field(unsigned long, ino) + __field(unsigned long long, nr) + __field(size_t, obj_size) + __field(size_t, bytes) + __field(unsigned int, max_stack_depth) + ), +TP_fast_assign ( + __entry->nr = si->array->nr; + __entry->obj_size = si->array->obj_size; + __entry->ino = file_inode(si->array->xfile->file)->i_ino; + __entry->bytes = bytes; + __entry->max_stack_depth = si->max_stack_depth; + ), +TP_printk ("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu" , + __entry->ino, + __entry->nr, + __entry->obj_size, + __entry->max_stack_depth, + __entry->bytes) +); + +TRACE_EVENT (xfarray_sort_stats, + TP_PROTO(struct xfarray_sortinfo *si, int error), +TP_ARGS (si, error), +TP_STRUCT__entry ( + __field(unsigned long, ino) +#ifdef DEBUG + __field(unsigned long long, loads) + __field(unsigned long long, stores) + __field(unsigned long long, compares) +#endif + __field(unsigned int, max_stack_depth) + __field(unsigned int, max_stack_used) +__field (int, error) + ), +TP_fast_assign ( + __entry->ino = file_inode(si->array->xfile->file)->i_ino; +#ifdef DEBUG + __entry->loads = si->loads; + __entry->stores = si->stores; + __entry->compares = si->compares; +#endif + __entry->max_stack_depth = si->max_stack_depth; + __entry->max_stack_used = si->max_stack_used; + __entry->error = error; + ), +TP_printk ( +#ifdef DEBUG +"xfino 0x%lx loads %llu stores %llu compares %llu stack_depth %u/%u error %d" , +#else +"xfino 0x%lx stack_depth %u/%u error %d" , +#endif + __entry->ino, +#ifdef DEBUG + __entry->loads, + __entry->stores, + __entry->compares, +#endif + __entry->max_stack_used, + __entry->max_stack_depth, + __entry->error) +); +/* repair tracepoints */ #if IS_ENABLED (CONFIG_XFS_ONLINE_REPAIR )
fs/xfs/scrub/xfarray.c +569 -0
572 lines not on this page · raw message
fs/xfs/scrub/xfarray.h +67 -0
71 lines not on this page · raw message
PATCH 3/7 xfs: convert xfarray insertion sort to heapsort using scratchpad memory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In the previous patch, we created a very basic quicksort implementation for xfile arrays. While the use of an alternate sorting algorithm to avoid quicksort recursion on very small subsets reduces the runtime modestly, we could do better than a load and store-heavy insertion sort, particularly since each load and store requires a page mapping lookup in the xfile.
For a small increase in kernel memory requirements, we could instead bulk load the xfarray records into memory, use the kernel's existing heapsort implementation to sort the records, and bulk store the memory buffer back into the xfile. On the author's computer, this reduces the runtime by about 5% on a 500,000 element array.
--- fs/xfs/scrub/trace.h | 5 +- fs/xfs/scrub/xfarray.c | 142 +++++++++--------------------------------------- fs/xfs/scrub/xfarray.h | 12 +++- 3 files changed, 39 insertions(+), 120 deletions(-)
fs/xfs/scrub/trace.h +4 -1
@@ -927,6 +927,7 @@ TRACE_EVENT(xfarray_sort_stats, __field(unsigned long long, loads) __field(unsigned long long, stores) __field(unsigned long long, compares) + __field(unsigned long long, heapsorts)#endif __field(unsigned int, max_stack_depth)__field (unsigned int , max_stack_used)
@@ -938,6 +939,7 @@ TRACE_EVENT(xfarray_sort_stats, __entry->loads = si->loads; __entry->stores = si->stores; __entry->compares = si->compares; + __entry->heapsorts = si->heapsorts;#endif __entry->max_stack_depth = si->max_stack_depth; __entry->max_stack_used = si->max_stack_used;
@@ -945,7 +947,7 @@ TRACE_EVENT(xfarray_sort_stats, ), TP_printk(#ifdef DEBUG - "xfino 0x%lx loads %llu stores %llu compares %llu stack_depth %u/%u error %d", +"xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d" , #else "xfino 0x%lx stack_depth %u/%u error %d", #endif
@@ -954,6 +956,7 @@ TRACE_EVENT(xfarray_sort_stats, __entry->loads, __entry->stores, __entry->compares, + __entry->heapsorts, #endif __entry->max_stack_used, __entry->max_stack_depth,
fs/xfs/scrub/xfarray.c +27 -115
202 lines not on this page · raw message
fs/xfs/scrub/xfarray.h +8 -4
@@ -58,6 +58,10 @@ int xfarray_load_next(struct xfarray *array, xfarray_idx_t *idx, void *rec);typedef cmp_func_t xfarray_cmp_fn ; +/* Perform an in-memory heapsort for small subsets. */ +#define XFARRAY_ISORT_SHIFT (4) +#define XFARRAY_ISORT_NR (1U << XFARRAY_ISORT_SHIFT) +struct xfarray_sortinfo {struct xfarray *array;
@@ -81,6 +85,7 @@ struct xfarray_sortinfo {uint64_t loads;uint64_t stores;uint64_t compares; +uint64_t heapsorts;#endif /*
@@ -99,11 +104,10 @@ struct xfarray_sortinfo {* * union { * -* If for a given subset we decide to use an insertion sort, we use the -* scratchpad record after the xfarray and a second scratchpad record -* here to compare items: +* If for a given subset we decide to use an in-memory sort, we use a +* block of scratchpad records here to compare items: * -* xfarray_rec_t scratch; +* xfarray_rec_t scratch[ISORT_NR]; * * Otherwise, we want to partition the records to partition the array. * We store the chosen pivot record here and use the xfarray scratchpad
PATCH 4/7 xfs: teach xfile to pass back direct-map pages to caller
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Certain xfile array operations (such as sorting) can be sped up quite a bit by allowing xfile users to grab a page to bulk-read the records contained within it. Create helper methods to facilitate this.
--- fs/xfs/scrub/trace.h | 2 + fs/xfs/scrub/xfile.c | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfile.h | 10 +++++ 3 files changed, 120 insertions(+)
fs/xfs/scrub/trace.h +2 -0
@@ -821,6 +821,8 @@ DEFINE_EVENT(xfile_class, name, \DEFINE_XFILE_EVENT (xfile_pread);DEFINE_XFILE_EVENT (xfile_pwrite);DEFINE_XFILE_EVENT (xfile_seek_data); +DEFINE_XFILE_EVENT (xfile_get_page); +DEFINE_XFILE_EVENT (xfile_put_page); TRACE_EVENT(xfarray_create, TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity),
fs/xfs/scrub/xfile.c +108 -0
111 lines not on this page · raw message
fs/xfs/scrub/xfile.h +10 -0
@@ -6,6 +6,12 @@#ifndef __XFS_SCRUB_XFILE_H__#define __XFS_SCRUB_XFILE_H__ +struct xfile_page { +struct page *page; +void *fsdata; +loff_t pos; +}; +struct xfile {struct file *file; };
@@ -54,4 +60,8 @@ struct xfile_stat {int xfile_stat (struct xfile *xf,struct xfile_stat *statbuf); +int xfile_get_page (struct xfile *xf,loff_t offset,unsigned int len, +struct xfile_page *xbuf); +int xfile_put_page (struct xfile *xf,struct xfile_page *xbuf); +#endif /* __XFS_SCRUB_XFILE_H__ */
PATCH 5/7 xfs: speed up xfarray sort by sorting xfile page contents directly
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If all the records in an xfarray subset live within the same memory page, we can short-circuit even more quicksort recursion by mapping that page into the local CPU and using the kernel's heapsort function to sort the subset. On the author's computer, this reduces the runtime by another 15% on a 500,000 element array.
--- fs/xfs/scrub/trace.h | 20 ++++++++++ fs/xfs/scrub/xfarray.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfarray.h | 4 ++ 3 files changed, 121 insertions(+)
fs/xfs/scrub/trace.h +20 -0
@@ -869,6 +869,26 @@ TRACE_EVENT(xfarray_isort, __entry->hi - __entry->lo) ); +TRACE_EVENT (xfarray_pagesort, + TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), +TP_ARGS (si, lo, hi), +TP_STRUCT__entry ( + __field(unsigned long, ino) + __field(unsigned long long, lo) + __field(unsigned long long, hi) + ), +TP_fast_assign ( + __entry->ino = file_inode(si->array->xfile->file)->i_ino; + __entry->lo = lo; + __entry->hi = hi; + ), +TP_printk ("xfino 0x%lx lo %llu hi %llu elts %llu" , + __entry->ino, + __entry->lo, + __entry->hi, + __entry->hi - __entry->lo) +); + TRACE_EVENT(xfarray_qsort, TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), TP_ARGS(si, lo, hi),
fs/xfs/scrub/xfarray.c +97 -0
115 lines not on this page · raw message
fs/xfs/scrub/xfarray.h +4 -0
@@ -80,6 +80,10 @@ struct xfarray_sortinfo {/* XFARRAY_SORT_* flags; see below. */ unsigned int flags; +/* Cache a page here for faster access. */ +struct xfile_page xfpage; +void *page_kaddr; +#ifdef DEBUG /* Performance statistics. */ uint64_t loads;
PATCH 6/7 xfs: cache pages used for xfarray quicksort convergence
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
After quicksort picks a pivot item for a particular subsort, it walks the records in that subset from the outside in, rearranging them so that every record less than the pivot comes before it, and every record greater than the pivot comes after it. This scan has a lot of locality, so we can speed it up quite a bit by grabbing the xfile backing page and holding onto it as long as we possibly can. Doing so reduces the runtime by another 5% on the author's computer.
--- fs/xfs/scrub/xfarray.c | 86 ++++++++++++++++++++++++++++++++++++++++++------ fs/xfs/scrub/xfile.h | 10 ++++++ 2 files changed, 86 insertions(+), 10 deletions(-)
fs/xfs/scrub/xfarray.c +76 -10
@@ -759,6 +759,66 @@ xfarray_qsort_push(return 0 ; } +/* +* Load an element from the array into the first scratchpad and cache the page, +* if possible. +*/ +static inline int +xfarray_sort_load_cached ( +struct xfarray_sortinfo *si, +xfarray_idx_t idx, +void *ptr) +{ +loff_t idx_pos =xfarray_pos (si->array, idx); +pgoff_t startpage; +pgoff_t endpage; +int error =0 ; + +/* +* If this load would split a page, release the cached page, if any, +* and perform a traditional read. +*/ + startpage = idx_pos >>PAGE_SHIFT ; + endpage = (idx_pos + si->array->obj_size -1 ) >>PAGE_SHIFT ; +if (startpage != endpage) { + error =xfarray_sort_put_page (si); +if (error) +return error; + +if (xfarray_sort_terminated (si, &error)) +return error; + +return xfile_obj_load (si->array->xfile, ptr, + si->array->obj_size, idx_pos); + } + +/* If the cached page is not the one we want, release it. */ +if (xfile_page_cached (&si->xfpage) && +xfile_page_index (&si->xfpage) != startpage) { + error =xfarray_sort_put_page (si); +if (error) +return error; + } + +/* +* If we don't have a cached page (and we know the load is contained +* in a single page) then grab it. +*/ +if (!xfile_page_cached (&si->xfpage)) { +if (xfarray_sort_terminated (si, &error)) +return error; + + error =xfarray_sort_get_page (si, startpage <<PAGE_SHIFT , +PAGE_SIZE ); +if (error) +return error; + } + +memcpy (ptr, si->page_kaddr +offset_in_page (idx_pos), + si->array->obj_size); +return 0 ; +} +/* * Sort the array elements via quicksort. This implementation incorporates * four optimizations discussed in Sedgewick:
@@ -784,6 +844,10 @@ xfarray_qsort_push(* If a small set is contained entirely within a single xfile memory page, * map the page directly and run heap sort directly on the xfile page * instead of using the load/store interface. This halves the runtime. +* +* 5. This optimization is specific to the implementation. When converging lo +* and hi after selecting a pivot, we will try to retain the xfile memory +* page between load calls, which reduces run time by 50%. */ /*
@@ -865,19 +929,20 @@ xfarray_sort(* Decrement hi until it finds an a[hi] less than the * pivot value. */ - error =xfarray_sort_load (si, hi, scratch); + error =xfarray_sort_load_cached (si, hi, scratch);if (error) goto out_free;while (xfarray_sort_cmp (si, scratch, pivot) >=0 && lo < hi) { -if (xfarray_sort_terminated (si, &error)) - goto out_free; - hi--; - error =xfarray_sort_load (si, hi, scratch); + error =xfarray_sort_load_cached (si, hi, + scratch);if (error) goto out_free; } + error =xfarray_sort_put_page (si); +if (error) + goto out_free;if (xfarray_sort_terminated (si, &error)) goto out_free;
@@ -893,19 +958,20 @@ xfarray_sort(* Increment lo until it finds an a[lo] greater than * the pivot value. */ - error =xfarray_sort_load (si, lo, scratch); + error =xfarray_sort_load_cached (si, lo, scratch);if (error) goto out_free;while (xfarray_sort_cmp (si, scratch, pivot) <=0 && lo < hi) { -if (xfarray_sort_terminated (si, &error)) - goto out_free; - lo++; - error =xfarray_sort_load (si, lo, scratch); + error =xfarray_sort_load_cached (si, lo, + scratch);if (error) goto out_free; } + error =xfarray_sort_put_page (si); +if (error) + goto out_free;if (xfarray_sort_terminated (si, &error)) goto out_free;
fs/xfs/scrub/xfile.h +10 -0
@@ -12,6 +12,16 @@ struct xfile_page {loff_t pos; }; +static inline bool xfile_page_cached (const struct xfile_page *xfpage) +{ +return xfpage->page !=NULL ; +} + +static inline pgoff_t xfile_page_index (const struct xfile_page *xfpage) +{ +return xfpage->page->index; +} +struct xfile {struct file *file; };
PATCH 7/7 xfs: improve xfarray quicksort pivot
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we have the means to do insertion sorts of small in-memory subsets of an xfarray, use it to improve the quicksort pivot algorithm by reading 7 records into memory and finding the median of that. This should prevent bad partitioning when a[lo] and a[hi] end up next to each other in the final sort, which can happen when sorting for cntbt repair when the free space is extremely fragmented (e.g. generic/176).
This doesn't speed up the average quicksort run by much, but it will (hopefully) avoid the quadratic time collapse for which quicksort is famous.
--- fs/xfs/scrub/xfarray.c | 198 ++++++++++++++++++++++++++++++++---------------- fs/xfs/scrub/xfarray.h | 19 +++-- 2 files changed, 148 insertions(+), 69 deletions(-)
fs/xfs/scrub/xfarray.c +134 -64
@@ -427,6 +427,14 @@ static inline xfarray_idx_t *xfarray_sortinfo_hi(struct xfarray_sortinfo *si)return xfarray_sortinfo_lo (si) + si->max_stack_depth; } +/* Size of each element in the quicksort pivot array. */ +static inline size_t +xfarray_pivot_rec_sz ( +struct xfarray *array) +{ +return round_up (array->obj_size,8 ) +sizeof (xfarray_idx_t); +} +/* Allocate memory to handle the sort. */ static inline int xfarray_sortinfo_alloc(
@@ -437,8 +445,16 @@ xfarray_sortinfo_alloc( {struct xfarray_sortinfo *si;size_t nr_bytes =sizeof (struct xfarray_sortinfo ); +size_t pivot_rec_sz =xfarray_pivot_rec_sz (array);int max_stack_depth; +/* +* The median-of-nine pivot algorithm doesn't work if a subset has +* fewer than 9 items. Make sure the in-memory sort will always take +* over for subsets where this wouldn't be the case. +*/ +BUILD_BUG_ON (XFARRAY_QSORT_PIVOT_NR >=XFARRAY_ISORT_NR ); +/* * Tail-call recursion during the partitioning phase means that * quicksort will never recurse more than log2(nr) times. We need one
@@ -453,8 +469,10 @@ xfarray_sortinfo_alloc(/* Each level of quicksort uses a lo and a hi index */ nr_bytes += max_stack_depth *sizeof (xfarray_idx_t) *2 ; -/* Scratchpad for in-memory sort, or one record for the pivot */ - nr_bytes += (XFARRAY_ISORT_NR * array->obj_size); +/* Scratchpad for in-memory sort, or finding the pivot */ + nr_bytes +=max_t (size_t, + (XFARRAY_QSORT_PIVOT_NR +1 ) * pivot_rec_sz, +XFARRAY_ISORT_NR * array->obj_size); si =kvzalloc (nr_bytes,XCHK_GFP_FLAGS );if (!si)
@@ -632,14 +650,43 @@ static inline void *xfarray_sortinfo_pivot(struct xfarray_sortinfo *si)return xfarray_sortinfo_hi (si) + si->max_stack_depth; } +/* Return a pointer to the start of the pivot array. */ +static inline void * +xfarray_sortinfo_pivot_array ( +struct xfarray_sortinfo *si) +{ +return xfarray_sortinfo_pivot (si) + si->array->obj_size; +} + +/* The xfarray record is stored at the start of each pivot array element. */ +static inline void * +xfarray_pivot_array_rec ( +void *pa, +size_t pa_recsz, +unsigned int pa_idx) +{ +return pa + (pa_recsz * pa_idx); +} + +/* The xfarray index is stored at the end of each pivot array element. */ +static inline xfarray_idx_t * +xfarray_pivot_array_idx ( +void *pa, +size_t pa_recsz, +unsigned int pa_idx) +{ +return xfarray_pivot_array_rec (pa, pa_recsz, pa_idx +1 ) - +sizeof (xfarray_idx_t); +} +/* * Find a pivot value for quicksort partitioning, swap it with a[lo], and save * the cached pivot record for the next step. * -* Select the median value from a[lo], a[mid], and a[hi]. Put the median in -* a[lo], the lowest in a[mid], and the highest in a[hi]. Using the median of -* the three reduces the chances that we pick the worst case pivot value, since -* it's likely that our array values are nearly sorted. +* Load evenly-spaced records within the given range into memory, sort them, +* and choose the pivot from the median record. Using multiple points will +* improve the quality of the pivot selection, and hopefully avoid the worst +* quicksort behavior, since our array values are nearly always evenly sorted. */ STATIC int xfarray_qsort_pivot(
@@ -647,76 +694,99 @@ xfarray_qsort_pivot(xfarray_idx_t lo, xfarray_idx_t hi) { - void *a = xfarray_sortinfo_pivot(si); -void *b =xfarray_scratch (si->array); -xfarray_idx_t mid = lo + ((hi - lo) /2 ); + void *pivot = xfarray_sortinfo_pivot(si); +void *parray =xfarray_sortinfo_pivot_array (si); +void *recp; +xfarray_idx_t *idxp; +xfarray_idx_t step = (hi - lo) / (XFARRAY_QSORT_PIVOT_NR -1 ); +size_t pivot_rec_sz =xfarray_pivot_rec_sz (si->array); +int i, j;int error; -/* if a[mid] < a[lo], swap a[mid] and a[lo]. */ - error =xfarray_sort_load (si, mid, a); -if (error) -return error; - error =xfarray_sort_load (si, lo, b); -if (error) -return error; -if (xfarray_sort_cmp (si, a, b) <0 ) { - error =xfarray_sort_store (si, lo, a); -if (error) -return error; - error =xfarray_sort_store (si, mid, b); -if (error) -return error; - } +ASSERT (step >0 ); -/* if a[hi] < a[mid], swap a[mid] and a[hi]. */ - error =xfarray_sort_load (si, hi, a); -if (error) -return error; - error =xfarray_sort_load (si, mid, b); -if (error) -return error; -if (xfarray_sort_cmp (si, a, b) <0 ) { - error =xfarray_sort_store (si, mid, a); -if (error) -return error; - error =xfarray_sort_store (si, hi, b); -if (error) -return error; - }else { - goto move_front; +/* +* Load the xfarray indexes of the records we intend to sample into the +* pivot array. +*/ + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz,0 ); + *idxp = lo; +for (i =1 ; i <XFARRAY_QSORT_PIVOT_NR -1 ; i++) { + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, i); + *idxp = lo + (i * step); } + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, +XFARRAY_QSORT_PIVOT_NR -1 ); + *idxp = hi; -/* if a[mid] < a[lo], swap a[mid] and a[lo]. */ - error =xfarray_sort_load (si, mid, a); -if (error) -return error; - error =xfarray_sort_load (si, lo, b); -if (error) -return error; -if (xfarray_sort_cmp (si, a, b) <0 ) { - error =xfarray_sort_store (si, lo, a); -if (error) -return error; - error =xfarray_sort_store (si, mid, b); +/* Load the selected xfarray records into the pivot array. */ +for (i =0 ; i <XFARRAY_QSORT_PIVOT_NR ; i++) { +xfarray_idx_t idx; + + recp =xfarray_pivot_array_rec (parray, pivot_rec_sz, i); + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, i); + +/* No unset records; load directly into the array. */ +if (likely (si->array->unset_slots ==0 )) { + error =xfarray_sort_load (si, *idxp, recp); +if (error) +return error; +continue ; + } + +/* +* Load non-null records into the scratchpad without changing +* the xfarray_idx_t in the pivot array. +*/ + idx = *idxp; +xfarray_sort_bump_loads (si); + error =xfarray_load_next (si->array, &idx, recp);if (error)return error; } -move_front: +xfarray_sort_bump_heapsorts (si); +sort (parray,XFARRAY_QSORT_PIVOT_NR , pivot_rec_sz, si->cmp_fn,NULL ); +/* -* Move our selected pivot to a[lo]. Recall that a == si->pivot, so -* this leaves us with the pivot cached in the sortinfo structure. +* We sorted the pivot array records (which includes the xfarray +* indices) in xfarray record order. The median element of the pivot +* array contains the xfarray record that we will use as the pivot. +* Copy that xfarray record to the designated space. */ - error =xfarray_sort_load (si, lo, b); -if (error) -return error; - error =xfarray_sort_load (si, mid, a); -if (error) -return error; - error =xfarray_sort_store (si, mid, b); + recp =xfarray_pivot_array_rec (parray, pivot_rec_sz, +XFARRAY_QSORT_PIVOT_NR /2 ); +memcpy (pivot, recp, si->array->obj_size); + +/* If the pivot record we chose was already in a[lo] then we're done. */ + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, +XFARRAY_QSORT_PIVOT_NR /2 ); +if (*idxp == lo) +return 0 ; + +/* +* Find the cached copy of a[lo] in the pivot array so that we can swap +* a[lo] and a[pivot]. +*/ +for (i =0 , j =-1 ; i <XFARRAY_QSORT_PIVOT_NR ; i++) { + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, i); +if (*idxp == lo) + j = i; + } +if (j <0 ) { +ASSERT (j >=0 ); +return -EFSCORRUPTED ; + } + +/* Swap a[lo] and a[pivot]. */ + error =xfarray_sort_store (si, lo, pivot);if (error)return error; -return xfarray_sort_store (si, lo, a); + + recp =xfarray_pivot_array_rec (parray, pivot_rec_sz, j); + idxp =xfarray_pivot_array_idx (parray, pivot_rec_sz, +XFARRAY_QSORT_PIVOT_NR /2 ); +return xfarray_sort_store (si, *idxp, recp); }/*
@@ -828,7 +898,7 @@ xfarray_sort_load_cached(* particularly expensive in the kernel. * * 2. For arrays with records in arbitrary or user-controlled order, choose the -* pivot element using a median-of-three decision tree. This reduces the +* pivot element using a median-of-nine decision tree. This reduces the * probability of selecting a bad pivot value which causes worst case * behavior (i.e. partition sizes of 1). *
fs/xfs/scrub/xfarray.h +14 -5
@@ -62,6 +62,9 @@ typedef cmp_func_t xfarray_cmp_fn;#define XFARRAY_ISORT_SHIFT (4)#define XFARRAY_ISORT_NR (1U << XFARRAY_ISORT_SHIFT) +/* Evalulate this many points to find the qsort pivot. */ +#define XFARRAY_QSORT_PIVOT_NR (9) +struct xfarray_sortinfo {struct xfarray *array;
@@ -91,7 +94,6 @@ struct xfarray_sortinfo {uint64_t compares;uint64_t heapsorts;#endif -/* * Extra bytes are allocated beyond the end of the structure to store * quicksort information. C does not permit multiple VLAs per struct,
@@ -114,11 +116,18 @@ struct xfarray_sortinfo {* xfarray_rec_t scratch[ISORT_NR]; * * Otherwise, we want to partition the records to partition the array. -* We store the chosen pivot record here and use the xfarray scratchpad -* to rearrange the array around the pivot: -* -* xfarray_rec_t pivot; +* We store the chosen pivot record at the start of the scratchpad area +* and use the rest to sample some records to estimate the median. +* The format of the qsort_pivot array enables us to use the kernel +* heapsort function to place the median value in the middle. * +* struct { +* xfarray_rec_t pivot; +* struct { +* xfarray_rec_t rec; (rounded up to 8 bytes) +* xfarray_idx_t idx; +* } qsort_pivot[QSORT_PIVOT_NR]; +* }; * } */ };
cover xfs: add usage counters for scrub
In reply to Darrick J. WongHi all,
This series introduces simple usage and performance counters for the online fsck subsystem. The goal here is to enable developers and sysadmins to look at summary counts of how many objects were checked and repaired; what the outcomes were; and how much time the kernel has spent on these operations. The counter file is exposed in debugfs because that's easier than cramming it into the device model, and debugfs doesn't have rules against complex file contents, unlike sysfs.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-usage-stats
--- fs/xfs/Kconfig | 17 ++ fs/xfs/Makefile | 1 fs/xfs/scrub/repair.c | 11 + fs/xfs/scrub/repair.h | 7 + fs/xfs/scrub/scrub.c | 11 + fs/xfs/scrub/stats.c | 405 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/stats.h | 59 +++++++ fs/xfs/xfs_linux.h | 1 fs/xfs/xfs_mount.c | 9 + fs/xfs/xfs_mount.h | 4 fs/xfs/xfs_super.c | 53 ++++++ fs/xfs/xfs_super.h | 2 12 files changed, 569 insertions(+), 11 deletions(-) create mode 100644 fs/xfs/scrub/stats.c create mode 100644 fs/xfs/scrub/stats.h
PATCH 1/2 xfs: create scaffolding for creating debugfs entries
From: Darrick J. Wong <[email protected]>
Set up debugfs directories for xfs as a whole, and a subdirectory for each mounted filesystem. This will enable the creation of debugfs files in the next patch.
--- fs/xfs/xfs_linux.h | 1 + fs/xfs/xfs_mount.h | 1 + fs/xfs/xfs_super.c | 32 ++++++++++++++++++++++++++++++-- fs/xfs/xfs_super.h | 2 ++ 4 files changed, 34 insertions(+), 2 deletions(-)
fs/xfs/xfs_linux.h +1 -0
@@ -63,6 +63,7 @@ typedef __u32 xfs_nlink_t;#include <linux/rhashtable.h> #include <linux/xattr.h> #include <linux/mnt_idmapping.h> +#include <linux/debugfs.h> #include <asm/page.h> #include <asm/div64.h>
fs/xfs/xfs_mount.h +1 -0
@@ -208,6 +208,7 @@ typedef struct xfs_mount {uint64_t m_resblks_avail;/* available reserved blocks */ uint64_t m_resblks_save;/* reserved blks @ remount,ro */ struct delayed_work m_reclaim_work;/* background inode reclaim */ +struct dentry *m_debugfs;/* debugfs parent */ struct xfs_kobj m_kobj;struct xfs_kobj m_error_kobj;struct xfs_kobj m_error_meta_kobj;
fs/xfs/xfs_super.c +30 -2
@@ -49,6 +49,7 @@static const struct super_operations xfs_super_operations; +static struct dentry *xfs_debugfs;/* top-level xfs debugfs dir */ static struct kset *xfs_kset;/* top-level xfs sysfs dir */ #ifdef DEBUG static struct xfs_kobj xfs_dbg_kobj;/* global debug sysfs attrs */
@@ -758,6 +759,7 @@ static voidxfs_mount_free ( struct xfs_mount *mp) { +debugfs_remove (mp->m_debugfs);kfree (mp->m_rtname);kfree (mp->m_logname);kmem_free (mp);
@@ -1479,6 +1481,21 @@ xfs_fs_validate_params(return 0 ; } +struct dentry * +xfs_debugfs_mkdir ( +const char *name, +struct dentry *parent) +{ +struct dentry *child; + +/* Apparently we're expected to ignore error returns?? */ + child =debugfs_create_dir (name, parent); +if (IS_ERR (child)) +return NULL ; + +return child; +} + static int xfs_fs_fill_super( struct super_block *sb,
@@ -1521,6 +1538,13 @@ xfs_fs_fill_super(if (error) goto out_free_names; +if (xfs_debugfs) { + mp->m_debugfs =xfs_debugfs_mkdir (mp->m_super->s_id, + xfs_debugfs); + }else { + mp->m_debugfs =NULL ; + } + error =xfs_init_mount_workqueues (mp);if (error) goto out_close_devices;
@@ -2353,10 +2377,12 @@ init_xfs_fs(void)if (error) goto out_cleanup_procfs; + xfs_debugfs =xfs_debugfs_mkdir ("xfs" ,NULL ); + xfs_kset =kset_create_and_add ("xfs" ,NULL , fs_kobj);if (!xfs_kset) { error = -ENOMEM ; - goto out_sysctl_unregister; + goto out_debugfs_unregister; } xfsstats.xs_kobj.kobject.kset = xfs_kset;
@@ -2400,7 +2426,8 @@ init_xfs_fs(void)free_percpu (xfsstats.xs_stats); out_kset_unregister:kset_unregister (xfs_kset); - out_sysctl_unregister: + out_debugfs_unregister: +debugfs_remove (xfs_debugfs);xfs_sysctl_unregister (); out_cleanup_procfs:xfs_cleanup_procfs ();
@@ -2427,6 +2454,7 @@ exit_xfs_fs(void)xfs_sysfs_del (&xfsstats.xs_kobj);free_percpu (xfsstats.xs_stats);kset_unregister (xfs_kset); +debugfs_remove (xfs_debugfs);xfs_sysctl_unregister ();xfs_cleanup_procfs ();xfs_mru_cache_uninit ();
fs/xfs/xfs_super.h +2 -0
@@ -100,4 +100,6 @@ extern struct workqueue_struct *xfs_discard_wq;#define XFS_M (sb) ((struct xfs_mount *)((sb)->s_fs_info)) +struct dentry *xfs_debugfs_mkdir (const char *name,struct dentry *parent); +#endif /* __XFS_SUPER_H__ */
PATCH 2/2 xfs: track usage statistics of online fsck
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Track the usage, outcomes, and run times of the online fsck code, and report these values via debugfs. The columns in the file are:
* scrubber name
* number of scrub invocations
* clean objects found
* corruptions found
* optimizations found
* cross referencing failures
* inconsistencies found during cross referencing
* incomplete scrubs
* warnings
* number of time scrub had to retry
* cumulative amount of time spent scrubbing (microseconds)
* number of repair inovcations
* successfully repaired objects
* cumuluative amount of time spent repairing (microseconds)
--- fs/xfs/Kconfig | 17 ++ fs/xfs/Makefile | 1 fs/xfs/scrub/repair.c | 11 + fs/xfs/scrub/repair.h | 7 + fs/xfs/scrub/scrub.c | 11 + fs/xfs/scrub/stats.c | 405 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/stats.h | 59 +++++++ fs/xfs/xfs_mount.c | 9 + fs/xfs/xfs_mount.h | 3 fs/xfs/xfs_super.c | 21 ++- 10 files changed, 535 insertions(+), 9 deletions(-) create mode 100644 fs/xfs/scrub/stats.c create mode 100644 fs/xfs/scrub/stats.h
fs/xfs/Kconfig +17 -0
@@ -143,6 +143,23 @@ config XFS_ONLINE_SCRUB If unsure, say N. +config XFS_ONLINE_SCRUB_STATS + bool "XFS online metadata check usage data collection" + default y + depends on XFS_ONLINE_SCRUB + select FS_DEBUG + help + If you say Y here, the kernel will gather usage data about + the online metadata check subsystem. This includes the number + of invocations, the outcomes, and the results of repairs, if any. + This may slow down scrub slightly due to the use of high precision + timers and the need to merge per-invocation information into the + filesystem counters. + + Usage data are collected in /sys/kernel/debug/xfs/scrub. + + If unsure, say N. + config XFS_ONLINE_REPAIR bool "XFS online metadata repair support" default n
fs/xfs/Makefile +1 -0
@@ -168,6 +168,7 @@ xfs-y += $(addprefix scrub/, \ xfile.o \ ) +xfs-$(CONFIG_XFS_ONLINE_SCRUB_STATS) += scrub/stats.o xfs-$(CONFIG_XFS_RT) += scrub/rtbitmap.o xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o
fs/xfs/scrub/repair.c +10 -1
@@ -32,6 +32,7 @@#include "scrub/trace.h" #include "scrub/repair.h" #include "scrub/bitmap.h" +#include "scrub/stats.h" /* * Attempt to repair some metadata, if the metadata is corrupt and userspace
@@ -40,8 +41,10 @@*/ int xrep_attempt ( -struct xfs_scrub *sc) +struct xfs_scrub *sc, +struct xchk_stats_run *run) { +u64 repair_start;int error =0 ;trace_xrep_attempt (XFS_I (file_inode (sc->file)), sc->sm, error);
@@ -50,8 +53,11 @@ xrep_attempt(/* Repair whatever's broken. */ ASSERT (sc->ops->repair); + run->repair_attempted = true; + repair_start =xchk_stats_now (); error = sc->ops->repair (sc);trace_xrep_done (XFS_I (file_inode (sc->file)), sc->sm, error); + run->repair_ns +=xchk_stats_elapsed_ns (repair_start);switch (error) {case 0 :/*
@@ -60,14 +66,17 @@ xrep_attempt(*/ sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT ; sc->flags |=XREP_ALREADY_FIXED ; + run->repair_succeeded = true;return -EAGAIN ;case -ECHRNG : sc->flags |=XCHK_NEED_DRAIN ; + run->retries++;return -EAGAIN ;case -EDEADLOCK :/* Tell the caller to try again having grabbed all the locks. */ if (!(sc->flags &XCHK_TRY_HARDER )) { sc->flags |=XCHK_TRY_HARDER ; + run->retries++;return -EAGAIN ; }/*
fs/xfs/scrub/repair.h +5 -2
@@ -8,6 +8,8 @@#include "xfs_quota_defs.h" +struct xchk_stats_run ; +static inline int xrep_notsupported (struct xfs_scrub *sc) {return -EOPNOTSUPP ;
@@ -17,7 +19,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)/* Repair helpers */ -int xrep_attempt (struct xfs_scrub *sc); +int xrep_attempt (struct xfs_scrub *sc,struct xchk_stats_run *run);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc);int xrep_roll_trans (struct xfs_scrub *sc);
@@ -63,7 +65,8 @@ int xrep_agi(struct xfs_scrub *sc);static inline int xrep_attempt ( -struct xfs_scrub *sc) +struct xfs_scrub *sc, +struct xchk_stats_run *run) {return -EOPNOTSUPP ; }
fs/xfs/scrub/scrub.c +10 -1
@@ -24,6 +24,7 @@#include "scrub/trace.h" #include "scrub/repair.h" #include "scrub/health.h" +#include "scrub/stats.h" /* * Online Scrub and Repair
@@ -463,8 +464,10 @@ xfs_scrub_metadata(struct file *file, struct xfs_scrub_metadata *sm) { + struct xchk_stats_run run = { };struct xfs_scrub *sc;struct xfs_mount *mp =XFS_I (file_inode (file))->i_mount; +u64 check_start;int error =0 ; BUILD_BUG_ON(sizeof(meta_scrub_ops) !=
@@ -519,7 +522,9 @@ xfs_scrub_metadata( goto out_teardown;/* Scrub for errors. */ + check_start =xchk_stats_now (); error = sc->ops->scrub (sc); + run.scrub_ns +=xchk_stats_elapsed_ns (check_start);if (error == -EDEADLOCK && !(sc->flags &XCHK_TRY_HARDER )) goto try_harder;if (error == -ECHRNG && !(sc->flags &XCHK_NEED_DRAIN ))
@@ -553,7 +558,7 @@ xfs_scrub_metadata(* If it's broken, userspace wants us to fix it, and we haven't * already tried to fix it, then attempt a repair. */ - error =xrep_attempt (sc); + error =xrep_attempt (sc, &run);if (error == -EAGAIN ) {/* * Either the repair function succeeded or it couldn't
@@ -581,12 +586,15 @@ xfs_scrub_metadata( sm->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; error =0 ; } +if (error != -ENOENT ) +xchk_stats_merge (mp, sm, &run);return error; need_drain: error =xchk_teardown (sc,0 );if (error) goto out_sc; sc->flags |=XCHK_NEED_DRAIN ; + run.retries++; goto retry_op; try_harder:/*
@@ -598,5 +606,6 @@ xfs_scrub_metadata(if (error) goto out_sc; sc->flags |=XCHK_TRY_HARDER ; + run.retries++; goto retry_op; }
fs/xfs/scrub/stats.c new file +405 -0
405 lines not on this page · raw message
fs/xfs/scrub/stats.h new file +59 -0
59 lines not on this page · raw message
fs/xfs/xfs_mount.c +7 -2
@@ -34,6 +34,7 @@#include "xfs_health.h" #include "xfs_trace.h" #include "xfs_ag.h" +#include "scrub/stats.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);static int xfs_uuid_table_size;
@@ -716,9 +717,11 @@ xfs_mountfs(if (error) goto out_remove_sysfs; +xchk_stats_register (mp->m_scrub_stats, mp->m_debugfs); + error =xfs_error_sysfs_init (mp);if (error) - goto out_del_stats; + goto out_remove_scrub_stats; error =xfs_errortag_init (mp);if (error)
@@ -1033,7 +1036,8 @@ xfs_mountfs(xfs_errortag_del (mp); out_remove_error_sysfs:xfs_error_sysfs_del (mp); - out_del_stats: + out_remove_scrub_stats: +xchk_stats_unregister (mp->m_scrub_stats);xfs_sysfs_del (&mp->m_stats.xs_kobj); out_remove_sysfs:xfs_sysfs_del (&mp->m_kobj);
@@ -1105,6 +1109,7 @@ xfs_unmountfs(xfs_errortag_del (mp);xfs_error_sysfs_del (mp); +xchk_stats_unregister (mp->m_scrub_stats);xfs_sysfs_del (&mp->m_stats.xs_kobj);xfs_sysfs_del (&mp->m_kobj); }
fs/xfs/xfs_mount.h +3 -0
@@ -214,6 +214,9 @@ typedef struct xfs_mount {struct xfs_kobj m_error_meta_kobj;struct xfs_error_cfg m_error_cfg[XFS_ERR_CLASS_MAX ][XFS_ERR_ERRNO_MAX ];struct xstats m_stats;/* per-fs stats */ +#ifdef CONFIG_XFS_ONLINE_SCRUB_STATS +struct xchk_stats *m_scrub_stats; +#endif xfs_agnumber_t m_agfrotor;/* last ag where space found */ atomic_t m_agirotor;/* last ag dir inode alloced */
fs/xfs/xfs_super.c +18 -3
@@ -42,6 +42,7 @@#include "xfs_xattr.h" #include "xfs_iunlink_item.h" #include "xfs_dahash_test.h" +#include "scrub/stats.h" #include <linux/magic.h> #include <linux/fs_context.h>
@@ -1144,6 +1145,7 @@ xfs_fs_put_super(xfs_unmountfs (mp);xfs_freesb (mp); +xchk_mount_stats_free (mp);free_percpu (mp->m_stats.xs_stats);xfs_mount_list_del (mp);xfs_inodegc_free_percpu (mp);
@@ -1571,9 +1573,13 @@ xfs_fs_fill_super( goto out_destroy_inodegc; } + error =xchk_mount_stats_alloc (mp); +if (error) + goto out_free_stats; + error =xfs_readsb (mp, flags);if (error) - goto out_free_stats; + goto out_free_scrub_stats; error =xfs_finish_flags (mp);if (error)
@@ -1752,6 +1758,8 @@ xfs_fs_fill_super(xfs_filestream_unmount (mp); out_free_sb:xfs_freesb (mp); + out_free_scrub_stats: +xchk_mount_stats_free (mp); out_free_stats:free_percpu (mp->m_stats.xs_stats); out_destroy_inodegc:
@@ -2398,11 +2406,15 @@ init_xfs_fs(void)if (error) goto out_free_stats; + error =xchk_global_stats_setup (xfs_debugfs); +if (error) + goto out_remove_stats_kobj; +#ifdef DEBUG xfs_dbg_kobj.kobject.kset = xfs_kset; error =xfs_sysfs_init (&xfs_dbg_kobj, &xfs_dbg_ktype,NULL ,"debug" );if (error) - goto out_remove_stats_kobj; + goto out_remove_scrub_stats;#endif error =xfs_qm_init ();
@@ -2419,8 +2431,10 @@ init_xfs_fs(void) out_remove_dbg_kobj:#ifdef DEBUG xfs_sysfs_del (&xfs_dbg_kobj); + out_remove_scrub_stats: +#endif +xchk_global_stats_teardown (); out_remove_stats_kobj: -#endif xfs_sysfs_del (&xfsstats.xs_kobj); out_free_stats:free_percpu (xfsstats.xs_stats);
@@ -2451,6 +2465,7 @@ exit_xfs_fs(void)#ifdef DEBUG xfs_sysfs_del (&xfs_dbg_kobj);#endif +xchk_global_stats_teardown ();xfs_sysfs_del (&xfsstats.xs_kobj);free_percpu (xfsstats.xs_stats);kset_unregister (xfs_kset);
Re: [PATCHSET v26.0 0/2] xfs: add usage counters for scrub
In reply to Darrick J. WongQuoted 9 lines · Darrick J. Wong
Hi all,
This series introduces simple usage and performance counters for the online fsck subsystem. The goal here is to enable developers and sysadmins to look at summary counts of how many objects were checked and repaired; what the outcomes were; and how much time the kernel has spent on these operations. The counter file is exposed in debugfs because that's easier than cramming it into the device model, and debugfs doesn't have rules against complex file contents, unlike sysfs.
I wish we could just put these in sysfs with all the other per-mount stats files we have. It's just stupid to have to put them somewhere else because we want to put all the stats in a single file and so grab them with a single read operation...
Other than that, this series looks fine.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: online scrubbing of realtime summary files
In reply to Darrick J. WongHi all,
This patchset implements an online checker for the realtime summary file. The first few changes are some general cleanups -- scrub should get its own references to all inodes, and we also wrap the inode lock functions so that we can standardize unlocking and releasing inodes that are the focus of a scrub.
With that out of the way, we move on to constructing a shadow copy of the rtsummary information from the rtbitmap, and compare the new copy against the ondisk copy.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-rtsummary
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=scrub-rtsummary
--- fs/xfs/Makefile | 7 + fs/xfs/scrub/bmap.c | 9 +- fs/xfs/scrub/common.c | 63 +++++++++-- fs/xfs/scrub/common.h | 24 ++++ fs/xfs/scrub/inode.c | 11 +- fs/xfs/scrub/parent.c | 4 - fs/xfs/scrub/quota.c | 15 +-- fs/xfs/scrub/rtbitmap.c | 48 +------- fs/xfs/scrub/rtsummary.c | 264 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 17 ++- fs/xfs/scrub/scrub.h | 4 + fs/xfs/scrub/trace.h | 34 ++++++ fs/xfs/xfs_trace.h | 3 + 13 files changed, 421 insertions(+), 82 deletions(-) create mode 100644 fs/xfs/scrub/rtsummary.c
PATCH 1/4 xfs: get our own reference to inodes that we want to scrub
From: Darrick J. Wong <[email protected]>
When we want to scrub a file, get our own reference to the inode unconditionally. This will make disposal rules simpler in the long run.
--- fs/xfs/scrub/common.c | 25 +++++++++++++++++++++---- fs/xfs/scrub/common.h | 1 + fs/xfs/scrub/inode.c | 5 ++++- fs/xfs/scrub/quota.c | 6 +++++- fs/xfs/scrub/rtbitmap.c | 6 ++++-- fs/xfs/scrub/scrub.c | 6 +----- 6 files changed, 36 insertions(+), 13 deletions(-)
fs/xfs/scrub/common.c +21 -4
@@ -832,6 +832,25 @@ xchk_install_handle_inode(return 0 ; } +/* +* Install an already-referenced inode for scrubbing. Get our own reference to +* the inode to make disposal simpler. The inode must not be in I_FREEING or +* I_WILL_FREE state! +*/ +int +xchk_install_live_inode ( +struct xfs_scrub *sc, +struct xfs_inode *ip) +{ +if (!igrab (VFS_I (ip))) { +xchk_ino_set_corrupt (sc, ip->i_ino); +return -EFSCORRUPTED ; + } + + sc->ip = ip; +return 0 ; +} +/* * In preparation to scrub metadata structures that hang off of an inode, * grab either the inode referenced in the scrub control structure or the
@@ -855,10 +874,8 @@ xchk_iget_for_scrubbing(ASSERT (sc->tp ==NULL );/* We want to scan the inode we already had opened. */ -if (sc->sm->sm_ino ==0 || sc->sm->sm_ino == ip_in->i_ino) { - sc->ip = ip_in; -return 0 ; - } +if (sc->sm->sm_ino ==0 || sc->sm->sm_ino == ip_in->i_ino) +return xchk_install_live_inode (sc, ip_in);/* Reject internal metadata files and obviously bad inode numbers. */ if (xfs_internal_inum (mp, sc->sm->sm_ino))
fs/xfs/scrub/common.h +1 -0
@@ -137,6 +137,7 @@ int xchk_count_rmap_ownedby_ag(struct xfs_scrub *sc, struct xfs_btree_cur *cur,int xchk_setup_ag_btree (struct xfs_scrub *sc,bool force_log);int xchk_iget_for_scrubbing (struct xfs_scrub *sc);int xchk_setup_inode_contents (struct xfs_scrub *sc,unsigned int resblks); +int xchk_install_live_inode (struct xfs_scrub *sc,struct xfs_inode *ip);void xchk_buffer_recheck (struct xfs_scrub *sc,struct xfs_buf *bp);int xchk_iget (struct xfs_scrub *sc,xfs_ino_t inum,struct xfs_inode **ipp);
fs/xfs/scrub/inode.c +4 -1
@@ -83,7 +83,10 @@ xchk_setup_inode(/* We want to scan the opened inode, so lock it and exit. */ if (sc->sm->sm_ino ==0 || sc->sm->sm_ino == ip_in->i_ino) { - sc->ip = ip_in; + error =xchk_install_live_inode (sc, ip_in); +if (error) +return error; +return xchk_prepare_iscrub (sc); }
fs/xfs/scrub/quota.c +5 -1
@@ -59,7 +59,11 @@ xchk_setup_quota( error =xchk_setup_fs (sc);if (error)return error; - sc->ip =xfs_quota_inode (sc->mp, dqtype); + + error =xchk_install_live_inode (sc,xfs_quota_inode (sc->mp, dqtype)); +if (error) +return error; +xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); sc->ilock_flags =XFS_ILOCK_EXCL ;return 0 ;
fs/xfs/scrub/rtbitmap.c +4 -2
@@ -28,10 +28,12 @@ xchk_setup_rt(if (error)return error; + error =xchk_install_live_inode (sc, sc->mp->m_rbmip); +if (error) +return error; + sc->ilock_flags =XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ; - sc->ip = sc->mp->m_rbmip;xfs_ilock (sc->ip, sc->ilock_flags); -return 0 ; }
fs/xfs/scrub/scrub.c +1 -5
@@ -169,8 +169,6 @@ xchk_teardown(struct xfs_scrub *sc, int error) { -struct xfs_inode *ip_in =XFS_I (file_inode (sc->file)); - xchk_ag_free(sc, &sc->sa);if (sc->tp) {if (error ==0 && (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ))
@@ -182,9 +180,7 @@ xchk_teardown(if (sc->ip) {if (sc->ilock_flags)xfs_iunlock (sc->ip, sc->ilock_flags); -if (sc->ip != ip_in && - !xfs_internal_inum (sc->mp, sc->ip->i_ino)) -xchk_irele (sc, sc->ip); +xchk_irele (sc, sc->ip); sc->ip =NULL ; }if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR )
PATCH 2/4 xfs: wrap ilock/iunlock operations on sc->ip
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Scrub tracks the resources that it's holding onto in the xfs_scrub structure. This includes the inode being checked (if applicable) and the inode lock state of that inode. Replace the open-coded structure manipulation with a trivial helper to eliminate sources of error.
--- fs/xfs/scrub/bmap.c | 9 +++------ fs/xfs/scrub/common.c | 38 +++++++++++++++++++++++++++++++++----- fs/xfs/scrub/common.h | 5 +++++ fs/xfs/scrub/inode.c | 6 ++---- fs/xfs/scrub/parent.c | 4 ++-- fs/xfs/scrub/quota.c | 9 +++------ fs/xfs/scrub/rtbitmap.c | 9 ++++----- fs/xfs/scrub/scrub.c | 2 +- 8 files changed, 53 insertions(+), 29 deletions(-)
fs/xfs/scrub/bmap.c +3 -6
@@ -38,8 +38,7 @@ xchk_setup_inode_bmap(if (error) goto out; - sc->ilock_flags =XFS_IOLOCK_EXCL ; -xfs_ilock (sc->ip,XFS_IOLOCK_EXCL ); +xchk_ilock (sc,XFS_IOLOCK_EXCL );/* * We don't want any ephemeral data/cow fork updates sitting around
@@ -50,8 +49,7 @@ xchk_setup_inode_bmap( sc->sm->sm_type != XFS_SCRUB_TYPE_BMBTA) {struct address_space *mapping =VFS_I (sc->ip)->i_mapping; - sc->ilock_flags |=XFS_MMAPLOCK_EXCL ; -xfs_ilock (sc->ip,XFS_MMAPLOCK_EXCL ); +xchk_ilock (sc,XFS_MMAPLOCK_EXCL );inode_dio_wait (VFS_I (sc->ip));
@@ -79,9 +77,8 @@ xchk_setup_inode_bmap( error =xchk_trans_alloc (sc,0 );if (error) goto out; - sc->ilock_flags |=XFS_ILOCK_EXCL ; -xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode */ return error;
fs/xfs/scrub/common.c +33 -5
@@ -1023,20 +1023,48 @@ xchk_setup_inode_contents(return error;/* Lock the inode so the VFS cannot touch this file. */ - sc->ilock_flags =XFS_IOLOCK_EXCL ; -xfs_ilock (sc->ip, sc->ilock_flags); +xchk_ilock (sc,XFS_IOLOCK_EXCL ); error =xchk_trans_alloc (sc, resblks);if (error) goto out; - sc->ilock_flags |=XFS_ILOCK_EXCL ; -xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); - +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode for us */ return error; } +void +xchk_ilock ( +struct xfs_scrub *sc, +unsigned int ilock_flags) +{ +xfs_ilock (sc->ip, ilock_flags); + sc->ilock_flags |= ilock_flags; +} + +bool +xchk_ilock_nowait ( +struct xfs_scrub *sc, +unsigned int ilock_flags) +{ +if (xfs_ilock_nowait (sc->ip, ilock_flags)) { + sc->ilock_flags |= ilock_flags; +return true; + } + +return false; +} + +void +xchk_iunlock ( +struct xfs_scrub *sc, +unsigned int ilock_flags) +{ + sc->ilock_flags &= ~ilock_flags; +xfs_iunlock (sc->ip, ilock_flags); +} +/* * Predicate that decides if we need to evaluate the cross-reference check. * If there was an error accessing the cross-reference btree, just delete
fs/xfs/scrub/common.h +5 -0
@@ -138,6 +138,11 @@ int xchk_setup_ag_btree(struct xfs_scrub *sc, bool force_log);int xchk_iget_for_scrubbing (struct xfs_scrub *sc);int xchk_setup_inode_contents (struct xfs_scrub *sc,unsigned int resblks);int xchk_install_live_inode (struct xfs_scrub *sc,struct xfs_inode *ip); + +void xchk_ilock (struct xfs_scrub *sc,unsigned int ilock_flags); +bool xchk_ilock_nowait (struct xfs_scrub *sc,unsigned int ilock_flags); +void xchk_iunlock (struct xfs_scrub *sc,unsigned int ilock_flags); +void xchk_buffer_recheck (struct xfs_scrub *sc,struct xfs_buf *bp);int xchk_iget (struct xfs_scrub *sc,xfs_ino_t inum,struct xfs_inode **ipp);
fs/xfs/scrub/inode.c +2 -4
@@ -32,15 +32,13 @@ xchk_prepare_iscrub( {int error; - sc->ilock_flags =XFS_IOLOCK_EXCL ; -xfs_ilock (sc->ip, sc->ilock_flags); +xchk_ilock (sc,XFS_IOLOCK_EXCL ); error =xchk_trans_alloc (sc,0 );if (error)return error; - sc->ilock_flags |=XFS_ILOCK_EXCL ; -xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); +xchk_ilock (sc,XFS_ILOCK_EXCL );return 0 ; }
fs/xfs/scrub/parent.c +2 -2
@@ -150,8 +150,8 @@ xchk_parent_validate( lock_mode =xchk_parent_ilock_dir (dp);if (!lock_mode) { -xfs_iunlock (sc->ip,XFS_ILOCK_EXCL ); -xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); +xchk_iunlock (sc,XFS_ILOCK_EXCL ); +xchk_ilock (sc,XFS_ILOCK_EXCL ); error = -EAGAIN ; goto out_rele; }
fs/xfs/scrub/quota.c +3 -6
@@ -64,8 +64,7 @@ xchk_setup_quota(if (error)return error; -xfs_ilock (sc->ip,XFS_ILOCK_EXCL ); - sc->ilock_flags =XFS_ILOCK_EXCL ; +xchk_ilock (sc,XFS_ILOCK_EXCL );return 0 ; }
@@ -239,13 +238,11 @@ xchk_quota(* data fork we have to drop ILOCK_EXCL to use the regular dquot * functions. */ -xfs_iunlock (sc->ip, sc->ilock_flags); - sc->ilock_flags =0 ; +xchk_iunlock (sc, sc->ilock_flags); sqi.sc = sc; sqi.last_id =0 ; error =xfs_qm_dqiterate (mp, dqtype, xchk_quota_item, &sqi); - sc->ilock_flags =XFS_ILOCK_EXCL ; -xfs_ilock (sc->ip, sc->ilock_flags); +xchk_ilock (sc,XFS_ILOCK_EXCL );if (error == -ECANCELED ) error =0 ; if (!xchk_fblock_process_error(sc, XFS_DATA_FORK,
fs/xfs/scrub/rtbitmap.c +4 -5
@@ -32,8 +32,7 @@ xchk_setup_rt(if (error)return error; - sc->ilock_flags =XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ; -xfs_ilock (sc->ip, sc->ilock_flags); +xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP );return 0 ; }
@@ -143,8 +142,8 @@ xchk_rtsummary(* flags so that we don't mix up the inode state that @sc tracks. */ sc->ip = rsumip; - sc->ilock_flags =XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ; -xfs_ilock (sc->ip, sc->ilock_flags); + sc->ilock_flags =0 ; +xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM );/* Invoke the fork scrubber. */ error =xchk_metadata_inode_forks (sc);
@@ -155,7 +154,7 @@ xchk_rtsummary(xchk_set_incomplete (sc); out:/* Switch back to the rtbitmap inode and lock flags. */ -xfs_iunlock (sc->ip, sc->ilock_flags); +xchk_iunlock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); sc->ilock_flags = old_ilock_flags; sc->ip = old_ip;return error;
fs/xfs/scrub/scrub.c +1 -1
@@ -179,7 +179,7 @@ xchk_teardown( }if (sc->ip) {if (sc->ilock_flags) -xfs_iunlock (sc->ip, sc->ilock_flags); +xchk_iunlock (sc, sc->ilock_flags);xchk_irele (sc, sc->ip); sc->ip =NULL ; }
PATCH 3/4 xfs: move the realtime summary file scrubber to a separate source file
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the realtime summary file checking code to a separate file in preparation to actually implement it.
--- fs/xfs/Makefile | 7 +++++- fs/xfs/scrub/rtbitmap.c | 37 -------------------------------- fs/xfs/scrub/rtsummary.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+), 38 deletions(-) create mode 100644 fs/xfs/scrub/rtsummary.c
fs/xfs/Makefile +6 -1
@@ -169,7 +169,12 @@ xfs-y += $(addprefix scrub/, \ ) xfs-$(CONFIG_XFS_ONLINE_SCRUB_STATS) += scrub/stats.o -xfs-$(CONFIG_XFS_RT) += scrub/rtbitmap.o + +xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ + rtbitmap.o \ + rtsummary.o \ + ) + xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o # online repair
fs/xfs/scrub/rtbitmap.c +0 -37
@@ -124,43 +124,6 @@ xchk_rtbitmap(return error; } -/* Scrub the realtime summary. */ -int -xchk_rtsummary ( -struct xfs_scrub *sc) -{ -struct xfs_inode *rsumip = sc->mp->m_rsumip; -struct xfs_inode *old_ip = sc->ip; -uint old_ilock_flags = sc->ilock_flags; -int error =0 ; - -/* -* We ILOCK'd the rt bitmap ip in the setup routine, now lock the -* rt summary ip in compliance with the rt inode locking rules. -* -* Since we switch sc->ip to rsumip we have to save the old ilock -* flags so that we don't mix up the inode state that @sc tracks. -*/ - sc->ip = rsumip; - sc->ilock_flags =0 ; -xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); - -/* Invoke the fork scrubber. */ - error =xchk_metadata_inode_forks (sc); -if (error || (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT )) - goto out; - -/* XXX: implement this some day */ -xchk_set_incomplete (sc); -out: -/* Switch back to the rtbitmap inode and lock flags. */ -xchk_iunlock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); - sc->ilock_flags = old_ilock_flags; - sc->ip = old_ip; -return error; -} - -/* xref check that the extent is not free in the rtbitmap */ void xchk_xref_is_used_rt_space(
fs/xfs/scrub/rtsummary.c new file +54 -0
54 lines not on this page · raw message
PATCH 4/4 xfs: implement online scrubbing of rtsummary info
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Finish the realtime summary scrubber by adding the functions we need to compute a fresh copy of the rtsummary info and comparing it to the copy on disk.
--- fs/xfs/scrub/common.h | 18 +++ fs/xfs/scrub/rtbitmap.c | 4 - fs/xfs/scrub/rtsummary.c | 254 ++++++++++++++++++++++++++++++++++++++++++---- fs/xfs/scrub/scrub.c | 9 +- fs/xfs/scrub/scrub.h | 4 + fs/xfs/scrub/trace.h | 34 ++++++ fs/xfs/xfs_trace.h | 3 + 7 files changed, 298 insertions(+), 28 deletions(-)
fs/xfs/scrub/common.h +16 -2
@@ -88,10 +88,16 @@ int xchk_setup_xattr(struct xfs_scrub *sc);int xchk_setup_symlink (struct xfs_scrub *sc);int xchk_setup_parent (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT -int xchk_setup_rt (struct xfs_scrub *sc); +int xchk_setup_rtbitmap (struct xfs_scrub *sc); +int xchk_setup_rtsummary (struct xfs_scrub *sc);#else static inline int -xchk_setup_rt (struct xfs_scrub *sc) +xchk_setup_rtbitmap (struct xfs_scrub *sc) +{ +return -ENOENT ; +} +static inline int +xchk_setup_rtsummary (struct xfs_scrub *sc) {return -ENOENT ; }
@@ -163,6 +169,14 @@ static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm)int xchk_metadata_inode_forks (struct xfs_scrub *sc); +/* +* Helper macros to allocate and format xfile description strings. +* Callers must kfree the pointer returned. +*/ +#define xchk_xfile_descr (sc, fmt, ...) \ + kasprintf(XCHK_GFP_FLAGS, "XFS (%s): " fmt, \ + (sc)->mp->m_super->s_id, ##__VA_ARGS__) +/* * Setting up a hook to wait for intents to drain is costly -- we have to take * the CPU hotplug lock and force an i-cache flush on all CPUs once to set it
fs/xfs/scrub/rtbitmap.c +2 -2
@@ -19,12 +19,12 @@/* Set us up with the realtime metadata locked. */ int -xchk_setup_rt ( +xchk_setup_rtbitmap (struct xfs_scrub *sc) {int error; - error =xchk_setup_fs (sc); + error =xchk_trans_alloc (sc,0 );if (error)return error;
fs/xfs/scrub/rtsummary.c +232 -22
273 lines not on this page · raw message
fs/xfs/scrub/scrub.c +7 -2
@@ -25,6 +25,7 @@#include "scrub/repair.h" #include "scrub/health.h" #include "scrub/stats.h" +#include "scrub/xfile.h" /* * Online Scrub and Repair
@@ -185,6 +186,10 @@ xchk_teardown( }if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR )mnt_drop_write_file (sc->file); +if (sc->xfile) { +xfile_destroy (sc->xfile); + sc->xfile =NULL ; + }if (sc->buf) {if (sc->buf_cleanup) sc->buf_cleanup (sc->buf);
@@ -319,14 +324,14 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { }, [XFS_SCRUB_TYPE_RTBITMAP] = { /* realtime bitmap */ .type = ST_FS, - .setup = xchk_setup_rt, + .setup = xchk_setup_rtbitmap, .scrub = xchk_rtbitmap, .has = xfs_has_realtime, .repair = xrep_notsupported, }, [XFS_SCRUB_TYPE_RTSUM] = { /* realtime summary */ .type = ST_FS, - .setup = xchk_setup_rt, + .setup = xchk_setup_rtsummary, .scrub = xchk_rtsummary, .has = xfs_has_realtime, .repair = xrep_notsupported,
fs/xfs/scrub/scrub.h +4 -0
@@ -88,6 +88,10 @@ struct xfs_scrub {*/ void (*buf_cleanup)(void *buf); +/* xfile used by the scrubbers; freed at teardown. */ +struct xfile *xfile; + +/* Lock flags for @ip. */ uint ilock_flags;/* See the XCHK/XREP state flags below. */
fs/xfs/scrub/trace.h +34 -0
@@ -985,6 +985,40 @@ TRACE_EVENT(xfarray_sort_stats, __entry->error) ); +#ifdef CONFIG_XFS_RT +TRACE_EVENT (xchk_rtsum_record_free, + TP_PROTO(struct xfs_mount *mp, xfs_rtblock_t start, + uint64_t len, unsigned int log, loff_t pos, xfs_suminfo_t v), +TP_ARGS (mp, start, len, log, pos, v), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(dev_t, rtdev) + __field(xfs_rtblock_t, start) + __field(unsigned long long, len) + __field(unsigned int, log) + __field(loff_t, pos) +__field (xfs_suminfo_t, v) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->rtdev = mp->m_rtdev_targp->bt_dev; + __entry->start = start; + __entry->len = len; + __entry->log = log; + __entry->pos = pos; + __entry->v = v; + ), +TP_printk ("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u" , +MAJOR (__entry->dev),MINOR (__entry->dev), +MAJOR (__entry->rtdev),MINOR (__entry->rtdev), + __entry->start, + __entry->len, + __entry->log, + __entry->pos, + __entry->v) +); +#endif /* CONFIG_XFS_RT */ +/* repair tracepoints */ #if IS_ENABLED (CONFIG_XFS_ONLINE_REPAIR )
fs/xfs/xfs_trace.h +3 -0
@@ -22,6 +22,9 @@* daddr: physical block number in 512b blocks * bbcount: number of blocks in a physical extent, in 512b blocks * +* rtx: physical rt extent number for extent mappings +* rtxcount: number of rt extents in an extent mapping +* * owner: reverse-mapping owner, usually inodes * * fileoff: file offset, in fs blocks
cover xfs: miscellaneous repair tweaks
In reply to Darrick J. WongHi all,
Before we start adding online repair functionality, there's a few tweaks that I'd like to make to the common repair code. First is a fix to the integration between repair and the health status code that was interfering with repair re-evaluations. Second is a minor tweak to the sole existing repair functions to make one last check that the user hasn't terminated the calling process before we start writing to the filesystem. This is a pattern that will repeat throughout the rest of the repair functions.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-tweaks
--- fs/xfs/scrub/agheader_repair.c | 16 ++++++++++++++++ fs/xfs/scrub/health.c | 10 ++++++++++ 2 files changed, 26 insertions(+)
PATCH 1/2 xfs: always rescan allegedly healthy per-ag metadata after repair
From: Darrick J. Wong <[email protected]>
After an online repair function runs for a per-AG metadata structure, sc->sick_mask is supposed to reflect the per-AG metadata that the repair function fixed. Our next move is to re-check the metadata to assess the completeness of our repair, so we don't want the rebuilt structure to be excluded from the rescan just because the health system previously logged a problem with the data structure.
--- fs/xfs/scrub/health.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
fs/xfs/scrub/health.c +10 -0
@@ -226,6 +226,16 @@ xchk_ag_btree_healthy_enough(return true; } +/* +* If we just repaired some AG metadata, sc->sick_mask will reflect all +* the per-AG metadata types that were repaired. Exclude these from +* the filesystem health query because we have not yet updated the +* health status and we want everything to be scanned. +*/ +if ((sc->flags &XREP_ALREADY_FIXED ) && + type_to_health_flag[sc->sm->sm_type].group ==XHG_AG ) + mask &= ~sc->sick_mask; +if (xfs_ag_has_sickness (pag, mask)) { sc->sm->sm_flags |=XFS_SCRUB_OFLAG_XFAIL ;return false;
PATCH 2/2 xfs: allow the user to cancel repairs before we start writing
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
All online repair functions have the same structure: walk filesystem metadata structures gathering enough data to rebuild the structure, stage a new copy, and then commit the new copy.
The gathering steps do not write anything to disk, so they are peppered with xchk_should_terminate calls to avoid softlockup warnings and to provide an opportunity to abort the repair (by killing xfs_scrub). However, it's not clear in the code base when is the last chance to abort cleanly without having to undo a bunch of structure.
Therefore, add one more call to xchk_should_terminate (along with a comment) providing the sysadmin with the ability to abort before it's too late and to make it clear in the source code when it's no longer
convenient or safe to abort a repair. As there are only four repair
functions right now, this patch exists more to establish a precedent for subsequent additions than to deliver practical functionality.
--- fs/xfs/scrub/agheader_repair.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
fs/xfs/scrub/agheader_repair.c +16 -0
@@ -50,6 +50,10 @@ xrep_superblock(if (error)return error; +/* Last chance to abort before we start committing fixes. */ +if (xchk_should_terminate (sc, &error)) +return error; +/* Copy AG 0's superblock to this one. */ xfs_buf_zero (bp,0 ,BBTOB (bp->b_length));xfs_sb_to_disk (bp->b_addr, &mp->m_sb);
@@ -425,6 +429,10 @@ xrep_agf(if (error)return error; +/* Last chance to abort before we start committing fixes. */ +if (xchk_should_terminate (sc, &error)) +return error; +/* Start rewriting the header and implant the btrees we found. */ xrep_agf_init_header (sc, agf_bp, &old_agf);xrep_agf_set_roots (sc, agf, fab);
@@ -749,6 +757,10 @@ xrep_agfl(if (error) goto err; +/* Last chance to abort before we start committing fixes. */ +if (xchk_should_terminate (sc, &error)) + goto err; +/* * Update AGF and AGFL. We reset the global free block counter when * we adjust the AGF flcount (which can fail) so avoid updating any
@@ -996,6 +1008,10 @@ xrep_agi(if (error)return error; +/* Last chance to abort before we start committing fixes. */ +if (xchk_should_terminate (sc, &error)) +return error; +/* Start rewriting the header and implant the btrees we found. */ xrep_agi_init_header (sc, agi_bp, &old_agi);xrep_agi_set_roots (sc, agi, fab);
cover xfs: force rebuilding of metadata
In reply to Darrick J. WongHi all,
This patchset adds a new IFLAG to the scrub ioctl so that userspace can force a rebuild of an otherwise consistent piece of metadata. This will eventually enable the use of online repair to relocate metadata during a filesystem reorganization (e.g. shrink). For now, it facilitates stress testing of online repair without needing the debugging knobs to be enabled.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-force-rebuild
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-force-rebuild
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-force-rebuild
--- fs/xfs/libxfs/xfs_fs.h | 6 +++++- fs/xfs/scrub/common.h | 12 ++++++++++++ fs/xfs/scrub/scrub.c | 18 ++++++++++++------ fs/xfs/scrub/trace.h | 3 ++- 4 files changed, 31 insertions(+), 8 deletions(-)
PATCH 1/2 xfs: don't complain about unfixed metadata when repairs were injected
From: Darrick J. Wong <[email protected]>
While debugging other parts of online repair, I noticed that if someone injects FORCE_SCRUB_REPAIR, starts an IFLAG_REPAIR scrub on a piece of metadata, and the metadata repair fails, we'll log a message about uncorrected errors in the filesystem.
This isn't strictly true if the scrub function didn't set OFLAG_CORRUPT and we're only doing the repair because the error injection knob is set. Repair functions are allowed to abort the entire operation at any point before committing new metadata, in which case the piece of metadata is in the same state as it was before. Therefore, the log message should be gated on the results of the scrub. Refactor the predicate and rearrange the code flow to make this happen.
Note: If the repair function errors out after it commits the new metadata, the transaction cancellation will shut down the filesystem, which is an obvious sign of corrupt metadata.
--- fs/xfs/scrub/common.h | 12 ++++++++++++ fs/xfs/scrub/scrub.c | 7 ++----- 2 files changed, 14 insertions(+), 5 deletions(-)
fs/xfs/scrub/common.h +12 -0
@@ -167,6 +167,18 @@ static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm) XFS_SCRUB_OFLAG_XCORRUPT); } +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* Decide if a repair is required. */ +static inline bool xchk_needs_repair (const struct xfs_scrub_metadata *sm) +{ +return sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT | +XFS_SCRUB_OFLAG_XCORRUPT | +XFS_SCRUB_OFLAG_PREEN ); +} +#else +# define xchk_needs_repair (sc) (false) +#endif /* CONFIG_XFS_ONLINE_REPAIR */ +int xchk_metadata_inode_forks (struct xfs_scrub *sc);/*
fs/xfs/scrub/scrub.c +2 -5
@@ -537,15 +537,12 @@ xfs_scrub_metadata(if ((sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && !(sc->flags &XREP_ALREADY_FIXED )) { -bool needs_fix; +bool needs_fix =xchk_needs_repair (sc->sm);/* Let debug users force us into the repair routines. */ if (XFS_TEST_ERROR (false, mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) - sc->sm->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; + needs_fix = true; - needs_fix = (sc->sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT | -XFS_SCRUB_OFLAG_XCORRUPT | -XFS_SCRUB_OFLAG_PREEN ));/* * If userspace asked for a repair but it wasn't necessary, * report that back to userspace.
PATCH 2/2 xfs: allow userspace to rebuild metadata structures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new (superuser-only) flag to the online metadata repair ioctl to force it to rebuild structures, even if they're not broken. We will use this to move metadata structures out of the way during a free space defragmentation operation.
--- fs/xfs/libxfs/xfs_fs.h | 6 +++++- fs/xfs/scrub/scrub.c | 11 ++++++++++- fs/xfs/scrub/trace.h | 3 ++- 3 files changed, 17 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_fs.h +5 -1
@@ -743,7 +743,11 @@ struct xfs_scrub_metadata {*/ #define XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED (1u << 7) -#define XFS_SCRUB_FLAGS_IN (XFS_SCRUB_IFLAG_REPAIR) +/* i: Rebuild the data structure. */ +#define XFS_SCRUB_IFLAG_FORCE_REBUILD (1u << 8) + +#define XFS_SCRUB_FLAGS_IN (XFS_SCRUB_IFLAG_REPAIR | \ + XFS_SCRUB_IFLAG_FORCE_REBUILD)#define XFS_SCRUB_FLAGS_OUT (XFS_SCRUB_OFLAG_CORRUPT | \ XFS_SCRUB_OFLAG_PREEN | \ XFS_SCRUB_OFLAG_XFAIL | \
fs/xfs/scrub/scrub.c +10 -1
@@ -411,6 +411,11 @@ xchk_validate_inputs( goto out; } +/* No rebuild without repair. */ +if ((sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) && + !(sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR )) +return -EINVAL ; +/* * We only want to repair read-write v5+ filesystems. Defer the check * for ops->repair until after our scrub confirms that we need to
@@ -539,8 +544,12 @@ xfs_scrub_metadata( !(sc->flags & XREP_ALREADY_FIXED)) {bool needs_fix =xchk_needs_repair (sc->sm); +/* Userspace asked us to rebuild the structure regardless. */ +if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) + needs_fix = true; +/* Let debug users force us into the repair routines. */ -if (XFS_TEST_ERROR (false, mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) +if (XFS_TEST_ERROR (needs_fix, mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) needs_fix = true;/*
fs/xfs/scrub/trace.h +2 -1
@@ -98,7 +98,8 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS); { XFS_SCRUB_OFLAG_XCORRUPT, "xcorrupt" }, \ { XFS_SCRUB_OFLAG_INCOMPLETE, "incomplete" }, \ { XFS_SCRUB_OFLAG_WARNING, "warning" }, \ - { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED, "norepair" } + { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED, "norepair" }, \ + { XFS_SCRUB_IFLAG_FORCE_REBUILD, "rebuild" } #define XFS_SCRUB_STATE_STRINGS \ { XCHK_TRY_HARDER, "try_harder" }, \
cover xfs: fixes to the AGFL repair code
In reply to Darrick J. WongHi all,
This series contains a couple of bug fixes to the AGFL repair code that came up during QA.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-agfl-fixes
--- fs/xfs/scrub/agheader_repair.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
PATCH 1/2 xfs: clear pagf_agflreset when repairing the AGFL
From: Darrick J. Wong <[email protected]>
Clear the pagf_agflreset flag when we're repairing the AGFL because we fix all the same padding problems that xfs_agfl_reset does.
--- fs/xfs/scrub/agheader_repair.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/xfs/scrub/agheader_repair.c +4 -1
@@ -621,8 +621,11 @@ xrep_agfl_update_agf(xfs_force_summary_recalc (sc->mp);/* Update the AGF counters. */ -if (xfs_perag_initialised_agf (sc->sa.pag)) +if (xfs_perag_initialised_agf (sc->sa.pag)) { sc->sa.pag->pagf_flcount = flcount; +clear_bit (XFS_AGSTATE_AGFL_NEEDS_RESET , + &sc->sa.pag->pag_opstate); + } agf->agf_flfirst =cpu_to_be32 (0 ); agf->agf_flcount =cpu_to_be32 (flcount); agf->agf_fllast =cpu_to_be32 (flcount -1 );
PATCH 2/2 xfs: fix agf_fllast when repairing an empty AGFL
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
xfs/139 with parent pointers enabled occasionally pops up a corruption message when online fsck force-rebuild repairs an AGFL:
XFS (sde): Metadata corruption detected at xfs_agf_verify+0x11e/0x220 [xfs], xfs_agf block 0x9e0001 XFS (sde): Unmount and run xfs_repair
XFS (sde): First 128 bytes of corrupted metadata buffer:
00000000: 58 41 47 46 00 00 00 01 00 00 00 4f 00 00 40 00 XAGF.......O..@. 00000010: 00 00 00 01 00 00 00 02 00 00 00 05 00 00 00 01 ................ 00000020: 00 00 00 01 00 00 00 01 00 00 00 00 ff ff ff ff ................ 00000030: 00 00 00 00 00 00 00 05 00 00 00 05 00 00 00 00 ................ 00000040: 91 2e 6f b1 ed 61 4b 4d 8c 9b 6e 87 08 bb f6 36 ..o..aKM..n....6 00000050: 00 00 00 01 00 00 00 01 00 00 00 06 00 00 00 01 ................ 00000060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ 00000070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
The root cause of this failure is that prior to the repair, there were zero blocks in the AGFL. This scenario is set up by the test case, since it formats with 64MB AGs and tries to ENOSPC the whole filesystem. In this case of flcount==0, we reset fllast to -1U, which then trips the write verifier's check that fllast is less than xfs_agfl_size().
Correct this code to set fllast to the last possible slot in the AGFL when flcount is zero, which mirrors the behavior of xfs_repair phase5 when it has to create a totally empty AGFL.
--- fs/xfs/scrub/agheader_repair.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/xfs/scrub/agheader_repair.c +4 -1
@@ -628,7 +628,10 @@ xrep_agfl_update_agf( } agf->agf_flfirst =cpu_to_be32 (0 ); agf->agf_flcount =cpu_to_be32 (flcount); - agf->agf_fllast =cpu_to_be32 (flcount -1 ); +if (flcount) + agf->agf_fllast =cpu_to_be32 (flcount -1 ); +else + agf->agf_fllast =cpu_to_be32 (xfs_agfl_size (sc->mp) -1 );xfs_alloc_log_agf (sc->tp, agf_bp,XFS_AGF_FLFIRST |XFS_AGF_FLLAST |XFS_AGF_FLCOUNT );
Re: [PATCH 2/2] xfs: fix agf_fllast when repairing an empty AGFL
Quoted 40 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
xfs/139 with parent pointers enabled occasionally pops up a corruption message when online fsck force-rebuild repairs an AGFL:
XFS (sde): Metadata corruption detected at
xfs_agf_verify+0x11e/0x220[xfs],xfs_agfblock0x9e0001XFS (sde): Unmount and runxfs_repair
XFS (sde): First 128 bytes of corrupted metadata buffer:00000000: 58 41 47 46 00 00 00 01 00 00 00 4f 00 00 40 00 XAGF.......O..@. 00000010: 00 00 00 01 00 00 00 02 00 00 00 05 00 00 00 01 ................ 00000020: 00 00 00 01 00 00 00 01 00 00 00 00 ff ff ff ff ................ 00000030: 00 00 00 00 00 00 00 05 00 00 00 05 00 00 00 00 ................ 00000040: 91 2e 6f b1 ed 61 4b 4d 8c 9b 6e 87 08 bb f6 36 ..o..aKM..n....6 00000050: 00 00 00 01 00 00 00 01 00 00 00 06 00 00 00 01 ................ 00000060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ 00000070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................The root cause of this failure is that prior to the repair, there were zero blocks in the AGFL. This scenario is set up by the test case, since it formats with 64MB AGs and tries to ENOSPC the whole filesystem. In this case of flcount==0, we reset fllast to -1U, which then trips the write verifier's check that fllast is less than
xfs_agfl_size().Correct this code to set fllast to the last possible slot in the AGFL when flcount is zero, which mirrors the behavior of
xfs_repairphase5 when it has to create a totally empty AGFL.Fixes 0e93d3f43ec7 ("xfs: repair the AGFL")Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/agheader_repair.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)fs/xfs/scrub/agheader_repair.c +0
-0@@ -628,7 +628,10 @@ xrep_agfl_update_agf( }
fs/xfs/scrub/agheader_repair.c xrep_agfl_update_agf( · line 637
Quoted 10 lines
fs/xfs/scrub/agheader_repair.c +4
-1agf->agf_flfirst =cpu_to_be32 (0 ); agf->agf_flcount =cpu_to_be32 (flcount); - agf->agf_fllast =cpu_to_be32 (flcount -1 ); +if (flcount) + agf->agf_fllast =cpu_to_be32 (flcount -1 ); +else + agf->agf_fllast =cpu_to_be32 (xfs_agfl_size (sc->mp) -1 );xfs_alloc_log_agf (sc->tp, agf_bp,XFS_AGF_FLFIRST |XFS_AGF_FLLAST |XFS_AGF_FLCOUNT );
Looks good.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: online repair of AG btrees
In reply to Darrick J. WongHi all,
Now that we've spent a lot of time reworking common code in online fsck, we're ready to start rebuilding the AG space btrees. This series implements repair functions for the free space, inode, and refcount btrees. Rebuilding the reverse mapping btree is much more intense and is left for a subsequent patchset. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-ag-btrees
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-ag-btrees
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-ag-btrees
--- fs/xfs/Makefile | 3 fs/xfs/libxfs/xfs_ag.h | 10 fs/xfs/libxfs/xfs_ag_resv.c | 2 fs/xfs/libxfs/xfs_alloc.c | 18 - fs/xfs/libxfs/xfs_alloc.h | 2 fs/xfs/libxfs/xfs_alloc_btree.c | 13 - fs/xfs/libxfs/xfs_btree.c | 26 + fs/xfs/libxfs/xfs_btree.h | 2 fs/xfs/libxfs/xfs_ialloc.c | 41 +- fs/xfs/libxfs/xfs_ialloc.h | 3 fs/xfs/libxfs/xfs_refcount.c | 18 - fs/xfs/libxfs/xfs_refcount.h | 2 fs/xfs/libxfs/xfs_refcount_btree.c | 13 - fs/xfs/libxfs/xfs_types.h | 7 fs/xfs/scrub/alloc.c | 14 - fs/xfs/scrub/alloc_repair.c | 912 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.c | 153 ++++++ fs/xfs/scrub/common.h | 22 + fs/xfs/scrub/ialloc.c | 3 fs/xfs/scrub/ialloc_repair.c | 882 +++++++++++++++++++++++++++++++++++ fs/xfs/scrub/newbt.c | 45 ++ fs/xfs/scrub/newbt.h | 6 fs/xfs/scrub/refcount_repair.c | 796 +++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 128 +++++ fs/xfs/scrub/repair.h | 43 ++ fs/xfs/scrub/scrub.c | 22 + fs/xfs/scrub/scrub.h | 9 fs/xfs/scrub/trace.h | 134 ++++- fs/xfs/scrub/xfarray.h | 22 + fs/xfs/xfs_extent_busy.c | 13 + fs/xfs/xfs_extent_busy.h | 2 fs/xfs/xfs_icache.c | 38 -- fs/xfs/xfs_icache.h | 4 33 files changed, 3277 insertions(+), 131 deletions(-) create mode 100644 fs/xfs/scrub/alloc_repair.c create mode 100644 fs/xfs/scrub/ialloc_repair.c create mode 100644 fs/xfs/scrub/refcount_repair.c
PATCH 1/5 xfs: repair free space btrees
From: Darrick J. Wong <[email protected]>
Rebuild the free space btrees from the gaps in the rmap btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.h | 9 fs/xfs/libxfs/xfs_ag_resv.c | 2 fs/xfs/libxfs/xfs_alloc.c | 18 + fs/xfs/libxfs/xfs_alloc.h | 2 fs/xfs/libxfs/xfs_alloc_btree.c | 13 + fs/xfs/libxfs/xfs_types.h | 7 fs/xfs/scrub/alloc.c | 14 + fs/xfs/scrub/alloc_repair.c | 912 +++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 19 + fs/xfs/scrub/newbt.c | 45 ++ fs/xfs/scrub/newbt.h | 6 fs/xfs/scrub/repair.c | 69 +++ fs/xfs/scrub/repair.h | 24 + fs/xfs/scrub/scrub.c | 14 - fs/xfs/scrub/scrub.h | 8 fs/xfs/scrub/trace.h | 24 + fs/xfs/scrub/xfarray.h | 22 + fs/xfs/xfs_extent_busy.c | 13 + fs/xfs/xfs_extent_busy.h | 2 20 files changed, 1203 insertions(+), 21 deletions(-) create mode 100644 fs/xfs/scrub/alloc_repair.c
fs/xfs/Makefile +1 -0
@@ -181,6 +181,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ + alloc_repair.o \ newbt.o \ reap.o \ repair.o \
fs/xfs/libxfs/xfs_ag.h +9 -0
@@ -80,6 +80,15 @@ struct xfs_perag {*/ uint16_t pag_checked;uint16_t pag_sick; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Alternate btree heights so that online repair won't trip the write +* verifiers while rebuilding the AG btrees. +*/ +uint8_t pagf_alt_levels[XFS_BTNUM_AGF ]; +#endif +spinlock_t pag_state_lock;spinlock_t pagb_lock;/* lock for pagb_tree */
fs/xfs/libxfs/xfs_ag_resv.c +2 -0
@@ -411,6 +411,8 @@ xfs_ag_resv_free_extent( fallthrough;case XFS_AG_RESV_NONE :xfs_trans_mod_sb (tp,XFS_TRANS_SB_FDBLOCKS , (int64_t )len); + fallthrough; +case XFS_AG_RESV_IGNORE :return ; }
fs/xfs/libxfs/xfs_alloc.c +12 -6
@@ -243,14 +243,11 @@ xfs_alloc_btrec_to_irec( irec->ar_blockcount =be32_to_cpu (rec->alloc.ar_blockcount); } -/* Simple checks for free space records. */ -xfs_failaddr_t -xfs_alloc_check_irec ( -struct xfs_btree_cur *cur, +inline xfs_failaddr_t +xfs_alloc_check_perag_irec ( +struct xfs_perag *pag,const struct xfs_alloc_rec_incore *irec) { -struct xfs_perag *pag = cur->bc_ag.pag; -if (irec->ar_blockcount ==0 )return __this_address;
@@ -261,6 +258,15 @@ xfs_alloc_check_irec(return NULL ; } +/* Simple checks for free space records. */ +xfs_failaddr_t +xfs_alloc_check_irec ( +struct xfs_btree_cur *cur, +const struct xfs_alloc_rec_incore *irec) +{ +return xfs_alloc_check_perag_irec (cur->bc_ag.pag, irec); +} + static inline int xfs_alloc_complain_bad_rec( struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_alloc.h +2 -0
@@ -185,6 +185,8 @@ xfs_alloc_get_rec(union xfs_btree_rec ;void xfs_alloc_btrec_to_irec (const union xfs_btree_rec *rec,struct xfs_alloc_rec_incore *irec); +xfs_failaddr_t xfs_alloc_check_perag_irec (struct xfs_perag *pag, +const struct xfs_alloc_rec_incore *irec);xfs_failaddr_t xfs_alloc_check_irec (struct xfs_btree_cur *cur,const struct xfs_alloc_rec_incore *irec);
fs/xfs/libxfs/xfs_alloc_btree.c +12 -1
@@ -323,7 +323,18 @@ xfs_allocbt_verify(if (bp->b_ops->magic[0 ] ==cpu_to_be32 (XFS_ABTC_MAGIC )) btnum = XFS_BTNUM_CNTi;if (pag &&xfs_perag_initialised_agf (pag)) { -if (level >= pag->pagf_levels[btnum]) +unsigned int maxlevel = pag->pagf_levels[btnum]; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Online repair could be rewriting the free space btrees, so +* we'll validate against the larger of either tree while this +* is going on. +*/ + maxlevel = max_t(unsigned int, maxlevel, + pag->pagf_alt_levels[btnum]); +#endif +if (level >= maxlevel)return __this_address; }else if (level >= mp->m_alloc_maxlevels)return __this_address;
fs/xfs/libxfs/xfs_types.h +7 -0
@@ -202,6 +202,13 @@ enum xfs_ag_resv_type {XFS_AG_RESV_AGFL ,XFS_AG_RESV_METADATA ,XFS_AG_RESV_RMAPBT , + +/* +* Don't increase fdblocks when freeing extent. This is a pony for +* the bnobt repair functions to re-free the free space without +* altering fdblocks. If you think you need this you're wrong. +*/ + XFS_AG_RESV_IGNORE, };/* Results of scanning a btree keyspace to check occupancy. */
fs/xfs/scrub/alloc.c +12 -2
@@ -12,10 +12,11 @@#include "xfs_btree.h" #include "xfs_alloc.h" #include "xfs_rmap.h" +#include "xfs_ag.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/btree.h" -#include "xfs_ag.h" +#include "scrub/repair.h" /* * Set us up to scrub free space btrees.
@@ -24,10 +25,19 @@ intxchk_setup_ag_allocbt ( struct xfs_scrub *sc) { +int error; +if (xchk_need_intent_drain (sc))xchk_fsgates_enable (sc,XCHK_FSGATES_DRAIN ); -return xchk_setup_ag_btree (sc, false); + error =xchk_setup_ag_btree (sc, false); +if (error) +return error; + +if (xchk_could_repair (sc)) +return xrep_setup_ag_allocbt (sc); + +return 0 ; }/* Free space btree scrubber. */
fs/xfs/scrub/alloc_repair.c new file +912 -0
912 lines not on this page · raw message
fs/xfs/scrub/common.h +19 -0
@@ -175,8 +175,21 @@ static inline bool xchk_needs_repair(const struct xfs_scrub_metadata *sm)XFS_SCRUB_OFLAG_XCORRUPT | XFS_SCRUB_OFLAG_PREEN); } + +/* +* "Should we prepare for a repair?" +* +* Return true if the caller permits us to repair metadata and we're not +* setting up for a post-repair evaluation. +*/ +static inline bool xchk_could_repair (const struct xfs_scrub *sc) +{ +return (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && + !(sc->flags &XREP_ALREADY_FIXED ); +}#else # define xchk_needs_repair (sc) (false) +# define xchk_could_repair (sc) (false)#endif /* CONFIG_XFS_ONLINE_REPAIR */ int xchk_metadata_inode_forks (struct xfs_scrub *sc);
@@ -188,6 +201,12 @@ int xchk_metadata_inode_forks(struct xfs_scrub *sc);#define xchk_xfile_descr (sc, fmt, ...) \ kasprintf(XCHK_GFP_FLAGS, "XFS (%s): " fmt, \ (sc)->mp->m_super->s_id, ##__VA_ARGS__) +#define xchk_xfile_ag_descr (sc, fmt, ...) \ + kasprintf(XCHK_GFP_FLAGS, "XFS (%s): AG 0x%x " fmt, \ + (sc)->mp->m_super->s_id, \ + (sc)->sa.pag ? (sc)->sa.pag->pag_agno : (sc)->sm->sm_agno, \ + ##__VA_ARGS__) +/* * Setting up a hook to wait for intents to drain is costly -- we have to take
fs/xfs/scrub/newbt.c +39 -6
84 lines not on this page · raw message
fs/xfs/scrub/newbt.h +6 -0
@@ -50,6 +50,9 @@ struct xrep_newbt {enum xfs_ag_resv_type resv; }; +#define for_each_xrep_newbt_reservation (xnr, resv, n) \ + list_for_each_entry_safe((resv), (n), &(xnr)->resv_list, list) +void xrep_newbt_init_bare (struct xrep_newbt *xnr,struct xfs_scrub *sc); void xrep_newbt_init_ag(struct xrep_newbt *xnr, struct xfs_scrub *sc, const struct xfs_owner_info *oinfo, xfs_fsblock_t alloc_hint,
@@ -57,10 +60,13 @@ void xrep_newbt_init_ag(struct xrep_newbt *xnr, struct xfs_scrub *sc,int xrep_newbt_init_inode (struct xrep_newbt *xnr,struct xfs_scrub *sc,int whichfork,const struct xfs_owner_info *oinfo);int xrep_newbt_alloc_blocks (struct xrep_newbt *xnr,uint64_t nr_blocks); +int xrep_newbt_add_extent (struct xrep_newbt *xnr,struct xfs_perag *pag, +xfs_agblock_t agbno,xfs_extlen_t len);void xrep_newbt_cancel (struct xrep_newbt *xnr);int xrep_newbt_commit (struct xrep_newbt *xnr);int xrep_newbt_claim_block (struct xfs_btree_cur *cur,struct xrep_newbt *xnr,union xfs_btree_ptr *ptr);int xrep_newbt_relog_autoreap (struct xrep_newbt *xnr); +unsigned int xrep_newbt_unused_blocks (struct xrep_newbt *xnr);#endif /* __XFS_SCRUB_NEWBT_H__ */
fs/xfs/scrub/repair.c +69 -0
72 lines not on this page · raw message
fs/xfs/scrub/repair.h +24 -0
@@ -53,6 +53,15 @@ int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp,void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +/* Repair setup functions */ +int xrep_setup_ag_allocbt (struct xfs_scrub *sc); + +void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa); + +/* Metadata revalidators */ + +int xrep_revalidate_allocbt (struct xfs_scrub *sc); +/* Metadata repairers */ int xrep_probe (struct xfs_scrub *sc);
@@ -60,6 +69,9 @@ int xrep_superblock(struct xfs_scrub *sc);int xrep_agf (struct xfs_scrub *sc);int xrep_agfl (struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc); +int xrep_allocbt (struct xfs_scrub *sc); + +int xrep_reinit_pagf (struct xfs_scrub *sc);#else
@@ -80,11 +92,23 @@ xrep_calc_ag_resblks( return 0; } +/* repair setup functions for no-repair */ +static inline int +xrep_setup_nothing ( +struct xfs_scrub *sc) +{ +return 0 ; +} +#define xrep_setup_ag_allocbt xrep_setup_nothing + +#define xrep_revalidate_allocbt (NULL) +#define xrep_probe xrep_notsupported#define xrep_superblock xrep_notsupported#define xrep_agf xrep_notsupported#define xrep_agfl xrep_notsupported#define xrep_agi xrep_notsupported +#define xrep_allocbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +9 -5
@@ -239,13 +239,15 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_PERAG, .setup = xchk_setup_ag_allocbt, .scrub = xchk_bnobt, - .repair = xrep_notsupported, + .repair = xrep_allocbt, + .repair_eval = xrep_revalidate_allocbt, }, [XFS_SCRUB_TYPE_CNTBT] = { /* cntbt */ .type = ST_PERAG, .setup = xchk_setup_ag_allocbt, .scrub = xchk_cntbt, - .repair = xrep_notsupported, + .repair = xrep_allocbt, + .repair_eval = xrep_revalidate_allocbt, }, [XFS_SCRUB_TYPE_INOBT] = { /* inobt */ .type = ST_PERAG,
@@ -529,7 +531,10 @@ xfs_scrub_metadata(/* Scrub for errors. */ check_start =xchk_stats_now (); - error = sc->ops->scrub (sc); +if ((sc->flags &XREP_ALREADY_FIXED ) && sc->ops->repair_eval !=NULL ) + error = sc->ops->repair_eval (sc); +else + error = sc->ops->scrub (sc); run.scrub_ns +=xchk_stats_elapsed_ns (check_start);if (error == -EDEADLOCK && !(sc->flags &XCHK_TRY_HARDER )) goto try_harder;
@@ -540,8 +545,7 @@ xfs_scrub_metadata(xchk_update_health (sc); -if ((sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) && - !(sc->flags &XREP_ALREADY_FIXED )) { +if (xchk_could_repair (sc)) {bool needs_fix =xchk_needs_repair (sc->sm);/* Userspace asked us to rebuild the structure regardless. */
fs/xfs/scrub/scrub.h +8 -0
@@ -35,6 +35,14 @@ struct xchk_meta_ops {/* Repair or optimize the metadata. */ int (*repair)(struct xfs_scrub *); +/* +* Re-scrub the metadata we repaired, in case there's extra work that +* we need to do to check our repair work. If this is NULL, we'll use +* the ->scrub function pointer, assuming that the regular scrub is +* sufficient. +*/ +int (*repair_eval)(struct xfs_scrub *sc); +/* Decide if we even have this piece of metadata. */ bool (*has)(struct xfs_mount *);
fs/xfs/scrub/trace.h +23 -1
@@ -1123,11 +1123,33 @@ DEFINE_EVENT(xrep_rmap_class, name, \ xfs_agblock_t agbno, xfs_extlen_t len, \ uint64_t owner, uint64_t offset, unsigned int flags), \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) -DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn); DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);DEFINE_REPAIR_RMAP_EVENT (xrep_rmap_extent_fn);DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_extent_fn); +TRACE_EVENT (xrep_abt_found, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + const struct xfs_alloc_rec_incore *rec), +TP_ARGS (mp, agno, rec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, startblock) +__field (xfs_extlen_t, blockcount) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->startblock = rec->ar_startblock; + __entry->blockcount = rec->ar_blockcount; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->startblock, + __entry->blockcount) +) + TRACE_EVENT(xrep_refcount_extent_fn, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, struct xfs_refcount_irec *irec),
fs/xfs/scrub/xfarray.h +22 -0
@@ -54,6 +54,28 @@ static inline int xfarray_append(struct xfarray *array, const void *ptr)uint64_t xfarray_length (struct xfarray *array);int xfarray_load_next (struct xfarray *array,xfarray_idx_t *idx,void *rec); +/* +* Iterate the non-null elements in a sparse xfarray. Callers should +* initialize *idx to XFARRAY_CURSOR_INIT before the first call; on return, it +* will be set to one more than the index of the record that was retrieved. +* Returns 1 if a record was retrieved, 0 if there weren't any more records, or +* a negative errno. +*/ +static inline int +xfarray_iter ( +struct xfarray *array, +xfarray_idx_t *idx, +void *rec) +{ +int ret =xfarray_load_next (array, idx, rec); + +if (ret == -ENODATA ) +return 0 ; +if (ret ==0 ) +return 1 ; +return ret; +} +/* Declarations for xfile array sort functionality. */ typedef cmp_func_t xfarray_cmp_fn ;
fs/xfs/xfs_extent_busy.c +13 -0
@@ -655,3 +655,16 @@ xfs_extent_busy_ag_cmp( diff = b1->bno - b2->bno;return diff; } + +/* Are there any busy extents in this AG? */ +bool +xfs_extent_busy_list_empty ( +struct xfs_perag *pag) +{ +bool res; + +spin_lock (&pag->pagb_lock); + res =RB_EMPTY_ROOT (&pag->pagb_tree); +spin_unlock (&pag->pagb_lock); +return res; +}
fs/xfs/xfs_extent_busy.h +2 -0
@@ -67,4 +67,6 @@ static inline void xfs_extent_busy_sort(struct list_head *list) list_sort(NULL, list, xfs_extent_busy_ag_cmp); } +bool xfs_extent_busy_list_empty (struct xfs_perag *pag); +#endif /* __XFS_EXTENT_BUSY_H__ */
PATCH 2/5 xfs: hide xfs_inode_is_allocated in scrub common code
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
This function is only used by online fsck, so let's move it there. In the next patch, we'll fix it to work properly and to require that the caller hold the AGI buffer locked. No major changes aside from adjusting the signature a bit.
--- fs/xfs/scrub/common.c | 37 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 2 ++ fs/xfs/scrub/ialloc.c | 3 +-- fs/xfs/xfs_icache.c | 38 -------------------------------------- fs/xfs/xfs_icache.h | 4 ---- 5 files changed, 40 insertions(+), 44 deletions(-)
fs/xfs/scrub/common.c +37 -0
@@ -1231,3 +1231,40 @@ xchk_fsgates_enable( sc->flags |= scrub_fsgates; } + +/* +* Decide if this is this a cached inode that's also allocated. +* +* Look up an inode by number in the given file system. If the inode is +* in cache and isn't in purgatory, return 1 if the inode is allocated +* and 0 if it is not. For all other cases (not in cache, being torn +* down, etc.), return a negative error code. +* +* The caller has to prevent inode allocation and freeing activity, +* presumably by locking the AGI buffer. This is to ensure that an +* inode cannot transition from allocated to freed until the caller is +* ready to allow that. If the inode is in an intermediate state (new, +* reclaimable, or being reclaimed), -EAGAIN will be returned; if the +* inode is not in the cache, -ENOENT will be returned. The caller must +* deal with these scenarios appropriately. +* +* This is a specialized use case for the online scrubber; if you're +* reading this, you probably want xfs_iget. +*/ +int +xchk_inode_is_allocated ( +struct xfs_scrub *sc, +xfs_ino_t ino, +bool *inuse) +{ +struct xfs_inode *ip; +int error; + + error =xfs_iget (sc->mp, sc->tp, ino,XFS_IGET_INCORE ,0 , &ip); +if (error) +return error; + + *inuse = !!(VFS_I (ip)->i_mode); +xfs_irele (ip); +return 0 ; +}
fs/xfs/scrub/common.h +2 -0
@@ -222,4 +222,6 @@ static inline bool xchk_need_intent_drain(struct xfs_scrub *sc)void xchk_fsgates_enable (struct xfs_scrub *sc,unsigned int scrub_fshooks); +int xchk_inode_is_allocated (struct xfs_scrub *sc,xfs_ino_t ino,bool *inuse); +#endif /* __XFS_SCRUB_COMMON_H__ */
fs/xfs/scrub/ialloc.c +1 -2
@@ -328,8 +328,7 @@ xchk_iallocbt_check_cluster_ifree( goto out; } - error =xfs_icache_inode_is_allocated (mp, bs->cur->bc_tp, fsino, - &ino_inuse); + error =xchk_inode_is_allocated (bs->sc, fsino, &ino_inuse);if (error == -ENODATA ) {/* Not cached, just read the disk buffer */ freemask_ok = irec_free ^ !!(dip->di_mode);
fs/xfs/xfs_icache.c +0 -38
@@ -802,44 +802,6 @@ xfs_iget(return error; } -/* -* "Is this a cached inode that's also allocated?" -* -* Look up an inode by number in the given file system. If the inode is -* in cache and isn't in purgatory, return 1 if the inode is allocated -* and 0 if it is not. For all other cases (not in cache, being torn -* down, etc.), return a negative error code. -* -* The caller has to prevent inode allocation and freeing activity, -* presumably by locking the AGI buffer. This is to ensure that an -* inode cannot transition from allocated to freed until the caller is -* ready to allow that. If the inode is in an intermediate state (new, -* reclaimable, or being reclaimed), -EAGAIN will be returned; if the -* inode is not in the cache, -ENOENT will be returned. The caller must -* deal with these scenarios appropriately. -* -* This is a specialized use case for the online scrubber; if you're -* reading this, you probably want xfs_iget. -*/ -int -xfs_icache_inode_is_allocated ( -struct xfs_mount *mp, -struct xfs_trans *tp, -xfs_ino_t ino, -bool *inuse) -{ -struct xfs_inode *ip; -int error; - - error =xfs_iget (mp, tp, ino,XFS_IGET_INCORE ,0 , &ip); -if (error) -return error; - - *inuse = !!(VFS_I (ip)->i_mode); -xfs_irele (ip); -return 0 ; -} -/* * Grab the inode for reclaim exclusively. *
fs/xfs/xfs_icache.h +0 -4
@@ -71,10 +71,6 @@ void xfs_inode_set_cowblocks_tag(struct xfs_inode *ip);void xfs_inode_clear_cowblocks_tag (struct xfs_inode *ip);void xfs_blockgc_worker (struct work_struct *work); - -int xfs_icache_inode_is_allocated (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_ino_t ino,bool *inuse); -void xfs_blockgc_stop (struct xfs_mount *mp);void xfs_blockgc_start (struct xfs_mount *mp);
Re: [PATCH 2/5] xfs: hide xfs_inode_is_allocated in scrub common code
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
This function is only used by online fsck, so let's move it there. In the next patch, we'll fix it to work properly and to require that the caller hold the AGI buffer locked. No major changes aside from adjusting the signature a bit.
Signed-off-by Darrick J. Wong <[email protected]>
LGTM
Signature · 2 lines
Dave Chinner [email protected]
PATCH 3/5 xfs: rewrite xchk_inode_is_allocated to work properly
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Back in the mists of time[1], I proposed this function to assist the inode btree scrubbers in checking the inode btree contents against the allocation state of the inode records. The original version performed a direct lookup in the inode cache and returned the allocation status if the cached inode hadn't been reused and wasn't in an intermediate state. Brian thought it would be better to use the usual iget/irele mechanisms, so that was changed for the final version.
Unfortunately, this hasn't aged well -- the IGET_INCORE flag only has one user and clutters up the regular iget path, which makes it hard to reason about how it actually works. Worse yet, the inode inactivation series silently broke it because iget won't return inodes that are anywhere in the inactivation machinery, even though the caller is already required to prevent inode allocation and freeing. Inodes in the inactivation machinery are still allocated, but the current code's interactions with the iget code prevent us from being able to say that.
Now that I understand the inode lifecycle better than I did in early 2017, I now realize that as long as the cached inode hasn't been reused and isn't actively being reclaimed, it's safe to access the i_mode field (with the AGI, rcu, and i_flags locks held), and we don't need to worry about the inode being freed out from under us.
Therefore, port the original version to modern code structure, which fixes the brokennes w.r.t. inactivation. In the next patch we'll remove IGET_INCORE since it's no longer necessary.
[1] https://lore.kernel.org/linux-xfs/[email protected]/
--- fs/xfs/scrub/common.c | 159 ++++++++++++++++++++++++++++++++++++++++++------- fs/xfs/scrub/common.h | 3 + fs/xfs/scrub/ialloc.c | 2 - fs/xfs/scrub/trace.h | 22 +++++++ 4 files changed, 162 insertions(+), 24 deletions(-)
fs/xfs/scrub/common.c +137 -22
@@ -1233,38 +1233,153 @@ xchk_fsgates_enable( }/* -* Decide if this is this a cached inode that's also allocated. +* Decide if this is this a cached inode that's also allocated. The caller +* must hold a reference to an AG and the AGI buffer lock to prevent inodes +* from being allocated or freed. * -* Look up an inode by number in the given file system. If the inode is -* in cache and isn't in purgatory, return 1 if the inode is allocated -* and 0 if it is not. For all other cases (not in cache, being torn -* down, etc.), return a negative error code. +* Look up an inode by number in the given file system. If the inode number +* is invalid, return -EINVAL. If the inode is not in cache, return -ENODATA. +* If the inode is being reclaimed, return -ENODATA because we know the inode +* cache cannot be updating the ondisk metadata. * -* The caller has to prevent inode allocation and freeing activity, -* presumably by locking the AGI buffer. This is to ensure that an -* inode cannot transition from allocated to freed until the caller is -* ready to allow that. If the inode is in an intermediate state (new, -* reclaimable, or being reclaimed), -EAGAIN will be returned; if the -* inode is not in the cache, -ENOENT will be returned. The caller must -* deal with these scenarios appropriately. -* -* This is a specialized use case for the online scrubber; if you're -* reading this, you probably want xfs_iget. +* Otherwise, the incore inode is the one we want, and it is either live, +* somewhere in the inactivation machinery, or reclaimable. The inode is +* allocated if i_mode is nonzero. In all three cases, the cached inode will +* be more up to date than the ondisk inode buffer, so we must use the incore +* i_mode. */ int xchk_inode_is_allocated (struct xfs_scrub *sc, -xfs_ino_t ino, +xfs_agino_t agino,bool *inuse) { +struct xfs_mount *mp = sc->mp; +struct xfs_perag *pag = sc->sa.pag; +xfs_ino_t ino;struct xfs_inode *ip;int error; - error =xfs_iget (sc->mp, sc->tp, ino,XFS_IGET_INCORE ,0 , &ip); -if (error) -return error; +/* caller must hold perag reference */ +if (pag ==NULL ) { +ASSERT (pag !=NULL ); +return -EINVAL ; + } - *inuse = !!(VFS_I (ip)->i_mode); -xfs_irele (ip); -return 0 ; +/* caller must have AGI buffer */ +if (sc->sa.agi_bp ==NULL ) { +ASSERT (sc->sa.agi_bp !=NULL ); +return -EINVAL ; + } + +/* reject inode numbers outside existing AGs */ + ino =XFS_AGINO_TO_INO (sc->mp, pag->pag_agno, agino); +if (!xfs_verify_ino (mp, ino)) +return -EINVAL ; + + error = -ENODATA ; +rcu_read_lock (); + ip =radix_tree_lookup (&pag->pag_ici_root, agino); +if (!ip) { +/* cache miss */ + goto out_rcu; + } + +/* +* If the inode number doesn't match, the incore inode got reused +* during an RCU grace period and the radix tree hasn't been updated. +* This isn't the inode we want. +*/ +spin_lock (&ip->i_flags_lock); +if (ip->i_ino != ino) + goto out_skip; + +trace_xchk_inode_is_allocated (ip); + +/* +* We have an incore inode that matches the inode we want, and the +* caller holds the perag structure and the AGI buffer. Let's check +* our assumptions below: +*/ + +#ifdef DEBUG +/* +* (1) If the incore inode is live (i.e. referenced from the dcache), +* it will not be INEW, nor will it be in the inactivation or reclaim +* machinery. The ondisk inode had better be allocated. This is the +* most trivial case. +*/ +if (!(ip->i_flags & (XFS_NEED_INACTIVE |XFS_INEW |XFS_IRECLAIMABLE | +XFS_INACTIVATING ))) { +/* live inode */ +ASSERT (VFS_I (ip)->i_mode !=0 ); + } + +/* +* If the incore inode is INEW, there are several possibilities: +* +* (2) For a file that is being created, note that we allocate the +* ondisk inode before allocating, initializing, and adding the incore +* inode to the radix tree. +* +* (3) If the incore inode is being recycled, the inode has to be +* allocated because we don't allow freed inodes to be recycled. +* Recycling doesn't touch i_mode. +*/ +if (ip->i_flags &XFS_INEW ) { +/* created on disk already or recycling */ +ASSERT (VFS_I (ip)->i_mode !=0 ); + } + +/* +* (4) If the inode is queued for inactivation (NEED_INACTIVE) but +* inactivation has not started (!INACTIVATING), it is still allocated. +*/ +if ((ip->i_flags &XFS_NEED_INACTIVE ) && + !(ip->i_flags &XFS_INACTIVATING )) { +/* definitely before difree */ +ASSERT (VFS_I (ip)->i_mode !=0 ); + } +#endif + +/* +* If the incore inode is undergoing inactivation (INACTIVATING), there +* are two possibilities: +* +* (5) It is before the point where it would get freed ondisk, in which +* case i_mode is still nonzero. +* +* (6) It has already been freed, in which case i_mode is zero. +* +* We don't take the ILOCK here, but difree and dialloc update the AGI, +* and we've taken the AGI buffer lock, which prevents that from +* happening. +*/ + +/* +* (7) Inodes undergoing inactivation (INACTIVATING) or queued for +* reclaim (IRECLAIMABLE) could be allocated or free. i_mode still +* reflects the ondisk state. +*/ + +/* +* (8) If the inode is in IFLUSHING, it's safe to query i_mode because +* the flush code uses i_mode to format the ondisk inode. +*/ + +/* +* (9) If the inode is in IRECLAIM and was reachable via the radix +* tree, it still has the same i_mode as it did before it entered +* reclaim. The inode object is still alive because we hold the RCU +* read lock. +*/ + + *inuse =VFS_I (ip)->i_mode !=0 ; + error =0 ; + +out_skip: +spin_unlock (&ip->i_flags_lock); +out_rcu: +rcu_read_unlock (); +return error; }
fs/xfs/scrub/common.h +2 -1
@@ -222,6 +222,7 @@ static inline bool xchk_need_intent_drain(struct xfs_scrub *sc)void xchk_fsgates_enable (struct xfs_scrub *sc,unsigned int scrub_fshooks); -int xchk_inode_is_allocated (struct xfs_scrub *sc,xfs_ino_t ino,bool *inuse); +int xchk_inode_is_allocated (struct xfs_scrub *sc,xfs_agino_t agino, +bool *inuse);#endif /* __XFS_SCRUB_COMMON_H__ */
fs/xfs/scrub/ialloc.c +1 -1
@@ -328,7 +328,7 @@ xchk_iallocbt_check_cluster_ifree( goto out; } - error =xchk_inode_is_allocated (bs->sc, fsino, &ino_inuse); + error =xchk_inode_is_allocated (bs->sc, agino, &ino_inuse);if (error == -ENODATA ) {/* Not cached, just read the disk buffer */ freemask_ok = irec_free ^ !!(dip->di_mode);
fs/xfs/scrub/trace.h +22 -0
@@ -640,6 +640,28 @@ TRACE_EVENT(xchk_iallocbt_check_cluster, __entry->cluster_ino) ) +TRACE_EVENT (xchk_inode_is_allocated, + TP_PROTO(struct xfs_inode *ip), +TP_ARGS (ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(unsigned long, iflags) +__field (umode_t, mode) + ), +TP_fast_assign ( + __entry->dev = VFS_I(ip)->i_sb->s_dev; + __entry->ino = ip->i_ino; + __entry->iflags = ip->i_flags; + __entry->mode = VFS_I(ip)->i_mode; + ), +TP_printk ("dev %d:%d ino 0x%llx iflags 0x%lx mode 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, + __entry->iflags, + __entry->mode) +); + TRACE_EVENT(xchk_fscounters_calc, TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree, uint64_t fdblocks, uint64_t delalloc),
Re: [PATCH 3/5] xfs: rewrite xchk_inode_is_allocated to work properly
Quoted 25 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Back in the mists of time[1], I proposed this function to assist the inode btree scrubbers in checking the inode btree contents against the allocation state of the inode records. The original version performed a direct lookup in the inode cache and returned the allocation status if the cached inode hadn't been reused and wasn't in an intermediate state. Brian thought it would be better to use the usual iget/irele mechanisms, so that was changed for the final version.
Unfortunately, this hasn't aged well -- the
IGET_INCOREflag only has one user and clutters up the regular iget path, which makes it hard to reason about how it actually works. Worse yet, the inode inactivation series silently broke it because iget won't return inodes that are anywhere in the inactivation machinery, even though the caller is already required to prevent inode allocation and freeing. Inodes in the inactivation machinery are still allocated, but the current code's interactions with the iget code prevent us from being able to say that.Now that I understand the inode lifecycle better than I did in early 2017, I now realize that as long as the cached inode hasn't been reused and isn't actively being reclaimed, it's safe to access the
i_modefield (with the AGI, rcu, andi_flagslocks held), and we don't need to worry about the inode being freed out from under us.
Quoted 7 lines
Therefore, port the original version to modern code structure, which fixes the brokennes w.r.t. inactivation. In the next patch we'll remove
IGET_INCOREsince it's no longer necessary.[1] https://lore.kernel.org/linux-xfs/[email protected]/
Signed-off-by Darrick J. Wong <[email protected]>
Lotsa comments, nothing triggered me this time through :)
Signature · 2 lines
Dave Chinner [email protected]
PATCH 4/5 xfs: repair inode btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the rmapbt to find inode chunks, query the chunks to compute hole and free masks, and with that information rebuild the inobt and finobt.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ialloc.c | 41 +- fs/xfs/libxfs/xfs_ialloc.h | 3 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/ialloc_repair.c | 882 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 59 +++ fs/xfs/scrub/repair.h | 17 + fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/scrub.h | 1 fs/xfs/scrub/trace.h | 68 ++- 10 files changed, 1030 insertions(+), 49 deletions(-) create mode 100644 fs/xfs/scrub/ialloc_repair.c
fs/xfs/Makefile +1 -0
@@ -182,6 +182,7 @@ ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ + ialloc_repair.o \ newbt.o \ reap.o \ repair.o \
fs/xfs/libxfs/xfs_ialloc.c +28 -13
63 lines not on this page · raw message
fs/xfs/libxfs/xfs_ialloc.h +3 -0
@@ -79,6 +79,7 @@ int xfs_inobt_lookup(struct xfs_btree_cur *cur, xfs_agino_t ino,*/ int xfs_inobt_get_rec (struct xfs_btree_cur *cur,xfs_inobt_rec_incore_t *rec,int *stat); +uint8_t xfs_inobt_rec_freecount (const struct xfs_inobt_rec_incore *irec);/* * Inode chunk initialisation routine
@@ -93,6 +94,8 @@ union xfs_btree_rec;void xfs_inobt_btrec_to_irec (struct xfs_mount *mp,const union xfs_btree_rec *rec,struct xfs_inobt_rec_incore *irec); +xfs_failaddr_t xfs_inobt_check_perag_irec (struct xfs_perag *pag, +const struct xfs_inobt_rec_incore *irec);xfs_failaddr_t xfs_inobt_check_irec (struct xfs_btree_cur *cur,const struct xfs_inobt_rec_incore *irec); int xfs_ialloc_has_inodes_at_extent(struct xfs_btree_cur *cur,
fs/xfs/scrub/common.c +1 -0
@@ -605,6 +605,7 @@ xchk_ag_free( struct xchk_ag *sa) {xchk_ag_btcur_free (sa); +xrep_reset_perag_resv (sc);if (sa->agf_bp) {xfs_trans_brelse (sc->tp, sa->agf_bp); sa->agf_bp =NULL ;
fs/xfs/scrub/ialloc_repair.c new file +882 -0
882 lines not on this page · raw message
fs/xfs/scrub/repair.c +59 -0
62 lines not on this page · raw message
fs/xfs/scrub/repair.h +17 -0
@@ -52,6 +52,7 @@ 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);void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc);
@@ -61,6 +62,7 @@ void xrep_ag_btcur_init(struct xfs_scrub *sc, struct xchk_ag *sa);/* Metadata revalidators */ int xrep_revalidate_allocbt (struct xfs_scrub *sc); +int xrep_revalidate_iallocbt (struct xfs_scrub *sc);/* Metadata repairers */
@@ -70,8 +72,10 @@ int xrep_agf(struct xfs_scrub *sc);int xrep_agfl (struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc); +int xrep_iallocbt (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc); +int xrep_reinit_pagi (struct xfs_scrub *sc);#else
@@ -92,6 +96,17 @@ xrep_calc_ag_resblks(return 0 ; } +static inline int +xrep_reset_perag_resv ( +struct xfs_scrub *sc) +{ +if (!(sc->flags &XREP_RESET_PERAG_RESV )) +return 0 ; + +ASSERT (0 ); +return -EOPNOTSUPP ; +} +/* repair setup functions for no-repair */ static inline int xrep_setup_nothing(
@@ -102,6 +117,7 @@ xrep_setup_nothing(#define xrep_setup_ag_allocbt xrep_setup_nothing#define xrep_revalidate_allocbt (NULL) +#define xrep_revalidate_iallocbt (NULL)#define xrep_probe xrep_notsupported#define xrep_superblock xrep_notsupported
@@ -109,6 +125,7 @@ xrep_setup_nothing(#define xrep_agfl xrep_notsupported#define xrep_agi xrep_notsupported#define xrep_allocbt xrep_notsupported +#define xrep_iallocbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +4 -2
@@ -253,14 +253,16 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_PERAG, .setup = xchk_setup_ag_iallocbt, .scrub = xchk_inobt, - .repair = xrep_notsupported, + .repair = xrep_iallocbt, + .repair_eval = xrep_revalidate_iallocbt, }, [XFS_SCRUB_TYPE_FINOBT] = { /* finobt */ .type = ST_PERAG, .setup = xchk_setup_ag_iallocbt, .scrub = xchk_finobt, .has = xfs_has_finobt, - .repair = xrep_notsupported, + .repair = xrep_iallocbt, + .repair_eval = xrep_revalidate_iallocbt, }, [XFS_SCRUB_TYPE_RMAPBT] = { /* rmapbt */ .type = ST_PERAG,
fs/xfs/scrub/scrub.h +1 -0
@@ -120,6 +120,7 @@ struct xfs_scrub {#define XCHK_TRY_HARDER (1U << 0)/* can't get resources, try again */ #define XCHK_FSGATES_DRAIN (1U << 2)/* defer ops draining enabled */ #define XCHK_NEED_DRAIN (1U << 3)/* scrub needs to drain defer ops */ +#define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */ /*
fs/xfs/scrub/trace.h +34 -34
92 lines not on this page · raw message
PATCH 5/5 xfs: repair refcount btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Reconstruct the refcount data from the rmap btree.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.h | 1 fs/xfs/libxfs/xfs_btree.c | 26 + fs/xfs/libxfs/xfs_btree.h | 2 fs/xfs/libxfs/xfs_refcount.c | 18 + fs/xfs/libxfs/xfs_refcount.h | 2 fs/xfs/libxfs/xfs_refcount_btree.c | 13 + fs/xfs/scrub/refcount_repair.c | 796 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 22 + 11 files changed, 867 insertions(+), 18 deletions(-) create mode 100644 fs/xfs/scrub/refcount_repair.c
fs/xfs/Makefile +1 -0
@@ -185,6 +185,7 @@ xfs-y += $(addprefix scrub/, \ ialloc_repair.o \ newbt.o \ reap.o \ + refcount_repair.o \ repair.o \ ) endif
fs/xfs/libxfs/xfs_ag.h +1 -0
@@ -87,6 +87,7 @@ struct xfs_perag {* verifiers while rebuilding the AG btrees. */ uint8_t pagf_alt_levels[XFS_BTNUM_AGF ]; +uint8_t pagf_alt_refcount_level;#endif spinlock_t pag_state_lock;
fs/xfs/libxfs/xfs_btree.c +26 -0
@@ -5212,3 +5212,29 @@ xfs_btree_destroy_cur_caches(void)xfs_rmapbt_destroy_cur_cache ();xfs_refcountbt_destroy_cur_cache (); } + +/* Move the btree cursor before the first record. */ +int +xfs_btree_goto_left_edge ( +struct xfs_btree_cur *cur) +{ +int stat =0 ; +int error; + +memset (&cur->bc_rec,0 ,sizeof (cur->bc_rec)); + error =xfs_btree_lookup (cur,XFS_LOOKUP_LE , &stat); +if (error) +return error; +if (!stat) +return 0 ; + + error =xfs_btree_decrement (cur,0 , &stat); +if (error) +return error; +if (stat !=0 ) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +return 0 ; +}
fs/xfs/libxfs/xfs_btree.h +2 -0
@@ -738,4 +738,6 @@ xfs_btree_alloc_cursor(int __init xfs_btree_init_cur_caches (void );void xfs_btree_destroy_cur_caches (void ); +int xfs_btree_goto_left_edge (struct xfs_btree_cur *cur); +#endif /* __XFS_BTREE_H__ */
fs/xfs/libxfs/xfs_refcount.c +12 -6
@@ -120,14 +120,11 @@ xfs_refcount_btrec_to_irec( irec->rc_refcount =be32_to_cpu (rec->refc.rc_refcount); } -/* Simple checks for refcount records. */ -xfs_failaddr_t -xfs_refcount_check_irec ( -struct xfs_btree_cur *cur, +inline xfs_failaddr_t +xfs_refcount_check_perag_irec ( +struct xfs_perag *pag,const struct xfs_refcount_irec *irec) { -struct xfs_perag *pag = cur->bc_ag.pag; -if (irec->rc_blockcount ==0 || irec->rc_blockcount >MAXREFCEXTLEN )return __this_address;
@@ -144,6 +141,15 @@ xfs_refcount_check_irec(return NULL ; } +/* Simple checks for refcount records. */ +xfs_failaddr_t +xfs_refcount_check_irec ( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *irec) +{ +return xfs_refcount_check_perag_irec (cur->bc_ag.pag, irec); +} + static inline int xfs_refcount_complain_bad_rec( struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_refcount.h +2 -0
@@ -117,6 +117,8 @@ extern int xfs_refcount_has_records(struct xfs_btree_cur *cur,union xfs_btree_rec ;extern void xfs_refcount_btrec_to_irec (const union xfs_btree_rec *rec,struct xfs_refcount_irec *irec); +xfs_failaddr_t xfs_refcount_check_perag_irec (struct xfs_perag *pag, +const struct xfs_refcount_irec *irec);xfs_failaddr_t xfs_refcount_check_irec (struct xfs_btree_cur *cur,const struct xfs_refcount_irec *irec); extern int xfs_refcount_insert(struct xfs_btree_cur *cur,
fs/xfs/libxfs/xfs_refcount_btree.c +12 -1
@@ -226,7 +226,18 @@ xfs_refcountbt_verify( level =be16_to_cpu (block->bb_level);if (pag &&xfs_perag_initialised_agf (pag)) { -if (level >= pag->pagf_refcount_level) +unsigned int maxlevel = pag->pagf_refcount_level; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Online repair could be rewriting the refcount btree, so +* we'll validate against the larger of either tree while this +* is going on. +*/ + maxlevel = max_t(unsigned int, maxlevel, + pag->pagf_alt_refcount_level); +#endif +if (level >= maxlevel)return __this_address; }else if (level >= mp->m_refc_maxlevels)return __this_address;
fs/xfs/scrub/refcount_repair.c new file +796 -0
796 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -73,6 +73,7 @@ int xrep_agfl(struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc); +int xrep_refcountbt (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -126,6 +127,7 @@ xrep_setup_nothing(#define xrep_agi xrep_notsupported#define xrep_allocbt xrep_notsupported#define xrep_iallocbt xrep_notsupported +#define xrep_refcountbt xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -276,7 +276,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .setup = xchk_setup_ag_refcountbt, .scrub = xchk_refcountbt, .has = xfs_has_reflink, - .repair = xrep_notsupported, + .repair = xrep_refcountbt, }, [XFS_SCRUB_TYPE_INODE] = { /* inode record */ .type = ST_INODE,
fs/xfs/scrub/trace.h +12 -10
@@ -1205,27 +1205,29 @@ TRACE_EVENT(xrep_ibt_found, __entry->freemask) ) -TRACE_EVENT (xrep_refcount_extent_fn, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, - struct xfs_refcount_irec *irec), -TP_ARGS (mp, agno, irec), +TRACE_EVENT (xrep_refc_found, + TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *rec), +TP_ARGS (pag, rec),TP_STRUCT__entry ( __field(dev_t, dev) __field(xfs_agnumber_t, agno) + __field(enum xfs_refc_domain, domain) __field(xfs_agblock_t, startblock) __field(xfs_extlen_t, blockcount)__field (xfs_nlink_t, refcount) ),TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->startblock = irec->rc_startblock; - __entry->blockcount = irec->rc_blockcount; - __entry->refcount = irec->rc_refcount; + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->agno = pag->pag_agno; + __entry->domain = rec->rc_domain; + __entry->startblock = rec->rc_startblock; + __entry->blockcount = rec->rc_blockcount; + __entry->refcount = rec->rc_refcount; ), -TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x refcount %u" , +TP_printk ("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->agno, +__print_symbolic (__entry->domain,XFS_REFC_DOMAIN_STRINGS ), __entry->startblock, __entry->blockcount, __entry->refcount)
cover xfs: fixes for the block mapping checker
In reply to Darrick J. WongHi all,
This series amends the file extent map checking code so that nonexistent cow/attr forks get the ENOENT return they're supposed to; and fixes some incorrect logic about the presence of a cow fork vs. reflink iflag.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-bmap-fixes
--- fs/xfs/scrub/bmap.c | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-)
PATCH 1/2 xfs: simplify returns in xchk_bmap
From: Darrick J. Wong <[email protected]>
Remove the pointless goto and return code in xchk_bmap, since it only serves to obscure what's going on in the function. Instead, return whichever error code is appropriate there. For nonexistent forks, this should have been ENOENT.
--- fs/xfs/scrub/bmap.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
fs/xfs/scrub/bmap.c +13 -13
@@ -841,7 +841,7 @@ xchk_bmap(/* Non-existent forks can be ignored. */ if (!ifp) - goto out; +return -ENOENT ; info.is_rt = whichfork ==XFS_DATA_FORK &&XFS_IS_REALTIME_INODE (ip); info.whichfork = whichfork;
@@ -853,7 +853,7 @@ xchk_bmap(/* No CoW forks on non-reflink inodes/filesystems. */ if (!xfs_is_reflink_inode (ip)) {xchk_ino_set_corrupt (sc, sc->ip->i_ino); - goto out; +return 0 ; }break ;case XFS_ATTR_FORK :
@@ -873,31 +873,31 @@ xchk_bmap(/* No mappings to check. */ if (whichfork ==XFS_COW_FORK )xchk_fblock_set_corrupt (sc, whichfork,0 ); - goto out; +return 0 ;case XFS_DINODE_FMT_EXTENTS :break ;case XFS_DINODE_FMT_BTREE :if (whichfork ==XFS_COW_FORK ) {xchk_fblock_set_corrupt (sc, whichfork,0 ); - goto out; +return 0 ; } error =xchk_bmap_btree (sc, whichfork, &info);if (error) - goto out; +return error;break ;default :xchk_fblock_set_corrupt (sc, whichfork,0 ); - goto out; +return 0 ; }if (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) - goto out; +return 0 ;/* Find the offset of the last extent in the mapping. */ error =xfs_bmap_last_offset (ip, &endoff, whichfork);if (!xchk_fblock_process_error (sc, whichfork,0 , &error)) - goto out; +return error;/* * Scrub extent records. We use a special iterator function here that
@@ -910,12 +910,12 @@ xchk_bmap(while (xchk_bmap_iext_iter (&info, &irec)) {if (xchk_should_terminate (sc, &error) || (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT )) - goto out; +return 0 ;if (irec.br_startoff >= endoff) {xchk_fblock_set_corrupt (sc, whichfork, irec.br_startoff); - goto out; +return 0 ; }if (isnullstartblock (irec.br_startblock))
@@ -928,10 +928,10 @@ xchk_bmap(if (xchk_bmap_want_check_rmaps (&info)) { error =xchk_bmap_check_rmaps (sc, whichfork);if (!xchk_fblock_xref_process_error (sc, whichfork,0 , &error)) - goto out; +return error; } -out: -return error; + +return 0 ; }/* Scrub an inode's data fork. */
PATCH 2/2 xfs: don't check reflink iflag state when checking cow fork
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Any inode on a reflink filesystem can have a cow fork, even if the inode does not have the reflink iflag set. This happens either because the inode once had the iflag set but does not now, because we don't free the incore cow fork until the icache deletes the inode; or because we're running in alwayscow mode.
Either way, we can collapse both of the xfs_is_reflink_inode calls into one, and change it to xfs_has_reflink, now that the bmap checker will return ENOENT if there is no pointer to the incore fork.
--- fs/xfs/scrub/bmap.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
fs/xfs/scrub/bmap.c +2 -5
@@ -850,8 +850,8 @@ xchk_bmap(switch (whichfork) {case XFS_COW_FORK : -/* No CoW forks on non-reflink inodes/filesystems. */ -if (!xfs_is_reflink_inode (ip)) { +/* No CoW forks on non-reflink filesystems. */ +if (!xfs_has_reflink (mp)) {xchk_ino_set_corrupt (sc, sc->ip->i_ino);return 0 ; }
@@ -955,8 +955,5 @@ intxchk_bmap_cow ( struct xfs_scrub *sc) { -if (!xfs_is_reflink_inode (sc->ip)) -return -ENOENT ; -return xchk_bmap (sc,XFS_COW_FORK ); }
Re: [PATCHSET v26.0 0/2] xfs: fixes for the block mapping checker
In reply to Darrick J. WongQuoted 5 lines · Darrick J. Wong
Hi all,
This series amends the file extent map checking code so that nonexistent cow/attr forks get the ENOENT return they're supposed to; and fixes some incorrect logic about the presence of a cow fork vs. reflink iflag.
Looks good.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: online repair of inodes and forks
In reply to Darrick J. WongHi all,
In this series, online repair gains the ability to repair inode records. To do this, we must repair the ondisk inode and fork information enough to pass the iget verifiers and hence make the inode igettable again. Once that's done, we can perform higher level repairs on the incore inode. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-inodes
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-inodes
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-inodes
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_attr_leaf.c | 32 - fs/xfs/libxfs/xfs_attr_leaf.h | 2 fs/xfs/libxfs/xfs_bmap.c | 22 fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_dir2_priv.h | 2 fs/xfs/libxfs/xfs_dir2_sf.c | 29 - fs/xfs/libxfs/xfs_format.h | 3 fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/libxfs/xfs_symlink_remote.c | 21 fs/xfs/scrub/alloc.c | 2 fs/xfs/scrub/bmap.c | 4 fs/xfs/scrub/common.c | 26 + fs/xfs/scrub/common.h | 8 fs/xfs/scrub/dir.c | 21 fs/xfs/scrub/inode.c | 14 fs/xfs/scrub/inode_repair.c | 1607 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/parent.c | 10 fs/xfs/scrub/repair.c | 47 + fs/xfs/scrub/repair.h | 28 + fs/xfs/scrub/rtbitmap.c | 4 fs/xfs/scrub/rtsummary.c | 4 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 174 ++++ 24 files changed, 2023 insertions(+), 43 deletions(-) create mode 100644 fs/xfs/scrub/inode_repair.c
PATCH 1/6 xfs: disable online repair quota helpers when quota not enabled
From: Darrick J. Wong <[email protected]>
Don't compile the quota helper functions if quota isn't being built into the XFS module.
--- fs/xfs/scrub/repair.c | 2 ++ fs/xfs/scrub/repair.h | 9 +++++++++ 2 files changed, 11 insertions(+)
fs/xfs/scrub/repair.c +2 -0
@@ -683,6 +683,7 @@ xrep_find_ag_btree_roots(return error; } +#ifdef CONFIG_XFS_QUOTA /* Force a quotacheck the next time we mount. */ void xrep_force_quotacheck(
@@ -744,6 +745,7 @@ xrep_ino_dqattach( return error; } +#endif /* CONFIG_XFS_QUOTA */ /* Initialize all the btree cursors for an AG repair. */ void
fs/xfs/scrub/repair.h +9 -0
@@ -50,8 +50,15 @@ struct xrep_find_ag_btree {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); + +#ifdef CONFIG_XFS_QUOTA void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc); +#else +# define xrep_force_quotacheck (sc, type) ((void)0) +# define xrep_ino_dqattach (sc) (0) +#endif /* CONFIG_XFS_QUOTA */ +int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */
@@ -80,6 +87,8 @@ int xrep_reinit_pagi(struct xfs_scrub *sc);#else +#define xrep_ino_dqattach (sc) (0) + static inline int xrep_attempt( struct xfs_scrub *sc,
PATCH 2/6 xfs: try to attach dquots to files before repairing them
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Inode resource usage is tracked in the quota metadata. Repairing a file might change the resources used by that file, which means that we need to attach dquots to the file that we're examining before accessing anything in the file protected by the ILOCK.
However, there's a twist: a dquot cache miss requires the dquot to be read in from the quota file, during which we drop the ILOCK on the file being examined. This means that we *must* try to attach the dquots before taking the ILOCK.
Therefore, dquots must be attached to files in the scrub setup function. If doing so yields corruption errors (or unknown dquot errors), we instead clear the quotachecked status, which will cause a quotacheck on next mount. A future series will make this trigger live quotacheck.
While we're here, change the xrep_ino_dqattach function to use the unlocked dqattach functions so that we avoid cycling the ILOCK if the inode already has dquots attached. This makes the naming and locking requirements consistent with the rest of the filesystem.
--- fs/xfs/scrub/bmap.c | 4 ++++ fs/xfs/scrub/common.c | 25 +++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 ++++++ fs/xfs/scrub/inode.c | 4 ++++ fs/xfs/scrub/repair.c | 13 ++++++++----- fs/xfs/scrub/rtbitmap.c | 4 ++++ fs/xfs/scrub/rtsummary.c | 4 ++++ 7 files changed, 55 insertions(+), 5 deletions(-)
fs/xfs/scrub/bmap.c +4 -0
@@ -78,6 +78,10 @@ xchk_setup_inode_bmap(if (error) goto out; + error =xchk_ino_dqattach (sc); +if (error) + goto out; +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode */
fs/xfs/scrub/common.c +25 -0
@@ -818,6 +818,26 @@ xchk_iget_agi(return 0 ; } +#ifdef CONFIG_XFS_QUOTA +/* +* Try to attach dquots to this inode if we think we might want to repair it. +* Callers must not hold any ILOCKs. If the dquots are broken and cannot be +* attached, a quotacheck will be scheduled. +*/ +int +xchk_ino_dqattach ( +struct xfs_scrub *sc) +{ +ASSERT (sc->tp !=NULL ); +ASSERT (sc->ip !=NULL ); + +if (!xchk_could_repair (sc)) +return 0 ; + +return xrep_ino_dqattach (sc); +} +#endif +/* Install an inode that we opened by handle for scrubbing. */ int xchk_install_handle_inode(
@@ -1029,6 +1049,11 @@ xchk_setup_inode_contents( error =xchk_trans_alloc (sc, resblks);if (error) goto out; + + error =xchk_ino_dqattach (sc); +if (error) + goto out; +xchk_ilock (sc,XFS_ILOCK_EXCL ); out:/* scrub teardown will unlock and release the inode for us */
fs/xfs/scrub/common.h +6 -0
@@ -103,9 +103,15 @@ xchk_setup_rtsummary(struct xfs_scrub *sc) }#endif #ifdef CONFIG_XFS_QUOTA +int xchk_ino_dqattach (struct xfs_scrub *sc);int xchk_setup_quota (struct xfs_scrub *sc);#else static inline int +xchk_ino_dqattach (struct xfs_scrub *sc) +{ +return 0 ; +} +static inline int xchk_setup_quota (struct xfs_scrub *sc) {return -ENOENT ;
fs/xfs/scrub/inode.c +4 -0
@@ -38,6 +38,10 @@ xchk_prepare_iscrub(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +xchk_ilock (sc,XFS_ILOCK_EXCL );return 0 ; }
fs/xfs/scrub/repair.c +8 -5
@@ -710,10 +710,10 @@ xrep_force_quotacheck(* * 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. +* because we're already in transaction context. 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(
@@ -721,7 +721,10 @@ xrep_ino_dqattach( {int error; - error =xfs_qm_dqattach_locked (sc->ip, false); +ASSERT (sc->tp !=NULL ); +ASSERT (sc->ip !=NULL ); + + error =xfs_qm_dqattach (sc->ip);switch (error) {case -EFSBADCRC :case -EFSCORRUPTED :
fs/xfs/scrub/rtbitmap.c +4 -0
@@ -32,6 +32,10 @@ xchk_setup_rtbitmap(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP );return 0 ; }
fs/xfs/scrub/rtsummary.c +4 -0
@@ -63,6 +63,10 @@ xchk_setup_rtsummary(if (error)return error; + error =xchk_ino_dqattach (sc); +if (error) +return error; +/* * Locking order requires us to take the rtbitmap first. We must be * careful to unlock it ourselves when we are done with the rtbitmap
PATCH 3/6 xfs: repair inode records
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If an inode is so badly damaged that it cannot be loaded into the cache, fix the ondisk metadata and try again. If there /is/ a cached inode, fix any problems and apply any optimizations that can be solved incore.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_format.h | 3 fs/xfs/scrub/alloc.c | 2 fs/xfs/scrub/inode.c | 10 + fs/xfs/scrub/inode_repair.c | 763 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 32 ++ fs/xfs/scrub/repair.h | 19 + fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 129 +++++++ 9 files changed, 958 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/inode_repair.c
fs/xfs/Makefile +1 -0
@@ -183,6 +183,7 @@ xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ ialloc_repair.o \ + inode_repair.o \ newbt.o \ reap.o \ refcount_repair.o \
fs/xfs/libxfs/xfs_format.h +2 -1
@@ -996,7 +996,8 @@ enum xfs_dinode_fmt {#define XFS_DFORK_APTR (dip) \ (XFS_DFORK_DPTR(dip) + XFS_DFORK_BOFF(dip))#define XFS_DFORK_PTR (dip,w) \ - ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip)) + ((void *)((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : \ + XFS_DFORK_APTR(dip)))#define XFS_DFORK_FORMAT (dip,w) \ ((w) == XFS_DATA_FORK ? \
fs/xfs/scrub/alloc.c +2 -0
@@ -9,6 +9,8 @@#include "xfs_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h" +#include "xfs_log_format.h" +#include "xfs_trans.h" #include "xfs_btree.h" #include "xfs_alloc.h" #include "xfs_rmap.h"
fs/xfs/scrub/inode.c +9 -1
@@ -24,6 +24,7 @@#include "scrub/common.h" #include "scrub/btree.h" #include "scrub/trace.h" +#include "scrub/repair.h" /* Prepare the attached inode for scrubbing. */ static inline int
@@ -184,8 +185,11 @@ xchk_setup_inode(* saying the inode is allocated and the icache being unable to load * the inode until we can flag the corruption in xchk_inode. The * scrub function has to note the corruption, since we're not really -* supposed to do that from the setup function. +* supposed to do that from the setup function. Save the mapping to +* make repairs to the ondisk inode buffer. */ +if (xchk_could_repair (sc)) +xrep_setup_inode (sc, &imap);return 0 ; out_cancel:
@@ -341,6 +345,10 @@ xchk_inode_flags2(if (xfs_dinode_has_bigtime (dip) && !xfs_has_bigtime (mp)) goto bad; +/* no large extent counts without the filesystem feature */ +if ((flags2 &XFS_DIFLAG2_NREXT64 ) && !xfs_has_large_extent_counts (mp)) + goto bad; +return ; bad:xchk_ino_set_corrupt (sc, ino);
fs/xfs/scrub/inode_repair.c new file +763 -0
763 lines not on this page · raw message
fs/xfs/scrub/repair.c +32 -0
@@ -750,6 +750,38 @@ xrep_ino_dqattach( }#endif /* CONFIG_XFS_QUOTA */ +/* +* Ensure that the inode being repaired is ready to handle a certain number of +* extents, or return EFSCORRUPTED. Caller must hold the ILOCK of the inode +* being repaired and have joined it to the scrub transaction. +*/ +int +xrep_ino_ensure_extent_count ( +struct xfs_scrub *sc, +int whichfork, +xfs_extnum_t nextents) +{ +xfs_extnum_t max_extents; +bool large_extcount; + + large_extcount =xfs_inode_has_large_extent_counts (sc->ip); + max_extents =xfs_iext_max_nextents (large_extcount, whichfork); +if (nextents <= max_extents) +return 0 ; +if (large_extcount) +return -EFSCORRUPTED ; +if (!xfs_has_large_extent_counts (sc->mp)) +return -EFSCORRUPTED ; + + max_extents =xfs_iext_max_nextents (true, whichfork); +if (nextents > max_extents) +return -EFSCORRUPTED ; + + sc->ip->i_diflags2 |=XFS_DIFLAG2_NREXT64 ; +xfs_trans_log_inode (sc->tp, sc->ip,XFS_ILOG_CORE ); +return 0 ; +} +/* Initialize all the btree cursors for an AG repair. */ void xrep_ag_btcur_init(
fs/xfs/scrub/repair.h +19 -0
@@ -28,6 +28,16 @@ bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks, enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc); +static inline int +xrep_trans_commit ( +struct xfs_scrub *sc) +{ +int error =xfs_trans_commit (sc->tp); + + sc->tp =NULL ; +return error; +} +struct xbitmap ;struct xagb_bitmap ;
@@ -59,11 +69,16 @@ int xrep_ino_dqattach(struct xfs_scrub *sc);# define xrep_ino_dqattach (sc) (0)#endif /* CONFIG_XFS_QUOTA */ +int xrep_ino_ensure_extent_count (struct xfs_scrub *sc,int whichfork, +xfs_extnum_t nextents);int xrep_reset_perag_resv (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc); +struct xfs_imap ; +int xrep_setup_inode (struct xfs_scrub *sc,struct xfs_imap *imap); +void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa);/* Metadata revalidators */
@@ -81,6 +96,7 @@ int xrep_agi(struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc);int xrep_refcountbt (struct xfs_scrub *sc); +int xrep_inode (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -126,6 +142,8 @@ xrep_setup_nothing( }#define xrep_setup_ag_allocbt xrep_setup_nothing +#define xrep_setup_inode (sc, imap) ((void)0) +#define xrep_revalidate_allocbt (NULL)#define xrep_revalidate_iallocbt (NULL)
@@ -137,6 +155,7 @@ xrep_setup_nothing(#define xrep_allocbt xrep_notsupported#define xrep_iallocbt xrep_notsupported#define xrep_refcountbt xrep_notsupported +#define xrep_inode xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -282,7 +282,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode, .scrub = xchk_inode, - .repair = xrep_notsupported, + .repair = xrep_inode, }, [XFS_SCRUB_TYPE_BMBTD] = { /* inode data fork */ .type = ST_INODE,
fs/xfs/scrub/trace.h +129 -0
135 lines not on this page · raw message
Re: [PATCH 3/6] xfs: repair inode records
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
If an inode is so badly damaged that it cannot be loaded into the cache, fix the ondisk metadata and try again. If there /is/ a cached inode, fix any problems and apply any optimizations that can be solved incore.
Signed-off-by Darrick J. Wong <[email protected]>
.....
Quoted 46 lines
fs/xfs/scrub/inode_repair.c new file +40
-0@@ -0,0 +1,763 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (C) 2018-2023 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#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_defer.h" +#include "xfs_btree.h" +#include "xfs_bit.h" +#include "xfs_log_format.h" +#include "xfs_trans.h" +#include "xfs_sb.h" +#include "xfs_inode.h" +#include "xfs_icache.h" +#include "xfs_inode_buf.h" +#include "xfs_inode_fork.h" +#include "xfs_ialloc.h" +#include "xfs_da_format.h" +#include "xfs_reflink.h" +#include "xfs_rmap.h" +#include "xfs_bmap.h" +#include "xfs_bmap_util.h" +#include "xfs_dir2.h" +#include "xfs_dir2_priv.h" +#include "xfs_quota_defs.h" +#include "xfs_quota.h" +#include "xfs_ag.h" +#include "scrub/xfs_scrub.h" +#include "scrub/scrub.h" +#include "scrub/common.h" +#include "scrub/btree.h" +#include "scrub/trace.h" +#include "scrub/repair.h" + +/*
fs/xfs/scrub/inode_repair.c line 50
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+* Inode Repair +* +* Roughly speaking, inode problems can be classified based on whether or not +* they trip the dinode verifiers. If those trip, then we won't be able to +* _iget ourselves the inode. +* +* Therefore, the xrep_dinode_* functions fix anything that will cause the +* inode buffer verifier or the dinode verifier. The xrep_inode_* functions +* fix things on live incore inodes. +*/
I'd like to see some of the decisions made documented here. Stuff like:
- "unknown di_mode converts inode to a regular file only root can read" needs to be clearly documented because that "regular file" that results might not actually contain user data....
- what we do with setuid/setgid on repaired inodes
- things we just trash and leave to other parts of repair to clean up stuff we leak or trash...
Quoted 15 lines
fs/xfs/scrub/inode_repair.c new file +15
-0+/* Fix any conflicting flags that the verifiers complain about. */ +STATIC void +xrep_dinode_flags ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +uint64_t flags2; +uint16_t mode; +uint16_t flags; + +trace_xrep_dinode_flags (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + flags =be16_to_cpu (dip->di_flags);
fs/xfs/scrub/inode_repair.c line 209
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+ flags2 =be64_to_cpu (dip->di_flags2); + +if (xfs_has_reflink (mp) &&S_ISREG (mode)) + flags2 |=XFS_DIFLAG2_REFLINK ; +else + flags2 &= ~(XFS_DIFLAG2_REFLINK |XFS_DIFLAG2_COWEXTSIZE ); +if (flags &XFS_DIFLAG_REALTIME ) + flags2 &= ~XFS_DIFLAG2_REFLINK ; +if (flags2 &XFS_DIFLAG2_REFLINK ) + flags2 &= ~XFS_DIFLAG2_DAX ;
IIRC, reflink and DAX co-exist just fine now....
Quoted 19 lines
fs/xfs/scrub/inode_repair.c new file +19
-0+if (!xfs_has_bigtime (mp)) + flags2 &= ~XFS_DIFLAG2_BIGTIME ; +if (!xfs_has_large_extent_counts (mp)) + flags2 &= ~XFS_DIFLAG2_NREXT64 ; +if (flags2 &XFS_DIFLAG2_NREXT64 ) + dip->di_nrext64_pad =0 ; +else if (dip->di_version >=3 ) + dip->di_v3_pad =0 ; + dip->di_flags =cpu_to_be16 (flags); + dip->di_flags2 =cpu_to_be64 (flags2); +} + +/* +* Blow out symlink; now it points to the current dir. We don't have to worry +* about incore state because this inode is failing the verifiers. +*/ +STATIC void +xrep_dinode_zap_symlink( + struct xfs_scrub *sc,
fs/xfs/scrub/inode_repair.c line 238
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+ struct xfs_dinode *dip) +{ +char *p; + +trace_xrep_dinode_zap_symlink (sc, dip); + + dip->di_format =XFS_DINODE_FMT_LOCAL ; + dip->di_size =cpu_to_be64 (1 ); + p =XFS_DFORK_PTR (dip,XFS_DATA_FORK ); + *p ='.' ;
What if this was in extent form? Didn't we just leak an extent?
Quoted 17 lines
fs/xfs/scrub/inode_repair.c new file +17
-0+} + +/* +* Blow out dir, make it point to the root. In the future repair will +* reconstruct this directory for us. Note that there's no in-core directory +* inode because the sf verifier tripped, so we don't have to worry about the +* dentry cache. +*/ +STATIC void +xrep_dinode_zap_dir ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +struct xfs_dir2_sf_hdr *sfp; +int i8count; +
fs/xfs/scrub/inode_repair.c line 265
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+trace_xrep_dinode_zap_dir (sc, dip); + + dip->di_format =XFS_DINODE_FMT_LOCAL ; + i8count = mp->m_sb.sb_rootino >XFS_DIR2_MAX_SHORT_INUM ; + sfp =XFS_DFORK_PTR (dip,XFS_DATA_FORK ); + sfp->count =0 ; + sfp->i8count = i8count; +xfs_dir2_sf_put_parent_ino (sfp, mp->m_sb.sb_rootino); + dip->di_size =cpu_to_be64 (xfs_dir2_sf_hdr_size (i8count)); +}
Same here?
Quoted 101 lines
fs/xfs/scrub/inode_repair.c new file +101
-0+ +/* Make sure we don't have a garbage file size. */ +STATIC void +xrep_dinode_size ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +uint64_t size; +uint16_t mode; + +trace_xrep_dinode_size (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + size =be64_to_cpu (dip->di_size); +switch (mode &S_IFMT ) { +case S_IFIFO : +case S_IFCHR : +case S_IFBLK : +case S_IFSOCK : +/* di_size can't be nonzero for special files */ + dip->di_size =0 ; +break ; +case S_IFREG : +/* Regular files can't be larger than 2^63-1 bytes. */ + dip->di_size =cpu_to_be64 (size & ~(1ULL <<63 )); +break ; +case S_IFLNK : +/* +* Truncate ridiculously oversized symlinks. If the size is +* zero, reset it to point to the current directory. Both of +* these conditions trigger dinode verifier errors, so there +* is no in-core state to reset. +*/ +if (size >XFS_SYMLINK_MAXLEN ) + dip->di_size =cpu_to_be64 (XFS_SYMLINK_MAXLEN ); +else if (size ==0 ) +xrep_dinode_zap_symlink (sc, dip); +break ; +case S_IFDIR : +/* +* Directories can't have a size larger than 32G. If the size +* is zero, reset it to an empty directory. Both of these +* conditions trigger dinode verifier errors, so there is no +* in-core state to reset. +*/ +if (size >XFS_DIR2_SPACE_SIZE ) + dip->di_size =cpu_to_be64 (XFS_DIR2_SPACE_SIZE ); +else if (size ==0 ) +xrep_dinode_zap_dir (sc, dip); +break ; + } +} + +/* Fix extent size hints. */ +STATIC void +xrep_dinode_extsize_hints ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +uint64_t flags2; +uint16_t flags; +uint16_t mode; +xfs_failaddr_t fa; + +trace_xrep_dinode_extsize_hints (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + flags =be16_to_cpu (dip->di_flags); + flags2 =be64_to_cpu (dip->di_flags2); + + fa =xfs_inode_validate_extsize (mp,be32_to_cpu (dip->di_extsize), + mode, flags); +if (fa) { + dip->di_extsize =0 ; + dip->di_flags &= ~cpu_to_be16 (XFS_DIFLAG_EXTSIZE | +XFS_DIFLAG_EXTSZINHERIT ); + } + +if (dip->di_version <3 ) +return ; + + fa =xfs_inode_validate_cowextsize (mp,be32_to_cpu (dip->di_cowextsize), + mode, flags, flags2); +if (fa) { + dip->di_cowextsize =0 ; + dip->di_flags2 &= ~cpu_to_be64 (XFS_DIFLAG2_COWEXTSIZE ); + } +} + +/* Inode didn't pass verifiers, so fix the raw buffer and retry iget. */ +STATIC int +xrep_dinode_core ( +struct xrep_inode *ri) +{ +struct xfs_scrub *sc = ri->sc; +struct xfs_buf *bp; +struct xfs_dinode *dip; +xfs_ino_t ino = sc->sm->sm_ino; +int error; +
fs/xfs/scrub/inode_repair.c line 376
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+/* Read the inode cluster buffer. */ + error =xfs_trans_read_buf (sc->mp, sc->tp, sc->mp->m_ddev_targp, + ri->imap.im_blkno, ri->imap.im_len,XBF_UNMAPPED , &bp, +NULL ); +if (error) +return error; + +/* Make sure we can pass the inode buffer verifier. */ +xrep_dinode_buf (sc, bp); + bp->b_ops = &xfs_inode_buf_ops;
Hmmmmm. Don't we at least need to check this looks like an inode cluster buffer first?
....
Quoted 11 lines
fs/xfs/scrub/inode_repair.c new file +11
-0+ +/* Check for invalid uid/gid/prid. */ +STATIC void +xrep_inode_ids ( +struct xfs_scrub *sc) +{ +trace_xrep_inode_ids (sc); + +if (i_uid_read (VFS_I (sc->ip)) ==-1U ) { +i_uid_write (VFS_I (sc->ip),0 ); +VFS_I (sc->ip)->i_mode &= ~(S_ISUID |S_ISGID );
fs/xfs/scrub/inode_repair.c line 523
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+if (XFS_IS_UQUOTA_ON (sc->mp)) +xrep_force_quotacheck (sc,XFS_DQTYPE_USER ); + } + +if (i_gid_read (VFS_I (sc->ip)) ==-1U ) { +i_gid_write (VFS_I (sc->ip),0 ); +VFS_I (sc->ip)->i_mode &= ~(S_ISUID |S_ISGID ); +if (XFS_IS_GQUOTA_ON (sc->mp)) +xrep_force_quotacheck (sc,XFS_DQTYPE_GROUP ); + }
IF we are repairing an inode that has setuid or setgid, I think we should just strip those permissions regardless of whether the uid/gid are valid. It think it's better to be cautious here rather than leave setuid on a file that we reconstructed but have no real way of knowing that data in the file is untainted.
Quoted 15 lines
fs/xfs/scrub/inode_repair.c new file +15
-0+ +if (sc->ip->i_projid ==-1U ) { + sc->ip->i_projid =0 ; +if (XFS_IS_PQUOTA_ON (sc->mp)) +xrep_force_quotacheck (sc,XFS_DQTYPE_PROJ ); + } +} + +static inline void +xrep_clamp_nsec ( +struct timespec64 *ts) +{ + ts->tv_nsec =clamp_t (long, ts->tv_nsec,0 ,NSEC_PER_SEC ); +} +
fs/xfs/scrub/inode_repair.c line 548
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+/* Nanosecond counters can't have more than 1 billion. */ +STATIC void +xrep_inode_timestamps ( +struct xfs_inode *ip) +{ +xrep_clamp_nsec (&VFS_I (ip)->i_atime); +xrep_clamp_nsec (&VFS_I (ip)->i_mtime); +xrep_clamp_nsec (&VFS_I (ip)->i_ctime); +xrep_clamp_nsec (&ip->i_crtime); +}
Should we be clamping the entire timestamp within the valid filesystem timestamp range here?
Quoted 9 lines
fs/xfs/scrub/inode_repair.c new file +9
-0+ +/* Fix inode flags that don't make sense together. */ +STATIC void +xrep_inode_flags ( +struct xfs_scrub *sc) +{ +uint16_t mode; + +trace_xrep_inode_flags (sc);
....
fs/xfs/scrub/inode_repair.c line 610
Quoted 3 lines
fs/xfs/scrub/inode_repair.c new file +3
-0+/* No mixing reflink and DAX yet. */ +if (sc->ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) + sc->ip->i_diflags2 &= ~XFS_DIFLAG2_DAX ;
This can go, too...
.....
Quoted 16 lines
fs/xfs/scrub/inode_repair.c new file +12
-0@@ -750,6 +750,38 @@ xrep_ino_dqattach( }#endif /* CONFIG_XFS_QUOTA */ +/* +* Ensure that the inode being repaired is ready to handle a certain number of +* extents, or return EFSCORRUPTED. Caller must hold the ILOCK of the inode +* being repaired and have joined it to the scrub transaction. +*/ +int +xrep_ino_ensure_extent_count ( +struct xfs_scrub *sc, +int whichfork, +xfs_extnum_t nextents) +{ +xfs_extnum_t max_extents;
fs/xfs/scrub/inode_repair.c xrep_ino_dqattach( · line 774
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+bool large_extcount; + + large_extcount =xfs_inode_has_large_extent_counts (sc->ip); + max_extents =xfs_iext_max_nextents (large_extcount, whichfork); +if (nextents <= max_extents) +return 0 ; +if (large_extcount) +return -EFSCORRUPTED ; +if (!xfs_has_large_extent_counts (sc->mp)) +return -EFSCORRUPTED ;
This logic took me a bit of peering at to work out. large_extcount says whether the inode has the large extcount flag set, which is different to whether the superblock has large extcoutn flag set.
Can change large_extcount to inode_has_nrext64 or something like that just so it's really clear that there are two different flags being checked here?
Quoted 7 lines
fs/xfs/scrub/repair.h +0
-0@@ -28,6 +28,16 @@ bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks, enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc);
fs/xfs/scrub/repair.h bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks, · line 39
Quoted 10 lines
fs/xfs/scrub/repair.h +9
-0+static inline int +xrep_trans_commit ( +struct xfs_scrub *sc) +{ +int error =xfs_trans_commit (sc->tp); + + sc->tp =NULL ; +return error; +}
That's .... interesting formatting. I'd be happy with using standard linux format for this:
static inline int xrep_trans_commit(struct xfs_scrub *sc)
{
int error = xfs_trans_commit(sc->tp);
sc->tp = NULL;
return error;
}But that's just personal preference....
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 3/6] xfs: repair inode records
Quoted 69 lines · Dave Chinner
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
If an inode is so badly damaged that it cannot be loaded into the cache, fix the ondisk metadata and try again. If there /is/ a cached inode, fix any problems and apply any optimizations that can be solved incore.
Signed-off-by Darrick J. Wong <[email protected]>.....
Quoted 46 lines
fs/xfs/scrub/inode_repair.c new file +40
-0@@ -0,0 +1,763 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (C) 2018-2023 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#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_defer.h" +#include "xfs_btree.h" +#include "xfs_bit.h" +#include "xfs_log_format.h" +#include "xfs_trans.h" +#include "xfs_sb.h" +#include "xfs_inode.h" +#include "xfs_icache.h" +#include "xfs_inode_buf.h" +#include "xfs_inode_fork.h" +#include "xfs_ialloc.h" +#include "xfs_da_format.h" +#include "xfs_reflink.h" +#include "xfs_rmap.h" +#include "xfs_bmap.h" +#include "xfs_bmap_util.h" +#include "xfs_dir2.h" +#include "xfs_dir2_priv.h" +#include "xfs_quota_defs.h" +#include "xfs_quota.h" +#include "xfs_ag.h" +#include "scrub/xfs_scrub.h" +#include "scrub/scrub.h" +#include "scrub/common.h" +#include "scrub/btree.h" +#include "scrub/trace.h" +#include "scrub/repair.h" + +/* fs/xfs/scrub/inode_repair.c line 50
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+* Inode Repair +* +* Roughly speaking, inode problems can be classified based on whether or not +* they trip the dinode verifiers. If those trip, then we won't be able to +* _iget ourselves the inode. +* +* Therefore, the xrep_dinode_* functions fix anything that will cause the +* inode buffer verifier or the dinode verifier. The xrep_inode_* functions +* fix things on live incore inodes. +*/ I'd like to see some of the decisions made documented here. Stuff like:
Quoted 6 lines
- "unknown
di_modeconverts inode to a regular file only root can read" needs to be clearly documented because that "regular file" that results might not actually contain user data....
- what we do with setuid/setgid on repaired inodes
- things we just trash and leave to other parts of repair to clean up stuff we leak or trash...
Ok.
* Therefore, the xrep_dinode_* functions fix anything that will cause
* the inode buffer verifier or the dinode verifier. The xrep_inode_*
* functions fix things on live incore inodes. The repair functions in
* here can make decisions with security and usability implications in
* order to revive a file:
*
* - Files with zero di_mode or a garbage di_mode are converted to a
* file that only root can read. If the immediate data fork area or
* block 0 of the data fork look like a directory, the file type will be
* set to a directory. If the immediate data fork area has no nulls, it
* will be turned into a symbolic link. Otherwise, it is turned into a
* regular file. This file may not actually contain user data, if the
* file was not previously a regular file. Setuid and setgid bits are
* cleared.
*
* - Zero-size directories can be truncated to look empty. It is
* necessary to run the bmapbtd and directory repair functions to fully
* rebuild the directory.
*
* - Zero-size symbolic link targets can be truncated to '.'. It is
* necessary to run the bmapbtd and symlink repair functions to salvage
* the symlink.
*
* - Invalid extent size hints will be removed.
*
* - Quotacheck will be scheduled if we repaired an inode that was so
* badly damaged that the ondisk inode had to be rebuilt.
*
* - Invalid user, group, or project IDs (aka -1U) will be reset to
* zero. Setuid and setgid bits are cleared.
The next patch will add to that:
* - Data and attr forks are reset to extents format with zero extents
* if the fork data is inconsistent. It is necessary to run the bmapbtd
* or bmapbta repair functions to recover the space mapping. *
* - ACLs will not be recovered if the attr fork is zapped or the
* extended attribute structure itself requires salvaging.
*
* - If the attr fork is zapped, the user and group ids are reset to
* root and the setuid and setgid bits are removed.
How does that sit with you?
Quoted 20 lines
Quoted 20 lines
fs/xfs/scrub/inode_repair.c new file +19
-0+/* Fix any conflicting flags that the verifiers complain about. */ +STATIC void +xrep_dinode_flags ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +uint64_t flags2; +uint16_t mode; +uint16_t flags; + +trace_xrep_dinode_flags (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + flags =be16_to_cpu (dip->di_flags); + flags2 =be64_to_cpu (dip->di_flags2); + +if (xfs_has_reflink (mp) &&S_ISREG (mode)) + flags2 |=XFS_DIFLAG2_REFLINK ;
Quoted 8 lines
fs/xfs/scrub/inode_repair.c line 209
Quoted 6 lines
fs/xfs/scrub/inode_repair.c new file +6
-0+else + flags2 &= ~(XFS_DIFLAG2_REFLINK |XFS_DIFLAG2_COWEXTSIZE ); +if (flags &XFS_DIFLAG_REALTIME ) + flags2 &= ~XFS_DIFLAG2_REFLINK ; +if (flags2 &XFS_DIFLAG2_REFLINK ) + flags2 &= ~XFS_DIFLAG2_DAX ;IIRC, reflink and DAX co-exist just fine now....
Yep. Fixed.
Quoted 23 lines
Quoted 23 lines
fs/xfs/scrub/inode_repair.c new file +23
-0+if (!xfs_has_bigtime (mp)) + flags2 &= ~XFS_DIFLAG2_BIGTIME ; +if (!xfs_has_large_extent_counts (mp)) + flags2 &= ~XFS_DIFLAG2_NREXT64 ; +if (flags2 &XFS_DIFLAG2_NREXT64 ) + dip->di_nrext64_pad =0 ; +else if (dip->di_version >=3 ) + dip->di_v3_pad =0 ; + dip->di_flags =cpu_to_be16 (flags); + dip->di_flags2 =cpu_to_be64 (flags2); +} + +/* +* Blow out symlink; now it points to the current dir. We don't have to worry +* about incore state because this inode is failing the verifiers. +*/ +STATIC void +xrep_dinode_zap_symlink ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +char *p; +
Quoted 8 lines
fs/xfs/scrub/inode_repair.c line 238
Quoted 6 lines
fs/xfs/scrub/inode_repair.c new file +6
-0+trace_xrep_dinode_zap_symlink (sc, dip); + + dip->di_format =XFS_DINODE_FMT_LOCAL ; + dip->di_size =cpu_to_be64 (1 ); + p =XFS_DFORK_PTR (dip,XFS_DATA_FORK ); + *p ='.' ;What if this was in extent form? Didn't we just leak an extent?
Yeah. I'll add that to the giant comment.
"Zero-size symbolic link targets can be truncated to '.'. It is necessary to run the bmapbtd and symlink repair functions to salvage the symlink."
The next few patches will add the ability to zap the data and attr forks if either of them look bad. After that, the (or really xfs_scrub) will have to call several more scrubbers to completely fix the file:
bmapbtd -> symlink/directory
bmapbta -> attr -> parent ptr
So this is a common post-requirement for the inode repair code. It's a bit racy, and arguably the kernel could auto-invoke those repair functions instead of requiring userspace to call back, but that's something for another conversation. :)
(e.g. "Is it ok if this one repair function could potentially take a very long time to finish, and won't tell userspace what it's up to?")
((The scrub vectorization in online fsck part 3 might actually be a reasonable way for xfs_scrub to get the kernel to do everything all at once.))
Quoted 21 lines
Quoted 21 lines
fs/xfs/scrub/inode_repair.c new file +21
-0+} + +/* +* Blow out dir, make it point to the root. In the future repair will +* reconstruct this directory for us. Note that there's no in-core directory +* inode because the sf verifier tripped, so we don't have to worry about the +* dentry cache. +*/ +STATIC void +xrep_dinode_zap_dir ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +struct xfs_dir2_sf_hdr *sfp; +int i8count; + +trace_xrep_dinode_zap_dir (sc, dip); + + dip->di_format =XFS_DINODE_FMT_LOCAL ; + i8count = mp->m_sb.sb_rootino >XFS_DIR2_MAX_SHORT_INUM ;
Quoted 8 lines
fs/xfs/scrub/inode_repair.c line 265
Quoted 6 lines
fs/xfs/scrub/inode_repair.c new file +6
-0+ sfp =XFS_DFORK_PTR (dip,XFS_DATA_FORK ); + sfp->count =0 ; + sfp->i8count = i8count; +xfs_dir2_sf_put_parent_ino (sfp, mp->m_sb.sb_rootino); + dip->di_size =cpu_to_be64 (xfs_dir2_sf_hdr_size (i8count)); +}Same here?
Same as above.
Quoted 106 lines
Quoted 106 lines
fs/xfs/scrub/inode_repair.c new file +106
-0+ +/* Make sure we don't have a garbage file size. */ +STATIC void +xrep_dinode_size ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +uint64_t size; +uint16_t mode; + +trace_xrep_dinode_size (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + size =be64_to_cpu (dip->di_size); +switch (mode &S_IFMT ) { +case S_IFIFO : +case S_IFCHR : +case S_IFBLK : +case S_IFSOCK : +/* di_size can't be nonzero for special files */ + dip->di_size =0 ; +break ; +case S_IFREG : +/* Regular files can't be larger than 2^63-1 bytes. */ + dip->di_size =cpu_to_be64 (size & ~(1ULL <<63 )); +break ; +case S_IFLNK : +/* +* Truncate ridiculously oversized symlinks. If the size is +* zero, reset it to point to the current directory. Both of +* these conditions trigger dinode verifier errors, so there +* is no in-core state to reset. +*/ +if (size >XFS_SYMLINK_MAXLEN ) + dip->di_size =cpu_to_be64 (XFS_SYMLINK_MAXLEN ); +else if (size ==0 ) +xrep_dinode_zap_symlink (sc, dip); +break ; +case S_IFDIR : +/* +* Directories can't have a size larger than 32G. If the size +* is zero, reset it to an empty directory. Both of these +* conditions trigger dinode verifier errors, so there is no +* in-core state to reset. +*/ +if (size >XFS_DIR2_SPACE_SIZE ) + dip->di_size =cpu_to_be64 (XFS_DIR2_SPACE_SIZE ); +else if (size ==0 ) +xrep_dinode_zap_dir (sc, dip); +break ; + } +} + +/* Fix extent size hints. */ +STATIC void +xrep_dinode_extsize_hints ( +struct xfs_scrub *sc, +struct xfs_dinode *dip) +{ +struct xfs_mount *mp = sc->mp; +uint64_t flags2; +uint16_t flags; +uint16_t mode; +xfs_failaddr_t fa; + +trace_xrep_dinode_extsize_hints (sc, dip); + + mode =be16_to_cpu (dip->di_mode); + flags =be16_to_cpu (dip->di_flags); + flags2 =be64_to_cpu (dip->di_flags2); + + fa =xfs_inode_validate_extsize (mp,be32_to_cpu (dip->di_extsize), + mode, flags); +if (fa) { + dip->di_extsize =0 ; + dip->di_flags &= ~cpu_to_be16 (XFS_DIFLAG_EXTSIZE | +XFS_DIFLAG_EXTSZINHERIT ); + } + +if (dip->di_version <3 ) +return ; + + fa =xfs_inode_validate_cowextsize (mp,be32_to_cpu (dip->di_cowextsize), + mode, flags, flags2); +if (fa) { + dip->di_cowextsize =0 ; + dip->di_flags2 &= ~cpu_to_be64 (XFS_DIFLAG2_COWEXTSIZE ); + } +} + +/* Inode didn't pass verifiers, so fix the raw buffer and retry iget. */ +STATIC int +xrep_dinode_core ( +struct xrep_inode *ri) +{ +struct xfs_scrub *sc = ri->sc; +struct xfs_buf *bp; +struct xfs_dinode *dip; +xfs_ino_t ino = sc->sm->sm_ino; +int error; + +/* Read the inode cluster buffer. */ + error =xfs_trans_read_buf (sc->mp, sc->tp, sc->mp->m_ddev_targp, + ri->imap.im_blkno, ri->imap.im_len,XBF_UNMAPPED , &bp, +NULL ); +if (error)
Quoted 8 lines
fs/xfs/scrub/inode_repair.c line 376
Quoted 5 lines
fs/xfs/scrub/inode_repair.c new file +5
-0+return error; + +/* Make sure we can pass the inode buffer verifier. */ +xrep_dinode_buf (sc, bp); + bp->b_ops = &xfs_inode_buf_ops;Hmmmmm. Don't we at least need to check this looks like an inode cluster buffer first?
Check it how? The cluster buffer could be completely trashed due to crosslinking with a regular file, or bad storage devices, or whatnot. xrep_dinode_buf will rewrite the whole buffer to get it to the point where it'll pass the buffer verifier.
Quoted 20 lines
....
Quoted 19 lines
fs/xfs/scrub/inode_repair.c new file +19
-0+ +/* Check for invalid uid/gid/prid. */ +STATIC void +xrep_inode_ids ( +struct xfs_scrub *sc) +{ +trace_xrep_inode_ids (sc); + +if (i_uid_read (VFS_I (sc->ip)) ==-1U ) { +i_uid_write (VFS_I (sc->ip),0 ); +VFS_I (sc->ip)->i_mode &= ~(S_ISUID |S_ISGID ); +if (XFS_IS_UQUOTA_ON (sc->mp)) +xrep_force_quotacheck (sc,XFS_DQTYPE_USER ); + } + +if (i_gid_read (VFS_I (sc->ip)) ==-1U ) { +i_gid_write (VFS_I (sc->ip),0 ); +VFS_I (sc->ip)->i_mode &= ~(S_ISUID |S_ISGID ); +if (XFS_IS_GQUOTA_ON (sc->mp))
Quoted 8 lines
fs/xfs/scrub/inode_repair.c
Quoted 2 lines
fs/xfs/scrub/inode_repair.c new file +2
-0+xrep_force_quotacheck (sc,XFS_DQTYPE_GROUP ); + }IF we are repairing an inode that has setuid or setgid, I think we should just strip those permissions regardless of whether the uid/gid are valid. It think it's better to be cautious here rather than leave setuid on a file that we reconstructed but have no real way of knowing that data in the file is untainted.
Ok, changed.
Quoted 20 lines
Quoted 20 lines
fs/xfs/scrub/inode_repair.c new file +20
-0+ +if (sc->ip->i_projid ==-1U ) { + sc->ip->i_projid =0 ; +if (XFS_IS_PQUOTA_ON (sc->mp)) +xrep_force_quotacheck (sc,XFS_DQTYPE_PROJ ); + } +} + +static inline void +xrep_clamp_nsec ( +struct timespec64 *ts) +{ + ts->tv_nsec =clamp_t (long, ts->tv_nsec,0 ,NSEC_PER_SEC ); +} + +/* Nanosecond counters can't have more than 1 billion. */ +STATIC void +xrep_inode_timestamps ( +struct xfs_inode *ip) +{
Quoted 8 lines
fs/xfs/scrub/inode_repair.c line 548
Quoted 5 lines
fs/xfs/scrub/inode_repair.c new file +5
-0+xrep_clamp_nsec (&VFS_I (ip)->i_atime); +xrep_clamp_nsec (&VFS_I (ip)->i_mtime); +xrep_clamp_nsec (&VFS_I (ip)->i_ctime); +xrep_clamp_nsec (&ip->i_crtime); +}Should we be clamping the entire timestamp within the valid filesystem timestamp range here?
Yes.
static inline void
xrep_clamp_timestamp(
struct xfs_inode *ip,
struct timespec64 *ts)
{
ts->tv_nsec = clamp_t(long, ts->tv_nsec, 0, NSEC_PER_SEC);
*ts = timestamp_truncate(*ts, VFS_I(ip));
}Quoted 10 lines
Quoted 9 lines
fs/xfs/scrub/inode_repair.c new file +9
-0+ +/* Fix inode flags that don't make sense together. */ +STATIC void +xrep_inode_flags ( +struct xfs_scrub *sc) +{ +uint16_t mode; + +trace_xrep_inode_flags (sc);....
Quoted 5 lines
fs/xfs/scrub/inode_repair.c line 610
Quoted 3 lines
fs/xfs/scrub/inode_repair.c new file +3
-0+/* No mixing reflink and DAX yet. */ +if (sc->ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) + sc->ip->i_diflags2 &= ~XFS_DIFLAG2_DAX ;This can go, too...
Fixed.
Quoted 32 lines
.....
Quoted 16 lines
fs/xfs/scrub/inode_repair.c new file +12
-0@@ -750,6 +750,38 @@ xrep_ino_dqattach( }#endif /* CONFIG_XFS_QUOTA */ +/* +* Ensure that the inode being repaired is ready to handle a certain number of +* extents, or return EFSCORRUPTED. Caller must hold the ILOCK of the inode +* being repaired and have joined it to the scrub transaction. +*/ +int +xrep_ino_ensure_extent_count ( +struct xfs_scrub *sc, +int whichfork, +xfs_extnum_t nextents) +{ +xfs_extnum_t max_extents;fs/xfs/scrub/inode_repair.c xrep_ino_dqattach( · line 774
Quoted 10 lines
fs/xfs/scrub/inode_repair.c new file +10
-0+bool large_extcount; + + large_extcount =xfs_inode_has_large_extent_counts (sc->ip); + max_extents =xfs_iext_max_nextents (large_extcount, whichfork); +if (nextents <= max_extents) +return 0 ; +if (large_extcount) +return -EFSCORRUPTED ; +if (!xfs_has_large_extent_counts (sc->mp)) +return -EFSCORRUPTED ;This logic took me a bit of peering at to work out.
large_extcountsays whether the inode has the large extcount flag set, which is different to whether the superblock has large extcoutn flag set.
Quoted 3 lines
Can change
large_extcounttoinode_has_nrext64or something like that just so it's really clear that there are two different flags being checked here?
Yup, done.
Quoted 22 lines
Quoted 7 lines
fs/xfs/scrub/repair.h +0
-0@@ -28,6 +28,16 @@ bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks, enum xfs_ag_resv_type type);xfs_extlen_t xrep_calc_ag_resblks (struct xfs_scrub *sc);fs/xfs/scrub/repair.h bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks, · line 39
Quoted 10 lines
fs/xfs/scrub/repair.h +9
-0+static inline int +xrep_trans_commit ( +struct xfs_scrub *sc) +{ +int error =xfs_trans_commit (sc->tp); + + sc->tp =NULL ; +return error; +}That's .... interesting formatting. I'd be happy with using standard linux format for this:
static inline int
xrep_trans_commit(struct xfs_scrub *sc)
Quoted 8 lines
{ int error = xfs_trans_commit(sc->tp); sc->tp = NULL; return error; }But that's just personal preference....
Yeah, that's ok with me.
--D
Quoted 4 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 4/6 xfs: zap broken inode forks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Determine if inode fork damage is responsible for the inode being unable to pass the ifork verifiers in xfs_iget and zap the fork contents if this is true. Once this is done the fork will be empty but we'll be able to construct an in-core inode, and a subsequent call to the inode fork repair ioctl will search the rmapbt to rebuild the records that were in the fork.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 32 +- fs/xfs/libxfs/xfs_attr_leaf.h | 2 fs/xfs/libxfs/xfs_bmap.c | 22 + fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_dir2_priv.h | 2 fs/xfs/libxfs/xfs_dir2_sf.c | 29 +- fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/libxfs/xfs_symlink_remote.c | 21 + fs/xfs/scrub/inode_repair.c | 688 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/trace.h | 42 ++ 10 files changed, 804 insertions(+), 37 deletions(-)
fs/xfs/libxfs/xfs_attr_leaf.c +21 -11
@@ -1040,23 +1040,16 @@ xfs_attr_shortform_allfit(return xfs_attr_shortform_bytesfit (dp, bytes); } -/* Verify the consistency of an inline attribute fork. */ +/* Verify the consistency of a raw inline attribute fork. */ xfs_failaddr_t -xfs_attr_shortform_verify ( -struct xfs_inode *ip) +xfs_attr_shortform_verify_struct ( +struct xfs_attr_shortform *sfp, +size_t size) { -struct xfs_attr_shortform *sfp;struct xfs_attr_sf_entry *sfep;struct xfs_attr_sf_entry *next_sfep;char *endp; -struct xfs_ifork *ifp;int i; -int64_t size; - -ASSERT (ip->i_af.if_format ==XFS_DINODE_FMT_LOCAL ); - ifp =xfs_ifork_ptr (ip,XFS_ATTR_FORK ); - sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data; - size = ifp->if_bytes;/* * Give up if the attribute is way too short.
@@ -1116,6 +1109,23 @@ xfs_attr_shortform_verify(return NULL ; } +/* Verify the consistency of an inline attribute fork. */ +xfs_failaddr_t +xfs_attr_shortform_verify ( +struct xfs_inode *ip) +{ +struct xfs_attr_shortform *sfp; +struct xfs_ifork *ifp; +int64_t size; + +ASSERT (ip->i_af.if_format ==XFS_DINODE_FMT_LOCAL ); + ifp =xfs_ifork_ptr (ip,XFS_ATTR_FORK ); + sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data; + size = ifp->if_bytes; + +return xfs_attr_shortform_verify_struct (sfp, size); +} +/* * Convert a leaf attribute list to shortform attribute list */
fs/xfs/libxfs/xfs_attr_leaf.h +2 -0
@@ -56,6 +56,8 @@ int xfs_attr_sf_findname(struct xfs_da_args *args, unsigned int *basep);int xfs_attr_shortform_allfit (struct xfs_buf *bp,struct xfs_inode *dp);int xfs_attr_shortform_bytesfit (struct xfs_inode *dp,int bytes); +xfs_failaddr_t xfs_attr_shortform_verify_struct (struct xfs_attr_shortform *sfp, +size_t size);xfs_failaddr_t xfs_attr_shortform_verify (struct xfs_inode *ip);void xfs_attr_fork_remove (struct xfs_inode *ip,struct xfs_trans *tp);
fs/xfs/libxfs/xfs_bmap.c +16 -6
@@ -6196,19 +6196,18 @@ xfs_bmap_finish_one(return error; } -/* Check that an inode's extent does not have invalid flags or bad ranges. */ +/* Check that an extent does not have invalid flags or bad ranges. */ xfs_failaddr_t -xfs_bmap_validate_extent ( -struct xfs_inode *ip, +xfs_bmap_validate_extent_raw ( +struct xfs_mount *mp, +bool rtfile,int whichfork,struct xfs_bmbt_irec *irec) { -struct xfs_mount *mp = ip->i_mount; -if (!xfs_verify_fileext (mp, irec->br_startoff, irec->br_blockcount))return __this_address; -if (XFS_IS_REALTIME_INODE (ip) && whichfork ==XFS_DATA_FORK ) { +if (rtfile && whichfork ==XFS_DATA_FORK ) {if (!xfs_verify_rtext (mp, irec->br_startblock, irec->br_blockcount))return __this_address;
@@ -6238,3 +6237,14 @@ xfs_bmap_intent_destroy_cache(void)kmem_cache_destroy (xfs_bmap_intent_cache); xfs_bmap_intent_cache =NULL ; } + +/* Check that an inode's extent does not have invalid flags or bad ranges. */ +xfs_failaddr_t +xfs_bmap_validate_extent ( +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *irec) +{ +return xfs_bmap_validate_extent_raw (ip->i_mount, +XFS_IS_REALTIME_INODE (ip), whichfork, irec); +}
fs/xfs/libxfs/xfs_bmap.h +2 -0
@@ -263,6 +263,8 @@ static inline uint32_t xfs_bmap_fork_to_state(int whichfork) } } +xfs_failaddr_t xfs_bmap_validate_extent_raw (struct xfs_mount *mp,bool rtfile, +int whichfork,struct xfs_bmbt_irec *irec);xfs_failaddr_t xfs_bmap_validate_extent (struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *irec); int xfs_bmap_complain_bad_rec(struct xfs_inode *ip, int whichfork,
fs/xfs/libxfs/xfs_dir2_priv.h +2 -0
@@ -175,6 +175,8 @@ extern int xfs_dir2_sf_create(struct xfs_da_args *args, xfs_ino_t pino);extern int xfs_dir2_sf_lookup (struct xfs_da_args *args);extern int xfs_dir2_sf_removename (struct xfs_da_args *args);extern int xfs_dir2_sf_replace (struct xfs_da_args *args); +extern xfs_failaddr_t xfs_dir2_sf_verify_struct (struct xfs_mount *mp, +struct xfs_dir2_sf_hdr *sfp,int64_t size);extern xfs_failaddr_t xfs_dir2_sf_verify (struct xfs_inode *ip);int xfs_dir2_sf_entsize (struct xfs_mount *mp,struct xfs_dir2_sf_hdr *hdr,int len);
fs/xfs/libxfs/xfs_dir2_sf.c +18 -11
@@ -706,12 +706,11 @@ xfs_dir2_sf_check(/* Verify the consistency of an inline directory. */ xfs_failaddr_t -xfs_dir2_sf_verify ( -struct xfs_inode *ip) +xfs_dir2_sf_verify_struct ( +struct xfs_mount *mp, +struct xfs_dir2_sf_hdr *sfp, +int64_t size) { -struct xfs_mount *mp = ip->i_mount; -struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); -struct xfs_dir2_sf_hdr *sfp;struct xfs_dir2_sf_entry *sfep;struct xfs_dir2_sf_entry *next_sfep;char *endp;
@@ -719,15 +718,9 @@ xfs_dir2_sf_verify(int i;int i8count;int offset; -int64_t size;int error;uint8_t filetype; -ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); - - sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data; - size = ifp->if_bytes; -/* * Give up if the directory is way too short. */
@@ -803,6 +796,20 @@ xfs_dir2_sf_verify(return NULL ; } +xfs_failaddr_t +xfs_dir2_sf_verify ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +struct xfs_dir2_sf_hdr *sfp; + +ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); + + sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data; +return xfs_dir2_sf_verify_struct (mp, sfp, ifp->if_bytes); +} +/* * Create a new (shortform) directory. */
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -139,6 +139,7 @@ bool xfs_symlink_hdr_ok(xfs_ino_t ino, uint32_t offset, uint32_t size, struct xfs_buf *bp);void xfs_symlink_local_to_remote (struct xfs_trans *tp,struct xfs_buf *bp,struct xfs_inode *ip,struct xfs_ifork *ifp); +xfs_failaddr_t xfs_symlink_sf_verify_struct (void *sfp,int64_t size);xfs_failaddr_t xfs_symlink_shortform_verify (struct xfs_inode *ip);/* Computed inode geometry for the filesystem. */
fs/xfs/libxfs/xfs_symlink_remote.c +14 -7
@@ -201,16 +201,12 @@ xfs_symlink_local_to_remote(* does not do on-disk format checks. */ xfs_failaddr_t -xfs_symlink_shortform_verify ( -struct xfs_inode *ip) +xfs_symlink_sf_verify_struct ( +void *sfp, +int64_t size) { -struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); -char *sfp = (char *)ifp->if_u1.if_data; -int size = ifp->if_bytes;char *endp = sfp + size; -ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); -/* * Zero length symlinks should never occur in memory as they are * never allowed to exist on disk.
@@ -231,3 +227,14 @@ xfs_symlink_shortform_verify(return __this_address;return NULL ; } + +xfs_failaddr_t +xfs_symlink_shortform_verify ( +struct xfs_inode *ip) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); + +ASSERT (ifp->if_format ==XFS_DINODE_FMT_LOCAL ); + +return xfs_symlink_sf_verify_struct (ifp->if_u1.if_data, ifp->if_bytes); +}
fs/xfs/scrub/inode_repair.c +686 -2
740 lines not on this page · raw message
fs/xfs/scrub/trace.h +42 -0
54 lines not on this page · raw message
PATCH 5/6 xfs: abort directory parent scrub scans if we encounter a zapped directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In the previous patch, we added some code to perform sufficient repairs to an ondisk inode record such that the inode cache would be willing to load the inode. If the broken inode was a shortform directory, it will reset the directory to something plausible, which is to say an empty subdirectory of the root. The telltale signs that something is seriously wrong is the broken link count.
Such directories look clean, but they shouldn't participate in a filesystem scan to find or confirm a directory parent pointer. Create a predicate that identifies such directories and abort the scrub.
Found by fuzzing xfs/1554 with multithreaded xfs_scrub enabled and u3.bmx[0].startblock = zeroes.
--- fs/xfs/scrub/common.c | 1 + fs/xfs/scrub/common.h | 2 ++ fs/xfs/scrub/dir.c | 21 +++++++++++++++++++++ fs/xfs/scrub/parent.c | 10 ++++++++++ 4 files changed, 34 insertions(+)
fs/xfs/scrub/common.c +1 -0
@@ -26,6 +26,7 @@#include "xfs_trans_priv.h" #include "xfs_da_format.h" #include "xfs_da_btree.h" +#include "xfs_dir2_priv.h" #include "xfs_attr.h" #include "xfs_reflink.h" #include "xfs_ag.h"
fs/xfs/scrub/common.h +2 -0
@@ -173,6 +173,8 @@ static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm) XFS_SCRUB_OFLAG_XCORRUPT); } +bool xchk_dir_looks_zapped (struct xfs_inode *dp); +#ifdef CONFIG_XFS_ONLINE_REPAIR /* Decide if a repair is required. */ static inline bool xchk_needs_repair (const struct xfs_scrub_metadata *sm)
fs/xfs/scrub/dir.c +21 -0
@@ -788,3 +788,24 @@ xchk_directory( error =0 ;return error; } + +/* +* Decide if this directory has been zapped to satisfy the inode and ifork +* verifiers. Checking and repairing should be postponed until the directory +* is fixed. +*/ +bool +xchk_dir_looks_zapped ( +struct xfs_inode *dp) +{ +/* +* If the dinode repair found a bad data fork, it will reset the fork +* to extents format with zero records and wait for the bmapbtd +* scrubber to reconstruct the block mappings. Directories always +* contain some content, so this is a clear sign of a zapped directory. +*/ +if (dp->i_df.if_format ==XFS_DINODE_FMT_EXTENTS ) +return dp->i_df.if_nextents ==0 ; + +return false; +}
fs/xfs/scrub/parent.c +10 -0
@@ -156,6 +156,16 @@ xchk_parent_validate( goto out_rele; } +/* +* We cannot yet validate this parent pointer if the directory looks as +* though it has been zapped by the inode record repair code. +*/ +if (xchk_dir_looks_zapped (dp)) { + error = -EFSCORRUPTED ; +xchk_set_incomplete (sc); + goto out_unlock; + } +/* Look for a directory entry in the parent pointing to the child. */ error =xchk_dir_walk (sc, dp, xchk_parent_actor, &spc);if (!xchk_fblock_xref_process_error (sc,XFS_DATA_FORK ,0 , &error))
PATCH 6/6 xfs: repair obviously broken inode modes
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Building off the rmap scanner that we added in the previous patch, we can now find block 0 and try to use the information contained inside of it to guess the mode of an inode if it's totally improper.
--- fs/xfs/scrub/inode_repair.c | 170 ++++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/trace.h | 11 ++- 2 files changed, 172 insertions(+), 9 deletions(-)
fs/xfs/scrub/inode_repair.c +165 -5
@@ -74,6 +74,9 @@ struct xrep_inode {/* Blocks in use by the attr fork. */ xfs_rfsblock_t attr_blocks; +/* Physical block containing data block 0. */ +xfs_fsblock_t block0; +/* Number of data device extents for the data fork. */ xfs_extnum_t data_extents;
@@ -113,6 +116,7 @@ xrep_setup_inode( ri = sc->buf;memcpy (&ri->imap, imap,sizeof (struct xfs_imap )); ri->sc = sc; + ri->block0 =NULLFSBLOCK ;return 0 ; }
@@ -188,12 +192,159 @@ xrep_dinode_header( dip->di_gen =cpu_to_be32 (sc->sm->sm_gen); } +/* Parse enough of the directory block header to guess if this is a dir. */ +static inline bool +xrep_dinode_is_dir ( +xfs_ino_t ino, +xfs_daddr_t daddr, +struct xfs_buf *bp) +{ +struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; +struct xfs_dir2_data_free *bf; +struct xfs_mount *mp = bp->b_mount; +xfs_lsn_t lsn =be64_to_cpu (hdr3->lsn); + +/* Does the dir3 header match the filesystem? */ +if (hdr3->magic !=cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ) && + hdr3->magic !=cpu_to_be32 (XFS_DIR3_DATA_MAGIC )) +return false; + +if (be64_to_cpu (hdr3->owner) != ino) +return false; + +if (!uuid_equal (&hdr3->uuid, &mp->m_sb.sb_meta_uuid)) +return false; + +if (be64_to_cpu (hdr3->blkno) != daddr) +return false; + +/* Directory blocks are always logged and must have a valid LSN. */ +if (lsn ==NULLCOMMITLSN ) +return false; +if (!xlog_valid_lsn (mp->m_log, lsn)) +return false; + +/* +* bestfree information lives immediately after the end of the header, +* so we won't run off the end of the buffer. +*/ + bf =xfs_dir2_data_bestfree_p (mp, bp->b_addr); +if (!bf[0 ].length && bf[0 ].offset) +return false; +if (!bf[1 ].length && bf[1 ].offset) +return false; +if (!bf[2 ].length && bf[2 ].offset) +return false; + +if (be16_to_cpu (bf[0 ].length) <be16_to_cpu (bf[1 ].length)) +return false; +if (be16_to_cpu (bf[1 ].length) <be16_to_cpu (bf[2 ].length)) +return false; + +return true; +} + +/* Guess the mode of this file from the contents. */ +STATIC uint16_t +xrep_dinode_guess_mode ( +struct xrep_inode *ri, +struct xfs_dinode *dip) +{ +struct xfs_buf *bp; +struct xfs_mount *mp = ri->sc->mp; +xfs_daddr_t daddr; +uint64_t fsize =be64_to_cpu (dip->di_size); +unsigned int dfork_sz =XFS_DFORK_DSIZE (dip, mp); +uint16_t mode =S_IFREG ; +int error; + +switch (dip->di_format) { +case XFS_DINODE_FMT_LOCAL : +/* +* If the data fork is local format, the size of the data area +* is reasonable and is big enough to contain the entire file, +* we can guess the file type from the local data. +* +* If there are no nulls, guess this is a symbolic link. +* Otherwise, this is probably a shortform directory. +*/ +if (dfork_sz <=XFS_LITINO (mp) && dfork_sz >= fsize) { +if (!memchr (XFS_DFORK_DPTR (dip),0 , fsize)) +return S_IFLNK ; +return S_IFDIR ; + } + +/* By default, we guess regular file. */ +return S_IFREG ; +case XFS_DINODE_FMT_DEV : +/* +* If the data fork is dev format, the size of the data area is +* reasonable and large enough to store a dev_t, and the file +* size is zero, this could be a blockdev, a chardev, a fifo, +* or a socket. There is no solid way to distinguish between +* those choices, so we guess blockdev if the device number is +* nonzero and chardev if it's zero (aka whiteout). +*/ +if (dfork_sz <=XFS_LITINO (mp) && + dfork_sz >=sizeof (__be32) && fsize ==0 ) { +xfs_dev_t dev =xfs_dinode_get_rdev (dip); + +return dev !=0 ?S_IFBLK :S_IFCHR ; + } + +/* By default, we guess regular file. */ +return S_IFREG ; +case XFS_DINODE_FMT_EXTENTS : +case XFS_DINODE_FMT_BTREE : +/* There are data blocks to examine below. */ +break ; +default : +/* Everything else is considered a regular file. */ +return S_IFREG ; + } + +/* There are no zero-length directories. */ +if (fsize ==0 ) +return S_IFREG ; + +/* +* If we didn't find a written mapping for file block zero, we'll guess +* that it's a sparse regular file. +*/ +if (ri->block0 ==NULLFSBLOCK ) +return S_IFREG ; + +/* Directories can't have rt extents. */ +if (ri->rt_extents >0 ) +return S_IFREG ; + +/* +* Read the first block of the file. Since we have no idea what kind +* of file geometry (e.g. dirblock size) we might be reading into, use +* an uncached buffer so that we don't pollute the buffer cache. We +* can't do uncached mapped buffers, so the best we can do is guess +* from the directory header. +*/ + daddr =XFS_FSB_TO_DADDR (mp, ri->block0); + error =xfs_buf_read_uncached (mp->m_ddev_targp, daddr, +XFS_FSS_TO_BB (mp,1 ),0 , &bp,NULL ); +if (error) +return S_IFREG ; + +if (xrep_dinode_is_dir (ri->sc->sm->sm_ino, daddr, bp)) + mode =S_IFDIR ; + +xfs_buf_relse (bp); +return mode; +} +/* Turn di_mode into /something/ recognizable. */ STATIC voidxrep_dinode_mode ( -struct xfs_scrub *sc, +struct xrep_inode *ri,struct xfs_dinode *dip) { +struct xfs_scrub *sc = ri->sc;uint16_t mode;trace_xrep_dinode_mode (sc, dip);
@@ -203,7 +354,7 @@ xrep_dinode_mode(return ;/* bad mode, so we set it to a file that only root can read */ - mode =S_IFREG ; + mode =xrep_dinode_guess_mode (ri, dip); dip->di_mode =cpu_to_be16 (mode); dip->di_uid =0 ; dip->di_gid =0 ;
@@ -412,9 +563,17 @@ xrep_dinode_walk_rmap( } ri->data_blocks += rec->rm_blockcount; -if (!(rec->rm_flags &XFS_RMAP_BMBT_BLOCK )) +if (!(rec->rm_flags &XFS_RMAP_BMBT_BLOCK )) { ri->data_extents++; +if (rec->rm_offset ==0 && + !(rec->rm_flags &XFS_RMAP_UNWRITTEN )) { +if (ri->block0 !=NULLFSBLOCK ) +return -EFSCORRUPTED ; + ri->block0 = rec->rm_startblock; + } + } +return 0 ; }
@@ -465,7 +624,8 @@ xrep_dinode_count_rmaps(trace_xrep_dinode_count_rmaps (ri->sc, ri->data_blocks, ri->rt_blocks, ri->attr_blocks, - ri->data_extents, ri->rt_extents, ri->attr_extents); + ri->data_extents, ri->rt_extents, ri->attr_extents, + ri->block0);return 0 ; }
@@ -1061,7 +1221,7 @@ xrep_dinode_core(/* Fix everything the verifier will complain about. */ dip =xfs_buf_offset (bp, ri->imap.im_boffset);xrep_dinode_header (sc, dip); -xrep_dinode_mode (sc, dip); +xrep_dinode_mode (ri, dip);xrep_dinode_flags (sc, dip, ri->rt_extents >0 );xrep_dinode_size (sc, dip);xrep_dinode_extsize_hints (sc, dip);
fs/xfs/scrub/trace.h +7 -4
@@ -1503,9 +1503,9 @@ TRACE_EVENT(xrep_dinode_count_rmaps, TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks, xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks, xfs_extnum_t data_extents, xfs_extnum_t rt_extents, - xfs_aextnum_t attr_extents), + xfs_aextnum_t attr_extents, xfs_fsblock_t block0),TP_ARGS (sc, data_blocks, rt_blocks, attr_blocks, data_extents, - rt_extents, attr_extents), + rt_extents, attr_extents, block0), TP_STRUCT__entry( __field(dev_t, dev) __field(xfs_ino_t, ino)
@@ -1515,6 +1515,7 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __field(xfs_extnum_t, data_extents) __field(xfs_extnum_t, rt_extents) __field(xfs_aextnum_t, attr_extents) +__field (xfs_fsblock_t, block0) ),TP_fast_assign ( __entry->dev = sc->mp->m_super->s_dev;
@@ -1525,8 +1526,9 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __entry->data_extents = data_extents; __entry->rt_extents = rt_extents; __entry->attr_extents = attr_extents; + __entry->block0 = block0; ), - TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u", + TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u startblock0 0x%llx", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->data_blocks,
@@ -1534,7 +1536,8 @@ TRACE_EVENT(xrep_dinode_count_rmaps, __entry->attr_blocks, __entry->data_extents, __entry->rt_extents, - __entry->attr_extents) + __entry->attr_extents, + __entry->block0) );#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
Re: [PATCHSET v26.0 0/6] xfs: online repair of inodes and forks
In reply to Darrick J. WongQuoted 11 lines · Darrick J. Wong
Hi all,
In this series, online repair gains the ability to repair inode records. To do this, we must repair the ondisk inode and fork information enough to pass the iget verifiers and hence make the inode igettable again. Once that's done, we can perform higher level repairs on the incore inode. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
Most of this makes sense. I think the main thing I'd suggest is documenting the repair decisions being made and how things that get zapped are then rebuilt - it seems like there is a lot of dependency on running other parts of repair after zapping for things to be rebuilt, but it's not immediately clear how the bits are supposed to go together so a little bit of documentation for that would go a long way....
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCHSET v26.0 0/6] xfs: online repair of inodes and forks
Quoted 13 lines · Dave Chinner
Quoted 11 lines · Darrick J. Wong
Hi all,
In this series, online repair gains the ability to repair inode records. To do this, we must repair the ondisk inode and fork information enough to pass the iget verifiers and hence make the inode igettable again. Once that's done, we can perform higher level repairs on the incore inode. The fstests counterpart of this patchset implements stress testing of repair.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
Quoted 7 lines
Most of this makes sense. I think the main thing I'd suggest is documenting the repair decisions being made and how things that get zapped are then rebuilt - it seems like there is a lot of dependency on running other parts of repair after zapping for things to be rebuilt, but it's not immediately clear how the bits are supposed to go together so a little bit of documentation for that would go a long way....
Ok. The comment for inode_repair.c now reads:
/*
* Inode Record Repair
* ===================
*
* Roughly speaking, inode problems can be classified based on whether
* or not they trip the dinode verifiers. If those trip, then we won't
* be able to xfs_iget ourselves the inode.
*
* Therefore, the xrep_dinode_* functions fix anything that will cause
* the inode buffer verifier or the dinode verifier. The xrep_inode_*
* functions fix things on live incore inodes. The inode repair
* functions make decisions with security and usability implications
* when reviving a file:
*
* - Files with zero di_mode or a garbage di_mode are converted to a
* file that only root can read. If the immediate data fork area or
* block 0 of the data fork look like a directory, the file type will be
* set to a directory. If the immediate data fork area has no nulls, it
* will be turned into a symbolic link. Otherwise, it is turned into a
* regular file. This file may not actually contain user data, if the
* file was not previously a regular file. Setuid and setgid bits are
* cleared.
*
* - Zero-size directories can be truncated to look empty. It is
* necessary to run the bmapbtd and directory repair functions to fully
* rebuild the directory.
*
* - Zero-size symbolic link targets can be truncated to '.'. It is
* necessary to run the bmapbtd and symlink repair functions to salvage
* the symlink.
*
* - Invalid extent size hints will be removed.
*
* - Quotacheck will be scheduled if we repaired an inode that was so
* badly damaged that the ondisk inode had to be rebuilt.
*
* - Invalid user, group, or project IDs (aka -1U) will be reset to
* zero. Setuid and setgid bits are cleared.
*
* - Data and attr forks are reset to extents format with zero extents
* if the fork data is inconsistent. It is necessary to run the bmapbtd
* or bmapbta repair functions to recover the space mapping. *
* - ACLs will not be recovered if the attr fork is zapped or the
* extended attribute structure itself requires salvaging.
*
* - If the attr fork is zapped, the user and group ids are reset to
* root and the setuid and setgid bits are removed.
*/
--D
Quoted 5 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
cover xfs: online repair of file fork mappings
In reply to Darrick J. WongHi all,
In this series, online repair gains the ability to rebuild data and attr fork mappings from the reverse mapping information. It is at this point where we reintroduce the ability to reap file extents.
Repair of CoW forks is a little different -- on disk, CoW staging extents are owned by the refcount btree and cannot be mapped back to individual files. Hence we can only detect staging extents that don't quite look right (missing reverse mappings, shared staging extents) and replace them with fresh allocations.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-file-mappings
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-file-mappings
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-file-mappings
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_bmap_btree.c | 112 ++++- fs/xfs/libxfs/xfs_bmap_btree.h | 5 fs/xfs/libxfs/xfs_btree_staging.c | 11 fs/xfs/libxfs/xfs_btree_staging.h | 2 fs/xfs/libxfs/xfs_iext_tree.c | 23 + fs/xfs/libxfs/xfs_inode_fork.c | 1 fs/xfs/libxfs/xfs_inode_fork.h | 3 fs/xfs/libxfs/xfs_refcount.c | 41 ++ fs/xfs/libxfs/xfs_refcount.h | 10 fs/xfs/scrub/bitmap.h | 28 + fs/xfs/scrub/bmap.c | 18 + fs/xfs/scrub/bmap_repair.c | 849 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 fs/xfs/scrub/cow_repair.c | 609 +++++++++++++++++++++++++++ fs/xfs/scrub/reap.c | 152 ++++++- fs/xfs/scrub/reap.h | 2 fs/xfs/scrub/repair.c | 50 ++ fs/xfs/scrub/repair.h | 11 fs/xfs/scrub/scrub.c | 20 - fs/xfs/scrub/trace.h | 118 +++++ fs/xfs/xfs_trans.c | 95 ++++ fs/xfs/xfs_trans.h | 4 23 files changed, 2126 insertions(+), 46 deletions(-) create mode 100644 fs/xfs/scrub/bmap_repair.c create mode 100644 fs/xfs/scrub/cow_repair.c
PATCH 1/5 xfs: reintroduce reaping of file metadata blocks to xrep_reap_extents
From: Darrick J. Wong <[email protected]>
Reintroduce to xrep_reap_extents the ability to reap extents from any AG. We dropped this before because it was buggy, but in the next patch we will gain the ability to reap old bmap btrees, which can have blocks in any AG. To do this, we require that sc->sa is uninitialized, so that we can use it to hold all the per-AG context for a given extent.
--- fs/xfs/scrub/bitmap.h | 28 +++++++++++ fs/xfs/scrub/reap.c | 120 +++++++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/scrub/reap.h | 2 + fs/xfs/scrub/repair.h | 1 4 files changed, 147 insertions(+), 4 deletions(-)
fs/xfs/scrub/bitmap.h +28 -0
@@ -105,4 +105,32 @@ int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,int xagb_bitmap_set_btcur_path (struct xagb_bitmap *bitmap,struct xfs_btree_cur *cur); +/* Bitmaps, but for type-checked for xfs_fsblock_t */ + +struct xfsb_bitmap { +struct xbitmap fsbitmap; +}; + +static inline void xfsb_bitmap_init (struct xfsb_bitmap *bitmap) +{ +xbitmap_init (&bitmap->fsbitmap); +} + +static inline void xfsb_bitmap_destroy (struct xfsb_bitmap *bitmap) +{ +xbitmap_destroy (&bitmap->fsbitmap); +} + +static inline int xfsb_bitmap_set (struct xfsb_bitmap *bitmap, +xfs_fsblock_t start,xfs_filblks_t len) +{ +return xbitmap_set (&bitmap->fsbitmap, start, len); +} + +static inline int xfsb_bitmap_walk (struct xfsb_bitmap *bitmap, +xbitmap_walk_fn fn,void *priv) +{ +return xbitmap_walk (&bitmap->fsbitmap, fn, priv); +} +#endif /* __XFS_SCRUB_BITMAP_H__ */
fs/xfs/scrub/reap.c +116 -4
129 lines not on this page · raw message
fs/xfs/scrub/reap.h +2 -0
@@ -8,5 +8,7 @@int xrep_reap_agblocks (struct xfs_scrub *sc,struct xagb_bitmap *bitmap,const struct xfs_owner_info *oinfo,enum xfs_ag_resv_type type); +int xrep_reap_fsblocks (struct xfs_scrub *sc,struct xfsb_bitmap *bitmap, +const struct xfs_owner_info *oinfo);#endif /* __XFS_SCRUB_REAP_H__ */
fs/xfs/scrub/repair.h +1 -0
@@ -40,6 +40,7 @@ xrep_trans_commit(struct xbitmap ;struct xagb_bitmap ; +struct xfsb_bitmap ;int xrep_fix_freelist (struct xfs_scrub *sc,bool can_shrink);
PATCH 2/5 xfs: repair inode fork block mapping data structures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the reverse-mapping btree information to rebuild an inode block map. Update the btree bulk loading code as necessary to support inode rooted btrees and fix some bitrot problems.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap_btree.c | 112 ++++- fs/xfs/libxfs/xfs_bmap_btree.h | 5 fs/xfs/libxfs/xfs_btree_staging.c | 11 fs/xfs/libxfs/xfs_btree_staging.h | 2 fs/xfs/libxfs/xfs_iext_tree.c | 23 + fs/xfs/libxfs/xfs_inode_fork.c | 1 fs/xfs/libxfs/xfs_inode_fork.h | 3 fs/xfs/scrub/bmap.c | 18 + fs/xfs/scrub/bmap_repair.c | 849 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 6 fs/xfs/scrub/repair.c | 28 + fs/xfs/scrub/repair.h | 6 fs/xfs/scrub/scrub.c | 4 fs/xfs/scrub/trace.h | 34 + fs/xfs/xfs_trans.c | 95 ++++ fs/xfs/xfs_trans.h | 4 17 files changed, 1174 insertions(+), 28 deletions(-) create mode 100644 fs/xfs/scrub/bmap_repair.c
fs/xfs/Makefile +1 -0
@@ -182,6 +182,7 @@ ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y) xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ + bmap_repair.o \ ialloc_repair.o \ inode_repair.o \ newbt.o \
fs/xfs/libxfs/xfs_bmap_btree.c +98 -14
160 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap_btree.h +5 -0
@@ -11,6 +11,7 @@ struct xfs_btree_block;struct xfs_mount ;struct xfs_inode ;struct xfs_trans ; +struct xbtree_ifakeroot ;/* * Btree block header size depends on a superblock flag.
@@ -106,6 +107,10 @@ extern int xfs_bmbt_change_owner(struct xfs_trans *tp, struct xfs_inode *ip,extern struct xfs_btree_cur *xfs_bmbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_inode *,int ); +struct xfs_btree_cur *xfs_bmbt_stage_cursor (struct xfs_mount *mp, +struct xfs_inode *ip,struct xbtree_ifakeroot *ifake); +void xfs_bmbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,int whichfork);extern unsigned long long xfs_bmbt_calc_size (struct xfs_mount *mp,unsigned long long len);
fs/xfs/libxfs/xfs_btree_staging.c +9 -2
@@ -399,7 +399,7 @@ xfs_btree_bload_prep_block(ASSERT (*bpp ==NULL );/* Allocate a new incore btree root block. */ - new_size = bbl->iroot_size (cur, nr_this_block, priv); + new_size = bbl->iroot_size (cur, level, nr_this_block, priv); ifp->if_broot =kmem_zalloc (new_size,0 ); ifp->if_broot_bytes = (int )new_size;
@@ -585,7 +585,14 @@ xfs_btree_bload_level_geometry(unsigned int desired_npb;unsigned int maxnr; - maxnr = cur->bc_ops->get_maxrecs (cur, level); +/* +* Compute the absolute maximum number of records that we can store in +* the ondisk block or inode root. +*/ +if (cur->bc_ops->get_dmaxrecs) + maxnr = cur->bc_ops->get_dmaxrecs (cur, level); +else + maxnr = cur->bc_ops->get_maxrecs (cur, level);/* * Compute the number of blocks we need to fill each block with the
fs/xfs/libxfs/xfs_btree_staging.h +1 -1
@@ -56,7 +56,7 @@ typedef int (*xfs_btree_bload_get_records_fn)(struct xfs_btree_cur *cur,typedef int (*xfs_btree_bload_claim_block_fn )(struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr,void *priv);typedef size_t (*xfs_btree_bload_iroot_size_fn )(struct xfs_btree_cur *cur, -unsigned int nr_this_level,void *priv); +unsigned int level,unsigned int nr_this_level,void *priv);struct xfs_btree_bload {/*
fs/xfs/libxfs/xfs_iext_tree.c +16 -7
@@ -622,13 +622,11 @@ static inline void xfs_iext_inc_seq(struct xfs_ifork *ifp) }void -xfs_iext_insert ( -struct xfs_inode *ip, +xfs_iext_insert_raw ( +struct xfs_ifork *ifp,struct xfs_iext_cursor *cur, -struct xfs_bmbt_irec *irec, -int state) +struct xfs_bmbt_irec *irec) { -struct xfs_ifork *ifp =xfs_iext_state_to_fork (ip, state);xfs_fileoff_t offset = irec->br_startoff;struct xfs_iext_leaf *new =NULL ;int nr_entries, i;
@@ -662,12 +660,23 @@ xfs_iext_insert(xfs_iext_set (cur_rec (cur), irec); ifp->if_bytes +=sizeof (struct xfs_iext_rec ); -trace_xfs_iext_insert (ip, cur, state, _RET_IP_); -if (new)xfs_iext_insert_node (ifp,xfs_iext_leaf_key (new,0 ), new,2 ); } +void +xfs_iext_insert ( +struct xfs_inode *ip, +struct xfs_iext_cursor *cur, +struct xfs_bmbt_irec *irec, +int state) +{ +struct xfs_ifork *ifp =xfs_iext_state_to_fork (ip, state); + +xfs_iext_insert_raw (ifp, cur, irec); +trace_xfs_iext_insert (ip, cur, state, _RET_IP_); +} +static struct xfs_iext_node * xfs_iext_rebalance_node( struct xfs_iext_node *parent,
fs/xfs/libxfs/xfs_inode_fork.c +1 -0
@@ -520,6 +520,7 @@ xfs_idata_realloc( ifp->if_bytes = new_size; } +/* Free all memory and reset a fork back to its initial state. */ void xfs_idestroy_fork (struct xfs_ifork *ifp)
fs/xfs/libxfs/xfs_inode_fork.h +3 -0
@@ -180,6 +180,9 @@ void xfs_init_local_fork(struct xfs_inode *ip, int whichfork, const void *data, int64_t size);xfs_extnum_t xfs_iext_count (struct xfs_ifork *ifp); +void xfs_iext_insert_raw (struct xfs_ifork *ifp, +struct xfs_iext_cursor *cur, +struct xfs_bmbt_irec *irec);void xfs_iext_insert (struct xfs_inode *,struct xfs_iext_cursor *cur,struct xfs_bmbt_irec *,int ); void xfs_iext_remove(struct xfs_inode *, struct xfs_iext_cursor *,
fs/xfs/scrub/bmap.c +18 -0
@@ -48,9 +48,18 @@ xchk_setup_inode_bmap(if (S_ISREG (VFS_I (sc->ip)->i_mode) && sc->sm->sm_type !=XFS_SCRUB_TYPE_BMBTA ) {struct address_space *mapping =VFS_I (sc->ip)->i_mapping; +bool is_repair =xchk_could_repair (sc);xchk_ilock (sc,XFS_MMAPLOCK_EXCL ); +/* Break all our leases, we're going to mess with things. */ +if (is_repair) { + error =xfs_break_layouts (VFS_I (sc->ip), + &sc->ilock_flags,BREAK_WRITE ); +if (error) + goto out; + } +inode_dio_wait (VFS_I (sc->ip));/*
@@ -71,6 +80,15 @@ xchk_setup_inode_bmap( error =filemap_fdatawait_keep_errors (mapping);if (error && (error != -ENOSPC && error != -EIO )) goto out; + +/* Drop the page cache if we're repairing block mappings. */ +if (is_repair) { + error =invalidate_inode_pages2 ( +VFS_I (sc->ip)->i_mapping); +if (error) + goto out; + } + }/* Got the inode, lock it and we're ready to go. */
fs/xfs/scrub/bmap_repair.c new file +849 -0
849 lines not on this page · raw message
fs/xfs/scrub/common.h +5 -1
@@ -214,7 +214,11 @@ int xchk_metadata_inode_forks(struct xfs_scrub *sc); (sc)->mp->m_super->s_id, \ (sc)->sa.pag ? (sc)->sa.pag->pag_agno : (sc)->sm->sm_agno, \ ##__VA_ARGS__) - +#define xchk_xfile_ino_descr (sc, fmt, ...) \ + kasprintf(XCHK_GFP_FLAGS, "XFS (%s): inode 0x%llx " fmt, \ + (sc)->mp->m_super->s_id, \ + (sc)->ip ? (sc)->ip->i_ino : (sc)->sm->sm_ino, \ + ##__VA_ARGS__)/* * Setting up a hook to wait for intents to drain is costly -- we have to take
fs/xfs/scrub/repair.c +28 -0
@@ -880,6 +880,34 @@ xrep_reinit_pagi(return 0 ; } +/* +* Given an active reference to a perag structure, load AG headers and cursors. +* This should only be called to scan an AG while repairing file-based metadata. +*/ +int +xrep_ag_init ( +struct xfs_scrub *sc, +struct xfs_perag *pag, +struct xchk_ag *sa) +{ +int error; + +ASSERT (!sa->pag); + + error =xfs_ialloc_read_agi (pag, sc->tp, &sa->agi_bp); +if (error) +return error; + + error =xfs_alloc_read_agf (pag, sc->tp,0 , &sa->agf_bp); +if (error) +return error; + +/* Grab our own passive reference from the caller's ref. */ + sa->pag =xfs_perag_hold (pag); +xrep_ag_btcur_init (sc, sa); +return 0 ; +} +/* Reinitialize the per-AG block reservation for the AG we just fixed. */ int xrep_reset_perag_resv(
fs/xfs/scrub/repair.h +6 -0
@@ -81,6 +81,8 @@ struct xfs_imap;int xrep_setup_inode (struct xfs_scrub *sc,struct xfs_imap *imap);void xrep_ag_btcur_init (struct xfs_scrub *sc,struct xchk_ag *sa); +int xrep_ag_init (struct xfs_scrub *sc,struct xfs_perag *pag, +struct xchk_ag *sa);/* Metadata revalidators */
@@ -98,6 +100,8 @@ int xrep_allocbt(struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc);int xrep_refcountbt (struct xfs_scrub *sc);int xrep_inode (struct xfs_scrub *sc); +int xrep_bmap_data (struct xfs_scrub *sc); +int xrep_bmap_attr (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -157,6 +161,8 @@ xrep_setup_nothing(#define xrep_iallocbt xrep_notsupported#define xrep_refcountbt xrep_notsupported#define xrep_inode xrep_notsupported +#define xrep_bmap_data xrep_notsupported +#define xrep_bmap_attr xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +2 -2
@@ -288,13 +288,13 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_data, - .repair = xrep_notsupported, + .repair = xrep_bmap_data, }, [XFS_SCRUB_TYPE_BMBTA] = { /* inode attr fork */ .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_attr, - .repair = xrep_notsupported, + .repair = xrep_bmap_attr, }, [XFS_SCRUB_TYPE_BMBTC] = { /* inode CoW fork */ .type = ST_INODE,
fs/xfs/scrub/trace.h +33 -1
@@ -1148,7 +1148,7 @@ DEFINE_EVENT(xrep_rmap_class, name, \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags))DEFINE_REPAIR_RMAP_EVENT (xrep_ibt_walk_rmap);DEFINE_REPAIR_RMAP_EVENT (xrep_rmap_extent_fn); -DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_extent_fn); +DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_walk_rmap); TRACE_EVENT(xrep_abt_found, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
@@ -1233,6 +1233,38 @@ TRACE_EVENT(xrep_refc_found, __entry->refcount) ) +TRACE_EVENT (xrep_bmap_found, + TP_PROTO(struct xfs_inode *ip, int whichfork, + struct xfs_bmbt_irec *irec), +TP_ARGS (ip, whichfork, irec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(int, whichfork) + __field(xfs_fileoff_t, lblk) + __field(xfs_filblks_t, len) + __field(xfs_fsblock_t, pblk) +__field (int, state) + ), +TP_fast_assign ( + __entry->dev = VFS_I(ip)->i_sb->s_dev; + __entry->ino = ip->i_ino; + __entry->whichfork = whichfork; + __entry->lblk = irec->br_startoff; + __entry->len = irec->br_blockcount; + __entry->pblk = irec->br_startblock; + __entry->state = irec->br_state; + ), +TP_printk ("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, +__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), + __entry->lblk, + __entry->len, + __entry->pblk, + __entry->state) +); + TRACE_EVENT(xrep_findroot_block, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, uint32_t magic, uint16_t level),
fs/xfs/xfs_trans.c +95 -0
107 lines not on this page · raw message
fs/xfs/xfs_trans.h +4 -0
@@ -168,6 +168,8 @@ typedef struct xfs_trans {int xfs_trans_alloc (struct xfs_mount *mp,struct xfs_trans_res *resp,uint blocks,uint rtextents,uint flags,struct xfs_trans **tpp); +int xfs_trans_reserve_more (struct xfs_trans *tp, +unsigned int blocks,unsigned int rtextents);int xfs_trans_alloc_empty (struct xfs_mount *mp,struct xfs_trans **tpp);void xfs_trans_mod_sb (xfs_trans_t *,uint ,int64_t );
@@ -260,6 +262,8 @@ struct xfs_dquot;int xfs_trans_alloc_inode (struct xfs_inode *ip,struct xfs_trans_res *resv,unsigned int dblocks,unsigned int rblocks,bool force,struct xfs_trans **tpp); +int xfs_trans_reserve_more_inode (struct xfs_trans *tp,struct xfs_inode *ip, +unsigned int dblocks,unsigned int rblocks,bool force_quota); int xfs_trans_alloc_icreate(struct xfs_mount *mp, struct xfs_trans_res *resv, struct xfs_dquot *udqp, struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, unsigned int dblocks,
PATCH 3/5 xfs: refactor repair forcing tests into a repair.c helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
There are a couple of conditions that userspace can set to force repairs of metadata. These really belong in the repair code and not open-coded into the check code, so refactor them into a helper.
--- fs/xfs/scrub/repair.c | 22 ++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 ++ fs/xfs/scrub/scrub.c | 14 +------------- 3 files changed, 25 insertions(+), 13 deletions(-)
fs/xfs/scrub/repair.c +22 -0
@@ -27,6 +27,8 @@#include "xfs_quota.h" #include "xfs_qm.h" #include "xfs_defer.h" +#include "xfs_errortag.h" +#include "xfs_error.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -937,3 +939,23 @@ xrep_reset_perag_resv( out:return error; } + +/* Decide if we are going to call the repair function for a scrub type. */ +bool +xrep_will_attempt ( +struct xfs_scrub *sc) +{ +/* Userspace asked us to rebuild the structure regardless. */ +if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) +return true; + +/* Let debug users force us into the repair routines. */ +if (XFS_TEST_ERROR (false, sc->mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) +return true; + +/* Metadata is corrupt or failed cross-referencing. */ +if (xchk_needs_repair (sc->sm)) +return true; + +return false; +}
fs/xfs/scrub/repair.h +2 -0
@@ -20,6 +20,7 @@ static inline int xrep_notsupported(struct xfs_scrub *sc)/* Repair helpers */ int xrep_attempt (struct xfs_scrub *sc,struct xchk_stats_run *run); +bool xrep_will_attempt (struct xfs_scrub *sc);void xrep_failure (struct xfs_mount *mp);int xrep_roll_ag_trans (struct xfs_scrub *sc);int xrep_roll_trans (struct xfs_scrub *sc);
@@ -109,6 +110,7 @@ int xrep_reinit_pagi(struct xfs_scrub *sc);#else #define xrep_ino_dqattach (sc) (0) +#define xrep_will_attempt (sc) (false)static inline int xrep_attempt(
fs/xfs/scrub/scrub.c +1 -13
@@ -14,8 +14,6 @@#include "xfs_inode.h" #include "xfs_quota.h" #include "xfs_qm.h" -#include "xfs_errortag.h" -#include "xfs_error.h" #include "xfs_scrub.h" #include "xfs_btree.h" #include "xfs_btree_staging.h"
@@ -548,21 +546,11 @@ xfs_scrub_metadata(xchk_update_health (sc);if (xchk_could_repair (sc)) { -bool needs_fix =xchk_needs_repair (sc->sm); - -/* Userspace asked us to rebuild the structure regardless. */ -if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_FORCE_REBUILD ) - needs_fix = true; - -/* Let debug users force us into the repair routines. */ -if (XFS_TEST_ERROR (needs_fix, mp,XFS_ERRTAG_FORCE_SCRUB_REPAIR )) - needs_fix = true; -/* * If userspace asked for a repair but it wasn't necessary, * report that back to userspace. */ -if (!needs_fix) { +if (!xrep_will_attempt (sc)) { sc->sm->sm_flags |=XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ; goto out_nofix; }
PATCH 4/5 xfs: create a ranged query function for refcount btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Implement ranged queries for refcount records. The next patch will use this to scan refcount data.
--- fs/xfs/libxfs/xfs_refcount.c | 41 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_refcount.h | 10 ++++++++++ 2 files changed, 51 insertions(+)
fs/xfs/libxfs/xfs_refcount.c +41 -0
@@ -2039,6 +2039,47 @@ xfs_refcount_has_records(return xfs_btree_has_records (cur, &low, &high,NULL , outcome); } +struct xfs_refcount_query_range_info { +xfs_refcount_query_range_fn fn; +void *priv; +}; + +/* Format btree record and pass to our callback. */ +STATIC int +xfs_refcount_query_range_helper ( +struct xfs_btree_cur *cur, +const union xfs_btree_rec *rec, +void *priv) +{ +struct xfs_refcount_query_range_info *query = priv; +struct xfs_refcount_irec irec; +xfs_failaddr_t fa; + +xfs_refcount_btrec_to_irec (rec, &irec); + fa =xfs_refcount_check_irec (cur, &irec); +if (fa) +return xfs_refcount_complain_bad_rec (cur, fa, &irec); + +return query->fn (cur, &irec, query->priv); +} + +/* Find all refcount records between two keys. */ +int +xfs_refcount_query_range ( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *low_rec, +const struct xfs_refcount_irec *high_rec, +xfs_refcount_query_range_fn fn, +void *priv) +{ +union xfs_btree_irec low_brec = { .rc = *low_rec }; +union xfs_btree_irec high_brec = { .rc = *high_rec }; +struct xfs_refcount_query_range_info query = { .priv = priv, .fn = fn }; + +return xfs_btree_query_range (cur, &low_brec, &high_brec, + xfs_refcount_query_range_helper, &query); +} +int __init xfs_refcount_intent_init_cache (void ) {
fs/xfs/libxfs/xfs_refcount.h +10 -0
@@ -129,4 +129,14 @@ extern struct kmem_cache *xfs_refcount_intent_cache;int __init xfs_refcount_intent_init_cache (void );void xfs_refcount_intent_destroy_cache (void ); +typedef int (*xfs_refcount_query_range_fn )( +struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *rec, +void *priv); + +int xfs_refcount_query_range (struct xfs_btree_cur *cur, +const struct xfs_refcount_irec *low_rec, +const struct xfs_refcount_irec *high_rec, +xfs_refcount_query_range_fn fn,void *priv); +#endif /* __XFS_REFCOUNT_H__ */
PATCH 5/5 xfs: repair problems in CoW forks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Try to repair errors that we see in file CoW forks so that we don't do stupid things like remap garbage into a file. There's not a lot we can do with the COW fork -- the ondisk metadata record only that the COW staging extents are owned by the refcount btree, which effectively means that we can't reconstruct this incore structure from scratch.
Actually, this is even worse -- we can't touch written extents, because those map space that are actively under writeback, and there's not much to do with delalloc reservations. Hence we can only detect crosslinked unwritten extents and fix them by punching out the problematic parts and replacing them with delalloc extents.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/cow_repair.c | 609 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/reap.c | 32 ++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 84 ++++++ 6 files changed, 729 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/scrub/cow_repair.c
fs/xfs/Makefile +1 -0
@@ -183,6 +183,7 @@ xfs-y += $(addprefix scrub/, \ agheader_repair.o \ alloc_repair.o \ bmap_repair.o \ + cow_repair.o \ ialloc_repair.o \ inode_repair.o \ newbt.o \
fs/xfs/scrub/cow_repair.c new file +609 -0
609 lines not on this page · raw message
fs/xfs/scrub/reap.c +32 -0
@@ -20,6 +20,7 @@#include "xfs_ialloc_btree.h" #include "xfs_rmap.h" #include "xfs_rmap_btree.h" +#include "xfs_refcount.h" #include "xfs_refcount_btree.h" #include "xfs_extent_busy.h" #include "xfs_ag.h"
@@ -378,6 +379,17 @@ xreap_agextent_iter(trace_xreap_dispose_unmap_extent (sc->sa.pag, agbno, *aglenp); rs->force_roll = true; + +if (rs->oinfo == &XFS_RMAP_OINFO_COW ) { +/* +* If we're unmapping CoW staging extents, remove the +* records from the refcountbt, which will remove the +* rmap record as well. +*/ +xfs_refcount_free_cow_extent (sc->tp, fsbno, *aglenp); +return 0 ; + } +return xfs_rmap_free (sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, *aglenp, rs->oinfo); }
@@ -396,6 +408,26 @@ xreap_agextent_iter(return 0 ; } +/* +* If we're getting rid of CoW staging extents, use deferred work items +* to remove the refcountbt records (which removes the rmap records) +* and free the extent. We're not worried about the system going down +* here because log recovery walks the refcount btree to clean out the +* CoW staging extents. +*/ +if (rs->oinfo == &XFS_RMAP_OINFO_COW ) { +ASSERT (rs->resv ==XFS_AG_RESV_NONE ); + +xfs_refcount_free_cow_extent (sc->tp, fsbno, *aglenp); + error =__xfs_free_extent_later (sc->tp, fsbno, *aglenp,NULL , + rs->resv, true); +if (error) +return error; + + rs->force_roll = true; +return 0 ; + } +/* Put blocks back on the AGFL one at a time. */ if (rs->resv ==XFS_AG_RESV_AGFL ) {ASSERT (*aglenp ==1 );
fs/xfs/scrub/repair.h +2 -0
@@ -103,6 +103,7 @@ int xrep_refcountbt(struct xfs_scrub *sc);int xrep_inode (struct xfs_scrub *sc);int xrep_bmap_data (struct xfs_scrub *sc);int xrep_bmap_attr (struct xfs_scrub *sc); +int xrep_bmap_cow (struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc);
@@ -165,6 +166,7 @@ xrep_setup_nothing(#define xrep_inode xrep_notsupported#define xrep_bmap_data xrep_notsupported#define xrep_bmap_attr xrep_notsupported +#define xrep_bmap_cow xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -298,7 +298,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_INODE, .setup = xchk_setup_inode_bmap, .scrub = xchk_bmap_cow, - .repair = xrep_notsupported, + .repair = xrep_bmap_cow, }, [XFS_SCRUB_TYPE_DIR] = { /* directory */ .type = ST_INODE,
fs/xfs/scrub/trace.h +84 -0
90 lines not on this page · raw message