NFSv4: Remove obsolete state_owner and lock_owner semaphores

 OPEN, CLOSE, etc no longer need these semaphores to ensure ordering of
 requests.

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

3 files changed, 4 insertions, 35 deletions

diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 6ac6708484..d4fcb5d0ce 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -125,16 +125,11 @@ static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status
  * NFS4 state_owners and lock_owners are simply labels for ordered
  * sequences of RPC calls. Their sole purpose is to provide once-only
  * semantics by allowing the server to identify replayed requests.
- *
- * The ->so_sema is held during all state_owner seqid-mutating operations:
- * OPEN, OPEN_DOWNGRADE, and CLOSE. Its purpose is to properly serialize
- * so_seqid.
  */
 struct nfs4_state_owner {
         struct list_head     so_list;    /* per-clientid list of state_owners */
         struct nfs4_client   *so_client;
         u32                  so_id;      /* 32-bit identifier, unique */
-        struct semaphore     so_sema;
         atomic_t             so_count;
 
         struct rpc_cred      *so_cred;   /* Associated cred */
@@ -183,7 +178,6 @@ struct nfs4_state {
         struct inode *inode;            /* Pointer to the inode */
 
         unsigned long flags;            /* Do we hold any locks? */
-        struct semaphore lock_sema;     /* Serializes file locking operations */
         spinlock_t state_lock;          /* Protects the lock_states list */
 
         nfs4_stateid stateid;
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 5154ddf6d9..25bab6032d 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -224,7 +224,6 @@ static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid,
 /*
  * OPEN_RECLAIM:
  *      reclaim state on the server after a reboot.
- *      Assumes caller is holding the sp->so_sem
  */
 static int _nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
 {
@@ -322,7 +321,6 @@ static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state
         };
         int status = 0;
 
-        down(&sp->so_sema);
         if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
                 goto out;
         if (state->state == 0)
@@ -342,7 +340,6 @@ static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state
         }
         nfs_free_seqid(arg.seqid);
 out:
-        up(&sp->so_sema);
         dput(parent);
         return status;
 }
@@ -595,7 +592,6 @@ static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred
                 dprintk("%s: nfs4_get_state_owner failed!\n", __FUNCTION__);
                 goto out_err;
         }
-        down(&sp->so_sema);
         state = nfs4_get_open_state(inode, sp);
         if (state == NULL)
                 goto out_err;
@@ -620,7 +616,6 @@ static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred
         set_bit(NFS_DELEGATED_STATE, &state->flags);
         update_open_stateid(state, &delegation->stateid, open_flags);
 out_ok:
-        up(&sp->so_sema);
         nfs4_put_state_owner(sp);
         up_read(&nfsi->rwsem);
         up_read(&clp->cl_sem);
@@ -631,7 +626,6 @@ out_err:
         if (sp != NULL) {
                 if (state != NULL)
                         nfs4_put_open_state(state);
-                up(&sp->so_sema);
                 nfs4_put_state_owner(sp);
         }
         up_read(&nfsi->rwsem);
@@ -696,7 +690,6 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         } else
                 o_arg.u.attrs = sattr;
         /* Serialization for the sequence id */
-        down(&sp->so_sema);
 
         o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
         if (o_arg.seqid == NULL)
@@ -716,7 +709,6 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         if (o_res.delegation_type != 0)
                 nfs_inode_set_delegation(inode, cred, &o_res);
         nfs_free_seqid(o_arg.seqid);
-        up(&sp->so_sema);
         nfs4_put_state_owner(sp);
         up_read(&clp->cl_sem);
         *res = state;
@@ -726,7 +718,6 @@ out_err:
                 if (state != NULL)
                         nfs4_put_open_state(state);
                 nfs_free_seqid(o_arg.seqid);
-                up(&sp->so_sema);
                 nfs4_put_state_owner(sp);
         }
         /* Note: clp->cl_sem must be released before nfs4_put_open_state()! */
@@ -833,7 +824,6 @@ static void nfs4_free_closedata(struct nfs4_closedata *calldata)
 
         nfs4_put_open_state(calldata->state);
         nfs_free_seqid(calldata->arg.seqid);
-        up(&sp->so_sema);
         nfs4_put_state_owner(sp);
         up_read(&server->nfs4_state->cl_sem);
         kfree(calldata);
@@ -2702,7 +2692,6 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
 
         down_read(&clp->cl_sem);
         nlo.clientid = clp->cl_clientid;
-        down(&state->lock_sema);
         status = nfs4_set_lock_state(state, request);
         if (status != 0)
                 goto out;
@@ -2729,7 +2718,6 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
                 status = 0;
         }
 out:
-        up(&state->lock_sema);
         up_read(&clp->cl_sem);
         return status;
 }
@@ -2791,7 +2779,6 @@ static int _nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock
         int status;
                         
         down_read(&clp->cl_sem);
-        down(&state->lock_sema);
         status = nfs4_set_lock_state(state, request);
         if (status != 0)
                 goto out;
