sunrpc: drop BKL around wrap and unwrap

We don't need the BKL when wrapping and unwrapping; and experiments by Avishay
Traeger have found that permitting multiple encryption and decryption
operations to proceed in parallel can provide significant performance
improvements.

Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
Cc: Avishay Traeger <atraeger@cs.sunysb.edu>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

3 files changed, 21 insertions, 6 deletions

diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 74baf87ccff9..aa55d0a03e6f 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -13,6 +13,7 @@
 #include <linux/errno.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/spinlock.h>
+#include <linux/smp_lock.h>
 
 #ifdef RPC_DEBUG
 # define RPCDBG_FACILITY        RPCDBG_AUTH
@@ -475,13 +476,17 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
                 __be32 *data, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
+        int ret;
 
         dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
                         task->tk_pid, cred->cr_ops->cr_name, cred);
         if (cred->cr_ops->crwrap_req)
                 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
         /* By default, we encode the arguments normally. */
-        return encode(rqstp, data, obj);
+        lock_kernel();
+        ret = encode(rqstp, data, obj);
+        unlock_kernel();
+        return ret;
 }
 
 int
@@ -489,6 +494,7 @@ rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
                 __be32 *data, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
+        int ret;
 
         dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
                         task->tk_pid, cred->cr_ops->cr_name, cred);
@@ -496,7 +502,10 @@ rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
                 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
                                                    data, obj);
         /* By default, we decode the arguments normally. */
-        return decode(rqstp, data, obj);
+        lock_kernel();
+        ret = decode(rqstp, data, obj);
+        unlock_kernel();
+        return ret;
 }
 
 int
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 17d460f85f0e..baf4096d52d4 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -999,7 +999,9 @@ gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
         offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
         *p++ = htonl(rqstp->rq_seqno);
 
+        lock_kernel();
         status = encode(rqstp, p, obj);
+        unlock_kernel();
         if (status)
                 return status;
 
@@ -1093,7 +1095,9 @@ gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
         offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
         *p++ = htonl(rqstp->rq_seqno);
 
+        lock_kernel();
         status = encode(rqstp, p, obj);
+        unlock_kernel();
         if (status)
                 return status;
 
@@ -1152,12 +1156,16 @@ gss_wrap_req(struct rpc_task *task,
                 /* The spec seems a little ambiguous here, but I think that not
                  * wrapping context destruction requests makes the most sense.
                  */
+                lock_kernel();
                 status = encode(rqstp, p, obj);
+                unlock_kernel();
                 goto out;
         }
         switch (gss_cred->gc_service) {
                 case RPC_GSS_SVC_NONE:
+                        lock_kernel();
                         status = encode(rqstp, p, obj);
+                        unlock_kernel();
                         break;
                 case RPC_GSS_SVC_INTEGRITY:
                         status = gss_wrap_req_integ(cred, ctx, encode,
@@ -1273,7 +1281,9 @@ gss_unwrap_resp(struct rpc_task *task,
         cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp)
                                                 + (savedlen - head->iov_len);
 out_decode:
+        lock_kernel();
         status = decode(rqstp, p, obj);
+        unlock_kernel();
 out:
         gss_put_ctx(ctx);
         dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid,
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 5d3fe7b22488..52429b1ffcc1 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -904,10 +904,8 @@ call_encode(struct rpc_task *task)
         if (encode == NULL)
                 return;
 
-        lock_kernel();
         task->tk_status = rpcauth_wrap_req(task, encode, req, p,
                         task->tk_msg.rpc_argp);
-        unlock_kernel();
         if (task->tk_status == -ENOMEM) {
                 /* XXX: Is this sane? */
                 rpc_delay(task, 3*HZ);
@@ -1238,10 +1236,8 @@ call_decode(struct rpc_task *task)
         task->tk_action = rpc_exit_task;
 
         if (decode) {
-                lock_kernel();
                 task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
                                                       task->tk_msg.rpc_resp);
-                unlock_kernel();
         }
         dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
                         task->tk_status);