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);