Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-17 05:45:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

lockd: Add helper for *_RES callbacks

Browse Source 
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Trond Myklebust 2006-03-20 13:44:45 -05:00
parent 92737230dd
commit d471662448
4 changed files with 131 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
fs/lockd/clntproc.c
View File

@ -354,14 +354,10 @@ in_grace_period:
/* /*
* Generic NLM call, async version. * Generic NLM call, async version.
*/ */
int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) static int __nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops)
{ {
struct nlm_host *host = req->a_host; struct nlm_host *host = req->a_host;
struct rpc_clnt *clnt; struct rpc_clnt *clnt;
struct rpc_message msg = {
.rpc_argp = &req->a_args,
.rpc_resp = &req->a_res,
};
int status = -ENOLCK; int status = -ENOLCK;
dprintk("lockd: call procedure %d on %s (async)\n", dprintk("lockd: call procedure %d on %s (async)\n",
@ -371,10 +367,10 @@ int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk
clnt = nlm_bind_host(host); clnt = nlm_bind_host(host);
if (clnt == NULL) if (clnt == NULL)
goto out_err; goto out_err;
msg.rpc_proc = &clnt->cl_procinfo[proc]; msg->rpc_proc = &clnt->cl_procinfo[proc];
/* bootstrap and kick off the async RPC call */ /* bootstrap and kick off the async RPC call */
status = rpc_call_async(clnt, &msg, RPC_TASK_ASYNC, tk_ops, req); status = rpc_call_async(clnt, msg, RPC_TASK_ASYNC, tk_ops, req);
if (status == 0) if (status == 0)
return 0; return 0;
out_err: out_err:
@ -382,6 +378,23 @@ out_err:
return status; return status;
} }
int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
{
struct rpc_message msg = {
.rpc_argp = &req->a_args,
.rpc_resp = &req->a_res,
};
return __nlm_async_call(req, proc, &msg, tk_ops);
}
int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
{
struct rpc_message msg = {
.rpc_argp = &req->a_res,
};
return __nlm_async_call(req, proc, &msg, tk_ops);
}
/* /*
* TEST for the presence of a conflicting lock * TEST for the presence of a conflicting lock
*/ */

152
fs/lockd/svc4proc.c
View File

@ -21,10 +21,6 @@
#define NLMDBG_FACILITY NLMDBG_CLIENT #define NLMDBG_FACILITY NLMDBG_CLIENT
static u32 nlm4svc_callback(struct svc_rqst *, u32, struct nlm_res *);
static const struct rpc_call_ops nlm4svc_callback_ops;
/* /*
* Obtain client and file from arguments * Obtain client and file from arguments
*/ */
@ -233,84 +229,90 @@ nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
return rpc_success; return rpc_success;
} }
/*
* This is the generic lockd callback for async RPC calls
*/
static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
{
dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
-task->tk_status);
}
static void nlm4svc_callback_release(void *data)
{
nlm_release_call(data);
}
static const struct rpc_call_ops nlm4svc_callback_ops = {
.rpc_call_done = nlm4svc_callback_exit,
.rpc_release = nlm4svc_callback_release,
};
/* /*
* `Async' versions of the above service routines. They aren't really, * `Async' versions of the above service routines. They aren't really,
* because we send the callback before the reply proper. I hope this * because we send the callback before the reply proper. I hope this
* doesn't break any clients. * doesn't break any clients.
*/ */
static int static int nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
nlm4svc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp, int (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res *))
{
struct nlm_host *host;
struct nlm_rqst *call;
int stat;
host = nlmsvc_lookup_host(rqstp);
if (host == NULL)
return rpc_system_err;
call = nlm_alloc_call(host);
if (call == NULL)
return rpc_system_err;
stat = func(rqstp, argp, &call->a_res);
if (stat != 0) {
nlm_release_call(call);
return stat;
}
call->a_flags = RPC_TASK_ASYNC;
if (nlm_async_reply(call, proc, &nlm4svc_callback_ops) < 0)
return rpc_system_err;
return rpc_success;
}
static int nlm4svc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: TEST_MSG called\n"); dprintk("lockd: TEST_MSG called\n");
memset(&res, 0, sizeof(res)); return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, argp, nlm4svc_proc_test);
if ((stat = nlm4svc_proc_test(rqstp, argp, &res)) == 0)
stat = nlm4svc_callback(rqstp, NLMPROC_TEST_RES, &res);
return stat;
} }
static int static int nlm4svc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlm4svc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: LOCK_MSG called\n"); dprintk("lockd: LOCK_MSG called\n");
memset(&res, 0, sizeof(res)); return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlm4svc_proc_lock);
if ((stat = nlm4svc_proc_lock(rqstp, argp, &res)) == 0)
stat = nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, &res);
return stat;
} }
static int static int nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: CANCEL_MSG called\n"); dprintk("lockd: CANCEL_MSG called\n");
memset(&res, 0, sizeof(res)); return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlm4svc_proc_cancel);
if ((stat = nlm4svc_proc_cancel(rqstp, argp, &res)) == 0)
stat = nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, &res);
return stat;
} }
static int static int nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: UNLOCK_MSG called\n"); dprintk("lockd: UNLOCK_MSG called\n");
memset(&res, 0, sizeof(res)); return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlm4svc_proc_unlock);
if ((stat = nlm4svc_proc_unlock(rqstp, argp, &res)) == 0)
stat = nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, &res);
return stat;
} }
static int static int nlm4svc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlm4svc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: GRANTED_MSG called\n"); dprintk("lockd: GRANTED_MSG called\n");
memset(&res, 0, sizeof(res)); return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlm4svc_proc_granted);
if ((stat = nlm4svc_proc_granted(rqstp, argp, &res)) == 0)
stat = nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, &res);
return stat;
} }
/* /*
@ -471,48 +473,6 @@ nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res *argp,
} }
/*
* This is the generic lockd callback for async RPC calls
*/
static u32
nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_res *resp)
{
struct nlm_host *host;
struct nlm_rqst *call;
host = nlmsvc_lookup_host(rqstp);
if (host == NULL)
return rpc_system_err;
call = nlm_alloc_call(host);
if (call == NULL)
return rpc_system_err;
call->a_flags = RPC_TASK_ASYNC;
memcpy(&call->a_args, resp, sizeof(*resp));
if (nlm_async_call(call, proc, &nlm4svc_callback_ops) < 0)
return rpc_system_err;
return rpc_success;
}
static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
{
dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
-task->tk_status);
}
static void nlm4svc_callback_release(void *data)
{
nlm_release_call(data);
}
static const struct rpc_call_ops nlm4svc_callback_ops = {
.rpc_call_done = nlm4svc_callback_exit,
.rpc_release = nlm4svc_callback_release,
};
/* /*
* NLM Server procedures. * NLM Server procedures.
*/ */

