1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * linux/fs/lockd/svcproc.c
  4 *
  5 * Lockd server procedures. We don't implement the NLM_*_RES 
  6 * procedures because we don't use the async procedures.
  7 *
  8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  9 */
 10
 11#include <linux/types.h>
 12#include <linux/time.h>
 13#include <linux/lockd/lockd.h>
 14#include <linux/lockd/share.h>
 15#include <linux/sunrpc/svc_xprt.h>
 16
 17#define NLMDBG_FACILITY		NLMDBG_CLIENT
 18
 19#ifdef CONFIG_LOCKD_V4
 20static __be32
 21cast_to_nlm(__be32 status, u32 vers)
 22{
 23	/* Note: status is assumed to be in network byte order !!! */
 24	if (vers != 4){
 25		switch (status) {
 26		case nlm_granted:
 27		case nlm_lck_denied:
 28		case nlm_lck_denied_nolocks:
 29		case nlm_lck_blocked:
 30		case nlm_lck_denied_grace_period:
 31		case nlm_drop_reply:
 32			break;
 33		case nlm4_deadlock:
 34			status = nlm_lck_denied;
 35			break;
 36		default:
 37			status = nlm_lck_denied_nolocks;
 38		}
 39	}
 40
 41	return (status);
 42}
 43#define	cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
 44#else
 45#define cast_status(status) (status)
 46#endif
 47
 48/*
 49 * Obtain client and file from arguments
 50 */
 51static __be32
 52nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
 53			struct nlm_host **hostp, struct nlm_file **filp)
 54{
 55	struct nlm_host		*host = NULL;
 56	struct nlm_file		*file = NULL;
 57	struct nlm_lock		*lock = &argp->lock;
 58	__be32			error = 0;
 59
 60	/* nfsd callbacks must have been installed for this procedure */
 61	if (!nlmsvc_ops)
 62		return nlm_lck_denied_nolocks;
 63
 64	/* Obtain host handle */
 65	if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
 66	 || (argp->monitor && nsm_monitor(host) < 0))
 67		goto no_locks;
 68	*hostp = host;
 69
 70	/* Obtain file pointer. Not used by FREE_ALL call. */
 71	if (filp != NULL) {
 72		error = cast_status(nlm_lookup_file(rqstp, &file, &lock->fh));
 73		if (error != 0)
 74			goto no_locks;
 75		*filp = file;
 76
 77		/* Set up the missing parts of the file_lock structure */
 78		lock->fl.fl_file  = file->f_file;
 79		lock->fl.fl_pid = current->tgid;
 80		lock->fl.fl_lmops = &nlmsvc_lock_operations;
 81		nlmsvc_locks_init_private(&lock->fl, host, (pid_t)lock->svid);
 82		if (!lock->fl.fl_owner) {
 83			/* lockowner allocation has failed */
 84			nlmsvc_release_host(host);
 85			return nlm_lck_denied_nolocks;
 86		}
 87	}
 88
 89	return 0;
 90
 91no_locks:
 92	nlmsvc_release_host(host);
 93	if (error)
 94		return error;
 95	return nlm_lck_denied_nolocks;
 96}
 97
 98/*
 99 * NULL: Test for presence of service
100 */
101static __be32
102nlmsvc_proc_null(struct svc_rqst *rqstp)
103{
104	dprintk("lockd: NULL          called\n");
105	return rpc_success;
106}
107
108/*
109 * TEST: Check for conflicting lock
110 */
111static __be32
112__nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
113{
114	struct nlm_args *argp = rqstp->rq_argp;
115	struct nlm_host	*host;
116	struct nlm_file	*file;
117	__be32 rc = rpc_success;
118
119	dprintk("lockd: TEST          called\n");
120	resp->cookie = argp->cookie;
121
122	/* Obtain client and file */
123	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
124		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
125
126	/* Now check for conflicting locks */
127	resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
128	if (resp->status == nlm_drop_reply)
129		rc = rpc_drop_reply;
130	else
131		dprintk("lockd: TEST          status %d vers %d\n",
132			ntohl(resp->status), rqstp->rq_vers);
133
134	nlmsvc_release_lockowner(&argp->lock);
135	nlmsvc_release_host(host);
136	nlm_release_file(file);
137	return rc;
138}
139
140static __be32
141nlmsvc_proc_test(struct svc_rqst *rqstp)
142{
143	return __nlmsvc_proc_test(rqstp, rqstp->rq_resp);
144}
145
146static __be32
147__nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
148{
149	struct nlm_args *argp = rqstp->rq_argp;
150	struct nlm_host	*host;
151	struct nlm_file	*file;
152	__be32 rc = rpc_success;
153
154	dprintk("lockd: LOCK          called\n");
155
156	resp->cookie = argp->cookie;
157
158	/* Obtain client and file */
159	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
160		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
161
162#if 0
163	/* If supplied state doesn't match current state, we assume it's
164	 * an old request that time-warped somehow. Any error return would
165	 * do in this case because it's irrelevant anyway.
166	 *
167	 * NB: We don't retrieve the remote host's state yet.
168	 */
169	if (host->h_nsmstate && host->h_nsmstate != argp->state) {
170		resp->status = nlm_lck_denied_nolocks;
171	} else
172#endif
173
174	/* Now try to lock the file */
175	resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
176					       argp->block, &argp->cookie,
177					       argp->reclaim));
178	if (resp->status == nlm_drop_reply)
179		rc = rpc_drop_reply;
180	else
181		dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
182
183	nlmsvc_release_lockowner(&argp->lock);
184	nlmsvc_release_host(host);
185	nlm_release_file(file);
186	return rc;
187}
188
189static __be32
190nlmsvc_proc_lock(struct svc_rqst *rqstp)
191{
192	return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp);
193}
194
195static __be32
196__nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
197{
198	struct nlm_args *argp = rqstp->rq_argp;
199	struct nlm_host	*host;
200	struct nlm_file	*file;
201	struct net *net = SVC_NET(rqstp);
202
203	dprintk("lockd: CANCEL        called\n");
204
205	resp->cookie = argp->cookie;
206
207	/* Don't accept requests during grace period */
208	if (locks_in_grace(net)) {
209		resp->status = nlm_lck_denied_grace_period;
210		return rpc_success;
211	}
212
213	/* Obtain client and file */
214	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
215		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
216
217	/* Try to cancel request. */
218	resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock));
219
220	dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
221	nlmsvc_release_lockowner(&argp->lock);
222	nlmsvc_release_host(host);
223	nlm_release_file(file);
224	return rpc_success;
225}
226
227static __be32
228nlmsvc_proc_cancel(struct svc_rqst *rqstp)
229{
230	return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp);
231}
232
233/*
234 * UNLOCK: release a lock
235 */
236static __be32
237__nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
238{
239	struct nlm_args *argp = rqstp->rq_argp;
240	struct nlm_host	*host;
241	struct nlm_file	*file;
242	struct net *net = SVC_NET(rqstp);
243
244	dprintk("lockd: UNLOCK        called\n");
245
246	resp->cookie = argp->cookie;
247
248	/* Don't accept new lock requests during grace period */
249	if (locks_in_grace(net)) {
250		resp->status = nlm_lck_denied_grace_period;
251		return rpc_success;
252	}
253
254	/* Obtain client and file */
255	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
256		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
257
258	/* Now try to remove the lock */
259	resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock));
260
261	dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
262	nlmsvc_release_lockowner(&argp->lock);
263	nlmsvc_release_host(host);
264	nlm_release_file(file);
265	return rpc_success;
266}
267
268static __be32
269nlmsvc_proc_unlock(struct svc_rqst *rqstp)
270{
271	return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp);
272}
273
274/*
275 * GRANTED: A server calls us to tell that a process' lock request
276 * was granted
277 */
278static __be32
279__nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
280{
281	struct nlm_args *argp = rqstp->rq_argp;
282
283	resp->cookie = argp->cookie;
284
285	dprintk("lockd: GRANTED       called\n");
286	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
287	dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
288	return rpc_success;
289}
290
291static __be32
292nlmsvc_proc_granted(struct svc_rqst *rqstp)
293{
294	return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp);
295}
296
297/*
298 * This is the generic lockd callback for async RPC calls
299 */
300static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
301{
302	dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
303			-task->tk_status);
304}
305
306void nlmsvc_release_call(struct nlm_rqst *call)
307{
308	if (!refcount_dec_and_test(&call->a_count))
309		return;
310	nlmsvc_release_host(call->a_host);
311	kfree(call);
312}
313
314static void nlmsvc_callback_release(void *data)
315{
316	nlmsvc_release_call(data);
317}
318
319static const struct rpc_call_ops nlmsvc_callback_ops = {
320	.rpc_call_done = nlmsvc_callback_exit,
321	.rpc_release = nlmsvc_callback_release,
322};
323
324/*
325 * `Async' versions of the above service routines. They aren't really,
326 * because we send the callback before the reply proper. I hope this
327 * doesn't break any clients.
328 */
329static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc,
330		__be32 (*func)(struct svc_rqst *, struct nlm_res *))
331{
332	struct nlm_args *argp = rqstp->rq_argp;
333	struct nlm_host	*host;
334	struct nlm_rqst	*call;
335	__be32 stat;
336
337	host = nlmsvc_lookup_host(rqstp,
338				  argp->lock.caller,
339				  argp->lock.len);
340	if (host == NULL)
341		return rpc_system_err;
342
343	call = nlm_alloc_call(host);
344	nlmsvc_release_host(host);
345	if (call == NULL)
346		return rpc_system_err;
347
348	stat = func(rqstp, &call->a_res);
349	if (stat != 0) {
350		nlmsvc_release_call(call);
351		return stat;
352	}
353
354	call->a_flags = RPC_TASK_ASYNC;
355	if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
356		return rpc_system_err;
357	return rpc_success;
358}
359
360static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
361{
362	dprintk("lockd: TEST_MSG      called\n");
363	return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test);
364}
365
366static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
367{
368	dprintk("lockd: LOCK_MSG      called\n");
369	return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock);
370}
371
372static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
373{
374	dprintk("lockd: CANCEL_MSG    called\n");
375	return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel);
376}
377
378static __be32
379nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
380{
381	dprintk("lockd: UNLOCK_MSG    called\n");
382	return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock);
383}
384
385static __be32
386nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
387{
388	dprintk("lockd: GRANTED_MSG   called\n");
389	return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted);
390}
391
392/*
393 * SHARE: create a DOS share or alter existing share.
394 */
395static __be32
396nlmsvc_proc_share(struct svc_rqst *rqstp)
397{
398	struct nlm_args *argp = rqstp->rq_argp;
399	struct nlm_res *resp = rqstp->rq_resp;
400	struct nlm_host	*host;
401	struct nlm_file	*file;
402
403	dprintk("lockd: SHARE         called\n");
404
405	resp->cookie = argp->cookie;
406
407	/* Don't accept new lock requests during grace period */
408	if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
409		resp->status = nlm_lck_denied_grace_period;
410		return rpc_success;
411	}
412
413	/* Obtain client and file */
414	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
415		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
416
417	/* Now try to create the share */
418	resp->status = cast_status(nlmsvc_share_file(host, file, argp));
419
420	dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
421	nlmsvc_release_lockowner(&argp->lock);
422	nlmsvc_release_host(host);
423	nlm_release_file(file);
424	return rpc_success;
425}
426
427/*
428 * UNSHARE: Release a DOS share.
429 */
430static __be32
431nlmsvc_proc_unshare(struct svc_rqst *rqstp)
432{
433	struct nlm_args *argp = rqstp->rq_argp;
434	struct nlm_res *resp = rqstp->rq_resp;
435	struct nlm_host	*host;
436	struct nlm_file	*file;
437
438	dprintk("lockd: UNSHARE       called\n");
439
440	resp->cookie = argp->cookie;
441
442	/* Don't accept requests during grace period */
443	if (locks_in_grace(SVC_NET(rqstp))) {
444		resp->status = nlm_lck_denied_grace_period;
445		return rpc_success;
446	}
447
448	/* Obtain client and file */
449	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
450		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
451
452	/* Now try to unshare the file */
453	resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));
454
455	dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
456	nlmsvc_release_lockowner(&argp->lock);
457	nlmsvc_release_host(host);
458	nlm_release_file(file);
459	return rpc_success;
460}
461
462/*
463 * NM_LOCK: Create an unmonitored lock
464 */
465static __be32
466nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
467{
468	struct nlm_args *argp = rqstp->rq_argp;
469
470	dprintk("lockd: NM_LOCK       called\n");
471
472	argp->monitor = 0;		/* just clean the monitor flag */
473	return nlmsvc_proc_lock(rqstp);
474}
475
476/*
477 * FREE_ALL: Release all locks and shares held by client
478 */
479static __be32
480nlmsvc_proc_free_all(struct svc_rqst *rqstp)
481{
482	struct nlm_args *argp = rqstp->rq_argp;
483	struct nlm_host	*host;
484
485	/* Obtain client */
486	if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
487		return rpc_success;
488
489	nlmsvc_free_host_resources(host);
490	nlmsvc_release_host(host);
491	return rpc_success;
492}
493
494/*
495 * SM_NOTIFY: private callback from statd (not part of official NLM proto)
496 */
497static __be32
498nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
499{
500	struct nlm_reboot *argp = rqstp->rq_argp;
501
502	dprintk("lockd: SM_NOTIFY     called\n");
503
504	if (!nlm_privileged_requester(rqstp)) {
505		char buf[RPC_MAX_ADDRBUFLEN];
506		printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
507				svc_print_addr(rqstp, buf, sizeof(buf)));
508		return rpc_system_err;
509	}
510
511	nlm_host_rebooted(SVC_NET(rqstp), argp);
512	return rpc_success;
513}
514
515/*
516 * client sent a GRANTED_RES, let's remove the associated block
517 */
518static __be32
519nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
520{
521	struct nlm_res *argp = rqstp->rq_argp;
522
523	if (!nlmsvc_ops)
524		return rpc_success;
525
526	dprintk("lockd: GRANTED_RES   called\n");
527
528	nlmsvc_grant_reply(&argp->cookie, argp->status);
529	return rpc_success;
530}
531
532static __be32
533nlmsvc_proc_unused(struct svc_rqst *rqstp)
534{
535	return rpc_proc_unavail;
536}
537
538/*
539 * NLM Server procedures.
540 */
541
 
 
 
 
 
 
 
 
 
 
 
 
 
 
542struct nlm_void			{ int dummy; };
543
 
 
 
 
 
 
 
 
 
 
544#define	Ck	(1+XDR_QUADLEN(NLM_MAXCOOKIELEN))	/* cookie */
545#define	St	1				/* status */
546#define	No	(1+1024/4)			/* Net Obj */
547#define	Rg	2				/* range - offset + size */
548
549const struct svc_procedure nlmsvc_procedures[24] = {
550	[NLMPROC_NULL] = {
551		.pc_func = nlmsvc_proc_null,
552		.pc_decode = nlmsvc_decode_void,
553		.pc_encode = nlmsvc_encode_void,
554		.pc_argsize = sizeof(struct nlm_void),
555		.pc_ressize = sizeof(struct nlm_void),
556		.pc_xdrressize = St,
557		.pc_name = "NULL",
558	},
559	[NLMPROC_TEST] = {
560		.pc_func = nlmsvc_proc_test,
561		.pc_decode = nlmsvc_decode_testargs,
562		.pc_encode = nlmsvc_encode_testres,
563		.pc_argsize = sizeof(struct nlm_args),
564		.pc_ressize = sizeof(struct nlm_res),
565		.pc_xdrressize = Ck+St+2+No+Rg,
566		.pc_name = "TEST",
567	},
568	[NLMPROC_LOCK] = {
569		.pc_func = nlmsvc_proc_lock,
570		.pc_decode = nlmsvc_decode_lockargs,
571		.pc_encode = nlmsvc_encode_res,
572		.pc_argsize = sizeof(struct nlm_args),
573		.pc_ressize = sizeof(struct nlm_res),
574		.pc_xdrressize = Ck+St,
575		.pc_name = "LOCK",
576	},
577	[NLMPROC_CANCEL] = {
578		.pc_func = nlmsvc_proc_cancel,
579		.pc_decode = nlmsvc_decode_cancargs,
580		.pc_encode = nlmsvc_encode_res,
581		.pc_argsize = sizeof(struct nlm_args),
582		.pc_ressize = sizeof(struct nlm_res),
583		.pc_xdrressize = Ck+St,
584		.pc_name = "CANCEL",
585	},
586	[NLMPROC_UNLOCK] = {
587		.pc_func = nlmsvc_proc_unlock,
588		.pc_decode = nlmsvc_decode_unlockargs,
589		.pc_encode = nlmsvc_encode_res,
590		.pc_argsize = sizeof(struct nlm_args),
591		.pc_ressize = sizeof(struct nlm_res),
592		.pc_xdrressize = Ck+St,
593		.pc_name = "UNLOCK",
594	},
595	[NLMPROC_GRANTED] = {
596		.pc_func = nlmsvc_proc_granted,
597		.pc_decode = nlmsvc_decode_testargs,
598		.pc_encode = nlmsvc_encode_res,
599		.pc_argsize = sizeof(struct nlm_args),
600		.pc_ressize = sizeof(struct nlm_res),
601		.pc_xdrressize = Ck+St,
602		.pc_name = "GRANTED",
603	},
604	[NLMPROC_TEST_MSG] = {
605		.pc_func = nlmsvc_proc_test_msg,
606		.pc_decode = nlmsvc_decode_testargs,
607		.pc_encode = nlmsvc_encode_void,
608		.pc_argsize = sizeof(struct nlm_args),
609		.pc_ressize = sizeof(struct nlm_void),
610		.pc_xdrressize = St,
611		.pc_name = "TEST_MSG",
612	},
613	[NLMPROC_LOCK_MSG] = {
614		.pc_func = nlmsvc_proc_lock_msg,
615		.pc_decode = nlmsvc_decode_lockargs,
616		.pc_encode = nlmsvc_encode_void,
617		.pc_argsize = sizeof(struct nlm_args),
618		.pc_ressize = sizeof(struct nlm_void),
619		.pc_xdrressize = St,
620		.pc_name = "LOCK_MSG",
621	},
622	[NLMPROC_CANCEL_MSG] = {
623		.pc_func = nlmsvc_proc_cancel_msg,
624		.pc_decode = nlmsvc_decode_cancargs,
625		.pc_encode = nlmsvc_encode_void,
626		.pc_argsize = sizeof(struct nlm_args),
627		.pc_ressize = sizeof(struct nlm_void),
628		.pc_xdrressize = St,
629		.pc_name = "CANCEL_MSG",
630	},
631	[NLMPROC_UNLOCK_MSG] = {
632		.pc_func = nlmsvc_proc_unlock_msg,
633		.pc_decode = nlmsvc_decode_unlockargs,
634		.pc_encode = nlmsvc_encode_void,
635		.pc_argsize = sizeof(struct nlm_args),
636		.pc_ressize = sizeof(struct nlm_void),
637		.pc_xdrressize = St,
638		.pc_name = "UNLOCK_MSG",
639	},
640	[NLMPROC_GRANTED_MSG] = {
641		.pc_func = nlmsvc_proc_granted_msg,
642		.pc_decode = nlmsvc_decode_testargs,
643		.pc_encode = nlmsvc_encode_void,
644		.pc_argsize = sizeof(struct nlm_args),
645		.pc_ressize = sizeof(struct nlm_void),
646		.pc_xdrressize = St,
647		.pc_name = "GRANTED_MSG",
648	},
649	[NLMPROC_TEST_RES] = {
650		.pc_func = nlmsvc_proc_null,
651		.pc_decode = nlmsvc_decode_void,
652		.pc_encode = nlmsvc_encode_void,
653		.pc_argsize = sizeof(struct nlm_res),
654		.pc_ressize = sizeof(struct nlm_void),
655		.pc_xdrressize = St,
656		.pc_name = "TEST_RES",
657	},
658	[NLMPROC_LOCK_RES] = {
659		.pc_func = nlmsvc_proc_null,
660		.pc_decode = nlmsvc_decode_void,
661		.pc_encode = nlmsvc_encode_void,
662		.pc_argsize = sizeof(struct nlm_res),
663		.pc_ressize = sizeof(struct nlm_void),
664		.pc_xdrressize = St,
665		.pc_name = "LOCK_RES",
666	},
667	[NLMPROC_CANCEL_RES] = {
668		.pc_func = nlmsvc_proc_null,
669		.pc_decode = nlmsvc_decode_void,
670		.pc_encode = nlmsvc_encode_void,
671		.pc_argsize = sizeof(struct nlm_res),
672		.pc_ressize = sizeof(struct nlm_void),
673		.pc_xdrressize = St,
674		.pc_name = "CANCEL_RES",
675	},
676	[NLMPROC_UNLOCK_RES] = {
677		.pc_func = nlmsvc_proc_null,
678		.pc_decode = nlmsvc_decode_void,
679		.pc_encode = nlmsvc_encode_void,
680		.pc_argsize = sizeof(struct nlm_res),
681		.pc_ressize = sizeof(struct nlm_void),
682		.pc_xdrressize = St,
683		.pc_name = "UNLOCK_RES",
684	},
685	[NLMPROC_GRANTED_RES] = {
686		.pc_func = nlmsvc_proc_granted_res,
687		.pc_decode = nlmsvc_decode_res,
688		.pc_encode = nlmsvc_encode_void,
689		.pc_argsize = sizeof(struct nlm_res),
690		.pc_ressize = sizeof(struct nlm_void),
691		.pc_xdrressize = St,
692		.pc_name = "GRANTED_RES",
693	},
694	[NLMPROC_NSM_NOTIFY] = {
695		.pc_func = nlmsvc_proc_sm_notify,
696		.pc_decode = nlmsvc_decode_reboot,
697		.pc_encode = nlmsvc_encode_void,
698		.pc_argsize = sizeof(struct nlm_reboot),
699		.pc_ressize = sizeof(struct nlm_void),
700		.pc_xdrressize = St,
701		.pc_name = "SM_NOTIFY",
702	},
703	[17] = {
704		.pc_func = nlmsvc_proc_unused,
705		.pc_decode = nlmsvc_decode_void,
706		.pc_encode = nlmsvc_encode_void,
707		.pc_argsize = sizeof(struct nlm_void),
708		.pc_ressize = sizeof(struct nlm_void),
709		.pc_xdrressize = St,
710		.pc_name = "UNUSED",
711	},
712	[18] = {
713		.pc_func = nlmsvc_proc_unused,
714		.pc_decode = nlmsvc_decode_void,
715		.pc_encode = nlmsvc_encode_void,
716		.pc_argsize = sizeof(struct nlm_void),
717		.pc_ressize = sizeof(struct nlm_void),
718		.pc_xdrressize = St,
719		.pc_name = "UNUSED",
720	},
721	[19] = {
722		.pc_func = nlmsvc_proc_unused,
723		.pc_decode = nlmsvc_decode_void,
724		.pc_encode = nlmsvc_encode_void,
725		.pc_argsize = sizeof(struct nlm_void),
726		.pc_ressize = sizeof(struct nlm_void),
727		.pc_xdrressize = St,
728		.pc_name = "UNUSED",
729	},
730	[NLMPROC_SHARE] = {
731		.pc_func = nlmsvc_proc_share,
732		.pc_decode = nlmsvc_decode_shareargs,
733		.pc_encode = nlmsvc_encode_shareres,
734		.pc_argsize = sizeof(struct nlm_args),
735		.pc_ressize = sizeof(struct nlm_res),
736		.pc_xdrressize = Ck+St+1,
737		.pc_name = "SHARE",
738	},
739	[NLMPROC_UNSHARE] = {
740		.pc_func = nlmsvc_proc_unshare,
741		.pc_decode = nlmsvc_decode_shareargs,
742		.pc_encode = nlmsvc_encode_shareres,
743		.pc_argsize = sizeof(struct nlm_args),
744		.pc_ressize = sizeof(struct nlm_res),
745		.pc_xdrressize = Ck+St+1,
746		.pc_name = "UNSHARE",
747	},
748	[NLMPROC_NM_LOCK] = {
749		.pc_func = nlmsvc_proc_nm_lock,
750		.pc_decode = nlmsvc_decode_lockargs,
751		.pc_encode = nlmsvc_encode_res,
752		.pc_argsize = sizeof(struct nlm_args),
753		.pc_ressize = sizeof(struct nlm_res),
754		.pc_xdrressize = Ck+St,
755		.pc_name = "NM_LOCK",
756	},
757	[NLMPROC_FREE_ALL] = {
758		.pc_func = nlmsvc_proc_free_all,
759		.pc_decode = nlmsvc_decode_notify,
760		.pc_encode = nlmsvc_encode_void,
761		.pc_argsize = sizeof(struct nlm_args),
762		.pc_ressize = sizeof(struct nlm_void),
763		.pc_xdrressize = 0,
764		.pc_name = "FREE_ALL",
765	},
766};