iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NFS/SUNRPC: Convert all users of rpc_call_setup()

Browse Source 
Replace use of rpc_call_setup() with rpc_init_task(), and in cases where we
need to initialise task->tk_action, with rpc_call_start().

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Trond Myklebust 2007-07-14 15:40:01 -04:00
parent bdc7f021f3
commit 5138fde011
3 changed files with 79 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
fs/nfs/nfs4proc.c
View File

@ -718,19 +718,6 @@ int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state
return err; return err;
} }
static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
{
struct nfs4_opendata *data = calldata;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
.rpc_argp = &data->c_arg,
.rpc_resp = &data->c_res,
.rpc_cred = data->owner->so_cred,
};
data->timestamp = jiffies;
rpc_call_setup(task, &msg, 0);
}
static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
{ {
struct nfs4_opendata *data = calldata; struct nfs4_opendata *data = calldata;
@ -767,7 +754,6 @@ out_free:
} }
static const struct rpc_call_ops nfs4_open_confirm_ops = { static const struct rpc_call_ops nfs4_open_confirm_ops = {
.rpc_call_prepare = nfs4_open_confirm_prepare,
.rpc_call_done = nfs4_open_confirm_done, .rpc_call_done = nfs4_open_confirm_done,
.rpc_release = nfs4_open_confirm_release, .rpc_release = nfs4_open_confirm_release,
}; };
@ -779,8 +765,15 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
{ {
struct nfs_server *server = NFS_SERVER(data->dir->d_inode); struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
struct rpc_task *task; struct rpc_task *task;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
.rpc_argp = &data->c_arg,
.rpc_resp = &data->c_res,
.rpc_cred = data->owner->so_cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = server->client, .rpc_client = server->client,
.rpc_message = &msg,
.callback_ops = &nfs4_open_confirm_ops, .callback_ops = &nfs4_open_confirm_ops,
.callback_data = data, .callback_data = data,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
@ -790,6 +783,7 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
kref_get(&data->kref); kref_get(&data->kref);
data->rpc_done = 0; data->rpc_done = 0;
data->rpc_status = 0; data->rpc_status = 0;
data->timestamp = jiffies;
task = rpc_run_task(&task_setup_data); task = rpc_run_task(&task_setup_data);
if (IS_ERR(task)) if (IS_ERR(task))
return PTR_ERR(task); return PTR_ERR(task);
@ -807,13 +801,7 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
{ {
struct nfs4_opendata *data = calldata; struct nfs4_opendata *data = calldata;
struct nfs4_state_owner *sp = data->owner; struct nfs4_state_owner *sp = data->owner;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
.rpc_argp = &data->o_arg,
.rpc_resp = &data->o_res,
.rpc_cred = sp->so_cred,
};
if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
return; return;
/* /*
@ -838,11 +826,11 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
data->o_arg.id = sp->so_owner_id.id; data->o_arg.id = sp->so_owner_id.id;
data->o_arg.clientid = sp->so_client->cl_clientid; data->o_arg.clientid = sp->so_client->cl_clientid;
if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) { if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
} }
data->timestamp = jiffies; data->timestamp = jiffies;
rpc_call_setup(task, &msg, 0); rpc_call_start(task);
return; return;
out_no_action: out_no_action:
task->tk_action = NULL; task->tk_action = NULL;
@ -914,8 +902,15 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
struct nfs_openargs *o_arg = &data->o_arg; struct nfs_openargs *o_arg = &data->o_arg;
struct nfs_openres *o_res = &data->o_res; struct nfs_openres *o_res = &data->o_res;
struct rpc_task *task; struct rpc_task *task;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
.rpc_argp = o_arg,
.rpc_resp = o_res,
.rpc_cred = data->owner->so_cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = server->client, .rpc_client = server->client,
.rpc_message = &msg,
.callback_ops = &nfs4_open_ops, .callback_ops = &nfs4_open_ops,
.callback_data = data, .callback_data = data,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
@ -1256,12 +1251,6 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
{ {
struct nfs4_closedata *calldata = data; struct nfs4_closedata *calldata = data;
struct nfs4_state *state = calldata->state; struct nfs4_state *state = calldata->state;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
.rpc_argp = &calldata->arg,
.rpc_resp = &calldata->res,
.rpc_cred = state->owner->so_cred,
};
int clear_rd, clear_wr, clear_rdwr; int clear_rd, clear_wr, clear_rdwr;
if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
@ -1288,14 +1277,14 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
} }
nfs_fattr_init(calldata->res.fattr); nfs_fattr_init(calldata->res.fattr);
if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) {
msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
calldata->arg.open_flags = FMODE_READ; calldata->arg.open_flags = FMODE_READ;
} else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) {
msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
calldata->arg.open_flags = FMODE_WRITE; calldata->arg.open_flags = FMODE_WRITE;
} }
calldata->timestamp = jiffies; calldata->timestamp = jiffies;
rpc_call_setup(task, &msg, 0); rpc_call_start(task);
} }
static const struct rpc_call_ops nfs4_close_ops = { static const struct rpc_call_ops nfs4_close_ops = {
@ -1321,8 +1310,13 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait)
struct nfs4_closedata *calldata; struct nfs4_closedata *calldata;
struct nfs4_state_owner *sp = state->owner; struct nfs4_state_owner *sp = state->owner;
struct rpc_task *task; struct rpc_task *task;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
.rpc_cred = state->owner->so_cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = server->client, .rpc_client = server->client,
.rpc_message = &msg,
.callback_ops = &nfs4_close_ops, .callback_ops = &nfs4_close_ops,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
}; };
@ -1345,6 +1339,8 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait)
calldata->path.mnt = mntget(path->mnt); calldata->path.mnt = mntget(path->mnt);
calldata->path.dentry = dget(path->dentry); calldata->path.dentry = dget(path->dentry);
msg.rpc_argp = &calldata->arg,
msg.rpc_resp = &calldata->res,
task_setup_data.callback_data = calldata; task_setup_data.callback_data = calldata;
task = rpc_run_task(&task_setup_data); task = rpc_run_task(&task_setup_data);
if (IS_ERR(task)) if (IS_ERR(task))
@ -2966,25 +2962,11 @@ struct nfs4_delegreturndata {
struct nfs4_delegreturnres res; struct nfs4_delegreturnres res;
struct nfs_fh fh; struct nfs_fh fh;
nfs4_stateid stateid; nfs4_stateid stateid;
struct rpc_cred *cred;
unsigned long timestamp; unsigned long timestamp;
struct nfs_fattr fattr; struct nfs_fattr fattr;
int rpc_status; int rpc_status;
}; };
static void nfs4_delegreturn_prepare(struct rpc_task *task, void *calldata)
{
struct nfs4_delegreturndata *data = calldata;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
nfs_fattr_init(data->res.fattr);
rpc_call_setup(task, &msg, 0);
}
static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
{ {
struct nfs4_delegreturndata *data = calldata; struct nfs4_delegreturndata *data = calldata;
@ -2995,14 +2977,10 @@ static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
static void nfs4_delegreturn_release(void *calldata) static void nfs4_delegreturn_release(void *calldata)
{ {
struct nfs4_delegreturndata *data = calldata;
put_rpccred(data->cred);
kfree(calldata); kfree(calldata);
} }
static const struct rpc_call_ops nfs4_delegreturn_ops = { static const struct rpc_call_ops nfs4_delegreturn_ops = {
.rpc_call_prepare = nfs4_delegreturn_prepare,
.rpc_call_done = nfs4_delegreturn_done, .rpc_call_done = nfs4_delegreturn_done,
.rpc_release = nfs4_delegreturn_release, .rpc_release = nfs4_delegreturn_release,
}; };
@ -3012,8 +2990,13 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
struct nfs4_delegreturndata *data; struct nfs4_delegreturndata *data;
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct rpc_task *task; struct rpc_task *task;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
.rpc_cred = cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = server->client, .rpc_client = server->client,
.rpc_message = &msg,
.callback_ops = &nfs4_delegreturn_ops, .callback_ops = &nfs4_delegreturn_ops,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
}; };
@ -3029,11 +3012,13 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
memcpy(&data->stateid, stateid, sizeof(data->stateid)); memcpy(&data->stateid, stateid, sizeof(data->stateid));
data->res.fattr = &data->fattr; data->res.fattr = &data->fattr;
data->res.server = server; data->res.server = server;
data->cred = get_rpccred(cred); nfs_fattr_init(data->res.fattr);
data->timestamp = jiffies; data->timestamp = jiffies;
data->rpc_status = 0; data->rpc_status = 0;
task_setup_data.callback_data = data; task_setup_data.callback_data = data;
msg.rpc_argp = &data->args,
msg.rpc_resp = &data->res,
task = rpc_run_task(&task_setup_data); task = rpc_run_task(&task_setup_data);
if (IS_ERR(task)) if (IS_ERR(task))
return PTR_ERR(task); return PTR_ERR(task);
@ -3221,12 +3206,6 @@ static void nfs4_locku_done(struct rpc_task *task, void *data)
static void nfs4_locku_prepare(struct rpc_task *task, void *data) static void nfs4_locku_prepare(struct rpc_task *task, void *data)
{ {
struct nfs4_unlockdata *calldata = data; struct nfs4_unlockdata *calldata = data;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
.rpc_argp = &calldata->arg,
.rpc_resp = &calldata->res,
.rpc_cred = calldata->lsp->ls_state->owner->so_cred,
};
if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
return; return;
@ -3236,7 +3215,7 @@ static void nfs4_locku_prepare(struct rpc_task *task, void *data)
return; return;
} }
calldata->timestamp = jiffies; calldata->timestamp = jiffies;
rpc_call_setup(task, &msg, 0); rpc_call_start(task);
} }
static const struct rpc_call_ops nfs4_locku_ops = { static const struct rpc_call_ops nfs4_locku_ops = {
@ -3251,8 +3230,13 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
struct nfs_seqid *seqid) struct nfs_seqid *seqid)
{ {
struct nfs4_unlockdata *data; struct nfs4_unlockdata *data;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
.rpc_cred = ctx->cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = NFS_CLIENT(lsp->ls_state->inode), .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
.rpc_message = &msg,
.callback_ops = &nfs4_locku_ops, .callback_ops = &nfs4_locku_ops,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
}; };
@ -3268,6 +3252,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
msg.rpc_argp = &data->arg,
msg.rpc_resp = &data->res,
task_setup_data.callback_data = data; task_setup_data.callback_data = data;
return rpc_run_task(&task_setup_data); return rpc_run_task(&task_setup_data);
} }
@ -3353,13 +3339,6 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
{ {
struct nfs4_lockdata *data = calldata; struct nfs4_lockdata *data = calldata;
struct nfs4_state *state = data->lsp->ls_state; struct nfs4_state *state = data->lsp->ls_state;
struct nfs4_state_owner *sp = state->owner;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
.rpc_argp = &data->arg,
.rpc_resp = &data->res,
.rpc_cred = sp->so_cred,
};
dprintk("%s: begin!\n", __FUNCTION__); dprintk("%s: begin!\n", __FUNCTION__);
if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
@ -3373,7 +3352,7 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
} else } else
data->arg.new_lock_owner = 0; data->arg.new_lock_owner = 0;
data->timestamp = jiffies; data->timestamp = jiffies;
rpc_call_setup(task, &msg, 0); rpc_call_start(task);
dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status); dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status);
} }
@ -3435,8 +3414,13 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
{ {
struct nfs4_lockdata *data; struct nfs4_lockdata *data;
struct rpc_task *task; struct rpc_task *task;
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
.rpc_cred = state->owner->so_cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_client = NFS_CLIENT(state->inode), .rpc_client = NFS_CLIENT(state->inode),
.rpc_message = &msg,
.callback_ops = &nfs4_lock_ops, .callback_ops = &nfs4_lock_ops,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
}; };
@ -3451,6 +3435,8 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
data->arg.block = 1; data->arg.block = 1;
if (reclaim != 0) if (reclaim != 0)
data->arg.reclaim = 1; data->arg.reclaim = 1;
msg.rpc_argp = &data->arg,
msg.rpc_resp = &data->res,
task_setup_data.callback_data = data; task_setup_data.callback_data = data;
task = rpc_run_task(&task_setup_data); task = rpc_run_task(&task_setup_data);
if (IS_ERR(task)) if (IS_ERR(task))

28
fs/nfs/unlink.c
View File

@ -70,24 +70,6 @@ static void nfs_dec_sillycount(struct inode *dir)
wake_up(&nfsi->waitqueue); wake_up(&nfsi->waitqueue);
} }
/**
* nfs_async_unlink_init - Initialize the RPC info
* task: rpc_task of the sillydelete
*/
static void nfs_async_unlink_init(struct rpc_task *task, void *calldata)
{
struct nfs_unlinkdata *data = calldata;
struct inode *dir = data->dir;
struct rpc_message msg = {
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
NFS_PROTO(dir)->unlink_setup(&msg, dir);
rpc_call_setup(task, &msg, 0);
}
/** /**
* nfs_async_unlink_done - Sillydelete post-processing * nfs_async_unlink_done - Sillydelete post-processing
* @task: rpc_task of the sillydelete * @task: rpc_task of the sillydelete
@ -120,14 +102,19 @@ static void nfs_async_unlink_release(void *calldata)
} }
static const struct rpc_call_ops nfs_unlink_ops = { static const struct rpc_call_ops nfs_unlink_ops = {
.rpc_call_prepare = nfs_async_unlink_init,
.rpc_call_done = nfs_async_unlink_done, .rpc_call_done = nfs_async_unlink_done,
.rpc_release = nfs_async_unlink_release, .rpc_release = nfs_async_unlink_release,
}; };
static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data) static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data)
{ {
struct rpc_message msg = {
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
struct rpc_task_setup task_setup_data = { struct rpc_task_setup task_setup_data = {
.rpc_message = &msg,
.callback_ops = &nfs_unlink_ops, .callback_ops = &nfs_unlink_ops,
.callback_data = data, .callback_data = data,
.flags = RPC_TASK_ASYNC, .flags = RPC_TASK_ASYNC,
@ -165,8 +152,9 @@ static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct n
data->args.fh = NFS_FH(dir); data->args.fh = NFS_FH(dir);
nfs_fattr_init(&data->res.dir_attr); nfs_fattr_init(&data->res.dir_attr);
task_setup_data.rpc_client = NFS_CLIENT(dir); NFS_PROTO(dir)->unlink_setup(&msg, dir);
task_setup_data.rpc_client = NFS_CLIENT(dir);
task = rpc_run_task(&task_setup_data); task = rpc_run_task(&task_setup_data);
if (!IS_ERR(task)) if (!IS_ERR(task))
rpc_put_task(task); rpc_put_task(task);

40
net/sunrpc/rpcb_clnt.c
View File

@ -128,19 +128,6 @@ struct rpcb_info {
static struct rpcb_info rpcb_next_version[]; static struct rpcb_info rpcb_next_version[];
static struct rpcb_info rpcb_next_version6[]; static struct rpcb_info rpcb_next_version6[];
static void rpcb_getport_prepare(struct rpc_task *task, void *calldata)
{
struct rpcbind_args *map = calldata;
struct rpc_xprt *xprt = map->r_xprt;
struct rpc_message msg = {
.rpc_proc = rpcb_next_version[xprt->bind_index].rpc_proc,
.rpc_argp = map,
.rpc_resp = &map->r_port,
};
rpc_call_setup(task, &msg, 0);
}
static void rpcb_map_release(void *data) static void rpcb_map_release(void *data)
{ {
struct rpcbind_args *map = data; struct rpcbind_args *map = data;
@ -150,7 +137,6 @@ static void rpcb_map_release(void *data)
} }
static const struct rpc_call_ops rpcb_getport_ops = { static const struct rpc_call_ops rpcb_getport_ops = {
.rpc_call_prepare = rpcb_getport_prepare,
.rpc_call_done = rpcb_getport_done, .rpc_call_done = rpcb_getport_done,
.rpc_release = rpcb_map_release, .rpc_release = rpcb_map_release,
}; };
@ -295,6 +281,24 @@ int rpcb_getport_sync(struct sockaddr_in *sin, __u32 prog,
} }
EXPORT_SYMBOL_GPL(rpcb_getport_sync); EXPORT_SYMBOL_GPL(rpcb_getport_sync);
static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt, struct rpcbind_args *map, int version)
{
struct rpc_message msg = {
.rpc_proc = rpcb_next_version[version].rpc_proc,
.rpc_argp = map,
.rpc_resp = &map->r_port,
};
struct rpc_task_setup task_setup_data = {
.rpc_client = rpcb_clnt,
.rpc_message = &msg,
.callback_ops = &rpcb_getport_ops,
.callback_data = map,
.flags = RPC_TASK_ASYNC,
};
return rpc_run_task(&task_setup_data);
}
/** /**
* rpcb_getport_async - obtain the port for a given RPC service on a given host * rpcb_getport_async - obtain the port for a given RPC service on a given host
* @task: task that is waiting for portmapper request * @task: task that is waiting for portmapper request
@ -310,10 +314,6 @@ void rpcb_getport_async(struct rpc_task *task)
struct rpc_clnt *rpcb_clnt; struct rpc_clnt *rpcb_clnt;
static struct rpcbind_args *map; static struct rpcbind_args *map;
struct rpc_task *child; struct rpc_task *child;
struct rpc_task_setup task_setup_data = {
.callback_ops = &rpcb_getport_ops,
.flags = RPC_TASK_ASYNC,
};
struct sockaddr addr; struct sockaddr addr;
int status; int status;
struct rpcb_info *info; struct rpcb_info *info;
@ -399,9 +399,7 @@ void rpcb_getport_async(struct rpc_task *task)
sizeof(map->r_addr)); sizeof(map->r_addr));
map->r_owner = RPCB_OWNER_STRING; /* ignored for GETADDR */ map->r_owner = RPCB_OWNER_STRING; /* ignored for GETADDR */
task_setup_data.rpc_client = rpcb_clnt; child = rpcb_call_async(rpcb_clnt, map, xprt->bind_index);
task_setup_data.callback_data = map;
child = rpc_run_task(&task_setup_data);
rpc_release_client(rpcb_clnt); rpc_release_client(rpcb_clnt);
if (IS_ERR(child)) { if (IS_ERR(child)) {
status = -EIO; status = -EIO;