1 files changed, 62 insertions, 47 deletions

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 39896afc6edf..1406858bae6c 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1683,6 +1683,14 @@ static void nfs_state_set_open_stateid(struct nfs4_state *state,
         write_sequnlock(&state->seqlock);
 }
 
+static void nfs_state_clear_open_state_flags(struct nfs4_state *state)
+{
+        clear_bit(NFS_O_RDWR_STATE, &state->flags);
+        clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+        clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+        clear_bit(NFS_OPEN_STATE, &state->flags);
+}
+
 static void nfs_state_set_delegation(struct nfs4_state *state,
                 const nfs4_stateid *deleg_stateid,
                 fmode_t fmode)
@@ -1907,8 +1915,9 @@ _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
         if (data->o_res.delegation_type != 0)
                 nfs4_opendata_check_deleg(data, state);
 update:
-        update_open_stateid(state, &data->o_res.stateid, NULL,
-                            data->o_arg.fmode);
+        if (!update_open_stateid(state, &data->o_res.stateid,
+                                NULL, data->o_arg.fmode))
+                return ERR_PTR(-EAGAIN);
         refcount_inc(&state->count);
 
         return state;
@@ -1973,8 +1982,11 @@ _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 
         if (data->o_res.delegation_type != 0)
                 nfs4_opendata_check_deleg(data, state);
-        update_open_stateid(state, &data->o_res.stateid, NULL,
-                        data->o_arg.fmode);
+        if (!update_open_stateid(state, &data->o_res.stateid,
+                                NULL, data->o_arg.fmode)) {
+                nfs4_put_open_state(state);
+                state = ERR_PTR(-EAGAIN);
+        }
 out:
         nfs_release_seqid(data->o_arg.seqid);
         return state;
@@ -2074,13 +2086,7 @@ static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *
 {
         int ret;
 
-        /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
-        clear_bit(NFS_O_RDWR_STATE, &state->flags);
-        clear_bit(NFS_O_WRONLY_STATE, &state->flags);
-        clear_bit(NFS_O_RDONLY_STATE, &state->flags);
         /* memory barrier prior to reading state->n_* */
-        clear_bit(NFS_DELEGATED_STATE, &state->flags);
-        clear_bit(NFS_OPEN_STATE, &state->flags);
         smp_rmb();
         ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
         if (ret != 0)
@@ -2156,6 +2162,8 @@ static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *sta
         ctx = nfs4_state_find_open_context(state);
         if (IS_ERR(ctx))
                 return -EAGAIN;
+        clear_bit(NFS_DELEGATED_STATE, &state->flags);
+        nfs_state_clear_open_state_flags(state);
         ret = nfs4_do_open_reclaim(ctx, state);
         put_nfs_open_context(ctx);
         return ret;
@@ -2171,18 +2179,17 @@ static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct
                 case -ENOENT:
                 case -EAGAIN:
                 case -ESTALE:
+                case -ETIMEDOUT:
                         break;
                 case -NFS4ERR_BADSESSION:
                 case -NFS4ERR_BADSLOT:
                 case -NFS4ERR_BAD_HIGH_SLOT:
                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
                 case -NFS4ERR_DEADSESSION:
-                        set_bit(NFS_DELEGATED_STATE, &state->flags);
                         nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
                         return -EAGAIN;
                 case -NFS4ERR_STALE_CLIENTID:
                 case -NFS4ERR_STALE_STATEID:
-                        set_bit(NFS_DELEGATED_STATE, &state->flags);
                         /* Don't recall a delegation if it was lost */
                         nfs4_schedule_lease_recovery(server->nfs_client);
                         return -EAGAIN;
@@ -2203,7 +2210,6 @@ static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct
                         return -EAGAIN;
                 case -NFS4ERR_DELAY:
                 case -NFS4ERR_GRACE:
-                        set_bit(NFS_DELEGATED_STATE, &state->flags);
                         ssleep(1);
                         return -EAGAIN;
                 case -ENOMEM:
@@ -2219,8 +2225,7 @@ static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct
 }
 
 int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
-                struct nfs4_state *state, const nfs4_stateid *stateid,
-                fmode_t type)
+                struct nfs4_state *state, const nfs4_stateid *stateid)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_opendata *opendata;
@@ -2231,20 +2236,23 @@ int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
         if (IS_ERR(opendata))
                 return PTR_ERR(opendata);
         nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
-        nfs_state_clear_delegation(state);
-        switch (type & (FMODE_READ|FMODE_WRITE)) {
-        case FMODE_READ|FMODE_WRITE:
-        case FMODE_WRITE:
+        if (!test_bit(NFS_O_RDWR_STATE, &state->flags)) {
                 err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
                 if (err)
-                        break;
+                        goto out;
+        }
+        if (!test_bit(NFS_O_WRONLY_STATE, &state->flags)) {
                 err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
                 if (err)
-                        break;
-                /* Fall through */
-        case FMODE_READ:
+                        goto out;
+        }
+        if (!test_bit(NFS_O_RDONLY_STATE, &state->flags)) {
                 err = nfs4_open_recover_helper(opendata, FMODE_READ);
+                if (err)
+                        goto out;
         }
+        nfs_state_clear_delegation(state);
+out:
         nfs4_opendata_put(opendata);
         return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);
 }
