xfs: finish removing IOP_* macros.

In optimising the CIL operations, some of the IOP_* macros for
calling log item operations were removed. Remove the rest of them as
Christoph requested.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Geoffrey Wehrman <gwehrman@sgi.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

4 files changed, 17 insertions, 20 deletions

diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index b986400ea728..5411e01ab452 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -716,10 +716,10 @@ xfs_trans_free_items(
                 lip->li_desc = NULL;
 
                 if (commit_lsn != NULLCOMMITLSN)
-                        IOP_COMMITTING(lip, commit_lsn);
+                        lip->li_ops->iop_committing(lip, commit_lsn);
                 if (flags & XFS_TRANS_ABORT)
                         lip->li_flags |= XFS_LI_ABORTED;
-                IOP_UNLOCK(lip);
+                lip->li_ops->iop_unlock(lip);
 
                 xfs_trans_free_item_desc(lidp);
         }
@@ -739,8 +739,11 @@ xfs_log_item_batch_insert(
         /* xfs_trans_ail_update_bulk drops ailp->xa_lock */
         xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
 
-        for (i = 0; i < nr_items; i++)
-                IOP_UNPIN(log_items[i], 0);
+        for (i = 0; i < nr_items; i++) {
+                struct xfs_log_item *lip = log_items[i];
+
+                lip->li_ops->iop_unpin(lip, 0);
+        }
 }
 
 /*
@@ -750,11 +753,11 @@ xfs_log_item_batch_insert(
  *
  * If we are called with the aborted flag set, it is because a log write during
  * a CIL checkpoint commit has failed. In this case, all the items in the
- * checkpoint have already gone through IOP_COMMITED and IOP_UNLOCK, which
+ * checkpoint have already gone through iop_commited and iop_unlock, which
  * means that checkpoint commit abort handling is treated exactly the same
  * as an iclog write error even though we haven't started any IO yet. Hence in
- * this case all we need to do is IOP_COMMITTED processing, followed by an
- * IOP_UNPIN(aborted) call.
+ * this case all we need to do is iop_committed processing, followed by an
+ * iop_unpin(aborted) call.
  *
  * The AIL cursor is used to optimise the insert process. If commit_lsn is not
  * at the end of the AIL, the insert cursor avoids the need to walk
@@ -787,7 +790,7 @@ xfs_trans_committed_bulk(
 
                 if (aborted)
                         lip->li_flags |= XFS_LI_ABORTED;
-                item_lsn = IOP_COMMITTED(lip, commit_lsn);
+                item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
 
                 /* item_lsn of -1 means the item needs no further processing */
                 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
@@ -799,7 +802,7 @@ xfs_trans_committed_bulk(
                  */
                 if (aborted) {
                         ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount));
-                        IOP_UNPIN(lip, 1);
+                        lip->li_ops->iop_unpin(lip, 1);
                         continue;
                 }
 
@@ -817,7 +820,7 @@ xfs_trans_committed_bulk(
                                 xfs_trans_ail_update(ailp, lip, item_lsn);
                         else
                                 spin_unlock(&ailp->xa_lock);
-                        IOP_UNPIN(lip, 0);
+                        lip->li_ops->iop_unpin(lip, 0);
                         continue;
                 }
 
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 4786170baeb0..09cf40b89e8c 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -77,14 +77,8 @@ struct xfs_item_ops {
         void (*iop_committing)(xfs_log_item_t *, xfs_lsn_t);
 };
 
-#define IOP_UNPIN(ip, remove)   (*(ip)->li_ops->iop_unpin)(ip, remove)
-#define IOP_PUSH(ip, list)      (*(ip)->li_ops->iop_push)(ip, list)
-#define IOP_UNLOCK(ip)          (*(ip)->li_ops->iop_unlock)(ip)
-#define IOP_COMMITTED(ip, lsn)  (*(ip)->li_ops->iop_committed)(ip, lsn)
-#define IOP_COMMITTING(ip, lsn) (*(ip)->li_ops->iop_committing)(ip, lsn)
-
 /*
- * Return values for the IOP_PUSH() routines.
+ * Return values for the iop_push() routines.
  */
 #define XFS_ITEM_SUCCESS        0
 #define XFS_ITEM_PINNED         1
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 0e7df03e60c5..21c6d7ddbc06 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -379,11 +379,11 @@ xfsaild_push(
                 int     lock_result;
 
                 /*
-                 * Note that IOP_PUSH may unlock and reacquire the AIL lock.  We
+                 * Note that iop_push may unlock and reacquire the AIL lock.  We
                  * rely on the AIL cursor implementation to be able to deal with
                  * the dropped lock.
                  */
-                lock_result = IOP_PUSH(lip, &ailp->xa_buf_list);
+                lock_result = lip->li_ops->iop_push(lip, &ailp->xa_buf_list);
                 switch (lock_result) {
                 case XFS_ITEM_SUCCESS:
                         XFS_STATS_INC(xs_push_ail_success);
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index aa5a04b844d6..8c75b8f67270 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -505,7 +505,7 @@ xfs_trans_brelse(xfs_trans_t	*tp,
 
 /*
  * Mark the buffer as not needing to be unlocked when the buf item's
- * IOP_UNLOCK() routine is called.  The buffer must already be locked
+ * iop_unlock() routine is called.  The buffer must already be locked
  * and associated with the given transaction.
  */
 /* ARGSUSED */