Merge tag 'repair-reap-fixes-6.6_2023-08-10' of... (81fbc5f9) · Commits · jan.koester / Linux

fs/xfs/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -173,6 +173,7 @@ xfs-$(CONFIG_XFS_QUOTA) += scrub/quota.o
	ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y)		ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y)
	xfs-y += $(addprefix scrub/, \		xfs-y += $(addprefix scrub/, \
	agheader_repair.o \		agheader_repair.o \
			reap.o \
	repair.o \		repair.o \
	)		)
	endif		endif

fs/xfs/scrub/agheader_repair.c

+35 −40

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@
	#include "scrub/trace.h"		#include "scrub/trace.h"
	#include "scrub/repair.h"		#include "scrub/repair.h"
	#include "scrub/bitmap.h"		#include "scrub/bitmap.h"
			#include "scrub/reap.h"

	/* Superblock */		/* Superblock */

	@@ -444,13 +445,13 @@ xrep_agf(

	struct xrep_agfl {		struct xrep_agfl {
	/* Bitmap of alleged AGFL blocks that we're not going to add. */		/* 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. */		/* Bitmap of other OWN_AG metadata blocks. */
	struct xbitmap agmetablocks;		struct xagb_bitmap agmetablocks;

	/* Bitmap of free space. */		/* Bitmap of free space. */
	struct xbitmap *freesp;		struct xagb_bitmap *freesp;

	/* rmapbt cursor for finding crosslinked blocks */		/* rmapbt cursor for finding crosslinked blocks */
	struct xfs_btree_cur *rmap_cur;		struct xfs_btree_cur *rmap_cur;
	@@ -466,7 +467,6 @@ xrep_agfl_walk_rmap(
	void *priv)		void *priv)
	{		{
	struct xrep_agfl *ra = priv;		struct xrep_agfl *ra = priv;
	xfs_fsblock_t fsb;
	int error = 0;		int error = 0;

	if (xchk_should_terminate(ra->sc, &error))		if (xchk_should_terminate(ra->sc, &error))
	@@ -474,14 +474,13 @@ xrep_agfl_walk_rmap(

	/* Record all the OWN_AG blocks. */		/* Record all the OWN_AG blocks. */
	if (rec->rm_owner == XFS_RMAP_OWN_AG) {		if (rec->rm_owner == XFS_RMAP_OWN_AG) {
	fsb = XFS_AGB_TO_FSB(cur->bc_mp, cur->bc_ag.pag->pag_agno,		error = xagb_bitmap_set(ra->freesp, rec->rm_startblock,
	rec->rm_startblock);		rec->rm_blockcount);
	error = xbitmap_set(ra->freesp, fsb, rec->rm_blockcount);
	if (error)		if (error)
	return 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. */		/* Strike out the blocks that are cross-linked according to the rmapbt. */
	@@ -492,12 +491,10 @@ xrep_agfl_check_extent(
	void *priv)		void *priv)
	{		{
	struct xrep_agfl *ra = 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;		xfs_agblock_t last_agbno = agbno + len - 1;
	int error;		int error;

	ASSERT(XFS_FSB_TO_AGNO(ra->sc->mp, start) == ra->sc->sa.pag->pag_agno);

	while (agbno <= last_agbno) {		while (agbno <= last_agbno) {
	bool other_owners;		bool other_owners;

	@@ -507,7 +504,7 @@ xrep_agfl_check_extent(
	return error;		return error;

	if (other_owners) {		if (other_owners) {
	error = xbitmap_set(&ra->crossed, agbno, 1);		error = xagb_bitmap_set(&ra->crossed, agbno, 1);
	if (error)		if (error)
	return error;		return error;
	}		}
	@@ -533,7 +530,7 @@ STATIC int
	xrep_agfl_collect_blocks(		xrep_agfl_collect_blocks(
	struct xfs_scrub *sc,		struct xfs_scrub *sc,
	struct xfs_buf *agf_bp,		struct xfs_buf *agf_bp,
	struct xbitmap *agfl_extents,		struct xagb_bitmap *agfl_extents,
	xfs_agblock_t *flcount)		xfs_agblock_t *flcount)
	{		{
	struct xrep_agfl ra;		struct xrep_agfl ra;
	@@ -543,8 +540,8 @@ xrep_agfl_collect_blocks(

	ra.sc = sc;		ra.sc = sc;
	ra.freesp = agfl_extents;		ra.freesp = agfl_extents;
	xbitmap_init(&ra.agmetablocks);		xagb_bitmap_init(&ra.agmetablocks);
	xbitmap_init(&ra.crossed);		xagb_bitmap_init(&ra.crossed);

	/* Find all space used by the free space btrees & rmapbt. */		/* Find all space used by the free space btrees & rmapbt. */
	cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);		cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);
	@@ -556,7 +553,7 @@ xrep_agfl_collect_blocks(
	/* Find all blocks currently being used by the bnobt. */		/* Find all blocks currently being used by the bnobt. */
	cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp,		cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp,
	sc->sa.pag, XFS_BTNUM_BNO);		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);		xfs_btree_del_cursor(cur, error);
	if (error)		if (error)
	goto out_bmp;		goto out_bmp;
	@@ -564,7 +561,7 @@ xrep_agfl_collect_blocks(
	/* Find all blocks currently being used by the cntbt. */		/* Find all blocks currently being used by the cntbt. */
	cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp,		cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp,
	sc->sa.pag, XFS_BTNUM_CNT);		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);		xfs_btree_del_cursor(cur, error);
	if (error)		if (error)
	goto out_bmp;		goto out_bmp;
	@@ -573,17 +570,17 @@ xrep_agfl_collect_blocks(
	* Drop the freesp meta blocks that are in use by btrees.		* Drop the freesp meta blocks that are in use by btrees.
	* The remaining blocks /should/ be AGFL blocks.		* The remaining blocks /should/ be AGFL blocks.
	*/		*/
	error = xbitmap_disunion(agfl_extents, &ra.agmetablocks);		error = xagb_bitmap_disunion(agfl_extents, &ra.agmetablocks);
	if (error)		if (error)
	goto out_bmp;		goto out_bmp;

	/* Strike out the blocks that are cross-linked. */		/* Strike out the blocks that are cross-linked. */
	ra.rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);		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);		xfs_btree_del_cursor(ra.rmap_cur, error);
	if (error)		if (error)
	goto out_bmp;		goto out_bmp;
	error = xbitmap_disunion(agfl_extents, &ra.crossed);		error = xagb_bitmap_disunion(agfl_extents, &ra.crossed);
	if (error)		if (error)
	goto out_bmp;		goto out_bmp;

	@@ -591,12 +588,12 @@ xrep_agfl_collect_blocks(
	* Calculate the new AGFL size. If we found more blocks than fit in		* Calculate the new AGFL size. If we found more blocks than fit in
	* the AGFL we'll free them later.		* 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));		xfs_agfl_size(mp));

	out_bmp:		out_bmp:
	xbitmap_destroy(&ra.crossed);		xagb_bitmap_destroy(&ra.crossed);
	xbitmap_destroy(&ra.agmetablocks);		xagb_bitmap_destroy(&ra.agmetablocks);
	return error;		return error;
	}		}

	@@ -626,7 +623,7 @@ xrep_agfl_update_agf(
	}		}

	struct xrep_agfl_fill {		struct xrep_agfl_fill {
	struct xbitmap used_extents;		struct xagb_bitmap used_extents;
	struct xfs_scrub *sc;		struct xfs_scrub *sc;
	__be32 *agfl_bno;		__be32 *agfl_bno;
	xfs_agblock_t flcount;		xfs_agblock_t flcount;
	@@ -642,17 +639,15 @@ xrep_agfl_fill(
	{		{
	struct xrep_agfl_fill *af = priv;		struct xrep_agfl_fill *af = priv;
	struct xfs_scrub *sc = af->sc;		struct xfs_scrub *sc = af->sc;
	xfs_fsblock_t fsbno = start;		xfs_agblock_t agbno = start;
	int error;		int error;

	while (fsbno < start + len && af->fl_off < af->flcount)		trace_xrep_agfl_insert(sc->sa.pag, agbno, len);
	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,		while (agbno < start + len && af->fl_off < af->flcount)
	XFS_FSB_TO_AGBNO(sc->mp, start), len);		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)		if (error)
	return error;		return error;

	@@ -667,7 +662,7 @@ STATIC int
	xrep_agfl_init_header(		xrep_agfl_init_header(
	struct xfs_scrub *sc,		struct xfs_scrub *sc,
	struct xfs_buf *agfl_bp,		struct xfs_buf *agfl_bp,
	struct xbitmap *agfl_extents,		struct xagb_bitmap *agfl_extents,
	xfs_agblock_t flcount)		xfs_agblock_t flcount)
	{		{
	struct xrep_agfl_fill af = {		struct xrep_agfl_fill af = {
	@@ -695,17 +690,17 @@ xrep_agfl_init_header(
	* blocks than fit in the AGFL, they will be freed in a subsequent		* blocks than fit in the AGFL, they will be freed in a subsequent
	* step.		* step.
	*/		*/
	xbitmap_init(&af.used_extents);		xagb_bitmap_init(&af.used_extents);
	af.agfl_bno = xfs_buf_to_agfl_bno(agfl_bp),		af.agfl_bno = xfs_buf_to_agfl_bno(agfl_bp),
	xbitmap_walk(agfl_extents, xrep_agfl_fill, &af);		xagb_bitmap_walk(agfl_extents, xrep_agfl_fill, &af);
	error = xbitmap_disunion(agfl_extents, &af.used_extents);		error = xagb_bitmap_disunion(agfl_extents, &af.used_extents);
	if (error)		if (error)
	return error;		return error;

	/* Write new AGFL to disk. */		/* Write new AGFL to disk. */
	xfs_trans_buf_set_type(sc->tp, agfl_bp, XFS_BLFT_AGFL_BUF);		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);		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;		return 0;
	}		}

	@@ -714,7 +709,7 @@ int
	xrep_agfl(		xrep_agfl(
	struct xfs_scrub *sc)		struct xfs_scrub *sc)
	{		{
	struct xbitmap agfl_extents;		struct xagb_bitmap agfl_extents;
	struct xfs_mount *mp = sc->mp;		struct xfs_mount *mp = sc->mp;
	struct xfs_buf *agf_bp;		struct xfs_buf *agf_bp;
	struct xfs_buf *agfl_bp;		struct xfs_buf *agfl_bp;
	@@ -725,7 +720,7 @@ xrep_agfl(
	if (!xfs_has_rmapbt(mp))		if (!xfs_has_rmapbt(mp))
	return -EOPNOTSUPP;		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		* Read the AGF so that we can query the rmapbt. We hope that there's
	@@ -774,10 +769,10 @@ xrep_agfl(
	goto err;		goto err;

	/* Dump any AGFL overflow. */		/* Dump any AGFL overflow. */
	error = xrep_reap_extents(sc, &agfl_extents, &XFS_RMAP_OINFO_AG,		error = xrep_reap_agblocks(sc, &agfl_extents, &XFS_RMAP_OINFO_AG,
	XFS_AG_RESV_AGFL);		XFS_AG_RESV_AGFL);
	err:		err:
	xbitmap_destroy(&agfl_extents);		xagb_bitmap_destroy(&agfl_extents);
	return error;		return error;
	}		}

fs/xfs/scrub/bitmap.c

+3 −75

Original line number	Original line	Diff line number	Diff line
	@@ -301,21 +301,15 @@ xagb_bitmap_set_btblocks(
	* blocks going from the leaf towards the root.		* blocks going from the leaf towards the root.
	*/		*/
	int		int
	xbitmap_set_btcur_path(		xagb_bitmap_set_btcur_path(
	struct xbitmap *bitmap,		struct xagb_bitmap *bitmap,
	struct xfs_btree_cur *cur)		struct xfs_btree_cur *cur)
	{		{
	struct xfs_buf *bp;
	xfs_fsblock_t fsb;
	int i;		int i;
	int error;		int error;

	for (i = 0; i < cur->bc_nlevels && cur->bc_levels[i].ptr == 1; i++) {		for (i = 0; i < cur->bc_nlevels && cur->bc_levels[i].ptr == 1; i++) {
	xfs_btree_get_block(cur, i, &bp);		error = xagb_bitmap_visit_btblock(cur, i, bitmap);
	if (!bp)
	continue;
	fsb = XFS_DADDR_TO_FSB(cur->bc_mp, xfs_buf_daddr(bp));
	error = xbitmap_set(bitmap, fsb, 1);
	if (error)		if (error)
	return error;		return error;
	}		}
	@@ -323,35 +317,6 @@ xbitmap_set_btcur_path(
	return 0;		return 0;
	}		}

	/* Collect a btree's block in the bitmap. */
	STATIC int
	xbitmap_collect_btblock(
	struct xfs_btree_cur *cur,
	int level,
	void *priv)
	{
	struct xbitmap *bitmap = priv;
	struct xfs_buf *bp;
	xfs_fsblock_t fsbno;

	xfs_btree_get_block(cur, level, &bp);
	if (!bp)
	return 0;

	fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, xfs_buf_daddr(bp));
	return xbitmap_set(bitmap, fsbno, 1);
	}

	/* Walk the btree and mark the bitmap wherever a btree block is found. */
	int
	xbitmap_set_btblocks(
	struct xbitmap *bitmap,
	struct xfs_btree_cur *cur)
	{
	return xfs_btree_visit_blocks(cur, xbitmap_collect_btblock,
	XFS_BTREE_VISIT_ALL, bitmap);
	}

	/* How many bits are set in this bitmap? */		/* How many bits are set in this bitmap? */
	uint64_t		uint64_t
	xbitmap_hweight(		xbitmap_hweight(
	@@ -385,43 +350,6 @@ xbitmap_walk(
	return error;		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? */		/* Does this bitmap have no bits set at all? */
	bool		bool
	xbitmap_empty(		xbitmap_empty(

fs/xfs/scrub/bitmap.h

+2 −8

Original line number	Original line	Diff line number	Diff line
	@@ -16,10 +16,6 @@ void xbitmap_destroy(struct xbitmap *bitmap);
	int xbitmap_clear(struct xbitmap *bitmap, uint64_t start, uint64_t len);		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_set(struct xbitmap *bitmap, uint64_t start, uint64_t len);
	int xbitmap_disunion(struct xbitmap bitmap, struct xbitmap sub);		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);		uint64_t xbitmap_hweight(struct xbitmap *bitmap);

	/*		/*
	@@ -33,10 +29,6 @@ typedef int (xbitmap_walk_fn)(uint64_t start, uint64_t len, void priv);
	int xbitmap_walk(struct xbitmap *bitmap, xbitmap_walk_fn fn,		int xbitmap_walk(struct xbitmap *bitmap, xbitmap_walk_fn fn,
	void *priv);		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_empty(struct xbitmap *bitmap);
	bool xbitmap_test(struct xbitmap bitmap, uint64_t start, uint64_t len);		bool xbitmap_test(struct xbitmap bitmap, uint64_t start, uint64_t len);

	@@ -110,5 +102,7 @@ static inline int xagb_bitmap_walk(struct xagb_bitmap *bitmap,

	int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,		int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,
	struct xfs_btree_cur *cur);		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__ */		#endif /* __XFS_SCRUB_BITMAP_H__ */

fs/xfs/scrub/reap.c

0 → 100644

+498 −0

Original line number	Original line	Diff line number	Diff line
			// SPDX-License-Identifier: GPL-2.0-or-later
			/*
			* Copyright (C) 2022-2023 Oracle. All Rights Reserved.
			* Author: Darrick J. Wong <djwong@kernel.org>
			*/
			#include "xfs.h"
			#include "xfs_fs.h"
			#include "xfs_shared.h"
			#include "xfs_format.h"
			#include "xfs_trans_resv.h"
			#include "xfs_mount.h"
			#include "xfs_btree.h"
			#include "xfs_log_format.h"
			#include "xfs_trans.h"
			#include "xfs_sb.h"
			#include "xfs_inode.h"
			#include "xfs_alloc.h"
			#include "xfs_alloc_btree.h"
			#include "xfs_ialloc.h"
			#include "xfs_ialloc_btree.h"
			#include "xfs_rmap.h"
			#include "xfs_rmap_btree.h"
			#include "xfs_refcount_btree.h"
			#include "xfs_extent_busy.h"
			#include "xfs_ag.h"
			#include "xfs_ag_resv.h"
			#include "xfs_quota.h"
			#include "xfs_qm.h"
			#include "xfs_bmap.h"
			#include "xfs_da_format.h"
			#include "xfs_da_btree.h"
			#include "xfs_attr.h"
			#include "xfs_attr_remote.h"
			#include "scrub/scrub.h"
			#include "scrub/common.h"
			#include "scrub/trace.h"
			#include "scrub/repair.h"
			#include "scrub/bitmap.h"
			#include "scrub/reap.h"

			/*
			* Disposal of Blocks from Old Metadata
			*
			* Now that we've constructed a new btree to replace the damaged one, we want
			* to dispose of the blocks that (we think) the old btree was using.
			* Previously, we used the rmapbt to collect the extents (bitmap) with the
			* rmap owner corresponding to the tree we rebuilt, collected extents for any
			* blocks with the same rmap owner that are owned by another data structure
			* (sublist), and subtracted sublist from bitmap. In theory the extents
			* remaining in bitmap are the old btree's blocks.
			*
			* Unfortunately, it's possible that the btree was crosslinked with other
			* blocks on disk. The rmap data can tell us if there are multiple owners, so
			* if the rmapbt says there is an owner of this block other than @oinfo, then
			* the block is crosslinked. Remove the reverse mapping and continue.
			*
			* If there is one rmap record, we can free the block, which removes the
			* reverse mapping but doesn't add the block to the free space. Our repair
			* strategy is to hope the other metadata objects crosslinked on this block
			* will be rebuilt (atop different blocks), thereby removing all the cross
			* links.
			*
			* If there are no rmap records at all, we also free the block. If the btree
			* being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't
			* supposed to be a rmap record and everything is ok. For other btrees there
			* had to have been an rmap entry for the block to have ended up on @bitmap,
			* so if it's gone now there's something wrong and the fs will shut down.
			*
			* Note: If there are multiple rmap records with only the same rmap owner as
			* the btree we're trying to rebuild and the block is indeed owned by another
			* data structure with the same rmap owner, then the block will be in sublist
			* and therefore doesn't need disposal. If there are multiple rmap records
			* with only the same rmap owner but the block is not owned by something with
			* the same rmap owner, the block will be freed.
			*
			* The caller is responsible for locking the AG headers for the entire rebuild
			* operation so that nothing else can sneak in and change the AG state while
			* we're not looking. We must also invalidate any buffers associated with
			* @bitmap.
			*/

			/* Information about reaping extents after a repair. */
			struct xreap_state {
			struct xfs_scrub *sc;

			/* Reverse mapping owner and metadata reservation type. */
			const struct xfs_owner_info *oinfo;
			enum xfs_ag_resv_type resv;

			/* If true, roll the transaction before reaping the next extent. */
			bool force_roll;

			/* Number of deferred reaps attached to the current transaction. */
			unsigned int deferred;

			/* Number of invalidated buffers logged to the current transaction. */
			unsigned int invalidated;

			/* Number of deferred reaps queued during the whole reap sequence. */
			unsigned long long total_deferred;
			};

			/* Put a block back on the AGFL. */
			STATIC int
			xreap_put_freelist(
			struct xfs_scrub *sc,
			xfs_agblock_t agbno)
			{
			struct xfs_buf *agfl_bp;
			int error;

			/* Make sure there's space on the freelist. */
			error = xrep_fix_freelist(sc, true);
			if (error)
			return error;

			/*
			* Since we're "freeing" a lost block onto the AGFL, we have to
			* create an rmap for the block prior to merging it or else other
			* parts will break.
			*/
			error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1,
			&XFS_RMAP_OINFO_AG);
			if (error)
			return error;

			/* Put the block on the AGFL. */
			error = xfs_alloc_read_agfl(sc->sa.pag, sc->tp, &agfl_bp);
			if (error)
			return error;

			error = xfs_alloc_put_freelist(sc->sa.pag, sc->tp, sc->sa.agf_bp,
			agfl_bp, agbno, 0);
			if (error)
			return error;
			xfs_extent_busy_insert(sc->tp, sc->sa.pag, agbno, 1,
			XFS_EXTENT_BUSY_SKIP_DISCARD);

			return 0;
			}

			/* Are there any uncommitted reap operations? */
			static inline bool xreap_dirty(const struct xreap_state *rs)
			{
			if (rs->force_roll)
			return true;
			if (rs->deferred)
			return true;
			if (rs->invalidated)
			return true;
			if (rs->total_deferred)
			return true;
			return false;
			}

			#define XREAP_MAX_BINVAL (2048)

			/*
			* Decide if we want to roll the transaction after reaping an extent. We don't
			* want to overrun the transaction reservation, so we prohibit more than
			* 128 EFIs per transaction. For the same reason, we limit the number
			* of buffer invalidations to 2048.
			*/
			static inline bool xreap_want_roll(const struct xreap_state *rs)
			{
			if (rs->force_roll)
			return true;
			if (rs->deferred > XREP_MAX_ITRUNCATE_EFIS)
			return true;
			if (rs->invalidated > XREAP_MAX_BINVAL)
			return true;
			return false;
			}

			static inline void xreap_reset(struct xreap_state *rs)
			{
			rs->total_deferred += rs->deferred;
			rs->deferred = 0;
			rs->invalidated = 0;
			rs->force_roll = false;
			}

			#define XREAP_MAX_DEFER_CHAIN (2048)

			/*
			* Decide if we want to finish the deferred ops that are attached to the scrub
			* transaction. We don't want to queue huge chains of deferred ops because
			* that can consume a lot of log space and kernel memory. Hence we trigger a
			* xfs_defer_finish if there are more than 2048 deferred reap operations or the
			* caller did some real work.
			*/
			static inline bool
			xreap_want_defer_finish(const struct xreap_state *rs)
			{
			if (rs->force_roll)
			return true;
			if (rs->total_deferred > XREAP_MAX_DEFER_CHAIN)
			return true;
			return false;
			}

			static inline void xreap_defer_finish_reset(struct xreap_state *rs)
			{
			rs->total_deferred = 0;
			rs->deferred = 0;
			rs->invalidated = 0;
			rs->force_roll = false;
			}

			/* Try to invalidate the incore buffers for an extent that we're freeing. */
			STATIC void
			xreap_agextent_binval(
			struct xreap_state *rs,
			xfs_agblock_t agbno,
			xfs_extlen_t *aglenp)
			{
			struct xfs_scrub *sc = rs->sc;
			struct xfs_perag *pag = sc->sa.pag;
			struct xfs_mount *mp = sc->mp;
			xfs_agnumber_t agno = sc->sa.pag->pag_agno;
			xfs_agblock_t agbno_next = agbno + *aglenp;
			xfs_agblock_t bno = agbno;

			/*
			* Avoid invalidating AG headers and post-EOFS blocks because we never
			* own those.
			*/
			if (!xfs_verify_agbno(pag, agbno) \|\|
			!xfs_verify_agbno(pag, agbno_next - 1))
			return;

			/*
			* If there are incore buffers for these blocks, invalidate them. We
			* assume that the lack of any other known owners means that the buffer
			* can be locked without risk of deadlocking. The buffer cache cannot
			* detect aliasing, so employ nested loops to scan for incore buffers
			* of any plausible size.
			*/
			while (bno < agbno_next) {
			xfs_agblock_t fsbcount;
			xfs_agblock_t max_fsbs;

			/*
			* Max buffer size is the max remote xattr buffer size, which
			* is one fs block larger than 64k.
			*/
			max_fsbs = min_t(xfs_agblock_t, agbno_next - bno,
			xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX));

			for (fsbcount = 1; fsbcount < max_fsbs; fsbcount++) {
			struct xfs_buf *bp = NULL;
			xfs_daddr_t daddr;
			int error;

			daddr = XFS_AGB_TO_DADDR(mp, agno, bno);
			error = xfs_buf_incore(mp->m_ddev_targp, daddr,
			XFS_FSB_TO_BB(mp, fsbcount),
			XBF_LIVESCAN, &bp);
			if (error)
			continue;

			xfs_trans_bjoin(sc->tp, bp);
			xfs_trans_binval(sc->tp, bp);
			rs->invalidated++;

			/*
			* Stop invalidating if we've hit the limit; we should
			* still have enough reservation left to free however
			* far we've gotten.
			*/
			if (rs->invalidated > XREAP_MAX_BINVAL) {
			*aglenp -= agbno_next - bno;
			goto out;
			}
			}

			bno++;
			}

			out:
			trace_xreap_agextent_binval(sc->sa.pag, agbno, *aglenp);
			}

			/*
			* Figure out the longest run of blocks that we can dispose of with a single
			* call. Cross-linked blocks should have their reverse mappings removed, but
			* single-owner extents can be freed. AGFL blocks can only be put back one at
			* a time.
			*/
			STATIC int
			xreap_agextent_select(
			struct xreap_state *rs,
			xfs_agblock_t agbno,
			xfs_agblock_t agbno_next,
			bool *crosslinked,
			xfs_extlen_t *aglenp)
			{
			struct xfs_scrub *sc = rs->sc;
			struct xfs_btree_cur *cur;
			xfs_agblock_t bno = agbno + 1;
			xfs_extlen_t len = 1;
			int error;

			/*
			* Determine if there are any other rmap records covering the first
			* block of this extent. If so, the block is crosslinked.
			*/
			cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, sc->sa.agf_bp,
			sc->sa.pag);
			error = xfs_rmap_has_other_keys(cur, agbno, 1, rs->oinfo,
			crosslinked);
			if (error)
			goto out_cur;

			/* AGFL blocks can only be deal with one at a time. */
			if (rs->resv == XFS_AG_RESV_AGFL)
			goto out_found;

			/*
			* Figure out how many of the subsequent blocks have the same crosslink
			* status.
			*/
			while (bno < agbno_next) {
			bool also_crosslinked;

			error = xfs_rmap_has_other_keys(cur, bno, 1, rs->oinfo,
			&also_crosslinked);
			if (error)
			goto out_cur;

			if (*crosslinked != also_crosslinked)
			break;

			len++;
			bno++;
			}

			out_found:
			*aglenp = len;
			trace_xreap_agextent_select(sc->sa.pag, agbno, len, *crosslinked);
			out_cur:
			xfs_btree_del_cursor(cur, error);
			return error;
			}

			/*
			* Dispose of as much of the beginning of this AG extent as possible. The
			* number of blocks disposed of will be returned in @aglenp.
			*/
			STATIC int
			xreap_agextent_iter(
			struct xreap_state *rs,
			xfs_agblock_t agbno,
			xfs_extlen_t *aglenp,
			bool crosslinked)
			{
			struct xfs_scrub *sc = rs->sc;
			xfs_fsblock_t fsbno;
			int error = 0;

			fsbno = XFS_AGB_TO_FSB(sc->mp, sc->sa.pag->pag_agno, agbno);

			/*
			* If there are other rmappings, this block is cross linked and must
			* not be freed. Remove the reverse mapping and move on. Otherwise,
			* we were the only owner of the block, so free the extent, which will
			* also remove the rmap.
			*
			* XXX: XFS doesn't support detecting the case where a single block
			* metadata structure is crosslinked with a multi-block structure
			* because the buffer cache doesn't detect aliasing problems, so we
			* can't fix 100% of crosslinking problems (yet). The verifiers will
			* blow on writeout, the filesystem will shut down, and the admin gets
			* to run xfs_repair.
			*/
			if (crosslinked) {
			trace_xreap_dispose_unmap_extent(sc->sa.pag, agbno, *aglenp);

			rs->force_roll = true;
			return xfs_rmap_free(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno,
			*aglenp, rs->oinfo);
			}

			trace_xreap_dispose_free_extent(sc->sa.pag, agbno, *aglenp);

			/*
			* Invalidate as many buffers as we can, starting at agbno. If this
			* function sets *aglenp to zero, the transaction is full of logged
			* buffer invalidations, so we need to return early so that we can
			* roll and retry.
			*/
			xreap_agextent_binval(rs, agbno, aglenp);
			if (*aglenp == 0) {
			ASSERT(xreap_want_roll(rs));
			return 0;
			}

			/* Put blocks back on the AGFL one at a time. */
			if (rs->resv == XFS_AG_RESV_AGFL) {
			ASSERT(*aglenp == 1);
			error = xreap_put_freelist(sc, agbno);
			if (error)
			return error;

			rs->force_roll = true;
			return 0;
			}

			/*
			* 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.
			*/
			error = __xfs_free_extent_later(sc->tp, fsbno, *aglenp, rs->oinfo,
			rs->resv, true);
			if (error)
			return error;

			rs->deferred++;
			return 0;
			}

			/*
			* Break an AG metadata extent into sub-extents by fate (crosslinked, not
			* crosslinked), and dispose of each sub-extent separately.
			*/
			STATIC int
			xreap_agmeta_extent(
			uint64_t fsbno,
			uint64_t len,
			void *priv)
			{
			struct xreap_state *rs = priv;
			struct xfs_scrub *sc = rs->sc;
			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);

			while (agbno < agbno_next) {
			xfs_extlen_t aglen;
			bool crosslinked;

			error = xreap_agextent_select(rs, agbno, agbno_next,
			&crosslinked, &aglen);
			if (error)
			return error;

			error = xreap_agextent_iter(rs, agbno, &aglen, crosslinked);
			if (error)
			return error;

			if (xreap_want_defer_finish(rs)) {
			error = xrep_defer_finish(sc);
			if (error)
			return error;
			xreap_defer_finish_reset(rs);
			} else if (xreap_want_roll(rs)) {
			error = xrep_roll_ag_trans(sc);
			if (error)
			return error;
			xreap_reset(rs);
			}

			agbno += aglen;
			}

			return 0;
			}

			/* Dispose of every block of every AG metadata extent in the bitmap. */
			int
			xrep_reap_agblocks(
			struct xfs_scrub *sc,
			struct xagb_bitmap *bitmap,
			const struct xfs_owner_info *oinfo,
			enum xfs_ag_resv_type type)
			{
			struct xreap_state rs = {
			.sc = sc,
			.oinfo = oinfo,
			.resv = type,
			};
			int error;

			ASSERT(xfs_has_rmapbt(sc->mp));
			ASSERT(sc->ip == NULL);

			error = xagb_bitmap_walk(bitmap, xreap_agmeta_extent, &rs);
			if (error)
			return error;

			if (xreap_dirty(&rs))
			return xrep_defer_finish(sc);

			return 0;
			}