@@ -2813,7 +2800,6 @@ static int _nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock
                                 sizeof(lsp->ls_stateid.data));
         nfs_free_seqid(luargs.seqid);
 out:
-        up(&state->lock_sema);
         if (status == 0)
                 do_vfs_lock(request->fl_file, request);
         up_read(&clp->cl_sem);
@@ -2877,7 +2863,6 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
                 largs.u.open_lock = &otl;
                 largs.new_lock_owner = 1;
                 arg.u.lock = &largs;
-                down(&owner->so_sema);
                 otl.open_seqid = nfs_alloc_seqid(&owner->so_seqid);
                 if (otl.open_seqid != NULL) {
                         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
@@ -2885,7 +2870,6 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
                         nfs_increment_open_seqid(status, otl.open_seqid);
                         nfs_free_seqid(otl.open_seqid);
                 }
-                up(&owner->so_sema);
                 if (status == 0)
                         nfs_confirm_seqid(&lsp->ls_seqid, 0);
         } else {
@@ -2944,11 +2928,9 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
         int status;
 
         down_read(&clp->cl_sem);
-        down(&state->lock_sema);
         status = nfs4_set_lock_state(state, request);
         if (status == 0)
                 status = _nfs4_do_setlk(state, cmd, request, 0);
-        up(&state->lock_sema);
         if (status == 0) {
                 /* Note: we always want to sleep here! */
                 request->fl_flags |= FL_SLEEP;
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 59c93f37e1..86c08c165c 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -267,7 +267,6 @@ nfs4_alloc_state_owner(void)
         sp = kzalloc(sizeof(*sp),GFP_KERNEL);
         if (!sp)
                 return NULL;
-        init_MUTEX(&sp->so_sema);
         INIT_LIST_HEAD(&sp->so_states);
         INIT_LIST_HEAD(&sp->so_delegations);
         rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
@@ -362,7 +361,6 @@ nfs4_alloc_open_state(void)
         memset(state->stateid.data, 0, sizeof(state->stateid.data));
         atomic_set(&state->count, 1);
         INIT_LIST_HEAD(&state->lock_states);
-        init_MUTEX(&state->lock_sema);
         spin_lock_init(&state->state_lock);
         return state;
 }
@@ -444,7 +442,6 @@ nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
         state = __nfs4_find_state_byowner(inode, owner);
         if (state == NULL && new != NULL) {
                 state = new;
-                /* Caller *must* be holding owner->so_sem */
                 /* Note: The reclaim code dictates that we add stateless
                  * and read-only stateids to the end of the list */
                 list_add_tail(&state->open_states, &owner->so_states);
@@ -464,7 +461,7 @@ out:
 
 /*
  * Beware! Caller must be holding exactly one
- * reference to clp->cl_sem and owner->so_sema!
+ * reference to clp->cl_sem!
  */
 void nfs4_put_open_state(struct nfs4_state *state)
 {
@@ -485,7 +482,6 @@ void nfs4_put_open_state(struct nfs4_state *state)
 
 /*
  * Beware! Caller must be holding no references to clp->cl_sem!
- * of owner->so_sema!
  */
 void nfs4_close_state(struct nfs4_state *state, mode_t mode)
 {
@@ -496,7 +492,6 @@ void nfs4_close_state(struct nfs4_state *state, mode_t mode)
 
         atomic_inc(&owner->so_count);
         down_read(&clp->cl_sem);
-        down(&owner->so_sema);
         /* Protect against nfs4_find_state() */
         spin_lock(&inode->i_lock);
         if (mode & FMODE_READ)
@@ -527,7 +522,6 @@ void nfs4_close_state(struct nfs4_state *state, mode_t mode)
         }
 out:
         nfs4_put_open_state(state);
-        up(&owner->so_sema);
         nfs4_put_state_owner(owner);
         up_read(&clp->cl_sem);
 }
@@ -553,7 +547,6 @@ __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
  * Return a compatible lock_state. If no initialized lock_state structure
  * exists, return an uninitialized one.
  *
- * The caller must be holding state->lock_sema
  */
 static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
 {
@@ -577,7 +570,7 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
  * Return a compatible lock_state. If no initialized lock_state structure
  * exists, return an uninitialized one.
  *
- * The caller must be holding state->lock_sema and clp->cl_sem
+ * The caller must be holding clp->cl_sem
  */
 static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
 {
@@ -711,7 +704,7 @@ void nfs_free_seqid(struct nfs_seqid *seqid)
 }
 
 /*
- * Called with sp->so_sema and clp->cl_sem held.
+ * Called with clp->cl_sem held.
  *
  * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
  * failed with a seqid incrementing error -
@@ -750,7 +743,7 @@ void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
 }
 
 /*
- * Called with ls->lock_sema and clp->cl_sem held.
+ * Called with clp->cl_sem held.
  *
  * Increment the seqid if the LOCK/LOCKU succeeded, or
  * failed with a seqid incrementing error -