[PATCH 0/10 v3] xfs: refactor and tablise growfs

[PATCH 0/10 v3] xfs: refactor and tablise growfs

[Dave Chinner]

THis is the third version of the growfs tablisation patchset,
addressing the changes that Darrick raised. I've reposted the
entire patchset because changes in early patches cascaded throw
several others and it was just easier to repost the lot.

Version 3:
- fix agno variable to use xfs_agnumber_t
- change ag header table to use expanded definitions
- dropped numrecs from tables as they are always either zero or hard
  coded by type specific block initialisers.

Version 2:
- rebase on current for-next
- add oneshot cached buffer support
- clean up more of the typedef usage.
- move id->nfree calc to per-ag hdr init function from the freespace
  btree root initialisation.
- only use id->type and id->numrecs for the generic btree root block
  init calls.
- only call xfs_growfs_data_private() if the size is actually being
  changed.
- make sure we still update secondary superblocks if physical grow
  fails with ENOSPC.
- change secondary superblock updates to use cached one-shot
  buffers.
- moved the core code to libxfs so it can be shared easily with
  userspace.

Version 1:
https://marc.info/?l=linux-xfs&m=151746732826277&w=2

[PATCH 01/10] xfs: one-shot cached buffers

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

For the new growfs work, we want to ensure that we serialise
secondary superblock updates with other operations (e.g. scrub)
correctly, but we don't want to cache the buffers for long term
reuse. We need cached buffers for serialisation, however.

To solve this, introduce a "oneshot" buffer which will be marshalled
through the cache but then released once the last current reference
goes away. If the buffer is already cached, then we ignore the
"one-shot" behaviour and leave the buffer in the state it was prior
to the one-shot command being run. This means we don't perturb
either the working set or existing cached buffer state by a one-shot
operation.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_buf.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 830e2f6c064a..f5f2b71c2fde 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -347,6 +347,18 @@ extern void xfs_buf_terminate(void);
 
 void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref);
 
+/*
+ * If the buffer is already on the LRU, do nothing. Otherwise set the buffer
+ * up with a reference count of 0 so it will be tossed from the cache when
+ * released.
+ */
+static inline void xfs_buf_oneshot(struct xfs_buf *bp)
+{
+	if (!list_empty(&bp->b_lru) || atomic_read(&bp->b_lru_ref) > 1)
+		return;
+	atomic_set(&bp->b_lru_ref, 0);
+}
+
 static inline int xfs_buf_ispinned(struct xfs_buf *bp)
 {
 	return atomic_read(&bp->b_pin_count);
-- 
2.17.0

[PATCH 02/10] xfs: factor out AG header initialisation from growfs core

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

The intialisation of new AG headers is mostly common with the
userspace mkfs code and growfs in the kernel, so start factoring it
out so we can move it to libxfs and use it in both places.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
---
 fs/xfs/xfs_fsops.c | 637 +++++++++++++++++++++++----------------------
 1 file changed, 331 insertions(+), 306 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 523792768080..391d1938a6c8 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -71,20 +71,344 @@ xfs_growfs_get_hdr_buf(
 	return bp;
 }
 
+/*
+ * Write new AG headers to disk. Non-transactional, but written
+ * synchronously so they are completed prior to the growfs transaction
+ * being logged.
+ */
+static int
+xfs_grow_ag_headers(
+	struct xfs_mount	*mp,
+	xfs_agnumber_t		agno,
+	xfs_extlen_t		agsize,
+	xfs_rfsblock_t		*nfree)
+{
+	struct xfs_agf		*agf;
+	struct xfs_agi		*agi;
+	struct xfs_agfl		*agfl;
+	__be32			*agfl_bno;
+	xfs_alloc_rec_t		*arec;
+	struct xfs_buf		*bp;
+	int			bucket;
+	xfs_extlen_t		tmpsize;
+	int			error = 0;
+
+	/*
+	 * AG freespace header block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1), 0,
+			&xfs_agf_buf_ops);
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	agf = XFS_BUF_TO_AGF(bp);
+	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
+	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
+	agf->agf_seqno = cpu_to_be32(agno);
+	agf->agf_length = cpu_to_be32(agsize);
+	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
+	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
+	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
+	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+		agf->agf_roots[XFS_BTNUM_RMAPi] =
+					cpu_to_be32(XFS_RMAP_BLOCK(mp));
+		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
+		agf->agf_rmap_blocks = cpu_to_be32(1);
+	}
+
+	agf->agf_flfirst = cpu_to_be32(1);
+	agf->agf_fllast = 0;
+	agf->agf_flcount = 0;
+	tmpsize = agsize - mp->m_ag_prealloc_blocks;
+	agf->agf_freeblks = cpu_to_be32(tmpsize);
+	agf->agf_longest = cpu_to_be32(tmpsize);
+	if (xfs_sb_version_hascrc(&mp->m_sb))
+		uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		agf->agf_refcount_root = cpu_to_be32(
+				xfs_refc_block(mp));
+		agf->agf_refcount_level = cpu_to_be32(1);
+		agf->agf_refcount_blocks = cpu_to_be32(1);
+	}
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/*
+	 * AG freelist header block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1), 0,
+			&xfs_agfl_buf_ops);
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	agfl = XFS_BUF_TO_AGFL(bp);
+	if (xfs_sb_version_hascrc(&mp->m_sb)) {
+		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
+		agfl->agfl_seqno = cpu_to_be32(agno);
+		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
+	}
+
+	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
+	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
+		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/*
+	 * AG inode header block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1), 0,
+			&xfs_agi_buf_ops);
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	agi = XFS_BUF_TO_AGI(bp);
+	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
+	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
+	agi->agi_seqno = cpu_to_be32(agno);
+	agi->agi_length = cpu_to_be32(agsize);
+	agi->agi_count = 0;
+	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	agi->agi_level = cpu_to_be32(1);
+	agi->agi_freecount = 0;
+	agi->agi_newino = cpu_to_be32(NULLAGINO);
+	agi->agi_dirino = cpu_to_be32(NULLAGINO);
+	if (xfs_sb_version_hascrc(&mp->m_sb))
+		uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
+	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
+		agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
+		agi->agi_free_level = cpu_to_be32(1);
+	}
+	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
+		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/*
+	 * BNO btree root block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_allocbt_buf_ops);
+
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
+
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(
+		agsize - be32_to_cpu(arec->ar_startblock));
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/*
+	 * CNT btree root block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_allocbt_buf_ops);
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
+
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(
+		agsize - be32_to_cpu(arec->ar_startblock));
+	*nfree += be32_to_cpu(arec->ar_blockcount);
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/* RMAP btree root block */
+	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+		struct xfs_rmap_rec	*rrec;
+		struct xfs_btree_block	*block;
+
+		bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_rmapbt_buf_ops);
+		if (!bp) {
+			error = -ENOMEM;
+			goto out_error;
+		}
+
+		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
+					agno, 0);
+		block = XFS_BUF_TO_BLOCK(bp);
+
+
+		/*
+		 * mark the AG header regions as static metadata The BNO
+		 * btree block is the first block after the headers, so
+		 * it's location defines the size of region the static
+		 * metadata consumes.
+		 *
+		 * Note: unlike mkfs, we never have to account for log
+		 * space when growing the data regions
+		 */
+		rrec = XFS_RMAP_REC_ADDR(block, 1);
+		rrec->rm_startblock = 0;
+		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account freespace btree root blocks */
+		rrec = XFS_RMAP_REC_ADDR(block, 2);
+		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(2);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account inode btree root blocks */
+		rrec = XFS_RMAP_REC_ADDR(block, 3);
+		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+						XFS_IBT_BLOCK(mp));
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account for rmap btree root */
+		rrec = XFS_RMAP_REC_ADDR(block, 4);
+		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(1);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account for refc btree root */
+		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+			rrec = XFS_RMAP_REC_ADDR(block, 5);
+			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
+			rrec->rm_blockcount = cpu_to_be32(1);
+			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
+			rrec->rm_offset = 0;
+			be16_add_cpu(&block->bb_numrecs, 1);
+		}
+
+		error = xfs_bwrite(bp);
+		xfs_buf_relse(bp);
+		if (error)
+			goto out_error;
+	}
+
+	/*
+	 * INO btree root block
+	 */
+	bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_inobt_buf_ops);
+	if (!bp) {
+		error = -ENOMEM;
+		goto out_error;
+	}
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
+
+	error = xfs_bwrite(bp);
+	xfs_buf_relse(bp);
+	if (error)
+		goto out_error;
+
+	/*
+	 * FINO btree root block
+	 */
+	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
+		bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_inobt_buf_ops);
+		if (!bp) {
+			error = -ENOMEM;
+			goto out_error;
+		}
+
+		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
+					     0, 0, agno, 0);
+
+		error = xfs_bwrite(bp);
+		xfs_buf_relse(bp);
+		if (error)
+			goto out_error;
+	}
+
+	/*
+	 * refcount btree root block
+	 */
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		bp = xfs_growfs_get_hdr_buf(mp,
+			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
+			BTOBB(mp->m_sb.sb_blocksize), 0,
+			&xfs_refcountbt_buf_ops);
+		if (!bp) {
+			error = -ENOMEM;
+			goto out_error;
+		}
+
+		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
+				     0, 0, agno, 0);
+
+		error = xfs_bwrite(bp);
+		xfs_buf_relse(bp);
+		if (error)
+			goto out_error;
+	}
+
+out_error:
+	return error;
+}
+
 static int
 xfs_growfs_data_private(
 	xfs_mount_t		*mp,		/* mount point for filesystem */
 	xfs_growfs_data_t	*in)		/* growfs data input struct */
 {
 	xfs_agf_t		*agf;
-	struct xfs_agfl		*agfl;
 	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
 	xfs_extlen_t		agsize;
-	xfs_extlen_t		tmpsize;
-	xfs_alloc_rec_t		*arec;
 	xfs_buf_t		*bp;
-	int			bucket;
 	int			dpct;
 	int			error, saved_error = 0;
 	xfs_agnumber_t		nagcount;
@@ -141,318 +465,19 @@ xfs_growfs_data_private(
 	 */
 	nfree = 0;
 	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
-		__be32	*agfl_bno;
-
-		/*
-		 * AG freespace header block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1), 0,
-				&xfs_agf_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
 
-		agf = XFS_BUF_TO_AGF(bp);
-		agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
-		agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
-		agf->agf_seqno = cpu_to_be32(agno);
 		if (agno == nagcount - 1)
-			agsize =
-				nb -
+			agsize = nb -
 				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
 		else
 			agsize = mp->m_sb.sb_agblocks;
-		agf->agf_length = cpu_to_be32(agsize);
-		agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
-		agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
-		agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
-		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-			agf->agf_roots[XFS_BTNUM_RMAPi] =
-						cpu_to_be32(XFS_RMAP_BLOCK(mp));
-			agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
-			agf->agf_rmap_blocks = cpu_to_be32(1);
-		}
-
-		agf->agf_flfirst = cpu_to_be32(1);
-		agf->agf_fllast = 0;
-		agf->agf_flcount = 0;
-		tmpsize = agsize - mp->m_ag_prealloc_blocks;
-		agf->agf_freeblks = cpu_to_be32(tmpsize);
-		agf->agf_longest = cpu_to_be32(tmpsize);
-		if (xfs_sb_version_hascrc(&mp->m_sb))
-			uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			agf->agf_refcount_root = cpu_to_be32(
-					xfs_refc_block(mp));
-			agf->agf_refcount_level = cpu_to_be32(1);
-			agf->agf_refcount_blocks = cpu_to_be32(1);
-		}
-
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
-		if (error)
-			goto error0;
-
-		/*
-		 * AG freelist header block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1), 0,
-				&xfs_agfl_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
-
-		agfl = XFS_BUF_TO_AGFL(bp);
-		if (xfs_sb_version_hascrc(&mp->m_sb)) {
-			agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
-			agfl->agfl_seqno = cpu_to_be32(agno);
-			uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
-		}
-
-		agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
-		for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
-			agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
 
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
+		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree);
 		if (error)
 			goto error0;
-
-		/*
-		 * AG inode header block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1), 0,
-				&xfs_agi_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
-
-		agi = XFS_BUF_TO_AGI(bp);
-		agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
-		agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
-		agi->agi_seqno = cpu_to_be32(agno);
-		agi->agi_length = cpu_to_be32(agsize);
-		agi->agi_count = 0;
-		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
-		agi->agi_level = cpu_to_be32(1);
-		agi->agi_freecount = 0;
-		agi->agi_newino = cpu_to_be32(NULLAGINO);
-		agi->agi_dirino = cpu_to_be32(NULLAGINO);
-		if (xfs_sb_version_hascrc(&mp->m_sb))
-			uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
-		if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-			agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
-			agi->agi_free_level = cpu_to_be32(1);
-		}
-		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
-			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
-
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
-		if (error)
-			goto error0;
-
-		/*
-		 * BNO btree root block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_allocbt_buf_ops);
-
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
-
-		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-		arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-		arec->ar_blockcount = cpu_to_be32(
-			agsize - be32_to_cpu(arec->ar_startblock));
-
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
-		if (error)
-			goto error0;
-
-		/*
-		 * CNT btree root block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_allocbt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
-
-		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-		arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-		arec->ar_blockcount = cpu_to_be32(
-			agsize - be32_to_cpu(arec->ar_startblock));
-		nfree += be32_to_cpu(arec->ar_blockcount);
-
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
-		if (error)
-			goto error0;
-
-		/* RMAP btree root block */
-		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-			struct xfs_rmap_rec	*rrec;
-			struct xfs_btree_block	*block;
-
-			bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_rmapbt_buf_ops);
-			if (!bp) {
-				error = -ENOMEM;
-				goto error0;
-			}
-
-			xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
-						agno, 0);
-			block = XFS_BUF_TO_BLOCK(bp);
-
-
-			/*
-			 * mark the AG header regions as static metadata The BNO
-			 * btree block is the first block after the headers, so
-			 * it's location defines the size of region the static
-			 * metadata consumes.
-			 *
-			 * Note: unlike mkfs, we never have to account for log
-			 * space when growing the data regions
-			 */
-			rrec = XFS_RMAP_REC_ADDR(block, 1);
-			rrec->rm_startblock = 0;
-			rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account freespace btree root blocks */
-			rrec = XFS_RMAP_REC_ADDR(block, 2);
-			rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(2);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account inode btree root blocks */
-			rrec = XFS_RMAP_REC_ADDR(block, 3);
-			rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
-							XFS_IBT_BLOCK(mp));
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account for rmap btree root */
-			rrec = XFS_RMAP_REC_ADDR(block, 4);
-			rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(1);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account for refc btree root */
-			if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-				rrec = XFS_RMAP_REC_ADDR(block, 5);
-				rrec->rm_startblock = cpu_to_be32(
-						xfs_refc_block(mp));
-				rrec->rm_blockcount = cpu_to_be32(1);
-				rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
-				rrec->rm_offset = 0;
-				be16_add_cpu(&block->bb_numrecs, 1);
-			}
-
-			error = xfs_bwrite(bp);
-			xfs_buf_relse(bp);
-			if (error)
-				goto error0;
-		}
-
-		/*
-		 * INO btree root block
-		 */
-		bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_inobt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto error0;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
-
-		error = xfs_bwrite(bp);
-		xfs_buf_relse(bp);
-		if (error)
-			goto error0;
-
-		/*
-		 * FINO btree root block
-		 */
-		if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-			bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_inobt_buf_ops);
-			if (!bp) {
-				error = -ENOMEM;
-				goto error0;
-			}
-
-			xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
-						     0, 0, agno, 0);
-
-			error = xfs_bwrite(bp);
-			xfs_buf_relse(bp);
-			if (error)
-				goto error0;
-		}
-
-		/*
-		 * refcount btree root block
-		 */
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			bp = xfs_growfs_get_hdr_buf(mp,
-				XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
-				BTOBB(mp->m_sb.sb_blocksize), 0,
-				&xfs_refcountbt_buf_ops);
-			if (!bp) {
-				error = -ENOMEM;
-				goto error0;
-			}
-
-			xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
-					     0, 0, agno, 0);
-
-			error = xfs_bwrite(bp);
-			xfs_buf_relse(bp);
-			if (error)
-				goto error0;
-		}
 	}
 	xfs_trans_agblocks_delta(tp, nfree);
+
 	/*
 	 * There are new blocks in the old last a.g.
 	 */
-- 
2.17.0

Re: [PATCH 02/10] xfs: factor out AG header initialisation from growfs core

[Darrick J. Wong]

On Mon, May 14, 2018 at 02:18:56PM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
> 
> The intialisation of new AG headers is mostly common with the
> userspace mkfs code and growfs in the kernel, so start factoring it
> out so we can move it to libxfs and use it in both places.
> 
> Signed-Off-By: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Brian Foster <bfoster@redhat.com>

Looks ok,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>

--D

