1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/fs/lockd/svc.c
  4 *
  5 * This is the central lockd service.
  6 *
  7 * FIXME: Separate the lockd NFS server functionality from the lockd NFS
  8 * 	  client functionality. Oh why didn't Sun create two separate
  9 *	  services in the first place?
 10 *
 11 * Authors:	Olaf Kirch (okir@monad.swb.de)
 12 *
 13 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
 14 */
 15
 16#include <linux/module.h>
 17#include <linux/init.h>
 18#include <linux/sysctl.h>
 19#include <linux/moduleparam.h>
 20
 21#include <linux/sched/signal.h>
 22#include <linux/errno.h>
 23#include <linux/in.h>
 24#include <linux/uio.h>
 25#include <linux/smp.h>
 26#include <linux/mutex.h>
 27#include <linux/freezer.h>
 28#include <linux/inetdevice.h>
 29
 30#include <linux/sunrpc/types.h>
 31#include <linux/sunrpc/stats.h>
 32#include <linux/sunrpc/clnt.h>
 33#include <linux/sunrpc/svc.h>
 34#include <linux/sunrpc/svcsock.h>
 35#include <linux/sunrpc/svc_xprt.h>
 36#include <net/ip.h>
 37#include <net/addrconf.h>
 38#include <net/ipv6.h>
 39#include <linux/lockd/lockd.h>
 40#include <linux/nfs.h>
 41
 42#include "netns.h"
 43#include "procfs.h"
 44
 45#define NLMDBG_FACILITY		NLMDBG_SVC
 46#define LOCKD_BUFSIZE		(1024 + NLMSVC_XDRSIZE)
 47
 48static struct svc_program	nlmsvc_program;
 49
 50const struct nlmsvc_binding	*nlmsvc_ops;
 51EXPORT_SYMBOL_GPL(nlmsvc_ops);
 52
 53static DEFINE_MUTEX(nlmsvc_mutex);
 54static unsigned int		nlmsvc_users;
 55static struct svc_serv		*nlmsvc_serv;
 56unsigned long			nlmsvc_timeout;
 57
 58static void nlmsvc_request_retry(struct timer_list *tl)
 59{
 60	svc_wake_up(nlmsvc_serv);
 61}
 62DEFINE_TIMER(nlmsvc_retry, nlmsvc_request_retry);
 63
 64unsigned int lockd_net_id;
 65
 66/*
 67 * These can be set at insmod time (useful for NFS as root filesystem),
 68 * and also changed through the sysctl interface.  -- Jamie Lokier, Aug 2003
 69 */
 70static unsigned long		nlm_grace_period;
 71static unsigned long		nlm_timeout = LOCKD_DFLT_TIMEO;
 72static int			nlm_udpport, nlm_tcpport;
 73
 74/* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
 75static unsigned int		nlm_max_connections = 1024;
 76
 77/*
 78 * Constants needed for the sysctl interface.
 79 */
 80static const unsigned long	nlm_grace_period_min = 0;
 81static const unsigned long	nlm_grace_period_max = 240;
 82static const unsigned long	nlm_timeout_min = 3;
 83static const unsigned long	nlm_timeout_max = 20;
 84
 85#ifdef CONFIG_SYSCTL
 86static const int		nlm_port_min = 0, nlm_port_max = 65535;
 87static struct ctl_table_header * nlm_sysctl_table;
 88#endif
 89
 90static unsigned long get_lockd_grace_period(void)
 91{
 92	/* Note: nlm_timeout should always be nonzero */
 93	if (nlm_grace_period)
 94		return roundup(nlm_grace_period, nlm_timeout) * HZ;
 95	else
 96		return nlm_timeout * 5 * HZ;
 97}
 98
 99static void grace_ender(struct work_struct *grace)
