SUNRPC: Cleanup of rpc_task initialisation

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

2 files changed, 50 insertions, 28 deletions

diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 22092b91dd85..7c80abd9263f 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -524,25 +524,22 @@ void rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset)
 EXPORT_SYMBOL_GPL(rpc_clnt_sigunmask);
 
 static
-struct rpc_task *rpc_do_run_task(struct rpc_clnt *clnt,
-                struct rpc_message *msg,
-                int flags,
-                const struct rpc_call_ops *ops,
-                void *data)
+struct rpc_task *rpc_do_run_task(const struct rpc_task_setup *task_setup_data)
 {
         struct rpc_task *task, *ret;
         sigset_t oldset;
 
-        task = rpc_new_task(clnt, flags, ops, data);
+        task = rpc_new_task(task_setup_data);
         if (task == NULL) {
-                rpc_release_calldata(ops, data);
+                rpc_release_calldata(task_setup_data->callback_ops,
+                                task_setup_data->callback_data);
                 return ERR_PTR(-ENOMEM);
         }
 
         /* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */
         rpc_task_sigmask(task, &oldset);
-        if (msg != NULL) {
-                rpc_call_setup(task, msg, 0);
+        if (task_setup_data->rpc_message != NULL) {
+                rpc_call_setup(task, task_setup_data->rpc_message, 0);
                 if (task->tk_status != 0) {
                         ret = ERR_PTR(task->tk_status);
                         rpc_put_task(task);
@@ -566,11 +563,17 @@ out:
 int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
 {
         struct rpc_task *task;
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = clnt,
+                .rpc_message = msg,
+                .callback_ops = &rpc_default_ops,
+                .flags = flags,
+        };
         int status;
 
         BUG_ON(flags & RPC_TASK_ASYNC);
 
-        task = rpc_do_run_task(clnt, msg, flags, &rpc_default_ops, NULL);
+        task = rpc_do_run_task(&task_setup_data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
         status = task->tk_status;
@@ -592,8 +595,15 @@ rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg, int flags,
                const struct rpc_call_ops *tk_ops, void *data)
 {
         struct rpc_task *task;
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = clnt,
+                .rpc_message = msg,
+                .callback_ops = tk_ops,
+                .callback_data = data,
+                .flags = flags|RPC_TASK_ASYNC,
+        };
 
-        task = rpc_do_run_task(clnt, msg, flags|RPC_TASK_ASYNC, tk_ops, data);
+        task = rpc_do_run_task(&task_setup_data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
         rpc_put_task(task);
@@ -612,12 +622,19 @@ struct rpc_task *rpc_run_task(struct rpc_clnt *clnt, int flags,
                                         const struct rpc_call_ops *tk_ops,
                                         void *data)
 {
-        return rpc_do_run_task(clnt, NULL, flags, tk_ops, data);
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = clnt,
+                .callback_ops = tk_ops,
+                .callback_data = data,
+                .flags = flags,
+        };
+
+        return rpc_do_run_task(&task_setup_data);
 }
 EXPORT_SYMBOL_GPL(rpc_run_task);
 
 void
-rpc_call_setup(struct rpc_task *task, struct rpc_message *msg, int flags)
+rpc_call_setup(struct rpc_task *task, const struct rpc_message *msg, int flags)
 {
         task->tk_msg   = *msg;
         task->tk_flags |= flags;
@@ -1527,7 +1544,13 @@ struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int
                 .rpc_proc = &rpcproc_null,
                 .rpc_cred = cred,
         };
-        return rpc_do_run_task(clnt, &msg, flags, &rpc_default_ops, NULL);
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = clnt,
+                .rpc_message = &msg,
+                .callback_ops = &rpc_default_ops,
+                .flags = flags,
+        };
+        return rpc_do_run_task(&task_setup_data);
 }
 EXPORT_SYMBOL_GPL(rpc_call_null);
 
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index d0b4c7e11e06..10216989309c 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -815,18 +815,15 @@ EXPORT_SYMBOL_GPL(rpc_free);
 /*
  * Creation and deletion of RPC task structures
  */
-void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, int flags, const struct rpc_call_ops *tk_ops, void *calldata)
+void rpc_init_task(struct rpc_task *task, const struct rpc_task_setup *task_setup_data)
 {
         memset(task, 0, sizeof(*task));
         setup_timer(&task->tk_timer, (void (*)(unsigned long))rpc_run_timer,
                         (unsigned long)task);
         atomic_set(&task->tk_count, 1);
-        task->tk_client = clnt;
-        task->tk_flags  = flags;
-        task->tk_ops = tk_ops;
-        if (tk_ops->rpc_call_prepare != NULL)
-                task->tk_action = rpc_prepare_task;
-        task->tk_calldata = calldata;
+        task->tk_flags  = task_setup_data->flags;
+        task->tk_ops = task_setup_data->callback_ops;
+        task->tk_calldata = task_setup_data->callback_data;
         INIT_LIST_HEAD(&task->tk_task);
 
         /* Initialize retry counters */
@@ -839,15 +836,17 @@ void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, int flags, cons
         /* Initialize workqueue for async tasks */
         task->tk_workqueue = rpciod_workqueue;
 
-        if (clnt) {
-                kref_get(&clnt->cl_kref);
-                if (clnt->cl_softrtry)
+        task->tk_client = task_setup_data->rpc_client;
+        if (task->tk_client != NULL) {
+                kref_get(&task->tk_client->cl_kref);
+                if (task->tk_client->cl_softrtry)
                         task->tk_flags |= RPC_TASK_SOFT;
-                if (!clnt->cl_intr)
+                if (!task->tk_client->cl_intr)
                         task->tk_flags |= RPC_TASK_NOINTR;
         }
 
-        BUG_ON(task->tk_ops == NULL);
+        if (task->tk_ops->rpc_call_prepare != NULL)
+                task->tk_action = rpc_prepare_task;
 
         /* starting timestamp */
         task->tk_start = jiffies;
@@ -873,7 +872,7 @@ static void rpc_free_task(struct rcu_head *rcu)
 /*
  * Create a new task for the specified client.
  */
-struct rpc_task *rpc_new_task(struct rpc_clnt *clnt, int flags, const struct rpc_call_ops *tk_ops, void *calldata)
+struct rpc_task *rpc_new_task(const struct rpc_task_setup *setup_data)
 {
         struct rpc_task *task;
 
@@ -881,7 +880,7 @@ struct rpc_task *rpc_new_task(struct rpc_clnt *clnt, int flags, const struct rpc
         if (!task)
                 goto out;
 
-        rpc_init_task(task, clnt, flags, tk_ops, calldata);
+        rpc_init_task(task, setup_data);
 
         dprintk("RPC:       allocated task %p\n", task);
         task->tk_flags |= RPC_TASK_DYNAMIC;