> ---
>  fs/xfs/xfs_fsops.c | 637 +++++++++++++++++++++++----------------------
>  1 file changed, 331 insertions(+), 306 deletions(-)
> 
> diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> index 523792768080..391d1938a6c8 100644
> --- a/fs/xfs/xfs_fsops.c
> +++ b/fs/xfs/xfs_fsops.c
> @@ -71,20 +71,344 @@ xfs_growfs_get_hdr_buf(
>  	return bp;
>  }
>  
> +/*
> + * Write new AG headers to disk. Non-transactional, but written
> + * synchronously so they are completed prior to the growfs transaction
> + * being logged.
> + */
> +static int
> +xfs_grow_ag_headers(
> +	struct xfs_mount	*mp,
> +	xfs_agnumber_t		agno,
> +	xfs_extlen_t		agsize,
> +	xfs_rfsblock_t		*nfree)
> +{
> +	struct xfs_agf		*agf;
> +	struct xfs_agi		*agi;
> +	struct xfs_agfl		*agfl;
> +	__be32			*agfl_bno;
> +	xfs_alloc_rec_t		*arec;
> +	struct xfs_buf		*bp;
> +	int			bucket;
> +	xfs_extlen_t		tmpsize;
> +	int			error = 0;
> +
> +	/*
> +	 * AG freespace header block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
> +			XFS_FSS_TO_BB(mp, 1), 0,
> +			&xfs_agf_buf_ops);
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	agf = XFS_BUF_TO_AGF(bp);
> +	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
> +	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
> +	agf->agf_seqno = cpu_to_be32(agno);
> +	agf->agf_length = cpu_to_be32(agsize);
> +	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
> +	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
> +	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
> +	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> +		agf->agf_roots[XFS_BTNUM_RMAPi] =
> +					cpu_to_be32(XFS_RMAP_BLOCK(mp));
> +		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
> +		agf->agf_rmap_blocks = cpu_to_be32(1);
> +	}
> +
> +	agf->agf_flfirst = cpu_to_be32(1);
> +	agf->agf_fllast = 0;
> +	agf->agf_flcount = 0;
> +	tmpsize = agsize - mp->m_ag_prealloc_blocks;
> +	agf->agf_freeblks = cpu_to_be32(tmpsize);
> +	agf->agf_longest = cpu_to_be32(tmpsize);
> +	if (xfs_sb_version_hascrc(&mp->m_sb))
> +		uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
> +	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> +		agf->agf_refcount_root = cpu_to_be32(
> +				xfs_refc_block(mp));
> +		agf->agf_refcount_level = cpu_to_be32(1);
> +		agf->agf_refcount_blocks = cpu_to_be32(1);
> +	}
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/*
> +	 * AG freelist header block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
> +			XFS_FSS_TO_BB(mp, 1), 0,
> +			&xfs_agfl_buf_ops);
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	agfl = XFS_BUF_TO_AGFL(bp);
> +	if (xfs_sb_version_hascrc(&mp->m_sb)) {
> +		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
> +		agfl->agfl_seqno = cpu_to_be32(agno);
> +		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
> +	}
> +
> +	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
> +	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
> +		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/*
> +	 * AG inode header block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
> +			XFS_FSS_TO_BB(mp, 1), 0,
> +			&xfs_agi_buf_ops);
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	agi = XFS_BUF_TO_AGI(bp);
> +	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
> +	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
> +	agi->agi_seqno = cpu_to_be32(agno);
> +	agi->agi_length = cpu_to_be32(agsize);
> +	agi->agi_count = 0;
> +	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
> +	agi->agi_level = cpu_to_be32(1);
> +	agi->agi_freecount = 0;
> +	agi->agi_newino = cpu_to_be32(NULLAGINO);
> +	agi->agi_dirino = cpu_to_be32(NULLAGINO);
> +	if (xfs_sb_version_hascrc(&mp->m_sb))
> +		uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
> +	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> +		agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
> +		agi->agi_free_level = cpu_to_be32(1);
> +	}
> +	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
> +		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/*
> +	 * BNO btree root block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_allocbt_buf_ops);
> +
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
> +
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(
> +		agsize - be32_to_cpu(arec->ar_startblock));
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/*
> +	 * CNT btree root block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_allocbt_buf_ops);
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
> +
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(
> +		agsize - be32_to_cpu(arec->ar_startblock));
> +	*nfree += be32_to_cpu(arec->ar_blockcount);
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/* RMAP btree root block */
> +	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> +		struct xfs_rmap_rec	*rrec;
> +		struct xfs_btree_block	*block;
> +
> +		bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_rmapbt_buf_ops);
> +		if (!bp) {
> +			error = -ENOMEM;
> +			goto out_error;
> +		}
> +
> +		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
> +					agno, 0);
> +		block = XFS_BUF_TO_BLOCK(bp);
> +
> +
> +		/*
> +		 * mark the AG header regions as static metadata The BNO
> +		 * btree block is the first block after the headers, so
> +		 * it's location defines the size of region the static
> +		 * metadata consumes.
> +		 *
> +		 * Note: unlike mkfs, we never have to account for log
> +		 * space when growing the data regions
> +		 */
> +		rrec = XFS_RMAP_REC_ADDR(block, 1);
> +		rrec->rm_startblock = 0;
> +		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
> +
> +		/* account freespace btree root blocks */
> +		rrec = XFS_RMAP_REC_ADDR(block, 2);
> +		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +		rrec->rm_blockcount = cpu_to_be32(2);
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
> +
> +		/* account inode btree root blocks */
> +		rrec = XFS_RMAP_REC_ADDR(block, 3);
> +		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> +		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> +						XFS_IBT_BLOCK(mp));
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
> +
> +		/* account for rmap btree root */
> +		rrec = XFS_RMAP_REC_ADDR(block, 4);
> +		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> +		rrec->rm_blockcount = cpu_to_be32(1);
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
> +
> +		/* account for refc btree root */
> +		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> +			rrec = XFS_RMAP_REC_ADDR(block, 5);
> +			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
> +			rrec->rm_blockcount = cpu_to_be32(1);
> +			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> +			rrec->rm_offset = 0;
> +			be16_add_cpu(&block->bb_numrecs, 1);
> +		}
> +
> +		error = xfs_bwrite(bp);
> +		xfs_buf_relse(bp);
> +		if (error)
> +			goto out_error;
> +	}
> +
> +	/*
> +	 * INO btree root block
> +	 */
> +	bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_inobt_buf_ops);
> +	if (!bp) {
> +		error = -ENOMEM;
> +		goto out_error;
> +	}
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
> +
> +	error = xfs_bwrite(bp);
> +	xfs_buf_relse(bp);
> +	if (error)
> +		goto out_error;
> +
> +	/*
> +	 * FINO btree root block
> +	 */
> +	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> +		bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_inobt_buf_ops);
> +		if (!bp) {
> +			error = -ENOMEM;
> +			goto out_error;
> +		}
> +
> +		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
> +					     0, 0, agno, 0);
> +
> +		error = xfs_bwrite(bp);
> +		xfs_buf_relse(bp);
> +		if (error)
> +			goto out_error;
> +	}
> +
> +	/*
> +	 * refcount btree root block
> +	 */
> +	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> +		bp = xfs_growfs_get_hdr_buf(mp,
> +			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
> +			BTOBB(mp->m_sb.sb_blocksize), 0,
> +			&xfs_refcountbt_buf_ops);
> +		if (!bp) {
> +			error = -ENOMEM;
> +			goto out_error;
> +		}
> +
> +		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
> +				     0, 0, agno, 0);
> +
> +		error = xfs_bwrite(bp);
> +		xfs_buf_relse(bp);
> +		if (error)
> +			goto out_error;
> +	}
> +
> +out_error:
> +	return error;
> +}
> +
>  static int
>  xfs_growfs_data_private(
>  	xfs_mount_t		*mp,		/* mount point for filesystem */
>  	xfs_growfs_data_t	*in)		/* growfs data input struct */
>  {
>  	xfs_agf_t		*agf;
> -	struct xfs_agfl		*agfl;
>  	xfs_agi_t		*agi;
>  	xfs_agnumber_t		agno;
>  	xfs_extlen_t		agsize;
> -	xfs_extlen_t		tmpsize;
> -	xfs_alloc_rec_t		*arec;
>  	xfs_buf_t		*bp;
> -	int			bucket;
>  	int			dpct;
>  	int			error, saved_error = 0;
>  	xfs_agnumber_t		nagcount;
> @@ -141,318 +465,19 @@ xfs_growfs_data_private(
>  	 */
>  	nfree = 0;
>  	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
> -		__be32	*agfl_bno;
> -
> -		/*
> -		 * AG freespace header block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
> -				XFS_FSS_TO_BB(mp, 1), 0,
> -				&xfs_agf_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
>  
> -		agf = XFS_BUF_TO_AGF(bp);
> -		agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
> -		agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
> -		agf->agf_seqno = cpu_to_be32(agno);
>  		if (agno == nagcount - 1)
> -			agsize =
> -				nb -
> +			agsize = nb -
>  				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
>  		else
>  			agsize = mp->m_sb.sb_agblocks;
> -		agf->agf_length = cpu_to_be32(agsize);
> -		agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -		agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
> -		agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
> -		agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
> -		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> -			agf->agf_roots[XFS_BTNUM_RMAPi] =
> -						cpu_to_be32(XFS_RMAP_BLOCK(mp));
> -			agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
> -			agf->agf_rmap_blocks = cpu_to_be32(1);
> -		}
> -
> -		agf->agf_flfirst = cpu_to_be32(1);
> -		agf->agf_fllast = 0;
> -		agf->agf_flcount = 0;
> -		tmpsize = agsize - mp->m_ag_prealloc_blocks;
> -		agf->agf_freeblks = cpu_to_be32(tmpsize);
> -		agf->agf_longest = cpu_to_be32(tmpsize);
> -		if (xfs_sb_version_hascrc(&mp->m_sb))
> -			uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
> -		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -			agf->agf_refcount_root = cpu_to_be32(
> -					xfs_refc_block(mp));
> -			agf->agf_refcount_level = cpu_to_be32(1);
> -			agf->agf_refcount_blocks = cpu_to_be32(1);
> -		}
> -
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> -		if (error)
> -			goto error0;
> -
> -		/*
> -		 * AG freelist header block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
> -				XFS_FSS_TO_BB(mp, 1), 0,
> -				&xfs_agfl_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
> -
> -		agfl = XFS_BUF_TO_AGFL(bp);
> -		if (xfs_sb_version_hascrc(&mp->m_sb)) {
> -			agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
> -			agfl->agfl_seqno = cpu_to_be32(agno);
> -			uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
> -		}
> -
> -		agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
> -		for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
> -			agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
>  
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> +		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree);
>  		if (error)
>  			goto error0;
> -
> -		/*
> -		 * AG inode header block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
> -				XFS_FSS_TO_BB(mp, 1), 0,
> -				&xfs_agi_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
> -
> -		agi = XFS_BUF_TO_AGI(bp);
> -		agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
> -		agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
> -		agi->agi_seqno = cpu_to_be32(agno);
> -		agi->agi_length = cpu_to_be32(agsize);
> -		agi->agi_count = 0;
> -		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
> -		agi->agi_level = cpu_to_be32(1);
> -		agi->agi_freecount = 0;
> -		agi->agi_newino = cpu_to_be32(NULLAGINO);
> -		agi->agi_dirino = cpu_to_be32(NULLAGINO);
> -		if (xfs_sb_version_hascrc(&mp->m_sb))
> -			uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
> -		if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> -			agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
> -			agi->agi_free_level = cpu_to_be32(1);
> -		}
> -		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
> -			agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> -
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> -		if (error)
> -			goto error0;
> -
> -		/*
> -		 * BNO btree root block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_allocbt_buf_ops);
> -
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
> -
> -		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -		arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -		arec->ar_blockcount = cpu_to_be32(
> -			agsize - be32_to_cpu(arec->ar_startblock));
> -
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> -		if (error)
> -			goto error0;
> -
> -		/*
> -		 * CNT btree root block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_allocbt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
> -
> -		arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -		arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -		arec->ar_blockcount = cpu_to_be32(
> -			agsize - be32_to_cpu(arec->ar_startblock));
> -		nfree += be32_to_cpu(arec->ar_blockcount);
> -
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> -		if (error)
> -			goto error0;
> -
> -		/* RMAP btree root block */
> -		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> -			struct xfs_rmap_rec	*rrec;
> -			struct xfs_btree_block	*block;
> -
> -			bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_rmapbt_buf_ops);
> -			if (!bp) {
> -				error = -ENOMEM;
> -				goto error0;
> -			}
> -
> -			xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
> -						agno, 0);
> -			block = XFS_BUF_TO_BLOCK(bp);
> -
> -
> -			/*
> -			 * mark the AG header regions as static metadata The BNO
> -			 * btree block is the first block after the headers, so
> -			 * it's location defines the size of region the static
> -			 * metadata consumes.
> -			 *
> -			 * Note: unlike mkfs, we never have to account for log
> -			 * space when growing the data regions
> -			 */
> -			rrec = XFS_RMAP_REC_ADDR(block, 1);
> -			rrec->rm_startblock = 0;
> -			rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -
> -			/* account freespace btree root blocks */
> -			rrec = XFS_RMAP_REC_ADDR(block, 2);
> -			rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -			rrec->rm_blockcount = cpu_to_be32(2);
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -
> -			/* account inode btree root blocks */
> -			rrec = XFS_RMAP_REC_ADDR(block, 3);
> -			rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> -			rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> -							XFS_IBT_BLOCK(mp));
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -
> -			/* account for rmap btree root */
> -			rrec = XFS_RMAP_REC_ADDR(block, 4);
> -			rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> -			rrec->rm_blockcount = cpu_to_be32(1);
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -
> -			/* account for refc btree root */
> -			if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -				rrec = XFS_RMAP_REC_ADDR(block, 5);
> -				rrec->rm_startblock = cpu_to_be32(
> -						xfs_refc_block(mp));
> -				rrec->rm_blockcount = cpu_to_be32(1);
> -				rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> -				rrec->rm_offset = 0;
> -				be16_add_cpu(&block->bb_numrecs, 1);
> -			}
> -
> -			error = xfs_bwrite(bp);
> -			xfs_buf_relse(bp);
> -			if (error)
> -				goto error0;
> -		}
> -
> -		/*
> -		 * INO btree root block
> -		 */
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_inobt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto error0;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
> -
> -		error = xfs_bwrite(bp);
> -		xfs_buf_relse(bp);
> -		if (error)
> -			goto error0;
> -
> -		/*
> -		 * FINO btree root block
> -		 */
> -		if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> -			bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_inobt_buf_ops);
> -			if (!bp) {
> -				error = -ENOMEM;
> -				goto error0;
> -			}
> -
> -			xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
> -						     0, 0, agno, 0);
> -
> -			error = xfs_bwrite(bp);
> -			xfs_buf_relse(bp);
> -			if (error)
> -				goto error0;
> -		}
> -
> -		/*
> -		 * refcount btree root block
> -		 */
> -		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -			bp = xfs_growfs_get_hdr_buf(mp,
> -				XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
> -				BTOBB(mp->m_sb.sb_blocksize), 0,
> -				&xfs_refcountbt_buf_ops);
> -			if (!bp) {
> -				error = -ENOMEM;
> -				goto error0;
> -			}
> -
> -			xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
> -					     0, 0, agno, 0);
> -
> -			error = xfs_bwrite(bp);
> -			xfs_buf_relse(bp);
> -			if (error)
> -				goto error0;
> -		}
>  	}
>  	xfs_trans_agblocks_delta(tp, nfree);
> +
>  	/*
>  	 * There are new blocks in the old last a.g.
>  	 */
> -- 
> 2.17.0
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 03/10] xfs: convert growfs AG header init to use buffer lists

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

We currently write all new AG headers synchronously, which can be
slow for large grow operations. All we really need to do is ensure
all the headers are on disk before we run the growfs transaction, so
convert this to a buffer list and a delayed write operation. We
block waiting for the delayed write buffer submission to complete,
so this will fulfill the requirement to have all the buffers written
correctly before proceeding.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_fsops.c | 74 +++++++++++++++++++++-------------------------
 1 file changed, 33 insertions(+), 41 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 391d1938a6c8..4b560caaf397 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -81,7 +81,8 @@ xfs_grow_ag_headers(
 	struct xfs_mount	*mp,
 	xfs_agnumber_t		agno,
 	xfs_extlen_t		agsize,
-	xfs_rfsblock_t		*nfree)
+	xfs_rfsblock_t		*nfree,
+	struct list_head	*buffer_list)
 {
 	struct xfs_agf		*agf;
 	struct xfs_agi		*agi;
@@ -135,11 +136,8 @@ xfs_grow_ag_headers(
 		agf->agf_refcount_level = cpu_to_be32(1);
 		agf->agf_refcount_blocks = cpu_to_be32(1);
 	}
-
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/*
 	 * AG freelist header block
@@ -164,10 +162,8 @@ xfs_grow_ag_headers(
 	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
 		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
 
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/*
 	 * AG inode header block
@@ -201,10 +197,8 @@ xfs_grow_ag_headers(
 	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
 		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
 
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/*
 	 * BNO btree root block
@@ -226,10 +220,8 @@ xfs_grow_ag_headers(
 	arec->ar_blockcount = cpu_to_be32(
 		agsize - be32_to_cpu(arec->ar_startblock));
 
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/*
 	 * CNT btree root block
@@ -251,10 +243,8 @@ xfs_grow_ag_headers(
 		agsize - be32_to_cpu(arec->ar_startblock));
 	*nfree += be32_to_cpu(arec->ar_blockcount);
 
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/* RMAP btree root block */
 	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
@@ -326,10 +316,8 @@ xfs_grow_ag_headers(
 			be16_add_cpu(&block->bb_numrecs, 1);
 		}
 
-		error = xfs_bwrite(bp);
+		xfs_buf_delwri_queue(bp, buffer_list);
 		xfs_buf_relse(bp);
-		if (error)
-			goto out_error;
 	}
 
 	/*
@@ -345,11 +333,8 @@ xfs_grow_ag_headers(
 	}
 
 	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
-
-	error = xfs_bwrite(bp);
+	xfs_buf_delwri_queue(bp, buffer_list);
 	xfs_buf_relse(bp);
-	if (error)
-		goto out_error;
 
 	/*
 	 * FINO btree root block
@@ -364,13 +349,9 @@ xfs_grow_ag_headers(
 			goto out_error;
 		}
 
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
-					     0, 0, agno, 0);
-
-		error = xfs_bwrite(bp);
+		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO, 0, 0, agno, 0);
+		xfs_buf_delwri_queue(bp, buffer_list);
 		xfs_buf_relse(bp);
-		if (error)
-			goto out_error;
 	}
 
 	/*
@@ -386,13 +367,9 @@ xfs_grow_ag_headers(
 			goto out_error;
 		}
 
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
-				     0, 0, agno, 0);
-
-		error = xfs_bwrite(bp);
+		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC, 0, 0, agno, 0);
+		xfs_buf_delwri_queue(bp, buffer_list);
 		xfs_buf_relse(bp);
-		if (error)
-			goto out_error;
 	}
 
 out_error:
@@ -419,6 +396,7 @@ xfs_growfs_data_private(
 	xfs_agnumber_t		oagcount;
 	int			pct;
 	xfs_trans_t		*tp;
+	LIST_HEAD		(buffer_list);
 
 	nb = in->newblocks;
 	pct = in->imaxpct;
@@ -459,9 +437,16 @@ xfs_growfs_data_private(
 		return error;
 
 	/*
-	 * Write new AG headers to disk. Non-transactional, but written
-	 * synchronously so they are completed prior to the growfs transaction
-	 * being logged.
+	 * Write new AG headers to disk. Non-transactional, but need to be
+	 * written and completed prior to the growfs transaction being logged.
+	 * To do this, we use a delayed write buffer list and wait for
+	 * submission and IO completion of the list as a whole. This allows the
+	 * IO subsystem to merge all the AG headers in a single AG into a single
+	 * IO and hide most of the latency of the IO from us.
+	 *
+	 * This also means that if we get an error whilst building the buffer
+	 * list to write, we can cancel the entire list without having written
+	 * anything.
 	 */
 	nfree = 0;
 	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
@@ -472,10 +457,17 @@ xfs_growfs_data_private(
 		else
 			agsize = mp->m_sb.sb_agblocks;
 
-		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree);
-		if (error)
+		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree,
+					    &buffer_list);
+		if (error) {
+			xfs_buf_delwri_cancel(&buffer_list);
 			goto error0;
+		}
 	}
+	error = xfs_buf_delwri_submit(&buffer_list);
+	if (error)
+		goto error0;
+
 	xfs_trans_agblocks_delta(tp, nfree);
 
 	/*
-- 
2.17.0

[PATCH 04/10] xfs: factor ag btree root block initialisation

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Cookie cutter code, easily factored.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_fsops.c | 481 ++++++++++++++++++++++++---------------------
 1 file changed, 259 insertions(+), 222 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 4b560caaf397..ec3c51ee8134 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -71,46 +71,140 @@ xfs_growfs_get_hdr_buf(
 	return bp;
 }
 
+struct aghdr_init_data {
+	/* per ag data */
+	xfs_agnumber_t		agno;		/* ag to init */
+	xfs_extlen_t		agsize;		/* new AG size */
+	struct list_head	buffer_list;	/* buffer writeback list */
+	xfs_rfsblock_t		nfree;		/* cumulative new free space */
+
+	/* per header data */
+	xfs_daddr_t		daddr;		/* header location */
+	size_t			numblks;	/* size of header */
+	xfs_btnum_t		type;		/* type of btree root block */
+};
+
 /*
- * Write new AG headers to disk. Non-transactional, but written
- * synchronously so they are completed prior to the growfs transaction
- * being logged.
+ * Generic btree root block init function
  */
-static int
-xfs_grow_ag_headers(
+static void
+xfs_btroot_init(
 	struct xfs_mount	*mp,
-	xfs_agnumber_t		agno,
-	xfs_extlen_t		agsize,
-	xfs_rfsblock_t		*nfree,
-	struct list_head	*buffer_list)
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
 {
-	struct xfs_agf		*agf;
-	struct xfs_agi		*agi;
-	struct xfs_agfl		*agfl;
-	__be32			*agfl_bno;
-	xfs_alloc_rec_t		*arec;
-	struct xfs_buf		*bp;
-	int			bucket;
-	xfs_extlen_t		tmpsize;
-	int			error = 0;
+	xfs_btree_init_block(mp, bp, id->type, 0, 0, id->agno, 0);
+}
+
+/*
+ * Alloc btree root block init functions
+ */
+static void
+xfs_bnoroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+static void
+xfs_cntroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+/*
+ * Reverse map root block init
+ */
+static void
+xfs_rmaproot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
+	struct xfs_rmap_rec	*rrec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
 
 	/*
-	 * AG freespace header block
+	 * mark the AG header regions as static metadata The BNO
+	 * btree block is the first block after the headers, so
+	 * it's location defines the size of region the static
+	 * metadata consumes.
+	 *
+	 * Note: unlike mkfs, we never have to account for log
+	 * space when growing the data regions
 	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agf_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
+	rrec = XFS_RMAP_REC_ADDR(block, 1);
+	rrec->rm_startblock = 0;
+	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+	rrec->rm_offset = 0;
+
+	/* account freespace btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 2);
+	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(2);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account inode btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 3);
+	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+					  XFS_IBT_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+	rrec->rm_offset = 0;
+
+	/* account for rmap btree root */
+	rrec = XFS_RMAP_REC_ADDR(block, 4);
+	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(1);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account for refc btree root */
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		rrec = XFS_RMAP_REC_ADDR(block, 5);
+		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
+		rrec->rm_blockcount = cpu_to_be32(1);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
 	}
+}
+
+
+static void
+xfs_agfblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
+	xfs_extlen_t		tmpsize;
 
-	agf = XFS_BUF_TO_AGF(bp);
 	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
 	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
-	agf->agf_seqno = cpu_to_be32(agno);
-	agf->agf_length = cpu_to_be32(agsize);
+	agf->agf_seqno = cpu_to_be32(id->agno);
+	agf->agf_length = cpu_to_be32(id->agsize);
 	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
 	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
 	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
@@ -125,7 +219,7 @@ xfs_grow_ag_headers(
 	agf->agf_flfirst = cpu_to_be32(1);
 	agf->agf_fllast = 0;
 	agf->agf_flcount = 0;
-	tmpsize = agsize - mp->m_ag_prealloc_blocks;
+	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
 	agf->agf_freeblks = cpu_to_be32(tmpsize);
 	agf->agf_longest = cpu_to_be32(tmpsize);
 	if (xfs_sb_version_hascrc(&mp->m_sb))
@@ -136,52 +230,42 @@ xfs_grow_ag_headers(
 		agf->agf_refcount_level = cpu_to_be32(1);
 		agf->agf_refcount_blocks = cpu_to_be32(1);
 	}
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
+}
 