100{
101	struct delayed_work *dwork = to_delayed_work(grace);
102	struct lockd_net *ln = container_of(dwork, struct lockd_net,
103					    grace_period_end);
104
105	locks_end_grace(&ln->lockd_manager);
106}
107
108static void set_grace_period(struct net *net)
109{
110	unsigned long grace_period = get_lockd_grace_period();
111	struct lockd_net *ln = net_generic(net, lockd_net_id);
112
113	locks_start_grace(net, &ln->lockd_manager);
114	cancel_delayed_work_sync(&ln->grace_period_end);
115	schedule_delayed_work(&ln->grace_period_end, grace_period);
116}
117
118/*
119 * This is the lockd kernel thread
120 */
121static int
122lockd(void *vrqstp)
123{
124	struct svc_rqst *rqstp = vrqstp;
125	struct net *net = &init_net;
126	struct lockd_net *ln = net_generic(net, lockd_net_id);
127
 
 
128	/* try_to_freeze() is called from svc_recv() */
129	set_freezable();
130
131	dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
132
133	/*
134	 * The main request loop. We don't terminate until the last
135	 * NFS mount or NFS daemon has gone away.
136	 */
137	while (!svc_thread_should_stop(rqstp)) {
138		/* update sv_maxconn if it has changed */
139		rqstp->rq_server->sv_maxconn = nlm_max_connections;
140
141		nlmsvc_retry_blocked(rqstp);
142		svc_recv(rqstp);
143	}
144	if (nlmsvc_ops)
145		nlmsvc_invalidate_all();
146	nlm_shutdown_hosts();
147	cancel_delayed_work_sync(&ln->grace_period_end);
148	locks_end_grace(&ln->lockd_manager);
149
150	dprintk("lockd_down: service stopped\n");
151
152	svc_exit_thread(rqstp);
153	return 0;
154}
155
156static int create_lockd_listener(struct svc_serv *serv, const char *name,
157				 struct net *net, const int family,
158				 const unsigned short port,
159				 const struct cred *cred)
160{
161	struct svc_xprt *xprt;
162
163	xprt = svc_find_xprt(serv, name, net, family, 0);
164	if (xprt == NULL)
165		return svc_xprt_create(serv, name, net, family, port,
166				       SVC_SOCK_DEFAULTS, cred);
167	svc_xprt_put(xprt);
168	return 0;
169}
170
171static int create_lockd_family(struct svc_serv *serv, struct net *net,
172			       const int family, const struct cred *cred)
173{
174	int err;
175
176	err = create_lockd_listener(serv, "udp", net, family, nlm_udpport,
177			cred);
178	if (err < 0)
179		return err;
180
181	return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport,
182			cred);
183}
184
185/*
186 * Ensure there are active UDP and TCP listeners for lockd.
187 *
188 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
189 * local services (such as rpc.statd) still require UDP, and
190 * some NFS servers do not yet support NLM over TCP.
191 *
192 * Returns zero if all listeners are available; otherwise a
193 * negative errno value is returned.
194 */
195static int make_socks(struct svc_serv *serv, struct net *net,
196		const struct cred *cred)
197{
198	static int warned;
199	int err;
200
201	err = create_lockd_family(serv, net, PF_INET, cred);
202	if (err < 0)
203		goto out_err;
204
205	err = create_lockd_family(serv, net, PF_INET6, cred);
206	if (err < 0 && err != -EAFNOSUPPORT)
207		goto out_err;
208
209	warned = 0;
210	return 0;
211
212out_err:
213	if (warned++ == 0)
214		printk(KERN_WARNING
215			"lockd_up: makesock failed, error=%d\n", err);
216	svc_xprt_destroy_all(serv, net);
217	svc_rpcb_cleanup(serv, net);
218	return err;
219}
220
221static int lockd_up_net(struct svc_serv *serv, struct net *net,
222		const struct cred *cred)
223{
224	struct lockd_net *ln = net_generic(net, lockd_net_id);
225	int error;
226
227	if (ln->nlmsvc_users++)
228		return 0;
229
230	error = svc_bind(serv, net);
231	if (error)
232		goto err_bind;
233
234	error = make_socks(serv, net, cred);
235	if (error < 0)
236		goto err_bind;
237	set_grace_period(net);
238	dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum);
239	return 0;
240
241err_bind:
242	ln->nlmsvc_users--;
243	return error;
244}
245
246static void lockd_down_net(struct svc_serv *serv, struct net *net)
247{
248	struct lockd_net *ln = net_generic(net, lockd_net_id);
249
250	if (ln->nlmsvc_users) {
251		if (--ln->nlmsvc_users == 0) {
252			nlm_shutdown_hosts_net(net);
253			cancel_delayed_work_sync(&ln->grace_period_end);
254			locks_end_grace(&ln->lockd_manager);
255			svc_xprt_destroy_all(serv, net);
256			svc_rpcb_cleanup(serv, net);
257		}
258	} else {
259		pr_err("%s: no users! net=%x\n",
260			__func__, net->ns.inum);
261		BUG();
262	}
263}
264
265static int lockd_inetaddr_event(struct notifier_block *this,
266	unsigned long event, void *ptr)
267{
268	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
269	struct sockaddr_in sin;
270
271	if (event != NETDEV_DOWN)
272		goto out;
273
274	if (nlmsvc_serv) {
275		dprintk("lockd_inetaddr_event: removed %pI4\n",
276			&ifa->ifa_local);
277		sin.sin_family = AF_INET;
278		sin.sin_addr.s_addr = ifa->ifa_local;
279		svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin);
280	}
281
282out:
283	return NOTIFY_DONE;
284}
285
286static struct notifier_block lockd_inetaddr_notifier = {
287	.notifier_call = lockd_inetaddr_event,
288};
289
290#if IS_ENABLED(CONFIG_IPV6)
291static int lockd_inet6addr_event(struct notifier_block *this,
292	unsigned long event, void *ptr)
293{
294	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
295	struct sockaddr_in6 sin6;
296
297	if (event != NETDEV_DOWN)
298		goto out;
299
300	if (nlmsvc_serv) {
301		dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);
302		sin6.sin6_family = AF_INET6;
303		sin6.sin6_addr = ifa->addr;
304		if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
305			sin6.sin6_scope_id = ifa->idev->dev->ifindex;
306		svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6);
307	}
308
309out:
310	return NOTIFY_DONE;
311}
312
313static struct notifier_block lockd_inet6addr_notifier = {
314	.notifier_call = lockd_inet6addr_event,
315};
316#endif
317
318static int lockd_get(void)
319{
320	struct svc_serv *serv;
321	int error;
322
323	if (nlmsvc_serv) {
324		nlmsvc_users++;
325		return 0;
326	}
327
328	/*
329	 * Sanity check: if there's no pid,
330	 * we should be the first user ...
331	 */
332	if (nlmsvc_users)
333		printk(KERN_WARNING
334			"lockd_up: no pid, %d users??\n", nlmsvc_users);
335
336	if (!nlm_timeout)
337		nlm_timeout = LOCKD_DFLT_TIMEO;
338	nlmsvc_timeout = nlm_timeout * HZ;
339
340	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, lockd);
341	if (!serv) {
342		printk(KERN_WARNING "lockd_up: create service failed\n");
343		return -ENOMEM;
344	}
345
346	serv->sv_maxconn = nlm_max_connections;
347	error = svc_set_num_threads(serv, NULL, 1);
348	if (error < 0) {
349		svc_destroy(&serv);
350		return error;
351	}
352
353	nlmsvc_serv = serv;
354	register_inetaddr_notifier(&lockd_inetaddr_notifier);
355#if IS_ENABLED(CONFIG_IPV6)
356	register_inet6addr_notifier(&lockd_inet6addr_notifier);
357#endif
358	dprintk("lockd_up: service created\n");
359	nlmsvc_users++;
360	return 0;
361}
362
363static void lockd_put(void)
364{
365	if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n"))
366		return;
367	if (--nlmsvc_users)
368		return;
369
370	unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
371#if IS_ENABLED(CONFIG_IPV6)
372	unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
373#endif
374
375	svc_set_num_threads(nlmsvc_serv, NULL, 0);
376	timer_delete_sync(&nlmsvc_retry);
377	svc_destroy(&nlmsvc_serv);
378	dprintk("lockd_down: service destroyed\n");
379}
380
381/*
382 * Bring up the lockd process if it's not already up.
383 */
384int lockd_up(struct net *net, const struct cred *cred)
385{
386	int error;
387
388	mutex_lock(&nlmsvc_mutex);
389
390	error = lockd_get();
391	if (error)
392		goto err;
393
394	error = lockd_up_net(nlmsvc_serv, net, cred);
395	if (error < 0) {
396		lockd_put();
397		goto err;
398	}
399
400err:
401	mutex_unlock(&nlmsvc_mutex);
402	return error;
403}
404EXPORT_SYMBOL_GPL(lockd_up);
405
406/*
407 * Decrement the user count and bring down lockd if we're the last.
408 */
409void
410lockd_down(struct net *net)
411{
412	mutex_lock(&nlmsvc_mutex);
413	lockd_down_net(nlmsvc_serv, net);
414	lockd_put();
415	mutex_unlock(&nlmsvc_mutex);
416}
417EXPORT_SYMBOL_GPL(lockd_down);
418
419#ifdef CONFIG_SYSCTL
420
421/*
422 * Sysctl parameters (same as module parameters, different interface).
423 */
424
425static struct ctl_table nlm_sysctls[] = {
426	{
427		.procname	= "nlm_grace_period",
428		.data		= &nlm_grace_period,
429		.maxlen		= sizeof(unsigned long),
430		.mode		= 0644,
431		.proc_handler	= proc_doulongvec_minmax,
432		.extra1		= (unsigned long *) &nlm_grace_period_min,
433		.extra2		= (unsigned long *) &nlm_grace_period_max,
434	},
435	{
436		.procname	= "nlm_timeout",
437		.data		= &nlm_timeout,
438		.maxlen		= sizeof(unsigned long),
439		.mode		= 0644,
440		.proc_handler	= proc_doulongvec_minmax,
441		.extra1		= (unsigned long *) &nlm_timeout_min,
442		.extra2		= (unsigned long *) &nlm_timeout_max,
443	},
444	{
445		.procname	= "nlm_udpport",
446		.data		= &nlm_udpport,
447		.maxlen		= sizeof(int),
448		.mode		= 0644,
449		.proc_handler	= proc_dointvec_minmax,
450		.extra1		= (int *) &nlm_port_min,
451		.extra2		= (int *) &nlm_port_max,
452	},
453	{
454		.procname	= "nlm_tcpport",
455		.data		= &nlm_tcpport,
456		.maxlen		= sizeof(int),
457		.mode		= 0644,
458		.proc_handler	= proc_dointvec_minmax,
459		.extra1		= (int *) &nlm_port_min,
460		.extra2		= (int *) &nlm_port_max,
461	},
462	{
463		.procname	= "nsm_use_hostnames",
464		.data		= &nsm_use_hostnames,
465		.maxlen		= sizeof(bool),
466		.mode		= 0644,
467		.proc_handler	= proc_dobool,
468	},
469	{
470		.procname	= "nsm_local_state",
471		.data		= &nsm_local_state,
472		.maxlen		= sizeof(int),
473		.mode		= 0644,
474		.proc_handler	= proc_dointvec,
475	},
476};
477
478#endif	/* CONFIG_SYSCTL */
479
480/*
481 * Module (and sysfs) parameters.
482 */
483
484#define param_set_min_max(name, type, which_strtol, min, max)		\
485static int param_set_##name(const char *val, const struct kernel_param *kp) \
486{									\
487	char *endp;							\
488	__typeof__(type) num = which_strtol(val, &endp, 0);		\
489	if (endp == val || *endp || num < (min) || num > (max))		\
490		return -EINVAL;						\
491	*((type *) kp->arg) = num;					\
492	return 0;							\
493}
494
495static inline int is_callback(u32 proc)
496{
497	return proc == NLMPROC_GRANTED
498		|| proc == NLMPROC_GRANTED_MSG
499		|| proc == NLMPROC_TEST_RES
500		|| proc == NLMPROC_LOCK_RES
501		|| proc == NLMPROC_CANCEL_RES
502		|| proc == NLMPROC_UNLOCK_RES
503		|| proc == NLMPROC_NSM_NOTIFY;
504}
505
506
507static enum svc_auth_status lockd_authenticate(struct svc_rqst *rqstp)
508{
509	rqstp->rq_client = NULL;
510	switch (rqstp->rq_authop->flavour) {
511		case RPC_AUTH_NULL:
512		case RPC_AUTH_UNIX:
513			rqstp->rq_auth_stat = rpc_auth_ok;
514			if (rqstp->rq_proc == 0)
515				return SVC_OK;
516			if (is_callback(rqstp->rq_proc)) {
517				/* Leave it to individual procedures to
518				 * call nlmsvc_lookup_host(rqstp)
519				 */
520				return SVC_OK;
521			}
522			return svc_set_client(rqstp);
523	}
524	rqstp->rq_auth_stat = rpc_autherr_badcred;
525	return SVC_DENIED;
526}
527
528
529param_set_min_max(port, int, simple_strtol, 0, 65535)
530param_set_min_max(grace_period, unsigned long, simple_strtoul,
531		  nlm_grace_period_min, nlm_grace_period_max)
532param_set_min_max(timeout, unsigned long, simple_strtoul,
533		  nlm_timeout_min, nlm_timeout_max)
534
535MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
536MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
537MODULE_LICENSE("GPL");
538
539module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
540		  &nlm_grace_period, 0644);
541module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
542		  &nlm_timeout, 0644);
543module_param_call(nlm_udpport, param_set_port, param_get_int,
544		  &nlm_udpport, 0644);
545module_param_call(nlm_tcpport, param_set_port, param_get_int,
546		  &nlm_tcpport, 0644);
547module_param(nsm_use_hostnames, bool, 0644);
548module_param(nlm_max_connections, uint, 0644);
549
550static int lockd_init_net(struct net *net)
551{
552	struct lockd_net *ln = net_generic(net, lockd_net_id);
553
554	INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
555	INIT_LIST_HEAD(&ln->lockd_manager.list);
556	ln->lockd_manager.block_opens = false;
557	INIT_LIST_HEAD(&ln->nsm_handles);
558	return 0;
559}
560
561static void lockd_exit_net(struct net *net)
562{
563	struct lockd_net *ln = net_generic(net, lockd_net_id);
564
565	WARN_ONCE(!list_empty(&ln->lockd_manager.list),
566		  "net %x %s: lockd_manager.list is not empty\n",
567		  net->ns.inum, __func__);
568	WARN_ONCE(!list_empty(&ln->nsm_handles),
569		  "net %x %s: nsm_handles list is not empty\n",
570		  net->ns.inum, __func__);
571	WARN_ONCE(delayed_work_pending(&ln->grace_period_end),
572		  "net %x %s: grace_period_end was not cancelled\n",
573		  net->ns.inum, __func__);
574}
575
576static struct pernet_operations lockd_net_ops = {
577	.init = lockd_init_net,
578	.exit = lockd_exit_net,
579	.id = &lockd_net_id,
580	.size = sizeof(struct lockd_net),
581};
582
583
584/*
585 * Initialising and terminating the module.
586 */
587
588static int __init init_nlm(void)
589{
590	int err;
591
592#ifdef CONFIG_SYSCTL
593	err = -ENOMEM;
594	nlm_sysctl_table = register_sysctl("fs/nfs", nlm_sysctls);
595	if (nlm_sysctl_table == NULL)
596		goto err_sysctl;
597#endif
598	err = register_pernet_subsys(&lockd_net_ops);
599	if (err)
600		goto err_pernet;
601
602	err = lockd_create_procfs();
603	if (err)
604		goto err_procfs;
605
606	return 0;
607
608err_procfs:
609	unregister_pernet_subsys(&lockd_net_ops);
610err_pernet:
611#ifdef CONFIG_SYSCTL
612	unregister_sysctl_table(nlm_sysctl_table);
613err_sysctl:
614#endif
615	return err;
616}
617
618static void __exit exit_nlm(void)
619{
620	/* FIXME: delete all NLM clients */
621	nlm_shutdown_hosts();
622	lockd_remove_procfs();
623	unregister_pernet_subsys(&lockd_net_ops);
624#ifdef CONFIG_SYSCTL
625	unregister_sysctl_table(nlm_sysctl_table);
626#endif
627}
628
629module_init(init_nlm);
630module_exit(exit_nlm);
631
632/**
633 * nlmsvc_dispatch - Process an NLM Request
634 * @rqstp: incoming request
635 *
636 * Return values:
637 *  %0: Processing complete; do not send a Reply
638 *  %1: Processing complete; send Reply in rqstp->rq_res
639 */
640static int nlmsvc_dispatch(struct svc_rqst *rqstp)
641{
642	const struct svc_procedure *procp = rqstp->rq_procinfo;
643	__be32 *statp = rqstp->rq_accept_statp;
644
645	if (!procp->pc_decode(rqstp, &rqstp->rq_arg_stream))
646		goto out_decode_err;
647
648	*statp = procp->pc_func(rqstp);
649	if (*statp == rpc_drop_reply)
650		return 0;
651	if (*statp != rpc_success)
652		return 1;
653
654	if (!procp->pc_encode(rqstp, &rqstp->rq_res_stream))
655		goto out_encode_err;
656
657	return 1;
658
659out_decode_err:
660	*statp = rpc_garbage_args;
661	return 1;
662
663out_encode_err:
664	*statp = rpc_system_err;
665	return 1;
666}
667
668/*
669 * Define NLM program and procedures
670 */
671static DEFINE_PER_CPU_ALIGNED(unsigned long, nlmsvc_version1_count[17]);
672static const struct svc_version	nlmsvc_version1 = {
673	.vs_vers	= 1,
674	.vs_nproc	= 17,
675	.vs_proc	= nlmsvc_procedures,
676	.vs_count	= nlmsvc_version1_count,
677	.vs_dispatch	= nlmsvc_dispatch,
678	.vs_xdrsize	= NLMSVC_XDRSIZE,
679};
680
681static DEFINE_PER_CPU_ALIGNED(unsigned long,
682			      nlmsvc_version3_count[ARRAY_SIZE(nlmsvc_procedures)]);
683static const struct svc_version	nlmsvc_version3 = {
684	.vs_vers	= 3,
685	.vs_nproc	= ARRAY_SIZE(nlmsvc_procedures),
686	.vs_proc	= nlmsvc_procedures,
687	.vs_count	= nlmsvc_version3_count,
688	.vs_dispatch	= nlmsvc_dispatch,
689	.vs_xdrsize	= NLMSVC_XDRSIZE,
690};
691
692#ifdef CONFIG_LOCKD_V4
693static DEFINE_PER_CPU_ALIGNED(unsigned long,
694			      nlmsvc_version4_count[ARRAY_SIZE(nlmsvc_procedures4)]);
695static const struct svc_version	nlmsvc_version4 = {
696	.vs_vers	= 4,
697	.vs_nproc	= ARRAY_SIZE(nlmsvc_procedures4),
698	.vs_proc	= nlmsvc_procedures4,
699	.vs_count	= nlmsvc_version4_count,
700	.vs_dispatch	= nlmsvc_dispatch,
701	.vs_xdrsize	= NLMSVC_XDRSIZE,
702};
703#endif
704
705static const struct svc_version *nlmsvc_version[] = {
706	[1] = &nlmsvc_version1,
707	[3] = &nlmsvc_version3,
708#ifdef CONFIG_LOCKD_V4
709	[4] = &nlmsvc_version4,
710#endif
711};
712
713static struct svc_stat		nlmsvc_stats;
714
715#define NLM_NRVERS	ARRAY_SIZE(nlmsvc_version)
716static struct svc_program	nlmsvc_program = {
717	.pg_prog		= NLM_PROGRAM,		/* program number */
718	.pg_nvers		= NLM_NRVERS,		/* number of entries in nlmsvc_version */
719	.pg_vers		= nlmsvc_version,	/* version table */
720	.pg_name		= "lockd",		/* service name */
721	.pg_class		= "nfsd",		/* share authentication with nfsd */
722	.pg_stats		= &nlmsvc_stats,	/* stats table */
723	.pg_authenticate	= &lockd_authenticate,	/* export authentication */
724	.pg_init_request	= svc_generic_init_request,
725	.pg_rpcbind_set		= svc_generic_rpcbind_set,
726};

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/fs/lockd/svc.c
  4 *
  5 * This is the central lockd service.
  6 *
  7 * FIXME: Separate the lockd NFS server functionality from the lockd NFS
  8 * 	  client functionality. Oh why didn't Sun create two separate
  9 *	  services in the first place?
 10 *
 11 * Authors:	Olaf Kirch (okir@monad.swb.de)
 12 *
 13 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
 14 */
 15
 16#include <linux/module.h>
 17#include <linux/init.h>
 18#include <linux/sysctl.h>
 19#include <linux/moduleparam.h>
 20
 21#include <linux/sched/signal.h>
 22#include <linux/errno.h>
 23#include <linux/in.h>
 24#include <linux/uio.h>
 25#include <linux/smp.h>
 26#include <linux/mutex.h>
 27#include <linux/freezer.h>
 28#include <linux/inetdevice.h>
 29
 30#include <linux/sunrpc/types.h>
 31#include <linux/sunrpc/stats.h>
 32#include <linux/sunrpc/clnt.h>
 33#include <linux/sunrpc/svc.h>
 34#include <linux/sunrpc/svcsock.h>
 35#include <linux/sunrpc/svc_xprt.h>
 36#include <net/ip.h>
 37#include <net/addrconf.h>
 38#include <net/ipv6.h>
 39#include <linux/lockd/lockd.h>
 40#include <linux/nfs.h>
 41
 42#include "netns.h"
 43#include "procfs.h"
 44
 45#define NLMDBG_FACILITY		NLMDBG_SVC
 46#define LOCKD_BUFSIZE		(1024 + NLMSVC_XDRSIZE)
 47
 48static struct svc_program	nlmsvc_program;
 49
 50const struct nlmsvc_binding	*nlmsvc_ops;
 51EXPORT_SYMBOL_GPL(nlmsvc_ops);
 52
 53static DEFINE_MUTEX(nlmsvc_mutex);
 54static unsigned int		nlmsvc_users;
 55static struct svc_serv		*nlmsvc_serv;
 
 56
 57static void nlmsvc_request_retry(struct timer_list *tl)
 58{
 59	svc_wake_up(nlmsvc_serv);
 60}
 61DEFINE_TIMER(nlmsvc_retry, nlmsvc_request_retry);
 62
 63unsigned int lockd_net_id;
 64
 65/*
 66 * These can be set at insmod time (useful for NFS as root filesystem),
 67 * and also changed through the sysctl interface.  -- Jamie Lokier, Aug 2003
 68 */
 69static unsigned long		nlm_grace_period;
 70unsigned long			nlm_timeout = LOCKD_DFLT_TIMEO;
 71static int			nlm_udpport, nlm_tcpport;
 72
 73/* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
 74static unsigned int		nlm_max_connections = 1024;
 75
 76/*
 77 * Constants needed for the sysctl interface.
 78 */
 79static const unsigned long	nlm_grace_period_min = 0;
 80static const unsigned long	nlm_grace_period_max = 240;
 81static const unsigned long	nlm_timeout_min = 3;
 82static const unsigned long	nlm_timeout_max = 20;
 83
 84#ifdef CONFIG_SYSCTL
 85static const int		nlm_port_min = 0, nlm_port_max = 65535;
 86static struct ctl_table_header * nlm_sysctl_table;
 87#endif
 88
 89static unsigned long get_lockd_grace_period(void)
 90{
 91	/* Note: nlm_timeout should always be nonzero */
 92	if (nlm_grace_period)
 93		return roundup(nlm_grace_period, nlm_timeout) * HZ;
 94	else
 95		return nlm_timeout * 5 * HZ;
 96}
 97
 98static void grace_ender(struct work_struct *grace)
 99{
100	struct delayed_work *dwork = to_delayed_work(grace);
101	struct lockd_net *ln = container_of(dwork, struct lockd_net,
102					    grace_period_end);
103
104	locks_end_grace(&ln->lockd_manager);
105}
106
107static void set_grace_period(struct net *net)
108{
109	unsigned long grace_period = get_lockd_grace_period();
110	struct lockd_net *ln = net_generic(net, lockd_net_id);
111
112	locks_start_grace(net, &ln->lockd_manager);
113	cancel_delayed_work_sync(&ln->grace_period_end);
114	schedule_delayed_work(&ln->grace_period_end, grace_period);
115}
116
117/*
118 * This is the lockd kernel thread
119 */
120static int
121lockd(void *vrqstp)
122{
123	struct svc_rqst *rqstp = vrqstp;
124	struct net *net = &init_net;
125	struct lockd_net *ln = net_generic(net, lockd_net_id);
126
127	svc_thread_init_status(rqstp, 0);
128
129	/* try_to_freeze() is called from svc_recv() */
130	set_freezable();
131
132	dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
133
134	/*
135	 * The main request loop. We don't terminate until the last
136	 * NFS mount or NFS daemon has gone away.
137	 */
138	while (!svc_thread_should_stop(rqstp)) {
139		/* update sv_maxconn if it has changed */
140		rqstp->rq_server->sv_maxconn = nlm_max_connections;
141
142		nlmsvc_retry_blocked(rqstp);
143		svc_recv(rqstp);
144	}
145	if (nlmsvc_ops)
146		nlmsvc_invalidate_all();
147	nlm_shutdown_hosts();
148	cancel_delayed_work_sync(&ln->grace_period_end);
149	locks_end_grace(&ln->lockd_manager);
150
151	dprintk("lockd_down: service stopped\n");
152
153	svc_exit_thread(rqstp);
154	return 0;
155}
156
157static int create_lockd_listener(struct svc_serv *serv, const char *name,
158				 struct net *net, const int family,
159				 const unsigned short port,
160				 const struct cred *cred)
161{
162	struct svc_xprt *xprt;
163
164	xprt = svc_find_xprt(serv, name, net, family, 0);
165	if (xprt == NULL)
166		return svc_xprt_create(serv, name, net, family, port,
167				       SVC_SOCK_DEFAULTS, cred);
168	svc_xprt_put(xprt);
169	return 0;
170}
171
172static int create_lockd_family(struct svc_serv *serv, struct net *net,
173			       const int family, const struct cred *cred)
174{
175	int err;
176
177	err = create_lockd_listener(serv, "udp", net, family, nlm_udpport,
178			cred);
179	if (err < 0)
180		return err;
181
182	return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport,
183			cred);
184}
185
186/*
187 * Ensure there are active UDP and TCP listeners for lockd.
188 *
189 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
190 * local services (such as rpc.statd) still require UDP, and
191 * some NFS servers do not yet support NLM over TCP.
192 *
193 * Returns zero if all listeners are available; otherwise a
194 * negative errno value is returned.
195 */
196static int make_socks(struct svc_serv *serv, struct net *net,
197		const struct cred *cred)
198{
199	static int warned;
200	int err;
201
202	err = create_lockd_family(serv, net, PF_INET, cred);
203	if (err < 0)
204		goto out_err;
205
206	err = create_lockd_family(serv, net, PF_INET6, cred);
207	if (err < 0 && err != -EAFNOSUPPORT)
208		goto out_err;
209
210	warned = 0;
211	return 0;
212
213out_err:
214	if (warned++ == 0)
215		printk(KERN_WARNING
216			"lockd_up: makesock failed, error=%d\n", err);
217	svc_xprt_destroy_all(serv, net);
218	svc_rpcb_cleanup(serv, net);
219	return err;
220}
221
222static int lockd_up_net(struct svc_serv *serv, struct net *net,
223		const struct cred *cred)
224{
225	struct lockd_net *ln = net_generic(net, lockd_net_id);
226	int error;
227
228	if (ln->nlmsvc_users++)
229		return 0;
230
231	error = svc_bind(serv, net);
232	if (error)
233		goto err_bind;
234
235	error = make_socks(serv, net, cred);
236	if (error < 0)
237		goto err_bind;
238	set_grace_period(net);
239	dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum);
240	return 0;
241
242err_bind:
243	ln->nlmsvc_users--;
244	return error;
245}
246
247static void lockd_down_net(struct svc_serv *serv, struct net *net)
248{
249	struct lockd_net *ln = net_generic(net, lockd_net_id);
250
251	if (ln->nlmsvc_users) {
252		if (--ln->nlmsvc_users == 0) {
253			nlm_shutdown_hosts_net(net);
254			cancel_delayed_work_sync(&ln->grace_period_end);
255			locks_end_grace(&ln->lockd_manager);
256			svc_xprt_destroy_all(serv, net);
257			svc_rpcb_cleanup(serv, net);
258		}
259	} else {
260		pr_err("%s: no users! net=%x\n",
261			__func__, net->ns.inum);
262		BUG();
263	}
264}
265
266static int lockd_inetaddr_event(struct notifier_block *this,
267	unsigned long event, void *ptr)
268{
269	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
270	struct sockaddr_in sin;
271
272	if (event != NETDEV_DOWN)
273		goto out;
274
275	if (nlmsvc_serv) {
276		dprintk("lockd_inetaddr_event: removed %pI4\n",
277			&ifa->ifa_local);
278		sin.sin_family = AF_INET;
279		sin.sin_addr.s_addr = ifa->ifa_local;
280		svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin);
281	}
282
283out:
284	return NOTIFY_DONE;
285}
286
287static struct notifier_block lockd_inetaddr_notifier = {
288	.notifier_call = lockd_inetaddr_event,
289};
290
291#if IS_ENABLED(CONFIG_IPV6)
292static int lockd_inet6addr_event(struct notifier_block *this,
293	unsigned long event, void *ptr)
294{
295	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
296	struct sockaddr_in6 sin6;
297
298	if (event != NETDEV_DOWN)
299		goto out;
300
301	if (nlmsvc_serv) {
302		dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);
303		sin6.sin6_family = AF_INET6;
304		sin6.sin6_addr = ifa->addr;
305		if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
306			sin6.sin6_scope_id = ifa->idev->dev->ifindex;
307		svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6);
308	}
309
310out:
311	return NOTIFY_DONE;
312}
313
314static struct notifier_block lockd_inet6addr_notifier = {
315	.notifier_call = lockd_inet6addr_event,
316};
317#endif
318
319static int lockd_get(void)
320{
321	struct svc_serv *serv;
322	int error;
323
324	if (nlmsvc_serv) {
325		nlmsvc_users++;
326		return 0;
327	}
328
329	/*
330	 * Sanity check: if there's no pid,
331	 * we should be the first user ...
332	 */
333	if (nlmsvc_users)
334		printk(KERN_WARNING
335			"lockd_up: no pid, %d users??\n", nlmsvc_users);
336
 
 
 
 
337	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, lockd);
338	if (!serv) {
339		printk(KERN_WARNING "lockd_up: create service failed\n");
340		return -ENOMEM;
341	}
342
343	serv->sv_maxconn = nlm_max_connections;
344	error = svc_set_num_threads(serv, NULL, 1);
345	if (error < 0) {
346		svc_destroy(&serv);
347		return error;
348	}
349
350	nlmsvc_serv = serv;
351	register_inetaddr_notifier(&lockd_inetaddr_notifier);
352#if IS_ENABLED(CONFIG_IPV6)
353	register_inet6addr_notifier(&lockd_inet6addr_notifier);
354#endif
355	dprintk("lockd_up: service created\n");
356	nlmsvc_users++;
357	return 0;
358}
359
360static void lockd_put(void)
361{
362	if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n"))
363		return;
364	if (--nlmsvc_users)
365		return;
366
367	unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
368#if IS_ENABLED(CONFIG_IPV6)
369	unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
370#endif
371
372	svc_set_num_threads(nlmsvc_serv, NULL, 0);
373	timer_delete_sync(&nlmsvc_retry);
374	svc_destroy(&nlmsvc_serv);
375	dprintk("lockd_down: service destroyed\n");
376}
377
378/*
379 * Bring up the lockd process if it's not already up.
380 */
381int lockd_up(struct net *net, const struct cred *cred)
382{
383	int error;
384
385	mutex_lock(&nlmsvc_mutex);
386
387	error = lockd_get();
388	if (error)
389		goto err;
390
391	error = lockd_up_net(nlmsvc_serv, net, cred);
392	if (error < 0) {
393		lockd_put();
394		goto err;
395	}
396
397err:
398	mutex_unlock(&nlmsvc_mutex);
399	return error;
400}
401EXPORT_SYMBOL_GPL(lockd_up);
402
403/*
404 * Decrement the user count and bring down lockd if we're the last.
405 */
406void
407lockd_down(struct net *net)
408{
409	mutex_lock(&nlmsvc_mutex);
410	lockd_down_net(nlmsvc_serv, net);
411	lockd_put();
412	mutex_unlock(&nlmsvc_mutex);
413}
414EXPORT_SYMBOL_GPL(lockd_down);
415
416#ifdef CONFIG_SYSCTL
417
418/*
419 * Sysctl parameters (same as module parameters, different interface).
420 */
421
422static struct ctl_table nlm_sysctls[] = {
423	{
424		.procname	= "nlm_grace_period",
425		.data		= &nlm_grace_period,
426		.maxlen		= sizeof(unsigned long),
427		.mode		= 0644,
428		.proc_handler	= proc_doulongvec_minmax,
429		.extra1		= (unsigned long *) &nlm_grace_period_min,
430		.extra2		= (unsigned long *) &nlm_grace_period_max,
431	},
432	{
433		.procname	= "nlm_timeout",
434		.data		= &nlm_timeout,
435		.maxlen		= sizeof(unsigned long),
436		.mode		= 0644,
437		.proc_handler	= proc_doulongvec_minmax,
438		.extra1		= (unsigned long *) &nlm_timeout_min,
439		.extra2		= (unsigned long *) &nlm_timeout_max,
440	},
441	{
442		.procname	= "nlm_udpport",
443		.data		= &nlm_udpport,
444		.maxlen		= sizeof(int),
445		.mode		= 0644,
446		.proc_handler	= proc_dointvec_minmax,
447		.extra1		= (int *) &nlm_port_min,
448		.extra2		= (int *) &nlm_port_max,
449	},
450	{
451		.procname	= "nlm_tcpport",
452		.data		= &nlm_tcpport,
453		.maxlen		= sizeof(int),
454		.mode		= 0644,
455		.proc_handler	= proc_dointvec_minmax,
456		.extra1		= (int *) &nlm_port_min,
457		.extra2		= (int *) &nlm_port_max,
458	},
459	{
460		.procname	= "nsm_use_hostnames",
461		.data		= &nsm_use_hostnames,
462		.maxlen		= sizeof(bool),
463		.mode		= 0644,
464		.proc_handler	= proc_dobool,
465	},
466	{
467		.procname	= "nsm_local_state",
468		.data		= &nsm_local_state,
469		.maxlen		= sizeof(int),
470		.mode		= 0644,
471		.proc_handler	= proc_dointvec,
472	},
473};
474
475#endif	/* CONFIG_SYSCTL */
476
477/*
478 * Module (and sysfs) parameters.
479 */
480
481#define param_set_min_max(name, type, which_strtol, min, max)		\
482static int param_set_##name(const char *val, const struct kernel_param *kp) \
483{									\
484	char *endp;							\
485	__typeof__(type) num = which_strtol(val, &endp, 0);		\
486	if (endp == val || *endp || num < (min) || num > (max))		\
487		return -EINVAL;						\
488	*((type *) kp->arg) = num;					\
489	return 0;							\
490}
491
492static inline int is_callback(u32 proc)
493{
494	return proc == NLMPROC_GRANTED
495		|| proc == NLMPROC_GRANTED_MSG
496		|| proc == NLMPROC_TEST_RES
497		|| proc == NLMPROC_LOCK_RES
498		|| proc == NLMPROC_CANCEL_RES
499		|| proc == NLMPROC_UNLOCK_RES
500		|| proc == NLMPROC_NSM_NOTIFY;
501}
502
503
504static enum svc_auth_status lockd_authenticate(struct svc_rqst *rqstp)
505{
506	rqstp->rq_client = NULL;
507	switch (rqstp->rq_authop->flavour) {
508		case RPC_AUTH_NULL:
509		case RPC_AUTH_UNIX:
510			rqstp->rq_auth_stat = rpc_auth_ok;
511			if (rqstp->rq_proc == 0)
512				return SVC_OK;
513			if (is_callback(rqstp->rq_proc)) {
514				/* Leave it to individual procedures to
515				 * call nlmsvc_lookup_host(rqstp)
516				 */
517				return SVC_OK;
518			}
519			return svc_set_client(rqstp);
520	}
521	rqstp->rq_auth_stat = rpc_autherr_badcred;
522	return SVC_DENIED;
523}
524
525
526param_set_min_max(port, int, simple_strtol, 0, 65535)
527param_set_min_max(grace_period, unsigned long, simple_strtoul,
528		  nlm_grace_period_min, nlm_grace_period_max)
529param_set_min_max(timeout, unsigned long, simple_strtoul,
530		  nlm_timeout_min, nlm_timeout_max)
531
532MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
533MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
534MODULE_LICENSE("GPL");
535
536module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
537		  &nlm_grace_period, 0644);
538module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
539		  &nlm_timeout, 0644);
540module_param_call(nlm_udpport, param_set_port, param_get_int,
541		  &nlm_udpport, 0644);
542module_param_call(nlm_tcpport, param_set_port, param_get_int,
543		  &nlm_tcpport, 0644);
544module_param(nsm_use_hostnames, bool, 0644);
545module_param(nlm_max_connections, uint, 0644);
546
547static int lockd_init_net(struct net *net)
548{
549	struct lockd_net *ln = net_generic(net, lockd_net_id);
550
551	INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
552	INIT_LIST_HEAD(&ln->lockd_manager.list);
553	ln->lockd_manager.block_opens = false;
554	INIT_LIST_HEAD(&ln->nsm_handles);
555	return 0;
556}
557
558static void lockd_exit_net(struct net *net)
559{
560	struct lockd_net *ln = net_generic(net, lockd_net_id);
561
562	WARN_ONCE(!list_empty(&ln->lockd_manager.list),
563		  "net %x %s: lockd_manager.list is not empty\n",
564		  net->ns.inum, __func__);
565	WARN_ONCE(!list_empty(&ln->nsm_handles),
566		  "net %x %s: nsm_handles list is not empty\n",
567		  net->ns.inum, __func__);
568	WARN_ONCE(delayed_work_pending(&ln->grace_period_end),
569		  "net %x %s: grace_period_end was not cancelled\n",
570		  net->ns.inum, __func__);
571}
572
573static struct pernet_operations lockd_net_ops = {
574	.init = lockd_init_net,
575	.exit = lockd_exit_net,
576	.id = &lockd_net_id,
577	.size = sizeof(struct lockd_net),
578};
579
580
581/*
582 * Initialising and terminating the module.
583 */
584
585static int __init init_nlm(void)
586{
587	int err;
588
589#ifdef CONFIG_SYSCTL
590	err = -ENOMEM;
591	nlm_sysctl_table = register_sysctl("fs/nfs", nlm_sysctls);
592	if (nlm_sysctl_table == NULL)
593		goto err_sysctl;
594#endif
595	err = register_pernet_subsys(&lockd_net_ops);
596	if (err)
597		goto err_pernet;
598
599	err = lockd_create_procfs();
600	if (err)
601		goto err_procfs;
602
603	return 0;
604
605err_procfs:
606	unregister_pernet_subsys(&lockd_net_ops);
607err_pernet:
608#ifdef CONFIG_SYSCTL
609	unregister_sysctl_table(nlm_sysctl_table);
610err_sysctl:
611#endif
612	return err;
613}
614
615static void __exit exit_nlm(void)
616{
617	/* FIXME: delete all NLM clients */
618	nlm_shutdown_hosts();
619	lockd_remove_procfs();
620	unregister_pernet_subsys(&lockd_net_ops);
621#ifdef CONFIG_SYSCTL
622	unregister_sysctl_table(nlm_sysctl_table);
623#endif
624}
625
626module_init(init_nlm);
627module_exit(exit_nlm);
628
629/**
630 * nlmsvc_dispatch - Process an NLM Request
631 * @rqstp: incoming request
632 *
633 * Return values:
634 *  %0: Processing complete; do not send a Reply
635 *  %1: Processing complete; send Reply in rqstp->rq_res
636 */
637static int nlmsvc_dispatch(struct svc_rqst *rqstp)
638{
639	const struct svc_procedure *procp = rqstp->rq_procinfo;
640	__be32 *statp = rqstp->rq_accept_statp;
641
642	if (!procp->pc_decode(rqstp, &rqstp->rq_arg_stream))
643		goto out_decode_err;
644
645	*statp = procp->pc_func(rqstp);
646	if (*statp == rpc_drop_reply)
647		return 0;
648	if (*statp != rpc_success)
649		return 1;
650
651	if (!procp->pc_encode(rqstp, &rqstp->rq_res_stream))
652		goto out_encode_err;
653
654	return 1;
655
656out_decode_err:
657	*statp = rpc_garbage_args;
658	return 1;
659
660out_encode_err:
661	*statp = rpc_system_err;
662	return 1;
663}
664
665/*
666 * Define NLM program and procedures
667 */
668static DEFINE_PER_CPU_ALIGNED(unsigned long, nlmsvc_version1_count[17]);
669static const struct svc_version	nlmsvc_version1 = {
670	.vs_vers	= 1,
671	.vs_nproc	= 17,
672	.vs_proc	= nlmsvc_procedures,
673	.vs_count	= nlmsvc_version1_count,
674	.vs_dispatch	= nlmsvc_dispatch,
675	.vs_xdrsize	= NLMSVC_XDRSIZE,
676};
677
678static DEFINE_PER_CPU_ALIGNED(unsigned long,
679			      nlmsvc_version3_count[ARRAY_SIZE(nlmsvc_procedures)]);
680static const struct svc_version	nlmsvc_version3 = {
681	.vs_vers	= 3,
682	.vs_nproc	= ARRAY_SIZE(nlmsvc_procedures),
683	.vs_proc	= nlmsvc_procedures,
684	.vs_count	= nlmsvc_version3_count,
685	.vs_dispatch	= nlmsvc_dispatch,
686	.vs_xdrsize	= NLMSVC_XDRSIZE,
687};
688
689#ifdef CONFIG_LOCKD_V4
690static DEFINE_PER_CPU_ALIGNED(unsigned long,
691			      nlmsvc_version4_count[ARRAY_SIZE(nlmsvc_procedures4)]);
692static const struct svc_version	nlmsvc_version4 = {
693	.vs_vers	= 4,
694	.vs_nproc	= ARRAY_SIZE(nlmsvc_procedures4),
695	.vs_proc	= nlmsvc_procedures4,
696	.vs_count	= nlmsvc_version4_count,
697	.vs_dispatch	= nlmsvc_dispatch,
698	.vs_xdrsize	= NLMSVC_XDRSIZE,
699};
700#endif
701
702static const struct svc_version *nlmsvc_version[] = {
703	[1] = &nlmsvc_version1,
704	[3] = &nlmsvc_version3,
705#ifdef CONFIG_LOCKD_V4
706	[4] = &nlmsvc_version4,
707#endif
708};
709
 
 
710#define NLM_NRVERS	ARRAY_SIZE(nlmsvc_version)
711static struct svc_program	nlmsvc_program = {
712	.pg_prog		= NLM_PROGRAM,		/* program number */
713	.pg_nvers		= NLM_NRVERS,		/* number of entries in nlmsvc_version */
714	.pg_vers		= nlmsvc_version,	/* version table */
715	.pg_name		= "lockd",		/* service name */
716	.pg_class		= "nfsd",		/* share authentication with nfsd */
 
717	.pg_authenticate	= &lockd_authenticate,	/* export authentication */
718	.pg_init_request	= svc_generic_init_request,
719	.pg_rpcbind_set		= svc_generic_rpcbind_set,
720};