Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=287f3dad14828275d2517c8696ad118c82b9243f
Commit:     287f3dad14828275d2517c8696ad118c82b9243f
Parent:     541d7d3c4b31e2b0ac846fe6d2eb5cdbe1353095
Author:     Donald Douwsma <[EMAIL PROTECTED]>
AuthorDate: Thu Oct 11 17:36:05 2007 +1000
Committer:  Lachlan McIlroy <[EMAIL PROTECTED]>
CommitDate: Thu Feb 7 16:44:23 2008 +1100

    [XFS] Unwrap AIL_LOCK
    
    SGI-PV: 970382
    SGI-Modid: xfs-linux-melb:xfs-kern:29739a
    
    Signed-off-by: Donald Douwsma <[EMAIL PROTECTED]>
    Signed-off-by: Eric Sandeen <[EMAIL PROTECTED]>
    Signed-off-by: Tim Shimmin <[EMAIL PROTECTED]>
---
 fs/xfs/quota/xfs_dquot.c      |   12 ++++-----
 fs/xfs/quota/xfs_dquot_item.c |   11 ++++----
 fs/xfs/xfs_buf_item.c         |   10 +++----
 fs/xfs/xfs_extfree_item.c     |   21 +++++++---------
 fs/xfs/xfs_inode.c            |   22 +++++++----------
 fs/xfs/xfs_inode_item.c       |   21 +++++++---------
 fs/xfs/xfs_log_recover.c      |   21 +++++++---------
 fs/xfs/xfs_mount.c            |    4 +-
 fs/xfs/xfs_mount.h            |    9 +------
 fs/xfs/xfs_trans.c            |    7 ++---
 fs/xfs/xfs_trans_ail.c        |   52 ++++++++++++++++++----------------------
 fs/xfs/xfs_trans_priv.h       |    5 +--
 12 files changed, 81 insertions(+), 114 deletions(-)

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index cfdd35e..665babc 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -1209,7 +1209,6 @@ xfs_qm_dqflush(
        xfs_buf_t               *bp;
        xfs_disk_dquot_t        *ddqp;
        int                     error;
-       SPLDECL(s);
 
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
        ASSERT(XFS_DQ_IS_FLUSH_LOCKED(dqp));
@@ -1270,9 +1269,9 @@ xfs_qm_dqflush(
        mp = dqp->q_mount;
 
        /* lsn is 64 bits */
-       AIL_LOCK(mp, s);
+       spin_lock(&mp->m_ail_lock);
        dqp->q_logitem.qli_flush_lsn = dqp->q_logitem.qli_item.li_lsn;
-       AIL_UNLOCK(mp, s);
+       spin_unlock(&mp->m_ail_lock);
 
        /*
         * Attach an iodone routine so that we can remove this dquot from the
@@ -1318,7 +1317,6 @@ xfs_qm_dqflush_done(
        xfs_dq_logitem_t        *qip)
 {
        xfs_dquot_t             *dqp;
-       SPLDECL(s);
 
        dqp = qip->qli_dquot;
 
@@ -1333,15 +1331,15 @@ xfs_qm_dqflush_done(
        if ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
            qip->qli_item.li_lsn == qip->qli_flush_lsn) {
 
-               AIL_LOCK(dqp->q_mount, s);
+               spin_lock(&dqp->q_mount->m_ail_lock);
                /*
                 * xfs_trans_delete_ail() drops the AIL lock.
                 */
                if (qip->qli_item.li_lsn == qip->qli_flush_lsn)
                        xfs_trans_delete_ail(dqp->q_mount,
-                                            (xfs_log_item_t*)qip, s);
+                                            (xfs_log_item_t*)qip);
                else
-                       AIL_UNLOCK(dqp->q_mount, s);
+                       spin_unlock(&dqp->q_mount->m_ail_lock);
        }
 
        /*
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index ddb61fe..a00b71b 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -216,8 +216,8 @@ xfs_qm_dqunpin_wait(
  * If so, we want to push it out to help us take this item off the AIL as soon
  * as possible.
  *
- * We must not be holding the AIL_LOCK at this point. Calling incore() to
- * search the buffer cache can be a time consuming thing, and AIL_LOCK is a
+ * We must not be holding the AIL lock at this point. Calling incore() to
+ * search the buffer cache can be a time consuming thing, and AIL lock is a
  * spinlock.
  */
 STATIC void
