xfs: clean up buffer locking helpers

Rename xfs_buf_cond_lock and reverse it's return value to fit most other
trylock operations in the Kernel and XFS (with the exception of down_trylock,
after which xfs_buf_cond_lock was modelled), and replace xfs_buf_lock_val
with an xfs_buf_islocked for use in asserts, or and opencoded variant in
tracing.  remove the XFS_BUF_* wrappers for all the locking helpers.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Alex Elder <aelder@sgi.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 5e68099db2a5fdc97a284031e06a7f70fcea27cb..c77227615403b18c36cc40cf49ccda98f1249838 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -499,16 +499,14 @@ found:
        spin_unlock(&pag->pag_buf_lock);
        xfs_perag_put(pag);
 
-       if (xfs_buf_cond_lock(bp)) {
-               /* failed, so wait for the lock if requested. */
-               if (!(flags & XBF_TRYLOCK)) {
-                       xfs_buf_lock(bp);
-                       XFS_STATS_INC(xb_get_locked_waited);
-               } else {
+       if (!xfs_buf_trylock(bp)) {
+               if (flags & XBF_TRYLOCK) {
                        xfs_buf_rele(bp);
                        XFS_STATS_INC(xb_busy_locked);
                        return NULL;
                }
+               xfs_buf_lock(bp);
+               XFS_STATS_INC(xb_get_locked_waited);
        }
 
        /*
@@ -896,8 +894,8 @@ xfs_buf_rele(
  *     to push on stale inode buffers.
  */
 int
-xfs_buf_cond_lock(
-       xfs_buf_t               *bp)
+xfs_buf_trylock(
+       struct xfs_buf          *bp)
 {
        int                     locked;
 
@@ -907,15 +905,8 @@ xfs_buf_cond_lock(
        else if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
                xfs_log_force(bp->b_target->bt_mount, 0);
 
-       trace_xfs_buf_cond_lock(bp, _RET_IP_);
-       return locked ? 0 : -EBUSY;
-}
-
-int
-xfs_buf_lock_value(
-       xfs_buf_t               *bp)
-{
-       return bp->b_sema.count;
+       trace_xfs_buf_trylock(bp, _RET_IP_);
+       return locked;
 }
 
 /*
@@ -929,7 +920,7 @@ xfs_buf_lock_value(
  */
 void
 xfs_buf_lock(
-       xfs_buf_t               *bp)
+       struct xfs_buf          *bp)
 {
        trace_xfs_buf_lock(bp, _RET_IP_);
 
@@ -950,7 +941,7 @@ xfs_buf_lock(
  */
 void
 xfs_buf_unlock(
-       xfs_buf_t               *bp)
+       struct xfs_buf          *bp)
 {
        if ((bp->b_flags & (XBF_DELWRI|_XBF_DELWRI_Q)) == XBF_DELWRI) {
                atomic_inc(&bp->b_hold);
@@ -1694,7 +1685,7 @@ xfs_buf_delwri_split(
        list_for_each_entry_safe(bp, n, dwq, b_list) {
                ASSERT(bp->b_flags & XBF_DELWRI);
 
-               if (!XFS_BUF_ISPINNED(bp) && !xfs_buf_cond_lock(bp)) {
+               if (!XFS_BUF_ISPINNED(bp) && xfs_buf_trylock(bp)) {
                        if (!force &&
                            time_before(jiffies, bp->b_queuetime + age)) {
                                xfs_buf_unlock(bp);

diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index 6847dc4dceeb7619bfe1d082a1f4c312bf8ea945..706c400691161638cc86ffc5e300d4f0b470322e 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -187,10 +187,11 @@ extern void xfs_buf_free(xfs_buf_t *);
 extern void xfs_buf_rele(xfs_buf_t *);
 
 /* Locking and Unlocking Buffers */
-extern int xfs_buf_cond_lock(xfs_buf_t *);
-extern int xfs_buf_lock_value(xfs_buf_t *);
+extern int xfs_buf_trylock(xfs_buf_t *);
 extern void xfs_buf_lock(xfs_buf_t *);
 extern void xfs_buf_unlock(xfs_buf_t *);
+#define xfs_buf_islocked(bp) \
+       ((bp)->b_sema.count <= 0)
 
 /* Buffer Read and Write Routines */
 extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp);
@@ -308,10 +309,6 @@ xfs_buf_set_ref(
 
 #define XFS_BUF_ISPINNED(bp)   atomic_read(&((bp)->b_pin_count))
 
-#define XFS_BUF_VALUSEMA(bp)   xfs_buf_lock_value(bp)
-#define XFS_BUF_CPSEMA(bp)     (xfs_buf_cond_lock(bp) == 0)
-#define XFS_BUF_VSEMA(bp)      xfs_buf_unlock(bp)
-#define XFS_BUF_PSEMA(bp,x)    xfs_buf_lock(bp)
 #define XFS_BUF_FINISH_IOWAIT(bp)      complete(&bp->b_iowait);
 
 #define XFS_BUF_SET_TARGET(bp, target) ((bp)->b_target = (target))

diff --git a/fs/xfs/linux-2.6/xfs_trace.h b/fs/xfs/linux-2.6/xfs_trace.h
index 4fe53f9f0477c47d9b867c8469f4207aacb86ead..3bdfcb9f52b763789d1af8939159ed88a07f5269 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_trace.h
+++ b/fs/xfs/linux-2.6/xfs_trace.h
@@ -293,7 +293,7 @@ DECLARE_EVENT_CLASS(xfs_buf_class,
                __entry->buffer_length = bp->b_buffer_length;
                __entry->hold = atomic_read(&bp->b_hold);
                __entry->pincount = atomic_read(&bp->b_pin_count);
-               __entry->lockval = xfs_buf_lock_value(bp);
+               __entry->lockval = bp->b_sema.count;
                __entry->flags = bp->b_flags;
                __entry->caller_ip = caller_ip;
        ),
@@ -323,7 +323,7 @@ DEFINE_BUF_EVENT(xfs_buf_bawrite);
 DEFINE_BUF_EVENT(xfs_buf_bdwrite);
 DEFINE_BUF_EVENT(xfs_buf_lock);
 DEFINE_BUF_EVENT(xfs_buf_lock_done);
-DEFINE_BUF_EVENT(xfs_buf_cond_lock);
+DEFINE_BUF_EVENT(xfs_buf_trylock);
 DEFINE_BUF_EVENT(xfs_buf_unlock);
 DEFINE_BUF_EVENT(xfs_buf_iowait);
 DEFINE_BUF_EVENT(xfs_buf_iowait_done);
@@ -366,7 +366,7 @@ DECLARE_EVENT_CLASS(xfs_buf_flags_class,
                __entry->flags = flags;
                __entry->hold = atomic_read(&bp->b_hold);
                __entry->pincount = atomic_read(&bp->b_pin_count);
-               __entry->lockval = xfs_buf_lock_value(bp);
+               __entry->lockval = bp->b_sema.count;
                __entry->caller_ip = caller_ip;
        ),
        TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
@@ -409,7 +409,7 @@ TRACE_EVENT(xfs_buf_ioerror,
                __entry->buffer_length = bp->b_buffer_length;
                __entry->hold = atomic_read(&bp->b_hold);
                __entry->pincount = atomic_read(&bp->b_pin_count);
-               __entry->lockval = xfs_buf_lock_value(bp);
+               __entry->lockval = bp->b_sema.count;
                __entry->error = error;
                __entry->flags = bp->b_flags;
                __entry->caller_ip = caller_ip;
@@ -454,7 +454,7 @@ DECLARE_EVENT_CLASS(xfs_buf_item_class,
                __entry->buf_flags = bip->bli_buf->b_flags;
                __entry->buf_hold = atomic_read(&bip->bli_buf->b_hold);
                __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count);
-               __entry->buf_lockval = xfs_buf_lock_value(bip->bli_buf);
+               __entry->buf_lockval = bip->bli_buf->b_sema.count;
                __entry->li_desc = bip->bli_item.li_desc;
                __entry->li_flags = bip->bli_item.li_flags;
        ),

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index 6fa214603819d759f8fbbd8e588a1a306ac78420..dec11497a2ef8be643bdff21e4b5be044d04f94b 100644 (file)
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -318,7 +318,7 @@ xfs_qm_init_dquot_blk(
 
        ASSERT(tp);
        ASSERT(XFS_BUF_ISBUSY(bp));
-       ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+       ASSERT(xfs_buf_islocked(bp));
 
        d = (xfs_dqblk_t *)XFS_BUF_PTR(bp);
 
@@ -534,7 +534,7 @@ xfs_qm_dqtobp(
        }
 
        ASSERT(XFS_BUF_ISBUSY(bp));
-       ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+       ASSERT(xfs_buf_islocked(bp));
 
        /*
         * calculate the location of the dquot inside the buffer.
@@ -622,7 +622,7 @@ xfs_qm_dqread(
         * brelse it because we have the changes incore.
         */
        ASSERT(XFS_BUF_ISBUSY(bp));
-       ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+       ASSERT(xfs_buf_islocked(bp));
        xfs_trans_brelse(tp, bp);
 
        return (error);

diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 7b7e005e3dccd3620ddf66ff334dfe4f6e94bc03..da399ac4411dd8b0d2341da2f618820deacec069 100644 (file)
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -420,7 +420,7 @@ xfs_buf_item_unpin(
 
        if (freed && stale) {
                ASSERT(bip->bli_flags & XFS_BLI_STALE);
-               ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+               ASSERT(xfs_buf_islocked(bp));
                ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
                ASSERT(XFS_BUF_ISSTALE(bp));
                ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
@@ -483,7 +483,7 @@ xfs_buf_item_trylock(
 
        if (XFS_BUF_ISPINNED(bp))
                return XFS_ITEM_PINNED;
-       if (!XFS_BUF_CPSEMA(bp))
+       if (!xfs_buf_trylock(bp))
                return XFS_ITEM_LOCKED;
 
        /* take a reference to the buffer.  */
@@ -905,7 +905,7 @@ xfs_buf_attach_iodone(
        xfs_log_item_t  *head_lip;
 
        ASSERT(XFS_BUF_ISBUSY(bp));
-       ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+       ASSERT(xfs_buf_islocked(bp));
 
        lip->li_cb = cb;
        if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 5b24a71811f8ed3e95e0b140aa8df91ff250fff6..68e053ea6e7803337e4a13f512a054fc1ef12c45 100644 (file)
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1059,7 +1059,7 @@ xlog_alloc_log(xfs_mount_t        *mp,
        XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
        XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
        ASSERT(XFS_BUF_ISBUSY(bp));
-       ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+       ASSERT(xfs_buf_islocked(bp));
        log->l_xbuf = bp;
 
        spin_lock_init(&log->l_icloglock);
@@ -1090,7 +1090,7 @@ xlog_alloc_log(xfs_mount_t        *mp,
                                                log->l_iclog_size, 0);
                if (!bp)
                        goto out_free_iclog;
-               if (!XFS_BUF_CPSEMA(bp))
+               if (!xfs_buf_trylock(bp))
                        ASSERT(0);
                XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
                XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
@@ -1118,7 +1118,7 @@ xlog_alloc_log(xfs_mount_t        *mp,
                iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
 
                ASSERT(XFS_BUF_ISBUSY(iclog->ic_bp));
-               ASSERT(XFS_BUF_VALUSEMA(iclog->ic_bp) <= 0);
+               ASSERT(xfs_buf_islocked(iclog->ic_bp));
                init_waitqueue_head(&iclog->ic_force_wait);
                init_waitqueue_head(&iclog->ic_write_wait);
 

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index fb528b354c0dbd24e7f577bea0b95aa2e77c3da4..a74e26408343f93829de785c00265239af60da9a 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -264,7 +264,7 @@ xlog_bwrite(
        XFS_BUF_ZEROFLAGS(bp);
        XFS_BUF_BUSY(bp);
        XFS_BUF_HOLD(bp);
-       XFS_BUF_PSEMA(bp, PRIBIO);
+       xfs_buf_lock(bp);
        XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
        XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
 

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 63659ee316bd5f6b97367f0775e8fa8cd1d8300c..77ffe3ce71fe42b74a8a75ff66fada560449b65d 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1941,22 +1941,19 @@ unwind:
  * the superblock buffer if it can be locked without sleeping.
  * If it can't then we'll return NULL.
  */
-xfs_buf_t *
+struct xfs_buf *
 xfs_getsb(
-       xfs_mount_t     *mp,
-       int             flags)
+       struct xfs_mount        *mp,
+       int                     flags)
 {
-       xfs_buf_t       *bp;
+       struct xfs_buf          *bp = mp->m_sb_bp;
 
-       ASSERT(mp->m_sb_bp != NULL);
-       bp = mp->m_sb_bp;
-       if (flags & XBF_TRYLOCK) {
-               if (!XFS_BUF_CPSEMA(bp)) {
+       if (!xfs_buf_trylock(bp)) {
+               if (flags & XBF_TRYLOCK)
                        return NULL;
-               }
-       } else {
-               XFS_BUF_PSEMA(bp, PRIBIO);
+               xfs_buf_lock(bp);
        }
+
        XFS_BUF_HOLD(bp);
        ASSERT(XFS_BUF_ISDONE(bp));
        return bp;

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 03b3b7f85a3b59b68a1d6ff99ba83ac38ac7094c..bd544578785513f4d316e7436dfd1332beab944e 100644 (file)
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -160,7 +160,7 @@ xfs_trans_get_buf(xfs_trans_t       *tp,
         */
        bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
        if (bp != NULL) {
-               ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+               ASSERT(xfs_buf_islocked(bp));
                if (XFS_FORCED_SHUTDOWN(tp->t_mountp))
                        XFS_BUF_SUPER_STALE(bp);
 
@@ -327,7 +327,7 @@ xfs_trans_read_buf(
         */
        bp = xfs_trans_buf_item_match(tp, target, blkno, len);
        if (bp != NULL) {
-               ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+               ASSERT(xfs_buf_islocked(bp));
                ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
                ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
                ASSERT((XFS_BUF_ISERROR(bp)) == 0);