8 files changed, 42 insertions, 16 deletions

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index b5e2913dff2d..126a4cbbb98f 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -547,8 +547,8 @@ EXPORT_SYMBOL_GPL(nfs_getattr);
 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
 {
         atomic_set(&l_ctx->count, 1);
-        l_ctx->lockowner = current->files;
-        l_ctx->pid = current->tgid;
+        l_ctx->lockowner.l_owner = current->files;
+        l_ctx->lockowner.l_pid = current->tgid;
         INIT_LIST_HEAD(&l_ctx->list);
 }
 
@@ -557,9 +557,9 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
         struct nfs_lock_context *pos;
 
         list_for_each_entry(pos, &ctx->lock_context.list, list) {
-                if (pos->lockowner != current->files)
+                if (pos->lockowner.l_owner != current->files)
                         continue;
-                if (pos->pid != current->tgid)
+                if (pos->lockowner.l_pid != current->tgid)
                         continue;
                 atomic_inc(&pos->count);
                 return pos;
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index da0618aeeadb..d95e25ec3574 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -351,7 +351,7 @@ extern void nfs41_handle_server_scope(struct nfs_client *,
 extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
 extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
 extern void nfs4_select_rw_stateid(nfs4_stateid *, struct nfs4_state *,
-                fmode_t, fl_owner_t, pid_t);
+                fmode_t, const struct nfs_lockowner *);
 
 extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
 extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index ddfebb128017..f19ea4f0f0c5 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2013,8 +2013,12 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
         nfs_fattr_init(fattr);
 
         if (state != NULL) {
+                struct nfs_lockowner lockowner = {
+                        .l_owner = current->files,
+                        .l_pid = current->tgid,
+                };
                 nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE,
-                                current->files, current->tgid);
+                                &lockowner);
         } else if (nfs4_copy_delegation_stateid(&arg.stateid, inode,
                                 FMODE_WRITE)) {
                 /* Use that stateid */
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 55148def5540..03a4e7825f3b 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -911,14 +911,22 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
 }
 
 static bool nfs4_copy_lock_stateid(nfs4_stateid *dst, struct nfs4_state *state,
-                fl_owner_t fl_owner, pid_t fl_pid)
+                const struct nfs_lockowner *lockowner)
 {
         struct nfs4_lock_state *lsp;
+        fl_owner_t fl_owner;
+        pid_t fl_pid;
         bool ret = false;
 
+
+        if (lockowner == NULL)
+                goto out;
+
         if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
                 goto out;
 
+        fl_owner = lockowner->l_owner;
+        fl_pid = lockowner->l_pid;
         spin_lock(&state->state_lock);
         lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
         if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) {
@@ -946,11 +954,11 @@ static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
  * requests.
  */
 void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
-                fmode_t fmode, fl_owner_t fl_owner, pid_t fl_pid)
+                fmode_t fmode, const struct nfs_lockowner *lockowner)
 {
         if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
                 return;
-        if (nfs4_copy_lock_stateid(dst, state, fl_owner, fl_pid))
+        if (nfs4_copy_lock_stateid(dst, state, lockowner))
                 return;
         nfs4_copy_open_stateid(dst, state);
 }
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index a756349b0fa4..7ab29abb3160 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1509,8 +1509,12 @@ static void encode_open_stateid(struct xdr_stream *xdr,
         nfs4_stateid stateid;
 
         if (ctx->state != NULL) {
+                const struct nfs_lockowner *lockowner = NULL;
+
+                if (l_ctx != NULL)
+                        lockowner = &l_ctx->lockowner;
                 nfs4_select_rw_stateid(&stateid, ctx->state,
-                                fmode, l_ctx->lockowner, l_ctx->pid);
+                                fmode, lockowner);
                 if (zero_seqid)
                         stateid.seqid = 0;
                 encode_nfs4_stateid(xdr, &stateid);
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index dfd764bd943d..e56e846e9d2d 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -292,7 +292,9 @@ static bool nfs_can_coalesce_requests(struct nfs_page *prev,
 {
         if (req->wb_context->cred != prev->wb_context->cred)
                 return false;
-        if (req->wb_lock_context->lockowner != prev->wb_lock_context->lockowner)
+        if (req->wb_lock_context->lockowner.l_owner != prev->wb_lock_context->lockowner.l_owner)
+                return false;
+        if (req->wb_lock_context->lockowner.l_pid != prev->wb_lock_context->lockowner.l_pid)
                 return false;
         if (req->wb_context->state != prev->wb_context->state)
                 return false;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index e3b55372726c..e1b5fe4d873a 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -846,6 +846,7 @@ static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
 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 nfs_page *req;
         int do_flush, status;
         /*
@@ -860,9 +861,12 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
                 req = nfs_page_find_request(page);
                 if (req == NULL)
                         return 0;
-                do_flush = req->wb_page != page || req->wb_context != ctx ||
-                        req->wb_lock_context->lockowner != current->files ||
-                        req->wb_lock_context->pid != current->tgid;
+                l_ctx = req->wb_lock_context;
+                do_flush = req->wb_page != page || req->wb_context != ctx;
+                if (l_ctx) {
+                        do_flush |= l_ctx->lockowner.l_owner != current->files
+                                || l_ctx->lockowner.l_pid != current->tgid;
+                }
                 nfs_release_request(req);
                 if (!do_flush)
                         return 0;
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 4b03f56e280e..869eac0c2635 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -81,12 +81,16 @@ struct nfs_access_entry {
         int                     mask;
 };
 
+struct nfs_lockowner {
+        fl_owner_t l_owner;
+        pid_t l_pid;
+};
+
 struct nfs_lock_context {
         atomic_t count;
         struct list_head list;
         struct nfs_open_context *open_context;
-        fl_owner_t lockowner;
-        pid_t pid;
+        struct nfs_lockowner lockowner;
 };
 
 struct nfs4_state;