@@ -322,7 +322,7 @@ xfs_qm_dquot_logitem_trylock(
                 * want to do that now since we might sleep in the device
                 * strategy routine.  We also don't want to grab the buffer lock
                 * here because we'd like not to call into the buffer cache
-                * while holding the AIL_LOCK.
+                * while holding the AIL lock.
                 * Make sure to only return PUSHBUF if we set pushbuf_flag
                 * ourselves.  If someone else is doing it then we don't
                 * want to go to the push routine and duplicate their efforts.
@@ -562,15 +562,14 @@ xfs_qm_qoffend_logitem_committed(
        xfs_lsn_t lsn)
 {
        xfs_qoff_logitem_t      *qfs;
-       SPLDECL(s);
 
        qfs = qfe->qql_start_lip;
-       AIL_LOCK(qfs->qql_item.li_mountp,s);
+       spin_lock(&qfs->qql_item.li_mountp->m_ail_lock);
        /*
         * Delete the qoff-start logitem from the AIL.
         * xfs_trans_delete_ail() drops the AIL lock.
         */
-       xfs_trans_delete_ail(qfs->qql_item.li_mountp, (xfs_log_item_t *)qfs, s);
+       xfs_trans_delete_ail(qfs->qql_item.li_mountp, (xfs_log_item_t *)qfs);
        kmem_free(qfs, sizeof(xfs_qoff_logitem_t));
        kmem_free(qfe, sizeof(xfs_qoff_logitem_t));
        return (xfs_lsn_t)-1;
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index c8f2c28..63debd1 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -378,7 +378,6 @@ xfs_buf_item_unpin(
        xfs_mount_t     *mp;
        xfs_buf_t       *bp;
        int             freed;
-       SPLDECL(s);
 
        bp = bip->bli_buf;
        ASSERT(bp != NULL);
@@ -409,8 +408,8 @@ xfs_buf_item_unpin(
                        XFS_BUF_SET_FSPRIVATE(bp, NULL);
                        XFS_BUF_CLR_IODONE_FUNC(bp);
                } else {
-                       AIL_LOCK(mp,s);
-                       xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip, s);
+                       spin_lock(&mp->m_ail_lock);
+                       xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip);
                        xfs_buf_item_relse(bp);
                        ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL);
                }
@@ -1113,7 +1112,6 @@ xfs_buf_iodone(
        xfs_buf_log_item_t      *bip)
 {
        struct xfs_mount        *mp;
-       SPLDECL(s);
 
        ASSERT(bip->bli_buf == bp);
 
@@ -1128,11 +1126,11 @@ xfs_buf_iodone(
         *
         * Either way, AIL is useless if we're forcing a shutdown.
         */
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
        /*
         * xfs_trans_delete_ail() drops the AIL lock.
         */
-       xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip, s);
+       xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip);
 
 #ifdef XFS_TRANS_DEBUG
        kmem_free(bip->bli_orig, XFS_BUF_COUNT(bp));
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index f938a51..132bd07 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -110,19 +110,18 @@ STATIC void
 xfs_efi_item_unpin(xfs_efi_log_item_t *efip, int stale)
 {
        xfs_mount_t     *mp;
-       SPLDECL(s);
 
        mp = efip->efi_item.li_mountp;
-       AIL_LOCK(mp, s);
+       spin_lock(&mp->m_ail_lock);
        if (efip->efi_flags & XFS_EFI_CANCELED) {
                /*
                 * xfs_trans_delete_ail() drops the AIL lock.
                 */
-               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
+               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
                xfs_efi_item_free(efip);
        } else {
                efip->efi_flags |= XFS_EFI_COMMITTED;
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
        }
 }
 