-	/*
-	 * AG freelist header block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agfl_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+static void
+xfs_agflblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
+	__be32			*agfl_bno;
+	int			bucket;
 
-	agfl = XFS_BUF_TO_AGFL(bp);
 	if (xfs_sb_version_hascrc(&mp->m_sb)) {
 		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
-		agfl->agfl_seqno = cpu_to_be32(agno);
+		agfl->agfl_seqno = cpu_to_be32(id->agno);
 		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
 	}
 
 	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
 	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
 		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
+}
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
-
-	/*
-	 * AG inode header block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agi_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+static void
+xfs_agiblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
+	int			bucket;
 
-	agi = XFS_BUF_TO_AGI(bp);
 	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
 	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
-	agi->agi_seqno = cpu_to_be32(agno);
-	agi->agi_length = cpu_to_be32(agsize);
+	agi->agi_seqno = cpu_to_be32(id->agno);
+	agi->agi_length = cpu_to_be32(id->agsize);
 	agi->agi_count = 0;
 	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
 	agi->agi_level = cpu_to_be32(1);
@@ -196,180 +280,133 @@ xfs_grow_ag_headers(
 	}
 	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
 		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
+}
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
-
-	/*
-	 * BNO btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_allocbt_buf_ops);
+static int
+xfs_growfs_init_aghdr(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id,
+	void			(*work)(struct xfs_mount *, struct xfs_buf *,
+					struct aghdr_init_data *),
+	const struct xfs_buf_ops *ops)
 
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+{
+	struct xfs_buf		*bp;
 
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
+	bp = xfs_growfs_get_hdr_buf(mp, id->daddr, id->numblks, 0, ops);
+	if (!bp)
+		return -ENOMEM;
 
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(
-		agsize - be32_to_cpu(arec->ar_startblock));
+	(*work)(mp, bp, id);
 
-	xfs_buf_delwri_queue(bp, buffer_list);
+	xfs_buf_delwri_queue(bp, &id->buffer_list);
 	xfs_buf_relse(bp);
+	return 0;
+}
 
-	/*
-	 * CNT btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_allocbt_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
-
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
+/*
+ * Write new AG headers to disk. Non-transactional, but written
+ * synchronously so they are completed prior to the growfs transaction
+ * being logged.
+ */
+static int
+xfs_grow_ag_headers(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id)
 
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(
-		agsize - be32_to_cpu(arec->ar_startblock));
-	*nfree += be32_to_cpu(arec->ar_blockcount);
+{
+	int			error = 0;
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
+	/* Account for AG free space in new AG */
+	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
 
-	/* RMAP btree root block */
-	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-		struct xfs_rmap_rec	*rrec;
-		struct xfs_btree_block	*block;
-
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_rmapbt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto out_error;
-		}
+	/* AG freespace header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
+					&xfs_agf_buf_ops);
+	if (error)
+		goto out_error;
 
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
-					agno, 0);
-		block = XFS_BUF_TO_BLOCK(bp);
+	/* AG freelist header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
+					&xfs_agfl_buf_ops);
+	if (error)
+		goto out_error;
 
+	/* AG inode header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
+					&xfs_agi_buf_ops);
+	if (error)
+		goto out_error;
 
-		/*
-		 * mark the AG header regions as static metadata The BNO
-		 * btree block is the first block after the headers, so
-		 * it's location defines the size of region the static
-		 * metadata consumes.
-		 *
-		 * Note: unlike mkfs, we never have to account for log
-		 * space when growing the data regions
-		 */
-		rrec = XFS_RMAP_REC_ADDR(block, 1);
-		rrec->rm_startblock = 0;
-		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
 
-		/* account freespace btree root blocks */
-		rrec = XFS_RMAP_REC_ADDR(block, 2);
-		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(2);
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
+	/* BNO btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
+				   &xfs_allocbt_buf_ops);
+	if (error)
+		goto out_error;
 
-		/* account inode btree root blocks */
-		rrec = XFS_RMAP_REC_ADDR(block, 3);
-		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
-						XFS_IBT_BLOCK(mp));
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
 
-		/* account for rmap btree root */
-		rrec = XFS_RMAP_REC_ADDR(block, 4);
-		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(1);
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
+	/* CNT btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
+				   &xfs_allocbt_buf_ops);
+	if (error)
+		goto out_error;
 
-		/* account for refc btree root */
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			rrec = XFS_RMAP_REC_ADDR(block, 5);
-			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
-			rrec->rm_blockcount = cpu_to_be32(1);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-		}
+	/* RMAP btree root block */
+	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
+					   &xfs_rmapbt_buf_ops);
+		if (error)
+			goto out_error;
 
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
-	/*
-	 * INO btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_inobt_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
+	/* INO btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	id->type = XFS_BTNUM_INO;
+	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+				   &xfs_inobt_buf_ops);
+	if (error)
 		goto out_error;
-	}
 
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
 
 	/*
 	 * FINO btree root block
 	 */
 	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_inobt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		id->type = XFS_BTNUM_FINO;
+		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+					   &xfs_inobt_buf_ops);
+		if (error)
 			goto out_error;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO, 0, 0, agno, 0);
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
 	/*
 	 * refcount btree root block
 	 */
 	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_refcountbt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		id->type = XFS_BTNUM_REFC;
+		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+					   &xfs_refcountbt_buf_ops);
+		if (error)
 			goto out_error;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC, 0, 0, agno, 0);
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
 out_error:
@@ -384,7 +421,6 @@ xfs_growfs_data_private(
 	xfs_agf_t		*agf;
 	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
-	xfs_extlen_t		agsize;
 	xfs_buf_t		*bp;
 	int			dpct;
 	int			error, saved_error = 0;
@@ -392,11 +428,11 @@ xfs_growfs_data_private(
 	xfs_agnumber_t		nagimax = 0;
 	xfs_rfsblock_t		nb, nb_mod;
 	xfs_rfsblock_t		new;
-	xfs_rfsblock_t		nfree;
 	xfs_agnumber_t		oagcount;
 	int			pct;
 	xfs_trans_t		*tp;
 	LIST_HEAD		(buffer_list);
+	struct aghdr_init_data	id = {};
 
 	nb = in->newblocks;
 	pct = in->imaxpct;
@@ -448,27 +484,28 @@ xfs_growfs_data_private(
 	 * list to write, we can cancel the entire list without having written
 	 * anything.
 	 */
-	nfree = 0;
-	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
-
-		if (agno == nagcount - 1)
-			agsize = nb -
-				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
+	INIT_LIST_HEAD(&id.buffer_list);
+	for (id.agno = nagcount - 1;
+	     id.agno >= oagcount;
+	     id.agno--, new -= id.agsize) {
+
+		if (id.agno == nagcount - 1)
+			id.agsize = nb -
+				(id.agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
 		else
-			agsize = mp->m_sb.sb_agblocks;
+			id.agsize = mp->m_sb.sb_agblocks;
 
-		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree,
-					    &buffer_list);
+		error = xfs_grow_ag_headers(mp, &id);
 		if (error) {
-			xfs_buf_delwri_cancel(&buffer_list);
+			xfs_buf_delwri_cancel(&id.buffer_list);
 			goto error0;
 		}
 	}
-	error = xfs_buf_delwri_submit(&buffer_list);
+	error = xfs_buf_delwri_submit(&id.buffer_list);
 	if (error)
 		goto error0;
 
-	xfs_trans_agblocks_delta(tp, nfree);
+	xfs_trans_agblocks_delta(tp, id.nfree);
 
 	/*
 	 * There are new blocks in the old last a.g.
@@ -479,7 +516,7 @@ xfs_growfs_data_private(
 		/*
 		 * Change the agi length.
 		 */
-		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
+		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
 		if (error) {
 			goto error0;
 		}
@@ -492,7 +529,7 @@ xfs_growfs_data_private(
 		/*
 		 * Change agf length.
 		 */
-		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
+		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
 		if (error) {
 			goto error0;
 		}
@@ -511,13 +548,13 @@ xfs_growfs_data_private(
 		 * this doesn't actually exist in the rmap btree.
 		 */
 		xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
-		error = xfs_rmap_free(tp, bp, agno,
+		error = xfs_rmap_free(tp, bp, id.agno,
 				be32_to_cpu(agf->agf_length) - new,
 				new, &oinfo);
 		if (error)
 			goto error0;
 		error = xfs_free_extent(tp,
-				XFS_AGB_TO_FSB(mp, agno,
+				XFS_AGB_TO_FSB(mp, id.agno,
 					be32_to_cpu(agf->agf_length) - new),
 				new, &oinfo, XFS_AG_RESV_NONE);
 		if (error)
@@ -534,8 +571,8 @@ xfs_growfs_data_private(
 	if (nb > mp->m_sb.sb_dblocks)
 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
 				 nb - mp->m_sb.sb_dblocks);
-	if (nfree)
-		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
+	if (id.nfree)
+		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
 	if (dpct)
 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
 	xfs_trans_set_sync(tp);
@@ -562,7 +599,7 @@ xfs_growfs_data_private(
 	if (new) {
 		struct xfs_perag	*pag;
 
-		pag = xfs_perag_get(mp, agno);
+		pag = xfs_perag_get(mp, id.agno);
 		error = xfs_ag_resv_free(pag);
 		xfs_perag_put(pag);
 		if (error)
-- 
2.17.0

Re: [PATCH 04/10] xfs: factor ag btree root block initialisation

[Darrick J. Wong]

On Mon, May 14, 2018 at 02:18:58PM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
> 
> Cookie cutter code, easily factored.
> 
> Signed-Off-By: Dave Chinner <dchinner@redhat.com>

Looks ok,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>

--D

> ---
>  fs/xfs/xfs_fsops.c | 481 ++++++++++++++++++++++++---------------------
>  1 file changed, 259 insertions(+), 222 deletions(-)
> 
> diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> index 4b560caaf397..ec3c51ee8134 100644
> --- a/fs/xfs/xfs_fsops.c
> +++ b/fs/xfs/xfs_fsops.c
> @@ -71,46 +71,140 @@ xfs_growfs_get_hdr_buf(
>  	return bp;
>  }
>  
> +struct aghdr_init_data {
> +	/* per ag data */
> +	xfs_agnumber_t		agno;		/* ag to init */
> +	xfs_extlen_t		agsize;		/* new AG size */
> +	struct list_head	buffer_list;	/* buffer writeback list */
> +	xfs_rfsblock_t		nfree;		/* cumulative new free space */
> +
> +	/* per header data */
> +	xfs_daddr_t		daddr;		/* header location */
> +	size_t			numblks;	/* size of header */
> +	xfs_btnum_t		type;		/* type of btree root block */
> +};
> +
>  /*
> - * Write new AG headers to disk. Non-transactional, but written
> - * synchronously so they are completed prior to the growfs transaction
> - * being logged.
> + * Generic btree root block init function
>   */
> -static int
> -xfs_grow_ag_headers(
> +static void
> +xfs_btroot_init(
>  	struct xfs_mount	*mp,
> -	xfs_agnumber_t		agno,
> -	xfs_extlen_t		agsize,
> -	xfs_rfsblock_t		*nfree,
> -	struct list_head	*buffer_list)
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
>  {
> -	struct xfs_agf		*agf;
> -	struct xfs_agi		*agi;
> -	struct xfs_agfl		*agfl;
> -	__be32			*agfl_bno;
> -	xfs_alloc_rec_t		*arec;
> -	struct xfs_buf		*bp;
> -	int			bucket;
> -	xfs_extlen_t		tmpsize;
> -	int			error = 0;
> +	xfs_btree_init_block(mp, bp, id->type, 0, 0, id->agno, 0);
> +}
> +
> +/*
> + * Alloc btree root block init functions
> + */
> +static void
> +xfs_bnoroot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_alloc_rec	*arec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(id->agsize -
> +					  be32_to_cpu(arec->ar_startblock));
> +}
> +
> +static void
> +xfs_cntroot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_alloc_rec	*arec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(id->agsize -
> +					  be32_to_cpu(arec->ar_startblock));
> +}
> +
> +/*
> + * Reverse map root block init
> + */
> +static void
> +xfs_rmaproot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
> +	struct xfs_rmap_rec	*rrec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
>  
>  	/*
> -	 * AG freespace header block
> +	 * mark the AG header regions as static metadata The BNO
> +	 * btree block is the first block after the headers, so
> +	 * it's location defines the size of region the static
> +	 * metadata consumes.
> +	 *
> +	 * Note: unlike mkfs, we never have to account for log
> +	 * space when growing the data regions
>  	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agf_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> +	rrec = XFS_RMAP_REC_ADDR(block, 1);
> +	rrec->rm_startblock = 0;
> +	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> +	rrec->rm_offset = 0;
> +
> +	/* account freespace btree root blocks */
> +	rrec = XFS_RMAP_REC_ADDR(block, 2);
> +	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(2);
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +	rrec->rm_offset = 0;
> +
> +	/* account inode btree root blocks */
> +	rrec = XFS_RMAP_REC_ADDR(block, 3);
> +	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> +					  XFS_IBT_BLOCK(mp));
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> +	rrec->rm_offset = 0;
> +
> +	/* account for rmap btree root */
> +	rrec = XFS_RMAP_REC_ADDR(block, 4);
> +	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(1);
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +	rrec->rm_offset = 0;
> +
> +	/* account for refc btree root */
> +	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> +		rrec = XFS_RMAP_REC_ADDR(block, 5);
> +		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
> +		rrec->rm_blockcount = cpu_to_be32(1);
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
>  	}
> +}
> +
> +
> +static void
> +xfs_agfblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
> +	xfs_extlen_t		tmpsize;
>  
> -	agf = XFS_BUF_TO_AGF(bp);
>  	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
>  	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
> -	agf->agf_seqno = cpu_to_be32(agno);
> -	agf->agf_length = cpu_to_be32(agsize);
> +	agf->agf_seqno = cpu_to_be32(id->agno);
> +	agf->agf_length = cpu_to_be32(id->agsize);
>  	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
>  	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
>  	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
> @@ -125,7 +219,7 @@ xfs_grow_ag_headers(
>  	agf->agf_flfirst = cpu_to_be32(1);
>  	agf->agf_fllast = 0;
>  	agf->agf_flcount = 0;
> -	tmpsize = agsize - mp->m_ag_prealloc_blocks;
> +	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
>  	agf->agf_freeblks = cpu_to_be32(tmpsize);
>  	agf->agf_longest = cpu_to_be32(tmpsize);
>  	if (xfs_sb_version_hascrc(&mp->m_sb))
> @@ -136,52 +230,42 @@ xfs_grow_ag_headers(
>  		agf->agf_refcount_level = cpu_to_be32(1);
>  		agf->agf_refcount_blocks = cpu_to_be32(1);
>  	}
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> +}
>  
> -	/*
> -	 * AG freelist header block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agfl_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +static void
> +xfs_agflblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
> +	__be32			*agfl_bno;
> +	int			bucket;
>  
> -	agfl = XFS_BUF_TO_AGFL(bp);
>  	if (xfs_sb_version_hascrc(&mp->m_sb)) {
>  		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
> -		agfl->agfl_seqno = cpu_to_be32(agno);
> +		agfl->agfl_seqno = cpu_to_be32(id->agno);
>  		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
>  	}
>  
>  	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
>  	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
>  		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
> +}
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> -
> -	/*
> -	 * AG inode header block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agi_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +static void
> +xfs_agiblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
> +	int			bucket;
>  
> -	agi = XFS_BUF_TO_AGI(bp);
>  	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
>  	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
> -	agi->agi_seqno = cpu_to_be32(agno);
> -	agi->agi_length = cpu_to_be32(agsize);
> +	agi->agi_seqno = cpu_to_be32(id->agno);
> +	agi->agi_length = cpu_to_be32(id->agsize);
>  	agi->agi_count = 0;
>  	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
>  	agi->agi_level = cpu_to_be32(1);
> @@ -196,180 +280,133 @@ xfs_grow_ag_headers(
>  	}
>  	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
>  		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> +}
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> -
> -	/*
> -	 * BNO btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_allocbt_buf_ops);
> +static int
> +xfs_growfs_init_aghdr(
> +	struct xfs_mount	*mp,
> +	struct aghdr_init_data	*id,
> +	void			(*work)(struct xfs_mount *, struct xfs_buf *,
> +					struct aghdr_init_data *),
> +	const struct xfs_buf_ops *ops)
>  
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +{
> +	struct xfs_buf		*bp;
>  
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
> +	bp = xfs_growfs_get_hdr_buf(mp, id->daddr, id->numblks, 0, ops);
> +	if (!bp)
> +		return -ENOMEM;
>  
> -	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -	arec->ar_blockcount = cpu_to_be32(
> -		agsize - be32_to_cpu(arec->ar_startblock));
> +	(*work)(mp, bp, id);
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> +	xfs_buf_delwri_queue(bp, &id->buffer_list);
>  	xfs_buf_relse(bp);
> +	return 0;
> +}
>  
> -	/*
> -	 * CNT btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_allocbt_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> -
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
> +/*
> + * Write new AG headers to disk. Non-transactional, but written
> + * synchronously so they are completed prior to the growfs transaction
> + * being logged.
> + */
> +static int
> +xfs_grow_ag_headers(
> +	struct xfs_mount	*mp,
> +	struct aghdr_init_data	*id)
>  
> -	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -	arec->ar_blockcount = cpu_to_be32(
> -		agsize - be32_to_cpu(arec->ar_startblock));
> -	*nfree += be32_to_cpu(arec->ar_blockcount);
> +{
> +	int			error = 0;
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> +	/* Account for AG free space in new AG */
> +	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
>  
> -	/* RMAP btree root block */
> -	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> -		struct xfs_rmap_rec	*rrec;
> -		struct xfs_btree_block	*block;
> -
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_rmapbt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto out_error;
> -		}
> +	/* AG freespace header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
> +					&xfs_agf_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
> -					agno, 0);
> -		block = XFS_BUF_TO_BLOCK(bp);
> +	/* AG freelist header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
> +					&xfs_agfl_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> +	/* AG inode header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
> +					&xfs_agi_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/*
> -		 * mark the AG header regions as static metadata The BNO
> -		 * btree block is the first block after the headers, so
> -		 * it's location defines the size of region the static
> -		 * metadata consumes.
> -		 *
> -		 * Note: unlike mkfs, we never have to account for log
> -		 * space when growing the data regions
> -		 */
> -		rrec = XFS_RMAP_REC_ADDR(block, 1);
> -		rrec->rm_startblock = 0;
> -		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
>  
> -		/* account freespace btree root blocks */
> -		rrec = XFS_RMAP_REC_ADDR(block, 2);
> -		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(2);
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
> +	/* BNO btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
> +				   &xfs_allocbt_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/* account inode btree root blocks */
> -		rrec = XFS_RMAP_REC_ADDR(block, 3);
> -		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> -						XFS_IBT_BLOCK(mp));
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
>  
> -		/* account for rmap btree root */
> -		rrec = XFS_RMAP_REC_ADDR(block, 4);
> -		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(1);
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
> +	/* CNT btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
> +				   &xfs_allocbt_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/* account for refc btree root */
> -		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -			rrec = XFS_RMAP_REC_ADDR(block, 5);
> -			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
> -			rrec->rm_blockcount = cpu_to_be32(1);
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -		}
> +	/* RMAP btree root block */
> +	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
> +					   &xfs_rmapbt_buf_ops);
> +		if (error)
> +			goto out_error;
>  
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
> -	/*
> -	 * INO btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_inobt_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> +	/* INO btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	id->type = XFS_BTNUM_INO;
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +				   &xfs_inobt_buf_ops);
> +	if (error)
>  		goto out_error;
> -	}
>  
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
>  
>  	/*
>  	 * FINO btree root block
>  	 */
>  	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_inobt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		id->type = XFS_BTNUM_FINO;
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +					   &xfs_inobt_buf_ops);
> +		if (error)
>  			goto out_error;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO, 0, 0, agno, 0);
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
>  	/*
>  	 * refcount btree root block
>  	 */
>  	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_refcountbt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		id->type = XFS_BTNUM_REFC;
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +					   &xfs_refcountbt_buf_ops);
> +		if (error)
>  			goto out_error;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC, 0, 0, agno, 0);
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
>  out_error:
> @@ -384,7 +421,6 @@ xfs_growfs_data_private(
>  	xfs_agf_t		*agf;
>  	xfs_agi_t		*agi;
>  	xfs_agnumber_t		agno;
> -	xfs_extlen_t		agsize;
>  	xfs_buf_t		*bp;
>  	int			dpct;
>  	int			error, saved_error = 0;
> @@ -392,11 +428,11 @@ xfs_growfs_data_private(
>  	xfs_agnumber_t		nagimax = 0;
>  	xfs_rfsblock_t		nb, nb_mod;
>  	xfs_rfsblock_t		new;
> -	xfs_rfsblock_t		nfree;
>  	xfs_agnumber_t		oagcount;
>  	int			pct;
>  	xfs_trans_t		*tp;
>  	LIST_HEAD		(buffer_list);
> +	struct aghdr_init_data	id = {};
>  
>  	nb = in->newblocks;
>  	pct = in->imaxpct;
> @@ -448,27 +484,28 @@ xfs_growfs_data_private(
>  	 * list to write, we can cancel the entire list without having written
>  	 * anything.
>  	 */
> -	nfree = 0;
> -	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
> -
> -		if (agno == nagcount - 1)
> -			agsize = nb -
> -				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
> +	INIT_LIST_HEAD(&id.buffer_list);
> +	for (id.agno = nagcount - 1;
> +	     id.agno >= oagcount;
> +	     id.agno--, new -= id.agsize) {
> +
> +		if (id.agno == nagcount - 1)
> +			id.agsize = nb -
> +				(id.agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
>  		else
> -			agsize = mp->m_sb.sb_agblocks;
> +			id.agsize = mp->m_sb.sb_agblocks;
>  
> -		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree,
> -					    &buffer_list);
> +		error = xfs_grow_ag_headers(mp, &id);
>  		if (error) {
> -			xfs_buf_delwri_cancel(&buffer_list);
> +			xfs_buf_delwri_cancel(&id.buffer_list);
>  			goto error0;
>  		}
>  	}
> -	error = xfs_buf_delwri_submit(&buffer_list);
> +	error = xfs_buf_delwri_submit(&id.buffer_list);
>  	if (error)
>  		goto error0;
>  
> -	xfs_trans_agblocks_delta(tp, nfree);
> +	xfs_trans_agblocks_delta(tp, id.nfree);
>  
>  	/*
>  	 * There are new blocks in the old last a.g.
> @@ -479,7 +516,7 @@ xfs_growfs_data_private(
>  		/*
>  		 * Change the agi length.
>  		 */
> -		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
> +		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
>  		if (error) {
>  			goto error0;
>  		}
> @@ -492,7 +529,7 @@ xfs_growfs_data_private(
>  		/*
>  		 * Change agf length.
>  		 */
> -		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
> +		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
>  		if (error) {
>  			goto error0;
>  		}
> @@ -511,13 +548,13 @@ xfs_growfs_data_private(
>  		 * this doesn't actually exist in the rmap btree.
>  		 */
>  		xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
> -		error = xfs_rmap_free(tp, bp, agno,
> +		error = xfs_rmap_free(tp, bp, id.agno,
>  				be32_to_cpu(agf->agf_length) - new,
>  				new, &oinfo);
>  		if (error)
>  			goto error0;
>  		error = xfs_free_extent(tp,
> -				XFS_AGB_TO_FSB(mp, agno,
> +				XFS_AGB_TO_FSB(mp, id.agno,
>  					be32_to_cpu(agf->agf_length) - new),
>  				new, &oinfo, XFS_AG_RESV_NONE);
>  		if (error)
> @@ -534,8 +571,8 @@ xfs_growfs_data_private(
>  	if (nb > mp->m_sb.sb_dblocks)
>  		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
>  				 nb - mp->m_sb.sb_dblocks);
> -	if (nfree)
> -		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
> +	if (id.nfree)
> +		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
>  	if (dpct)
>  		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
>  	xfs_trans_set_sync(tp);
> @@ -562,7 +599,7 @@ xfs_growfs_data_private(
>  	if (new) {
>  		struct xfs_perag	*pag;
>  
> -		pag = xfs_perag_get(mp, agno);
> +		pag = xfs_perag_get(mp, id.agno);
>  		error = xfs_ag_resv_free(pag);
>  		xfs_perag_put(pag);
>  		if (error)
> -- 
> 2.17.0
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 05/10] xfs: turn ag header initialisation into a table driven operation

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

There's still more cookie cutter code in setting up each AG header.
Separate all the variables into a simple structure and iterate a
table of header definitions to initialise everything.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
---
 fs/xfs/xfs_fsops.c | 182 +++++++++++++++++++++++----------------------
 1 file changed, 92 insertions(+), 90 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index ec3c51ee8134..fb283d2cf42b 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -282,12 +282,13 @@ xfs_agiblock_init(
 		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
 }
 
+typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
+				  struct aghdr_init_data *id);
 static int
 xfs_growfs_init_aghdr(
 	struct xfs_mount	*mp,
 	struct aghdr_init_data	*id,
-	void			(*work)(struct xfs_mount *, struct xfs_buf *,
-					struct aghdr_init_data *),
+	aghdr_init_work_f	work,
 	const struct xfs_buf_ops *ops)
 
 {
@@ -304,6 +305,15 @@ xfs_growfs_init_aghdr(
 	return 0;
 }
 
+struct xfs_aghdr_grow_data {
+	xfs_daddr_t		daddr;
+	size_t			numblks;
+	const struct xfs_buf_ops *ops;
+	aghdr_init_work_f	work;
+	xfs_btnum_t		type;
+	bool			need_init;
+};
+
 /*
  * Write new AG headers to disk. Non-transactional, but written
  * synchronously so they are completed prior to the growfs transaction
@@ -315,101 +325,93 @@ xfs_grow_ag_headers(
 	struct aghdr_init_data	*id)
 
 {
+	struct xfs_aghdr_grow_data aghdr_data[] = {
+	{ /* AGF */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agf_buf_ops,
+		.work = &xfs_agfblock_init,
+		.need_init = true
+	},
+	{ /* AGFL */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agfl_buf_ops,
+		.work = &xfs_agflblock_init,
+		.need_init = true
+	},
+	{ /* AGI */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agi_buf_ops,
+		.work = &xfs_agiblock_init,
+		.need_init = true
+	},
+	{ /* BNO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_allocbt_buf_ops,
+		.work = &xfs_bnoroot_init,
+		.need_init = true
+	},
+	{ /* CNT root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_allocbt_buf_ops,
+		.work = &xfs_cntroot_init,
+		.need_init = true
+	},
+	{ /* INO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_inobt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_INO,
+		.need_init = true
+	},
+	{ /* FINO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_inobt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_FINO,
+		.need_init =  xfs_sb_version_hasfinobt(&mp->m_sb)
+	},
+	{ /* RMAP root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_rmapbt_buf_ops,
+		.work = &xfs_rmaproot_init,
+		.need_init = xfs_sb_version_hasrmapbt(&mp->m_sb)
+	},
+	{ /* REFC root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_refcountbt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_REFC,
+		.need_init = xfs_sb_version_hasreflink(&mp->m_sb)
+	},
+	{ /* NULL terminating block */
+		.daddr = XFS_BUF_DADDR_NULL,
+	}
+	};
+	struct  xfs_aghdr_grow_data *dp;
 	int			error = 0;
 
 	/* Account for AG free space in new AG */
 	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
+	for (dp = &aghdr_data[0]; dp->daddr != XFS_BUF_DADDR_NULL; dp++) {
+		if (!dp->need_init)
+			continue;
 
-	/* AG freespace header block */
-	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
-	id->numblks = XFS_FSS_TO_BB(mp, 1);
-	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
-					&xfs_agf_buf_ops);
-	if (error)
-		goto out_error;
-
-	/* AG freelist header block */
-	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
-	id->numblks = XFS_FSS_TO_BB(mp, 1);
-	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
-					&xfs_agfl_buf_ops);
-	if (error)
-		goto out_error;
-
-	/* AG inode header block */
-	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
-	id->numblks = XFS_FSS_TO_BB(mp, 1);
-	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
-					&xfs_agi_buf_ops);
-	if (error)
-		goto out_error;
-
-
-	/* BNO btree root block */
-	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
-	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
-				   &xfs_allocbt_buf_ops);
-	if (error)
-		goto out_error;
-
-
-	/* CNT btree root block */
-	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
-	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
-				   &xfs_allocbt_buf_ops);
-	if (error)
-		goto out_error;
-
-	/* RMAP btree root block */
-	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
-		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
-					   &xfs_rmapbt_buf_ops);
-		if (error)
-			goto out_error;
-
-	}
-
-	/* INO btree root block */
-	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
-	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-	id->type = XFS_BTNUM_INO;
-	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
-				   &xfs_inobt_buf_ops);
-	if (error)
-		goto out_error;
-
-
-	/*
-	 * FINO btree root block
-	 */
-	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
-		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-		id->type = XFS_BTNUM_FINO;
-		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
-					   &xfs_inobt_buf_ops);
-		if (error)
-			goto out_error;
-	}
-
-	/*
-	 * refcount btree root block
-	 */
-	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
-		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
-		id->type = XFS_BTNUM_REFC;
-		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
-					   &xfs_refcountbt_buf_ops);
+		id->daddr = dp->daddr;
+		id->numblks = dp->numblks;
+		id->type = dp->type;
+		error = xfs_growfs_init_aghdr(mp, id, dp->work, dp->ops);
 		if (error)
