xfs: kill XBF_LOCK

Buffers are always returned locked from the lookup routines. Hence
we don't need to tell the lookup routines to return locked buffers,
on to try and lock them. Remove XBF_LOCK from all the callers and
from internal buffer cache usage.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

11 files changed, 29 insertions, 49 deletions

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 6e9bd7e46982..c8ef9a9c312b 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -1988,8 +1988,7 @@ xfs_attr_rmtval_get(xfs_da_args_t *args)
                         dblkno = XFS_FSB_TO_DADDR(mp, map[i].br_startblock);
                         blkcnt = XFS_FSB_TO_BB(mp, map[i].br_blockcount);
                         error = xfs_read_buf(mp, mp->m_ddev_targp, dblkno,
-                                             blkcnt, XBF_LOCK | XBF_DONT_BLOCK,
-                                             &bp);
+                                             blkcnt, XBF_DONT_BLOCK, &bp);
                         if (error)
                                 return(error);
 
@@ -2116,7 +2115,7 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
                 blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
 
                 bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt,
-                                 XBF_LOCK | XBF_DONT_BLOCK);
+                                 XBF_DONT_BLOCK);
                 if (!bp)
                         return ENOMEM;
 
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 76d93dc953e1..3cd5dc668043 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -2983,7 +2983,7 @@ xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
                                                 map.br_blockcount);
                         bp = xfs_trans_get_buf(*trans,
                                         dp->i_mount->m_ddev_targp,
-                                        dblkno, dblkcnt, XBF_LOCK);
+                                        dblkno, dblkcnt, 0);
                         if (!bp)
                                 return ENOMEM;
                         xfs_trans_binval(*trans, bp);
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 942cf5051ab4..8366348aa1f9 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -185,7 +185,7 @@ xfs_buf_alloc(
         /*
          * We don't want certain flags to appear in b_flags.
          */
-        flags &= ~(XBF_LOCK|XBF_MAPPED|XBF_DONT_BLOCK|XBF_READ_AHEAD);
+        flags &= ~(XBF_MAPPED|XBF_DONT_BLOCK|XBF_READ_AHEAD);
 
         atomic_set(&bp->b_hold, 1);
         atomic_set(&bp->b_lru_ref, 1);
@@ -584,19 +584,14 @@ found:
                 if (unlikely(error)) {
                         xfs_warn(target->bt_mount,
                                 "%s: failed to map pages\n", __func__);
-                        goto no_buffer;
+                        xfs_buf_relse(bp);
+                        return NULL;
                 }
         }
 
         XFS_STATS_INC(xb_get);
         trace_xfs_buf_get(bp, flags, _RET_IP_);
         return bp;
-
-no_buffer:
-        if (flags & (XBF_LOCK | XBF_TRYLOCK))
-                xfs_buf_unlock(bp);
-        xfs_buf_rele(bp);
-        return NULL;
 }
 
 STATIC int
@@ -639,7 +634,8 @@ xfs_buf_read(
                          * Read ahead call which is already satisfied,
                          * drop the buffer
                          */
-                        goto no_buffer;
+                        xfs_buf_relse(bp);
+                        return NULL;
                 } else {
                         /* We do not want read in the flags */
                         bp->b_flags &= ~XBF_READ;
@@ -647,12 +643,6 @@ xfs_buf_read(
         }
 
         return bp;
-
- no_buffer:
-        if (flags & (XBF_LOCK | XBF_TRYLOCK))
-                xfs_buf_unlock(bp);
-        xfs_buf_rele(bp);
-        return NULL;
 }
 
 /*
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 5b048f7d13ea..512d9a6776a5 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -52,7 +52,6 @@ typedef enum {
 #define XBF_FLUSH       (1 << 12)/* flush the disk cache before a write */
 
 /* flags used only as arguments to access routines */
-#define XBF_LOCK        (1 << 15)/* lock requested */
 #define XBF_TRYLOCK     (1 << 16)/* lock requested, but do not wait */
 #define XBF_DONT_BLOCK  (1 << 17)/* do not block in current thread */
 