@@ -138,10 +137,9 @@ xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, 
xfs_trans_t *tp)
 {
        xfs_mount_t     *mp;
        xfs_log_item_desc_t     *lidp;
-       SPLDECL(s);
 
        mp = efip->efi_item.li_mountp;
-       AIL_LOCK(mp, s);
+       spin_lock(&mp->m_ail_lock);
        if (efip->efi_flags & XFS_EFI_CANCELED) {
                /*
                 * free the xaction descriptor pointing to this item
@@ -152,11 +150,11 @@ xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, 
xfs_trans_t *tp)
                 * pull the item off the AIL.
                 * xfs_trans_delete_ail() drops the AIL lock.
                 */
-               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
+               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
                xfs_efi_item_free(efip);
        } else {
                efip->efi_flags |= XFS_EFI_COMMITTED;
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
        }
 }
 
@@ -350,13 +348,12 @@ xfs_efi_release(xfs_efi_log_item_t        *efip,
 {
        xfs_mount_t     *mp;
        int             extents_left;
-       SPLDECL(s);
 
        mp = efip->efi_item.li_mountp;
        ASSERT(efip->efi_next_extent > 0);
        ASSERT(efip->efi_flags & XFS_EFI_COMMITTED);
 
-       AIL_LOCK(mp, s);
+       spin_lock(&mp->m_ail_lock);
        ASSERT(efip->efi_next_extent >= nextents);
        efip->efi_next_extent -= nextents;
        extents_left = efip->efi_next_extent;
@@ -364,10 +361,10 @@ xfs_efi_release(xfs_efi_log_item_t        *efip,
                /*
                 * xfs_trans_delete_ail() drops the AIL lock.
                 */
-               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
+               xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
                xfs_efi_item_free(efip);
        } else {
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
        }
 }
 
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index a6d35ae..e793068 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2205,7 +2205,6 @@ xfs_ifree_cluster(
        xfs_inode_log_item_t    *iip;
        xfs_log_item_t          *lip;
        xfs_perag_t             *pag = xfs_get_perag(mp, inum);
-       SPLDECL(s);
 
        if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
                blks_per_cluster = 1;
@@ -2307,9 +2306,9 @@ xfs_ifree_cluster(
                                iip = (xfs_inode_log_item_t *)lip;
                                ASSERT(iip->ili_logged == 1);
                                lip->li_cb = 
(void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done;
-                               AIL_LOCK(mp,s);
+                               spin_lock(&mp->m_ail_lock);
                                iip->ili_flush_lsn = iip->ili_item.li_lsn;
-                               AIL_UNLOCK(mp, s);
+                               spin_unlock(&mp->m_ail_lock);
                                xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
                                pre_flushed++;
                        }
@@ -2330,9 +2329,9 @@ xfs_ifree_cluster(
                        iip->ili_last_fields = iip->ili_format.ilf_fields;
                        iip->ili_format.ilf_fields = 0;
                        iip->ili_logged = 1;
-                       AIL_LOCK(mp,s);
+                       spin_lock(&mp->m_ail_lock);
                        iip->ili_flush_lsn = iip->ili_item.li_lsn;
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
 
                        xfs_buf_attach_iodone(bp,
                                (void(*)(xfs_buf_t*,xfs_log_item_t*))
@@ -2731,7 +2730,6 @@ void
 xfs_idestroy(
        xfs_inode_t     *ip)
 {
-
        switch (ip->i_d.di_mode & S_IFMT) {
        case S_IFREG:
        case S_IFDIR:
@@ -2771,16 +2769,15 @@ xfs_idestroy(
                 */
                xfs_mount_t     *mp = ip->i_mount;
                xfs_log_item_t  *lip = &ip->i_itemp->ili_item;
-               int             s;
 
                ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) ||
                                       XFS_FORCED_SHUTDOWN(ip->i_mount));
                if (lip->li_flags & XFS_LI_IN_AIL) {
-                       AIL_LOCK(mp, s);
+                       spin_lock(&mp->m_ail_lock);
                        if (lip->li_flags & XFS_LI_IN_AIL)
-                               xfs_trans_delete_ail(mp, lip, s);
+                               xfs_trans_delete_ail(mp, lip);
                        else
-                               AIL_UNLOCK(mp, s);
+                               spin_unlock(&mp->m_ail_lock);
                }
                xfs_inode_item_destroy(ip);
        }
@@ -3334,7 +3331,6 @@ xfs_iflush_int(
 #ifdef XFS_TRANS_DEBUG
        int                     first;
 #endif
-       SPLDECL(s);
 
        ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
        ASSERT(issemalocked(&(ip->i_flock)));
@@ -3529,9 +3525,9 @@ xfs_iflush_int(
                iip->ili_logged = 1;
 
                ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */
-               AIL_LOCK(mp,s);
+               spin_lock(&mp->m_ail_lock);
                iip->ili_flush_lsn = iip->ili_item.li_lsn;
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
 
                /*
                 * Attach the function xfs_iflush_done to the inode's
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 565d470..e365b13 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -615,7 +615,7 @@ xfs_inode_item_trylock(
                        return XFS_ITEM_PUSHBUF;
                } else {
                        /*
-                        * We hold the AIL_LOCK, so we must specify the
+                        * We hold the AIL lock, so we must specify the
                         * NONOTIFY flag so that we won't double trip.
                         */
                        xfs_iunlock(ip, XFS_ILOCK_SHARED|XFS_IUNLOCK_NONOTIFY);
@@ -749,7 +749,7 @@ xfs_inode_item_committed(
  * marked delayed write. If that's the case, we'll initiate a bawrite on that
  * buffer to expedite the process.
  *
- * We aren't holding the AIL_LOCK (or the flush lock) when this gets called,
+ * We aren't holding the AIL lock (or the flush lock) when this gets called,
  * so it is inherently race-y.
  */
 STATIC void
@@ -792,7 +792,7 @@ xfs_inode_item_pushbuf(
                if (XFS_BUF_ISDELAYWRITE(bp)) {
                        /*
                         * We were racing with iflush because we don't hold
-                        * the AIL_LOCK or the flush lock. However, at this 
point,
+                        * the AIL lock or the flush lock. However, at this 
point,
                         * we have the buffer, and we know that it's dirty.
                         * So, it's possible that iflush raced with us, and
                         * this item is already taken off the AIL.
@@ -968,7 +968,6 @@ xfs_iflush_done(
        xfs_inode_log_item_t    *iip)
 {
        xfs_inode_t     *ip;
-       SPLDECL(s);
 
        ip = iip->ili_inode;
 
@@ -983,15 +982,15 @@ xfs_iflush_done(
         */
        if (iip->ili_logged &&
            (iip->ili_item.li_lsn == iip->ili_flush_lsn)) {
-               AIL_LOCK(ip->i_mount, s);
+               spin_lock(&ip->i_mount->m_ail_lock);
                if (iip->ili_item.li_lsn == iip->ili_flush_lsn) {
                        /*
                         * xfs_trans_delete_ail() drops the AIL lock.
                         */
                        xfs_trans_delete_ail(ip->i_mount,
-                                            (xfs_log_item_t*)iip, s);
+                                            (xfs_log_item_t*)iip);
                } else {
-                       AIL_UNLOCK(ip->i_mount, s);
+                       spin_unlock(&ip->i_mount->m_ail_lock);
                }
        }
 
@@ -1025,21 +1024,19 @@ xfs_iflush_abort(
 {
        xfs_inode_log_item_t    *iip;
        xfs_mount_t             *mp;
-       SPLDECL(s);
 
        iip = ip->i_itemp;
        mp = ip->i_mount;
        if (iip) {
                if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
-                       AIL_LOCK(mp, s);
+                       spin_lock(&mp->m_ail_lock);
                        if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
                                /*
                                 * xfs_trans_delete_ail() drops the AIL lock.
                                 */
-                               xfs_trans_delete_ail(mp, (xfs_log_item_t *)iip,
-                                       s);
+                               xfs_trans_delete_ail(mp, (xfs_log_item_t *)iip);
                        } else
-                               AIL_UNLOCK(mp, s);
+                               spin_unlock(&mp->m_ail_lock);
                }
                iip->ili_logged = 0;
                /*
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 851eca8..4c39dc0 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2660,7 +2660,6 @@ xlog_recover_do_efi_trans(
        xfs_mount_t             *mp;
        xfs_efi_log_item_t      *efip;
        xfs_efi_log_format_t    *efi_formatp;
-       SPLDECL(s);
 
        if (pass == XLOG_RECOVER_PASS1) {
                return 0;
@@ -2678,11 +2677,11 @@ xlog_recover_do_efi_trans(
        efip->efi_next_extent = efi_formatp->efi_nextents;
        efip->efi_flags |= XFS_EFI_COMMITTED;
 
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
        /*
         * xfs_trans_update_ail() drops the AIL lock.
         */
-       xfs_trans_update_ail(mp, (xfs_log_item_t *)efip, lsn, s);
+       xfs_trans_update_ail(mp, (xfs_log_item_t *)efip, lsn);
        return 0;
 }
 
@@ -2707,7 +2706,6 @@ xlog_recover_do_efd_trans(
        xfs_log_item_t          *lip;
        int                     gen;
        __uint64_t              efi_id;
-       SPLDECL(s);
 
        if (pass == XLOG_RECOVER_PASS1) {
                return;
@@ -2725,7 +2723,7 @@ xlog_recover_do_efd_trans(
         * in the AIL.
         */
        mp = log->l_mp;
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
        lip = xfs_trans_first_ail(mp, &gen);
        while (lip != NULL) {
                if (lip->li_type == XFS_LI_EFI) {
@@ -2735,7 +2733,7 @@ xlog_recover_do_efd_trans(
                                 * xfs_trans_delete_ail() drops the
                                 * AIL lock.
                                 */
-                               xfs_trans_delete_ail(mp, lip, s);
+                               xfs_trans_delete_ail(mp, lip);
                                break;
                        }
                }
@@ -2749,7 +2747,7 @@ xlog_recover_do_efd_trans(
        if (lip != NULL) {
                xfs_efi_item_free(efip);
        } else {
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
        }
 }
 
@@ -3075,10 +3073,9 @@ xlog_recover_process_efis(
        xfs_efi_log_item_t      *efip;
        int                     gen;
        xfs_mount_t             *mp;
-       SPLDECL(s);
 
        mp = log->l_mp;
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
 
        lip = xfs_trans_first_ail(mp, &gen);
        while (lip != NULL) {
@@ -3099,12 +3096,12 @@ xlog_recover_process_efis(
                        continue;
                }
 
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
                xlog_recover_process_efi(mp, efip);
-               AIL_LOCK(mp,s);
+               spin_lock(&mp->m_ail_lock);
                lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
        }
-       AIL_UNLOCK(mp, s);
+       spin_unlock(&mp->m_ail_lock);
 }
 
 /*
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index f395f59..9a80b55 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -136,7 +136,7 @@ xfs_mount_init(void)
                mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
        }
 
-       AIL_LOCKINIT(&mp->m_ail_lock, "xfs_ail");
+       spinlock_init(&mp->m_ail_lock, "xfs_ail");
        spinlock_init(&mp->m_sb_lock, "xfs_sb");
        mutex_init(&mp->m_ilock);
        mutex_init(&mp->m_growlock);
@@ -171,7 +171,7 @@ xfs_mount_free(
                          sizeof(xfs_perag_t) * mp->m_sb.sb_agcount);
        }
 
-       AIL_LOCK_DESTROY(&mp->m_ail_lock);
+       spinlock_destroy(&mp->m_ail_lock);
        spinlock_destroy(&mp->m_sb_lock);
        mutex_destroy(&mp->m_ilock);
        mutex_destroy(&mp->m_growlock);
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index f7b761f..723f01f 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -63,13 +63,6 @@ struct xfs_extdelta;
 struct xfs_swapext;
 struct xfs_mru_cache;
 
-#define        AIL_LOCK_T              lock_t
-#define        AIL_LOCKINIT(x,y)       spinlock_init(x,y)
-#define        AIL_LOCK_DESTROY(x)     spinlock_destroy(x)
-#define        AIL_LOCK(mp,s)          s=mutex_spinlock(&(mp)->m_ail_lock)
-#define        AIL_UNLOCK(mp,s)        mutex_spinunlock(&(mp)->m_ail_lock, s)
-
-
 /*
  * Prototypes and functions for the Data Migration subsystem.
  */
@@ -230,7 +223,7 @@ extern void xfs_icsb_sync_counters_flags(struct xfs_mount 
*, int);
 typedef struct xfs_mount {
        struct super_block      *m_super;
        xfs_tid_t               m_tid;          /* next unused tid for fs */
-       AIL_LOCK_T              m_ail_lock;     /* fs AIL mutex */
+       spinlock_t              m_ail_lock;     /* fs AIL mutex */
        xfs_ail_entry_t         m_ail;          /* fs active log item list */
        uint                    m_ail_gen;      /* fs AIL generation count */
        xfs_sb_t                m_sb;           /* copy of fs superblock */
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 8878322..71e4c8d 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -1322,7 +1322,6 @@ xfs_trans_chunk_committed(
        xfs_lsn_t               item_lsn;
        struct xfs_mount        *mp;
        int                     i;
-       SPLDECL(s);
 
        lidp = licp->lic_descs;
        for (i = 0; i < licp->lic_unused; i++, lidp++) {
@@ -1363,7 +1362,7 @@ xfs_trans_chunk_committed(
                 * the test below.
                 */
                mp = lip->li_mountp;
-               AIL_LOCK(mp,s);
+               spin_lock(&mp->m_ail_lock);
                if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) {
                        /*
                         * This will set the item's lsn to item_lsn
@@ -1372,9 +1371,9 @@ xfs_trans_chunk_committed(
                         *
                         * xfs_trans_update_ail() drops the AIL lock.
                         */
-                       xfs_trans_update_ail(mp, lip, item_lsn, s);
+                       xfs_trans_update_ail(mp, lip, item_lsn);
                } else {
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                }
 
                /*
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 5b2ff59..2d3c297 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -55,16 +55,15 @@ xfs_trans_tail_ail(
 {
        xfs_lsn_t       lsn;
        xfs_log_item_t  *lip;
-       SPLDECL(s);
 
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
        lip = xfs_ail_min(&(mp->m_ail));
        if (lip == NULL) {
                lsn = (xfs_lsn_t)0;
        } else {
                lsn = lip->li_lsn;
        }
-       AIL_UNLOCK(mp, s);
+       spin_unlock(&mp->m_ail_lock);
 
        return lsn;
 }
@@ -89,17 +88,16 @@ xfs_trans_push_ail(
        int                     restarts;
        int                     lock_result;
        int                     flush_log;
-       SPLDECL(s);
 
 #define        XFS_TRANS_PUSH_AIL_RESTARTS     1000
 
-       AIL_LOCK(mp,s);
+       spin_lock(&mp->m_ail_lock);
        lip = xfs_trans_first_ail(mp, &gen);
        if (lip == NULL || XFS_FORCED_SHUTDOWN(mp)) {
                /*
                 * Just return if the AIL is empty.
                 */
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
                return (xfs_lsn_t)0;
        }
 
@@ -112,7 +110,7 @@ xfs_trans_push_ail(
         * beginning of the list.  We'd like not to stop until we've at least
         * tried to push on everything in the AIL with an LSN less than
         * the given threshold. However, we may give up before that if
-        * we realize that we've been holding the AIL_LOCK for 'too long',
+        * we realize that we've been holding the AIL lock for 'too long',
         * blocking interrupts. Currently, too long is < 500us roughly.
         */
        flush_log = 0;
@@ -136,14 +134,14 @@ xfs_trans_push_ail(
                lock_result = IOP_TRYLOCK(lip);
                switch (lock_result) {
                      case XFS_ITEM_SUCCESS:
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                        XFS_STATS_INC(xs_push_ail_success);
                        IOP_PUSH(lip);
-                       AIL_LOCK(mp,s);
+                       spin_lock(&mp->m_ail_lock);
                        break;
 
                      case XFS_ITEM_PUSHBUF:
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                        XFS_STATS_INC(xs_push_ail_pushbuf);
 #ifdef XFSRACEDEBUG
                        delay_for_intr();
@@ -152,7 +150,7 @@ xfs_trans_push_ail(
                        ASSERT(lip->li_ops->iop_pushbuf);
                        ASSERT(lip);
                        IOP_PUSHBUF(lip);
-                       AIL_LOCK(mp,s);
+                       spin_lock(&mp->m_ail_lock);
                        break;
 
                      case XFS_ITEM_PINNED:
@@ -181,7 +179,7 @@ xfs_trans_push_ail(
                        /*
                         * Just return if we shut down during the last try.
                         */
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                        return (xfs_lsn_t)0;
                }
 
@@ -193,10 +191,10 @@ xfs_trans_push_ail(
                 * push out the log so it will become unpinned and
                 * move forward in the AIL.
                 */
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
                XFS_STATS_INC(xs_push_ail_flush);
                xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
-               AIL_LOCK(mp, s);
+               spin_lock(&mp->m_ail_lock);
        }
 
        lip = xfs_ail_min(&(mp->m_ail));
@@ -206,7 +204,7 @@ xfs_trans_push_ail(
                lsn = lip->li_lsn;
        }
 
-       AIL_UNLOCK(mp, s);
+       spin_unlock(&mp->m_ail_lock);
        return lsn;
 }      /* xfs_trans_push_ail */
 
@@ -269,15 +267,13 @@ xfs_trans_unlocked_item(
  * has changed.
  *
  * This function must be called with the AIL lock held.  The lock
- * is dropped before returning, so the caller must pass in the
- * cookie returned by AIL_LOCK.
+ * is dropped before returning.
  */
 void
 xfs_trans_update_ail(
        xfs_mount_t     *mp,
        xfs_log_item_t  *lip,
-       xfs_lsn_t       lsn,
-       unsigned long   s) __releases(mp->m_ail_lock)
+       xfs_lsn_t       lsn) __releases(mp->m_ail_lock)
 {
        xfs_ail_entry_t         *ailp;
        xfs_log_item_t          *dlip=NULL;
@@ -300,10 +296,10 @@ xfs_trans_update_ail(
 
        if (mlip == dlip) {
                mlip = xfs_ail_min(&(mp->m_ail));
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
                xfs_log_move_tail(mp, mlip->li_lsn);
        } else {
-               AIL_UNLOCK(mp, s);
+               spin_unlock(&mp->m_ail_lock);
        }
 
 
@@ -322,14 +318,12 @@ xfs_trans_update_ail(
  * has changed.
  *
  * This function must be called with the AIL lock held.  The lock
- * is dropped before returning, so the caller must pass in the
- * cookie returned by AIL_LOCK.
+ * is dropped before returning.
  */
 void
 xfs_trans_delete_ail(
        xfs_mount_t     *mp,
-       xfs_log_item_t  *lip,
-       unsigned long   s) __releases(mp->m_ail_lock)
+       xfs_log_item_t  *lip) __releases(mp->m_ail_lock)
 {
        xfs_ail_entry_t         *ailp;
        xfs_log_item_t          *dlip;
@@ -348,10 +342,10 @@ xfs_trans_delete_ail(
 
                if (mlip == dlip) {
                        mlip = xfs_ail_min(&(mp->m_ail));
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                        xfs_log_move_tail(mp, (mlip ? mlip->li_lsn : 0));
                } else {
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                }
        }
        else {
@@ -360,12 +354,12 @@ xfs_trans_delete_ail(
                 * serious trouble if we get to this stage.
                 */
                if (XFS_FORCED_SHUTDOWN(mp))
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                else {
                        xfs_cmn_err(XFS_PTAG_AILDELETE, CE_ALERT, mp,
                "%s: attempting to delete a log item that is not in the AIL",
                                        __FUNCTION__);
-                       AIL_UNLOCK(mp, s);
+                       spin_unlock(&mp->m_ail_lock);
                        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
                }
        }
diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h
index 447ac43..c40f051 100644
--- a/fs/xfs/xfs_trans_priv.h
+++ b/fs/xfs/xfs_trans_priv.h
@@ -47,11 +47,10 @@ xfs_log_busy_slot_t         *xfs_trans_add_busy(xfs_trans_t 
*tp,
  * From xfs_trans_ail.c
  */
 void                   xfs_trans_update_ail(struct xfs_mount *mp,
-                                    struct xfs_log_item *lip, xfs_lsn_t lsn,
-                                    unsigned long s)
+                                    struct xfs_log_item *lip, xfs_lsn_t lsn)
                                     __releases(mp->m_ail_lock);
 void                   xfs_trans_delete_ail(struct xfs_mount *mp,
-                                    struct xfs_log_item *lip, unsigned long s)
+                                    struct xfs_log_item *lip)
                                     __releases(mp->m_ail_lock);
 struct xfs_log_item    *xfs_trans_first_ail(struct xfs_mount *, int *);
 struct xfs_log_item    *xfs_trans_next_ail(struct xfs_mount *,
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to