[PATCH 6/7] xfs: log EFIs for all btree blocks being used to stage a btree

Darrick J. Wong
2023-11-24T23:48:28Z

From: Darrick J. Wong <djwong@kernel.org>

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. Use the autoreaping mechanism provided by the
previous patch to attach paused freeing work to the scrub transaction.
We can then mark the EFIs stale if we decide to commit the new btree, or
we can unpause the EFIs if we decide to abort the repair.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
---
fs/xfs/scrub/newbt.c | 34 ++++++++++++++++++++++++++--------
fs/xfs/scrub/newbt.h | 3 +++
2 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/fs/xfs/scrub/newbt.c b/fs/xfs/scrub/newbt.c
index 4e8d6637426e4..2932fd317ab23 100644
--- a/fs/xfs/scrub/newbt.c
+++ b/fs/xfs/scrub/newbt.c
@@ -136,6 +136,7 @@ xrep_newbt_add_blocks(
{
struct xfs_mount *mp = xnr->sc->mp;
struct xrep_newbt_resv *resv;
+ int error;

resv = kmalloc(sizeof(struct xrep_newbt_resv), XCHK_GFP_FLAGS);
if (!resv)
@@ -147,8 +148,18 @@ xrep_newbt_add_blocks(
resv->used = 0;
resv->pag = xfs_perag_hold(pag);

+ ASSERT(xnr->oinfo.oi_offset == 0);
+
+ error = xfs_alloc_schedule_autoreap(args, true, &resv->autoreap);
+ 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 */
@@ -327,16 +338,21 @@ xrep_newbt_free_extent(
if (!btree_committed || resv->used == 0) {
/*
* If we're not committing a new btree or we didn't use the
- * space reservation, free the entire space extent.
+ * space reservation, let the existing EFI free the entire
+ * space extent.
*/
- goto free;
+ trace_xrep_newbt_free_blocks(sc->mp, resv->pag->pag_agno,
+ free_agbno, free_aglen, xnr->oinfo.oi_owner);
+ xfs_alloc_commit_autoreap(sc->tp, &resv->autoreap);
+ return 1;
}

/*
- * We used space and committed the btree. Remove the written blocks
- * from the reservation and possibly log a new EFI to free any unused
- * reservation space.
+ * We used space and committed the btree. Cancel the autoreap, remove
+ * the written blocks from the reservation, and possibly log a new EFI
+ * to free any unused reservation space.
*/
+ xfs_alloc_cancel_autoreap(sc->tp, &resv->autoreap);
free_agbno += resv->used;
free_aglen -= resv->used;

@@ -348,7 +364,6 @@ xrep_newbt_free_extent(

ASSERT(xnr->resv != XFS_AG_RESV_AGFL);

-free:
/*
* Use EFIs to free the reservations. This reduces the chance
* that we leak blocks if the system goes down.
@@ -408,9 +423,10 @@ xrep_newbt_free(
/*
* If we still have reservations attached to @newbt, cleanup must have
* failed and the filesystem is about to go down. Clean up the incore
- * reservations.
+ * reservations and try to commit to freeing the space we used.
*/
list_for_each_entry_safe(resv, n, &xnr->resv_list, list) {
+ xfs_alloc_commit_autoreap(sc->tp, &resv->autoreap);
list_del(&resv->list);
xfs_perag_put(resv->pag);
kfree(resv);
@@ -488,5 +504,7 @@ xrep_newbt_claim_block(
agbno));
else
ptr->s = cpu_to_be32(agbno);
- return 0;
+
+ /* Relog all the EFIs. */
+ return xrep_defer_finish(xnr->sc);
}
diff --git a/fs/xfs/scrub/newbt.h b/fs/xfs/scrub/newbt.h
index ca53271f3a4c6..d2baffa17b1ae 100644
--- a/fs/xfs/scrub/newbt.h
+++ b/fs/xfs/scrub/newbt.h
@@ -12,6 +12,9 @@ struct xrep_newbt_resv {

struct xfs_perag *pag;

+ /* Auto-freeing this reservation if we don't commit. */
+ struct xfs_alloc_autoreap autoreap;
+
/* AG block of the extent we reserved. */
xfs_agblock_t agbno;