xfs: give xfs_refcount_intent its own perag reference

Give the xfs_refcount_intent a passive reference to the perag structure
data.  This reference will be used to enable scrub intent draining
functionality in subsequent patches.  Any space being modified by a
refcount intent is already allocated, so we need to be able to operate
even if the AG is being shrunk or offlined.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index bcf46aa..6dc9686 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -1332,26 +1332,22 @@ xfs_refcount_finish_one(
        xfs_agblock_t                   bno;
        unsigned long                   nr_ops = 0;
        int                             shape_changes = 0;
-       struct xfs_perag                *pag;
 
-       pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, ri->ri_startblock));
        bno = XFS_FSB_TO_AGBNO(mp, ri->ri_startblock);
 
        trace_xfs_refcount_deferred(mp, XFS_FSB_TO_AGNO(mp, ri->ri_startblock),
                        ri->ri_type, XFS_FSB_TO_AGBNO(mp, ri->ri_startblock),
                        ri->ri_blockcount);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE)) {
-               error = -EIO;
-               goto out_drop;
-       }
+       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE))
+               return -EIO;
 
        /*
         * If we haven't gotten a cursor or the cursor AG doesn't match
         * the startblock, get one now.
         */
        rcur = *pcur;
-       if (rcur != NULL && rcur->bc_ag.pag != pag) {
+       if (rcur != NULL && rcur->bc_ag.pag != ri->ri_pag) {
                nr_ops = rcur->bc_ag.refc.nr_ops;
                shape_changes = rcur->bc_ag.refc.shape_changes;
                xfs_refcount_finish_one_cleanup(tp, rcur, 0);
@@ -1359,12 +1355,12 @@ xfs_refcount_finish_one(
                *pcur = NULL;
        }
        if (rcur == NULL) {
-               error = xfs_alloc_read_agf(pag, tp, XFS_ALLOC_FLAG_FREEING,
-                               &agbp);
+               error = xfs_alloc_read_agf(ri->ri_pag, tp,
+                               XFS_ALLOC_FLAG_FREEING, &agbp);
                if (error)
-                       goto out_drop;
+                       return error;
 
-               rcur = xfs_refcountbt_init_cursor(mp, tp, agbp, pag);
+               rcur = xfs_refcountbt_init_cursor(mp, tp, agbp, ri->ri_pag);
                rcur->bc_ag.refc.nr_ops = nr_ops;
                rcur->bc_ag.refc.shape_changes = shape_changes;
        }
@@ -1375,7 +1371,7 @@ xfs_refcount_finish_one(
                error = xfs_refcount_adjust(rcur, &bno, &ri->ri_blockcount,
                                XFS_REFCOUNT_ADJUST_INCREASE);
                if (error)
-                       goto out_drop;
+                       return error;
                if (ri->ri_blockcount > 0)
                        error = xfs_refcount_continue_op(rcur, ri, bno);
                break;
@@ -1383,31 +1379,29 @@ xfs_refcount_finish_one(
                error = xfs_refcount_adjust(rcur, &bno, &ri->ri_blockcount,
                                XFS_REFCOUNT_ADJUST_DECREASE);
                if (error)
-                       goto out_drop;
+                       return error;
                if (ri->ri_blockcount > 0)
                        error = xfs_refcount_continue_op(rcur, ri, bno);
                break;
        case XFS_REFCOUNT_ALLOC_COW:
                error = __xfs_refcount_cow_alloc(rcur, bno, ri->ri_blockcount);
                if (error)
-                       goto out_drop;
+                       return error;
                ri->ri_blockcount = 0;
                break;
        case XFS_REFCOUNT_FREE_COW:
                error = __xfs_refcount_cow_free(rcur, bno, ri->ri_blockcount);
                if (error)
-                       goto out_drop;
+                       return error;
                ri->ri_blockcount = 0;
                break;
        default:
                ASSERT(0);
-               error = -EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        if (!error && ri->ri_blockcount > 0)
-               trace_xfs_refcount_finish_one_leftover(mp, pag->pag_agno,
+               trace_xfs_refcount_finish_one_leftover(mp, ri->ri_pag->pag_agno,
                                ri->ri_type, bno, ri->ri_blockcount);
-out_drop:
-       xfs_perag_put(pag);
        return error;
 }
 
@@ -1435,6 +1429,7 @@ __xfs_refcount_add(
        ri->ri_startblock = startblock;
        ri->ri_blockcount = blockcount;
 
+       xfs_refcount_update_get_group(tp->t_mountp, ri);
        xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_REFCOUNT, &ri->ri_list);
 }
 

diff --git a/fs/xfs/libxfs/xfs_refcount.h b/fs/xfs/libxfs/xfs_refcount.h
index c633477..c89f0fc 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount.h
+++ b/fs/xfs/libxfs/xfs_refcount.h
@@ -50,6 +50,7 @@ enum xfs_refcount_intent_type {
 
 struct xfs_refcount_intent {
        struct list_head                        ri_list;
+       struct xfs_perag                        *ri_pag;
        enum xfs_refcount_intent_type           ri_type;
        xfs_extlen_t                            ri_blockcount;
        xfs_fsblock_t                           ri_startblock;
@@ -67,6 +68,9 @@ xfs_refcount_check_domain(
        return true;
 }
 
+void xfs_refcount_update_get_group(struct xfs_mount *mp,
+               struct xfs_refcount_intent *ri);
+
 void xfs_refcount_increase_extent(struct xfs_trans *tp,
                struct xfs_bmbt_irec *irec);
 void xfs_refcount_decrease_extent(struct xfs_trans *tp,

diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c
index 48d771a..7edee95 100644 (file)
--- a/fs/xfs/xfs_refcount_item.c
+++ b/fs/xfs/xfs_refcount_item.c
@@ -20,6 +20,7 @@
 #include "xfs_error.h"
 #include "xfs_log_priv.h"
 #include "xfs_log_recover.h"
+#include "xfs_ag.h"
 
 struct kmem_cache      *xfs_cui_cache;
 struct kmem_cache      *xfs_cud_cache;
@@ -279,14 +280,13 @@ xfs_refcount_update_diff_items(
        const struct list_head          *a,
        const struct list_head          *b)
 {
-       struct xfs_mount                *mp = priv;
        struct xfs_refcount_intent      *ra;
        struct xfs_refcount_intent      *rb;
 
        ra = container_of(a, struct xfs_refcount_intent, ri_list);
        rb = container_of(b, struct xfs_refcount_intent, ri_list);
-       return  XFS_FSB_TO_AGNO(mp, ra->ri_startblock) -
-               XFS_FSB_TO_AGNO(mp, rb->ri_startblock);
+
+       return ra->ri_pag->pag_agno - rb->ri_pag->pag_agno;
 }
 
 /* Set the phys extent flags for this reverse mapping. */
@@ -365,6 +365,26 @@ xfs_refcount_update_create_done(
        return &xfs_trans_get_cud(tp, CUI_ITEM(intent))->cud_item;
 }
 
+/* Take a passive ref to the AG containing the space we're refcounting. */
+void
+xfs_refcount_update_get_group(
+       struct xfs_mount                *mp,
+       struct xfs_refcount_intent      *ri)
+{
+       xfs_agnumber_t                  agno;
+
+       agno = XFS_FSB_TO_AGNO(mp, ri->ri_startblock);
+       ri->ri_pag = xfs_perag_get(mp, agno);
+}
+
+/* Release a passive AG ref after finishing refcounting work. */
+static inline void
+xfs_refcount_update_put_group(
+       struct xfs_refcount_intent      *ri)
+{
+       xfs_perag_put(ri->ri_pag);
+}
+
 /* Process a deferred refcount update. */
 STATIC int
 xfs_refcount_update_finish_item(
@@ -386,6 +406,8 @@ xfs_refcount_update_finish_item(
                       ri->ri_type == XFS_REFCOUNT_DECREASE);
                return -EAGAIN;
        }
+
+       xfs_refcount_update_put_group(ri);
        kmem_cache_free(xfs_refcount_intent_cache, ri);
        return error;
 }
@@ -406,6 +428,8 @@ xfs_refcount_update_cancel_item(
        struct xfs_refcount_intent      *ri;
 
        ri = container_of(item, struct xfs_refcount_intent, ri_list);
+
+       xfs_refcount_update_put_group(ri);
        kmem_cache_free(xfs_refcount_intent_cache, ri);
 }
 
@@ -520,9 +544,13 @@ xfs_cui_item_recover(
 
                fake.ri_startblock = pmap->pe_startblock;
                fake.ri_blockcount = pmap->pe_len;
-               if (!requeue_only)
+
+               if (!requeue_only) {
+                       xfs_refcount_update_get_group(mp, &fake);
                        error = xfs_trans_log_finish_refcount_update(tp, cudp,
                                        &fake, &rcur);
+                       xfs_refcount_update_put_group(&fake);
+               }
                if (error == -EFSCORRUPTED)
                        XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
                                        &cuip->cui_format,