xfs: streamline defer op type handling

There's no need to bundle a pointer to the defer op type into the defer
op control structure.  Instead, store the defer op type enum, which
enables us to shorten some of the lines.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>

1 files changed, 27 insertions, 23 deletions

diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
index 277117a8ad13..94f00427de98 100644
--- a/fs/xfs/libxfs/xfs_defer.c
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -191,15 +191,15 @@ xfs_defer_create_intents(
 {
         struct list_head                *li;
         struct xfs_defer_pending        *dfp;
+        const struct xfs_defer_op_type  *ops;
 
         list_for_each_entry(dfp, &tp->t_dfops, dfp_list) {
-                dfp->dfp_intent = dfp->dfp_type->create_intent(tp,
-                                dfp->dfp_count);
+                ops = defer_op_types[dfp->dfp_type];
+                dfp->dfp_intent = ops->create_intent(tp, dfp->dfp_count);
                 trace_xfs_defer_create_intent(tp->t_mountp, dfp);
-                list_sort(tp->t_mountp, &dfp->dfp_work,
-                                dfp->dfp_type->diff_items);
+                list_sort(tp->t_mountp, &dfp->dfp_work, ops->diff_items);
                 list_for_each(li, &dfp->dfp_work)
-                        dfp->dfp_type->log_item(tp, dfp->dfp_intent, li);
+                        ops->log_item(tp, dfp->dfp_intent, li);
         }
 }
 
@@ -210,14 +210,16 @@ xfs_defer_trans_abort(
         struct list_head                *dop_pending)
 {
         struct xfs_defer_pending        *dfp;
+        const struct xfs_defer_op_type  *ops;
 
         trace_xfs_defer_trans_abort(tp, _RET_IP_);
 
         /* Abort intent items that don't have a done item. */
         list_for_each_entry(dfp, dop_pending, dfp_list) {
+                ops = defer_op_types[dfp->dfp_type];
                 trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
                 if (dfp->dfp_intent && !dfp->dfp_done) {
-                        dfp->dfp_type->abort_intent(dfp->dfp_intent);
+                        ops->abort_intent(dfp->dfp_intent);
                         dfp->dfp_intent = NULL;
                 }
         }
@@ -321,18 +323,20 @@ xfs_defer_cancel_list(
         struct xfs_defer_pending        *pli;
         struct list_head                *pwi;
         struct list_head                *n;
+        const struct xfs_defer_op_type  *ops;
 
         /*
          * Free the pending items.  Caller should already have arranged
          * for the intent items to be released.
          */
         list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) {
+                ops = defer_op_types[dfp->dfp_type];
                 trace_xfs_defer_cancel_list(mp, dfp);
                 list_del(&dfp->dfp_list);
                 list_for_each_safe(pwi, n, &dfp->dfp_work) {
                         list_del(pwi);
                         dfp->dfp_count--;
-                        dfp->dfp_type->cancel_item(pwi);
+                        ops->cancel_item(pwi);
                 }
                 ASSERT(dfp->dfp_count == 0);
                 kmem_free(dfp);
@@ -356,7 +360,7 @@ xfs_defer_finish_noroll(
         struct list_head                *n;
         void                            *state;
         int                             error = 0;
-        void                            (*cleanup_fn)(struct xfs_trans *, void *, int);
+        const struct xfs_defer_op_type  *ops;
         LIST_HEAD(dop_pending);
 
         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
@@ -379,18 +383,18 @@ xfs_defer_finish_noroll(
                 /* Log an intent-done item for the first pending item. */
                 dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,
                                        dfp_list);
+                ops = defer_op_types[dfp->dfp_type];
                 trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp);
-                dfp->dfp_done = dfp->dfp_type->create_done(*tp, dfp->dfp_intent,
+                dfp->dfp_done = ops->create_done(*tp, dfp->dfp_intent,
                                 dfp->dfp_count);
-                cleanup_fn = dfp->dfp_type->finish_cleanup;
 
                 /* Finish the work items. */
                 state = NULL;
                 list_for_each_safe(li, n, &dfp->dfp_work) {
                         list_del(li);
                         dfp->dfp_count--;
-                        error = dfp->dfp_type->finish_item(*tp, li,
-                                        dfp->dfp_done, &state);
+                        error = ops->finish_item(*tp, li, dfp->dfp_done,
+                                        &state);
                         if (error == -EAGAIN) {
                                 /*
                                  * Caller wants a fresh transaction;
@@ -406,8 +410,8 @@ xfs_defer_finish_noroll(
                                  * xfs_defer_cancel will take care of freeing
                                  * all these lists and stuff.
                                  */
-                                if (cleanup_fn)
-                                        cleanup_fn(*tp, state, error);
+                                if (ops->finish_cleanup)
+                                        ops->finish_cleanup(*tp, state, error);
                                 goto out;
                         }
                 }
@@ -419,20 +423,19 @@ xfs_defer_finish_noroll(
                          * a Fresh Transaction while Finishing
                          * Deferred Work" above.
                          */
-                        dfp->dfp_intent = dfp->dfp_type->create_intent(*tp,
+                        dfp->dfp_intent = ops->create_intent(*tp,
                                         dfp->dfp_count);
                         dfp->dfp_done = NULL;
                         list_for_each(li, &dfp->dfp_work)
-                                dfp->dfp_type->log_item(*tp, dfp->dfp_intent,
-                                                li);
+                                ops->log_item(*tp, dfp->dfp_intent, li);
                 } else {
                         /* Done with the dfp, free it. */
                         list_del(&dfp->dfp_list);
                         kmem_free(dfp);
                 }
 
-                if (cleanup_fn)
-                        cleanup_fn(*tp, state, error);
+                if (ops->finish_cleanup)
+                        ops->finish_cleanup(*tp, state, error);
         }
 
 out:
@@ -492,6 +495,7 @@ xfs_defer_add(
         struct list_head                *li)
 {
         struct xfs_defer_pending        *dfp = NULL;
+        const struct xfs_defer_op_type  *ops;
 
         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
         BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX);
@@ -504,15 +508,15 @@ xfs_defer_add(
         if (!list_empty(&tp->t_dfops)) {
                 dfp = list_last_entry(&tp->t_dfops,
                                 struct xfs_defer_pending, dfp_list);
-                if (dfp->dfp_type->type != type ||
-                    (dfp->dfp_type->max_items &&
-                     dfp->dfp_count >= dfp->dfp_type->max_items))
+                ops = defer_op_types[dfp->dfp_type];
+                if (dfp->dfp_type != type ||
+                    (ops->max_items && dfp->dfp_count >= ops->max_items))
                         dfp = NULL;
         }
         if (!dfp) {
                 dfp = kmem_alloc(sizeof(struct xfs_defer_pending),
                                 KM_SLEEP | KM_NOFS);
-                dfp->dfp_type = defer_op_types[type];
+                dfp->dfp_type = type;
                 dfp->dfp_intent = NULL;
                 dfp->dfp_done = NULL;
                 dfp->dfp_count = 0;