lockd: Refactor nlm4svc_callback()

The xdrgen-based XDR conversion requires each RPC procedure
to handle its own argument extraction, since xdrgen generates
distinct argument structures for each procedure rather than
using a single shared type.

This patch moves the host lookup logic from nlm4svc_callback()
into each of the five MSG procedure handlers (TEST_MSG,
LOCK_MSG, CANCEL_MSG, UNLOCK_MSG, and GRANTED_MSG). Each
handler now performs its own host lookup from rqstp->rq_argp
and passes the resulting host pointer to nlm4svc_callback(),
which is reduced to a simpler helper that only dispatches
the callback.

This refactoring enables the subsequent xdrgen conversion
patches by establishing the pattern where each procedure
handles its own argument extraction, while preserving
existing callback behavior unchanged.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>

diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c
index 2e1a0392d68ac245909f22242d6f1e172ec230c5..f1a692f72a39750f7cb684d19a1b4efd1b3aca20 100644 (file)
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -757,24 +757,17 @@ static const struct rpc_call_ops nlm4svc_callback_ops = {
 };
 
 /*
- * `Async' versions of the above service routines. They aren't really,
- * because we send the callback before the reply proper. I hope this
- * doesn't break any clients.
+ * Dispatch an async callback RPC to a client with a pre-resolved host.
+ * Caller provides a reference to @host; this function takes ownership
+ * and releases it via nlmsvc_release_host() before returning.
  */
-static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc,
-               __be32 (*func)(struct svc_rqst *,  struct nlm_res *))
+static __be32
+nlm4svc_callback(struct svc_rqst *rqstp, struct nlm_host *host, u32 proc,
+                __be32 (*func)(struct svc_rqst *,  struct nlm_res *))
 {
-       struct nlm_args *argp = rqstp->rq_argp;
-       struct nlm_host *host;
        struct nlm_rqst *call;
        __be32 stat;
 
-       host = nlmsvc_lookup_host(rqstp,
-                                 argp->lock.caller,
-                                 argp->lock.len);
-       if (host == NULL)
-               return rpc_system_err;
-
        call = nlm_alloc_call(host);
        nlmsvc_release_host(host);
        if (call == NULL)
@@ -792,34 +785,85 @@ static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc,
        return rpc_success;
 }
 
+/*
+ * 'Async' versions of the above service routines. They aren't really,
+ * because we send the callback before the reply proper. I hope this
+ * doesn't break any clients.
+ */
+
 static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
        dprintk("lockd: TEST_MSG      called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, __nlm4svc_proc_test);
+
+       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       if (!host)
+               return rpc_system_err;
+
+       return nlm4svc_callback(rqstp, host, NLMPROC_TEST_RES,
+                               __nlm4svc_proc_test);
 }
 
 static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
        dprintk("lockd: LOCK_MSG      called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, __nlm4svc_proc_lock);
+
+       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       if (!host)
+               return rpc_system_err;
+
+       return nlm4svc_callback(rqstp, host, NLMPROC_LOCK_RES,
+                               __nlm4svc_proc_lock);
 }
 
 static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
        dprintk("lockd: CANCEL_MSG    called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, __nlm4svc_proc_cancel);
+
+       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       if (!host)
+               return rpc_system_err;
+
+       return nlm4svc_callback(rqstp, host, NLMPROC_CANCEL_RES,
+                               __nlm4svc_proc_cancel);
 }
 
 static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
        dprintk("lockd: UNLOCK_MSG    called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlm4svc_proc_unlock);
+
+       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       if (!host)
+               return rpc_system_err;
+
+       return nlm4svc_callback(rqstp, host, NLMPROC_UNLOCK_RES,
+                               __nlm4svc_proc_unlock);
 }
 
 static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
        dprintk("lockd: GRANTED_MSG   called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, __nlm4svc_proc_granted);
+
+       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       if (!host)
+               return rpc_system_err;
+
+       return nlm4svc_callback(rqstp, host, NLMPROC_GRANTED_RES,
+                               __nlm4svc_proc_granted);
 }
 
 /*