4 files changed, 39 insertions, 26 deletions

diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index 5f07a0ed9188..03311259b0c4 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -241,28 +241,25 @@ void nfs4_free_client(struct nfs_client *clp)
  */
 static int nfs4_init_callback(struct nfs_client *clp)
 {
+        struct rpc_xprt *xprt;
         int error;
 
-        if (clp->rpc_ops->version == 4) {
-                struct rpc_xprt *xprt;
+        xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt);
 
-                xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt);
-
-                if (nfs4_has_session(clp)) {
-                        error = xprt_setup_backchannel(xprt,
-                                                NFS41_BC_MIN_CALLBACKS);
-                        if (error < 0)
-                                return error;
-                }
-
-                error = nfs_callback_up(clp->cl_mvops->minor_version, xprt);
-                if (error < 0) {
-                        dprintk("%s: failed to start callback. Error = %d\n",
-                                __func__, error);
+        if (nfs4_has_session(clp)) {
+                error = xprt_setup_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
+                if (error < 0)
                         return error;
-                }
-                __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
         }
+
+        error = nfs_callback_up(clp->cl_mvops->minor_version, xprt);
+        if (error < 0) {
+                dprintk("%s: failed to start callback. Error = %d\n",
+                        __func__, error);
+                return error;
+        }
+        __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
+
         return 0;
 }
 
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 03d0fa62a06e..cb4376b78ed9 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -141,13 +141,15 @@ static int nfs4_stat_to_errno(int);
                                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
                                 XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
                                 1 /* sc_prog */ + \
-                                XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
-                                XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
+                                1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
+                                1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
                                 1) /* sc_cb_ident */
 #define decode_setclientid_maxsz \
                                 (op_decode_hdr_maxsz + \
-                                2 + \
-                                1024) /* large value for CLID_INUSE */
+                                2 /* clientid */ + \
+                                XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
+                                1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
+                                1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
 #define encode_setclientid_confirm_maxsz \
                                 (op_encode_hdr_maxsz + \
                                 3 + (NFS4_VERIFIER_SIZE >> 2))
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index 1565bbe86d51..eecb5a71e6c0 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -27,10 +27,13 @@
 
 #include <linux/seq_file.h>
 #include <linux/ktime.h>
+#include <linux/spinlock.h>
 
 #define RPC_IOSTATS_VERS        "1.0"
 
 struct rpc_iostats {
+        spinlock_t              om_lock;
+
         /*
          * These counters give an idea about how many request
          * transmissions are required, on average, to complete that
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 54530490944e..9711a155bc50 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -116,7 +116,15 @@ EXPORT_SYMBOL_GPL(svc_seq_show);
  */
 struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt)
 {
-        return kcalloc(clnt->cl_maxproc, sizeof(struct rpc_iostats), GFP_KERNEL);
+        struct rpc_iostats *stats;
+        int i;
+
+        stats = kcalloc(clnt->cl_maxproc, sizeof(*stats), GFP_KERNEL);
+        if (stats) {
+                for (i = 0; i < clnt->cl_maxproc; i++)
+                        spin_lock_init(&stats[i].om_lock);
+        }
+        return stats;
 }
 EXPORT_SYMBOL_GPL(rpc_alloc_iostats);
 
@@ -135,20 +143,21 @@ EXPORT_SYMBOL_GPL(rpc_free_iostats);
  * rpc_count_iostats - tally up per-task stats
  * @task: completed rpc_task
  * @stats: array of stat structures
- *
- * Relies on the caller for serialization.
  */
 void rpc_count_iostats(const struct rpc_task *task, struct rpc_iostats *stats)
 {
         struct rpc_rqst *req = task->tk_rqstp;
         struct rpc_iostats *op_metrics;
-        ktime_t delta;
+        ktime_t delta, now;
 
         if (!stats || !req)
                 return;
 
+        now = ktime_get();
         op_metrics = &stats[task->tk_msg.rpc_proc->p_statidx];
 
+        spin_lock(&op_metrics->om_lock);
+
         op_metrics->om_ops++;
         op_metrics->om_ntrans += req->rq_ntrans;
         op_metrics->om_timeouts += task->tk_timeouts;
@@ -161,8 +170,10 @@ void rpc_count_iostats(const struct rpc_task *task, struct rpc_iostats *stats)
 
         op_metrics->om_rtt = ktime_add(op_metrics->om_rtt, req->rq_rtt);
 
-        delta = ktime_sub(ktime_get(), task->tk_start);
+        delta = ktime_sub(now, task->tk_start);
         op_metrics->om_execute = ktime_add(op_metrics->om_execute, delta);
+
+        spin_unlock(&op_metrics->om_lock);
 }
 EXPORT_SYMBOL_GPL(rpc_count_iostats);