xfs: add a realtime flag to the refcount update log redo items

Extend the refcount update (CUI) log items with a new realtime flag that
indicates that the updates apply against the realtime refcountbt.  We'll
wire up the actual refcount code later.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index e4559edb35381ecb3b3242091f87a09ae722f2d0..5b129dfbf60d938094a763da6e0454cb9837ee38 100644 (file)
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -442,9 +442,18 @@ xfs_refcount_defer_add(
 
        trace_xfs_refcount_defer(mp, ri);
 
+       /*
+        * Deferred refcount updates for the realtime and data sections must
+        * use separate transactions to finish deferred work because updates to
+        * realtime metadata files can lock AGFs to allocate btree blocks and
+        * we don't want that mixing with the AGF locks taken to finish data
+        * section updates.
+        */
        ri->ri_group = xfs_group_intent_get(mp, ri->ri_startblock,
-                       XG_TYPE_AG);
-       xfs_defer_add(tp, &ri->ri_list, &xfs_refcount_update_defer_type);
+                       ri->ri_realtime ? XG_TYPE_RTG : XG_TYPE_AG);
+       xfs_defer_add(tp, &ri->ri_list, ri->ri_realtime ?
+                       &xfs_rtrefcount_update_defer_type :
+                       &xfs_refcount_update_defer_type);
 }
 
 /* Cancel a deferred refcount update. */
@@ -516,6 +525,27 @@ const struct xfs_defer_op_type xfs_refcount_update_defer_type = {
        .cancel_item    = xfs_refcount_update_cancel_item,
 };
 
+/* Clean up after calling xfs_rtrefcount_finish_one. */
+STATIC void
+xfs_rtrefcount_finish_one_cleanup(
+       struct xfs_trans        *tp,
+       struct xfs_btree_cur    *rcur,
+       int                     error)
+{
+       if (rcur)
+               xfs_btree_del_cursor(rcur, error);
+}
+
+const struct xfs_defer_op_type xfs_rtrefcount_update_defer_type = {
+       .name           = "rtrefcount",
+       .create_intent  = xfs_refcount_update_create_intent,
+       .abort_intent   = xfs_refcount_update_abort_intent,
+       .create_done    = xfs_refcount_update_create_done,
+       .finish_item    = xfs_refcount_update_finish_item,
+       .finish_cleanup = xfs_rtrefcount_finish_one_cleanup,
+       .cancel_item    = xfs_refcount_update_cancel_item,
+};
+
 /* Inode Block Mapping */
 
 static inline struct xfs_bmap_intent *bi_entry(const struct list_head *e)

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index 582952fdeee1a658d68ecafe0d7250946965b41f..a6a889f944a732ffe9a1c1e02b6eeebf26b729e0 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -4614,8 +4614,9 @@ xfs_bmapi_write(
                         * the refcount btree for orphan recovery.
                         */
                        if (whichfork == XFS_COW_FORK)
-                               xfs_refcount_alloc_cow_extent(tp, bma.blkno,
-                                               bma.length);
+                               xfs_refcount_alloc_cow_extent(tp,
+                                               XFS_IS_REALTIME_INODE(ip),
+                                               bma.blkno, bma.length);
                }
 
                /* Deal with the allocated space we found.  */
@@ -4790,7 +4791,8 @@ xfs_bmapi_convert_one_delalloc(
                *seq = READ_ONCE(ifp->if_seq);
 
        if (whichfork == XFS_COW_FORK)
-               xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
+               xfs_refcount_alloc_cow_extent(tp, XFS_IS_REALTIME_INODE(ip),
+                               bma.blkno, bma.length);
 
        error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
                        whichfork);
