github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-12 16:18:45 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

lockd: Use xdrgen XDR functions for the NLMv4 NM_LOCK procedure

Browse Source 
Now that nlm4svc_do_lock() has been introduced to handle both
monitored and non-monitored lock requests, the NLMv4 NM_LOCK
procedure can be converted to use xdrgen-generated XDR
functions. This conversion allows the removal of
__nlm4svc_proc_lock(), a helper function that was previously
shared between the LOCK and NM_LOCK procedures.

Replace the NLMPROC4_NM_LOCK entry in the nlm_procedures4
array with an entry that uses xdrgen-built XDR decoders and
encoders. The procedure handler is updated to call
nlm4svc_do_lock() directly and access arguments through the
argp->xdrgen hierarchy.

The .pc_argzero field is set to zero because xdrgen decoders
fully initialize all fields in argp->xdrgen, making the early
defensive memset unnecessary. The remaining argp fields that
fall outside the xdrgen structures are cleared explicitly as
needed.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
This commit is contained in:
Chuck Lever 2026-02-17 17:07:17 -05:00
parent 985d022db3
commit eedae44301
1 changed files with 44 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
fs/lockd/svc4proc.c
View File

@ -358,44 +358,6 @@ static __be32 nlm4svc_proc_test(struct svc_rqst *rqstp)
rpc_drop_reply : rpc_success;
}
static __be32
__nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
{
struct nlm_args *argp = rqstp->rq_argp;
struct nlm_host *host;
struct nlm_file *file;
__be32 rc = rpc_success;
dprintk("lockd: LOCK called\n");
resp->cookie = argp->cookie;
/* 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;
/* Now try to lock the file */
resp->status = nlmsvc_lock(rqstp, file, host, &argp->lock,
argp->block, &argp->cookie,
argp->reclaim);
switch (resp->status) {
case nlm__int__drop_reply:
rc = rpc_drop_reply;
break;
case nlm__int__deadlock:
resp->status = nlm4_deadlock;
fallthrough;
default:
dprintk("lockd: LOCK status %d\n", ntohl(resp->status));
}
nlmsvc_release_lockowner(&argp->lock);
nlmsvc_release_host(host);
nlm_release_file(file);
return rc;
}
static __be32
nlm4svc_do_lock(struct svc_rqst *rqstp, bool monitored)
{
@ -1190,18 +1152,43 @@ static __be32 nlm4svc_proc_unshare(struct svc_rqst *rqstp)
rpc_drop_reply : rpc_success;
}
/*
* NM_LOCK: Create an unmonitored lock
/**
* nlm4svc_proc_nm_lock - NM_LOCK: Establish a non-monitored lock
* @rqstp: RPC transaction context
*
* Returns:
* %rpc_success: RPC executed successfully.
* %rpc_drop_reply: Do not send an RPC reply.
*
* RPC synopsis:
* nlm4_res NLMPROC4_NM_LOCK(nlm4_lockargs) = 22;
*
* Permissible procedure status codes:
* %NLM4_GRANTED: The requested lock was granted.
* %NLM4_DENIED: The requested lock conflicted with existing
* lock reservations for the file.
* %NLM4_DENIED_NOLOCKS: The server could not allocate the resources
* needed to process the request.
* %NLM4_BLOCKED: The blocking request cannot be granted
* immediately. The server will send an
* NLMPROC4_GRANTED callback to the client when
* the lock can be granted.
* %NLM4_DENIED_GRACE_PERIOD: The server has recently restarted and is
* re-establishing existing locks, and is not
* yet ready to accept normal service requests.
*
* The Linux NLM server implementation also returns:
* %NLM4_DEADLCK: The request could not be granted and
* blocking would cause a deadlock.
* %NLM4_STALE_FH: The request specified an invalid file handle.
* %NLM4_FBIG: The request specified a length or offset
* that exceeds the range supported by the
* server.
* %NLM4_FAILED: The request failed for an unspecified reason.
*/
static __be32
nlm4svc_proc_nm_lock(struct svc_rqst *rqstp)
static __be32 nlm4svc_proc_nm_lock(struct svc_rqst *rqstp)
{
struct nlm_args *argp = rqstp->rq_argp;
dprintk("lockd: NM_LOCK called\n");
argp->monitor = 0; /* just clean the monitor flag */
return __nlm4svc_proc_lock(rqstp, rqstp->rq_resp);
return nlm4svc_do_lock(rqstp, false);
}
/*
@ -1455,15 +1442,15 @@ static const struct svc_procedure nlm4svc_procedures[24] = {
.pc_xdrressize = NLM4_nlm4_shareres_sz,
.pc_name = "UNSHARE",
},
[NLMPROC_NM_LOCK] = {
.pc_func = nlm4svc_proc_nm_lock,
.pc_decode = nlm4svc_decode_lockargs,
.pc_encode = nlm4svc_encode_res,
.pc_argsize = sizeof(struct nlm_args),
.pc_argzero = sizeof(struct nlm_args),
.pc_ressize = sizeof(struct nlm_res),
.pc_xdrressize = Ck+St,
.pc_name = "NM_LOCK",
[NLMPROC4_NM_LOCK] = {
.pc_func = nlm4svc_proc_nm_lock,
.pc_decode = nlm4_svc_decode_nlm4_lockargs,
.pc_encode = nlm4_svc_encode_nlm4_res,
.pc_argsize = sizeof(struct nlm4_lockargs_wrapper),
.pc_argzero = 0,
.pc_ressize = sizeof(struct nlm4_res_wrapper),
.pc_xdrressize = NLM4_nlm4_res_sz,
.pc_name = "NM_LOCK",
},
[NLMPROC_FREE_ALL] = {
.pc_func = nlm4svc_proc_free_all,