-			goto out_error;
+			break;
 	}
-
-out_error:
 	return error;
 }
 
-- 
2.17.0

Re: [PATCH 05/10] xfs: turn ag header initialisation into a table driven operation

[Darrick J. Wong]

On Mon, May 14, 2018 at 02:18:59PM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
> 
> There's still more cookie cutter code in setting up each AG header.
> Separate all the variables into a simple structure and iterate a
> table of header definitions to initialise everything.
> 
> Signed-Off-By: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Brian Foster <bfoster@redhat.com>
> ---
>  fs/xfs/xfs_fsops.c | 182 +++++++++++++++++++++++----------------------
>  1 file changed, 92 insertions(+), 90 deletions(-)
> 
> diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> index ec3c51ee8134..fb283d2cf42b 100644
> --- a/fs/xfs/xfs_fsops.c
> +++ b/fs/xfs/xfs_fsops.c
> @@ -282,12 +282,13 @@ xfs_agiblock_init(
>  		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
>  }
>  
> +typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
> +				  struct aghdr_init_data *id);
>  static int
>  xfs_growfs_init_aghdr(
>  	struct xfs_mount	*mp,
>  	struct aghdr_init_data	*id,
> -	void			(*work)(struct xfs_mount *, struct xfs_buf *,
> -					struct aghdr_init_data *),
> +	aghdr_init_work_f	work,
>  	const struct xfs_buf_ops *ops)
>  
>  {
> @@ -304,6 +305,15 @@ xfs_growfs_init_aghdr(
>  	return 0;
>  }
>  
> +struct xfs_aghdr_grow_data {
> +	xfs_daddr_t		daddr;
> +	size_t			numblks;
> +	const struct xfs_buf_ops *ops;
> +	aghdr_init_work_f	work;
> +	xfs_btnum_t		type;
> +	bool			need_init;
> +};
> +
>  /*
>   * Write new AG headers to disk. Non-transactional, but written
>   * synchronously so they are completed prior to the growfs transaction
> @@ -315,101 +325,93 @@ xfs_grow_ag_headers(
>  	struct aghdr_init_data	*id)
>  
>  {
> +	struct xfs_aghdr_grow_data aghdr_data[] = {
> +	{ /* AGF */
> +		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp)),
> +		.numblks = XFS_FSS_TO_BB(mp, 1),
> +		.ops = &xfs_agf_buf_ops,
> +		.work = &xfs_agfblock_init,
> +		.need_init = true
> +	},
> +	{ /* AGFL */
> +		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp)),
> +		.numblks = XFS_FSS_TO_BB(mp, 1),
> +		.ops = &xfs_agfl_buf_ops,
> +		.work = &xfs_agflblock_init,
> +		.need_init = true
> +	},
> +	{ /* AGI */
> +		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp)),
> +		.numblks = XFS_FSS_TO_BB(mp, 1),
> +		.ops = &xfs_agi_buf_ops,
> +		.work = &xfs_agiblock_init,
> +		.need_init = true
> +	},
> +	{ /* BNO root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_allocbt_buf_ops,
> +		.work = &xfs_bnoroot_init,
> +		.need_init = true
> +	},
> +	{ /* CNT root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_allocbt_buf_ops,
> +		.work = &xfs_cntroot_init,
> +		.need_init = true
> +	},
> +	{ /* INO root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_inobt_buf_ops,
> +		.work = &xfs_btroot_init,
> +		.type = XFS_BTNUM_INO,
> +		.need_init = true
> +	},
> +	{ /* FINO root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_inobt_buf_ops,
> +		.work = &xfs_btroot_init,
> +		.type = XFS_BTNUM_FINO,
> +		.need_init =  xfs_sb_version_hasfinobt(&mp->m_sb)
> +	},
> +	{ /* RMAP root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_rmapbt_buf_ops,
> +		.work = &xfs_rmaproot_init,
> +		.need_init = xfs_sb_version_hasrmapbt(&mp->m_sb)
> +	},
> +	{ /* REFC root block */
> +		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp)),
> +		.numblks = BTOBB(mp->m_sb.sb_blocksize),
> +		.ops = &xfs_refcountbt_buf_ops,
> +		.work = &xfs_btroot_init,
> +		.type = XFS_BTNUM_REFC,
> +		.need_init = xfs_sb_version_hasreflink(&mp->m_sb)

Muuuuch easier to read,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>

--D


> +	},
> +	{ /* NULL terminating block */
> +		.daddr = XFS_BUF_DADDR_NULL,
> +	}
> +	};
> +	struct  xfs_aghdr_grow_data *dp;
>  	int			error = 0;
>  
>  	/* Account for AG free space in new AG */
>  	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
> +	for (dp = &aghdr_data[0]; dp->daddr != XFS_BUF_DADDR_NULL; dp++) {
> +		if (!dp->need_init)
> +			continue;
>  
> -	/* AG freespace header block */
> -	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
> -	id->numblks = XFS_FSS_TO_BB(mp, 1);
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
> -					&xfs_agf_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -	/* AG freelist header block */
> -	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
> -	id->numblks = XFS_FSS_TO_BB(mp, 1);
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
> -					&xfs_agfl_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -	/* AG inode header block */
> -	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
> -	id->numblks = XFS_FSS_TO_BB(mp, 1);
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
> -					&xfs_agi_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -
> -	/* BNO btree root block */
> -	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
> -	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
> -				   &xfs_allocbt_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -
> -	/* CNT btree root block */
> -	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
> -	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
> -				   &xfs_allocbt_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -	/* RMAP btree root block */
> -	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> -		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
> -		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
> -					   &xfs_rmapbt_buf_ops);
> -		if (error)
> -			goto out_error;
> -
> -	}
> -
> -	/* INO btree root block */
> -	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
> -	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -	id->type = XFS_BTNUM_INO;
> -	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> -				   &xfs_inobt_buf_ops);
> -	if (error)
> -		goto out_error;
> -
> -
> -	/*
> -	 * FINO btree root block
> -	 */
> -	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> -		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
> -		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -		id->type = XFS_BTNUM_FINO;
> -		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> -					   &xfs_inobt_buf_ops);
> -		if (error)
> -			goto out_error;
> -	}
> -
> -	/*
> -	 * refcount btree root block
> -	 */
> -	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
> -		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> -		id->type = XFS_BTNUM_REFC;
> -		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> -					   &xfs_refcountbt_buf_ops);
> +		id->daddr = dp->daddr;
> +		id->numblks = dp->numblks;
> +		id->type = dp->type;
> +		error = xfs_growfs_init_aghdr(mp, id, dp->work, dp->ops);
>  		if (error)
> -			goto out_error;
> +			break;
>  	}
> -
> -out_error:
>  	return error;
>  }
>  
> -- 
> 2.17.0
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 06/10] xfs: make imaxpct changes in growfs separate

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

