xfs: pass perag to xfs_alloc_read_agf()

Source kernel commit: 08d3e84feeb8cb8e20d54f659446b98fe17913aa

xfs_alloc_read_agf() initialises the perag if it hasn't been done
yet, so it makes sense to pass it the perag rather than pull a
reference from the buffer. This allows callers to be per-ag centric
rather than passing mount/agno pairs everywhere.

Whilst modifying the xfs_reflink_find_shared() function definition,
declare it static and remove the extern declaration as it is an
internal function only these days.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Carlos Maiolino <cem@kernel.org>

diff --git a/db/fsmap.c b/db/fsmap.c
index 8e130f5b7d228ae18ce12b884ae4f488d4fd0879..7fd42df2a1c8547c3cd27582fe24acdcba2c0746 100644 (file)
--- a/db/fsmap.c
+++ b/db/fsmap.c
@@ -67,7 +67,7 @@ fsmap(
                if (pag->pag_agno == end_ag)
                        high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsb);
 
-               error = -libxfs_alloc_read_agf(mp, NULL, pag->pag_agno, 0, &agbp);
+               error = -libxfs_alloc_read_agf(pag, NULL, 0, &agbp);
                if (error) {
                        libxfs_perag_put(pag);
                        dbprintf(_("Error %d while reading AGF.\n"), error);

diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index ce933e34322711bf56e222859d72fee9285890b3..01f0e163ef4ce70403a7fa7aa03fd62b482d807d 100644 (file)
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -23,6 +23,7 @@
 #include "xfs_inode.h"
 #include "xfs_da_btree.h"
 #include "xfs_attr.h"
+#include "libxfs.h"
 
 /* Dummy defer item ops, since we don't do logging. */
 
@@ -135,6 +136,7 @@ xfs_agfl_free_finish_item(
        struct xfs_mount                *mp = tp->t_mountp;
        struct xfs_extent_free_item     *free;
        struct xfs_buf                  *agbp;
+       struct xfs_perag                *pag;
        int                             error;
        xfs_agnumber_t                  agno;
        xfs_agblock_t                   agbno;
@@ -145,9 +147,11 @@ xfs_agfl_free_finish_item(
        agbno = XFS_FSB_TO_AGBNO(mp, free->xefi_startblock);
        oinfo.oi_owner = free->xefi_owner;
 
-       error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
+       pag = libxfs_perag_get(mp, agno);
+       error = xfs_alloc_read_agf(pag, tp, 0, &agbp);
        if (!error)
                error = xfs_free_agfl_block(tp, agno, agbno, agbp, &oinfo);
+       libxfs_perag_put(pag);
        kmem_cache_free(xfs_extfree_item_cache, free);
        return error;
 }

diff --git a/libxfs/xfs_ag.c b/libxfs/xfs_ag.c
index fb6d058307451444b6dfaed48146959dfbcfbc93..9e43820dfe6171266264cc70f87c6dfa199b69cc 100644 (file)
--- a/libxfs/xfs_ag.c
+++ b/libxfs/xfs_ag.c
@@ -118,16 +118,13 @@ xfs_initialize_perag_data(
 
        for (index = 0; index < agcount; index++) {
                /*
-                * read the agf, then the agi. This gets us
-                * all the information we need and populates the
-                * per-ag structures for us.
+                * Read the AGF and AGI buffers to populate the per-ag
+                * structures for us.
                 */
-               error = xfs_alloc_read_agf(mp, NULL, index, 0, NULL);
-               if (error)
-                       return error;
-
                pag = xfs_perag_get(mp, index);
-               error = xfs_ialloc_read_agi(pag, NULL, NULL);
+               error = xfs_alloc_read_agf(pag, NULL, 0, NULL);
+               if (!error)
+                       error = xfs_ialloc_read_agi(pag, NULL, NULL);
                if (error) {
                        xfs_perag_put(pag);
                        return error;
@@ -790,7 +787,7 @@ xfs_ag_shrink_space(
 
        agi = agibp->b_addr;
 
-       error = xfs_alloc_read_agf(mp, *tpp, pag->pag_agno, 0, &agfbp);
+       error = xfs_alloc_read_agf(pag, *tpp, 0, &agfbp);
        if (error)
                return error;
 
@@ -908,7 +905,7 @@ xfs_ag_extend_space(
        /*
         * Change agf length.
         */
-       error = xfs_alloc_read_agf(pag->pag_mount, tp, pag->pag_agno, 0, &bp);
+       error = xfs_alloc_read_agf(pag, tp, 0, &bp);
        if (error)
                return error;
 
@@ -951,8 +948,7 @@ xfs_ag_get_geometry(
        error = xfs_ialloc_read_agi(pag, NULL, &agi_bp);
        if (error)
                return error;
-       error = xfs_alloc_read_agf(pag->pag_mount, NULL, pag->pag_agno, 0,
-                       &agf_bp);
+       error = xfs_alloc_read_agf(pag, NULL, 0, &agf_bp);
        if (error)
                goto out_agi;
 

diff --git a/libxfs/xfs_ag_resv.c b/libxfs/xfs_ag_resv.c
index 95fe8d70d4595d0e3ddfaae3798854a14d428d5c..294d2ae22e90689b2304447700a9ce92c4a5fa45 100644 (file)
--- a/libxfs/xfs_ag_resv.c
+++ b/libxfs/xfs_ag_resv.c
@@ -321,7 +321,7 @@ out:
         * address.
         */
        if (has_resv) {
-               error2 = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0, NULL);
+               error2 = xfs_alloc_read_agf(pag, tp, 0, NULL);
                if (error2)
                        return error2;
 

diff --git a/libxfs/xfs_alloc.c b/libxfs/xfs_alloc.c
index 5b285c2fe4c8657b52eedcf3b9cb0b792b78640c..c73f43793095c713d667dcac01894a0eea449adf 100644 (file)
--- a/libxfs/xfs_alloc.c
+++ b/libxfs/xfs_alloc.c
@@ -2605,7 +2605,7 @@ xfs_alloc_fix_freelist(
        ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
 
        if (!pag->pagf_init) {
-               error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);
+               error = xfs_alloc_read_agf(pag, tp, flags, &agbp);
                if (error) {
                        /* Couldn't lock the AGF so skip this AG. */
                        if (error == -EAGAIN)
@@ -2635,7 +2635,7 @@ xfs_alloc_fix_freelist(
         * Can fail if we're not blocking on locks, and it's held.
         */
        if (!agbp) {
-               error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);
+               error = xfs_alloc_read_agf(pag, tp, flags, &agbp);
                if (error) {
                        /* Couldn't lock the AGF so skip this AG. */
                        if (error == -EAGAIN)
@@ -3076,34 +3076,30 @@ xfs_read_agf(
  * perag structure if necessary. If the caller provides @agfbpp, then return the
  * locked buffer to the caller, otherwise free it.
  */
-int                                    /* error */
+int
 xfs_alloc_read_agf(
-       struct xfs_mount        *mp,    /* mount point structure */
-       struct xfs_trans        *tp,    /* transaction pointer */
-       xfs_agnumber_t          agno,   /* allocation group number */
-       int                     flags,  /* XFS_ALLOC_FLAG_... */
+       struct xfs_perag        *pag,
+       struct xfs_trans        *tp,
+       int                     flags,
        struct xfs_buf          **agfbpp)
 {
        struct xfs_buf          *agfbp;
-       struct xfs_agf          *agf;           /* ag freelist header */
-       struct xfs_perag        *pag;           /* per allocation group data */
+       struct xfs_agf          *agf;
        int                     error;
        int                     allocbt_blks;
 
-       trace_xfs_alloc_read_agf(mp, agno);
+       trace_xfs_alloc_read_agf(pag->pag_mount, pag->pag_agno);
 
        /* We don't support trylock when freeing. */
        ASSERT((flags & (XFS_ALLOC_FLAG_FREEING | XFS_ALLOC_FLAG_TRYLOCK)) !=
                        (XFS_ALLOC_FLAG_FREEING | XFS_ALLOC_FLAG_TRYLOCK));
-       ASSERT(agno != NULLAGNUMBER);
-       error = xfs_read_agf(mp, tp, agno,
+       error = xfs_read_agf(pag->pag_mount, tp, pag->pag_agno,
                        (flags & XFS_ALLOC_FLAG_TRYLOCK) ? XBF_TRYLOCK : 0,
                        &agfbp);
        if (error)
                return error;
 
        agf = agfbp->b_addr;
-       pag = agfbp->b_pag;
        if (!pag->pagf_init) {
                pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
                pag->pagf_btreeblks = be32_to_cpu(agf->agf_btreeblks);
@@ -3117,7 +3113,7 @@ xfs_alloc_read_agf(
                        be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAPi]);
                pag->pagf_refcount_level = be32_to_cpu(agf->agf_refcount_level);
                pag->pagf_init = 1;
-               pag->pagf_agflreset = xfs_agfl_needs_reset(mp, agf);
+               pag->pagf_agflreset = xfs_agfl_needs_reset(pag->pag_mount, agf);
 
                /*
                 * Update the in-core allocbt counter. Filter out the rmapbt
@@ -3127,13 +3123,14 @@ xfs_alloc_read_agf(
                 * counter only tracks non-root blocks.
                 */
                allocbt_blks = pag->pagf_btreeblks;
-               if (xfs_has_rmapbt(mp))
+               if (xfs_has_rmapbt(pag->pag_mount))
                        allocbt_blks -= be32_to_cpu(agf->agf_rmap_blocks) - 1;
                if (allocbt_blks > 0)
-                       atomic64_add(allocbt_blks, &mp->m_allocbt_blks);
+                       atomic64_add(allocbt_blks,
+                                       &pag->pag_mount->m_allocbt_blks);
        }
 #ifdef DEBUG
-       else if (!xfs_is_shutdown(mp)) {
+       else if (!xfs_is_shutdown(pag->pag_mount)) {
                ASSERT(pag->pagf_freeblks == be32_to_cpu(agf->agf_freeblks));
                ASSERT(pag->pagf_btreeblks == be32_to_cpu(agf->agf_btreeblks));
                ASSERT(pag->pagf_flcount == be32_to_cpu(agf->agf_flcount));

diff --git a/libxfs/xfs_alloc.h b/libxfs/xfs_alloc.h
index 96d5301a5c8becb6090f15e1cfe9fb3a4c56eb96..b8cf5beb26d498c62e270ca14814a110bc7771c7 100644 (file)
--- a/libxfs/xfs_alloc.h
+++ b/libxfs/xfs_alloc.h
@@ -134,17 +134,6 @@ xfs_alloc_put_freelist(
        xfs_agblock_t   bno,    /* block being freed */
        int             btreeblk); /* owner was a AGF btree */
 
-/*
- * Read in the allocation group header (free/alloc section).
- */
-int                                    /* error  */
-xfs_alloc_read_agf(
-       struct xfs_mount *mp,           /* mount point structure */
-       struct xfs_trans *tp,           /* transaction pointer */
-       xfs_agnumber_t  agno,           /* allocation group number */
-       int             flags,          /* XFS_ALLOC_FLAG_... */
-       struct xfs_buf  **bpp);         /* buffer for the ag freelist header */
-
 /*
  * Allocate an extent (variable-size).
  */
@@ -198,6 +187,8 @@ xfs_alloc_get_rec(
 
 int xfs_read_agf(struct xfs_mount *mp, struct xfs_trans *tp,
                        xfs_agnumber_t agno, int flags, struct xfs_buf **bpp);
+int xfs_alloc_read_agf(struct xfs_perag *pag, struct xfs_trans *tp, int flags,
+               struct xfs_buf **agfbpp);
 int xfs_alloc_read_agfl(struct xfs_mount *mp, struct xfs_trans *tp,
                        xfs_agnumber_t agno, struct xfs_buf **bpp);
 int xfs_free_agfl_block(struct xfs_trans *, xfs_agnumber_t, xfs_agblock_t,

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index 743590cbf5367999b342675bb37b8cff6aef26fe..3093ab1bb6b4521202200c3e74f590652485ed72 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -3178,7 +3178,7 @@ xfs_bmap_longest_free_extent(
 
        pag = xfs_perag_get(mp, ag);
        if (!pag->pagf_init) {
-               error = xfs_alloc_read_agf(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK,
+               error = xfs_alloc_read_agf(pag, tp, XFS_ALLOC_FLAG_TRYLOCK,
                                NULL);
                if (error) {
                        /* Couldn't lock the AGF, so skip this AG. */

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index 40d2e03bf9d82fef0dbadfc7ea8550c6651d0cb6..f3087cb96f1f12bbde8572bb73a021bbbfad1edb 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -1616,7 +1616,7 @@ xfs_dialloc_good_ag(
                return false;
 
        if (!pag->pagf_init) {
-               error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, flags, NULL);
+               error = xfs_alloc_read_agf(pag, tp, flags, NULL);
                if (error)
                        return false;
        }

diff --git a/libxfs/xfs_refcount.c b/libxfs/xfs_refcount.c
index e5606916a2ac2dd49dd52de9b25c4a8d87155940..f287cdea59c91641fe954d36341e86508e3153b2 100644 (file)
--- a/libxfs/xfs_refcount.c
+++ b/libxfs/xfs_refcount.c
@@ -1176,8 +1176,8 @@ xfs_refcount_finish_one(
                *pcur = NULL;
        }
        if (rcur == NULL) {
-               error = xfs_alloc_read_agf(tp->t_mountp, tp, pag->pag_agno,
-                               XFS_ALLOC_FLAG_FREEING, &agbp);
+               error = xfs_alloc_read_agf(pag, tp, XFS_ALLOC_FLAG_FREEING,
+                               &agbp);
                if (error)
                        goto out_drop;
 
@@ -1709,7 +1709,7 @@ xfs_refcount_recover_cow_leftovers(
        if (error)
                return error;
 
-       error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0, &agbp);
+       error = xfs_alloc_read_agf(pag, tp, 0, &agbp);
        if (error)
                goto out_trans;
        cur = xfs_refcountbt_init_cursor(mp, tp, agbp, pag);

diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c
index 19ead6a2d03a9734a841add8c5fb5ef198210e19..d57445f68cd3e86c22e7925103ee8233ec0aa1a7 100644 (file)
--- a/libxfs/xfs_refcount_btree.c
+++ b/libxfs/xfs_refcount_btree.c
@@ -492,7 +492,7 @@ xfs_refcountbt_calc_reserves(
        if (!xfs_has_reflink(mp))
                return 0;
 
-       error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0, &agbp);
+       error = xfs_alloc_read_agf(pag, tp, 0, &agbp);
        if (error)
                return error;
 

diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
index f0fe78d3623e93b3541884e34f53b2ccfb6a8656..0fc58632a9bfa8a71a3fabd972f350fbd79b6cdb 100644 (file)
--- a/libxfs/xfs_rmap_btree.c
+++ b/libxfs/xfs_rmap_btree.c
@@ -650,7 +650,7 @@ xfs_rmapbt_calc_reserves(
        if (!xfs_has_rmapbt(mp))
                return 0;
 
-       error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0, &agbp);
+       error = xfs_alloc_read_agf(pag, tp, 0, &agbp);
        if (error)
                return error;
 

diff --git a/repair/rmap.c b/repair/rmap.c
index 51691fcceaae040a97963d532bf5f00e0066914c..a7c4b25b1f44e87ea497f935aeca46299c3c55b9 100644 (file)
--- a/repair/rmap.c
+++ b/repair/rmap.c
@@ -551,13 +551,15 @@ rmap_store_ag_btree_rec(
                if (error)
                        goto err_slab;
 
-               error = -libxfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
-               if (error)
+               pag = libxfs_perag_get(mp, agno);
+               error = -libxfs_alloc_read_agf(pag, tp, 0, &agbp);
+               if (error) {
+                       libxfs_perag_put(pag);
                        goto err_trans;
+               }
 
                ASSERT(XFS_RMAP_NON_INODE_OWNER(rm_rec->rm_owner));
                oinfo.oi_owner = rm_rec->rm_owner;
-               pag = libxfs_perag_get(mp, agno);
                error = -libxfs_rmap_alloc(tp, agbp, pag, rm_rec->rm_startblock,
                                rm_rec->rm_blockcount, &oinfo);
                libxfs_perag_put(pag);
@@ -995,7 +997,8 @@ rmaps_verify_btree(
                return;
        }
 
-       error = -libxfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
+       pag = libxfs_perag_get(mp, agno);
+       error = -libxfs_alloc_read_agf(pag, NULL, 0, &agbp);
        if (error) {
                do_warn(_("Could not read AGF %u to check rmap btree.\n"),
                                agno);
@@ -1003,7 +1006,6 @@ rmaps_verify_btree(
        }
 
        /* Leave the per-ag data "uninitialized" since we rewrite it later */
-       pag = libxfs_perag_get(mp, agno);
        pag->pagf_init = 0;
 
        bt_cur = libxfs_rmapbt_init_cursor(mp, NULL, agbp, pag);
@@ -1370,7 +1372,8 @@ check_refcounts(
                return;
        }
 
-       error = -libxfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
+       pag = libxfs_perag_get(mp, agno);
+       error = -libxfs_alloc_read_agf(pag, NULL, 0, &agbp);
        if (error) {
                do_warn(_("Could not read AGF %u to check refcount btree.\n"),
                                agno);
@@ -1378,7 +1381,6 @@ check_refcounts(
        }
 
        /* Leave the per-ag data "uninitialized" since we rewrite it later */
-       pag = libxfs_perag_get(mp, agno);
        pag->pagf_init = 0;
 
        bt_cur = libxfs_refcountbt_init_cursor(mp, NULL, agbp, pag);