NFS: Clean up helper function nfs4_select_rw_stateid()

We want to be able to pass on the information that the page was not
dirtied under a lock. Instead of adding a flag parameter, do this
by passing a pointer to a 'struct nfs_lock_owner' that may be NULL.

Also reuse this structure in struct nfs_lock_context to carry the
fl_owner_t and pid_t.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index b5e2913dff2dcf3f28a00ec03e51c61672d937ce..126a4cbbb98f5b8fc8dbd0d831f5ca88d165351f 100644 (file)
--- 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 da0618aeeadb88c04447a63b18e2d908b6d03955..d95e25ec35740744d1b33db1be3938630a9e2259 100644 (file)
--- 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 ddfebb128017a5f89740dcbb8a85f4f6d3a50bc8..f19ea4f0f0c555b4a09775696f07a5c779d8b5b9 100644 (file)
--- 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 55148def5540f325d3a13bea73aa713960ffcd1e..03a4e7825f3b00a7e04c7e2ba0a42464b2e396f2 100644 (file)
--- 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 a756349b0fa40b98a6caf2e3e7b88e23dd5787d4..7ab29abb3160d3c598e267d9c87c65ffed6e72b7 100644 (file)
--- 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 dfd764bd943d976d945388cb5c524bd177f1fc03..e56e846e9d2d61ebef728826a9125bcab61c0597 100644 (file)
--- 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 e3b55372726cb0d2a082c62ed86a35e8605c66b5..e1b5fe4d873abb50a5fb64febef2584d10d4b149 100644 (file)
--- 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 4b03f56e280eb9e59f236806ce24ce36e435c9c7..869eac0c263511d058d50b1aa1a5b3ff996528a9 100644 (file)
--- 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;