blob: c631a83931cec9cd56128daf5fc494b8fac9703a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/sysctl.h>
18#include <linux/moduleparam.h>
19
20#include <linux/sched.h>
21#include <linux/errno.h>
22#include <linux/in.h>
23#include <linux/uio.h>
24#include <linux/slab.h>
25#include <linux/smp.h>
26#include <linux/smp_lock.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080027#include <linux/mutex.h>
Jeff Laytond751a7c2008-02-07 16:34:55 -050028#include <linux/kthread.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070029#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <linux/sunrpc/types.h>
32#include <linux/sunrpc/stats.h>
33#include <linux/sunrpc/clnt.h>
34#include <linux/sunrpc/svc.h>
35#include <linux/sunrpc/svcsock.h>
NeilBrown24e36662006-10-02 02:17:45 -070036#include <net/ip.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/lockd/lockd.h>
Olaf Kirch460f5ca2006-10-04 02:16:03 -070038#include <linux/lockd/sm_inter.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/nfs.h>
40
41#define NLMDBG_FACILITY NLMDBG_SVC
42#define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
43#define ALLOWED_SIGS (sigmask(SIGKILL))
44
45static struct svc_program nlmsvc_program;
46
47struct nlmsvc_binding * nlmsvc_ops;
48EXPORT_SYMBOL(nlmsvc_ops);
49
Ingo Molnar353ab6e2006-03-26 01:37:12 -080050static DEFINE_MUTEX(nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051static unsigned int nlmsvc_users;
Jeff Laytond751a7c2008-02-07 16:34:55 -050052static struct task_struct *nlmsvc_task;
Jeff Laytonabd1ec42008-06-11 10:03:12 -040053static struct svc_rqst *nlmsvc_rqst;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054unsigned long nlmsvc_timeout;
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056/*
57 * These can be set at insmod time (useful for NFS as root filesystem),
58 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
59 */
60static unsigned long nlm_grace_period;
61static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO;
62static int nlm_udpport, nlm_tcpport;
Olaf Kirchabd1f502006-10-04 02:16:01 -070063int nsm_use_hostnames = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65/*
66 * Constants needed for the sysctl interface.
67 */
68static const unsigned long nlm_grace_period_min = 0;
69static const unsigned long nlm_grace_period_max = 240;
70static const unsigned long nlm_timeout_min = 3;
71static const unsigned long nlm_timeout_max = 20;
72static const int nlm_port_min = 0, nlm_port_max = 65535;
73
Chuck Lever90d5b182008-03-14 14:18:30 -040074#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -070075static struct ctl_table_header * nlm_sysctl_table;
Chuck Lever90d5b182008-03-14 14:18:30 -040076#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Marc Eshel9a8db972007-07-17 04:04:35 -070078static unsigned long get_lockd_grace_period(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 /* Note: nlm_timeout should always be nonzero */
81 if (nlm_grace_period)
Marc Eshel9a8db972007-07-17 04:04:35 -070082 return roundup(nlm_grace_period, nlm_timeout) * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 else
Marc Eshel9a8db972007-07-17 04:04:35 -070084 return nlm_timeout * 5 * HZ;
85}
86
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -040087static struct lock_manager lockd_manager = {
88};
Marc Eshel9a8db972007-07-17 04:04:35 -070089
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -040090static void grace_ender(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -040092 locks_end_grace(&lockd_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -040095static DECLARE_DELAYED_WORK(grace_period_end, grace_ender);
96
97static void set_grace_period(void)
98{
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -040099 unsigned long grace_period = get_lockd_grace_period();
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400100
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -0400101 locks_start_grace(&lockd_manager);
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400102 cancel_delayed_work_sync(&grace_period_end);
103 schedule_delayed_work(&grace_period_end, grace_period);
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/*
107 * This is the lockd kernel thread
108 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500109static int
110lockd(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
Jeff Laytonf97c6502008-04-08 15:40:08 -0400112 int err = 0, preverr = 0;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500113 struct svc_rqst *rqstp = vrqstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Jeff Laytond751a7c2008-02-07 16:34:55 -0500115 /* try_to_freeze() is called from svc_recv() */
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700116 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Jeff Laytond751a7c2008-02-07 16:34:55 -0500118 /* Allow SIGKILL to tell lockd to drop all of its locks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 allow_signal(SIGKILL);
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
122
Jeff Laytond751a7c2008-02-07 16:34:55 -0500123 /*
124 * FIXME: it would be nice if lockd didn't spend its entire life
125 * running under the BKL. At the very least, it would be good to
126 * have someone clarify what it's intended to protect here. I've
127 * seen some handwavy posts about posix locking needing to be
128 * done under the BKL, but it's far from clear.
129 */
130 lock_kernel();
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 if (!nlm_timeout)
133 nlm_timeout = LOCKD_DFLT_TIMEO;
134 nlmsvc_timeout = nlm_timeout * HZ;
135
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400136 set_grace_period();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138 /*
139 * The main request loop. We don't terminate until the last
Jeff Laytond751a7c2008-02-07 16:34:55 -0500140 * NFS mount or NFS daemon has gone away.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500142 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 long timeout = MAX_SCHEDULE_TIMEOUT;
Pavel Emelyanov5216a8e2008-02-21 10:57:45 +0300144 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146 if (signalled()) {
147 flush_signals(current);
148 if (nlmsvc_ops) {
149 nlmsvc_invalidate_all();
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400150 set_grace_period();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500152 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
154
J. Bruce Fields8fafa902008-01-24 11:11:34 -0500155 timeout = nlmsvc_retry_blocked();
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 /*
158 * Find a socket with data available and call its
159 * recvfrom routine.
160 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700161 err = svc_recv(rqstp, timeout);
Jeff Laytonf97c6502008-04-08 15:40:08 -0400162 if (err == -EAGAIN || err == -EINTR) {
163 preverr = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
Jeff Laytonf97c6502008-04-08 15:40:08 -0400166 if (err < 0) {
167 if (err != preverr) {
168 printk(KERN_WARNING "%s: unexpected error "
169 "from svc_recv (%d)\n", __func__, err);
170 preverr = err;
171 }
172 schedule_timeout_interruptible(HZ);
173 continue;
174 }
175 preverr = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Chuck Leverad06e4b2007-02-12 00:53:32 -0800177 dprintk("lockd: request from %s\n",
178 svc_print_addr(rqstp, buf, sizeof(buf)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
NeilBrown6fb2b472006-10-02 02:17:50 -0700180 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 }
Trond Myklebust2bd61572006-01-03 09:55:19 +0100182 flush_signals(current);
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400183 cancel_delayed_work_sync(&grace_period_end);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500184 if (nlmsvc_ops)
185 nlmsvc_invalidate_all();
186 nlm_shutdown_hosts();
Jeff Laytond751a7c2008-02-07 16:34:55 -0500187 unlock_kernel();
Jeff Laytond751a7c2008-02-07 16:34:55 -0500188 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
Chuck Lever482fb942007-02-12 00:53:29 -0800191/*
Chuck Lever8c3916f2008-10-03 17:15:23 -0400192 * Ensure there are active UDP and TCP listeners for lockd.
193 *
194 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
195 * local services (such as rpc.statd) still require UDP, and
196 * some NFS servers do not yet support NLM over TCP.
197 *
198 * Returns zero if all listeners are available; otherwise a
199 * negative errno value is returned.
Chuck Lever482fb942007-02-12 00:53:29 -0800200 */
Chuck Lever8c3916f2008-10-03 17:15:23 -0400201static int make_socks(struct svc_serv *serv)
NeilBrown24e36662006-10-02 02:17:45 -0700202{
Chuck Lever482fb942007-02-12 00:53:29 -0800203 static int warned;
Tom Tuckera2178132007-12-30 21:08:35 -0600204 struct svc_xprt *xprt;
NeilBrown24e36662006-10-02 02:17:45 -0700205 int err = 0;
Chuck Lever482fb942007-02-12 00:53:29 -0800206
Chuck Lever8c3916f2008-10-03 17:15:23 -0400207 xprt = svc_find_xprt(serv, "udp", 0, 0);
208 if (!xprt)
209 err = svc_create_xprt(serv, "udp", nlm_udpport,
210 SVC_SOCK_DEFAULTS);
211 else
212 svc_xprt_put(xprt);
213 if (err >= 0) {
Tom Tuckera2178132007-12-30 21:08:35 -0600214 xprt = svc_find_xprt(serv, "tcp", 0, 0);
215 if (!xprt)
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600216 err = svc_create_xprt(serv, "tcp", nlm_tcpport,
217 SVC_SOCK_DEFAULTS);
Tom Tuckera2178132007-12-30 21:08:35 -0600218 else
219 svc_xprt_put(xprt);
220 }
Chuck Lever482fb942007-02-12 00:53:29 -0800221 if (err >= 0) {
NeilBrown7dcf91e2006-10-02 02:17:52 -0700222 warned = 0;
Chuck Lever482fb942007-02-12 00:53:29 -0800223 err = 0;
224 } else if (warned++ == 0)
NeilBrown7dcf91e2006-10-02 02:17:52 -0700225 printk(KERN_WARNING
226 "lockd_up: makesock failed, error=%d\n", err);
NeilBrown24e36662006-10-02 02:17:45 -0700227 return err;
228}
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230/*
231 * Bring up the lockd process if it's not already up.
232 */
Chuck Lever26a41402008-10-03 17:15:30 -0400233int lockd_up(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
Jeff Laytond751a7c2008-02-07 16:34:55 -0500235 struct svc_serv *serv;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500236 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800238 mutex_lock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 * Check whether we're already up and running.
241 */
Chuck Lever8c3916f2008-10-03 17:15:23 -0400242 if (nlmsvc_rqst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 goto out;
244
245 /*
246 * Sanity check: if there's no pid,
247 * we should be the first user ...
248 */
NeilBrown4a3ae422006-10-02 02:17:53 -0700249 if (nlmsvc_users)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 printk(KERN_WARNING
251 "lockd_up: no pid, %d users??\n", nlmsvc_users);
252
253 error = -ENOMEM;
Chuck Levere851db52008-06-30 18:45:30 -0400254 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, AF_INET, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 if (!serv) {
256 printk(KERN_WARNING "lockd_up: create service failed\n");
257 goto out;
258 }
259
Chuck Lever8c3916f2008-10-03 17:15:23 -0400260 error = make_socks(serv);
261 if (error < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto destroy_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 /*
265 * Create the kernel thread and wait for it to start.
266 */
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400267 nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
268 if (IS_ERR(nlmsvc_rqst)) {
269 error = PTR_ERR(nlmsvc_rqst);
270 nlmsvc_rqst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 printk(KERN_WARNING
Jeff Laytond751a7c2008-02-07 16:34:55 -0500272 "lockd_up: svc_rqst allocation failed, error=%d\n",
273 error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 goto destroy_and_out;
275 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500276
277 svc_sock_update_bufs(serv);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500278
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400279 nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, serv->sv_name);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500280 if (IS_ERR(nlmsvc_task)) {
281 error = PTR_ERR(nlmsvc_task);
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400282 svc_exit_thread(nlmsvc_rqst);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500283 nlmsvc_task = NULL;
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400284 nlmsvc_rqst = NULL;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500285 printk(KERN_WARNING
286 "lockd_up: kthread_run failed, error=%d\n", error);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500287 goto destroy_and_out;
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 /*
291 * Note: svc_serv structures have an initial use count of 1,
292 * so we exit through here on both success and failure.
293 */
294destroy_and_out:
295 svc_destroy(serv);
296out:
NeilBrown4a3ae422006-10-02 02:17:53 -0700297 if (!error)
298 nlmsvc_users++;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800299 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 return error;
301}
302EXPORT_SYMBOL(lockd_up);
303
304/*
305 * Decrement the user count and bring down lockd if we're the last.
306 */
307void
308lockd_down(void)
309{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800310 mutex_lock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (nlmsvc_users) {
312 if (--nlmsvc_users)
313 goto out;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500314 } else {
315 printk(KERN_ERR "lockd_down: no users! task=%p\n",
316 nlmsvc_task);
317 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Jeff Laytond751a7c2008-02-07 16:34:55 -0500320 if (!nlmsvc_task) {
321 printk(KERN_ERR "lockd_down: no lockd running.\n");
322 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500324 kthread_stop(nlmsvc_task);
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400325 svc_exit_thread(nlmsvc_rqst);
326 nlmsvc_task = NULL;
327 nlmsvc_rqst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800329 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331EXPORT_SYMBOL(lockd_down);
332
Chuck Lever90d5b182008-03-14 14:18:30 -0400333#ifdef CONFIG_SYSCTL
334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335/*
336 * Sysctl parameters (same as module parameters, different interface).
337 */
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339static ctl_table nlm_sysctls[] = {
340 {
341 .ctl_name = CTL_UNNUMBERED,
342 .procname = "nlm_grace_period",
343 .data = &nlm_grace_period,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700344 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 .mode = 0644,
346 .proc_handler = &proc_doulongvec_minmax,
347 .extra1 = (unsigned long *) &nlm_grace_period_min,
348 .extra2 = (unsigned long *) &nlm_grace_period_max,
349 },
350 {
351 .ctl_name = CTL_UNNUMBERED,
352 .procname = "nlm_timeout",
353 .data = &nlm_timeout,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700354 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .mode = 0644,
356 .proc_handler = &proc_doulongvec_minmax,
357 .extra1 = (unsigned long *) &nlm_timeout_min,
358 .extra2 = (unsigned long *) &nlm_timeout_max,
359 },
360 {
361 .ctl_name = CTL_UNNUMBERED,
362 .procname = "nlm_udpport",
363 .data = &nlm_udpport,
364 .maxlen = sizeof(int),
365 .mode = 0644,
366 .proc_handler = &proc_dointvec_minmax,
367 .extra1 = (int *) &nlm_port_min,
368 .extra2 = (int *) &nlm_port_max,
369 },
370 {
371 .ctl_name = CTL_UNNUMBERED,
372 .procname = "nlm_tcpport",
373 .data = &nlm_tcpport,
374 .maxlen = sizeof(int),
375 .mode = 0644,
376 .proc_handler = &proc_dointvec_minmax,
377 .extra1 = (int *) &nlm_port_min,
378 .extra2 = (int *) &nlm_port_max,
379 },
Olaf Kirchabd1f502006-10-04 02:16:01 -0700380 {
381 .ctl_name = CTL_UNNUMBERED,
382 .procname = "nsm_use_hostnames",
383 .data = &nsm_use_hostnames,
384 .maxlen = sizeof(int),
385 .mode = 0644,
386 .proc_handler = &proc_dointvec,
387 },
Olaf Kirch460f5ca2006-10-04 02:16:03 -0700388 {
389 .ctl_name = CTL_UNNUMBERED,
390 .procname = "nsm_local_state",
391 .data = &nsm_local_state,
392 .maxlen = sizeof(int),
393 .mode = 0644,
394 .proc_handler = &proc_dointvec,
395 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 { .ctl_name = 0 }
397};
398
399static ctl_table nlm_sysctl_dir[] = {
400 {
401 .ctl_name = CTL_UNNUMBERED,
402 .procname = "nfs",
403 .mode = 0555,
404 .child = nlm_sysctls,
405 },
406 { .ctl_name = 0 }
407};
408
409static ctl_table nlm_sysctl_root[] = {
410 {
411 .ctl_name = CTL_FS,
412 .procname = "fs",
413 .mode = 0555,
414 .child = nlm_sysctl_dir,
415 },
416 { .ctl_name = 0 }
417};
418
Chuck Lever90d5b182008-03-14 14:18:30 -0400419#endif /* CONFIG_SYSCTL */
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100422 * Module (and sysfs) parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 */
424
425#define param_set_min_max(name, type, which_strtol, min, max) \
426static int param_set_##name(const char *val, struct kernel_param *kp) \
427{ \
428 char *endp; \
429 __typeof__(type) num = which_strtol(val, &endp, 0); \
430 if (endp == val || *endp || num < (min) || num > (max)) \
431 return -EINVAL; \
432 *((int *) kp->arg) = num; \
433 return 0; \
434}
435
436static inline int is_callback(u32 proc)
437{
438 return proc == NLMPROC_GRANTED
439 || proc == NLMPROC_GRANTED_MSG
440 || proc == NLMPROC_TEST_RES
441 || proc == NLMPROC_LOCK_RES
442 || proc == NLMPROC_CANCEL_RES
443 || proc == NLMPROC_UNLOCK_RES
444 || proc == NLMPROC_NSM_NOTIFY;
445}
446
447
448static int lockd_authenticate(struct svc_rqst *rqstp)
449{
450 rqstp->rq_client = NULL;
451 switch (rqstp->rq_authop->flavour) {
452 case RPC_AUTH_NULL:
453 case RPC_AUTH_UNIX:
454 if (rqstp->rq_proc == 0)
455 return SVC_OK;
456 if (is_callback(rqstp->rq_proc)) {
457 /* Leave it to individual procedures to
458 * call nlmsvc_lookup_host(rqstp)
459 */
460 return SVC_OK;
461 }
462 return svc_set_client(rqstp);
463 }
464 return SVC_DENIED;
465}
466
467
468param_set_min_max(port, int, simple_strtol, 0, 65535)
469param_set_min_max(grace_period, unsigned long, simple_strtoul,
470 nlm_grace_period_min, nlm_grace_period_max)
471param_set_min_max(timeout, unsigned long, simple_strtoul,
472 nlm_timeout_min, nlm_timeout_max)
473
474MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
475MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
476MODULE_LICENSE("GPL");
477
478module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
479 &nlm_grace_period, 0644);
480module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
481 &nlm_timeout, 0644);
482module_param_call(nlm_udpport, param_set_port, param_get_int,
483 &nlm_udpport, 0644);
484module_param_call(nlm_tcpport, param_set_port, param_get_int,
485 &nlm_tcpport, 0644);
Olaf Kirchabd1f502006-10-04 02:16:01 -0700486module_param(nsm_use_hostnames, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488/*
489 * Initialising and terminating the module.
490 */
491
492static int __init init_nlm(void)
493{
Chuck Lever90d5b182008-03-14 14:18:30 -0400494#ifdef CONFIG_SYSCTL
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800495 nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return nlm_sysctl_table ? 0 : -ENOMEM;
Chuck Lever90d5b182008-03-14 14:18:30 -0400497#else
498 return 0;
499#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
502static void __exit exit_nlm(void)
503{
504 /* FIXME: delete all NLM clients */
505 nlm_shutdown_hosts();
Chuck Lever90d5b182008-03-14 14:18:30 -0400506#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 unregister_sysctl_table(nlm_sysctl_table);
Chuck Lever90d5b182008-03-14 14:18:30 -0400508#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509}
510
511module_init(init_nlm);
512module_exit(exit_nlm);
513
514/*
515 * Define NLM program and procedures
516 */
517static struct svc_version nlmsvc_version1 = {
518 .vs_vers = 1,
519 .vs_nproc = 17,
520 .vs_proc = nlmsvc_procedures,
521 .vs_xdrsize = NLMSVC_XDRSIZE,
522};
523static struct svc_version nlmsvc_version3 = {
524 .vs_vers = 3,
525 .vs_nproc = 24,
526 .vs_proc = nlmsvc_procedures,
527 .vs_xdrsize = NLMSVC_XDRSIZE,
528};
529#ifdef CONFIG_LOCKD_V4
530static struct svc_version nlmsvc_version4 = {
531 .vs_vers = 4,
532 .vs_nproc = 24,
533 .vs_proc = nlmsvc_procedures4,
534 .vs_xdrsize = NLMSVC_XDRSIZE,
535};
536#endif
537static struct svc_version * nlmsvc_version[] = {
538 [1] = &nlmsvc_version1,
539 [3] = &nlmsvc_version3,
540#ifdef CONFIG_LOCKD_V4
541 [4] = &nlmsvc_version4,
542#endif
543};
544
545static struct svc_stat nlmsvc_stats;
546
Tobias Klausere8c96f82006-03-24 03:15:34 -0800547#define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548static struct svc_program nlmsvc_program = {
549 .pg_prog = NLM_PROGRAM, /* program number */
550 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */
551 .pg_vers = nlmsvc_version, /* version table */
552 .pg_name = "lockd", /* service name */
553 .pg_class = "nfsd", /* share authentication with nfsd */
554 .pg_stats = &nlmsvc_stats, /* stats table */
555 .pg_authenticate = &lockd_authenticate /* export authentication */
556};