@@ -74,8 +73,7 @@ typedef unsigned int xfs_buf_flags_t;
         { XBF_SYNCIO,           "SYNCIO" }, \
         { XBF_FUA,              "FUA" }, \
         { XBF_FLUSH,            "FLUSH" }, \
-        { XBF_LOCK,             "LOCK" },       /* should never be set */\
-        { XBF_TRYLOCK,          "TRYLOCK" },    /* ditto */\
+        { XBF_TRYLOCK,          "TRYLOCK" },    /* should never be set */\
         { XBF_DONT_BLOCK,       "DONT_BLOCK" }, /* ditto */\
         { _XBF_PAGES,           "PAGES" }, \
         { _XBF_KMEM,            "KMEM" }, \
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 019ba5c52a49..874d39883dab 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -193,7 +193,7 @@ xfs_growfs_data_private(
                  */
                 bp = xfs_buf_get(mp->m_ddev_targp,
                                  XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
-                                 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
+                                 XFS_FSS_TO_BB(mp, 1), XBF_MAPPED);
                 if (!bp) {
                         error = ENOMEM;
                         goto error0;
@@ -230,7 +230,7 @@ xfs_growfs_data_private(
                  */
                 bp = xfs_buf_get(mp->m_ddev_targp,
                                  XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
-                                 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
+                                 XFS_FSS_TO_BB(mp, 1), XBF_MAPPED);
                 if (!bp) {
                         error = ENOMEM;
                         goto error0;
@@ -259,8 +259,7 @@ xfs_growfs_data_private(
                  */
                 bp = xfs_buf_get(mp->m_ddev_targp,
                                  XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
-                                 BTOBB(mp->m_sb.sb_blocksize),
-                                 XBF_LOCK | XBF_MAPPED);
+                                 BTOBB(mp->m_sb.sb_blocksize), XBF_MAPPED);
                 if (!bp) {
                         error = ENOMEM;
                         goto error0;
@@ -286,8 +285,7 @@ xfs_growfs_data_private(
                  */
                 bp = xfs_buf_get(mp->m_ddev_targp,
                                  XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
-                                 BTOBB(mp->m_sb.sb_blocksize),
-                                 XBF_LOCK | XBF_MAPPED);
+                                 BTOBB(mp->m_sb.sb_blocksize), XBF_MAPPED);
                 if (!bp) {
                         error = ENOMEM;
                         goto error0;
@@ -314,8 +312,7 @@ xfs_growfs_data_private(
                  */
                 bp = xfs_buf_get(mp->m_ddev_targp,
                                  XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
-                                 BTOBB(mp->m_sb.sb_blocksize),
-                                 XBF_LOCK | XBF_MAPPED);
+                                 BTOBB(mp->m_sb.sb_blocksize), XBF_MAPPED);
                 if (!bp) {
                         error = ENOMEM;
                         goto error0;
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index dad1a31aa4fc..d094a23e1030 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -200,8 +200,7 @@ xfs_ialloc_inode_init(
                  */
                 d = XFS_AGB_TO_DADDR(mp, agno, agbno + (j * blks_per_cluster));
                 fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                                         mp->m_bsize * blks_per_cluster,
-                                         XBF_LOCK);
+                                         mp->m_bsize * blks_per_cluster, 0);
                 if (!fbuf)
                         return ENOMEM;
                 /*
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 65d7d994d499..f64b482a7953 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -226,7 +226,7 @@ xfs_inotobp(
         if (error)
                 return error;
 
-        error = xfs_imap_to_bp(mp, tp, &imap, &bp, XBF_LOCK, imap_flags);
+        error = xfs_imap_to_bp(mp, tp, &imap, &bp, 0, imap_flags);
         if (error)
                 return error;
 
@@ -782,8 +782,7 @@ xfs_iread(
         /*
          * Get pointers to the on-disk inode and the buffer containing it.
          */
-        error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp,
-                               XBF_LOCK, iget_flags);
+        error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp, 0, iget_flags);
         if (error)
                 return error;
         dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
@@ -1342,7 +1341,7 @@ xfs_iunlink(
                  * Here we put the head pointer into our next pointer,
                  * and then we fall through to point the head at us.
                  */
-                error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
+                error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0);
                 if (error)
                         return error;
 
@@ -1423,7 +1422,7 @@ xfs_iunlink_remove(
                  * of dealing with the buffer when there is no need to
                  * change it.
                  */
-                error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
+                error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0);
                 if (error) {
                         xfs_warn(mp, "%s: xfs_itobp() returned error %d.",
                                 __func__, error);
@@ -1484,7 +1483,7 @@ xfs_iunlink_remove(
                  * Now last_ibp points to the buffer previous to us on
                  * the unlinked list.  Pull us from the list.
                  */
-                error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
+                error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0);
                 if (error) {
                         xfs_warn(mp, "%s: xfs_itobp(2) returned error %d.",
                                 __func__, error);
@@ -1566,8 +1565,7 @@ xfs_ifree_cluster(
                  * to mark all the active inodes on the buffer stale.
                  */
                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
-                                        mp->m_bsize * blks_per_cluster,
-                                        XBF_LOCK);
+                                        mp->m_bsize * blks_per_cluster, 0);
 
                 if (!bp)
                         return ENOMEM;
@@ -1737,7 +1735,7 @@ xfs_ifree(
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
-        error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, XBF_LOCK);
+        error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, 0);
         if (error)
                 return error;
 
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 8c826b00aac1..0d9bdb6bace4 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2131,7 +2131,7 @@ xlog_recover_buffer_pass2(
 
         trace_xfs_log_recover_buf_recover(log, buf_f);
 
-        buf_flags = XBF_LOCK;
+        buf_flags = 0;
         if (!(buf_f->blf_flags & XFS_BLF_INODE_BUF))
                 buf_flags |= XBF_MAPPED;
 
@@ -2229,8 +2229,7 @@ xlog_recover_inode_pass2(
         }
         trace_xfs_log_recover_inode_recover(log, in_f);
 
-        bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len,
-                          XBF_LOCK);
+        bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0);
         if (!bp) {
                 error = ENOMEM;
                 goto error;
@@ -3103,7 +3102,7 @@ xlog_recover_process_one_iunlink(
         /*
          * Get the on disk inode to find the next inode in the bucket.
          */
-        error = xfs_itobp(mp, NULL, ip, &dip, &ibp, XBF_LOCK);
+        error = xfs_itobp(mp, NULL, ip, &dip, &ibp, 0);
         if (error)
                 goto fail_iput;
 
diff --git a/fs/xfs/xfs_rw.c b/fs/xfs/xfs_rw.c
index 597d044a09a1..2ce97758f4c7 100644
--- a/fs/xfs/xfs_rw.c
+++ b/fs/xfs/xfs_rw.c
@@ -114,7 +114,7 @@ xfs_read_buf(
         int              error;
 
         if (!flags)
-                flags = XBF_LOCK | XBF_MAPPED;
+                flags = XBF_MAPPED;
 
         bp = xfs_buf_read(target, blkno, len, flags);
         if (!bp)
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 2ec196b6c079..f9cb7ee04dae 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -142,7 +142,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
         xfs_buf_log_item_t      *bip;
 
         if (flags == 0)
-                flags = XBF_LOCK | XBF_MAPPED;
+                flags = XBF_MAPPED;
 
         /*
          * Default to a normal get_buf() call if the tp is NULL.
@@ -275,7 +275,7 @@ xfs_trans_read_buf(
         int                     error;
 
         if (flags == 0)
-                flags = XBF_LOCK | XBF_MAPPED;
+                flags = XBF_MAPPED;
 
         /*
          * Default to a normal get_buf() call if the tp is NULL.
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 445c224742b8..8f99c7781f39 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -82,7 +82,7 @@ xfs_readlink_bmap(
                 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
 
                 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt),
-                                  XBF_LOCK | XBF_MAPPED | XBF_DONT_BLOCK);
+                                  XBF_MAPPED | XBF_DONT_BLOCK);
                 if (!bp)
                         return XFS_ERROR(ENOMEM);
                 error = bp->b_error;