lockd: Use xdrgen XDR functions for the NLMv4 CANCEL_MSG procedure

The CANCEL_MSG procedure is part of NLM's asynchronous lock
request flow, where clients send CANCEL_MSG to cancel pending
lock requests. This patch continues the xdrgen migration by
converting CANCEL_MSG to use generated XDR functions.

This patch converts the CANCEL_MSG procedure to use xdrgen
functions nlm4_svc_decode_nlm4_cancargs and
nlm4_svc_encode_void generated from the NLM version 4 protocol
specification. The procedure handler uses xdrgen types through
the nlm4_cancargs_wrapper structure that bridges between
generated code and the legacy nlm_lock representation.

The pc_argzero field is set to zero because xdrgen decoders
reliably initialize all arguments in the argp->xdrgen field,
making the early defensive memset unnecessary. Remaining argp
fields are cleared as needed.

The NLM async callback mechanism uses client-side functions
which continue to take legacy results like struct nlm_res,
preventing CANCEL and CANCEL_MSG from sharing code for now.

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 d9406a4ab1761e5485db00945e1fa49e17cf7b26..01e21b0a89565c4db9ddc7ed80bc3975445af32f 100644 (file)
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -459,38 +459,6 @@ nlm4svc_proc_lock(struct svc_rqst *rqstp)
        return nlm4svc_do_lock(rqstp, true);
 }
 
-static __be32
-__nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
-{
-       struct nlm_args *argp = rqstp->rq_argp;
-       struct nlm_host *host;
-       struct nlm_file *file;
-
-       dprintk("lockd: CANCEL        called\n");
-
-       resp->cookie = argp->cookie;
-
-       /* Don't accept requests during grace period */
-       if (locks_in_grace(SVC_NET(rqstp))) {
-               resp->status = nlm_lck_denied_grace_period;
-               return rpc_success;
-       }
-
-       /* Obtain client and file */
-       if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
-               return resp->status == nlm__int__drop_reply ?
-                       rpc_drop_reply : rpc_success;
-
-       /* Try to cancel request. */
-       resp->status = nlmsvc_cancel_blocked(SVC_NET(rqstp), file, &argp->lock);
-
-       dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
-       nlmsvc_release_lockowner(&argp->lock);
-       nlmsvc_release_host(host);
-       nlm_release_file(file);
-       return rpc_success;
-}
-
 /**
  * nlm4svc_proc_cancel - CANCEL: Cancel an outstanding blocked lock request
  * @rqstp: RPC transaction context
@@ -872,19 +840,68 @@ static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp)
                                __nlm4svc_proc_lock_msg);
 }
 
-static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp)
+static __be32
+__nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
-       struct nlm_args *argp = rqstp->rq_argp;
-       struct nlm_host *host;
+       struct nlm4_cancargs_wrapper *argp = rqstp->rq_argp;
+       unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
+       struct net *net = SVC_NET(rqstp);
+       struct nlm_file *file = NULL;
+       struct nlm_host *host = NULL;
 
-       dprintk("lockd: CANCEL_MSG    called\n");
+       resp->status = nlm_lck_denied_nolocks;
+       if (nlm4_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
+               goto out;
 
-       host = nlmsvc_lookup_host(rqstp, argp->lock.caller, argp->lock.len);
+       resp->status = nlm_lck_denied_grace_period;
+       if (locks_in_grace(net))
+               goto out;
+
+       resp->status = nlm_lck_denied_nolocks;
+       host = nlm4svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
+       if (!host)
+               goto out;
+
+       resp->status = nlm4svc_lookup_file(rqstp, host, &argp->lock,
+                                          &file, &argp->xdrgen.alock, type);
+       if (resp->status)
+               goto out;
+
+       resp->status = nlmsvc_cancel_blocked(net, file, &argp->lock);
+       nlmsvc_release_lockowner(&argp->lock);
+
+out:
+       if (file)
+               nlm_release_file(file);
+       nlmsvc_release_host(host);
+       return resp->status == nlm__int__drop_reply ?
+               rpc_drop_reply : rpc_success;
+}
+
+/**
+ * nlm4svc_proc_cancel_msg - CANCEL_MSG: Cancel an outstanding lock request
+ * @rqstp: RPC transaction context
+ *
+ * Returns:
+ *   %rpc_success:             RPC executed successfully.
+ *   %rpc_system_err:          RPC execution failed.
+ *
+ * RPC synopsis:
+ *   void NLMPROC4_CANCEL_MSG(nlm4_cancargs) = 8;
+ *
+ * The response to this request is delivered via the CANCEL_RES procedure.
+ */
+static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp)
+{
+       struct nlm4_cancargs_wrapper *argp = rqstp->rq_argp;
+       struct nlm_host *host;
+
+       host = nlm4svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
        if (!host)
                return rpc_system_err;
 
-       return nlm4svc_callback(rqstp, host, NLMPROC_CANCEL_RES,
-                               __nlm4svc_proc_cancel);
+       return nlm4svc_callback(rqstp, host, NLMPROC4_CANCEL_RES,
+                               __nlm4svc_proc_cancel_msg);
 }
 
 static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp)
@@ -1158,15 +1175,15 @@ static const struct svc_procedure nlm4svc_procedures[24] = {
                .pc_xdrressize  = XDR_void,
                .pc_name        = "LOCK_MSG",
        },
-       [NLMPROC_CANCEL_MSG] = {
-               .pc_func = nlm4svc_proc_cancel_msg,
-               .pc_decode = nlm4svc_decode_cancargs,
-               .pc_encode = nlm4svc_encode_void,
-               .pc_argsize = sizeof(struct nlm_args),
-               .pc_argzero = sizeof(struct nlm_args),
-               .pc_ressize = sizeof(struct nlm_void),
-               .pc_xdrressize = St,
-               .pc_name = "CANCEL_MSG",
+       [NLMPROC4_CANCEL_MSG] = {
+               .pc_func        = nlm4svc_proc_cancel_msg,
+               .pc_decode      = nlm4_svc_decode_nlm4_cancargs,
+               .pc_encode      = nlm4_svc_encode_void,
+               .pc_argsize     = sizeof(struct nlm4_cancargs_wrapper),
+               .pc_argzero     = 0,
+               .pc_ressize     = 0,
+               .pc_xdrressize  = XDR_void,
+               .pc_name        = "CANCEL_MSG",
        },
        [NLMPROC_UNLOCK_MSG] = {
                .pc_func = nlm4svc_proc_unlock_msg,