145
fs/lockd/svcproc.c
View File

@ -22,10 +22,6 @@
#define NLMDBG_FACILITY NLMDBG_CLIENT #define NLMDBG_FACILITY NLMDBG_CLIENT
static u32 nlmsvc_callback(struct svc_rqst *, u32, struct nlm_res *);
static const struct rpc_call_ops nlmsvc_callback_ops;
#ifdef CONFIG_LOCKD_V4 #ifdef CONFIG_LOCKD_V4
static u32 static u32
cast_to_nlm(u32 status, u32 vers) cast_to_nlm(u32 status, u32 vers)
@ -261,84 +257,92 @@ nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
return rpc_success; return rpc_success;
} }
/*
* This is the generic lockd callback for async RPC calls
*/
static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
{
dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
-task->tk_status);
}
static void nlmsvc_callback_release(void *data)
{
nlm_release_call(data);
}
static const struct rpc_call_ops nlmsvc_callback_ops = {
.rpc_call_done = nlmsvc_callback_exit,
.rpc_release = nlmsvc_callback_release,
};
/* /*
* `Async' versions of the above service routines. They aren't really, * `Async' versions of the above service routines. They aren't really,
* because we send the callback before the reply proper. I hope this * because we send the callback before the reply proper. I hope this
* doesn't break any clients. * doesn't break any clients.
*/ */
static int static int nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp, int (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res *))
{
struct nlm_host *host;
struct nlm_rqst *call;
int stat;
host = nlmsvc_lookup_host(rqstp);
if (host == NULL)
return rpc_system_err;
call = nlm_alloc_call(host);
if (call == NULL)
return rpc_system_err;
stat = func(rqstp, argp, &call->a_res);
if (stat != 0) {
nlm_release_call(call);
return stat;
}
call->a_flags = RPC_TASK_ASYNC;
if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
return rpc_system_err;
return rpc_success;
}
static int nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: TEST_MSG called\n"); dprintk("lockd: TEST_MSG called\n");
memset(&res, 0, sizeof(res)); return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, argp, nlmsvc_proc_test);
if ((stat = nlmsvc_proc_test(rqstp, argp, &res)) == 0)
stat = nlmsvc_callback(rqstp, NLMPROC_TEST_RES, &res);
return stat;
} }
static int static int nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: LOCK_MSG called\n"); dprintk("lockd: LOCK_MSG called\n");
memset(&res, 0, sizeof(res)); return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlmsvc_proc_lock);
if ((stat = nlmsvc_proc_lock(rqstp, argp, &res)) == 0)
stat = nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, &res);
return stat;
} }
static int static int nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: CANCEL_MSG called\n"); dprintk("lockd: CANCEL_MSG called\n");
memset(&res, 0, sizeof(res)); return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlmsvc_proc_cancel);
if ((stat = nlmsvc_proc_cancel(rqstp, argp, &res)) == 0)
stat = nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, &res);
return stat;
} }
static int static int
nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp, nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: UNLOCK_MSG called\n"); dprintk("lockd: UNLOCK_MSG called\n");
memset(&res, 0, sizeof(res)); return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlmsvc_proc_unlock);
if ((stat = nlmsvc_proc_unlock(rqstp, argp, &res)) == 0)
stat = nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, &res);
return stat;
} }
static int static int
nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp, nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
void *resp) void *resp)
{ {
struct nlm_res res;
u32 stat;
dprintk("lockd: GRANTED_MSG called\n"); dprintk("lockd: GRANTED_MSG called\n");
memset(&res, 0, sizeof(res)); return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlmsvc_proc_granted);
if ((stat = nlmsvc_proc_granted(rqstp, argp, &res)) == 0)
stat = nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, &res);
return stat;
} }
/* /*
@ -496,47 +500,6 @@ nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res *argp,
return rpc_success; return rpc_success;
} }
/*
* This is the generic lockd callback for async RPC calls
*/
static u32
nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_res *resp)
{
struct nlm_host *host;
struct nlm_rqst *call;
host = nlmsvc_lookup_host(rqstp);
if (host == NULL)
return rpc_system_err;
call = nlm_alloc_call(host);
if (call == NULL)
return rpc_system_err;
call->a_flags = RPC_TASK_ASYNC;
memcpy(&call->a_args, resp, sizeof(*resp));
if (nlm_async_call(call, proc, &nlmsvc_callback_ops) < 0)
return rpc_system_err;
return rpc_success;
}
static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
{
dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
-task->tk_status);
}
static void nlmsvc_callback_release(void *data)
{
nlm_release_call(data);
}
static const struct rpc_call_ops nlmsvc_callback_ops = {
.rpc_call_done = nlmsvc_callback_exit,
.rpc_release = nlmsvc_callback_release,
};
/* /*
* NLM Server procedures. * NLM Server procedures.
*/ */

1
include/linux/lockd/lockd.h
View File

@ -151,6 +151,7 @@ extern unsigned long nlmsvc_timeout;
struct nlm_rqst * nlm_alloc_call(struct nlm_host *host); struct nlm_rqst * nlm_alloc_call(struct nlm_host *host);
void nlm_release_call(struct nlm_rqst *); void nlm_release_call(struct nlm_rqst *);
int nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *); int nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
int nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);
struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl); struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
void nlmclnt_finish_block(struct nlm_wait *block); void nlmclnt_finish_block(struct nlm_wait *block);
int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout); int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);