xfs: store an ops pointer in struct xfs_defer_pending

Source kernel commit: 7f2f7531e0d455f1abb9f48fbbe17c37e8742590

The dfp_type field in struct xfs_defer_pending is only used to either
look up the operations associated with the pending word or in trace
points.  Replace it with a direct pointer to the operations vector,
and store a pretty name in the vector for tracing.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>
Reviewed-by: Bill O'Donnell <bodonnel@redhat.com>

diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index b8afda0ceb583acaf6da8dae2c5b4aeb7f8515a2..014589f82ec8d4b91906e14071286daff00667e7 100644 (file)
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -152,6 +152,7 @@ xfs_extent_free_cancel_item(
 }
 
 const struct xfs_defer_op_type xfs_extent_free_defer_type = {
+       .name           = "extent_free",
        .create_intent  = xfs_extent_free_create_intent,
        .abort_intent   = xfs_extent_free_abort_intent,
        .create_done    = xfs_extent_free_create_done,
@@ -195,6 +196,7 @@ xfs_agfl_free_finish_item(
 
 /* sub-type with special handling for AGFL deferred frees */
 const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
+       .name           = "agfl_free",
        .create_intent  = xfs_extent_free_create_intent,
        .abort_intent   = xfs_extent_free_abort_intent,
        .create_done    = xfs_extent_free_create_done,
@@ -306,6 +308,7 @@ xfs_rmap_update_cancel_item(
 }
 
 const struct xfs_defer_op_type xfs_rmap_update_defer_type = {
+       .name           = "rmap",
        .create_intent  = xfs_rmap_update_create_intent,
        .abort_intent   = xfs_rmap_update_abort_intent,
        .create_done    = xfs_rmap_update_create_done,
@@ -424,6 +427,7 @@ xfs_refcount_update_cancel_item(
 }
 
 const struct xfs_defer_op_type xfs_refcount_update_defer_type = {
+       .name           = "refcount",
        .create_intent  = xfs_refcount_update_create_intent,
        .abort_intent   = xfs_refcount_update_abort_intent,
        .create_done    = xfs_refcount_update_create_done,
@@ -546,6 +550,7 @@ xfs_bmap_update_cancel_item(
 }
 
 const struct xfs_defer_op_type xfs_bmap_update_defer_type = {
+       .name           = "bmap",
        .create_intent  = xfs_bmap_update_create_intent,
        .abort_intent   = xfs_bmap_update_abort_intent,
        .create_done    = xfs_bmap_update_create_done,
@@ -641,6 +646,7 @@ xfs_attr_cancel_item(
 }
 
 const struct xfs_defer_op_type xfs_attr_defer_type = {
+       .name           = "attr",
        .max_items      = 1,
        .create_intent  = xfs_attr_create_intent,
        .abort_intent   = xfs_attr_abort_intent,

diff --git a/libxfs/xfs_defer.c b/libxfs/xfs_defer.c
index 98f1cbe6a67f9702dd27c88b4ea917e975d79148..bb5411b84545434589eb8f13917e54bc6dd5dd31 100644 (file)
--- a/libxfs/xfs_defer.c
+++ b/libxfs/xfs_defer.c
@@ -245,7 +245,6 @@ xfs_defer_create_done(
        struct xfs_trans                *tp,
        struct xfs_defer_pending        *dfp)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
        struct xfs_log_item             *lip;
 
        /* If there is no log intent item, there can be no log done item. */
@@ -260,7 +259,7 @@ xfs_defer_create_done(
         * 2.) shuts down the filesystem
         */
        tp->t_flags |= XFS_TRANS_DIRTY;
-       lip = ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count);
+       lip = dfp->dfp_ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count);
        if (!lip)
                return;
 
@@ -281,13 +280,13 @@ xfs_defer_create_intent(
        struct xfs_defer_pending        *dfp,
        bool                            sort)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
        struct xfs_log_item             *lip;
 
        if (dfp->dfp_intent)
                return 1;
 
-       lip = ops->create_intent(tp, &dfp->dfp_work, dfp->dfp_count, sort);
+       lip = dfp->dfp_ops->create_intent(tp, &dfp->dfp_work, dfp->dfp_count,
+                       sort);
        if (!lip)
                return 0;
        if (IS_ERR(lip))
@@ -332,12 +331,10 @@ xfs_defer_pending_abort(
        struct xfs_mount                *mp,
        struct xfs_defer_pending        *dfp)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
-
        trace_xfs_defer_pending_abort(mp, dfp);
 
        if (dfp->dfp_intent && !dfp->dfp_done) {
-               ops->abort_intent(dfp->dfp_intent);
+               dfp->dfp_ops->abort_intent(dfp->dfp_intent);
                dfp->dfp_intent = NULL;
        }
 }
@@ -347,7 +344,6 @@ xfs_defer_pending_cancel_work(
        struct xfs_mount                *mp,
        struct xfs_defer_pending        *dfp)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
        struct list_head                *pwi;
        struct list_head                *n;
 
@@ -358,7 +354,7 @@ xfs_defer_pending_cancel_work(
                list_del(pwi);
                dfp->dfp_count--;
                trace_xfs_defer_cancel_item(mp, dfp, pwi);
-               ops->cancel_item(pwi);
+               dfp->dfp_ops->cancel_item(pwi);
        }
        ASSERT(dfp->dfp_count == 0);
        kmem_cache_free(xfs_defer_pending_cache, dfp);
@@ -516,11 +512,10 @@ xfs_defer_relog_intent(
        struct xfs_defer_pending        *dfp)
 {
        struct xfs_log_item             *lip;
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
 
        xfs_defer_create_done(tp, dfp);
 
-       lip = ops->relog_intent(tp, dfp->dfp_intent, dfp->dfp_done);
+       lip = dfp->dfp_ops->relog_intent(tp, dfp->dfp_intent, dfp->dfp_done);
        if (lip) {
                xfs_trans_add_item(tp, lip);
                set_bit(XFS_LI_DIRTY, &lip->li_flags);
@@ -587,7 +582,7 @@ xfs_defer_finish_one(
        struct xfs_trans                *tp,
        struct xfs_defer_pending        *dfp)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
+       const struct xfs_defer_op_type  *ops = dfp->dfp_ops;
        struct xfs_btree_cur            *state = NULL;
        struct list_head                *li, *n;
        int                             error;
@@ -784,7 +779,6 @@ xfs_defer_cancel(
 static inline struct xfs_defer_pending *
 xfs_defer_find_last(
        struct xfs_trans                *tp,
-       enum xfs_defer_ops_type         type,
        const struct xfs_defer_op_type  *ops)
 {
        struct xfs_defer_pending        *dfp = NULL;
@@ -797,7 +791,7 @@ xfs_defer_find_last(
                        dfp_list);
 
        /* Wrong type? */
-       if (dfp->dfp_type != type)
+       if (dfp->dfp_ops != ops)
                return NULL;
        return dfp;
 }
@@ -830,13 +824,13 @@ xfs_defer_can_append(
 static inline struct xfs_defer_pending *
 xfs_defer_alloc(
        struct xfs_trans                *tp,
-       enum xfs_defer_ops_type         type)
+       const struct xfs_defer_op_type  *ops)
 {
        struct xfs_defer_pending        *dfp;
 
        dfp = kmem_cache_zalloc(xfs_defer_pending_cache,
                        GFP_NOFS | __GFP_NOFAIL);
-       dfp->dfp_type = type;
+       dfp->dfp_ops = ops;
        INIT_LIST_HEAD(&dfp->dfp_work);
        list_add_tail(&dfp->dfp_list, &tp->t_dfops);
 
@@ -856,9 +850,9 @@ xfs_defer_add(
        ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
        BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX);
 
-       dfp = xfs_defer_find_last(tp, type, ops);
+       dfp = xfs_defer_find_last(tp, ops);
        if (!dfp || !xfs_defer_can_append(dfp, ops))
-               dfp = xfs_defer_alloc(tp, type);
+               dfp = xfs_defer_alloc(tp, ops);
 
        xfs_defer_add_item(dfp, li);
        trace_xfs_defer_add_item(tp->t_mountp, dfp, li);
@@ -874,17 +868,15 @@ xfs_defer_add_barrier(
        struct xfs_trans                *tp)
 {
        struct xfs_defer_pending        *dfp;
-       const enum xfs_defer_ops_type   type = XFS_DEFER_OPS_TYPE_BARRIER;
-       const struct xfs_defer_op_type  *ops = defer_op_types[type];
 
        ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
 
        /* If the last defer op added was a barrier, we're done. */
-       dfp = xfs_defer_find_last(tp, type, ops);
+       dfp = xfs_defer_find_last(tp, &xfs_barrier_defer_type);
        if (dfp)
                return;
 
-       xfs_defer_alloc(tp, type);
+       xfs_defer_alloc(tp, &xfs_barrier_defer_type);
 
        trace_xfs_defer_add_item(tp->t_mountp, dfp, NULL);
 }
@@ -903,7 +895,7 @@ xfs_defer_start_recovery(
 
        dfp = kmem_cache_zalloc(xfs_defer_pending_cache,
                        GFP_NOFS | __GFP_NOFAIL);
-       dfp->dfp_type = dfp_type;
+       dfp->dfp_ops = defer_op_types[dfp_type];
        dfp->dfp_intent = lip;
        INIT_LIST_HEAD(&dfp->dfp_work);
        list_add_tail(&dfp->dfp_list, r_dfops);
@@ -929,13 +921,12 @@ xfs_defer_finish_recovery(
        struct xfs_defer_pending        *dfp,
        struct list_head                *capture_list)
 {
-       const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
        int                             error;
 
-       error = ops->recover_work(dfp, capture_list);
+       error = dfp->dfp_ops->recover_work(dfp, capture_list);
        if (error)
                trace_xlog_intent_recovery_failed(mp, error,
-                               ops->recover_work);
+                               dfp->dfp_ops->recover_work);
        return error;
 }
 

diff --git a/libxfs/xfs_defer.h b/libxfs/xfs_defer.h
index 5b1990ef3e5df48c573f6eb93b392a5cb5957fe2..957a06278e880d94fb620c602f0a250b69552797 100644 (file)
--- a/libxfs/xfs_defer.h
+++ b/libxfs/xfs_defer.h
@@ -34,9 +34,9 @@ struct xfs_defer_pending {
        struct list_head                dfp_work;       /* work items */
        struct xfs_log_item             *dfp_intent;    /* log intent item */
        struct xfs_log_item             *dfp_done;      /* log done item */
+       const struct xfs_defer_op_type  *dfp_ops;
        unsigned int                    dfp_count;      /* # extent items */
        unsigned int                    dfp_flags;
-       enum xfs_defer_ops_type         dfp_type;
 };
 
 /*
@@ -61,6 +61,8 @@ void xfs_defer_move(struct xfs_trans *dtp, struct xfs_trans *stp);
 
 /* Description of a deferred type. */
 struct xfs_defer_op_type {
+       const char              *name;
+       unsigned int            max_items;
        struct xfs_log_item *(*create_intent)(struct xfs_trans *tp,
                        struct list_head *items, unsigned int count, bool sort);
        void (*abort_intent)(struct xfs_log_item *intent);
@@ -76,7 +78,6 @@ struct xfs_defer_op_type {
        struct xfs_log_item *(*relog_intent)(struct xfs_trans *tp,
                        struct xfs_log_item *intent,
                        struct xfs_log_item *done_item);
-       unsigned int            max_items;
 };
 
 extern const struct xfs_defer_op_type xfs_bmap_update_defer_type;