NFSv4: Add functions to order RPC calls

 NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
 labelled with "sequence identifiers" in order to prevent the server from
 reordering RPC requests, as this could cause its file state to
 become out of sync with the client.

 Currently the NFS client code enforces this ordering locally using
 semaphores to restrict access to structures until the RPC call is done.
 This, of course, only works with synchronous RPC calls, since the
 user process must first grab the semaphore.
 By dropping semaphores, and instead teaching the RPC engine to hold
 the RPC calls until they are ready to be sent, we can extend this
 process to work nicely with asynchronous RPC calls too.

 This patch adds a new list called "rpc_sequence" that defines the order
 of the RPC calls to be sent. We add one such list for each state_owner.
 When an RPC call is ready to be sent, it checks if it is top of the
 rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
 and loops until it hits top of the list.
 Once the RPC call has completed, it can then bump the sequence id counter,
 and remove itself from the rpc_sequence list, and then wake up the next
 sleeper.

 Note that the state_owner sequence ids and lock_owner sequence ids are
 all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
 are all ordered w.r.t. each other.

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

4 files changed, 265 insertions, 76 deletions

diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index ec1a22d7b876..6ac6708484f5 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -93,6 +93,35 @@ struct nfs4_client {
 };
 
 /*
+ * struct rpc_sequence ensures that RPC calls are sent in the exact
+ * order that they appear on the list.
+ */
+struct rpc_sequence {
+        struct rpc_wait_queue   wait;   /* RPC call delay queue */
+        spinlock_t lock;                /* Protects the list */
+        struct list_head list;          /* Defines sequence of RPC calls */
+};
+
+#define NFS_SEQID_CONFIRMED 1
+struct nfs_seqid_counter {
+        struct rpc_sequence *sequence;
+        int flags;
+        u32 counter;
+};
+
+struct nfs_seqid {
+        struct list_head list;
+        struct nfs_seqid_counter *sequence;
+        struct rpc_task *task;
+};
+
+static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status)
+{
+        if (seqid_mutating_err(-status))
+                seqid->flags |= NFS_SEQID_CONFIRMED;
+}
+
+/*
  * 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.
@@ -106,12 +135,13 @@ struct nfs4_state_owner {
         struct nfs4_client   *so_client;
         u32                  so_id;      /* 32-bit identifier, unique */
         struct semaphore     so_sema;
-        u32                  so_seqid;   /* protected by so_sema */
         atomic_t             so_count;
 
         struct rpc_cred      *so_cred;   /* Associated cred */
         struct list_head     so_states;
         struct list_head     so_delegations;
+        struct nfs_seqid_counter so_seqid;
+        struct rpc_sequence  so_sequence;
 };
 
 /*
@@ -132,7 +162,7 @@ struct nfs4_lock_state {
         fl_owner_t              ls_owner;       /* POSIX lock owner */
 #define NFS_LOCK_INITIALIZED 1
         int                     ls_flags;
-        u32                     ls_seqid;
+        struct nfs_seqid_counter        ls_seqid;
         u32                     ls_id;
         nfs4_stateid            ls_stateid;
         atomic_t                ls_count;
@@ -224,12 +254,16 @@ extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state
 extern void nfs4_put_open_state(struct nfs4_state *);
 extern void nfs4_close_state(struct nfs4_state *, mode_t);
 extern struct nfs4_state *nfs4_find_state(struct inode *, struct rpc_cred *, mode_t mode);
-extern void nfs4_increment_seqid(int status, struct nfs4_state_owner *sp);
 extern void nfs4_schedule_state_recovery(struct nfs4_client *);
 extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
-extern void nfs4_increment_lock_seqid(int status, struct nfs4_lock_state *ls);
 extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);
 
+extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter);
+extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
+extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
+extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
+extern void nfs_free_seqid(struct nfs_seqid *seqid);
+
 extern const nfs4_stateid zero_stateid;
 
 /* nfs4xdr.c */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 9701ca8c9428..9ba89e7cdd28 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -218,7 +218,6 @@ static int _nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *st
         struct nfs_delegation *delegation = NFS_I(inode)->delegation;
         struct nfs_openargs o_arg = {
                 .fh = NFS_FH(inode),
-                .seqid = sp->so_seqid,
                 .id = sp->so_id,
                 .open_flags = state->state,
                 .clientid = server->nfs4_state->cl_clientid,
@@ -245,8 +244,13 @@ static int _nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *st
                 }
                 o_arg.u.delegation_type = delegation->type;
         }
+        o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
+        if (o_arg.seqid == NULL)
+                return -ENOMEM;
         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-        nfs4_increment_seqid(status, sp);
+        /* Confirm the sequence as being established */
+        nfs_confirm_seqid(&sp->so_seqid, status);
+        nfs_increment_open_seqid(status, o_arg.seqid);
         if (status == 0) {
                 memcpy(&state->stateid, &o_res.stateid, sizeof(state->stateid));
                 if (o_res.delegation_type != 0) {
@@ -256,6 +260,7 @@ static int _nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *st
                                 nfs_async_inode_return_delegation(inode, &o_res.stateid);
                 }
         }
+        nfs_free_seqid(o_arg.seqid);
         clear_bit(NFS_DELEGATED_STATE, &state->flags);
         /* Ensure we update the inode attributes */
         NFS_CACHEINV(inode);
@@ -307,16 +312,20 @@ static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state
                 goto out;
         if (state->state == 0)
                 goto out;
-        arg.seqid = sp->so_seqid;
+        arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
+        status = -ENOMEM;
+        if (arg.seqid == NULL)
+                goto out;
         arg.open_flags = state->state;
         memcpy(arg.u.delegation.data, state->stateid.data, sizeof(arg.u.delegation.data));
         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-        nfs4_increment_seqid(status, sp);
+        nfs_increment_open_seqid(status, arg.seqid);
         if (status >= 0) {
                 memcpy(state->stateid.data, res.stateid.data,
                                 sizeof(state->stateid.data));
                 clear_bit(NFS_DELEGATED_STATE, &state->flags);
         }
+        nfs_free_seqid(arg.seqid);
 out:
         up(&sp->so_sema);
         dput(parent);
@@ -345,11 +354,11 @@ int nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
         return err;
 }
 
-static inline int _nfs4_proc_open_confirm(struct rpc_clnt *clnt, const struct nfs_fh *fh, struct nfs4_state_owner *sp, nfs4_stateid *stateid)
+static inline int _nfs4_proc_open_confirm(struct rpc_clnt *clnt, const struct nfs_fh *fh, struct nfs4_state_owner *sp, nfs4_stateid *stateid, struct nfs_seqid *seqid)
 {
         struct nfs_open_confirmargs arg = {
                 .fh             = fh,
-                .seqid          = sp->so_seqid,
+                .seqid          = seqid,
                 .stateid        = *stateid,
         };
         struct nfs_open_confirmres res;
@@ -362,7 +371,9 @@ static inline int _nfs4_proc_open_confirm(struct rpc_clnt *clnt, const struct nf
         int status;
 
         status = rpc_call_sync(clnt, &msg, RPC_TASK_NOINTR);
-        nfs4_increment_seqid(status, sp);
+        /* Confirm the sequence as being established */
+        nfs_confirm_seqid(&sp->so_seqid, status);
+        nfs_increment_open_seqid(status, seqid);
         if (status >= 0)
                 memcpy(stateid, &res.stateid, sizeof(*stateid));
         return status;
@@ -380,21 +391,21 @@ static int _nfs4_proc_open(struct inode *dir, struct nfs4_state_owner  *sp, stru
         int status;
 
         /* Update sequence id. The caller must serialize! */
-        o_arg->seqid = sp->so_seqid;
         o_arg->id = sp->so_id;
         o_arg->clientid = sp->so_client->cl_clientid;
 
         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-        nfs4_increment_seqid(status, sp);
+        nfs_increment_open_seqid(status, o_arg->seqid);
         if (status != 0)
                 goto out;
         update_changeattr(dir, &o_res->cinfo);
         if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
                 status = _nfs4_proc_open_confirm(server->client, &o_res->fh,
-                                sp, &o_res->stateid);
+                                sp, &o_res->stateid, o_arg->seqid);
                 if (status != 0)
                         goto out;
         }
+        nfs_confirm_seqid(&sp->so_seqid, 0);
         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
                 status = server->rpc_ops->getattr(server, &o_res->fh, o_res->f_attr);
 out:
@@ -465,6 +476,10 @@ static int _nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
                 set_bit(NFS_DELEGATED_STATE, &state->flags);
                 goto out;
         }
