Move locks API users to locks_lock_inode_wait()

Instead of having users check for FL_POSIX or FL_FLOCK to call the correct
locks API function, use the check within locks_lock_inode_wait().  This
allows for some later cleanup.

Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jeff.layton@primarydata.com>

diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index dcd0c6d65efbcb4f475a92458b013c67a6c1d9c1..4edbf46869d47d9f586eb15d46f0506ca84a1d69 100644 (file)
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -2763,13 +2763,9 @@ ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
        rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
                        op_data, &lockh, &flock, 0, NULL /* req */, flags);
 
-       if ((file_lock->fl_flags & FL_FLOCK) &&
-           (rc == 0 || file_lock->fl_type == F_UNLCK))
-               rc2  = flock_lock_file_wait(file, file_lock);
-       if ((file_lock->fl_flags & FL_POSIX) &&
-           (rc == 0 || file_lock->fl_type == F_UNLCK) &&
+       if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
            !(flags & LDLM_FL_TEST_LOCK))
-               rc2  = posix_lock_file_wait(file, file_lock);
+               rc2  = locks_lock_file_wait(file, file_lock);
 
        if (rc2 && file_lock->fl_type != F_UNLCK) {
                einfo.ei_mode = LCK_NL;

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 3abc447783aa83cc7c5f57a57a52b9caa9063f94..f23fd86697ea5ed4234ff96a8dd236b8884e6026 100644 (file)
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -161,7 +161,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
        if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
                BUG();
 
-       res = posix_lock_file_wait(filp, fl);
+       res = locks_lock_file_wait(filp, fl);
        if (res < 0)
                goto out;
 
@@ -231,7 +231,7 @@ out_unlock:
        if (res < 0 && fl->fl_type != F_UNLCK) {
                fl_type = fl->fl_type;
                fl->fl_type = F_UNLCK;
-               res = posix_lock_file_wait(filp, fl);
+               res = locks_lock_file_wait(filp, fl);
                fl->fl_type = fl_type;
        }
 out:

diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c
index 6706bde9ad1b1e16e6a283a83ea93c4f58b6b2aa..a2cb0c254060f2bc0dd260334be910d005a3307f 100644 (file)
--- a/fs/ceph/locks.c
+++ b/fs/ceph/locks.c
@@ -228,12 +228,12 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
        err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK,
                                file, lock_cmd, wait, fl);
        if (!err) {
-               err = flock_lock_file_wait(file, fl);
+               err = locks_lock_file_wait(file, fl);
                if (err) {
                        ceph_lock_message(CEPH_LOCK_FLOCK,
                                          CEPH_MDS_OP_SETFILELOCK,
                                          file, CEPH_LOCK_UNLOCK, 0, fl);
-                       dout("got %d on flock_lock_file_wait, undid lock", err);
+                       dout("got %d on locks_lock_file_wait, undid lock", err);
                }
        }
        return err;

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index e2a6af1508af2aef789d0caab21fedfa91d49c60..6afdad7165613f64d5509a452bf2518fe66d5f10 100644 (file)
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1553,7 +1553,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
 
 out:
        if (flock->fl_flags & FL_POSIX && !rc)
-               rc = posix_lock_file_wait(file, flock);
+               rc = locks_lock_file_wait(file, flock);
        return rc;
 }
 

diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c
index 5532f097f6dac5fddbfde8030ba981fe417b6877..3585cc056fd1c86071f1cd05bb3aada6bf9df12e 100644 (file)
--- a/fs/dlm/plock.c
+++ b/fs/dlm/plock.c
@@ -172,7 +172,7 @@ int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file,
        rv = op->info.rv;
 
        if (!rv) {
-               if (posix_lock_file_wait(file, fl) < 0)
+               if (locks_lock_file_wait(file, fl) < 0)
                        log_error(ls, "dlm_posix_lock: vfs lock error %llx",
                                  (unsigned long long)number);
        }
@@ -262,7 +262,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file,
        /* cause the vfs unlock to return ENOENT if lock is not found */
        fl->fl_flags |= FL_EXISTS;
 
-       rv = posix_lock_file_wait(file, fl);
+       rv = locks_lock_file_wait(file, fl);
        if (rv == -ENOENT) {
                rv = 0;
                goto out_free;

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index f523f2f04c196db5b1201a38a6e3222ae40d1724..e0faf8f2c868a26b80331ef78c89db85091715ea 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -2189,7 +2189,7 @@ static int fuse_file_flock(struct file *file, int cmd, struct file_lock *fl)
        int err;
 
        if (fc->no_flock) {
-               err = flock_lock_file_wait(file, fl);
+               err = locks_lock_file_wait(file, fl);
        } else {
                struct fuse_file *ff = file->private_data;
 

diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index cf4ab89159f48641017b0feb57971d6e5c6a38bd..9287a2d17b8c3f6cdfe220f7f1717dc23e753a6b 100644 (file)
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -1000,7 +1000,7 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
        }
        if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
                if (fl->fl_type == F_UNLCK)
-                       posix_lock_file_wait(file, fl);
+                       locks_lock_file_wait(file, fl);
                return -EIO;
        }
        if (IS_GETLK(cmd))