When growfs changes the imaxpct value of the filesystem, it runs
through all the "change size" growfs code, whether it needs to or
not. Separate out changing imaxpct into it's own function and
transaction to simplify the rest of the growfs code.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_fsops.c | 69 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 50 insertions(+), 19 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index fb283d2cf42b..4e66d390e2a4 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -424,25 +424,21 @@ xfs_growfs_data_private(
 	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
 	xfs_buf_t		*bp;
-	int			dpct;
 	int			error, saved_error = 0;
 	xfs_agnumber_t		nagcount;
 	xfs_agnumber_t		nagimax = 0;
 	xfs_rfsblock_t		nb, nb_mod;
 	xfs_rfsblock_t		new;
 	xfs_agnumber_t		oagcount;
-	int			pct;
 	xfs_trans_t		*tp;
 	LIST_HEAD		(buffer_list);
 	struct aghdr_init_data	id = {};
 
 	nb = in->newblocks;
-	pct = in->imaxpct;
-	if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
+	if (nb < mp->m_sb.sb_dblocks)
 		return -EINVAL;
 	if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
 		return error;
-	dpct = pct - mp->m_sb.sb_imax_pct;
 	error = xfs_buf_read_uncached(mp->m_ddev_targp,
 				XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
 				XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
@@ -575,8 +571,6 @@ xfs_growfs_data_private(
 				 nb - mp->m_sb.sb_dblocks);
 	if (id.nfree)
 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
-	if (dpct)
-		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
 	xfs_trans_set_sync(tp);
 	error = xfs_trans_commit(tp);
 	if (error)
@@ -585,12 +579,6 @@ xfs_growfs_data_private(
 	/* New allocation groups fully initialized, so update mount struct */
 	if (nagimax)
 		mp->m_maxagi = nagimax;
-	if (mp->m_sb.sb_imax_pct) {
-		uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
-		do_div(icount, 100);
-		mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
-	} else
-		mp->m_maxicount = 0;
 	xfs_set_low_space_thresholds(mp);
 	mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
 
@@ -694,25 +682,68 @@ xfs_growfs_log_private(
 	return -ENOSYS;
 }
 
+static int
+xfs_growfs_imaxpct(
+	struct xfs_mount	*mp,
+	__u32			imaxpct)
+{
+	struct xfs_trans	*tp;
+	int64_t			dpct;
+	int			error;
+
+	if (imaxpct > 100)
+		return -EINVAL;
+
+	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
+			XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
+	if (error)
+		return error;
+
+	dpct = (int64_t)imaxpct - mp->m_sb.sb_imax_pct;
+	xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
+	xfs_trans_set_sync(tp);
+	return xfs_trans_commit(tp);
+}
+
 /*
  * protected versions of growfs function acquire and release locks on the mount
  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
  * XFS_IOC_FSGROWFSRT
  */
-
-
 int
 xfs_growfs_data(
-	xfs_mount_t		*mp,
-	xfs_growfs_data_t	*in)
+	struct xfs_mount	*mp,
+	struct xfs_growfs_data	*in)
 {
-	int error;
+	int			error = 0;
 
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (!mutex_trylock(&mp->m_growlock))
 		return -EWOULDBLOCK;
-	error = xfs_growfs_data_private(mp, in);
+
+	/* update imaxpct separately to the physical grow of the filesystem */
+	if (in->imaxpct != mp->m_sb.sb_imax_pct) {
+		error = xfs_growfs_imaxpct(mp, in->imaxpct);
+		if (error)
+			goto out_error;
+	}
+
+	if (in->newblocks != mp->m_sb.sb_dblocks) {
+		error = xfs_growfs_data_private(mp, in);
+		if (error)
+			goto out_error;
+	}
+
+	/* Post growfs calculations needed to reflect new state in operations */
+	if (mp->m_sb.sb_imax_pct) {
+		uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
+		do_div(icount, 100);
+		mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
+	} else
+		mp->m_maxicount = 0;
+
+out_error:
 	/*
 	 * Increment the generation unconditionally, the error could be from
 	 * updating the secondary superblocks, in which case the new size
-- 
2.17.0

[PATCH 07/10] xfs: separate secondary sb update in growfs

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

This happens after all the transactions to update the superblock
occur, and errors need to be handled slightly differently. Seperate
out the code into it's own function, and clean up the error goto
stack in the core growfs code as it is now much simpler.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_fsops.c | 159 ++++++++++++++++++++++++++-------------------
 1 file changed, 92 insertions(+), 67 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 4e66d390e2a4..a718bb002cf4 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -422,9 +422,8 @@ xfs_growfs_data_private(
 {
 	xfs_agf_t		*agf;
 	xfs_agi_t		*agi;
-	xfs_agnumber_t		agno;
 	xfs_buf_t		*bp;
-	int			error, saved_error = 0;
+	int			error;
 	xfs_agnumber_t		nagcount;
 	xfs_agnumber_t		nagimax = 0;
 	xfs_rfsblock_t		nb, nb_mod;
@@ -496,12 +495,12 @@ xfs_growfs_data_private(
 		error = xfs_grow_ag_headers(mp, &id);
 		if (error) {
 			xfs_buf_delwri_cancel(&id.buffer_list);
-			goto error0;
+			goto out_trans_cancel;
 		}
 	}
 	error = xfs_buf_delwri_submit(&id.buffer_list);
 	if (error)
-		goto error0;
+		goto out_trans_cancel;
 
 	xfs_trans_agblocks_delta(tp, id.nfree);
 
@@ -515,22 +514,23 @@ xfs_growfs_data_private(
 		 * Change the agi length.
 		 */
 		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
-		if (error) {
-			goto error0;
-		}
+		if (error)
+			goto out_trans_cancel;
+
 		ASSERT(bp);
 		agi = XFS_BUF_TO_AGI(bp);
 		be32_add_cpu(&agi->agi_length, new);
 		ASSERT(nagcount == oagcount ||
 		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
 		xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
+
 		/*
 		 * Change agf length.
 		 */
 		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
-		if (error) {
-			goto error0;
-		}
+		if (error)
+			goto out_trans_cancel;
+
 		ASSERT(bp);
 		agf = XFS_BUF_TO_AGF(bp);
 		be32_add_cpu(&agf->agf_length, new);
@@ -550,13 +550,13 @@ xfs_growfs_data_private(
 				be32_to_cpu(agf->agf_length) - new,
 				new, &oinfo);
 		if (error)
-			goto error0;
+			goto out_trans_cancel;
 		error = xfs_free_extent(tp,
 				XFS_AGB_TO_FSB(mp, id.agno,
 					be32_to_cpu(agf->agf_length) - new),
 				new, &oinfo, XFS_AG_RESV_NONE);
 		if (error)
-			goto error0;
+			goto out_trans_cancel;
 	}
 
 	/*
@@ -593,16 +593,86 @@ xfs_growfs_data_private(
 		error = xfs_ag_resv_free(pag);
 		xfs_perag_put(pag);
 		if (error)
-			goto out;
+			return error;
 	}
 
-	/* Reserve AG metadata blocks. */
+	/*
+	 * Reserve AG metadata blocks. ENOSPC here does not mean there was a
+	 * growfs failure, just that there still isn't space for new user data
+	 * after the grow has been run.
+	 */
 	error = xfs_fs_reserve_ag_blocks(mp);
-	if (error && error != -ENOSPC)
-		goto out;
+	if (error == -ENOSPC)
+		error = 0;
+	return error;
+
+out_trans_cancel:
+	xfs_trans_cancel(tp);
+	return error;
+}
+
+static int
+xfs_growfs_log_private(
+	xfs_mount_t		*mp,	/* mount point for filesystem */
+	xfs_growfs_log_t	*in)	/* growfs log input struct */
+{
+	xfs_extlen_t		nb;
+
+	nb = in->newblocks;
+	if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
+		return -EINVAL;
+	if (nb == mp->m_sb.sb_logblocks &&
+	    in->isint == (mp->m_sb.sb_logstart != 0))
+		return -EINVAL;
+	/*
+	 * Moving the log is hard, need new interfaces to sync
+	 * the log first, hold off all activity while moving it.
+	 * Can have shorter or longer log in the same space,
+	 * or transform internal to external log or vice versa.
+	 */
+	return -ENOSYS;
+}
+
+static int
+xfs_growfs_imaxpct(
+	struct xfs_mount	*mp,
+	__u32			imaxpct)
+{
+	struct xfs_trans	*tp;
+	int			dpct;
+	int			error;
+
+	if (imaxpct > 100)
+		return -EINVAL;
+
+	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
+			XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
+	if (error)
+		return error;
+
+	dpct = imaxpct - mp->m_sb.sb_imax_pct;
+	xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
+	xfs_trans_set_sync(tp);
+	return xfs_trans_commit(tp);
+}
+
+/*
+ * After a grow operation, we need to update all the secondary superblocks
+ * to match the new state of the primary. Read/init the superblocks and update
+ * them appropriately.
+ */
+static int
+xfs_growfs_update_superblocks(
+	struct xfs_mount	*mp,
+	xfs_agnumber_t		oagcount)
+{
+	struct xfs_buf		*bp;
+	xfs_agnumber_t		agno;
+	int			saved_error = 0;
+	int			error = 0;
 
 	/* update secondary superblocks. */
-	for (agno = 1; agno < nagcount; agno++) {
+	for (agno = 1; agno < mp->m_sb.sb_agcount; agno++) {
 		error = 0;
 		/*
 		 * new secondary superblocks need to be zeroed, not read from
@@ -652,57 +722,7 @@ xfs_growfs_data_private(
 		}
 	}
 
- out:
 	return saved_error ? saved_error : error;
-
- error0:
-	xfs_trans_cancel(tp);
-	return error;
-}
-
-static int
-xfs_growfs_log_private(
-	xfs_mount_t		*mp,	/* mount point for filesystem */
-	xfs_growfs_log_t	*in)	/* growfs log input struct */
-{
-	xfs_extlen_t		nb;
-
-	nb = in->newblocks;
-	if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
-		return -EINVAL;
-	if (nb == mp->m_sb.sb_logblocks &&
-	    in->isint == (mp->m_sb.sb_logstart != 0))
-		return -EINVAL;
-	/*
-	 * Moving the log is hard, need new interfaces to sync
-	 * the log first, hold off all activity while moving it.
-	 * Can have shorter or longer log in the same space,
-	 * or transform internal to external log or vice versa.
-	 */
-	return -ENOSYS;
-}
-
-static int
-xfs_growfs_imaxpct(
-	struct xfs_mount	*mp,
-	__u32			imaxpct)
-{
-	struct xfs_trans	*tp;
-	int64_t			dpct;
-	int			error;
-
-	if (imaxpct > 100)
-		return -EINVAL;
-
-	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
-			XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
-	if (error)
-		return error;
-
-	dpct = (int64_t)imaxpct - mp->m_sb.sb_imax_pct;
-	xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
-	xfs_trans_set_sync(tp);
-	return xfs_trans_commit(tp);
 }
 
 /*
@@ -715,6 +735,7 @@ xfs_growfs_data(
 	struct xfs_mount	*mp,
 	struct xfs_growfs_data	*in)
 {
+	xfs_agnumber_t		oagcount;
 	int			error = 0;
 
 	if (!capable(CAP_SYS_ADMIN))
@@ -729,6 +750,7 @@ xfs_growfs_data(
 			goto out_error;
 	}
 
+	oagcount = mp->m_sb.sb_agcount;
 	if (in->newblocks != mp->m_sb.sb_dblocks) {
 		error = xfs_growfs_data_private(mp, in);
 		if (error)
@@ -743,6 +765,9 @@ xfs_growfs_data(
 	} else
 		mp->m_maxicount = 0;
 
+	/* Update secondary superblocks now the physical grow has completed */
+	error = xfs_growfs_update_superblocks(mp, oagcount);
+
 out_error:
 	/*
 	 * Increment the generation unconditionally, the error could be from
-- 
2.17.0

[PATCH 08/10] xfs: rework secondary superblock updates in growfs

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Right now we wait until we've committed changes to the primary
superblock before we initialise any of the new secondary
superblocks. This means that if we have any write errors for new
secondary superblocks we end up with garbage in place rather than
zeros or even an "in progress" superblock to indicate a grow
operation is being done.

To ensure we can write the secondary superblocks, initialise them
earlier in the same loop that initialises the AG headers. We stamp
the new secondary superblocks here with the old geometry, but set
the "sb_inprogress" field to indicate that updates are being done to
the superblock so they cannot be used.  This will result in the
secondary superblock fields being updated or triggering errors that
will abort the grow before we commit any permanent changes.

This also means we can change the update mechanism of the secondary
superblocks.  We know that we are going to wholly overwrite the
information in the struct xfs_sb in the buffer, so there's no point
reading it from disk. Just allocate an uncached buffer, zero it in
memory, stamp the new superblock structure in it and write it out.
If we fail to write it out, then we'll leave the existing sb (old or
new w/ inprogress) on disk for repair to deal with later.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_fsops.c | 102 +++++++++++++++++++++++++++++----------------
 1 file changed, 65 insertions(+), 37 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index a718bb002cf4..ca3cf3f6239a 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -191,6 +191,25 @@ xfs_rmaproot_init(
 	}
 }
 
+/*
+ * Initialise new secondary superblocks with the pre-grow geometry, but mark
+ * them as "in progress" so we know they haven't yet been activated. This will
+ * get cleared when the update with the new geometry information is done after
+ * changes to the primary are committed. This isn't strictly necessary, but we
+ * get it for free with the delayed buffer write lists and it means we can tell
+ * if a grow operation didn't complete properly after the fact.
+ */
+static void
+xfs_sbblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_dsb		*dsb = XFS_BUF_TO_SBP(bp);
+
+	xfs_sb_to_disk(dsb, &mp->m_sb);
+	dsb->sb_inprogress = 1;
+}
 
 static void
 xfs_agfblock_init(
@@ -326,6 +345,13 @@ xfs_grow_ag_headers(
 
 {
 	struct xfs_aghdr_grow_data aghdr_data[] = {
+	{ /* SB */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_SB_DADDR),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_sb_buf_ops,
+		.work = &xfs_sbblock_init,
+		.need_init = true
+	},
 	{ /* AGF */
 		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp)),
 		.numblks = XFS_FSS_TO_BB(mp, 1),
@@ -658,43 +684,30 @@ xfs_growfs_imaxpct(
 
 /*
  * After a grow operation, we need to update all the secondary superblocks
- * to match the new state of the primary. Read/init the superblocks and update
- * them appropriately.
+ * to match the new state of the primary. Because we are completely overwriting
+ * all the existing fields in the secondary superblock buffers, there is no need
+ * to read them in from disk. Just get a new buffer, stamp it and write it.
+ *
+ * The sb buffers need to be cached here so that we serialise against scrub
+ * scanning secondary superblocks, but we don't want to keep it in memory once
+ * it is written so we mark it as a one-shot buffer.
  */
 static int
 xfs_growfs_update_superblocks(
-	struct xfs_mount	*mp,
-	xfs_agnumber_t		oagcount)
+	struct xfs_mount	*mp)
 {
-	struct xfs_buf		*bp;
 	xfs_agnumber_t		agno;
 	int			saved_error = 0;
 	int			error = 0;
+	LIST_HEAD		(buffer_list);
 
 	/* update secondary superblocks. */
 	for (agno = 1; agno < mp->m_sb.sb_agcount; agno++) {
-		error = 0;
-		/*
-		 * new secondary superblocks need to be zeroed, not read from
-		 * disk as the contents of the new area we are growing into is
-		 * completely unknown.
-		 */
-		if (agno < oagcount) {
-			error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
-				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
-				  XFS_FSS_TO_BB(mp, 1), 0, &bp,
-				  &xfs_sb_buf_ops);
-		} else {
-			bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp,
-				  XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
-				  XFS_FSS_TO_BB(mp, 1), 0);
-			if (bp) {
-				bp->b_ops = &xfs_sb_buf_ops;
-				xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
-			} else
-				error = -ENOMEM;
-		}
+		struct xfs_buf		*bp;
 
+		bp = xfs_buf_get(mp->m_ddev_targp,
+				 XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
+				 XFS_FSS_TO_BB(mp, 1), 0);
 		/*
 		 * If we get an error reading or writing alternate superblocks,
 		 * continue.  xfs_repair chooses the "best" superblock based
@@ -702,25 +715,42 @@ xfs_growfs_update_superblocks(
 		 * superblocks un-updated than updated, and xfs_repair may
 		 * pick them over the properly-updated primary.
 		 */
-		if (error) {
+		if (!bp) {
 			xfs_warn(mp,
-		"error %d reading secondary superblock for ag %d",
-				error, agno);
-			saved_error = error;
+		"error allocating secondary superblock for ag %d",
+				agno);
+			if (!saved_error)
+				saved_error = -ENOMEM;
 			continue;
 		}
-		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
 
-		error = xfs_bwrite(bp);
+		bp->b_ops = &xfs_sb_buf_ops;
+		xfs_buf_oneshot(bp);
+		xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
+		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
+		xfs_buf_delwri_queue(bp, &buffer_list);
 		xfs_buf_relse(bp);
+
+		/* don't hold too many buffers at once */
+		if (agno % 16)
+			continue;
+
+		error = xfs_buf_delwri_submit(&buffer_list);
 		if (error) {
 			xfs_warn(mp,
-		"write error %d updating secondary superblock for ag %d",
+		"write error %d updating a secondary superblock near ag %d",
 				error, agno);
-			saved_error = error;
+			if (!saved_error)
+				saved_error = error;
 			continue;
 		}
 	}
+	error = xfs_buf_delwri_submit(&buffer_list);
+	if (error) {
+		xfs_warn(mp,
+		"write error %d updating a secondary superblock near ag %d",
+			error, agno);
+	}
 
 	return saved_error ? saved_error : error;
 }
@@ -735,7 +765,6 @@ xfs_growfs_data(
 	struct xfs_mount	*mp,
 	struct xfs_growfs_data	*in)
 {
-	xfs_agnumber_t		oagcount;
 	int			error = 0;
 
 	if (!capable(CAP_SYS_ADMIN))
@@ -750,7 +779,6 @@ xfs_growfs_data(
 			goto out_error;
 	}
 
-	oagcount = mp->m_sb.sb_agcount;
 	if (in->newblocks != mp->m_sb.sb_dblocks) {
 		error = xfs_growfs_data_private(mp, in);
 		if (error)
@@ -766,7 +794,7 @@ xfs_growfs_data(
 		mp->m_maxicount = 0;
 
 	/* Update secondary superblocks now the physical grow has completed */
-	error = xfs_growfs_update_superblocks(mp, oagcount);
+	error = xfs_growfs_update_superblocks(mp);
 
 out_error:
 	/*
-- 
2.17.0

[PATCH 09/10] xfs: move growfs core to libxfs

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

So it can be shared with userspace (e.g. mkfs) easily.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/Makefile        |   1 +
 fs/xfs/libxfs/xfs_ag.c | 404 ++++++++++++++++++++++++++++++++++
 fs/xfs/libxfs/xfs_ag.h |  25 +++
 fs/xfs/libxfs/xfs_sb.c |  73 +++++++
 fs/xfs/libxfs/xfs_sb.h |   9 +
 fs/xfs/xfs_fsops.c     | 479 +----------------------------------------
 6 files changed, 516 insertions(+), 475 deletions(-)
 create mode 100644 fs/xfs/libxfs/xfs_ag.c
 create mode 100644 fs/xfs/libxfs/xfs_ag.h

diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 7ceb41a9786a..762477208322 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -28,6 +28,7 @@ xfs-y				+= xfs_trace.o
 
 # build the libxfs code first
 xfs-y				+= $(addprefix libxfs/, \
+				   xfs_ag.o \
 				   xfs_alloc.o \
 				   xfs_alloc_btree.o \
 				   xfs_attr.o \
diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
new file mode 100644
index 000000000000..5baa22c07095
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -0,0 +1,404 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2018 Red Hat, Inc.
+ * All rights reserved.
+ */
+
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_sb.h"
+#include "xfs_mount.h"
+#include "xfs_btree.h"
+#include "xfs_alloc_btree.h"
+#include "xfs_rmap_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_rmap.h"
+#include "xfs_ag.h"
+
+static struct xfs_buf *
+xfs_get_aghdr_buf(
+	struct xfs_mount	*mp,
+	xfs_daddr_t		blkno,
+	size_t			numblks,
+	int			flags,
+	const struct xfs_buf_ops *ops)
+{
+	struct xfs_buf		*bp;
+
+	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);
+	if (!bp)
+		return NULL;
+
+	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
+	bp->b_bn = blkno;
+	bp->b_maps[0].bm_bn = blkno;
+	bp->b_ops = ops;
+
+	return bp;
+}
+
+/*
+ * Generic btree root block init function
+ */
+static void
+xfs_btroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	xfs_btree_init_block(mp, bp, id->type, 0, 0, id->agno, 0);
+}
+
+/*
+ * Alloc btree root block init functions
+ */
+static void
+xfs_bnoroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+static void
+xfs_cntroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+/*
+ * Reverse map root block init
+ */
+static void
+xfs_rmaproot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
+	struct xfs_rmap_rec	*rrec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
+
+	/*
+	 * mark the AG header regions as static metadata The BNO
+	 * btree block is the first block after the headers, so
+	 * it's location defines the size of region the static
+	 * metadata consumes.
+	 *
+	 * Note: unlike mkfs, we never have to account for log
+	 * space when growing the data regions
+	 */
+	rrec = XFS_RMAP_REC_ADDR(block, 1);
+	rrec->rm_startblock = 0;
+	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+	rrec->rm_offset = 0;
+
+	/* account freespace btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 2);
+	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(2);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account inode btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 3);
+	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+					  XFS_IBT_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+	rrec->rm_offset = 0;
+
+	/* account for rmap btree root */
+	rrec = XFS_RMAP_REC_ADDR(block, 4);
+	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(1);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account for refc btree root */
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		rrec = XFS_RMAP_REC_ADDR(block, 5);
+		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
+		rrec->rm_blockcount = cpu_to_be32(1);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+	}
+}
+
+/*
+ * Initialise new secondary superblocks with the pre-grow geometry, but mark
+ * them as "in progress" so we know they haven't yet been activated. This will
+ * get cleared when the update with the new geometry information is done after
+ * changes to the primary are committed. This isn't strictly necessary, but we
+ * get it for free with the delayed buffer write lists and it means we can tell
+ * if a grow operation didn't complete properly after the fact.
+ */
+static void
+xfs_sbblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_dsb		*dsb = XFS_BUF_TO_SBP(bp);
+
+	xfs_sb_to_disk(dsb, &mp->m_sb);
+	dsb->sb_inprogress = 1;
+}
+
+static void
+xfs_agfblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
+	xfs_extlen_t		tmpsize;
+
+	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
+	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
+	agf->agf_seqno = cpu_to_be32(id->agno);
+	agf->agf_length = cpu_to_be32(id->agsize);
+	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
+	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
+	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
+	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+		agf->agf_roots[XFS_BTNUM_RMAPi] =
+					cpu_to_be32(XFS_RMAP_BLOCK(mp));
+		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
+		agf->agf_rmap_blocks = cpu_to_be32(1);
+	}
+
+	agf->agf_flfirst = cpu_to_be32(1);
+	agf->agf_fllast = 0;
+	agf->agf_flcount = 0;
+	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
+	agf->agf_freeblks = cpu_to_be32(tmpsize);
+	agf->agf_longest = cpu_to_be32(tmpsize);
+	if (xfs_sb_version_hascrc(&mp->m_sb))
+		uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		agf->agf_refcount_root = cpu_to_be32(
+				xfs_refc_block(mp));
+		agf->agf_refcount_level = cpu_to_be32(1);
+		agf->agf_refcount_blocks = cpu_to_be32(1);
+	}
+}
+
+static void
+xfs_agflblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
+	__be32			*agfl_bno;
+	int			bucket;
+
+	if (xfs_sb_version_hascrc(&mp->m_sb)) {
+		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
+		agfl->agfl_seqno = cpu_to_be32(id->agno);
+		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
+	}
+
+	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
+	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
+		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
+}
+
+static void
+xfs_agiblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
+	int			bucket;
+
+	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
+	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
+	agi->agi_seqno = cpu_to_be32(id->agno);
+	agi->agi_length = cpu_to_be32(id->agsize);
+	agi->agi_count = 0;
+	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	agi->agi_level = cpu_to_be32(1);
+	agi->agi_freecount = 0;
+	agi->agi_newino = cpu_to_be32(NULLAGINO);
+	agi->agi_dirino = cpu_to_be32(NULLAGINO);
+	if (xfs_sb_version_hascrc(&mp->m_sb))
+		uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
+	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
+		agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
+		agi->agi_free_level = cpu_to_be32(1);
+	}
+	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
+		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
+}
+
+typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
+				  struct aghdr_init_data *id);
+static int
+xfs_ag_init_hdr(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id,
+	aghdr_init_work_f	work,
+	const struct xfs_buf_ops *ops)
+
+{
+	struct xfs_buf		*bp;
+
+	bp = xfs_get_aghdr_buf(mp, id->daddr, id->numblks, 0, ops);
+	if (!bp)
+		return -ENOMEM;
+
+	(*work)(mp, bp, id);
+
+	xfs_buf_delwri_queue(bp, &id->buffer_list);
+	xfs_buf_relse(bp);
+	return 0;
+}
+
+struct xfs_aghdr_grow_data {
+	xfs_daddr_t		daddr;
+	size_t			numblks;
+	const struct xfs_buf_ops *ops;
+	aghdr_init_work_f	work;
+	xfs_btnum_t		type;
+	bool			need_init;
+};
+
+/*
+ * Prepare new AG headers to be written to disk. We use uncached buffers here,
+ * as it is assumed these new AG headers are currently beyond the currently
+ * valid filesystem address space. Using cached buffers would trip over EOFS
+ * corruption detection alogrithms in the buffer cache lookup routines.
+ *
+ * This is a non-transactional function, but the prepared buffers are added to a
+ * delayed write buffer list supplied by the caller so they can submit them to
+ * disk and wait on them as required.
+ */
+int
+xfs_ag_init_headers(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id)
+
+{
+	struct xfs_aghdr_grow_data aghdr_data[] = {
+	{ /* SB */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_SB_DADDR),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_sb_buf_ops,
+		.work = &xfs_sbblock_init,
+		.need_init = true
+	},
+	{ /* AGF */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agf_buf_ops,
+		.work = &xfs_agfblock_init,
+		.need_init = true
+	},
+	{ /* AGFL */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agfl_buf_ops,
+		.work = &xfs_agflblock_init,
+		.need_init = true
+	},
+	{ /* AGI */
+		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp)),
+		.numblks = XFS_FSS_TO_BB(mp, 1),
+		.ops = &xfs_agi_buf_ops,
+		.work = &xfs_agiblock_init,
+		.need_init = true
+	},
+	{ /* BNO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_allocbt_buf_ops,
+		.work = &xfs_bnoroot_init,
+		.need_init = true
+	},
+	{ /* CNT root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_allocbt_buf_ops,
+		.work = &xfs_cntroot_init,
+		.need_init = true
+	},
+	{ /* INO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_inobt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_INO,
+		.need_init = true
+	},
+	{ /* FINO root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_inobt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_FINO,
+		.need_init =  xfs_sb_version_hasfinobt(&mp->m_sb)
+	},
+	{ /* RMAP root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_rmapbt_buf_ops,
+		.work = &xfs_rmaproot_init,
+		.need_init = xfs_sb_version_hasrmapbt(&mp->m_sb)
+	},
+	{ /* REFC root block */
+		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp)),
+		.numblks = BTOBB(mp->m_sb.sb_blocksize),
+		.ops = &xfs_refcountbt_buf_ops,
+		.work = &xfs_btroot_init,
+		.type = XFS_BTNUM_REFC,
+		.need_init = xfs_sb_version_hasreflink(&mp->m_sb)
+	},
+	{ /* NULL terminating block */
+		.daddr = XFS_BUF_DADDR_NULL,
+	}
+	};
+	struct  xfs_aghdr_grow_data *dp;
+	int			error = 0;
+
+	/* Account for AG free space in new AG */
+	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
+	for (dp = &aghdr_data[0]; dp->daddr != XFS_BUF_DADDR_NULL; dp++) {
+		if (!dp->need_init)
+			continue;
+
+		id->daddr = dp->daddr;
+		id->numblks = dp->numblks;
+		id->type = dp->type;
+		error = xfs_ag_init_hdr(mp, id, dp->work, dp->ops);
+		if (error)
+			break;
+	}
+	return error;
+}
diff --git a/fs/xfs/libxfs/xfs_ag.h b/fs/xfs/libxfs/xfs_ag.h
new file mode 100644
index 000000000000..69f2fd4be0ea
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_ag.h
@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018 Red Hat, Inc.
+ * All rights reserved.
+ */
+
+#ifndef __LIBXFS_AG_H
+#define __LIBXFS_AG_H 1
+
+struct aghdr_init_data {
+	/* per ag data */
+	xfs_agblock_t		agno;		/* ag to init */
+	xfs_extlen_t		agsize;		/* new AG size */
+	struct list_head	buffer_list;	/* buffer writeback list */
+	xfs_rfsblock_t		nfree;		/* cumulative new free space */
+
+	/* per header data */
+	xfs_daddr_t		daddr;		/* header location */
+	size_t			numblks;	/* size of header */
+	xfs_btnum_t		type;		/* type of btree root block */
+};
+
+int xfs_ag_init_headers( struct xfs_mount *mp, struct aghdr_init_data *id);
+
+#endif /* __LIBXFS_AG_H */
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index d9b94bd5f689..75b2fee6f99a 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -888,6 +888,79 @@ xfs_sync_sb(
 	return xfs_trans_commit(tp);
 }
 
