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.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>
29 #include <linux/sunrpc/types.h>
30 #include <linux/sunrpc/stats.h>
31 #include <linux/sunrpc/clnt.h>
32 #include <linux/sunrpc/svc.h>
33 #include <linux/sunrpc/svcsock.h>
35 #include <linux/lockd/lockd.h>
36 #include <linux/nfs.h>
41 #define NLMDBG_FACILITY NLMDBG_SVC
42 #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
43 #define ALLOWED_SIGS (sigmask(SIGKILL))
45 static struct svc_program nlmsvc_program
;
47 struct nlmsvc_binding
* nlmsvc_ops
;
48 EXPORT_SYMBOL_GPL(nlmsvc_ops
);
50 static DEFINE_MUTEX(nlmsvc_mutex
);
51 static unsigned int nlmsvc_users
;
52 static struct task_struct
*nlmsvc_task
;
53 static struct svc_rqst
*nlmsvc_rqst
;
54 unsigned long nlmsvc_timeout
;
59 * These can be set at insmod time (useful for NFS as root filesystem),
60 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
62 static unsigned long nlm_grace_period
;
63 static unsigned long nlm_timeout
= LOCKD_DFLT_TIMEO
;
64 static int nlm_udpport
, nlm_tcpport
;
66 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
67 static unsigned int nlm_max_connections
= 1024;
70 * Constants needed for the sysctl interface.
72 static const unsigned long nlm_grace_period_min
= 0;
73 static const unsigned long nlm_grace_period_max
= 240;
74 static const unsigned long nlm_timeout_min
= 3;
75 static const unsigned long nlm_timeout_max
= 20;
76 static const int nlm_port_min
= 0, nlm_port_max
= 65535;
79 static struct ctl_table_header
* nlm_sysctl_table
;
82 static unsigned long get_lockd_grace_period(void)
84 /* Note: nlm_timeout should always be nonzero */
86 return roundup(nlm_grace_period
, nlm_timeout
) * HZ
;
88 return nlm_timeout
* 5 * HZ
;
91 static void grace_ender(struct work_struct
*grace
)
93 struct delayed_work
*dwork
= container_of(grace
, struct delayed_work
,
95 struct lockd_net
*ln
= container_of(dwork
, struct lockd_net
,
98 locks_end_grace(&ln
->lockd_manager
);
101 static void set_grace_period(struct net
*net
)
103 unsigned long grace_period
= get_lockd_grace_period();
104 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
106 locks_start_grace(net
, &ln
->lockd_manager
);
107 cancel_delayed_work_sync(&ln
->grace_period_end
);
108 schedule_delayed_work(&ln
->grace_period_end
, grace_period
);
111 static void restart_grace(void)
114 struct net
*net
= &init_net
;
115 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
117 cancel_delayed_work_sync(&ln
->grace_period_end
);
118 locks_end_grace(&ln
->lockd_manager
);
119 nlmsvc_invalidate_all();
120 set_grace_period(net
);
125 * This is the lockd kernel thread
131 struct svc_rqst
*rqstp
= vrqstp
;
132 struct net
*net
= &init_net
;
133 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
135 /* try_to_freeze() is called from svc_recv() */
138 /* Allow SIGKILL to tell lockd to drop all of its locks */
139 allow_signal(SIGKILL
);
141 dprintk("NFS locking service started (ver " LOCKD_VERSION
").\n");
144 * The main request loop. We don't terminate until the last
145 * NFS mount or NFS daemon has gone away.
147 while (!kthread_should_stop()) {
148 long timeout
= MAX_SCHEDULE_TIMEOUT
;
149 RPC_IFDEBUG(char buf
[RPC_MAX_ADDRBUFLEN
]);
151 /* update sv_maxconn if it has changed */
152 rqstp
->rq_server
->sv_maxconn
= nlm_max_connections
;
155 flush_signals(current
);
160 timeout
= nlmsvc_retry_blocked();
163 * Find a socket with data available and call its
166 err
= svc_recv(rqstp
, timeout
);
167 if (err
== -EAGAIN
|| err
== -EINTR
)
169 dprintk("lockd: request from %s\n",
170 svc_print_addr(rqstp
, buf
, sizeof(buf
)));
174 flush_signals(current
);
176 nlmsvc_invalidate_all();
177 nlm_shutdown_hosts();
178 cancel_delayed_work_sync(&ln
->grace_period_end
);
179 locks_end_grace(&ln
->lockd_manager
);
183 static int create_lockd_listener(struct svc_serv
*serv
, const char *name
,
184 struct net
*net
, const int family
,
185 const unsigned short port
)
187 struct svc_xprt
*xprt
;
189 xprt
= svc_find_xprt(serv
, name
, net
, family
, 0);
191 return svc_create_xprt(serv
, name
, net
, family
, port
,
197 static int create_lockd_family(struct svc_serv
*serv
, struct net
*net
,
202 err
= create_lockd_listener(serv
, "udp", net
, family
, nlm_udpport
);
206 return create_lockd_listener(serv
, "tcp", net
, family
, nlm_tcpport
);
210 * Ensure there are active UDP and TCP listeners for lockd.
212 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
213 * local services (such as rpc.statd) still require UDP, and
214 * some NFS servers do not yet support NLM over TCP.
216 * Returns zero if all listeners are available; otherwise a
217 * negative errno value is returned.
219 static int make_socks(struct svc_serv
*serv
, struct net
*net
)
224 err
= create_lockd_family(serv
, net
, PF_INET
);
228 err
= create_lockd_family(serv
, net
, PF_INET6
);
229 if (err
< 0 && err
!= -EAFNOSUPPORT
)
238 "lockd_up: makesock failed, error=%d\n", err
);
239 svc_shutdown_net(serv
, net
);
243 static int lockd_up_net(struct svc_serv
*serv
, struct net
*net
)
245 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
248 if (ln
->nlmsvc_users
++)
251 error
= svc_bind(serv
, net
);
255 error
= make_socks(serv
, net
);
258 set_grace_period(net
);
259 dprintk("lockd_up_net: per-net data created; net=%p\n", net
);
267 static void lockd_down_net(struct svc_serv
*serv
, struct net
*net
)
269 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
271 if (ln
->nlmsvc_users
) {
272 if (--ln
->nlmsvc_users
== 0) {
273 nlm_shutdown_hosts_net(net
);
274 cancel_delayed_work_sync(&ln
->grace_period_end
);
275 locks_end_grace(&ln
->lockd_manager
);
276 svc_shutdown_net(serv
, net
);
277 dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net
);
280 printk(KERN_ERR
"lockd_down_net: no users! task=%p, net=%p\n",
286 static int lockd_start_svc(struct svc_serv
*serv
)
294 * Create the kernel thread and wait for it to start.
296 nlmsvc_rqst
= svc_prepare_thread(serv
, &serv
->sv_pools
[0], NUMA_NO_NODE
);
297 if (IS_ERR(nlmsvc_rqst
)) {
298 error
= PTR_ERR(nlmsvc_rqst
);
300 "lockd_up: svc_rqst allocation failed, error=%d\n",
305 svc_sock_update_bufs(serv
);
306 serv
->sv_maxconn
= nlm_max_connections
;
308 nlmsvc_task
= kthread_create(lockd
, nlmsvc_rqst
, "%s", serv
->sv_name
);
309 if (IS_ERR(nlmsvc_task
)) {
310 error
= PTR_ERR(nlmsvc_task
);
312 "lockd_up: kthread_run failed, error=%d\n", error
);
315 nlmsvc_rqst
->rq_task
= nlmsvc_task
;
316 wake_up_process(nlmsvc_task
);
318 dprintk("lockd_up: service started\n");
322 svc_exit_thread(nlmsvc_rqst
);
329 static struct svc_serv_ops lockd_sv_ops
= {
330 .svo_shutdown
= svc_rpcb_cleanup
,
331 .svo_enqueue_xprt
= svc_xprt_do_enqueue
,
334 static struct svc_serv
*lockd_create_svc(void)
336 struct svc_serv
*serv
;
339 * Check whether we're already up and running.
343 * Note: increase service usage, because later in case of error
344 * svc_destroy() will be called.
346 svc_get(nlmsvc_rqst
->rq_server
);
347 return nlmsvc_rqst
->rq_server
;
351 * Sanity check: if there's no pid,
352 * we should be the first user ...
356 "lockd_up: no pid, %d users??\n", nlmsvc_users
);
359 nlm_timeout
= LOCKD_DFLT_TIMEO
;
360 nlmsvc_timeout
= nlm_timeout
* HZ
;
362 serv
= svc_create(&nlmsvc_program
, LOCKD_BUFSIZE
, &lockd_sv_ops
);
364 printk(KERN_WARNING
"lockd_up: create service failed\n");
365 return ERR_PTR(-ENOMEM
);
367 dprintk("lockd_up: service created\n");
372 * Bring up the lockd process if it's not already up.
374 int lockd_up(struct net
*net
)
376 struct svc_serv
*serv
;
379 mutex_lock(&nlmsvc_mutex
);
381 serv
= lockd_create_svc();
383 error
= PTR_ERR(serv
);
387 error
= lockd_up_net(serv
, net
);
391 error
= lockd_start_svc(serv
);
397 * Note: svc_serv structures have an initial use count of 1,
398 * so we exit through here on both success and failure.
403 mutex_unlock(&nlmsvc_mutex
);
407 lockd_down_net(serv
, net
);
410 EXPORT_SYMBOL_GPL(lockd_up
);
413 * Decrement the user count and bring down lockd if we're the last.
416 lockd_down(struct net
*net
)
418 mutex_lock(&nlmsvc_mutex
);
419 lockd_down_net(nlmsvc_rqst
->rq_server
, net
);
424 printk(KERN_ERR
"lockd_down: no users! task=%p\n",
430 printk(KERN_ERR
"lockd_down: no lockd running.\n");
433 kthread_stop(nlmsvc_task
);
434 dprintk("lockd_down: service stopped\n");
435 svc_exit_thread(nlmsvc_rqst
);
436 dprintk("lockd_down: service destroyed\n");
440 mutex_unlock(&nlmsvc_mutex
);
442 EXPORT_SYMBOL_GPL(lockd_down
);
447 * Sysctl parameters (same as module parameters, different interface).
450 static struct ctl_table nlm_sysctls
[] = {
452 .procname
= "nlm_grace_period",
453 .data
= &nlm_grace_period
,
454 .maxlen
= sizeof(unsigned long),
456 .proc_handler
= proc_doulongvec_minmax
,
457 .extra1
= (unsigned long *) &nlm_grace_period_min
,
458 .extra2
= (unsigned long *) &nlm_grace_period_max
,
461 .procname
= "nlm_timeout",
462 .data
= &nlm_timeout
,
463 .maxlen
= sizeof(unsigned long),
465 .proc_handler
= proc_doulongvec_minmax
,
466 .extra1
= (unsigned long *) &nlm_timeout_min
,
467 .extra2
= (unsigned long *) &nlm_timeout_max
,
470 .procname
= "nlm_udpport",
471 .data
= &nlm_udpport
,
472 .maxlen
= sizeof(int),
474 .proc_handler
= proc_dointvec_minmax
,
475 .extra1
= (int *) &nlm_port_min
,
476 .extra2
= (int *) &nlm_port_max
,
479 .procname
= "nlm_tcpport",
480 .data
= &nlm_tcpport
,
481 .maxlen
= sizeof(int),
483 .proc_handler
= proc_dointvec_minmax
,
484 .extra1
= (int *) &nlm_port_min
,
485 .extra2
= (int *) &nlm_port_max
,
488 .procname
= "nsm_use_hostnames",
489 .data
= &nsm_use_hostnames
,
490 .maxlen
= sizeof(int),
492 .proc_handler
= proc_dointvec
,
495 .procname
= "nsm_local_state",
496 .data
= &nsm_local_state
,
497 .maxlen
= sizeof(int),
499 .proc_handler
= proc_dointvec
,
504 static struct ctl_table nlm_sysctl_dir
[] = {
508 .child
= nlm_sysctls
,
513 static struct ctl_table nlm_sysctl_root
[] = {
517 .child
= nlm_sysctl_dir
,
522 #endif /* CONFIG_SYSCTL */
525 * Module (and sysfs) parameters.
528 #define param_set_min_max(name, type, which_strtol, min, max) \
529 static int param_set_##name(const char *val, struct kernel_param *kp) \
532 __typeof__(type) num = which_strtol(val, &endp, 0); \
533 if (endp == val || *endp || num < (min) || num > (max)) \
535 *((type *) kp->arg) = num; \
539 static inline int is_callback(u32 proc
)
541 return proc
== NLMPROC_GRANTED
542 || proc
== NLMPROC_GRANTED_MSG
543 || proc
== NLMPROC_TEST_RES
544 || proc
== NLMPROC_LOCK_RES
545 || proc
== NLMPROC_CANCEL_RES
546 || proc
== NLMPROC_UNLOCK_RES
547 || proc
== NLMPROC_NSM_NOTIFY
;
551 static int lockd_authenticate(struct svc_rqst
*rqstp
)
553 rqstp
->rq_client
= NULL
;
554 switch (rqstp
->rq_authop
->flavour
) {
557 if (rqstp
->rq_proc
== 0)
559 if (is_callback(rqstp
->rq_proc
)) {
560 /* Leave it to individual procedures to
561 * call nlmsvc_lookup_host(rqstp)
565 return svc_set_client(rqstp
);
571 param_set_min_max(port
, int, simple_strtol
, 0, 65535)
572 param_set_min_max(grace_period
, unsigned long, simple_strtoul
,
573 nlm_grace_period_min
, nlm_grace_period_max
)
574 param_set_min_max(timeout
, unsigned long, simple_strtoul
,
575 nlm_timeout_min
, nlm_timeout_max
)
577 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
578 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION
".");
579 MODULE_LICENSE("GPL");
581 module_param_call(nlm_grace_period
, param_set_grace_period
, param_get_ulong
,
582 &nlm_grace_period
, 0644);
583 module_param_call(nlm_timeout
, param_set_timeout
, param_get_ulong
,
585 module_param_call(nlm_udpport
, param_set_port
, param_get_int
,
587 module_param_call(nlm_tcpport
, param_set_port
, param_get_int
,
589 module_param(nsm_use_hostnames
, bool, 0644);
590 module_param(nlm_max_connections
, uint
, 0644);
592 static int lockd_init_net(struct net
*net
)
594 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
596 INIT_DELAYED_WORK(&ln
->grace_period_end
, grace_ender
);
597 INIT_LIST_HEAD(&ln
->lockd_manager
.list
);
598 ln
->lockd_manager
.block_opens
= false;
599 INIT_LIST_HEAD(&ln
->nsm_handles
);
603 static void lockd_exit_net(struct net
*net
)
607 static struct pernet_operations lockd_net_ops
= {
608 .init
= lockd_init_net
,
609 .exit
= lockd_exit_net
,
611 .size
= sizeof(struct lockd_net
),
616 * Initialising and terminating the module.
619 static int __init
init_nlm(void)
625 nlm_sysctl_table
= register_sysctl_table(nlm_sysctl_root
);
626 if (nlm_sysctl_table
== NULL
)
629 err
= register_pernet_subsys(&lockd_net_ops
);
633 err
= lockd_create_procfs();
640 unregister_pernet_subsys(&lockd_net_ops
);
643 unregister_sysctl_table(nlm_sysctl_table
);
649 static void __exit
exit_nlm(void)
651 /* FIXME: delete all NLM clients */
652 nlm_shutdown_hosts();
653 lockd_remove_procfs();
654 unregister_pernet_subsys(&lockd_net_ops
);
656 unregister_sysctl_table(nlm_sysctl_table
);
660 module_init(init_nlm
);
661 module_exit(exit_nlm
);
664 * Define NLM program and procedures
666 static struct svc_version nlmsvc_version1
= {
669 .vs_proc
= nlmsvc_procedures
,
670 .vs_xdrsize
= NLMSVC_XDRSIZE
,
672 static struct svc_version nlmsvc_version3
= {
675 .vs_proc
= nlmsvc_procedures
,
676 .vs_xdrsize
= NLMSVC_XDRSIZE
,
678 #ifdef CONFIG_LOCKD_V4
679 static struct svc_version nlmsvc_version4
= {
682 .vs_proc
= nlmsvc_procedures4
,
683 .vs_xdrsize
= NLMSVC_XDRSIZE
,
686 static struct svc_version
* nlmsvc_version
[] = {
687 [1] = &nlmsvc_version1
,
688 [3] = &nlmsvc_version3
,
689 #ifdef CONFIG_LOCKD_V4
690 [4] = &nlmsvc_version4
,
694 static struct svc_stat nlmsvc_stats
;
696 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
697 static struct svc_program nlmsvc_program
= {
698 .pg_prog
= NLM_PROGRAM
, /* program number */
699 .pg_nvers
= NLM_NRVERS
, /* number of entries in nlmsvc_version */
700 .pg_vers
= nlmsvc_version
, /* version table */
701 .pg_name
= "lockd", /* service name */
702 .pg_class
= "nfsd", /* share authentication with nfsd */
703 .pg_stats
= &nlmsvc_stats
, /* stats table */
704 .pg_authenticate
= &lockd_authenticate
/* export authentication */