[XFS] kill xfs_rwlock/xfs_rwunlock

We can just use xfs_ilock/xfs_iunlock instead and get rid of the ugly
bhv_vrwlock_t.

SGI-PV: 976035
SGI-Modid: xfs-linux-melb:xfs-kern:30533a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index e0519529c26cca838a9c65cfb370eb593fef16a6..169e6c062794626c5066db228e3c055d9f436494 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1532,9 +1532,9 @@ xfs_vm_bmap(
        struct xfs_inode        *ip = XFS_I(inode);
 
        xfs_itrace_entry(XFS_I(inode));
-       xfs_rwlock(ip, VRWLOCK_READ);
+       xfs_ilock(ip, XFS_IOLOCK_SHARED);
        xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);
-       xfs_rwunlock(ip, VRWLOCK_READ);
+       xfs_iunlock(ip, XFS_IOLOCK_SHARED);
        return generic_block_bmap(mapping, block, xfs_get_blocks);
 }
 

diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 1663533884902bb749a371271e7e4943f507a3f7..3c20007ab48f864334e445601cc6b677013e24fd 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -228,11 +228,11 @@ xfs_read(
        xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-               bhv_vrwlock_t locktype = VRWLOCK_READ;
                int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);
+               int iolock = XFS_IOLOCK_SHARED;
 
                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp, *offset, size,