+/*
+ * Update all the secondary superblocks to match the new state of the primary.
+ * Because we are completely overwriting all the existing fields in the
+ * secondary superblock buffers, there is no need to read them in from disk.
+ * Just get a new buffer, stamp it and write it.
+ *
+ * The sb buffers need to be cached here so that we serialise against other
+ * operations that access the secondary superblocks, but we don't want to keep
+ * them in memory once it is written so we mark it as a one-shot buffer.
+ */
+int
+xfs_update_secondary_sbs(
+	struct xfs_mount	*mp)
+{
+	xfs_agnumber_t		agno;
+	int			saved_error = 0;
+	int			error = 0;
+	LIST_HEAD		(buffer_list);
+
+	/* update secondary superblocks. */
+	for (agno = 1; agno < mp->m_sb.sb_agcount; agno++) {
+		struct xfs_buf		*bp;
+
+		bp = xfs_buf_get(mp->m_ddev_targp,
+				 XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
+				 XFS_FSS_TO_BB(mp, 1), 0);
+		/*
+		 * If we get an error reading or writing alternate superblocks,
+		 * continue.  xfs_repair chooses the "best" superblock based
+		 * on most matches; if we break early, we'll leave more
+		 * superblocks un-updated than updated, and xfs_repair may
+		 * pick them over the properly-updated primary.
+		 */
+		if (!bp) {
+			xfs_warn(mp,
+		"error allocating secondary superblock for ag %d",
+				agno);
+			if (!saved_error)
+				saved_error = -ENOMEM;
+			continue;
+		}
+
+		bp->b_ops = &xfs_sb_buf_ops;
+		xfs_buf_oneshot(bp);
+		xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
+		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
+		xfs_buf_delwri_queue(bp, &buffer_list);
+		xfs_buf_relse(bp);
+
+		/* don't hold too many buffers at once */
+		if (agno % 16)
+			continue;
+
+		error = xfs_buf_delwri_submit(&buffer_list);
+		if (error) {
+			xfs_warn(mp,
+		"write error %d updating a secondary superblock near ag %d",
+				error, agno);
+			if (!saved_error)
+				saved_error = error;
+			continue;
+		}
+	}
+	error = xfs_buf_delwri_submit(&buffer_list);
+	if (error) {
+		xfs_warn(mp,
+		"write error %d updating a secondary superblock near ag %d",
+			error, agno);
+	}
+
+	return saved_error ? saved_error : error;
+}
+
 int
 xfs_fs_geometry(
 	struct xfs_sb		*sbp,
diff --git a/fs/xfs/libxfs/xfs_sb.h b/fs/xfs/libxfs/xfs_sb.h
index 63dcd2a1a657..bb0196b56fa5 100644
--- a/fs/xfs/libxfs/xfs_sb.h
+++ b/fs/xfs/libxfs/xfs_sb.h
@@ -18,6 +18,13 @@
 #ifndef __XFS_SB_H__
 #define	__XFS_SB_H__
 
+struct xfs_mount;
+struct xfs_sb;
+struct xfs_dsb;
+struct xfs_trans;
+struct xfs_fsop_geom;
+struct xfs_perag;
+
 /*
  * perag get/put wrappers for ref counting
  */
@@ -34,6 +41,8 @@ extern void	xfs_sb_from_disk(struct xfs_sb *to, struct xfs_dsb *from);
 extern void	xfs_sb_to_disk(struct xfs_dsb *to, struct xfs_sb *from);
 extern void	xfs_sb_quota_from_disk(struct xfs_sb *sbp);
 
+extern int	xfs_update_secondary_sbs(struct xfs_mount *mp);
+
 #define XFS_FS_GEOM_MAX_STRUCT_VER	(4)
 extern int	xfs_fs_geometry(struct xfs_sb *sbp, struct xfs_fsop_geom *geo,
 				int struct_version);
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index ca3cf3f6239a..c5087b79bcea 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -24,11 +24,7 @@
 #include "xfs_sb.h"
 #include "xfs_mount.h"
 #include "xfs_defer.h"
-#include "xfs_da_format.h"
-#include "xfs_da_btree.h"
-#include "xfs_inode.h"
 #include "xfs_trans.h"
-#include "xfs_inode_item.h"
 #include "xfs_error.h"
 #include "xfs_btree.h"
 #include "xfs_alloc_btree.h"
@@ -36,411 +32,17 @@
 #include "xfs_rmap_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_fsops.h"
-#include "xfs_itable.h"
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
 #include "xfs_trace.h"
 #include "xfs_log.h"
-#include "xfs_filestream.h"
 #include "xfs_rmap.h"
+#include "xfs_ag.h"
 #include "xfs_ag_resv.h"
 
 /*
- * File system operations
- */
-
-static struct xfs_buf *
-xfs_growfs_get_hdr_buf(
-	struct xfs_mount	*mp,
-	xfs_daddr_t		blkno,
-	size_t			numblks,
-	int			flags,
-	const struct xfs_buf_ops *ops)
-{
-	struct xfs_buf		*bp;
-
-	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);
-	if (!bp)
-		return NULL;
-
-	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
-	bp->b_bn = blkno;
-	bp->b_maps[0].bm_bn = blkno;
-	bp->b_ops = ops;
-
-	return bp;
-}
-
-struct aghdr_init_data {
-	/* per ag data */
-	xfs_agnumber_t		agno;		/* ag to init */
-	xfs_extlen_t		agsize;		/* new AG size */
-	struct list_head	buffer_list;	/* buffer writeback list */
-	xfs_rfsblock_t		nfree;		/* cumulative new free space */
-
-	/* per header data */
-	xfs_daddr_t		daddr;		/* header location */
-	size_t			numblks;	/* size of header */
-	xfs_btnum_t		type;		/* type of btree root block */
-};
-
-/*
- * Generic btree root block init function
- */
-static void
-xfs_btroot_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	xfs_btree_init_block(mp, bp, id->type, 0, 0, id->agno, 0);
-}
-
-/*
- * Alloc btree root block init functions
- */
-static void
-xfs_bnoroot_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_alloc_rec	*arec;
-
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(id->agsize -
-					  be32_to_cpu(arec->ar_startblock));
-}
-
-static void
-xfs_cntroot_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_alloc_rec	*arec;
-
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(id->agsize -
-					  be32_to_cpu(arec->ar_startblock));
-}
-
-/*
- * Reverse map root block init
- */
-static void
-xfs_rmaproot_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
-	struct xfs_rmap_rec	*rrec;
-
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
-
-	/*
-	 * mark the AG header regions as static metadata The BNO
-	 * btree block is the first block after the headers, so
-	 * it's location defines the size of region the static
-	 * metadata consumes.
-	 *
-	 * Note: unlike mkfs, we never have to account for log
-	 * space when growing the data regions
-	 */
-	rrec = XFS_RMAP_REC_ADDR(block, 1);
-	rrec->rm_startblock = 0;
-	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
-	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
-	rrec->rm_offset = 0;
-
-	/* account freespace btree root blocks */
-	rrec = XFS_RMAP_REC_ADDR(block, 2);
-	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
-	rrec->rm_blockcount = cpu_to_be32(2);
-	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-	rrec->rm_offset = 0;
-
-	/* account inode btree root blocks */
-	rrec = XFS_RMAP_REC_ADDR(block, 3);
-	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
-	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
-					  XFS_IBT_BLOCK(mp));
-	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
-	rrec->rm_offset = 0;
-
-	/* account for rmap btree root */
-	rrec = XFS_RMAP_REC_ADDR(block, 4);
-	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
-	rrec->rm_blockcount = cpu_to_be32(1);
-	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-	rrec->rm_offset = 0;
-
-	/* account for refc btree root */
-	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-		rrec = XFS_RMAP_REC_ADDR(block, 5);
-		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
-		rrec->rm_blockcount = cpu_to_be32(1);
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
-	}
-}
-
-/*
- * Initialise new secondary superblocks with the pre-grow geometry, but mark
- * them as "in progress" so we know they haven't yet been activated. This will
- * get cleared when the update with the new geometry information is done after
- * changes to the primary are committed. This isn't strictly necessary, but we
- * get it for free with the delayed buffer write lists and it means we can tell
- * if a grow operation didn't complete properly after the fact.
- */
-static void
-xfs_sbblock_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_dsb		*dsb = XFS_BUF_TO_SBP(bp);
-
-	xfs_sb_to_disk(dsb, &mp->m_sb);
-	dsb->sb_inprogress = 1;
-}
-
-static void
-xfs_agfblock_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
-	xfs_extlen_t		tmpsize;
-
-	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
-	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
-	agf->agf_seqno = cpu_to_be32(id->agno);
-	agf->agf_length = cpu_to_be32(id->agsize);
-	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
-	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
-	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
-	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
-	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-		agf->agf_roots[XFS_BTNUM_RMAPi] =
-					cpu_to_be32(XFS_RMAP_BLOCK(mp));
-		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
-		agf->agf_rmap_blocks = cpu_to_be32(1);
-	}
-
-	agf->agf_flfirst = cpu_to_be32(1);
-	agf->agf_fllast = 0;
-	agf->agf_flcount = 0;
-	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
-	agf->agf_freeblks = cpu_to_be32(tmpsize);
-	agf->agf_longest = cpu_to_be32(tmpsize);
-	if (xfs_sb_version_hascrc(&mp->m_sb))
-		uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
-	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-		agf->agf_refcount_root = cpu_to_be32(
-				xfs_refc_block(mp));
-		agf->agf_refcount_level = cpu_to_be32(1);
-		agf->agf_refcount_blocks = cpu_to_be32(1);
-	}
-}
-
-static void
-xfs_agflblock_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
-	__be32			*agfl_bno;
-	int			bucket;
-
-	if (xfs_sb_version_hascrc(&mp->m_sb)) {
-		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
-		agfl->agfl_seqno = cpu_to_be32(id->agno);
-		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
-	}
-
-	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
-	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
-		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
-}
-
-static void
-xfs_agiblock_init(
-	struct xfs_mount	*mp,
-	struct xfs_buf		*bp,
-	struct aghdr_init_data	*id)
-{
-	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
-	int			bucket;
-
-	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
-	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
-	agi->agi_seqno = cpu_to_be32(id->agno);
-	agi->agi_length = cpu_to_be32(id->agsize);
-	agi->agi_count = 0;
-	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
-	agi->agi_level = cpu_to_be32(1);
-	agi->agi_freecount = 0;
-	agi->agi_newino = cpu_to_be32(NULLAGINO);
-	agi->agi_dirino = cpu_to_be32(NULLAGINO);
-	if (xfs_sb_version_hascrc(&mp->m_sb))
-		uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
-	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-		agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
-		agi->agi_free_level = cpu_to_be32(1);
-	}
-	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
-		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
-}
-
-typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
-				  struct aghdr_init_data *id);
-static int
-xfs_growfs_init_aghdr(
-	struct xfs_mount	*mp,
-	struct aghdr_init_data	*id,
-	aghdr_init_work_f	work,
-	const struct xfs_buf_ops *ops)
-
-{
-	struct xfs_buf		*bp;
-
-	bp = xfs_growfs_get_hdr_buf(mp, id->daddr, id->numblks, 0, ops);
-	if (!bp)
-		return -ENOMEM;
-
-	(*work)(mp, bp, id);
-
-	xfs_buf_delwri_queue(bp, &id->buffer_list);
-	xfs_buf_relse(bp);
-	return 0;
-}
-
-struct xfs_aghdr_grow_data {
-	xfs_daddr_t		daddr;
-	size_t			numblks;
-	const struct xfs_buf_ops *ops;
-	aghdr_init_work_f	work;
-	xfs_btnum_t		type;
-	bool			need_init;
-};
-
-/*
- * Write new AG headers to disk. Non-transactional, but written
- * synchronously so they are completed prior to the growfs transaction
- * being logged.
+ * growfs operations
  */