+        o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
+        status = -ENOMEM;
+        if (o_arg.seqid == NULL)
+                goto out;
         status = _nfs4_proc_open(dir, sp, &o_arg, &o_res);
         if (status != 0)
                 goto out_nodeleg;
@@ -490,6 +505,7 @@ static int _nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
                         nfs_inode_reclaim_delegation(inode, sp->so_cred, &o_res);
         }
 out_nodeleg:
+        nfs_free_seqid(o_arg.seqid);
         clear_bit(NFS_DELEGATED_STATE, &state->flags);
 out:
         dput(parent);
@@ -667,6 +683,9 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         /* Serialization for the sequence id */
         down(&sp->so_sema);
 
+        o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
+        if (o_arg.seqid == NULL)
+                return -ENOMEM;
         status = _nfs4_proc_open(dir, sp, &o_arg, &o_res);
         if (status != 0)
                 goto out_err;
@@ -681,6 +700,7 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         update_open_stateid(state, &o_res.stateid, flags);
         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);
@@ -690,6 +710,7 @@ out_err:
         if (sp != NULL) {
                 if (state != NULL)
                         nfs4_put_open_state(state);
+                nfs_free_seqid(o_arg.seqid);
                 up(&sp->so_sema);
                 nfs4_put_state_owner(sp);
         }
@@ -718,7 +739,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry,
                  * It is actually a sign of a bug on the client or on the server.
                  *
                  * If we receive a BAD_SEQID error in the particular case of
-                 * doing an OPEN, we assume that nfs4_increment_seqid() will
+                 * doing an OPEN, we assume that nfs_increment_open_seqid() will
                  * have unhashed the old state_owner for us, and that we can
                  * therefore safely retry using a new one. We should still warn
                  * the user though...
@@ -799,7 +820,7 @@ static void nfs4_close_done(struct rpc_task *task)
         /* hmm. we are done with the inode, and in the process of freeing
          * the state_owner. we keep this around to process errors
          */
