1 /*
2  * linux/fs/lockd/svc.c
3  *
4  * This is the central lockd service.
5  *
6  * FIXME: Separate the lockd NFS server functionality from the lockd NFS
7  * 	  client functionality. Oh why didn't Sun create two separate
8  *	  services in the first place?
9  *
10  * Authors:	Olaf Kirch (okir@monad.swb.de)
11  *
12  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
13  */
14 
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/sysctl.h>
18 #include <linux/moduleparam.h>
19 
20 #include <linux/sched/signal.h>
21 #include <linux/errno.h>
22 #include <linux/in.h>
23 #include <linux/uio.h>
24 #include <linux/smp.h>
25 #include <linux/mutex.h>
26 #include <linux/kthread.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 #define ALLOWED_SIGS		(sigmask(SIGKILL))
48 
49 static struct svc_program	nlmsvc_program;
50 
51 const struct nlmsvc_binding	*nlmsvc_ops;
52 EXPORT_SYMBOL_GPL(nlmsvc_ops);
53 
54 static DEFINE_MUTEX(nlmsvc_mutex);
55 static unsigned int		nlmsvc_users;
56 static struct task_struct	*nlmsvc_task;
57 static struct svc_rqst		*nlmsvc_rqst;
58 unsigned long			nlmsvc_timeout;
59 
60 static atomic_t nlm_ntf_refcnt = ATOMIC_INIT(0);
61 static DECLARE_WAIT_QUEUE_HEAD(nlm_ntf_wq);
62 
63 unsigned 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  */
69 static unsigned long		nlm_grace_period;
70 static unsigned long		nlm_timeout = LOCKD_DFLT_TIMEO;
71 static int			nlm_udpport, nlm_tcpport;
72 
73 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
74 static unsigned int		nlm_max_connections = 1024;
75 
76 /*
77  * Constants needed for the sysctl interface.
78  */
79 static const unsigned long	nlm_grace_period_min = 0;
80 static const unsigned long	nlm_grace_period_max = 240;
81 static const unsigned long	nlm_timeout_min = 3;
82 static const unsigned long	nlm_timeout_max = 20;
83 static const int		nlm_port_min = 0, nlm_port_max = 65535;
84 
85 #ifdef CONFIG_SYSCTL
86 static struct ctl_table_header * nlm_sysctl_table;
87 #endif
88 
get_lockd_grace_period(void)89 static 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 
grace_ender(struct work_struct * grace)98 static 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 
set_grace_period(struct net * net)107 static 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 
restart_grace(void)117 static void restart_grace(void)
118 {
119 	if (nlmsvc_ops) {
120 		struct net *net = &init_net;
121 		struct lockd_net *ln = net_generic(net, lockd_net_id);
122 
123 		cancel_delayed_work_sync(&ln->grace_period_end);
124 		locks_end_grace(&ln->lockd_manager);
125 		nlmsvc_invalidate_all();
126 		set_grace_period(net);
127 	}
128 }
129 
130 /*
131  * This is the lockd kernel thread
132  */
133 static int
lockd(void * vrqstp)134 lockd(void *vrqstp)
135 {
136 	int		err = 0;
137 	struct svc_rqst *rqstp = vrqstp;
138 	struct net *net = &init_net;
139 	struct lockd_net *ln = net_generic(net, lockd_net_id);
140 
141 	/* try_to_freeze() is called from svc_recv() */
142 	set_freezable();
143 
144 	/* Allow SIGKILL to tell lockd to drop all of its locks */
145 	allow_signal(SIGKILL);
146 
147 	dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
148 
149 	/*
150 	 * The main request loop. We don't terminate until the last
151 	 * NFS mount or NFS daemon has gone away.
152 	 */
153 	while (!kthread_should_stop()) {
154 		long timeout = MAX_SCHEDULE_TIMEOUT;
155 		RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
156 
157 		/* update sv_maxconn if it has changed */
158 		rqstp->rq_server->sv_maxconn = nlm_max_connections;
159 
160 		if (signalled()) {
161 			flush_signals(current);
162 			restart_grace();
163 			continue;
164 		}
165 
166 		timeout = nlmsvc_retry_blocked();
167 
168 		/*
169 		 * Find a socket with data available and call its
170 		 * recvfrom routine.
171 		 */
172 		err = svc_recv(rqstp, timeout);
173 		if (err == -EAGAIN || err == -EINTR)
174 			continue;
175 		dprintk("lockd: request from %s\n",
176 				svc_print_addr(rqstp, buf, sizeof(buf)));
177 
178 		svc_process(rqstp);
179 	}
180 	flush_signals(current);
181 	if (nlmsvc_ops)
182 		nlmsvc_invalidate_all();
183 	nlm_shutdown_hosts();
184 	cancel_delayed_work_sync(&ln->grace_period_end);
185 	locks_end_grace(&ln->lockd_manager);
186 	return 0;
187 }
188 
create_lockd_listener(struct svc_serv * serv,const char * name,struct net * net,const int family,const unsigned short port)189 static int create_lockd_listener(struct svc_serv *serv, const char *name,
190 				 struct net *net, const int family,
191 				 const unsigned short port)
192 {
193 	struct svc_xprt *xprt;
194 
195 	xprt = svc_find_xprt(serv, name, net, family, 0);
196 	if (xprt == NULL)
197 		return svc_create_xprt(serv, name, net, family, port,
198 						SVC_SOCK_DEFAULTS);
199 	svc_xprt_put(xprt);
200 	return 0;
201 }
202 
create_lockd_family(struct svc_serv * serv,struct net * net,const int family)203 static int create_lockd_family(struct svc_serv *serv, struct net *net,
204 			       const int family)
205 {
206 	int err;
207 
208 	err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
209 	if (err < 0)
210 		return err;
211 
212 	return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
213 }
214 
215 /*
216  * Ensure there are active UDP and TCP listeners for lockd.
217  *
218  * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
219  * local services (such as rpc.statd) still require UDP, and
220  * some NFS servers do not yet support NLM over TCP.
221  *
222  * Returns zero if all listeners are available; otherwise a
223  * negative errno value is returned.
224  */
make_socks(struct svc_serv * serv,struct net * net)225 static int make_socks(struct svc_serv *serv, struct net *net)
226 {
227 	static int warned;
228 	int err;
229 
230 	err = create_lockd_family(serv, net, PF_INET);
231 	if (err < 0)
232 		goto out_err;
233 
234 	err = create_lockd_family(serv, net, PF_INET6);
235 	if (err < 0 && err != -EAFNOSUPPORT)
236 		goto out_err;
237 
238 	warned = 0;
239 	return 0;
240 
241 out_err:
242 	if (warned++ == 0)
243 		printk(KERN_WARNING
244 			"lockd_up: makesock failed, error=%d\n", err);
245 	svc_shutdown_net(serv, net);
246 	return err;
247 }
248 
lockd_up_net(struct svc_serv * serv,struct net * net)249 static int lockd_up_net(struct svc_serv *serv, struct net *net)
250 {
251 	struct lockd_net *ln = net_generic(net, lockd_net_id);
252 	int error;
253 
254 	if (ln->nlmsvc_users++)
255 		return 0;
256 
257 	error = svc_bind(serv, net);
258 	if (error)
259 		goto err_bind;
260 
261 	error = make_socks(serv, net);
262 	if (error < 0)
263 		goto err_bind;
264 	set_grace_period(net);
265 	dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum);
266 	return 0;
267 
268 err_bind:
269 	ln->nlmsvc_users--;
270 	return error;
271 }
272 
lockd_down_net(struct svc_serv * serv,struct net * net)273 static void lockd_down_net(struct svc_serv *serv, struct net *net)
274 {
275 	struct lockd_net *ln = net_generic(net, lockd_net_id);
276 
277 	if (ln->nlmsvc_users) {
278 		if (--ln->nlmsvc_users == 0) {
279 			nlm_shutdown_hosts_net(net);
280 			cancel_delayed_work_sync(&ln->grace_period_end);
281 			locks_end_grace(&ln->lockd_manager);
282 			svc_shutdown_net(serv, net);
283 			dprintk("%s: per-net data destroyed; net=%x\n",
284 				__func__, net->ns.inum);
285 		}
286 	} else {
287 		pr_err("%s: no users! task=%p, net=%x\n",
288 			__func__, nlmsvc_task, net->ns.inum);
289 		BUG();
290 	}
291 }
292 
lockd_inetaddr_event(struct notifier_block * this,unsigned long event,void * ptr)293 static int lockd_inetaddr_event(struct notifier_block *this,
294 	unsigned long event, void *ptr)
295 {
296 	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
297 	struct sockaddr_in sin;
298 
299 	if ((event != NETDEV_DOWN) ||
300 	    !atomic_inc_not_zero(&nlm_ntf_refcnt))
301 		goto out;
302 
303 	if (nlmsvc_rqst) {
304 		dprintk("lockd_inetaddr_event: removed %pI4\n",
305 			&ifa->ifa_local);
306 		sin.sin_family = AF_INET;
307 		sin.sin_addr.s_addr = ifa->ifa_local;
308 		svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,
309 			(struct sockaddr *)&sin);
310 	}
311 	atomic_dec(&nlm_ntf_refcnt);
312 	wake_up(&nlm_ntf_wq);
313 
314 out:
315 	return NOTIFY_DONE;
316 }
317 
318 static struct notifier_block lockd_inetaddr_notifier = {
319 	.notifier_call = lockd_inetaddr_event,
320 };
321 
322 #if IS_ENABLED(CONFIG_IPV6)
lockd_inet6addr_event(struct notifier_block * this,unsigned long event,void * ptr)323 static int lockd_inet6addr_event(struct notifier_block *this,
324 	unsigned long event, void *ptr)
325 {
326 	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
327 	struct sockaddr_in6 sin6;
328 
329 	if ((event != NETDEV_DOWN) ||
330 	    !atomic_inc_not_zero(&nlm_ntf_refcnt))
331 		goto out;
332 
333 	if (nlmsvc_rqst) {
334 		dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);
335 		sin6.sin6_family = AF_INET6;
336 		sin6.sin6_addr = ifa->addr;
337 		if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
338 			sin6.sin6_scope_id = ifa->idev->dev->ifindex;
339 		svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,
340 			(struct sockaddr *)&sin6);
341 	}
342 	atomic_dec(&nlm_ntf_refcnt);
343 	wake_up(&nlm_ntf_wq);
344 
345 out:
346 	return NOTIFY_DONE;
347 }
348 
349 static struct notifier_block lockd_inet6addr_notifier = {
350 	.notifier_call = lockd_inet6addr_event,
351 };
352 #endif
353 
lockd_unregister_notifiers(void)354 static void lockd_unregister_notifiers(void)
355 {
356 	unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
357 #if IS_ENABLED(CONFIG_IPV6)
358 	unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
359 #endif
360 	wait_event(nlm_ntf_wq, atomic_read(&nlm_ntf_refcnt) == 0);
361 }
362 
lockd_svc_exit_thread(void)363 static void lockd_svc_exit_thread(void)
364 {
365 	atomic_dec(&nlm_ntf_refcnt);
366 	lockd_unregister_notifiers();
367 	svc_exit_thread(nlmsvc_rqst);
368 }
369 
lockd_start_svc(struct svc_serv * serv)370 static int lockd_start_svc(struct svc_serv *serv)
371 {
372 	int error;
373 
374 	if (nlmsvc_rqst)
375 		return 0;
376 
377 	/*
378 	 * Create the kernel thread and wait for it to start.
379 	 */
380 	nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
381 	if (IS_ERR(nlmsvc_rqst)) {
382 		error = PTR_ERR(nlmsvc_rqst);
383 		printk(KERN_WARNING
384 			"lockd_up: svc_rqst allocation failed, error=%d\n",
385 			error);
386 		lockd_unregister_notifiers();
387 		goto out_rqst;
388 	}
389 
390 	atomic_inc(&nlm_ntf_refcnt);
391 	svc_sock_update_bufs(serv);
392 	serv->sv_maxconn = nlm_max_connections;
393 
394 	nlmsvc_task = kthread_create(lockd, nlmsvc_rqst, "%s", serv->sv_name);
395 	if (IS_ERR(nlmsvc_task)) {
396 		error = PTR_ERR(nlmsvc_task);
397 		printk(KERN_WARNING
398 			"lockd_up: kthread_run failed, error=%d\n", error);
399 		goto out_task;
400 	}
401 	nlmsvc_rqst->rq_task = nlmsvc_task;
402 	wake_up_process(nlmsvc_task);
403 
404 	dprintk("lockd_up: service started\n");
405 	return 0;
406 
407 out_task:
408 	lockd_svc_exit_thread();
409 	nlmsvc_task = NULL;
410 out_rqst:
411 	nlmsvc_rqst = NULL;
412 	return error;
413 }
414 
415 static const struct svc_serv_ops lockd_sv_ops = {
416 	.svo_shutdown		= svc_rpcb_cleanup,
417 	.svo_enqueue_xprt	= svc_xprt_do_enqueue,
418 };
419 
lockd_create_svc(void)420 static struct svc_serv *lockd_create_svc(void)
421 {
422 	struct svc_serv *serv;
423 
424 	/*
425 	 * Check whether we're already up and running.
426 	 */
427 	if (nlmsvc_rqst) {
428 		/*
429 		 * Note: increase service usage, because later in case of error
430 		 * svc_destroy() will be called.
431 		 */
432 		svc_get(nlmsvc_rqst->rq_server);
433 		return nlmsvc_rqst->rq_server;
434 	}
435 
436 	/*
437 	 * Sanity check: if there's no pid,
438 	 * we should be the first user ...
439 	 */
440 	if (nlmsvc_users)
441 		printk(KERN_WARNING
442 			"lockd_up: no pid, %d users??\n", nlmsvc_users);
443 
444 	if (!nlm_timeout)
445 		nlm_timeout = LOCKD_DFLT_TIMEO;
446 	nlmsvc_timeout = nlm_timeout * HZ;
447 
448 	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops);
449 	if (!serv) {
450 		printk(KERN_WARNING "lockd_up: create service failed\n");
451 		return ERR_PTR(-ENOMEM);
452 	}
453 	register_inetaddr_notifier(&lockd_inetaddr_notifier);
454 #if IS_ENABLED(CONFIG_IPV6)
455 	register_inet6addr_notifier(&lockd_inet6addr_notifier);
456 #endif
457 	dprintk("lockd_up: service created\n");
458 	return serv;
459 }
460 
461 /*
462  * Bring up the lockd process if it's not already up.
463  */
lockd_up(struct net * net)464 int lockd_up(struct net *net)
465 {
466 	struct svc_serv *serv;
467 	int error;
468 
469 	mutex_lock(&nlmsvc_mutex);
470 
471 	serv = lockd_create_svc();
472 	if (IS_ERR(serv)) {
473 		error = PTR_ERR(serv);
474 		goto err_create;
475 	}
476 
477 	error = lockd_up_net(serv, net);
478 	if (error < 0) {
479 		lockd_unregister_notifiers();
480 		goto err_put;
481 	}
482 
483 	error = lockd_start_svc(serv);
484 	if (error < 0) {
485 		lockd_down_net(serv, net);
486 		goto err_put;
487 	}
488 	nlmsvc_users++;
489 	/*
490 	 * Note: svc_serv structures have an initial use count of 1,
491 	 * so we exit through here on both success and failure.
492 	 */
493 err_put:
494 	svc_destroy(serv);
495 err_create:
496 	mutex_unlock(&nlmsvc_mutex);
497 	return error;
498 }
499 EXPORT_SYMBOL_GPL(lockd_up);
500 
501 /*
502  * Decrement the user count and bring down lockd if we're the last.
503  */
504 void
lockd_down(struct net * net)505 lockd_down(struct net *net)
506 {
507 	mutex_lock(&nlmsvc_mutex);
508 	lockd_down_net(nlmsvc_rqst->rq_server, net);
509 	if (nlmsvc_users) {
510 		if (--nlmsvc_users)
511 			goto out;
512 	} else {
513 		printk(KERN_ERR "lockd_down: no users! task=%p\n",
514 			nlmsvc_task);
515 		BUG();
516 	}
517 
518 	if (!nlmsvc_task) {
519 		printk(KERN_ERR "lockd_down: no lockd running.\n");
520 		BUG();
521 	}
522 	kthread_stop(nlmsvc_task);
523 	dprintk("lockd_down: service stopped\n");
524 	lockd_svc_exit_thread();
525 	dprintk("lockd_down: service destroyed\n");
526 	nlmsvc_task = NULL;
527 	nlmsvc_rqst = NULL;
528 out:
529 	mutex_unlock(&nlmsvc_mutex);
530 }
531 EXPORT_SYMBOL_GPL(lockd_down);
532 
533 #ifdef CONFIG_SYSCTL
534 
535 /*
536  * Sysctl parameters (same as module parameters, different interface).
537  */
538 
539 static struct ctl_table nlm_sysctls[] = {
540 	{
541 		.procname	= "nlm_grace_period",
542 		.data		= &nlm_grace_period,
543 		.maxlen		= sizeof(unsigned long),
544 		.mode		= 0644,
545 		.proc_handler	= proc_doulongvec_minmax,
546 		.extra1		= (unsigned long *) &nlm_grace_period_min,
547 		.extra2		= (unsigned long *) &nlm_grace_period_max,
548 	},
549 	{
550 		.procname	= "nlm_timeout",
551 		.data		= &nlm_timeout,
552 		.maxlen		= sizeof(unsigned long),
553 		.mode		= 0644,
554 		.proc_handler	= proc_doulongvec_minmax,
555 		.extra1		= (unsigned long *) &nlm_timeout_min,
556 		.extra2		= (unsigned long *) &nlm_timeout_max,
557 	},
558 	{
559 		.procname	= "nlm_udpport",
560 		.data		= &nlm_udpport,
561 		.maxlen		= sizeof(int),
562 		.mode		= 0644,
563 		.proc_handler	= proc_dointvec_minmax,
564 		.extra1		= (int *) &nlm_port_min,
565 		.extra2		= (int *) &nlm_port_max,
566 	},
567 	{
568 		.procname	= "nlm_tcpport",
569 		.data		= &nlm_tcpport,
570 		.maxlen		= sizeof(int),
571 		.mode		= 0644,
572 		.proc_handler	= proc_dointvec_minmax,
573 		.extra1		= (int *) &nlm_port_min,
574 		.extra2		= (int *) &nlm_port_max,
575 	},
576 	{
577 		.procname	= "nsm_use_hostnames",
578 		.data		= &nsm_use_hostnames,
579 		.maxlen		= sizeof(int),
580 		.mode		= 0644,
581 		.proc_handler	= proc_dointvec,
582 	},
583 	{
584 		.procname	= "nsm_local_state",
585 		.data		= &nsm_local_state,
586 		.maxlen		= sizeof(int),
587 		.mode		= 0644,
588 		.proc_handler	= proc_dointvec,
589 	},
590 	{ }
591 };
592 
593 static struct ctl_table nlm_sysctl_dir[] = {
594 	{
595 		.procname	= "nfs",
596 		.mode		= 0555,
597 		.child		= nlm_sysctls,
598 	},
599 	{ }
600 };
601 
602 static struct ctl_table nlm_sysctl_root[] = {
603 	{
604 		.procname	= "fs",
605 		.mode		= 0555,
606 		.child		= nlm_sysctl_dir,
607 	},
608 	{ }
609 };
610 
611 #endif	/* CONFIG_SYSCTL */
612 
613 /*
614  * Module (and sysfs) parameters.
615  */
616 
617 #define param_set_min_max(name, type, which_strtol, min, max)		\
618 static int param_set_##name(const char *val, const struct kernel_param *kp) \
619 {									\
620 	char *endp;							\
621 	__typeof__(type) num = which_strtol(val, &endp, 0);		\
622 	if (endp == val || *endp || num < (min) || num > (max))		\
623 		return -EINVAL;						\
624 	*((type *) kp->arg) = num;					\
625 	return 0;							\
626 }
627 
is_callback(u32 proc)628 static inline int is_callback(u32 proc)
629 {
630 	return proc == NLMPROC_GRANTED
631 		|| proc == NLMPROC_GRANTED_MSG
632 		|| proc == NLMPROC_TEST_RES
633 		|| proc == NLMPROC_LOCK_RES
634 		|| proc == NLMPROC_CANCEL_RES
635 		|| proc == NLMPROC_UNLOCK_RES
636 		|| proc == NLMPROC_NSM_NOTIFY;
637 }
638 
639 
lockd_authenticate(struct svc_rqst * rqstp)640 static int lockd_authenticate(struct svc_rqst *rqstp)
641 {
642 	rqstp->rq_client = NULL;
643 	switch (rqstp->rq_authop->flavour) {
644 		case RPC_AUTH_NULL:
645 		case RPC_AUTH_UNIX:
646 			if (rqstp->rq_proc == 0)
647 				return SVC_OK;
648 			if (is_callback(rqstp->rq_proc)) {
649 				/* Leave it to individual procedures to
650 				 * call nlmsvc_lookup_host(rqstp)
651 				 */
652 				return SVC_OK;
653 			}
654 			return svc_set_client(rqstp);
655 	}
656 	return SVC_DENIED;
657 }
658 
659 
660 param_set_min_max(port, int, simple_strtol, 0, 65535)
661 param_set_min_max(grace_period, unsigned long, simple_strtoul,
662 		  nlm_grace_period_min, nlm_grace_period_max)
663 param_set_min_max(timeout, unsigned long, simple_strtoul,
664 		  nlm_timeout_min, nlm_timeout_max)
665 
666 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
667 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
668 MODULE_LICENSE("GPL");
669 
670 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
671 		  &nlm_grace_period, 0644);
672 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
673 		  &nlm_timeout, 0644);
674 module_param_call(nlm_udpport, param_set_port, param_get_int,
675 		  &nlm_udpport, 0644);
676 module_param_call(nlm_tcpport, param_set_port, param_get_int,
677 		  &nlm_tcpport, 0644);
678 module_param(nsm_use_hostnames, bool, 0644);
679 module_param(nlm_max_connections, uint, 0644);
680 
lockd_init_net(struct net * net)681 static int lockd_init_net(struct net *net)
682 {
683 	struct lockd_net *ln = net_generic(net, lockd_net_id);
684 
685 	INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
686 	INIT_LIST_HEAD(&ln->lockd_manager.list);
687 	ln->lockd_manager.block_opens = false;
688 	INIT_LIST_HEAD(&ln->nsm_handles);
689 	return 0;
690 }
691 
lockd_exit_net(struct net * net)692 static void lockd_exit_net(struct net *net)
693 {
694 	struct lockd_net *ln = net_generic(net, lockd_net_id);
695 
696 	WARN_ONCE(!list_empty(&ln->lockd_manager.list),
697 		  "net %x %s: lockd_manager.list is not empty\n",
698 		  net->ns.inum, __func__);
699 	WARN_ONCE(!list_empty(&ln->nsm_handles),
700 		  "net %x %s: nsm_handles list is not empty\n",
701 		  net->ns.inum, __func__);
702 	WARN_ONCE(delayed_work_pending(&ln->grace_period_end),
703 		  "net %x %s: grace_period_end was not cancelled\n",
704 		  net->ns.inum, __func__);
705 }
706 
707 static struct pernet_operations lockd_net_ops = {
708 	.init = lockd_init_net,
709 	.exit = lockd_exit_net,
710 	.id = &lockd_net_id,
711 	.size = sizeof(struct lockd_net),
712 };
713 
714 
715 /*
716  * Initialising and terminating the module.
717  */
718 
init_nlm(void)719 static int __init init_nlm(void)
720 {
721 	int err;
722 
723 #ifdef CONFIG_SYSCTL
724 	err = -ENOMEM;
725 	nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
726 	if (nlm_sysctl_table == NULL)
727 		goto err_sysctl;
728 #endif
729 	err = register_pernet_subsys(&lockd_net_ops);
730 	if (err)
731 		goto err_pernet;
732 
733 	err = lockd_create_procfs();
734 	if (err)
735 		goto err_procfs;
736 
737 	return 0;
738 
739 err_procfs:
740 	unregister_pernet_subsys(&lockd_net_ops);
741 err_pernet:
742 #ifdef CONFIG_SYSCTL
743 	unregister_sysctl_table(nlm_sysctl_table);
744 err_sysctl:
745 #endif
746 	return err;
747 }
748 
exit_nlm(void)749 static void __exit exit_nlm(void)
750 {
751 	/* FIXME: delete all NLM clients */
752 	nlm_shutdown_hosts();
753 	lockd_remove_procfs();
754 	unregister_pernet_subsys(&lockd_net_ops);
755 #ifdef CONFIG_SYSCTL
756 	unregister_sysctl_table(nlm_sysctl_table);
757 #endif
758 }
759 
760 module_init(init_nlm);
761 module_exit(exit_nlm);
762 
763 /*
764  * Define NLM program and procedures
765  */
766 static unsigned int nlmsvc_version1_count[17];
767 static const struct svc_version	nlmsvc_version1 = {
768 	.vs_vers	= 1,
769 	.vs_nproc	= 17,
770 	.vs_proc	= nlmsvc_procedures,
771 	.vs_count	= nlmsvc_version1_count,
772 	.vs_xdrsize	= NLMSVC_XDRSIZE,
773 };
774 static unsigned int nlmsvc_version3_count[24];
775 static const struct svc_version	nlmsvc_version3 = {
776 	.vs_vers	= 3,
777 	.vs_nproc	= 24,
778 	.vs_proc	= nlmsvc_procedures,
779 	.vs_count	= nlmsvc_version3_count,
780 	.vs_xdrsize	= NLMSVC_XDRSIZE,
781 };
782 #ifdef CONFIG_LOCKD_V4
783 static unsigned int nlmsvc_version4_count[24];
784 static const struct svc_version	nlmsvc_version4 = {
785 	.vs_vers	= 4,
786 	.vs_nproc	= 24,
787 	.vs_proc	= nlmsvc_procedures4,
788 	.vs_count	= nlmsvc_version4_count,
789 	.vs_xdrsize	= NLMSVC_XDRSIZE,
790 };
791 #endif
792 static const struct svc_version *nlmsvc_version[] = {
793 	[1] = &nlmsvc_version1,
794 	[3] = &nlmsvc_version3,
795 #ifdef CONFIG_LOCKD_V4
796 	[4] = &nlmsvc_version4,
797 #endif
798 };
799 
800 static struct svc_stat		nlmsvc_stats;
801 
802 #define NLM_NRVERS	ARRAY_SIZE(nlmsvc_version)
803 static struct svc_program	nlmsvc_program = {
804 	.pg_prog		= NLM_PROGRAM,		/* program number */
805 	.pg_nvers		= NLM_NRVERS,		/* number of entries in nlmsvc_version */
806 	.pg_vers		= nlmsvc_version,	/* version table */
807 	.pg_name		= "lockd",		/* service name */
808 	.pg_class		= "nfsd",		/* share authentication with nfsd */
809 	.pg_stats		= &nlmsvc_stats,	/* stats table */
810 	.pg_authenticate = &lockd_authenticate	/* export authentication */
811 };
812