-static int
-xfs_grow_ag_headers(
-	struct xfs_mount	*mp,
-	struct aghdr_init_data	*id)
-
-{
-	struct xfs_aghdr_grow_data aghdr_data[] = {
-	{ /* SB */
-		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_SB_DADDR),
-		.numblks = XFS_FSS_TO_BB(mp, 1),
-		.ops = &xfs_sb_buf_ops,
-		.work = &xfs_sbblock_init,
-		.need_init = true
-	},
-	{ /* AGF */
-		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp)),
-		.numblks = XFS_FSS_TO_BB(mp, 1),
-		.ops = &xfs_agf_buf_ops,
-		.work = &xfs_agfblock_init,
-		.need_init = true
-	},
-	{ /* AGFL */
-		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp)),
-		.numblks = XFS_FSS_TO_BB(mp, 1),
-		.ops = &xfs_agfl_buf_ops,
-		.work = &xfs_agflblock_init,
-		.need_init = true
-	},
-	{ /* AGI */
-		.daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp)),
-		.numblks = XFS_FSS_TO_BB(mp, 1),
-		.ops = &xfs_agi_buf_ops,
-		.work = &xfs_agiblock_init,
-		.need_init = true
-	},
-	{ /* BNO root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_allocbt_buf_ops,
-		.work = &xfs_bnoroot_init,
-		.need_init = true
-	},
-	{ /* CNT root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_allocbt_buf_ops,
-		.work = &xfs_cntroot_init,
-		.need_init = true
-	},
-	{ /* INO root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_inobt_buf_ops,
-		.work = &xfs_btroot_init,
-		.type = XFS_BTNUM_INO,
-		.need_init = true
-	},
-	{ /* FINO root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_inobt_buf_ops,
-		.work = &xfs_btroot_init,
-		.type = XFS_BTNUM_FINO,
-		.need_init =  xfs_sb_version_hasfinobt(&mp->m_sb)
-	},
-	{ /* RMAP root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_rmapbt_buf_ops,
-		.work = &xfs_rmaproot_init,
-		.need_init = xfs_sb_version_hasrmapbt(&mp->m_sb)
-	},
-	{ /* REFC root block */
-		.daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp)),
-		.numblks = BTOBB(mp->m_sb.sb_blocksize),
-		.ops = &xfs_refcountbt_buf_ops,
-		.work = &xfs_btroot_init,
-		.type = XFS_BTNUM_REFC,
-		.need_init = xfs_sb_version_hasreflink(&mp->m_sb)
-	},
-	{ /* NULL terminating block */
-		.daddr = XFS_BUF_DADDR_NULL,
-	}
-	};
-	struct  xfs_aghdr_grow_data *dp;
-	int			error = 0;
-
-	/* Account for AG free space in new AG */
-	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
-	for (dp = &aghdr_data[0]; dp->daddr != XFS_BUF_DADDR_NULL; dp++) {
-		if (!dp->need_init)
-			continue;
-
-		id->daddr = dp->daddr;
-		id->numblks = dp->numblks;
-		id->type = dp->type;
-		error = xfs_growfs_init_aghdr(mp, id, dp->work, dp->ops);
-		if (error)
-			break;
-	}
-	return error;
-}
-
 static int
 xfs_growfs_data_private(
 	xfs_mount_t		*mp,		/* mount point for filesystem */
@@ -518,7 +120,7 @@ xfs_growfs_data_private(
 		else
 			id.agsize = mp->m_sb.sb_agblocks;
 
-		error = xfs_grow_ag_headers(mp, &id);
+		error = xfs_ag_init_headers(mp, &id);
 		if (error) {
 			xfs_buf_delwri_cancel(&id.buffer_list);
 			goto out_trans_cancel;
@@ -682,79 +284,6 @@ xfs_growfs_imaxpct(
 	return xfs_trans_commit(tp);
 }
 
-/*
- * After a grow operation, we need to update all the secondary superblocks
- * to match the new state of the primary. Because we are completely overwriting
- * all the existing fields in the secondary superblock buffers, there is no need
- * to read them in from disk. Just get a new buffer, stamp it and write it.
- *
- * The sb buffers need to be cached here so that we serialise against scrub
- * scanning secondary superblocks, but we don't want to keep it in memory once
- * it is written so we mark it as a one-shot buffer.
- */
-static int
-xfs_growfs_update_superblocks(
-	struct xfs_mount	*mp)
-{
-	xfs_agnumber_t		agno;
-	int			saved_error = 0;
-	int			error = 0;
-	LIST_HEAD		(buffer_list);
-
-	/* update secondary superblocks. */
-	for (agno = 1; agno < mp->m_sb.sb_agcount; agno++) {
-		struct xfs_buf		*bp;
-
-		bp = xfs_buf_get(mp->m_ddev_targp,
-				 XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
-				 XFS_FSS_TO_BB(mp, 1), 0);
-		/*
-		 * If we get an error reading or writing alternate superblocks,
-		 * continue.  xfs_repair chooses the "best" superblock based
-		 * on most matches; if we break early, we'll leave more
-		 * superblocks un-updated than updated, and xfs_repair may
-		 * pick them over the properly-updated primary.
-		 */
-		if (!bp) {
-			xfs_warn(mp,
-		"error allocating secondary superblock for ag %d",
-				agno);
-			if (!saved_error)
-				saved_error = -ENOMEM;
-			continue;
-		}
-
-		bp->b_ops = &xfs_sb_buf_ops;
-		xfs_buf_oneshot(bp);
-		xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
-		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
-		xfs_buf_delwri_queue(bp, &buffer_list);
-		xfs_buf_relse(bp);
-
-		/* don't hold too many buffers at once */
-		if (agno % 16)
-			continue;
-
-		error = xfs_buf_delwri_submit(&buffer_list);
-		if (error) {
-			xfs_warn(mp,
-		"write error %d updating a secondary superblock near ag %d",
-				error, agno);
-			if (!saved_error)
-				saved_error = error;
-			continue;
-		}
-	}
-	error = xfs_buf_delwri_submit(&buffer_list);
-	if (error) {
-		xfs_warn(mp,
-		"write error %d updating a secondary superblock near ag %d",
-			error, agno);
-	}
-
-	return saved_error ? saved_error : error;
-}
-
 /*
  * protected versions of growfs function acquire and release locks on the mount
  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
@@ -794,7 +323,7 @@ xfs_growfs_data(
 		mp->m_maxicount = 0;
 
 	/* Update secondary superblocks now the physical grow has completed */
-	error = xfs_growfs_update_superblocks(mp);
+	error = xfs_update_secondary_sbs(mp);
 
 out_error:
 	/*
-- 
2.17.0

[PATCH 10/10] xfs: factor the ag length extension code into libxfs

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Growfs currently manually codes the extension of the last AG in a
filesytem during the growfs process. Factor that out of the growfs
code and move it into libxfs along with teh rest of the AG header
modification code.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/libxfs/xfs_ag.c | 60 ++++++++++++++++++++++++++++++++++++++++++
 fs/xfs/libxfs/xfs_ag.h |  7 ++++-
 fs/xfs/xfs_fsops.c     | 58 ++--------------------------------------
 3 files changed, 68 insertions(+), 57 deletions(-)

diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 5baa22c07095..9345802c99f7 100644
--- a/fs/xfs/libxfs/xfs_ag.c
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -16,6 +16,7 @@
 #include "xfs_alloc_btree.h"
 #include "xfs_rmap_btree.h"
 #include "xfs_alloc.h"
+#include "xfs_ialloc.h"
 #include "xfs_rmap.h"
 #include "xfs_ag.h"
 
@@ -402,3 +403,62 @@ xfs_ag_init_headers(
 	}
 	return error;
 }
+
+/*
+ * Extent the AG indicated by the @id by the length passed in
+ */
+int
+xfs_ag_extend_space(
+	struct xfs_mount	*mp,
+	struct xfs_trans	*tp,
+	struct aghdr_init_data	*id,
+	xfs_extlen_t		len)
+{
+	struct xfs_owner_info	oinfo;
+	struct xfs_buf		*bp;
+	struct xfs_agi		*agi;
+	struct xfs_agf		*agf;
+	int			error;
+
+	/*
+	 * Change the agi length.
+	 */
+	error = xfs_ialloc_read_agi(mp, tp, id->agno, &bp);
+	if (error)
+		return error;
+
+	agi = XFS_BUF_TO_AGI(bp);
+	be32_add_cpu(&agi->agi_length, len);
+	ASSERT(id->agno == mp->m_sb.sb_agcount - 1 ||
+	       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
+	xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
+
+	/*
+	 * Change agf length.
+	 */
+	error = xfs_alloc_read_agf(mp, tp, id->agno, 0, &bp);
+	if (error)
+		return error;
+
+	agf = XFS_BUF_TO_AGF(bp);
+	be32_add_cpu(&agf->agf_length, len);
+	ASSERT(agf->agf_length == agi->agi_length);
+	xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
+
+	/*
+	 * Free the new space.
+	 *
+	 * XFS_RMAP_OWN_NULL is used here to tell the rmap btree that
+	 * this doesn't actually exist in the rmap btree.
+	 */
+	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
+	error = xfs_rmap_free(tp, bp, id->agno,
+				be32_to_cpu(agf->agf_length) - len,
+				len, &oinfo);
+	if (error)
+		return error;
+
+	return  xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, id->agno,
+					be32_to_cpu(agf->agf_length) - len),
+				len, &oinfo, XFS_AG_RESV_NONE);
+}
diff --git a/fs/xfs/libxfs/xfs_ag.h b/fs/xfs/libxfs/xfs_ag.h
index 69f2fd4be0ea..412702e23f61 100644
--- a/fs/xfs/libxfs/xfs_ag.h
+++ b/fs/xfs/libxfs/xfs_ag.h
@@ -7,6 +7,9 @@
 #ifndef __LIBXFS_AG_H
 #define __LIBXFS_AG_H 1
 
+struct xfs_mount;
+struct xfs_trans;
+
 struct aghdr_init_data {
 	/* per ag data */
 	xfs_agblock_t		agno;		/* ag to init */
@@ -20,6 +23,8 @@ struct aghdr_init_data {
 	xfs_btnum_t		type;		/* type of btree root block */
 };
 
-int xfs_ag_init_headers( struct xfs_mount *mp, struct aghdr_init_data *id);
+int xfs_ag_init_headers(struct xfs_mount *mp, struct aghdr_init_data *id);
+int xfs_ag_extend_space(struct xfs_mount *mp, struct xfs_trans *tp,
+			struct aghdr_init_data *id, xfs_extlen_t len);
 
 #endif /* __LIBXFS_AG_H */
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index c5087b79bcea..bc7ef18da243 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -27,16 +27,12 @@
 #include "xfs_trans.h"
 #include "xfs_error.h"
 #include "xfs_btree.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
-#include "xfs_rmap_btree.h"
-#include "xfs_ialloc.h"
 #include "xfs_fsops.h"
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
 #include "xfs_trace.h"
 #include "xfs_log.h"
-#include "xfs_rmap.h"
 #include "xfs_ag.h"
 #include "xfs_ag_resv.h"
 
@@ -48,8 +44,6 @@ xfs_growfs_data_private(
 	xfs_mount_t		*mp,		/* mount point for filesystem */
 	xfs_growfs_data_t	*in)		/* growfs data input struct */
 {
-	xfs_agf_t		*agf;
-	xfs_agi_t		*agi;
 	xfs_buf_t		*bp;
 	int			error;
 	xfs_agnumber_t		nagcount;
@@ -132,57 +126,9 @@ xfs_growfs_data_private(
 
 	xfs_trans_agblocks_delta(tp, id.nfree);
 
-	/*
-	 * There are new blocks in the old last a.g.
-	 */
+	/* If there are new blocks in the old last AG, extend it. */
 	if (new) {
-		struct xfs_owner_info	oinfo;
-
-		/*
-		 * Change the agi length.
-		 */
-		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
-		if (error)
-			goto out_trans_cancel;
-
-		ASSERT(bp);
-		agi = XFS_BUF_TO_AGI(bp);
-		be32_add_cpu(&agi->agi_length, new);
-		ASSERT(nagcount == oagcount ||
-		       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
-		xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
-
-		/*
-		 * Change agf length.
-		 */
-		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
-		if (error)
-			goto out_trans_cancel;
-
-		ASSERT(bp);
-		agf = XFS_BUF_TO_AGF(bp);
-		be32_add_cpu(&agf->agf_length, new);
-		ASSERT(be32_to_cpu(agf->agf_length) ==
-		       be32_to_cpu(agi->agi_length));
-
-		xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
-
-		/*
-		 * Free the new space.
-		 *
-		 * XFS_RMAP_OWN_NULL is used here to tell the rmap btree that
-		 * this doesn't actually exist in the rmap btree.
-		 */
-		xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
-		error = xfs_rmap_free(tp, bp, id.agno,
-				be32_to_cpu(agf->agf_length) - new,
-				new, &oinfo);
-		if (error)
-			goto out_trans_cancel;
-		error = xfs_free_extent(tp,
-				XFS_AGB_TO_FSB(mp, id.agno,
-					be32_to_cpu(agf->agf_length) - new),
-				new, &oinfo, XFS_AG_RESV_NONE);
+		error = xfs_ag_extend_space(mp, tp, &id, new);
 		if (error)
 			goto out_trans_cancel;
 	}
-- 
2.17.0

[PATCH v2] xfs: refactor and tablise growfs

[Dave Chinner]

Hi folks,

This is an update of the patch set I sent a while ago, and
Eric and Darrick have been bugging me to get sorted. The last
posting was here:

https://marc.info/?l=linux-xfs&m=151746732826277&w=2

This update addresses most of the comments that were made at the
time. most importantly, it gets rid of the use of uncached buffers
for secondary superblocks. Instead, I introduced a small helper to
mark a buffer as a "one-shot" buffer, which will cause the buffer to
be reclaimed when all active references go away rather than being
put on the LRU. If teh buffer is already on the LRU, then it
respects that and does not change the buffer behaviour (similar to
XFS_IGET_DONTCACHE for inodes).  THis means the growfs code will
play nicely with scrub and other occasional users of secondary
superblocks, but not add any long term cache footprint.

The other addition since the last posting is moving all the code
that does the AG header setup to libxfs so it canbe shared with
userspace(*). Most of the functions have been moved to new files
fs/xfs/libxfs/xfs_ag.[ch], but the secondary superblock update got
moved to fs/xfs/libxfs/xfs_sb.c, because it's purely about
superblock updates.

The pastchset just passed an overnight QA run on v4 and v5
filesystems w/ both 1k and 4k block sizes.

Comments?

-Dave.

Version 2:
- rebase on current for-next
- add oneshot cached buffer support
- clean up more of the typedef usage.
- move id->nfree calc to per-ag hdr init function from the freespace
  btree root initialisation.
- only use id->type and id->numrecs for the generic btree root block
  init calls.
- only call xfs_growfs_data_private() if the size is actually being
  changed.
- make sure we still update secondary superblocks if physical grow
  fails with ENOSPC.
- change secondary superblock updates to use cached one-shot
  buffers.
- moved the core code to libxfs so it can be shared easily with
  userspace.

(*) e.g. mkfs. More interestingly, this provides a mechanism for a
simple offline grow implementation to be added to xfs_spaceman for
vm/container deployment infrastructures that have to mount an fs
image just to grow it during their setup phase.

[PATCH 04/10] xfs: factor ag btree root block initialisation

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Cookie cutter code, easily factored.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_fsops.c | 485 ++++++++++++++++++++++++---------------------
 1 file changed, 263 insertions(+), 222 deletions(-)

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 4b560caaf397..4dbb7b41aeca 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -71,46 +71,141 @@ xfs_growfs_get_hdr_buf(
 	return bp;
 }
 
+struct aghdr_init_data {
+	/* per ag data */
+	xfs_agblock_t		agno;
+	xfs_extlen_t		agsize;
+	struct list_head	buffer_list;
+	xfs_rfsblock_t		nfree;
+
+	/* per header data */
+	xfs_daddr_t		daddr;
+	size_t			numblks;
+	xfs_btnum_t		type;
+	int			numrecs;
+};
+
 /*
- * Write new AG headers to disk. Non-transactional, but written
- * synchronously so they are completed prior to the growfs transaction
- * being logged.
+ * Generic btree root block init function
  */
-static int
-xfs_grow_ag_headers(
+static void
+xfs_btroot_init(
 	struct xfs_mount	*mp,
-	xfs_agnumber_t		agno,
-	xfs_extlen_t		agsize,
-	xfs_rfsblock_t		*nfree,
-	struct list_head	*buffer_list)
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
 {
-	struct xfs_agf		*agf;
-	struct xfs_agi		*agi;
-	struct xfs_agfl		*agfl;
-	__be32			*agfl_bno;
-	xfs_alloc_rec_t		*arec;
-	struct xfs_buf		*bp;
-	int			bucket;
-	xfs_extlen_t		tmpsize;
-	int			error = 0;
+	xfs_btree_init_block(mp, bp, id->type, 0, id->numrecs, id->agno, 0);
+}
+
+/*
+ * Alloc btree root block init functions
+ */
+static void
+xfs_bnoroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+static void
+xfs_cntroot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_alloc_rec	*arec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
+	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
+	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
+	arec->ar_blockcount = cpu_to_be32(id->agsize -
+					  be32_to_cpu(arec->ar_startblock));
+}
+
+/*
+ * Reverse map root block init
+ */
+static void
+xfs_rmaproot_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
+	struct xfs_rmap_rec	*rrec;
+
+	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
 
 	/*
-	 * AG freespace header block
+	 * mark the AG header regions as static metadata The BNO
+	 * btree block is the first block after the headers, so
+	 * it's location defines the size of region the static
+	 * metadata consumes.
+	 *
+	 * Note: unlike mkfs, we never have to account for log
+	 * space when growing the data regions
 	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agf_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
+	rrec = XFS_RMAP_REC_ADDR(block, 1);
+	rrec->rm_startblock = 0;
+	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+	rrec->rm_offset = 0;
+
+	/* account freespace btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 2);
+	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(2);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account inode btree root blocks */
+	rrec = XFS_RMAP_REC_ADDR(block, 3);
+	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+					  XFS_IBT_BLOCK(mp));
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+	rrec->rm_offset = 0;
+
+	/* account for rmap btree root */
+	rrec = XFS_RMAP_REC_ADDR(block, 4);
+	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+	rrec->rm_blockcount = cpu_to_be32(1);
+	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+	rrec->rm_offset = 0;
+
+	/* account for refc btree root */
+	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+		rrec = XFS_RMAP_REC_ADDR(block, 5);
+		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
+		rrec->rm_blockcount = cpu_to_be32(1);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
 	}
+}
+
+
+static void
+xfs_agfblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
+	xfs_extlen_t		tmpsize;
 
-	agf = XFS_BUF_TO_AGF(bp);
 	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
 	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
-	agf->agf_seqno = cpu_to_be32(agno);
-	agf->agf_length = cpu_to_be32(agsize);
+	agf->agf_seqno = cpu_to_be32(id->agno);
+	agf->agf_length = cpu_to_be32(id->agsize);
 	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
 	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
 	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
@@ -125,7 +220,7 @@ xfs_grow_ag_headers(
 	agf->agf_flfirst = cpu_to_be32(1);
 	agf->agf_fllast = 0;
 	agf->agf_flcount = 0;
-	tmpsize = agsize - mp->m_ag_prealloc_blocks;
+	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
 	agf->agf_freeblks = cpu_to_be32(tmpsize);
 	agf->agf_longest = cpu_to_be32(tmpsize);
 	if (xfs_sb_version_hascrc(&mp->m_sb))
@@ -136,52 +231,42 @@ xfs_grow_ag_headers(
 		agf->agf_refcount_level = cpu_to_be32(1);
 		agf->agf_refcount_blocks = cpu_to_be32(1);
 	}
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
+}
 
-	/*
-	 * AG freelist header block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agfl_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+static void
+xfs_agflblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
+	__be32			*agfl_bno;
+	int			bucket;
 
-	agfl = XFS_BUF_TO_AGFL(bp);
 	if (xfs_sb_version_hascrc(&mp->m_sb)) {
 		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
-		agfl->agfl_seqno = cpu_to_be32(agno);
+		agfl->agfl_seqno = cpu_to_be32(id->agno);
 		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
 	}
 
 	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
 	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
 		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
+}
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
-
-	/*
-	 * AG inode header block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
-			XFS_FSS_TO_BB(mp, 1), 0,
-			&xfs_agi_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+static void
+xfs_agiblock_init(
+	struct xfs_mount	*mp,
+	struct xfs_buf		*bp,
+	struct aghdr_init_data	*id)
+{
+	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
+	int			bucket;
 
-	agi = XFS_BUF_TO_AGI(bp);
 	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
 	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
-	agi->agi_seqno = cpu_to_be32(agno);
-	agi->agi_length = cpu_to_be32(agsize);
+	agi->agi_seqno = cpu_to_be32(id->agno);
+	agi->agi_length = cpu_to_be32(id->agsize);
 	agi->agi_count = 0;
 	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
 	agi->agi_level = cpu_to_be32(1);
@@ -196,180 +281,136 @@ xfs_grow_ag_headers(
 	}
 	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
 		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
+}
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
-
-	/*
-	 * BNO btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_allocbt_buf_ops);
+static int
+xfs_growfs_init_aghdr(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id,
+	void			(*work)(struct xfs_mount *, struct xfs_buf *,
+					struct aghdr_init_data *),
+	const struct xfs_buf_ops *ops)
 
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
+{
+	struct xfs_buf		*bp;
 
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
+	bp = xfs_growfs_get_hdr_buf(mp, id->daddr, id->numblks, 0, ops);
+	if (!bp)
+		return -ENOMEM;
 
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(
-		agsize - be32_to_cpu(arec->ar_startblock));
+	(*work)(mp, bp, id);
 
-	xfs_buf_delwri_queue(bp, buffer_list);
+	xfs_buf_delwri_queue(bp, &id->buffer_list);
 	xfs_buf_relse(bp);
+	return 0;
+}
 
-	/*
-	 * CNT btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_allocbt_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
-		goto out_error;
-	}
-
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
+/*
+ * Write new AG headers to disk. Non-transactional, but written
+ * synchronously so they are completed prior to the growfs transaction
+ * being logged.
+ */
+static int
+xfs_grow_ag_headers(
+	struct xfs_mount	*mp,
+	struct aghdr_init_data	*id)
 
-	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
-	arec->ar_blockcount = cpu_to_be32(
-		agsize - be32_to_cpu(arec->ar_startblock));
-	*nfree += be32_to_cpu(arec->ar_blockcount);
+{
+	int			error = 0;
 
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
+	/* Account for AG free space in new AG */
+	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
 
-	/* RMAP btree root block */
-	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-		struct xfs_rmap_rec	*rrec;
-		struct xfs_btree_block	*block;
-
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_rmapbt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
-			goto out_error;
-		}
+	/* AG freespace header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
+					&xfs_agf_buf_ops);
+	if (error)
+		goto out_error;
 
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
-					agno, 0);
-		block = XFS_BUF_TO_BLOCK(bp);
+	/* AG freelist header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
+					&xfs_agfl_buf_ops);
+	if (error)
+		goto out_error;
 
+	/* AG inode header block */
+	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
+	id->numblks = XFS_FSS_TO_BB(mp, 1);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
+					&xfs_agi_buf_ops);
+	if (error)
+		goto out_error;
 
-		/*
-		 * mark the AG header regions as static metadata The BNO
-		 * btree block is the first block after the headers, so
-		 * it's location defines the size of region the static
-		 * metadata consumes.
-		 *
-		 * Note: unlike mkfs, we never have to account for log
-		 * space when growing the data regions
-		 */
-		rrec = XFS_RMAP_REC_ADDR(block, 1);
-		rrec->rm_startblock = 0;
-		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
 
-		/* account freespace btree root blocks */
-		rrec = XFS_RMAP_REC_ADDR(block, 2);
-		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(2);
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
+	/* BNO btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
+				   &xfs_allocbt_buf_ops);
+	if (error)
+		goto out_error;
 
-		/* account inode btree root blocks */
-		rrec = XFS_RMAP_REC_ADDR(block, 3);
-		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
-						XFS_IBT_BLOCK(mp));
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
 
-		/* account for rmap btree root */
-		rrec = XFS_RMAP_REC_ADDR(block, 4);
-		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
-		rrec->rm_blockcount = cpu_to_be32(1);
-		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-		rrec->rm_offset = 0;
-		be16_add_cpu(&block->bb_numrecs, 1);
+	/* CNT btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
+				   &xfs_allocbt_buf_ops);
+	if (error)
+		goto out_error;
 
-		/* account for refc btree root */
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			rrec = XFS_RMAP_REC_ADDR(block, 5);
-			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
-			rrec->rm_blockcount = cpu_to_be32(1);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-		}
+	/* RMAP btree root block */
+	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
+					   &xfs_rmapbt_buf_ops);
+		if (error)
+			goto out_error;
 
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
-	/*
-	 * INO btree root block
-	 */
-	bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_inobt_buf_ops);
-	if (!bp) {
-		error = -ENOMEM;
+	/* INO btree root block */
+	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
+	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+	id->type = XFS_BTNUM_INO;
+	id->numrecs = 0;
+	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+				   &xfs_inobt_buf_ops);
+	if (error)
 		goto out_error;
-	}
 
-	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
-	xfs_buf_delwri_queue(bp, buffer_list);
-	xfs_buf_relse(bp);
 
 	/*
 	 * FINO btree root block
 	 */
 	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_inobt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		id->type = XFS_BTNUM_FINO;
+		id->numrecs = 0;
+		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+					   &xfs_inobt_buf_ops);
+		if (error)
 			goto out_error;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO, 0, 0, agno, 0);
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
 	/*
 	 * refcount btree root block
 	 */
 	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-		bp = xfs_growfs_get_hdr_buf(mp,
-			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
-			BTOBB(mp->m_sb.sb_blocksize), 0,
-			&xfs_refcountbt_buf_ops);
-		if (!bp) {
-			error = -ENOMEM;
+		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
+		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
+		id->type = XFS_BTNUM_REFC;
+		id->numrecs = 0;
+		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
+					   &xfs_refcountbt_buf_ops);
+		if (error)
 			goto out_error;
-		}
-
-		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC, 0, 0, agno, 0);
-		xfs_buf_delwri_queue(bp, buffer_list);
-		xfs_buf_relse(bp);
 	}
 
 out_error:
@@ -384,7 +425,6 @@ xfs_growfs_data_private(
 	xfs_agf_t		*agf;
 	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
-	xfs_extlen_t		agsize;
 	xfs_buf_t		*bp;
 	int			dpct;
 	int			error, saved_error = 0;
@@ -392,11 +432,11 @@ xfs_growfs_data_private(
 	xfs_agnumber_t		nagimax = 0;
 	xfs_rfsblock_t		nb, nb_mod;
 	xfs_rfsblock_t		new;
-	xfs_rfsblock_t		nfree;
 	xfs_agnumber_t		oagcount;
 	int			pct;
 	xfs_trans_t		*tp;
 	LIST_HEAD		(buffer_list);
+	struct aghdr_init_data	id = {};
 
 	nb = in->newblocks;
 	pct = in->imaxpct;
@@ -448,27 +488,28 @@ xfs_growfs_data_private(
 	 * list to write, we can cancel the entire list without having written
 	 * anything.
 	 */
-	nfree = 0;
-	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
-
-		if (agno == nagcount - 1)
-			agsize = nb -
-				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
+	INIT_LIST_HEAD(&id.buffer_list);
+	for (id.agno = nagcount - 1;
+	     id.agno >= oagcount;
+	     id.agno--, new -= id.agsize) {
+
+		if (id.agno == nagcount - 1)
+			id.agsize = nb -
+				(id.agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
 		else
-			agsize = mp->m_sb.sb_agblocks;
+			id.agsize = mp->m_sb.sb_agblocks;
 
-		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree,
-					    &buffer_list);
+		error = xfs_grow_ag_headers(mp, &id);
 		if (error) {
-			xfs_buf_delwri_cancel(&buffer_list);
+			xfs_buf_delwri_cancel(&id.buffer_list);
 			goto error0;
 		}
 	}
-	error = xfs_buf_delwri_submit(&buffer_list);
+	error = xfs_buf_delwri_submit(&id.buffer_list);
 	if (error)
 		goto error0;
 
-	xfs_trans_agblocks_delta(tp, nfree);
+	xfs_trans_agblocks_delta(tp, id.nfree);
 
 	/*
 	 * There are new blocks in the old last a.g.
@@ -479,7 +520,7 @@ xfs_growfs_data_private(
 		/*
 		 * Change the agi length.
 		 */
-		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
+		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
 		if (error) {
 			goto error0;
 		}
@@ -492,7 +533,7 @@ xfs_growfs_data_private(
 		/*
 		 * Change agf length.
 		 */
-		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
+		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
 		if (error) {
 			goto error0;
 		}
@@ -511,13 +552,13 @@ xfs_growfs_data_private(
 		 * this doesn't actually exist in the rmap btree.
 		 */
 		xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
-		error = xfs_rmap_free(tp, bp, agno,
+		error = xfs_rmap_free(tp, bp, id.agno,
 				be32_to_cpu(agf->agf_length) - new,
 				new, &oinfo);
 		if (error)
 			goto error0;
 		error = xfs_free_extent(tp,
-				XFS_AGB_TO_FSB(mp, agno,
+				XFS_AGB_TO_FSB(mp, id.agno,
 					be32_to_cpu(agf->agf_length) - new),
 				new, &oinfo, XFS_AG_RESV_NONE);
 		if (error)
@@ -534,8 +575,8 @@ xfs_growfs_data_private(
 	if (nb > mp->m_sb.sb_dblocks)
 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
 				 nb - mp->m_sb.sb_dblocks);
-	if (nfree)
-		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
+	if (id.nfree)
+		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
 	if (dpct)
 		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
 	xfs_trans_set_sync(tp);
@@ -562,7 +603,7 @@ xfs_growfs_data_private(
 	if (new) {
 		struct xfs_perag	*pag;
 
-		pag = xfs_perag_get(mp, agno);
+		pag = xfs_perag_get(mp, id.agno);
 		error = xfs_ag_resv_free(pag);
 		xfs_perag_put(pag);
 		if (error)
-- 
2.17.0

Re: [PATCH 04/10] xfs: factor ag btree root block initialisation

[Darrick J. Wong]

On Sat, May 12, 2018 at 08:51:01AM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
> 
> Cookie cutter code, easily factored.
> 
> Signed-Off-By: Dave Chinner <dchinner@redhat.com>
> ---
>  fs/xfs/xfs_fsops.c | 485 ++++++++++++++++++++++++---------------------
>  1 file changed, 263 insertions(+), 222 deletions(-)
> 
> diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> index 4b560caaf397..4dbb7b41aeca 100644
> --- a/fs/xfs/xfs_fsops.c
> +++ b/fs/xfs/xfs_fsops.c
> @@ -71,46 +71,141 @@ xfs_growfs_get_hdr_buf(
>  	return bp;
>  }
>  
> +struct aghdr_init_data {
> +	/* per ag data */
> +	xfs_agblock_t		agno;

xfs_agnumber_t ?

Otherwise more or less looks ok to me.

--D

> +	xfs_extlen_t		agsize;
> +	struct list_head	buffer_list;
> +	xfs_rfsblock_t		nfree;
> +
> +	/* per header data */
> +	xfs_daddr_t		daddr;
> +	size_t			numblks;
> +	xfs_btnum_t		type;
> +	int			numrecs;
> +};
> +
>  /*
> - * Write new AG headers to disk. Non-transactional, but written
> - * synchronously so they are completed prior to the growfs transaction
> - * being logged.
> + * Generic btree root block init function
>   */
> -static int
> -xfs_grow_ag_headers(
> +static void
> +xfs_btroot_init(
>  	struct xfs_mount	*mp,
> -	xfs_agnumber_t		agno,
> -	xfs_extlen_t		agsize,
> -	xfs_rfsblock_t		*nfree,
> -	struct list_head	*buffer_list)
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
>  {
> -	struct xfs_agf		*agf;
> -	struct xfs_agi		*agi;
> -	struct xfs_agfl		*agfl;
> -	__be32			*agfl_bno;
> -	xfs_alloc_rec_t		*arec;
> -	struct xfs_buf		*bp;
> -	int			bucket;
> -	xfs_extlen_t		tmpsize;
> -	int			error = 0;
> +	xfs_btree_init_block(mp, bp, id->type, 0, id->numrecs, id->agno, 0);
> +}
> +
> +/*
> + * Alloc btree root block init functions
> + */
> +static void
> +xfs_bnoroot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_alloc_rec	*arec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, id->agno, 0);
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(id->agsize -
> +					  be32_to_cpu(arec->ar_startblock));
> +}
> +
> +static void
> +xfs_cntroot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_alloc_rec	*arec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, id->agno, 0);
> +	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> +	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> +	arec->ar_blockcount = cpu_to_be32(id->agsize -
> +					  be32_to_cpu(arec->ar_startblock));
> +}
> +
> +/*
> + * Reverse map root block init
> + */
> +static void
> +xfs_rmaproot_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
> +	struct xfs_rmap_rec	*rrec;
> +
> +	xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 4, id->agno, 0);
>  
>  	/*
> -	 * AG freespace header block
> +	 * mark the AG header regions as static metadata The BNO
> +	 * btree block is the first block after the headers, so
> +	 * it's location defines the size of region the static
> +	 * metadata consumes.
> +	 *
> +	 * Note: unlike mkfs, we never have to account for log
> +	 * space when growing the data regions
>  	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agf_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> +	rrec = XFS_RMAP_REC_ADDR(block, 1);
> +	rrec->rm_startblock = 0;
> +	rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> +	rrec->rm_offset = 0;
> +
> +	/* account freespace btree root blocks */
> +	rrec = XFS_RMAP_REC_ADDR(block, 2);
> +	rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(2);
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +	rrec->rm_offset = 0;
> +
> +	/* account inode btree root blocks */
> +	rrec = XFS_RMAP_REC_ADDR(block, 3);
> +	rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> +					  XFS_IBT_BLOCK(mp));
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> +	rrec->rm_offset = 0;
> +
> +	/* account for rmap btree root */
> +	rrec = XFS_RMAP_REC_ADDR(block, 4);
> +	rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> +	rrec->rm_blockcount = cpu_to_be32(1);
> +	rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> +	rrec->rm_offset = 0;
> +
> +	/* account for refc btree root */
> +	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> +		rrec = XFS_RMAP_REC_ADDR(block, 5);
> +		rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
> +		rrec->rm_blockcount = cpu_to_be32(1);
> +		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> +		rrec->rm_offset = 0;
> +		be16_add_cpu(&block->bb_numrecs, 1);
>  	}
> +}
> +
> +
> +static void
> +xfs_agfblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);
> +	xfs_extlen_t		tmpsize;
>  
> -	agf = XFS_BUF_TO_AGF(bp);
>  	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
>  	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
> -	agf->agf_seqno = cpu_to_be32(agno);
> -	agf->agf_length = cpu_to_be32(agsize);
> +	agf->agf_seqno = cpu_to_be32(id->agno);
> +	agf->agf_length = cpu_to_be32(id->agsize);
>  	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
>  	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
>  	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
> @@ -125,7 +220,7 @@ xfs_grow_ag_headers(
>  	agf->agf_flfirst = cpu_to_be32(1);
>  	agf->agf_fllast = 0;
>  	agf->agf_flcount = 0;
> -	tmpsize = agsize - mp->m_ag_prealloc_blocks;
> +	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;
>  	agf->agf_freeblks = cpu_to_be32(tmpsize);
>  	agf->agf_longest = cpu_to_be32(tmpsize);
>  	if (xfs_sb_version_hascrc(&mp->m_sb))
> @@ -136,52 +231,42 @@ xfs_grow_ag_headers(
>  		agf->agf_refcount_level = cpu_to_be32(1);
>  		agf->agf_refcount_blocks = cpu_to_be32(1);
>  	}
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> +}
>  
> -	/*
> -	 * AG freelist header block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agfl_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +static void
> +xfs_agflblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);
> +	__be32			*agfl_bno;
> +	int			bucket;
>  
> -	agfl = XFS_BUF_TO_AGFL(bp);
>  	if (xfs_sb_version_hascrc(&mp->m_sb)) {
>  		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
> -		agfl->agfl_seqno = cpu_to_be32(agno);
> +		agfl->agfl_seqno = cpu_to_be32(id->agno);
>  		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
>  	}
>  
>  	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
>  	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)
>  		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
> +}
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> -
> -	/*
> -	 * AG inode header block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
> -			XFS_FSS_TO_BB(mp, 1), 0,
> -			&xfs_agi_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +static void
> +xfs_agiblock_init(
> +	struct xfs_mount	*mp,
> +	struct xfs_buf		*bp,
> +	struct aghdr_init_data	*id)
> +{
> +	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);
> +	int			bucket;
>  
> -	agi = XFS_BUF_TO_AGI(bp);
>  	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
>  	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
> -	agi->agi_seqno = cpu_to_be32(agno);
> -	agi->agi_length = cpu_to_be32(agsize);
> +	agi->agi_seqno = cpu_to_be32(id->agno);
> +	agi->agi_length = cpu_to_be32(id->agsize);
>  	agi->agi_count = 0;
>  	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
>  	agi->agi_level = cpu_to_be32(1);
> @@ -196,180 +281,136 @@ xfs_grow_ag_headers(
>  	}
>  	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
>  		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> +}
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> -
> -	/*
> -	 * BNO btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_allocbt_buf_ops);
> +static int
> +xfs_growfs_init_aghdr(
> +	struct xfs_mount	*mp,
> +	struct aghdr_init_data	*id,
> +	void			(*work)(struct xfs_mount *, struct xfs_buf *,
> +					struct aghdr_init_data *),
> +	const struct xfs_buf_ops *ops)
>  
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> +{
> +	struct xfs_buf		*bp;
>  
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
> +	bp = xfs_growfs_get_hdr_buf(mp, id->daddr, id->numblks, 0, ops);
> +	if (!bp)
> +		return -ENOMEM;
>  
> -	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -	arec->ar_blockcount = cpu_to_be32(
> -		agsize - be32_to_cpu(arec->ar_startblock));
> +	(*work)(mp, bp, id);
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> +	xfs_buf_delwri_queue(bp, &id->buffer_list);
>  	xfs_buf_relse(bp);
> +	return 0;
> +}
>  
> -	/*
> -	 * CNT btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_allocbt_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> -		goto out_error;
> -	}
> -
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
> +/*
> + * Write new AG headers to disk. Non-transactional, but written
> + * synchronously so they are completed prior to the growfs transaction
> + * being logged.
> + */
> +static int
> +xfs_grow_ag_headers(
> +	struct xfs_mount	*mp,
> +	struct aghdr_init_data	*id)
>  
> -	arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
> -	arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
> -	arec->ar_blockcount = cpu_to_be32(
> -		agsize - be32_to_cpu(arec->ar_startblock));
> -	*nfree += be32_to_cpu(arec->ar_blockcount);
> +{
> +	int			error = 0;
>  
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
> +	/* Account for AG free space in new AG */
> +	id->nfree += id->agsize - mp->m_ag_prealloc_blocks;
>  
> -	/* RMAP btree root block */
> -	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> -		struct xfs_rmap_rec	*rrec;
> -		struct xfs_btree_block	*block;
> -
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_rmapbt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> -			goto out_error;
> -		}
> +	/* AG freespace header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGF_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agfblock_init,
> +					&xfs_agf_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
> -					agno, 0);
> -		block = XFS_BUF_TO_BLOCK(bp);
> +	/* AG freelist header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGFL_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agflblock_init,
> +					&xfs_agfl_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> +	/* AG inode header block */
> +	id->daddr = XFS_AG_DADDR(mp, id->agno, XFS_AGI_DADDR(mp));
> +	id->numblks = XFS_FSS_TO_BB(mp, 1);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_agiblock_init,
> +					&xfs_agi_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/*
> -		 * mark the AG header regions as static metadata The BNO
> -		 * btree block is the first block after the headers, so
> -		 * it's location defines the size of region the static
> -		 * metadata consumes.
> -		 *
> -		 * Note: unlike mkfs, we never have to account for log
> -		 * space when growing the data regions
> -		 */
> -		rrec = XFS_RMAP_REC_ADDR(block, 1);
> -		rrec->rm_startblock = 0;
> -		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
>  
> -		/* account freespace btree root blocks */
> -		rrec = XFS_RMAP_REC_ADDR(block, 2);
> -		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(2);
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
> +	/* BNO btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_BNO_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_bnoroot_init,
> +				   &xfs_allocbt_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/* account inode btree root blocks */
> -		rrec = XFS_RMAP_REC_ADDR(block, 3);
> -		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
> -						XFS_IBT_BLOCK(mp));
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
>  
> -		/* account for rmap btree root */
> -		rrec = XFS_RMAP_REC_ADDR(block, 4);
> -		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
> -		rrec->rm_blockcount = cpu_to_be32(1);
> -		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
> -		rrec->rm_offset = 0;
> -		be16_add_cpu(&block->bb_numrecs, 1);
> +	/* CNT btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_cntroot_init,
> +				   &xfs_allocbt_buf_ops);
> +	if (error)
> +		goto out_error;
>  
> -		/* account for refc btree root */
> -		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -			rrec = XFS_RMAP_REC_ADDR(block, 5);
> -			rrec->rm_startblock = cpu_to_be32(xfs_refc_block(mp));
> -			rrec->rm_blockcount = cpu_to_be32(1);
> -			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
> -			rrec->rm_offset = 0;
> -			be16_add_cpu(&block->bb_numrecs, 1);
> -		}
> +	/* RMAP btree root block */
> +	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_RMAP_BLOCK(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_rmaproot_init,
> +					   &xfs_rmapbt_buf_ops);
> +		if (error)
> +			goto out_error;
>  
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
> -	/*
> -	 * INO btree root block
> -	 */
> -	bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_inobt_buf_ops);
> -	if (!bp) {
> -		error = -ENOMEM;
> +	/* INO btree root block */
> +	id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_IBT_BLOCK(mp));
> +	id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +	id->type = XFS_BTNUM_INO;
> +	id->numrecs = 0;
> +	error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +				   &xfs_inobt_buf_ops);
> +	if (error)
>  		goto out_error;
> -	}
>  
> -	xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
> -	xfs_buf_delwri_queue(bp, buffer_list);
> -	xfs_buf_relse(bp);
>  
>  	/*
>  	 * FINO btree root block
>  	 */
>  	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_inobt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		id->type = XFS_BTNUM_FINO;
> +		id->numrecs = 0;
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +					   &xfs_inobt_buf_ops);
> +		if (error)
>  			goto out_error;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO, 0, 0, agno, 0);
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
>  	/*
>  	 * refcount btree root block
>  	 */
>  	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> -		bp = xfs_growfs_get_hdr_buf(mp,
> -			XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
> -			BTOBB(mp->m_sb.sb_blocksize), 0,
> -			&xfs_refcountbt_buf_ops);
> -		if (!bp) {
> -			error = -ENOMEM;
> +		id->daddr = XFS_AGB_TO_DADDR(mp, id->agno, xfs_refc_block(mp));
> +		id->numblks = BTOBB(mp->m_sb.sb_blocksize);
> +		id->type = XFS_BTNUM_REFC;
> +		id->numrecs = 0;
> +		error = xfs_growfs_init_aghdr(mp, id, xfs_btroot_init,
> +					   &xfs_refcountbt_buf_ops);
> +		if (error)
>  			goto out_error;
> -		}
> -
> -		xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC, 0, 0, agno, 0);
> -		xfs_buf_delwri_queue(bp, buffer_list);
> -		xfs_buf_relse(bp);
>  	}
>  
>  out_error:
> @@ -384,7 +425,6 @@ xfs_growfs_data_private(
>  	xfs_agf_t		*agf;
>  	xfs_agi_t		*agi;
>  	xfs_agnumber_t		agno;
> -	xfs_extlen_t		agsize;
>  	xfs_buf_t		*bp;
>  	int			dpct;
>  	int			error, saved_error = 0;
> @@ -392,11 +432,11 @@ xfs_growfs_data_private(
>  	xfs_agnumber_t		nagimax = 0;
>  	xfs_rfsblock_t		nb, nb_mod;
>  	xfs_rfsblock_t		new;
> -	xfs_rfsblock_t		nfree;
>  	xfs_agnumber_t		oagcount;
>  	int			pct;
>  	xfs_trans_t		*tp;
>  	LIST_HEAD		(buffer_list);
> +	struct aghdr_init_data	id = {};
>  
>  	nb = in->newblocks;
>  	pct = in->imaxpct;
> @@ -448,27 +488,28 @@ xfs_growfs_data_private(
>  	 * list to write, we can cancel the entire list without having written
>  	 * anything.
>  	 */
> -	nfree = 0;
> -	for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
> -
> -		if (agno == nagcount - 1)
> -			agsize = nb -
> -				(agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
> +	INIT_LIST_HEAD(&id.buffer_list);
> +	for (id.agno = nagcount - 1;
> +	     id.agno >= oagcount;
> +	     id.agno--, new -= id.agsize) {
> +
> +		if (id.agno == nagcount - 1)
> +			id.agsize = nb -
> +				(id.agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
>  		else
> -			agsize = mp->m_sb.sb_agblocks;
> +			id.agsize = mp->m_sb.sb_agblocks;
>  
> -		error = xfs_grow_ag_headers(mp, agno, agsize, &nfree,
> -					    &buffer_list);
> +		error = xfs_grow_ag_headers(mp, &id);
>  		if (error) {
> -			xfs_buf_delwri_cancel(&buffer_list);
> +			xfs_buf_delwri_cancel(&id.buffer_list);
>  			goto error0;
>  		}
>  	}
> -	error = xfs_buf_delwri_submit(&buffer_list);
> +	error = xfs_buf_delwri_submit(&id.buffer_list);
>  	if (error)
>  		goto error0;
>  
> -	xfs_trans_agblocks_delta(tp, nfree);
> +	xfs_trans_agblocks_delta(tp, id.nfree);
>  
>  	/*
>  	 * There are new blocks in the old last a.g.
> @@ -479,7 +520,7 @@ xfs_growfs_data_private(
>  		/*
>  		 * Change the agi length.
>  		 */
> -		error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
> +		error = xfs_ialloc_read_agi(mp, tp, id.agno, &bp);
>  		if (error) {
>  			goto error0;
>  		}
> @@ -492,7 +533,7 @@ xfs_growfs_data_private(
>  		/*
>  		 * Change agf length.
>  		 */
> -		error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
> +		error = xfs_alloc_read_agf(mp, tp, id.agno, 0, &bp);
>  		if (error) {
>  			goto error0;
>  		}
> @@ -511,13 +552,13 @@ xfs_growfs_data_private(
>  		 * this doesn't actually exist in the rmap btree.
>  		 */
>  		xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
> -		error = xfs_rmap_free(tp, bp, agno,
> +		error = xfs_rmap_free(tp, bp, id.agno,
>  				be32_to_cpu(agf->agf_length) - new,
>  				new, &oinfo);
>  		if (error)
>  			goto error0;
>  		error = xfs_free_extent(tp,
> -				XFS_AGB_TO_FSB(mp, agno,
> +				XFS_AGB_TO_FSB(mp, id.agno,
>  					be32_to_cpu(agf->agf_length) - new),
>  				new, &oinfo, XFS_AG_RESV_NONE);
>  		if (error)
> @@ -534,8 +575,8 @@ xfs_growfs_data_private(
>  	if (nb > mp->m_sb.sb_dblocks)
>  		xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
>  				 nb - mp->m_sb.sb_dblocks);
> -	if (nfree)
> -		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
> +	if (id.nfree)
> +		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
>  	if (dpct)
>  		xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
>  	xfs_trans_set_sync(tp);
> @@ -562,7 +603,7 @@ xfs_growfs_data_private(
>  	if (new) {
>  		struct xfs_perag	*pag;
>  
> -		pag = xfs_perag_get(mp, agno);
> +		pag = xfs_perag_get(mp, id.agno);
>  		error = xfs_ag_resv_free(pag);
>  		xfs_perag_put(pag);
>  		if (error)
> -- 
> 2.17.0
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 04/10] xfs: factor ag btree root block initialisation

[Dave Chinner]

On Fri, May 11, 2018 at 05:48:35PM -0700, Darrick J. Wong wrote:
> On Sat, May 12, 2018 at 08:51:01AM +1000, Dave Chinner wrote:
> > From: Dave Chinner <dchinner@redhat.com>
> > 
> > Cookie cutter code, easily factored.
> > 
> > Signed-Off-By: Dave Chinner <dchinner@redhat.com>
> > ---
> >  fs/xfs/xfs_fsops.c | 485 ++++++++++++++++++++++++---------------------
> >  1 file changed, 263 insertions(+), 222 deletions(-)
> > 
> > diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> > index 4b560caaf397..4dbb7b41aeca 100644
> > --- a/fs/xfs/xfs_fsops.c
> > +++ b/fs/xfs/xfs_fsops.c
> > @@ -71,46 +71,141 @@ xfs_growfs_get_hdr_buf(
> >  	return bp;
> >  }
> >  
> > +struct aghdr_init_data {
> > +	/* per ag data */
> > +	xfs_agblock_t		agno;
> 
> xfs_agnumber_t ?

Oops, yes.

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com