1 files changed, 22 insertions, 31 deletions

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 8f029db5d271..5e0dc528a0e8 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -177,7 +177,7 @@ fh_dup2(struct svc_fh *dst, struct svc_fh *src)
         fh_put(dst);
         dget(src->fh_dentry);
         if (src->fh_export)
-                cache_get(&src->fh_export->h);
+                exp_get(src->fh_export);
         *dst = *src;
 }
 
@@ -385,8 +385,6 @@ nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         if (nfsd4_has_session(cstate))
                 copy_clientid(&open->op_clientid, cstate->session);
 
-        nfs4_lock_state();
-
         /* check seqid for replay. set nfs4_owner */
         resp = rqstp->rq_resp;
         status = nfsd4_process_open1(&resp->cstate, open, nn);
@@ -431,8 +429,7 @@ nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                         break;
                 case NFS4_OPEN_CLAIM_PREVIOUS:
                         status = nfs4_check_open_reclaim(&open->op_clientid,
-                                                         cstate->minorversion,
-                                                         nn);
+                                                         cstate, nn);
                         if (status)
                                 goto out;
                         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
@@ -461,19 +458,17 @@ nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
          * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
          */
         status = nfsd4_process_open2(rqstp, resfh, open);
-        WARN_ON(status && open->op_created);
+        WARN(status && open->op_created,
+             "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
+             be32_to_cpu(status));
 out:
         if (resfh && resfh != &cstate->current_fh) {
                 fh_dup2(&cstate->current_fh, resfh);
                 fh_put(resfh);
                 kfree(resfh);
         }
-        nfsd4_cleanup_open_state(open, status);
-        if (open->op_openowner && !nfsd4_has_session(cstate))
-                cstate->replay_owner = &open->op_openowner->oo_owner;
+        nfsd4_cleanup_open_state(cstate, open, status);
         nfsd4_bump_seqid(cstate, status);
-        if (!cstate->replay_owner)
-                nfs4_unlock_state();
         return status;
 }
 
@@ -581,8 +576,12 @@ static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
         __be32 verf[2];
         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
-        verf[0] = (__be32)nn->nfssvc_boot.tv_sec;
-        verf[1] = (__be32)nn->nfssvc_boot.tv_usec;
+        /*
+         * This is opaque to client, so no need to byte-swap. Use
+         * __force to keep sparse happy
+         */
+        verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec;
+        verf[1] = (__force __be32)nn->nfssvc_boot.tv_usec;
         memcpy(verifier->data, verf, sizeof(verifier->data));
 }
 
@@ -619,8 +618,7 @@ nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         case NF4LNK:
                 status = nfsd_symlink(rqstp, &cstate->current_fh,
                                       create->cr_name, create->cr_namelen,
-                                      create->cr_linkname, create->cr_linklen,
-                                      &resfh, &create->cr_iattr);
+                                      create->cr_data, &resfh);
                 break;
 
         case NF4BLK:
@@ -909,8 +907,8 @@ nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstat
         default:
                 return nfserr_inval;
         }
-        exp_get(cstate->current_fh.fh_export);
-        sin->sin_exp = cstate->current_fh.fh_export;
+
+        sin->sin_exp = exp_get(cstate->current_fh.fh_export);
         fh_put(&cstate->current_fh);
         return nfs_ok;
 }
@@ -1289,7 +1287,7 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
          * Don't use the deferral mechanism for NFSv4; compounds make it
          * too hard to avoid non-idempotency problems.
          */
-        rqstp->rq_usedeferral = 0;
+        rqstp->rq_usedeferral = false;
 
         /*
          * According to RFC3010, this takes precedence over all other errors.
@@ -1391,10 +1389,7 @@ encode_op:
                         args->ops, args->opcnt, resp->opcnt, op->opnum,
                         be32_to_cpu(status));
 
-                if (cstate->replay_owner) {
-                        nfs4_unlock_state();
-                        cstate->replay_owner = NULL;
-                }
+                nfsd4_cstate_clear_replay(cstate);
                 /* XXX Ugh, we need to get rid of this kind of special case: */
                 if (op->opnum == OP_READ && op->u.read.rd_filp)
                         fput(op->u.read.rd_filp);
@@ -1408,7 +1403,7 @@ encode_op:
         BUG_ON(cstate->replay_owner);
 out:
         /* Reset deferral mechanism for RPC deferrals */
-        rqstp->rq_usedeferral = 1;
+        rqstp->rq_usedeferral = true;
         dprintk("nfsv4 compound returned %d\n", ntohl(status));
         return status;
 }
@@ -1520,21 +1515,17 @@ static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
         u32 maxcount = 0, rlen = 0;
 
         maxcount = svc_max_payload(rqstp);
-        rlen = op->u.read.rd_length;
-
-        if (rlen > maxcount)
-                rlen = maxcount;
+        rlen = min(op->u.read.rd_length, maxcount);
 
         return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
 }
 
 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
 {
-        u32 maxcount = svc_max_payload(rqstp);
-        u32 rlen = op->u.readdir.rd_maxcount;
+        u32 maxcount = 0, rlen = 0;
 
-        if (rlen > maxcount)
-                rlen = maxcount;
+        maxcount = svc_max_payload(rqstp);
+        rlen = min(op->u.readdir.rd_maxcount, maxcount);
 
         return (op_encode_hdr_size + op_encode_verifier_maxsz +
                 XDR_QUADLEN(rlen)) * sizeof(__be32);