@@ -2492,6 +2500,7 @@ static int nfs4_run_open_task(struct nfs4_opendata *data,
         if (!ctx) {
                 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 1);
                 data->is_recover = true;
+                task_setup_data.flags |= RPC_TASK_TIMEOUT;
         } else {
                 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 0);
                 pnfs_lgopen_prepare(data, ctx);
@@ -2698,6 +2707,7 @@ static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
 {
         /* NFSv4.0 doesn't allow for delegation recovery on open expire */
         nfs40_clear_delegation_stateid(state);
+        nfs_state_clear_open_state_flags(state);
         return nfs4_open_expired(sp, state);
 }
 
@@ -2740,13 +2750,13 @@ out_free:
         return -NFS4ERR_EXPIRED;
 }
 
-static void nfs41_check_delegation_stateid(struct nfs4_state *state)
+static int nfs41_check_delegation_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         nfs4_stateid stateid;
         struct nfs_delegation *delegation;
         const struct cred *cred = NULL;
-        int status;
+        int status, ret = NFS_OK;
 
         /* Get the delegation credential for use by test/free_stateid */
         rcu_read_lock();
@@ -2754,20 +2764,15 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state)
         if (delegation == NULL) {
                 rcu_read_unlock();
                 nfs_state_clear_delegation(state);
-                return;
+                return NFS_OK;
         }
 
         nfs4_stateid_copy(&stateid, &delegation->stateid);
-        if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
-                rcu_read_unlock();
-                nfs_state_clear_delegation(state);
-                return;
-        }
 
         if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED,
                                 &delegation->flags)) {
                 rcu_read_unlock();
-                return;
+                return NFS_OK;
         }
 
         if (delegation->cred)
@@ -2777,9 +2782,24 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state)
         trace_nfs4_test_delegation_stateid(state, NULL, status);
         if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
                 nfs_finish_clear_delegation_stateid(state, &stateid);
+        else
+                ret = status;
 
-        if (delegation->cred)
-                put_cred(cred);
+        put_cred(cred);
+        return ret;
+}
+
+static void nfs41_delegation_recover_stateid(struct nfs4_state *state)
+{
+        nfs4_stateid tmp;
+
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) &&
+            nfs4_copy_delegation_stateid(state->inode, state->state,
+                                &tmp, NULL) &&
+            nfs4_stateid_match_other(&state->stateid, &tmp))
+                nfs_state_set_delegation(state, &tmp, state->state);
+        else
+                nfs_state_clear_delegation(state);
 }
 
 /**
@@ -2849,21 +2869,12 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
         const struct cred *cred = state->owner->so_cred;
         int status;
 
-        if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
-                if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)  {
-                        if (nfs4_have_delegation(state->inode, state->state))
-                                return NFS_OK;
-                        return -NFS4ERR_OPENMODE;
-                }
+        if (test_bit(NFS_OPEN_STATE, &state->flags) == 0)
                 return -NFS4ERR_BAD_STATEID;
-        }
         status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
         trace_nfs4_test_open_stateid(state, NULL, status);
         if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
-                clear_bit(NFS_O_RDONLY_STATE, &state->flags);
-                clear_bit(NFS_O_WRONLY_STATE, &state->flags);
-                clear_bit(NFS_O_RDWR_STATE, &state->flags);
-                clear_bit(NFS_OPEN_STATE, &state->flags);
+                nfs_state_clear_open_state_flags(state);
                 stateid->type = NFS4_INVALID_STATEID_TYPE;
                 return status;
         }
@@ -2876,7 +2887,11 @@ static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
 {
         int status;
 
-        nfs41_check_delegation_stateid(state);
+        status = nfs41_check_delegation_stateid(state);
+        if (status != NFS_OK)
+                return status;
+        nfs41_delegation_recover_stateid(state);
+
         status = nfs41_check_expired_locks(state);
         if (status != NFS_OK)
                 return status;
@@ -3201,7 +3216,7 @@ static int _nfs4_do_setattr(struct inode *inode,
 
         if (nfs4_copy_delegation_stateid(inode, FMODE_WRITE, &arg->stateid, &delegation_cred)) {
                 /* Use that stateid */
-        } else if (ctx != NULL) {
+        } else if (ctx != NULL && ctx->state) {
                 struct nfs_lock_context *l_ctx;
                 if (!nfs4_valid_open_stateid(ctx->state))
                         return -EBADF;