-                                       dmflags, &locktype);
+                                       dmflags, &iolock);
                if (ret) {
                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
                        if (unlikely(ioflags & IO_ISDIRECT))
@@ -287,11 +287,11 @@ xfs_splice_read(
        xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-               bhv_vrwlock_t locktype = VRWLOCK_READ;
+               int iolock = XFS_IOLOCK_SHARED;
                int error;
 
                error = XFS_SEND_DATA(mp, DM_EVENT_READ, vp, *ppos, count,
-                                       FILP_DELAY_FLAG(infilp), &locktype);
+                                       FILP_DELAY_FLAG(infilp), &iolock);
                if (error) {
                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
                        return -error;
@@ -330,11 +330,11 @@ xfs_splice_write(
        xfs_ilock(ip, XFS_IOLOCK_EXCL);
 
        if (DM_EVENT_ENABLED(ip, DM_EVENT_WRITE) && !(ioflags & IO_INVIS)) {
-               bhv_vrwlock_t locktype = VRWLOCK_WRITE;
+               int iolock = XFS_IOLOCK_EXCL;
                int error;
 
                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, vp, *ppos, count,
-                                       FILP_DELAY_FLAG(outfilp), &locktype);
+                                       FILP_DELAY_FLAG(outfilp), &iolock);
                if (error) {
                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
                        return -error;
@@ -580,7 +580,6 @@ xfs_write(
        xfs_fsize_t             isize, new_size;
        int                     iolock;
        int                     eventsent = 0;
-       bhv_vrwlock_t           locktype;
        size_t                  ocount = 0, count;
        loff_t                  pos;
        int                     need_i_mutex;
@@ -607,11 +606,9 @@ xfs_write(
 relock:
        if (ioflags & IO_ISDIRECT) {
                iolock = XFS_IOLOCK_SHARED;
-               locktype = VRWLOCK_WRITE_DIRECT;
                need_i_mutex = 0;
        } else {
                iolock = XFS_IOLOCK_EXCL;
-               locktype = VRWLOCK_WRITE;
                need_i_mutex = 1;
                mutex_lock(&inode->i_mutex);
        }
@@ -635,8 +632,7 @@ start:
 
                xfs_iunlock(xip, XFS_ILOCK_EXCL);
                error = XFS_SEND_DATA(xip->i_mount, DM_EVENT_WRITE, vp,
-                                     pos, count,
-                                     dmflags, &locktype);
+                                     pos, count, dmflags, &iolock);
                if (error) {
                        goto out_unlock_internal;
                }
@@ -667,7 +663,6 @@ start:
                if (!need_i_mutex && (VN_CACHED(vp) || pos > xip->i_size)) {
                        xfs_iunlock(xip, XFS_ILOCK_EXCL|iolock);
                        iolock = XFS_IOLOCK_EXCL;
-                       locktype = VRWLOCK_WRITE;
                        need_i_mutex = 1;
                        mutex_lock(&inode->i_mutex);
                        xfs_ilock(xip, XFS_ILOCK_EXCL|iolock);
@@ -744,7 +739,6 @@ retry:
                        mutex_unlock(&inode->i_mutex);
 
                        iolock = XFS_IOLOCK_SHARED;
-                       locktype = VRWLOCK_WRITE_DIRECT;
                        need_i_mutex = 0;
                }
 
@@ -781,7 +775,7 @@ retry:
 
        if (ret == -ENOSPC &&
            DM_EVENT_ENABLED(xip, DM_EVENT_NOSPACE) && !(ioflags & IO_INVIS)) {
-               xfs_rwunlock(xip, locktype);
+               xfs_iunlock(xip, iolock);
                if (need_i_mutex)
                        mutex_unlock(&inode->i_mutex);
                error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,
@@ -789,7 +783,7 @@ retry:
                                0, 0, 0); /* Delay flag intentionally  unused */
                if (need_i_mutex)
                        mutex_lock(&inode->i_mutex);
-               xfs_rwlock(xip, locktype);
+               xfs_ilock(xip, iolock);
                if (error)
                        goto out_unlock_internal;
                pos = xip->i_size;
@@ -817,7 +811,8 @@ retry:
        /* Handle various SYNC-type writes */
        if ((file->f_flags & O_SYNC) || IS_SYNC(inode)) {
                int error2;
-               xfs_rwunlock(xip, locktype);
+
+               xfs_iunlock(xip, iolock);
                if (need_i_mutex)
                        mutex_unlock(&inode->i_mutex);
                error2 = sync_page_range(inode, mapping, pos, ret);
@@ -825,7 +820,7 @@ retry:
                        error = error2;
                if (need_i_mutex)
                        mutex_lock(&inode->i_mutex);
-               xfs_rwlock(xip, locktype);
+               xfs_ilock(xip, iolock);
                error2 = xfs_write_sync_logforce(mp, xip);
                if (!error)
                        error = error2;
@@ -846,7 +841,7 @@ retry:
                        xip->i_d.di_size = xip->i_size;
                xfs_iunlock(xip, XFS_ILOCK_EXCL);
        }
-       xfs_rwunlock(xip, locktype);
+       xfs_iunlock(xip, iolock);
  out_unlock_mutex:
        if (need_i_mutex)
                mutex_unlock(&inode->i_mutex);

diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 2022318282831cfab9d6b5bc45c9bf1b33a19701..4ed5914adefb8272ddc8b49d0b87850dba1eddec 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -45,18 +45,6 @@ static inline struct inode *vn_to_inode(bhv_vnode_t *vnode)
        return vnode;
 }
 
-/*
- * Values for the vop_rwlock/rwunlock flags parameter.
- */
-typedef enum bhv_vrwlock {
-       VRWLOCK_NONE,
-       VRWLOCK_READ,
-       VRWLOCK_WRITE,
-       VRWLOCK_WRITE_DIRECT,
-       VRWLOCK_TRY_READ,
-       VRWLOCK_TRY_WRITE
-} bhv_vrwlock_t;
-
 /*
  * Return values for xfs_inactive.  A return value of
  * VN_INACTIVE_NOCACHE implies that the file system behavior

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 1d8a4728d847c104403cbaa8117b6b2c6a8089a3..110ee83fcbec01d64fefaf96d3f6b6992fdfb860 100644 (file)
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -67,7 +67,7 @@ struct xfs_mru_cache;
  */
 
 typedef int    (*xfs_send_data_t)(int, bhv_vnode_t *,
-                       xfs_off_t, size_t, int, bhv_vrwlock_t *);
+                       xfs_off_t, size_t, int, int *);
 typedef int    (*xfs_send_mmap_t)(struct vm_area_struct *, uint);
 typedef int    (*xfs_send_destroy_t)(bhv_vnode_t *, dm_right_t);
 typedef int    (*xfs_send_namesp_t)(dm_eventtype_t, struct xfs_mount *,

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 4765e7c4b75d7155cdbfbd4077c79a22eb4674d4..811ee874d8689f4f4f3f4e2528fa4c4b7aff30a4 100644 (file)
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -3374,47 +3374,6 @@ std_return:
        goto std_return;
 }
 
-int
-xfs_rwlock(
-       xfs_inode_t     *ip,
-       bhv_vrwlock_t   locktype)
-{
-       if (S_ISDIR(ip->i_d.di_mode))
-               return 1;
-       if (locktype == VRWLOCK_WRITE) {
-               xfs_ilock(ip, XFS_IOLOCK_EXCL);
-       } else if (locktype == VRWLOCK_TRY_READ) {
-               return xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED);
-       } else if (locktype == VRWLOCK_TRY_WRITE) {
-               return xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL);
-       } else {
-               ASSERT((locktype == VRWLOCK_READ) ||
-                      (locktype == VRWLOCK_WRITE_DIRECT));
-               xfs_ilock(ip, XFS_IOLOCK_SHARED);
-       }
-
-       return 1;
-}
-
-
-void
-xfs_rwunlock(
-       xfs_inode_t     *ip,
-       bhv_vrwlock_t   locktype)
-{
-       if (S_ISDIR(ip->i_d.di_mode))
-               return;
-       if (locktype == VRWLOCK_WRITE) {
-               xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-       } else {
-               ASSERT((locktype == VRWLOCK_READ) ||
-                      (locktype == VRWLOCK_WRITE_DIRECT));
-               xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-       }
-       return;
-}
-
-
 int
 xfs_inode_flush(
        xfs_inode_t     *ip,

diff --git a/fs/xfs/xfs_vnodeops.h b/fs/xfs/xfs_vnodeops.h
index 4e3970f0e5e37f96138189aef88a305f27ee06bd..85340bafd42deec4c6b600e6fc04ac21d73e9fa6 100644 (file)
--- a/fs/xfs/xfs_vnodeops.h
+++ b/fs/xfs/xfs_vnodeops.h
@@ -38,8 +38,6 @@ int xfs_readdir(struct xfs_inode      *dp, void *dirent, size_t bufsize,
 int xfs_symlink(struct xfs_inode *dp, bhv_vname_t *dentry,
                char *target_path, mode_t mode, bhv_vnode_t **vpp,
                struct cred *credp);
-int xfs_rwlock(struct xfs_inode *ip, bhv_vrwlock_t locktype);
-void xfs_rwunlock(struct xfs_inode *ip, bhv_vrwlock_t locktype);
 int xfs_inode_flush(struct xfs_inode *ip, int flags);
 int xfs_set_dmattrs(struct xfs_inode *ip, u_int evmask, u_int16_t state);
 int xfs_reclaim(struct xfs_inode *ip);