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>

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 6e9bd7e469824824118f7b4fe100c7baa4dfcd35..c8ef9a9c312bc5d42fe484369d11b9272073c76d 100644 (file)
--- 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 76d93dc953e15fea0a213955e1c8cd7223974d7b..3cd5dc668043061c0fd0541f051d6c29369b10b5 100644 (file)
--- 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 942cf5051ab4094bc63fe47cbd07fdae071c0cf1..8366348aa1f9195ef1db67e77219ee70b528b8a0 100644 (file)
--- 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 5b048f7d13eabbc189b9ef051d6ce1f0d52e70c6..512d9a6776a5d8c8608779b46fd0ea931f3b23e9 100644 (file)
--- 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 019ba5c52a49577cc3c78d0c3f91323ec428fb22..874d39883dab6cd08e3145d41e26328f88eaffad 100644 (file)
--- 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 dad1a31aa4fca504c8f4103e85e4b027793d791a..d094a23e1030e3d227b1e5ea80dcc37507745251 100644 (file)
--- 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 65d7d994d499ac43faebd0268e23dd0b621fe356..f64b482a7953f48ecb7e861217bfb7057b085f02 100644 (file)
--- 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 8c826b00aac18b74078137bcec99b57c3fabf8f7..0d9bdb6bace45c91a22efb924abb92590f81ac04 100644 (file)
--- 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 597d044a09a1e41c91f644925d7d0b8b91f08bf2..2ce97758f4c7177bf8202b644e7a7dc9ceadc708 100644 (file)
--- 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 2ec196b6c07964890000316b4449ec4c9a58d53a..f9cb7ee04dae70f1c7442e534cdb6b8018f42791 100644 (file)
--- 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 445c224742b8362c3a3ef5151197b2064960499f..8f99c7781f39096e5c047d7ca39eac22d28372e8 100644 (file)
--- 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;