locks: convert posix locks to file_lock_context

Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Acked-by: Christoph Hellwig <hch@lst.de>

4 files changed, 35 insertions, 83 deletions

diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 9f9f67b17e2b..3fb1caa3874d 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -85,17 +85,17 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
 {
         struct inode *inode = state->inode;
         struct file_lock *fl;
-        struct file_lock_context *flctx;
+        struct file_lock_context *flctx = inode->i_flctx;
+        struct list_head *list;
         int status = 0;
 
-        if (inode->i_flock == NULL && inode->i_flctx == NULL)
+        if (flctx == NULL)
                 goto out;
 
-        /* Protect inode->i_flock using the i_lock */
+        list = &flctx->flc_posix;
         spin_lock(&inode->i_lock);
-        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
-                if (!(fl->fl_flags & (FL_POSIX)))
-                        continue;
+restart:
+        list_for_each_entry(fl, list, fl_list) {
                 if (nfs_file_open_context(fl->fl_file) != ctx)
                         continue;
                 spin_unlock(&inode->i_lock);
@@ -104,19 +104,9 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
                         goto out;
                 spin_lock(&inode->i_lock);
         }
-
-        flctx = inode->i_flctx;
-        if (flctx) {
-                list_for_each_entry(fl, &flctx->flc_flock, fl_list) {
-                        if (nfs_file_open_context(fl->fl_file) != ctx)
-                                continue;
-                        spin_unlock(&inode->i_lock);
-                        status = nfs4_lock_delegation_recall(fl, state,
-                                                                stateid);
-                        if (status < 0)
-                                goto out;
-                        spin_lock(&inode->i_lock);
-                }
+        if (list == &flctx->flc_posix) {
+                list = &flctx->flc_flock;
+                goto restart;
         }
         spin_unlock(&inode->i_lock);
 out:
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 65c404bf61ae..6084c267f3a0 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1367,53 +1367,18 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
         struct file_lock *fl;
         int status = 0;
         struct file_lock_context *flctx = inode->i_flctx;
+        struct list_head *list;
 
-        if (inode->i_flock == NULL && flctx == NULL)
+        if (flctx == NULL)
                 return 0;
 
+        list = &flctx->flc_posix;
+
         /* Guard against delegation returns and new lock/unlock calls */
         down_write(&nfsi->rwsem);
-        /* Protect inode->i_flock using the BKL */
         spin_lock(&inode->i_lock);
-        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
-                if (!(fl->fl_flags & FL_POSIX))
-                        continue;
-                if (nfs_file_open_context(fl->fl_file)->state != state)
-                        continue;
-                spin_unlock(&inode->i_lock);
-                status = ops->recover_lock(state, fl);
-                switch (status) {
-                        case 0:
-                                break;
-                        case -ESTALE:
-                        case -NFS4ERR_ADMIN_REVOKED:
-                        case -NFS4ERR_STALE_STATEID:
-                        case -NFS4ERR_BAD_STATEID:
-                        case -NFS4ERR_EXPIRED:
-                        case -NFS4ERR_NO_GRACE:
-                        case -NFS4ERR_STALE_CLIENTID:
-                        case -NFS4ERR_BADSESSION:
-                        case -NFS4ERR_BADSLOT:
-                        case -NFS4ERR_BAD_HIGH_SLOT:
-                        case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
-                                goto out;
-                        default:
-                                printk(KERN_ERR "NFS: %s: unhandled error %d\n",
-                                         __func__, status);
-                        case -ENOMEM:
-                        case -NFS4ERR_DENIED:
-                        case -NFS4ERR_RECLAIM_BAD:
-                        case -NFS4ERR_RECLAIM_CONFLICT:
-                                /* kill_proc(fl->fl_pid, SIGLOST, 1); */
-                                status = 0;
-                }
-                spin_lock(&inode->i_lock);
-        }
-
-        if (!flctx)
-                goto out_unlock;
-
-        list_for_each_entry(fl, &flctx->flc_flock, fl_list) {
+restart:
+        list_for_each_entry(fl, list, fl_list) {
                 if (nfs_file_open_context(fl->fl_file)->state != state)
                         continue;
                 spin_unlock(&inode->i_lock);
@@ -1445,7 +1410,10 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
                 }
                 spin_lock(&inode->i_lock);
         }
-out_unlock:
+        if (list == &flctx->flc_posix) {
+                list = &flctx->flc_flock;
+                goto restart;
+        }
         spin_unlock(&inode->i_lock);
 out:
         up_write(&nfsi->rwsem);
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index a3b62e15b444..29c7f33c9cf1 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -831,12 +831,10 @@ static bool nfs_can_coalesce_requests(struct nfs_page *prev,
         if (prev) {
                 if (!nfs_match_open_context(req->wb_context, prev->wb_context))
                         return false;
-                if (req->wb_context->dentry->d_inode->i_flock != NULL &&
-                    !nfs_match_lock_context(req->wb_lock_context,
-                                            prev->wb_lock_context))
-                        return false;
                 flctx = req->wb_context->dentry->d_inode->i_flctx;
-                if (flctx != NULL && !list_empty_careful(&flctx->flc_flock) &&
+                if (flctx != NULL &&
+                    !(list_empty_careful(&flctx->flc_posix) &&
+                      list_empty_careful(&flctx->flc_flock)) &&
                     !nfs_match_lock_context(req->wb_lock_context,
                                             prev->wb_lock_context))
                         return false;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index e072aeb34195..784c13485b3f 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1091,6 +1091,7 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
 {
         struct nfs_open_context *ctx = nfs_file_open_context(file);
         struct nfs_lock_context *l_ctx;
+        struct file_lock_context *flctx = file_inode(file)->i_flctx;
         struct nfs_page *req;
         int do_flush, status;
         /*
@@ -1109,12 +1110,9 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
                 do_flush = req->wb_page != page || req->wb_context != ctx;
                 /* for now, flush if more than 1 request in page_group */
                 do_flush |= req->wb_this_page != req;
-                if (l_ctx && ctx->dentry->d_inode->i_flock != NULL) {
-                        do_flush |= l_ctx->lockowner.l_owner != current->files
-                                || l_ctx->lockowner.l_pid != current->tgid;
-                }
-                if (l_ctx && ctx->dentry->d_inode->i_flctx &&
-                    !list_empty_careful(&ctx->dentry->d_inode->i_flctx->flc_flock)) {
+                if (l_ctx && flctx &&
+                    !(list_empty_careful(&flctx->flc_posix) &&
+                      list_empty_careful(&flctx->flc_flock))) {
                         do_flush |= l_ctx->lockowner.l_owner != current->files
                                 || l_ctx->lockowner.l_pid != current->tgid;
                 }
@@ -1202,26 +1200,24 @@ static int nfs_can_extend_write(struct file *file, struct page *page, struct ino
                 return 0;
         if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
                 return 1;
-        if (!inode->i_flock && !flctx)
+        if (!flctx || (list_empty_careful(&flctx->flc_flock) &&
+                       list_empty_careful(&flctx->flc_posix)))
                 return 0;
 
         /* Check to see if there are whole file write locks */
-        spin_lock(&inode->i_lock);
         ret = 0;
-
-        fl = inode->i_flock;
-        if (fl && is_whole_file_wrlock(fl)) {
-                ret = 1;
-                goto out;
-        }
-
-        if (!list_empty(&flctx->flc_flock)) {
+        spin_lock(&inode->i_lock);
+        if (!list_empty(&flctx->flc_posix)) {
+                fl = list_first_entry(&flctx->flc_posix, struct file_lock,
+                                        fl_list);
+                if (is_whole_file_wrlock(fl))
+                        ret = 1;
+        } else if (!list_empty(&flctx->flc_flock)) {
                 fl = list_first_entry(&flctx->flc_flock, struct file_lock,
                                         fl_list);
                 if (fl->fl_type == F_WRLCK)
                         ret = 1;
         }
-out:
         spin_unlock(&inode->i_lock);
         return ret;
 }