Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5138fde0 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

NFS/SUNRPC: Convert all users of rpc_call_setup() 



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: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent bdc7f021

fs/nfs/nfs4proc.c

+52 −66
Original line number Diff line number Diff line
@@ -718,19 +718,6 @@ int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state 
	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)

{

	struct nfs4_opendata *data = calldata;
@@ -767,7 +754,6 @@ static void nfs4_open_confirm_release(void *calldata) 
}



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_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 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 = {

		.rpc_client = server->client,

		.rpc_message = &msg,

		.callback_ops = &nfs4_open_confirm_ops,

		.callback_data = data,

		.flags = RPC_TASK_ASYNC,
@@ -790,6 +783,7 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 
	kref_get(&data->kref);

	data->rpc_done = 0;

	data->rpc_status = 0;

	data->timestamp = jiffies;

	task = rpc_run_task(&task_setup_data);

	if (IS_ERR(task))

		return PTR_ERR(task);
@@ -807,12 +801,6 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 
{

	struct nfs4_opendata *data = calldata;

	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)

		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.clientid = sp->so_client->cl_clientid;

	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);

	}

	data->timestamp = jiffies;

	rpc_call_setup(task, &msg, 0);

	rpc_call_start(task);

	return;

out_no_action:

	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_openres *o_res = &data->o_res;

	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 = {

		.rpc_client = server->client,

		.rpc_message = &msg,

		.callback_ops = &nfs4_open_ops,

		.callback_data = data,

		.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_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;



	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);

	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;

	} 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->timestamp = jiffies;

	rpc_call_setup(task, &msg, 0);

	rpc_call_start(task);

}



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_state_owner *sp = state->owner;

	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 = {

		.rpc_client = server->client,

		.rpc_message = &msg,

		.callback_ops = &nfs4_close_ops,

		.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.dentry = dget(path->dentry);



	msg.rpc_argp = &calldata->arg,

	msg.rpc_resp = &calldata->res,

	task_setup_data.callback_data = calldata;

	task = rpc_run_task(&task_setup_data);

	if (IS_ERR(task))
@@ -2966,25 +2962,11 @@ struct nfs4_delegreturndata { 
	struct nfs4_delegreturnres res;

	struct nfs_fh fh;

	nfs4_stateid stateid;

	struct rpc_cred *cred;

	unsigned long timestamp;

	struct nfs_fattr fattr;

	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)

{

	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)

{

	struct nfs4_delegreturndata *data = calldata;



	put_rpccred(data->cred);

	kfree(calldata);

}



static const struct rpc_call_ops nfs4_delegreturn_ops = {

	.rpc_call_prepare = nfs4_delegreturn_prepare,

	.rpc_call_done = nfs4_delegreturn_done,

	.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 nfs_server *server = NFS_SERVER(inode);

	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 = {

		.rpc_client = server->client,

		.rpc_message = &msg,

		.callback_ops = &nfs4_delegreturn_ops,

		.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));

	data->res.fattr = &data->fattr;

	data->res.server = server;

	data->cred = get_rpccred(cred);

	nfs_fattr_init(data->res.fattr);

	data->timestamp = jiffies;

	data->rpc_status = 0;



	task_setup_data.callback_data = data;

	msg.rpc_argp = &data->args,

	msg.rpc_resp = &data->res,

	task = rpc_run_task(&task_setup_data);

	if (IS_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)

{

	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)

		return;
@@ -3236,7 +3215,7 @@ static void nfs4_locku_prepare(struct rpc_task *task, void *data) 
		return;

	}

	calldata->timestamp = jiffies;

	rpc_call_setup(task, &msg, 0);

	rpc_call_start(task);

}



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 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 = {

		.rpc_client = NFS_CLIENT(lsp->ls_state->inode),

		.rpc_message = &msg,

		.callback_ops = &nfs4_locku_ops,

		.flags = RPC_TASK_ASYNC,

	};
@@ -3268,6 +3252,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 
		return ERR_PTR(-ENOMEM);

	}



	msg.rpc_argp = &data->arg,

	msg.rpc_resp = &data->res,

	task_setup_data.callback_data = 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_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__);

	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

		data->arg.new_lock_owner = 0;

	data->timestamp = jiffies;

	rpc_call_setup(task, &msg, 0);

	rpc_call_start(task);

	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 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 = {

		.rpc_client = NFS_CLIENT(state->inode),

		.rpc_message = &msg,

		.callback_ops = &nfs4_lock_ops,

		.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;

	if (reclaim != 0)

		data->arg.reclaim = 1;

	msg.rpc_argp = &data->arg,

	msg.rpc_resp = &data->res,

	task_setup_data.callback_data = data;

	task = rpc_run_task(&task_setup_data);

	if (IS_ERR(task))

fs/nfs/unlink.c

+8 −20
Original line number Diff line number Diff line
@@ -70,24 +70,6 @@ static void nfs_dec_sillycount(struct inode *dir) 
		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

 * @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 = {

	.rpc_call_prepare = nfs_async_unlink_init,

	.rpc_call_done = nfs_async_unlink_done,

	.rpc_release = nfs_async_unlink_release,

};



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 = {

		.rpc_message = &msg,

		.callback_ops = &nfs_unlink_ops,

		.callback_data = data,

		.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);

	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);

	if (!IS_ERR(task))

		rpc_put_task(task);

net/sunrpc/rpcb_clnt.c

+19 −21
Original line number Diff line number Diff line
@@ -128,19 +128,6 @@ struct rpcb_info { 
static struct rpcb_info rpcb_next_version[];

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)

{

	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 = {

	.rpc_call_prepare	= rpcb_getport_prepare,

	.rpc_call_done		= rpcb_getport_done,

	.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);



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

 * @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;

	static struct rpcbind_args *map;

	struct rpc_task	*child;

	struct rpc_task_setup task_setup_data = {

		.callback_ops = &rpcb_getport_ops,

		.flags = RPC_TASK_ASYNC,

	};

	struct sockaddr addr;

	int status;

	struct rpcb_info *info;
@@ -399,9 +399,7 @@ void rpcb_getport_async(struct rpc_task *task) 
	       sizeof(map->r_addr));

	map->r_owner = RPCB_OWNER_STRING;	/* ignored for GETADDR */



	task_setup_data.rpc_client = rpcb_clnt;

	task_setup_data.callback_data = map;

	child = rpc_run_task(&task_setup_data);

	child = rpcb_call_async(rpcb_clnt, map, xprt->bind_index);

	rpc_release_client(rpcb_clnt);

	if (IS_ERR(child)) {

		status = -EIO;