@@ -1031,7 +1031,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
        if (gl) {
                if (fl_gh->gh_state == state)
                        goto out;
-               flock_lock_file_wait(file,
+               locks_lock_file_wait(file,
                                     &(struct file_lock){.fl_type = F_UNLCK});
                gfs2_glock_dq(fl_gh);
                gfs2_holder_reinit(state, flags, fl_gh);
@@ -1056,7 +1056,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
                if (error == GLR_TRYFAILED)
                        error = -EAGAIN;
        } else {
-               error = flock_lock_file_wait(file, fl);
+               error = locks_lock_file_wait(file, fl);
                gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
        }
 
@@ -1071,7 +1071,7 @@ static void do_unflock(struct file *file, struct file_lock *fl)
        struct gfs2_holder *fl_gh = &fp->f_fl_gh;
 
        mutex_lock(&fp->f_fl_mutex);
-       flock_lock_file_wait(file, fl);
+       locks_lock_file_wait(file, fl);
        if (fl_gh->gh_gl) {
                gfs2_glock_dq(fl_gh);
                gfs2_holder_uninit(fl_gh);

diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index acd3947163497b802544a632aa02512c37b88d9d..112952037933b79fa36dbea67579c576ee19be58 100644 (file)
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -474,18 +474,7 @@ static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *ho
 
 static int do_vfs_lock(struct file_lock *fl)
 {
-       int res = 0;
-       switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-               case FL_POSIX:
-                       res = posix_lock_file_wait(fl->fl_file, fl);
-                       break;
-               case FL_FLOCK:
-                       res = flock_lock_file_wait(fl->fl_file, fl);
-                       break;
-               default:
-                       BUG();
-       }
-       return res;
+       return locks_lock_file_wait(fl->fl_file, fl);
 }
 
 /*

diff --git a/fs/locks.c b/fs/locks.c
index c1745119fc5b20b6d627b93d1e48b44997eca5c9..4667f82267476356b61fffa3834f75aa7d10bd19 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1961,7 +1961,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
                                          (can_sleep) ? F_SETLKW : F_SETLK,
                                          lock);
        else
-               error = flock_lock_file_wait(f.file, lock);
+               error = locks_lock_file_wait(f.file, lock);
 
  out_free:
        locks_free_lock(lock);

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index c0f9b1ed12b9eb281909926f2befacd13db1a026..37f639d50af580396bf016a2fb40c2b427c7b1dd 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -738,18 +738,7 @@ out_noconflict:
 
 static int do_vfs_lock(struct file *file, struct file_lock *fl)
 {
-       int res = 0;
-       switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-               case FL_POSIX:
-                       res = posix_lock_file_wait(file, fl);
-                       break;
-               case FL_FLOCK:
-                       res = flock_lock_file_wait(file, fl);
-                       break;
-               default:
-                       BUG();
-       }
-       return res;
+       return locks_lock_file_wait(file, fl);
 }
 
 static int

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 693b903b48bdfb78808274e90f53971eb1f21244..ce64a45ab648ae6f0f6d4312e52551397f27a47b 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -5472,18 +5472,7 @@ static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *
 
 static int do_vfs_lock(struct inode *inode, struct file_lock *fl)
 {
-       int res = 0;
-       switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-               case FL_POSIX:
-                       res = posix_lock_inode_wait(inode, fl);
-                       break;
-               case FL_FLOCK:
-                       res = flock_lock_inode_wait(inode, fl);
-                       break;
-               default:
-                       BUG();
-       }
-       return res;
+       return locks_lock_inode_wait(inode, fl);
 }
 
 struct nfs4_unlockdata {

diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c
index 6b6d092b09985941f856671722d6db52e1fd035d..652ece4a9d9e2e90a72a95b4be1d910ea46cfc9f 100644 (file)
--- a/fs/ocfs2/locks.c
+++ b/fs/ocfs2/locks.c
@@ -66,7 +66,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode,
                 * level.
                 */
 
-               flock_lock_file_wait(file,
+               locks_lock_file_wait(file,
                                     &(struct file_lock){.fl_type = F_UNLCK});
 
                ocfs2_file_unlock(file);
@@ -81,7 +81,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode,
                goto out;
        }
 
-       ret = flock_lock_file_wait(file, fl);
+       ret = locks_lock_file_wait(file, fl);
        if (ret)
                ocfs2_file_unlock(file);
 
@@ -98,7 +98,7 @@ static int ocfs2_do_funlock(struct file *file, int cmd, struct file_lock *fl)
 
        mutex_lock(&fp->fp_mutex);
        ocfs2_file_unlock(file);
-       ret = flock_lock_file_wait(file, fl);
+       ret = locks_lock_file_wait(file, fl);
        mutex_unlock(&fp->fp_mutex);
 
        return ret;
@@ -119,7 +119,7 @@ int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl)
 
        if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) ||
            ocfs2_mount_local(osb))
-               return flock_lock_file_wait(file, fl);
+               return locks_lock_file_wait(file, fl);
 
        if (fl->fl_type == F_UNLCK)
                return ocfs2_do_funlock(file, cmd, fl);