-        nfs4_increment_seqid(task->tk_status, sp);
+        nfs_increment_open_seqid(task->tk_status, calldata->arg.seqid);
         switch (task->tk_status) {
                 case 0:
                         memcpy(&state->stateid, &calldata->res.stateid,
@@ -818,6 +839,7 @@ static void nfs4_close_done(struct rpc_task *task)
         }
         state->state = calldata->arg.open_flags;
         nfs4_put_open_state(state);
+        nfs_free_seqid(calldata->arg.seqid);
         up(&sp->so_sema);
         nfs4_put_state_owner(sp);
         up_read(&server->nfs4_state->cl_sem);
@@ -865,7 +887,11 @@ int nfs4_do_close(struct inode *inode, struct nfs4_state *state, mode_t mode)
         calldata->state = state;
         calldata->arg.fh = NFS_FH(inode);
         /* Serialization for the sequence id */
-        calldata->arg.seqid = state->owner->so_seqid;
+        calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
+        if (calldata->arg.seqid == NULL) {
+                kfree(calldata);
+                return -ENOMEM;
+        }
         calldata->arg.open_flags = mode;
         memcpy(&calldata->arg.stateid, &state->stateid,
                         sizeof(calldata->arg.stateid));
@@ -2729,15 +2755,19 @@ static int _nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock
         /* We might have lost the locks! */
         if ((lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0)
                 goto out;
-        luargs.seqid = lsp->ls_seqid;
-        memcpy(&luargs.stateid, &lsp->ls_stateid, sizeof(luargs.stateid));
+        luargs.seqid = nfs_alloc_seqid(&lsp->ls_seqid);
+        status = -ENOMEM;
+        if (luargs.seqid == NULL)
+                goto out;
+        memcpy(luargs.stateid.data, lsp->ls_stateid.data, sizeof(luargs.stateid.data));
         arg.u.locku = &luargs;
         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-        nfs4_increment_lock_seqid(status, lsp);
+        nfs_increment_lock_seqid(status, luargs.seqid);
 
         if (status == 0)
-                memcpy(&lsp->ls_stateid,  &res.u.stateid, 
-                                sizeof(lsp->ls_stateid));
+                memcpy(lsp->ls_stateid.data, res.u.stateid.data, 
+                                sizeof(lsp->ls_stateid.data));
+        nfs_free_seqid(luargs.seqid);
 out:
         up(&state->lock_sema);
         if (status == 0)
@@ -2783,9 +2813,13 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
                 .reclaim = reclaim,
                 .new_lock_owner = 0,
         };
-        int status;
+        struct nfs_seqid *lock_seqid;
+        int status = -ENOMEM;
 
-        if (!(lsp->ls_flags & NFS_LOCK_INITIALIZED)) {
+        lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
+        if (lock_seqid == NULL)
+                return -ENOMEM;
+        if (!(lsp->ls_seqid.flags & NFS_SEQID_CONFIRMED)) {
                 struct nfs4_state_owner *owner = state->owner;
                 struct nfs_open_to_lock otl = {
                         .lock_owner = {
@@ -2793,39 +2827,40 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
                         },
                 };
 
-                otl.lock_seqid = lsp->ls_seqid;
+                otl.lock_seqid = lock_seqid;
                 otl.lock_owner.id = lsp->ls_id;
                 memcpy(&otl.open_stateid, &state->stateid, sizeof(otl.open_stateid));
                 largs.u.open_lock = &otl;
                 largs.new_lock_owner = 1;
                 arg.u.lock = &largs;
                 down(&owner->so_sema);
-                otl.open_seqid = owner->so_seqid;
-                status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-                /* increment open_owner seqid on success, and 
-                * seqid mutating errors */
-                nfs4_increment_seqid(status, owner);
-                up(&owner->so_sema);
-                if (status == 0) {
-                        lsp->ls_flags |= NFS_LOCK_INITIALIZED;
-                        lsp->ls_seqid++;
+                otl.open_seqid = nfs_alloc_seqid(&owner->so_seqid);
+                if (otl.open_seqid != NULL) {
+                        status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
+                        /* increment seqid on success, and seqid mutating errors */
+                        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 {
-                struct nfs_exist_lock el = {
-                        .seqid = lsp->ls_seqid,
-                };
+                struct nfs_exist_lock el;
                 memcpy(&el.stateid, &lsp->ls_stateid, sizeof(el.stateid));
                 largs.u.exist_lock = ⪙
                 arg.u.lock = &largs;
+                el.seqid = lock_seqid;
                 status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
-                /* increment seqid on success, and * seqid mutating errors*/
-                nfs4_increment_lock_seqid(status, lsp);
         }
+        /* increment seqid on success, and seqid mutating errors*/
+        nfs_increment_lock_seqid(status, lock_seqid);
         /* save the returned stateid. */
-        if (status == 0)
-                memcpy(&lsp->ls_stateid, &res.u.stateid, sizeof(nfs4_stateid));
-        else if (status == -NFS4ERR_DENIED)
+        if (status == 0) {
+                memcpy(lsp->ls_stateid.data, res.u.stateid.data, sizeof(lsp->ls_stateid.data));
+                lsp->ls_flags |= NFS_LOCK_INITIALIZED;
+        } else if (status == -NFS4ERR_DENIED)
                 status = -EAGAIN;
+        nfs_free_seqid(lock_seqid);
         return status;
 }
 
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index afe587d82f1e..f535c219cf3a 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -264,13 +264,16 @@ nfs4_alloc_state_owner(void)
 {
         struct nfs4_state_owner *sp;
 
-        sp = kmalloc(sizeof(*sp),GFP_KERNEL);
+        sp = kzalloc(sizeof(*sp),GFP_KERNEL);
         if (!sp)
                 return NULL;
         init_MUTEX(&sp->so_sema);
-        sp->so_seqid = 0;                 /* arbitrary */
         INIT_LIST_HEAD(&sp->so_states);
         INIT_LIST_HEAD(&sp->so_delegations);
+        rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
+        sp->so_seqid.sequence = &sp->so_sequence;
+        spin_lock_init(&sp->so_sequence.lock);
+        INIT_LIST_HEAD(&sp->so_sequence.list);
         atomic_set(&sp->so_count, 1);
         return sp;
 }
@@ -553,12 +556,10 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
         struct nfs4_lock_state *lsp;
         struct nfs4_client *clp = state->owner->so_client;
 
-        lsp = kmalloc(sizeof(*lsp), GFP_KERNEL);
+        lsp = kzalloc(sizeof(*lsp), GFP_KERNEL);
         if (lsp == NULL)
                 return NULL;
-        lsp->ls_flags = 0;
-        lsp->ls_seqid = 0;      /* arbitrary */
-        memset(lsp->ls_stateid.data, 0, sizeof(lsp->ls_stateid.data));
+        lsp->ls_seqid.sequence = &state->owner->so_sequence;
         atomic_set(&lsp->ls_count, 1);
         lsp->ls_owner = fl_owner;
         spin_lock(&clp->cl_lock);
@@ -673,29 +674,102 @@ void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t f
         nfs4_put_lock_state(lsp);
 }
 
-/*
-* Called with state->lock_sema and clp->cl_sem held.
-*/
-void nfs4_increment_lock_seqid(int status, struct nfs4_lock_state *lsp)
+struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter)
+{
+        struct rpc_sequence *sequence = counter->sequence;
+        struct nfs_seqid *new;
+
+        new = kmalloc(sizeof(*new), GFP_KERNEL);
+        if (new != NULL) {
+                new->sequence = counter;
+                new->task = NULL;
+                spin_lock(&sequence->lock);
+                list_add_tail(&new->list, &sequence->list);
+                spin_unlock(&sequence->lock);
+        }
+        return new;
+}
+
+void nfs_free_seqid(struct nfs_seqid *seqid)
 {
-        if (status == NFS_OK || seqid_mutating_err(-status))
-                lsp->ls_seqid++;
+        struct rpc_sequence *sequence = seqid->sequence->sequence;
+        struct rpc_task *next = NULL;
+
+        spin_lock(&sequence->lock);
+        list_del(&seqid->list);
+        if (!list_empty(&sequence->list)) {
+                next = list_entry(sequence->list.next, struct nfs_seqid, list)->task;
+                if (next)
+                        rpc_wake_up_task(next);
+        }
+        spin_unlock(&sequence->lock);
+        kfree(seqid);
 }
 
 /*
-* Called with sp->so_sema and clp->cl_sem held.
-*
-* Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
-* failed with a seqid incrementing error -
-* see comments nfs_fs.h:seqid_mutating_error()
-*/
-void nfs4_increment_seqid(int status, struct nfs4_state_owner *sp)
-{
-        if (status == NFS_OK || seqid_mutating_err(-status))
-                sp->so_seqid++;
-        /* If the server returns BAD_SEQID, unhash state_owner here */
-        if (status == -NFS4ERR_BAD_SEQID)
+ * Called with sp->so_sema and clp->cl_sem held.
+ *
+ * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
+ * failed with a seqid incrementing error -
+ * see comments nfs_fs.h:seqid_mutating_error()
+ */
+static inline void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
+{
+        switch (status) {
+                case 0:
+                        break;
+                case -NFS4ERR_BAD_SEQID:
+                case -NFS4ERR_STALE_CLIENTID:
+                case -NFS4ERR_STALE_STATEID:
+                case -NFS4ERR_BAD_STATEID:
+                case -NFS4ERR_BADXDR:
+                case -NFS4ERR_RESOURCE:
+                case -NFS4ERR_NOFILEHANDLE:
+                        /* Non-seqid mutating errors */
+                        return;
+        };
+        /*
+         * Note: no locking needed as we are guaranteed to be first
+         * on the sequence list
+         */
+        seqid->sequence->counter++;
+}
+
+void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
+{
+        if (status == -NFS4ERR_BAD_SEQID) {
+                struct nfs4_state_owner *sp = container_of(seqid->sequence,
+                                struct nfs4_state_owner, so_seqid);
                 nfs4_drop_state_owner(sp);
+        }
+        return nfs_increment_seqid(status, seqid);
+}
+
+/*
+ * Called with ls->lock_sema and clp->cl_sem held.
+ *
+ * Increment the seqid if the LOCK/LOCKU succeeded, or
+ * failed with a seqid incrementing error -
+ * see comments nfs_fs.h:seqid_mutating_error()
+ */
+void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
+{
+        return nfs_increment_seqid(status, seqid);
+}
+
+int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
+{
+        struct rpc_sequence *sequence = seqid->sequence->sequence;
+        int status = 0;
+
+        spin_lock(&sequence->lock);
+        if (sequence->list.next != &seqid->list) {
+                seqid->task = task;
+                rpc_sleep_on(&sequence->wait, task, NULL, NULL);
+                status = -EAGAIN;
+        }
+        spin_unlock(&sequence->lock);
+        return status;
 }
 
 static int reclaimer(void *);
@@ -791,8 +865,6 @@ static int nfs4_reclaim_open_state(struct nfs4_state_recovery_ops *ops, struct n
                 if (state->state == 0)
                         continue;
                 status = ops->recover_open(sp, state);
-                list_for_each_entry(lock, &state->lock_states, ls_locks)
-                        lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
                 if (status >= 0) {
                         status = nfs4_reclaim_locks(ops, state);
                         if (status < 0)
@@ -831,6 +903,26 @@ out_err:
         return status;
 }
 
+static void nfs4_state_mark_reclaim(struct nfs4_client *clp)
+{
+        struct nfs4_state_owner *sp;
+        struct nfs4_state *state;
+        struct nfs4_lock_state *lock;
+
+        /* Reset all sequence ids to zero */
+        list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
+                sp->so_seqid.counter = 0;
+                sp->so_seqid.flags = 0;
+                list_for_each_entry(state, &sp->so_states, open_states) {
+                        list_for_each_entry(lock, &state->lock_states, ls_locks) {
+                                lock->ls_seqid.counter = 0;
+                                lock->ls_seqid.flags = 0;
+                                lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
+                        }
+                }
+        }
+}
+
 static int reclaimer(void *ptr)
 {
         struct reclaimer_args *args = (struct reclaimer_args *)ptr;
@@ -864,6 +956,7 @@ restart_loop:
                 default:
                         ops = &nfs4_network_partition_recovery_ops;
         };
+        nfs4_state_mark_reclaim(clp);
         status = __nfs4_init_client(clp);
         if (status)
                 goto out_error;
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 6c564ef9489e..fcd28a29a2f8 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -604,7 +604,7 @@ static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
 
         RESERVE_SPACE(8+sizeof(arg->stateid.data));
         WRITE32(OP_CLOSE);
-        WRITE32(arg->seqid);
+        WRITE32(arg->seqid->sequence->counter);
         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
         
         return 0;
@@ -732,9 +732,9 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
                 struct nfs_open_to_lock *ol = opargs->u.open_lock;
 
                 RESERVE_SPACE(40);
-                WRITE32(ol->open_seqid);
+                WRITE32(ol->open_seqid->sequence->counter);
                 WRITEMEM(&ol->open_stateid, sizeof(ol->open_stateid));
-                WRITE32(ol->lock_seqid);
+                WRITE32(ol->lock_seqid->sequence->counter);
                 WRITE64(ol->lock_owner.clientid);
                 WRITE32(4);
                 WRITE32(ol->lock_owner.id);
@@ -744,7 +744,7 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
 
                 RESERVE_SPACE(20);
                 WRITEMEM(&el->stateid, sizeof(el->stateid));
-                WRITE32(el->seqid);
+                WRITE32(el->seqid->sequence->counter);
         }
 
         return 0;
@@ -775,7 +775,7 @@ static int encode_locku(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
         RESERVE_SPACE(44);
         WRITE32(OP_LOCKU);
         WRITE32(arg->type);
-        WRITE32(opargs->seqid);
+        WRITE32(opargs->seqid->sequence->counter);
         WRITEMEM(&opargs->stateid, sizeof(opargs->stateid));
         WRITE64(arg->offset);
         WRITE64(arg->length);
@@ -826,7 +826,7 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena
  */
         RESERVE_SPACE(8);
         WRITE32(OP_OPEN);
-        WRITE32(arg->seqid);
+        WRITE32(arg->seqid->sequence->counter);
         encode_share_access(xdr, arg->open_flags);
         RESERVE_SPACE(16);
         WRITE64(arg->clientid);
@@ -941,7 +941,7 @@ static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_con
         RESERVE_SPACE(8+sizeof(arg->stateid.data));
         WRITE32(OP_OPEN_CONFIRM);
         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
-        WRITE32(arg->seqid);
+        WRITE32(arg->seqid->sequence->counter);
 
         return 0;
 }
@@ -953,7 +953,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea
         RESERVE_SPACE(8+sizeof(arg->stateid.data));
         WRITE32(OP_OPEN_DOWNGRADE);
         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
-        WRITE32(arg->seqid);
+        WRITE32(arg->seqid->sequence->counter);
         encode_share_access(xdr, arg->open_flags);
         return 0;
 }
@@ -1416,6 +1416,9 @@ static int nfs4_xdr_enc_close(struct rpc_rqst *req, uint32_t *p, struct nfs_clos
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1437,6 +1440,9 @@ static int nfs4_xdr_enc_open(struct rpc_rqst *req, uint32_t *p, struct nfs_opena
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1464,6 +1470,9 @@ static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, uint32_t *p, struct n
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1485,6 +1494,9 @@ static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, uint32_t *p, struct nf
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1506,6 +1518,9 @@ static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, uint32_t *p, struct
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1525,8 +1540,17 @@ static int nfs4_xdr_enc_lock(struct rpc_rqst *req, uint32_t *p, struct nfs_locka
         struct compound_hdr hdr = {
                 .nops   = 2,
         };
+        struct nfs_lock_opargs *opargs = args->u.lock;
+        struct nfs_seqid *seqid;
         int status;
 
+        if (opargs->new_lock_owner)
+                seqid = opargs->u.open_lock->lock_seqid;
+        else
+                seqid = opargs->u.exist_lock->seqid;
+        status = nfs_wait_on_sequence(seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1569,6 +1593,9 @@ static int nfs4_xdr_enc_locku(struct rpc_rqst *req, uint32_t *p, struct nfs_lock
         };
         int status;
 
+        status = nfs_wait_on_sequence(args->u.locku->seqid, req->rq_task);
+        if (status != 0)
+                goto out;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);