4 * This is the central lockd service.
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?
10 * Authors: Olaf Kirch (okir@monad.swb.de)
12 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/sysctl.h>
18 #include <linux/moduleparam.h>
20 #include <linux/sched/signal.h>
21 #include <linux/errno.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>
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>
37 #include <net/addrconf.h>
39 #include <linux/lockd/lockd.h>
40 #include <linux/nfs.h>
45 #define NLMDBG_FACILITY NLMDBG_SVC
46 #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
47 #define ALLOWED_SIGS (sigmask(SIGKILL))
49 static struct svc_program nlmsvc_program
;
51 const struct nlmsvc_binding
*nlmsvc_ops
;
52 EXPORT_SYMBOL_GPL(nlmsvc_ops
);
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
;
60 unsigned int lockd_net_id
;
63 * These can be set at insmod time (useful for NFS as root filesystem),
64 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
66 static unsigned long nlm_grace_period
;
67 static unsigned long nlm_timeout
= LOCKD_DFLT_TIMEO
;
68 static int nlm_udpport
, nlm_tcpport
;
70 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
71 static unsigned int nlm_max_connections
= 1024;
74 * Constants needed for the sysctl interface.
76 static const unsigned long nlm_grace_period_min
= 0;
77 static const unsigned long nlm_grace_period_max
= 240;
78 static const unsigned long nlm_timeout_min
= 3;
79 static const unsigned long nlm_timeout_max
= 20;
80 static const int nlm_port_min
= 0, nlm_port_max
= 65535;
83 static struct ctl_table_header
* nlm_sysctl_table
;
86 static unsigned long get_lockd_grace_period(void)
88 /* Note: nlm_timeout should always be nonzero */
90 return roundup(nlm_grace_period
, nlm_timeout
) * HZ
;
92 return nlm_timeout
* 5 * HZ
;
95 static void grace_ender(struct work_struct
*grace
)
97 struct delayed_work
*dwork
= to_delayed_work(grace
);
98 struct lockd_net
*ln
= container_of(dwork
, struct lockd_net
,
101 locks_end_grace(&ln
->lockd_manager
);
104 static void set_grace_period(struct net
*net
)
106 unsigned long grace_period
= get_lockd_grace_period();
107 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
109 locks_start_grace(net
, &ln
->lockd_manager
);
110 cancel_delayed_work_sync(&ln
->grace_period_end
);
111 schedule_delayed_work(&ln
->grace_period_end
, grace_period
);
114 static void restart_grace(void)
117 struct net
*net
= &init_net
;
118 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
120 cancel_delayed_work_sync(&ln
->grace_period_end
);
121 locks_end_grace(&ln
->lockd_manager
);
122 nlmsvc_invalidate_all();
123 set_grace_period(net
);
128 * This is the lockd kernel thread
134 struct svc_rqst
*rqstp
= vrqstp
;
136 /* try_to_freeze() is called from svc_recv() */
139 /* Allow SIGKILL to tell lockd to drop all of its locks */
140 allow_signal(SIGKILL
);
142 dprintk("NFS locking service started (ver " LOCKD_VERSION
").\n");
145 * The main request loop. We don't terminate until the last
146 * NFS mount or NFS daemon has gone away.
148 while (!kthread_should_stop()) {
149 long timeout
= MAX_SCHEDULE_TIMEOUT
;
150 RPC_IFDEBUG(char buf
[RPC_MAX_ADDRBUFLEN
]);
152 /* update sv_maxconn if it has changed */
153 rqstp
->rq_server
->sv_maxconn
= nlm_max_connections
;
156 flush_signals(current
);
161 timeout
= nlmsvc_retry_blocked();
164 * Find a socket with data available and call its
167 err
= svc_recv(rqstp
, timeout
);
168 if (err
== -EAGAIN
|| err
== -EINTR
)
170 dprintk("lockd: request from %s\n",
171 svc_print_addr(rqstp
, buf
, sizeof(buf
)));
175 flush_signals(current
);
177 nlmsvc_invalidate_all();
178 nlm_shutdown_hosts();
182 static int create_lockd_listener(struct svc_serv
*serv
, const char *name
,
183 struct net
*net
, const int family
,
184 const unsigned short port
)
186 struct svc_xprt
*xprt
;
188 xprt
= svc_find_xprt(serv
, name
, net
, family
, 0);
190 return svc_create_xprt(serv
, name
, net
, family
, port
,
196 static int create_lockd_family(struct svc_serv
*serv
, struct net
*net
,
201 err
= create_lockd_listener(serv
, "udp", net
, family
, nlm_udpport
);
205 return create_lockd_listener(serv
, "tcp", net
, family
, nlm_tcpport
);
209 * Ensure there are active UDP and TCP listeners for lockd.
211 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
212 * local services (such as rpc.statd) still require UDP, and
213 * some NFS servers do not yet support NLM over TCP.
215 * Returns zero if all listeners are available; otherwise a
216 * negative errno value is returned.
218 static int make_socks(struct svc_serv
*serv
, struct net
*net
)
223 err
= create_lockd_family(serv
, net
, PF_INET
);
227 err
= create_lockd_family(serv
, net
, PF_INET6
);
228 if (err
< 0 && err
!= -EAFNOSUPPORT
)
237 "lockd_up: makesock failed, error=%d\n", err
);
238 svc_shutdown_net(serv
, net
);
242 static int lockd_up_net(struct svc_serv
*serv
, struct net
*net
)
244 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
247 if (ln
->nlmsvc_users
++)
250 error
= svc_bind(serv
, net
);
254 error
= make_socks(serv
, net
);
257 set_grace_period(net
);
258 dprintk("lockd_up_net: per-net data created; net=%p\n", net
);
266 static void lockd_down_net(struct svc_serv
*serv
, struct net
*net
)
268 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
270 if (ln
->nlmsvc_users
) {
271 if (--ln
->nlmsvc_users
== 0) {
272 nlm_shutdown_hosts_net(net
);
273 cancel_delayed_work_sync(&ln
->grace_period_end
);
274 locks_end_grace(&ln
->lockd_manager
);
275 svc_shutdown_net(serv
, net
);
276 dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net
);
279 printk(KERN_ERR
"lockd_down_net: no users! task=%p, net=%p\n",
285 static int lockd_inetaddr_event(struct notifier_block
*this,
286 unsigned long event
, void *ptr
)
288 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
289 struct sockaddr_in sin
;
291 if (event
!= NETDEV_DOWN
)
295 dprintk("lockd_inetaddr_event: removed %pI4\n",
297 sin
.sin_family
= AF_INET
;
298 sin
.sin_addr
.s_addr
= ifa
->ifa_local
;
299 svc_age_temp_xprts_now(nlmsvc_rqst
->rq_server
,
300 (struct sockaddr
*)&sin
);
307 static struct notifier_block lockd_inetaddr_notifier
= {
308 .notifier_call
= lockd_inetaddr_event
,
311 #if IS_ENABLED(CONFIG_IPV6)
312 static int lockd_inet6addr_event(struct notifier_block
*this,
313 unsigned long event
, void *ptr
)
315 struct inet6_ifaddr
*ifa
= (struct inet6_ifaddr
*)ptr
;
316 struct sockaddr_in6 sin6
;
318 if (event
!= NETDEV_DOWN
)
322 dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa
->addr
);
323 sin6
.sin6_family
= AF_INET6
;
324 sin6
.sin6_addr
= ifa
->addr
;
325 if (ipv6_addr_type(&sin6
.sin6_addr
) & IPV6_ADDR_LINKLOCAL
)
326 sin6
.sin6_scope_id
= ifa
->idev
->dev
->ifindex
;
327 svc_age_temp_xprts_now(nlmsvc_rqst
->rq_server
,
328 (struct sockaddr
*)&sin6
);
335 static struct notifier_block lockd_inet6addr_notifier
= {
336 .notifier_call
= lockd_inet6addr_event
,
340 static void lockd_unregister_notifiers(void)
342 unregister_inetaddr_notifier(&lockd_inetaddr_notifier
);
343 #if IS_ENABLED(CONFIG_IPV6)
344 unregister_inet6addr_notifier(&lockd_inet6addr_notifier
);
348 static void lockd_svc_exit_thread(void)
350 lockd_unregister_notifiers();
351 svc_exit_thread(nlmsvc_rqst
);
354 static int lockd_start_svc(struct svc_serv
*serv
)
362 * Create the kernel thread and wait for it to start.
364 nlmsvc_rqst
= svc_prepare_thread(serv
, &serv
->sv_pools
[0], NUMA_NO_NODE
);
365 if (IS_ERR(nlmsvc_rqst
)) {
366 error
= PTR_ERR(nlmsvc_rqst
);
368 "lockd_up: svc_rqst allocation failed, error=%d\n",
373 svc_sock_update_bufs(serv
);
374 serv
->sv_maxconn
= nlm_max_connections
;
376 nlmsvc_task
= kthread_create(lockd
, nlmsvc_rqst
, "%s", serv
->sv_name
);
377 if (IS_ERR(nlmsvc_task
)) {
378 error
= PTR_ERR(nlmsvc_task
);
380 "lockd_up: kthread_run failed, error=%d\n", error
);
383 nlmsvc_rqst
->rq_task
= nlmsvc_task
;
384 wake_up_process(nlmsvc_task
);
386 dprintk("lockd_up: service started\n");
390 lockd_svc_exit_thread();
397 static struct svc_serv_ops lockd_sv_ops
= {
398 .svo_shutdown
= svc_rpcb_cleanup
,
399 .svo_enqueue_xprt
= svc_xprt_do_enqueue
,
402 static struct svc_serv
*lockd_create_svc(void)
404 struct svc_serv
*serv
;
407 * Check whether we're already up and running.
411 * Note: increase service usage, because later in case of error
412 * svc_destroy() will be called.
414 svc_get(nlmsvc_rqst
->rq_server
);
415 return nlmsvc_rqst
->rq_server
;
419 * Sanity check: if there's no pid,
420 * we should be the first user ...
424 "lockd_up: no pid, %d users??\n", nlmsvc_users
);
427 nlm_timeout
= LOCKD_DFLT_TIMEO
;
428 nlmsvc_timeout
= nlm_timeout
* HZ
;
430 serv
= svc_create(&nlmsvc_program
, LOCKD_BUFSIZE
, &lockd_sv_ops
);
432 printk(KERN_WARNING
"lockd_up: create service failed\n");
433 return ERR_PTR(-ENOMEM
);
435 register_inetaddr_notifier(&lockd_inetaddr_notifier
);
436 #if IS_ENABLED(CONFIG_IPV6)
437 register_inet6addr_notifier(&lockd_inet6addr_notifier
);
439 dprintk("lockd_up: service created\n");
444 * Bring up the lockd process if it's not already up.
446 int lockd_up(struct net
*net
)
448 struct svc_serv
*serv
;
451 mutex_lock(&nlmsvc_mutex
);
453 serv
= lockd_create_svc();
455 error
= PTR_ERR(serv
);
459 error
= lockd_up_net(serv
, net
);
463 error
= lockd_start_svc(serv
);
469 * Note: svc_serv structures have an initial use count of 1,
470 * so we exit through here on both success and failure.
475 mutex_unlock(&nlmsvc_mutex
);
479 lockd_down_net(serv
, net
);
481 lockd_unregister_notifiers();
484 EXPORT_SYMBOL_GPL(lockd_up
);
487 * Decrement the user count and bring down lockd if we're the last.
490 lockd_down(struct net
*net
)
492 mutex_lock(&nlmsvc_mutex
);
493 lockd_down_net(nlmsvc_rqst
->rq_server
, net
);
498 printk(KERN_ERR
"lockd_down: no users! task=%p\n",
504 printk(KERN_ERR
"lockd_down: no lockd running.\n");
507 kthread_stop(nlmsvc_task
);
508 dprintk("lockd_down: service stopped\n");
509 lockd_svc_exit_thread();
510 dprintk("lockd_down: service destroyed\n");
514 mutex_unlock(&nlmsvc_mutex
);
516 EXPORT_SYMBOL_GPL(lockd_down
);
521 * Sysctl parameters (same as module parameters, different interface).
524 static struct ctl_table nlm_sysctls
[] = {
526 .procname
= "nlm_grace_period",
527 .data
= &nlm_grace_period
,
528 .maxlen
= sizeof(unsigned long),
530 .proc_handler
= proc_doulongvec_minmax
,
531 .extra1
= (unsigned long *) &nlm_grace_period_min
,
532 .extra2
= (unsigned long *) &nlm_grace_period_max
,
535 .procname
= "nlm_timeout",
536 .data
= &nlm_timeout
,
537 .maxlen
= sizeof(unsigned long),
539 .proc_handler
= proc_doulongvec_minmax
,
540 .extra1
= (unsigned long *) &nlm_timeout_min
,
541 .extra2
= (unsigned long *) &nlm_timeout_max
,
544 .procname
= "nlm_udpport",
545 .data
= &nlm_udpport
,
546 .maxlen
= sizeof(int),
548 .proc_handler
= proc_dointvec_minmax
,
549 .extra1
= (int *) &nlm_port_min
,
550 .extra2
= (int *) &nlm_port_max
,
553 .procname
= "nlm_tcpport",
554 .data
= &nlm_tcpport
,
555 .maxlen
= sizeof(int),
557 .proc_handler
= proc_dointvec_minmax
,
558 .extra1
= (int *) &nlm_port_min
,
559 .extra2
= (int *) &nlm_port_max
,
562 .procname
= "nsm_use_hostnames",
563 .data
= &nsm_use_hostnames
,
564 .maxlen
= sizeof(int),
566 .proc_handler
= proc_dointvec
,
569 .procname
= "nsm_local_state",
570 .data
= &nsm_local_state
,
571 .maxlen
= sizeof(int),
573 .proc_handler
= proc_dointvec
,
578 static struct ctl_table nlm_sysctl_dir
[] = {
582 .child
= nlm_sysctls
,
587 static struct ctl_table nlm_sysctl_root
[] = {
591 .child
= nlm_sysctl_dir
,
596 #endif /* CONFIG_SYSCTL */
599 * Module (and sysfs) parameters.
602 #define param_set_min_max(name, type, which_strtol, min, max) \
603 static int param_set_##name(const char *val, struct kernel_param *kp) \
606 __typeof__(type) num = which_strtol(val, &endp, 0); \
607 if (endp == val || *endp || num < (min) || num > (max)) \
609 *((type *) kp->arg) = num; \
613 static inline int is_callback(u32 proc
)
615 return proc
== NLMPROC_GRANTED
616 || proc
== NLMPROC_GRANTED_MSG
617 || proc
== NLMPROC_TEST_RES
618 || proc
== NLMPROC_LOCK_RES
619 || proc
== NLMPROC_CANCEL_RES
620 || proc
== NLMPROC_UNLOCK_RES
621 || proc
== NLMPROC_NSM_NOTIFY
;
625 static int lockd_authenticate(struct svc_rqst
*rqstp
)
627 rqstp
->rq_client
= NULL
;
628 switch (rqstp
->rq_authop
->flavour
) {
631 if (rqstp
->rq_proc
== 0)
633 if (is_callback(rqstp
->rq_proc
)) {
634 /* Leave it to individual procedures to
635 * call nlmsvc_lookup_host(rqstp)
639 return svc_set_client(rqstp
);
645 param_set_min_max(port
, int, simple_strtol
, 0, 65535)
646 param_set_min_max(grace_period
, unsigned long, simple_strtoul
,
647 nlm_grace_period_min
, nlm_grace_period_max
)
648 param_set_min_max(timeout
, unsigned long, simple_strtoul
,
649 nlm_timeout_min
, nlm_timeout_max
)
651 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
652 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION
".");
653 MODULE_LICENSE("GPL");
655 module_param_call(nlm_grace_period
, param_set_grace_period
, param_get_ulong
,
656 &nlm_grace_period
, 0644);
657 module_param_call(nlm_timeout
, param_set_timeout
, param_get_ulong
,
659 module_param_call(nlm_udpport
, param_set_port
, param_get_int
,
661 module_param_call(nlm_tcpport
, param_set_port
, param_get_int
,
663 module_param(nsm_use_hostnames
, bool, 0644);
664 module_param(nlm_max_connections
, uint
, 0644);
666 static int lockd_init_net(struct net
*net
)
668 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
670 INIT_DELAYED_WORK(&ln
->grace_period_end
, grace_ender
);
671 INIT_LIST_HEAD(&ln
->lockd_manager
.list
);
672 ln
->lockd_manager
.block_opens
= false;
673 INIT_LIST_HEAD(&ln
->nsm_handles
);
677 static void lockd_exit_net(struct net
*net
)
681 static struct pernet_operations lockd_net_ops
= {
682 .init
= lockd_init_net
,
683 .exit
= lockd_exit_net
,
685 .size
= sizeof(struct lockd_net
),
690 * Initialising and terminating the module.
693 static int __init
init_nlm(void)
699 nlm_sysctl_table
= register_sysctl_table(nlm_sysctl_root
);
700 if (nlm_sysctl_table
== NULL
)
703 err
= register_pernet_subsys(&lockd_net_ops
);
707 err
= lockd_create_procfs();
714 unregister_pernet_subsys(&lockd_net_ops
);
717 unregister_sysctl_table(nlm_sysctl_table
);
723 static void __exit
exit_nlm(void)
725 /* FIXME: delete all NLM clients */
726 nlm_shutdown_hosts();
727 lockd_remove_procfs();
728 unregister_pernet_subsys(&lockd_net_ops
);
730 unregister_sysctl_table(nlm_sysctl_table
);
734 module_init(init_nlm
);
735 module_exit(exit_nlm
);
738 * Define NLM program and procedures
740 static struct svc_version nlmsvc_version1
= {
743 .vs_proc
= nlmsvc_procedures
,
744 .vs_xdrsize
= NLMSVC_XDRSIZE
,
746 static struct svc_version nlmsvc_version3
= {
749 .vs_proc
= nlmsvc_procedures
,
750 .vs_xdrsize
= NLMSVC_XDRSIZE
,
752 #ifdef CONFIG_LOCKD_V4
753 static struct svc_version nlmsvc_version4
= {
756 .vs_proc
= nlmsvc_procedures4
,
757 .vs_xdrsize
= NLMSVC_XDRSIZE
,
760 static struct svc_version
* nlmsvc_version
[] = {
761 [1] = &nlmsvc_version1
,
762 [3] = &nlmsvc_version3
,
763 #ifdef CONFIG_LOCKD_V4
764 [4] = &nlmsvc_version4
,
768 static struct svc_stat nlmsvc_stats
;
770 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
771 static struct svc_program nlmsvc_program
= {
772 .pg_prog
= NLM_PROGRAM
, /* program number */
773 .pg_nvers
= NLM_NRVERS
, /* number of entries in nlmsvc_version */
774 .pg_vers
= nlmsvc_version
, /* version table */
775 .pg_name
= "lockd", /* service name */
776 .pg_class
= "nfsd", /* share authentication with nfsd */
777 .pg_stats
= &nlmsvc_stats
, /* stats table */
778 .pg_authenticate
= &lockd_authenticate
/* export authentication */