@@ -5438,7 +5440,7 @@ xfs_bmap_del_extent_real(
                bool    isrt = xfs_ifork_is_realtime(ip, whichfork);
 
                if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
-                       xfs_refcount_decrease_extent(tp, del);
+                       xfs_refcount_decrease_extent(tp, isrt, del);
                } else if (isrt && !xfs_has_rtgroups(mp)) {
                        error = xfs_bmap_free_rtblocks(tp, del);
                } else {

diff --git a/libxfs/xfs_defer.h b/libxfs/xfs_defer.h
index 1e2477eaa5a844e1cc0e7338bb2a7da28a41e6d8..9effd95ddcd4eef152122eac47a78face2798c04 100644 (file)
--- a/libxfs/xfs_defer.h
+++ b/libxfs/xfs_defer.h
@@ -68,6 +68,7 @@ struct xfs_defer_op_type {
 
 extern const struct xfs_defer_op_type xfs_bmap_update_defer_type;
 extern const struct xfs_defer_op_type xfs_refcount_update_defer_type;
+extern const struct xfs_defer_op_type xfs_rtrefcount_update_defer_type;
 extern const struct xfs_defer_op_type xfs_rmap_update_defer_type;
 extern const struct xfs_defer_op_type xfs_rtrmap_update_defer_type;
 extern const struct xfs_defer_op_type xfs_extent_free_defer_type;

diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h
index a7e0e479454d3d5196abaea0094d0d8fc7b1492a..ec7157eaba5f682e264dd8df1db199a86da21c8a 100644 (file)
--- a/libxfs/xfs_log_format.h
+++ b/libxfs/xfs_log_format.h
@@ -252,6 +252,8 @@ typedef struct xfs_trans_header {
 #define        XFS_LI_EFD_RT           0x124b  /* realtime extent free done */
 #define        XFS_LI_RUI_RT           0x124c  /* realtime rmap update intent */
 #define        XFS_LI_RUD_RT           0x124d  /* realtime rmap update done */
+#define        XFS_LI_CUI_RT           0x124e  /* realtime refcount update intent */
+#define        XFS_LI_CUD_RT           0x124f  /* realtime refcount update done */
 
 #define XFS_LI_TYPE_DESC \
        { XFS_LI_EFI,           "XFS_LI_EFI" }, \
@@ -275,7 +277,9 @@ typedef struct xfs_trans_header {
        { XFS_LI_EFI_RT,        "XFS_LI_EFI_RT" }, \
        { XFS_LI_EFD_RT,        "XFS_LI_EFD_RT" }, \
        { XFS_LI_RUI_RT,        "XFS_LI_RUI_RT" }, \
-       { XFS_LI_RUD_RT,        "XFS_LI_RUD_RT" }
+       { XFS_LI_RUD_RT,        "XFS_LI_RUD_RT" }, \
+       { XFS_LI_CUI_RT,        "XFS_LI_CUI_RT" }, \
+       { XFS_LI_CUD_RT,        "XFS_LI_CUD_RT" }
 
 /*
  * Inode Log Item Format definitions.

diff --git a/libxfs/xfs_refcount.c b/libxfs/xfs_refcount.c
index b9eb6f53a1c5424582707f154691194b5fdae049..408000123edfe6a25248bbb307b2911a04c7df82 100644 (file)
--- a/libxfs/xfs_refcount.c
+++ b/libxfs/xfs_refcount.c
@@ -1122,6 +1122,22 @@ xfs_refcount_still_have_space(
                cur->bc_refc.nr_ops * XFS_REFCOUNT_ITEM_OVERHEAD;
 }
 
+/* Schedule an extent free. */
+static int
+xrefc_free_extent(
+       struct xfs_btree_cur            *cur,
+       struct xfs_refcount_irec        *rec)
+{
+       unsigned int                    flags = 0;
+
+       if (xfs_btree_is_rtrefcount(cur->bc_ops))
+               flags |= XFS_FREE_EXTENT_REALTIME;
+
+       return xfs_free_extent_later(cur->bc_tp,
+                       xfs_gbno_to_fsb(cur->bc_group, rec->rc_startblock),
+                       rec->rc_blockcount, NULL, XFS_AG_RESV_NONE, flags);
+}
+
 /*
  * Adjust the refcounts of middle extents.  At this point we should have
  * split extents that crossed the adjustment range; merged with adjacent
@@ -1138,7 +1154,6 @@ xfs_refcount_adjust_extents(
        struct xfs_refcount_irec        ext, tmp;
        int                             error;
        int                             found_rec, found_tmp;
-       xfs_fsblock_t                   fsbno;
 
        /* Merging did all the work already. */
        if (*aglen == 0)
@@ -1191,11 +1206,7 @@ xfs_refcount_adjust_extents(
                                        goto out_error;
                                }
                        } else {
-                               fsbno = xfs_agbno_to_fsb(to_perag(cur->bc_group),
-                                               tmp.rc_startblock);
-                               error = xfs_free_extent_later(cur->bc_tp, fsbno,
-                                                 tmp.rc_blockcount, NULL,
-                                                 XFS_AG_RESV_NONE, 0);
+                               error = xrefc_free_extent(cur, &tmp);
                                if (error)
                                        goto out_error;
                        }
@@ -1253,11 +1264,7 @@ xfs_refcount_adjust_extents(
                        }
                        goto advloop;
                } else {
-                       fsbno = xfs_agbno_to_fsb(to_perag(cur->bc_group),
-                                       ext.rc_startblock);
-                       error = xfs_free_extent_later(cur->bc_tp, fsbno,
-                                       ext.rc_blockcount, NULL,
-                                       XFS_AG_RESV_NONE, 0);
+                       error = xrefc_free_extent(cur, &ext);
                        if (error)
                                goto out_error;
                }
@@ -1453,6 +1460,20 @@ xfs_refcount_finish_one(
        return error;
 }
 
+/*
+ * Process one of the deferred realtime refcount operations.  We pass back the
+ * btree cursor to maintain our lock on the btree between calls.
+ */
+int
+xfs_rtrefcount_finish_one(
+       struct xfs_trans                *tp,
+       struct xfs_refcount_intent      *ri,
+       struct xfs_btree_cur            **pcur)
+{
+       ASSERT(0);
+       return -EFSCORRUPTED;
+}
+
 /*
  * Record a refcount intent for later processing.
  */
@@ -1460,6 +1481,7 @@ static void
 __xfs_refcount_add(
        struct xfs_trans                *tp,
        enum xfs_refcount_intent_type   type,
+       bool                            isrt,
        xfs_fsblock_t                   startblock,
        xfs_extlen_t                    blockcount)
 {
@@ -1471,6 +1493,7 @@ __xfs_refcount_add(
        ri->ri_type = type;
        ri->ri_startblock = startblock;
        ri->ri_blockcount = blockcount;
+       ri->ri_realtime = isrt;
 
        xfs_refcount_defer_add(tp, ri);
 }
@@ -1481,12 +1504,13 @@ __xfs_refcount_add(
 void
 xfs_refcount_increase_extent(
        struct xfs_trans                *tp,
+       bool                            isrt,
        struct xfs_bmbt_irec            *PREV)
 {
        if (!xfs_has_reflink(tp->t_mountp))
                return;
 
-       __xfs_refcount_add(tp, XFS_REFCOUNT_INCREASE, PREV->br_startblock,
+       __xfs_refcount_add(tp, XFS_REFCOUNT_INCREASE, isrt, PREV->br_startblock,
                        PREV->br_blockcount);
 }
 
@@ -1496,12 +1520,13 @@ xfs_refcount_increase_extent(
 void
 xfs_refcount_decrease_extent(
        struct xfs_trans                *tp,
+       bool                            isrt,
        struct xfs_bmbt_irec            *PREV)
 {
        if (!xfs_has_reflink(tp->t_mountp))
                return;
 
-       __xfs_refcount_add(tp, XFS_REFCOUNT_DECREASE, PREV->br_startblock,
+       __xfs_refcount_add(tp, XFS_REFCOUNT_DECREASE, isrt, PREV->br_startblock,
                        PREV->br_blockcount);
 }
 
@@ -1857,6 +1882,7 @@ __xfs_refcount_cow_free(
 void
 xfs_refcount_alloc_cow_extent(
        struct xfs_trans                *tp,
+       bool                            isrt,
        xfs_fsblock_t                   fsb,
        xfs_extlen_t                    len)
 {
@@ -1865,16 +1891,17 @@ xfs_refcount_alloc_cow_extent(
        if (!xfs_has_reflink(mp))
                return;
 
-       __xfs_refcount_add(tp, XFS_REFCOUNT_ALLOC_COW, fsb, len);
+       __xfs_refcount_add(tp, XFS_REFCOUNT_ALLOC_COW, isrt, fsb, len);
 
        /* Add rmap entry */
-       xfs_rmap_alloc_extent(tp, false, fsb, len, XFS_RMAP_OWN_COW);
+       xfs_rmap_alloc_extent(tp, isrt, fsb, len, XFS_RMAP_OWN_COW);
 }
 
 /* Forget a CoW staging event in the refcount btree. */
 void
 xfs_refcount_free_cow_extent(
        struct xfs_trans                *tp,
+       bool                            isrt,
        xfs_fsblock_t                   fsb,
        xfs_extlen_t                    len)
 {
@@ -1884,8 +1911,8 @@ xfs_refcount_free_cow_extent(
                return;
 
        /* Remove rmap entry */
-       xfs_rmap_free_extent(tp, false, fsb, len, XFS_RMAP_OWN_COW);
-       __xfs_refcount_add(tp, XFS_REFCOUNT_FREE_COW, fsb, len);
+       xfs_rmap_free_extent(tp, isrt, fsb, len, XFS_RMAP_OWN_COW);
+       __xfs_refcount_add(tp, XFS_REFCOUNT_FREE_COW, isrt, fsb, len);
 }
 
 struct xfs_refcount_recovery {
@@ -1991,7 +2018,7 @@ xfs_refcount_recover_cow_leftovers(
 
                /* Free the orphan record */
                fsb = xfs_agbno_to_fsb(pag, rr->rr_rrec.rc_startblock);
-               xfs_refcount_free_cow_extent(tp, fsb,
+               xfs_refcount_free_cow_extent(tp, false, fsb,
                                rr->rr_rrec.rc_blockcount);
 
                /* Free the block. */

diff --git a/libxfs/xfs_refcount.h b/libxfs/xfs_refcount.h
index 9cd58d48716f835ac4a177c07a1ffe723e34df9f..be11df25abcc5bbf0435c6cac67345748620e270 100644 (file)
--- a/libxfs/xfs_refcount.h
+++ b/libxfs/xfs_refcount.h
@@ -61,6 +61,7 @@ struct xfs_refcount_intent {
        enum xfs_refcount_intent_type           ri_type;
        xfs_extlen_t                            ri_blockcount;
        xfs_fsblock_t                           ri_startblock;
+       bool                                    ri_realtime;
 };
 
 /* Check that the refcount is appropriate for the record domain. */
@@ -75,22 +76,24 @@ xfs_refcount_check_domain(
        return true;
 }
 
-void xfs_refcount_increase_extent(struct xfs_trans *tp,
+void xfs_refcount_increase_extent(struct xfs_trans *tp, bool isrt,
                struct xfs_bmbt_irec *irec);
-void xfs_refcount_decrease_extent(struct xfs_trans *tp,
+void xfs_refcount_decrease_extent(struct xfs_trans *tp, bool isrt,
                struct xfs_bmbt_irec *irec);
 
-extern int xfs_refcount_finish_one(struct xfs_trans *tp,
+int xfs_refcount_finish_one(struct xfs_trans *tp,
+               struct xfs_refcount_intent *ri, struct xfs_btree_cur **pcur);
+int xfs_rtrefcount_finish_one(struct xfs_trans *tp,
                struct xfs_refcount_intent *ri, struct xfs_btree_cur **pcur);
 
 extern int xfs_refcount_find_shared(struct xfs_btree_cur *cur,
                xfs_agblock_t agbno, xfs_extlen_t aglen, xfs_agblock_t *fbno,
                xfs_extlen_t *flen, bool find_end_of_shared);
 
-void xfs_refcount_alloc_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
-               xfs_extlen_t len);
-void xfs_refcount_free_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
-               xfs_extlen_t len);
+void xfs_refcount_alloc_cow_extent(struct xfs_trans *tp, bool isrt,
+               xfs_fsblock_t fsb, xfs_extlen_t len);
+void xfs_refcount_free_cow_extent(struct xfs_trans *tp, bool isrt,
+               xfs_fsblock_t fsb, xfs_extlen_t len);
 extern int xfs_refcount_recover_cow_leftovers(struct xfs_mount *mp,
                struct xfs_perag *pag);