blob: 1553fecc567d20d3bc7bc3f37f586d79ae51d933 [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 -070054int nlmsvc_grace_period;
55unsigned long nlmsvc_timeout;
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057/*
58 * These can be set at insmod time (useful for NFS as root filesystem),
59 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
60 */
61static unsigned long nlm_grace_period;
62static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO;
63static int nlm_udpport, nlm_tcpport;
Olaf Kirchabd1f502006-10-04 02:16:01 -070064int nsm_use_hostnames = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/*
67 * Constants needed for the sysctl interface.
68 */
69static const unsigned long nlm_grace_period_min = 0;
70static const unsigned long nlm_grace_period_max = 240;
71static const unsigned long nlm_timeout_min = 3;
72static const unsigned long nlm_timeout_max = 20;
73static const int nlm_port_min = 0, nlm_port_max = 65535;
74
Chuck Lever90d5b182008-03-14 14:18:30 -040075#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -070076static struct ctl_table_header * nlm_sysctl_table;
Chuck Lever90d5b182008-03-14 14:18:30 -040077#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Marc Eshel9a8db972007-07-17 04:04:35 -070079static unsigned long get_lockd_grace_period(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 /* Note: nlm_timeout should always be nonzero */
82 if (nlm_grace_period)
Marc Eshel9a8db972007-07-17 04:04:35 -070083 return roundup(nlm_grace_period, nlm_timeout) * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 else
Marc Eshel9a8db972007-07-17 04:04:35 -070085 return nlm_timeout * 5 * HZ;
86}
87
88unsigned long get_nfs_grace_period(void)
89{
90 unsigned long lockdgrace = get_lockd_grace_period();
91 unsigned long nfsdgrace = 0;
92
93 if (nlmsvc_ops)
94 nfsdgrace = nlmsvc_ops->get_grace_period();
95
96 return max(lockdgrace, nfsdgrace);
97}
98EXPORT_SYMBOL(get_nfs_grace_period);
99
100static unsigned long set_grace_period(void)
101{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 nlmsvc_grace_period = 1;
Marc Eshel9a8db972007-07-17 04:04:35 -0700103 return get_nfs_grace_period() + jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
106static inline void clear_grace_period(void)
107{
108 nlmsvc_grace_period = 0;
109}
110
111/*
112 * This is the lockd kernel thread
113 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500114static int
115lockd(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
Jeff Laytonf97c6502008-04-08 15:40:08 -0400117 int err = 0, preverr = 0;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500118 struct svc_rqst *rqstp = vrqstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 unsigned long grace_period_expire;
120
Jeff Laytond751a7c2008-02-07 16:34:55 -0500121 /* try_to_freeze() is called from svc_recv() */
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700122 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Jeff Laytond751a7c2008-02-07 16:34:55 -0500124 /* Allow SIGKILL to tell lockd to drop all of its locks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 allow_signal(SIGKILL);
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
128
Jeff Laytond751a7c2008-02-07 16:34:55 -0500129 /*
130 * FIXME: it would be nice if lockd didn't spend its entire life
131 * running under the BKL. At the very least, it would be good to
132 * have someone clarify what it's intended to protect here. I've
133 * seen some handwavy posts about posix locking needing to be
134 * done under the BKL, but it's far from clear.
135 */
136 lock_kernel();
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (!nlm_timeout)
139 nlm_timeout = LOCKD_DFLT_TIMEO;
140 nlmsvc_timeout = nlm_timeout * HZ;
141
142 grace_period_expire = set_grace_period();
143
144 /*
145 * The main request loop. We don't terminate until the last
Jeff Laytond751a7c2008-02-07 16:34:55 -0500146 * NFS mount or NFS daemon has gone away.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500148 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 long timeout = MAX_SCHEDULE_TIMEOUT;
Pavel Emelyanov5216a8e2008-02-21 10:57:45 +0300150 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 if (signalled()) {
153 flush_signals(current);
154 if (nlmsvc_ops) {
155 nlmsvc_invalidate_all();
156 grace_period_expire = set_grace_period();
157 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500158 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 }
160
161 /*
162 * Retry any blocked locks that have been notified by
163 * the VFS. Don't do this during grace period.
164 * (Theoretically, there shouldn't even be blocked locks
165 * during grace period).
166 */
167 if (!nlmsvc_grace_period) {
168 timeout = nlmsvc_retry_blocked();
169 } else if (time_before(grace_period_expire, jiffies))
170 clear_grace_period();
171
172 /*
173 * Find a socket with data available and call its
174 * recvfrom routine.
175 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700176 err = svc_recv(rqstp, timeout);
Jeff Laytonf97c6502008-04-08 15:40:08 -0400177 if (err == -EAGAIN || err == -EINTR) {
178 preverr = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 }
Jeff Laytonf97c6502008-04-08 15:40:08 -0400181 if (err < 0) {
182 if (err != preverr) {
183 printk(KERN_WARNING "%s: unexpected error "
184 "from svc_recv (%d)\n", __func__, err);
185 preverr = err;
186 }
187 schedule_timeout_interruptible(HZ);
188 continue;
189 }
190 preverr = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Chuck Leverad06e4b2007-02-12 00:53:32 -0800192 dprintk("lockd: request from %s\n",
193 svc_print_addr(rqstp, buf, sizeof(buf)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
NeilBrown6fb2b472006-10-02 02:17:50 -0700195 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 }
Trond Myklebust2bd61572006-01-03 09:55:19 +0100197 flush_signals(current);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500198 if (nlmsvc_ops)
199 nlmsvc_invalidate_all();
200 nlm_shutdown_hosts();
Jeff Laytond751a7c2008-02-07 16:34:55 -0500201 unlock_kernel();
Jeff Laytond751a7c2008-02-07 16:34:55 -0500202 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
Chuck Lever482fb942007-02-12 00:53:29 -0800205/*
206 * Make any sockets that are needed but not present.
207 * If nlm_udpport or nlm_tcpport were set as module
208 * options, make those sockets unconditionally
209 */
NeilBrown24e36662006-10-02 02:17:45 -0700210static int make_socks(struct svc_serv *serv, int proto)
211{
Chuck Lever482fb942007-02-12 00:53:29 -0800212 static int warned;
Tom Tuckera2178132007-12-30 21:08:35 -0600213 struct svc_xprt *xprt;
NeilBrown24e36662006-10-02 02:17:45 -0700214 int err = 0;
Chuck Lever482fb942007-02-12 00:53:29 -0800215
Tom Tuckera2178132007-12-30 21:08:35 -0600216 if (proto == IPPROTO_UDP || nlm_udpport) {
217 xprt = svc_find_xprt(serv, "udp", 0, 0);
218 if (!xprt)
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600219 err = svc_create_xprt(serv, "udp", nlm_udpport,
220 SVC_SOCK_DEFAULTS);
Tom Tuckera2178132007-12-30 21:08:35 -0600221 else
222 svc_xprt_put(xprt);
223 }
224 if (err >= 0 && (proto == IPPROTO_TCP || nlm_tcpport)) {
225 xprt = svc_find_xprt(serv, "tcp", 0, 0);
226 if (!xprt)
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600227 err = svc_create_xprt(serv, "tcp", nlm_tcpport,
228 SVC_SOCK_DEFAULTS);
Tom Tuckera2178132007-12-30 21:08:35 -0600229 else
230 svc_xprt_put(xprt);
231 }
Chuck Lever482fb942007-02-12 00:53:29 -0800232 if (err >= 0) {
NeilBrown7dcf91e2006-10-02 02:17:52 -0700233 warned = 0;
Chuck Lever482fb942007-02-12 00:53:29 -0800234 err = 0;
235 } else if (warned++ == 0)
NeilBrown7dcf91e2006-10-02 02:17:52 -0700236 printk(KERN_WARNING
237 "lockd_up: makesock failed, error=%d\n", err);
NeilBrown24e36662006-10-02 02:17:45 -0700238 return err;
239}
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241/*
242 * Bring up the lockd process if it's not already up.
243 */
244int
NeilBrown24e36662006-10-02 02:17:45 -0700245lockd_up(int proto) /* Maybe add a 'family' option when IPv6 is supported ?? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
Jeff Laytond751a7c2008-02-07 16:34:55 -0500247 struct svc_serv *serv;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500248 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800250 mutex_lock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 * Check whether we're already up and running.
253 */
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400254 if (nlmsvc_rqst) {
NeilBrown4a3ae422006-10-02 02:17:53 -0700255 if (proto)
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400256 error = make_socks(nlmsvc_rqst->rq_server, proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 goto out;
NeilBrown24e36662006-10-02 02:17:45 -0700258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 /*
261 * Sanity check: if there's no pid,
262 * we should be the first user ...
263 */
NeilBrown4a3ae422006-10-02 02:17:53 -0700264 if (nlmsvc_users)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 printk(KERN_WARNING
266 "lockd_up: no pid, %d users??\n", nlmsvc_users);
267
268 error = -ENOMEM;
Chuck Levere851db52008-06-30 18:45:30 -0400269 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, AF_INET, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 if (!serv) {
271 printk(KERN_WARNING "lockd_up: create service failed\n");
272 goto out;
273 }
274
NeilBrown7dcf91e2006-10-02 02:17:52 -0700275 if ((error = make_socks(serv, proto)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 goto destroy_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 /*
279 * Create the kernel thread and wait for it to start.
280 */
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400281 nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
282 if (IS_ERR(nlmsvc_rqst)) {
283 error = PTR_ERR(nlmsvc_rqst);
284 nlmsvc_rqst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 printk(KERN_WARNING
Jeff Laytond751a7c2008-02-07 16:34:55 -0500286 "lockd_up: svc_rqst allocation failed, error=%d\n",
287 error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 goto destroy_and_out;
289 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500290
291 svc_sock_update_bufs(serv);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500292
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400293 nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, serv->sv_name);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500294 if (IS_ERR(nlmsvc_task)) {
295 error = PTR_ERR(nlmsvc_task);
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400296 svc_exit_thread(nlmsvc_rqst);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500297 nlmsvc_task = NULL;
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400298 nlmsvc_rqst = NULL;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500299 printk(KERN_WARNING
300 "lockd_up: kthread_run failed, error=%d\n", error);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500301 goto destroy_and_out;
302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 /*
305 * Note: svc_serv structures have an initial use count of 1,
306 * so we exit through here on both success and failure.
307 */
308destroy_and_out:
309 svc_destroy(serv);
310out:
NeilBrown4a3ae422006-10-02 02:17:53 -0700311 if (!error)
312 nlmsvc_users++;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800313 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 return error;
315}
316EXPORT_SYMBOL(lockd_up);
317
318/*
319 * Decrement the user count and bring down lockd if we're the last.
320 */
321void
322lockd_down(void)
323{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800324 mutex_lock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 if (nlmsvc_users) {
326 if (--nlmsvc_users)
327 goto out;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500328 } else {
329 printk(KERN_ERR "lockd_down: no users! task=%p\n",
330 nlmsvc_task);
331 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
Jeff Laytond751a7c2008-02-07 16:34:55 -0500334 if (!nlmsvc_task) {
335 printk(KERN_ERR "lockd_down: no lockd running.\n");
336 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500338 kthread_stop(nlmsvc_task);
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400339 svc_exit_thread(nlmsvc_rqst);
340 nlmsvc_task = NULL;
341 nlmsvc_rqst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800343 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344}
345EXPORT_SYMBOL(lockd_down);
346
Chuck Lever90d5b182008-03-14 14:18:30 -0400347#ifdef CONFIG_SYSCTL
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349/*
350 * Sysctl parameters (same as module parameters, different interface).
351 */
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353static ctl_table nlm_sysctls[] = {
354 {
355 .ctl_name = CTL_UNNUMBERED,
356 .procname = "nlm_grace_period",
357 .data = &nlm_grace_period,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700358 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 .mode = 0644,
360 .proc_handler = &proc_doulongvec_minmax,
361 .extra1 = (unsigned long *) &nlm_grace_period_min,
362 .extra2 = (unsigned long *) &nlm_grace_period_max,
363 },
364 {
365 .ctl_name = CTL_UNNUMBERED,
366 .procname = "nlm_timeout",
367 .data = &nlm_timeout,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700368 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 .mode = 0644,
370 .proc_handler = &proc_doulongvec_minmax,
371 .extra1 = (unsigned long *) &nlm_timeout_min,
372 .extra2 = (unsigned long *) &nlm_timeout_max,
373 },
374 {
375 .ctl_name = CTL_UNNUMBERED,
376 .procname = "nlm_udpport",
377 .data = &nlm_udpport,
378 .maxlen = sizeof(int),
379 .mode = 0644,
380 .proc_handler = &proc_dointvec_minmax,
381 .extra1 = (int *) &nlm_port_min,
382 .extra2 = (int *) &nlm_port_max,
383 },
384 {
385 .ctl_name = CTL_UNNUMBERED,
386 .procname = "nlm_tcpport",
387 .data = &nlm_tcpport,
388 .maxlen = sizeof(int),
389 .mode = 0644,
390 .proc_handler = &proc_dointvec_minmax,
391 .extra1 = (int *) &nlm_port_min,
392 .extra2 = (int *) &nlm_port_max,
393 },
Olaf Kirchabd1f502006-10-04 02:16:01 -0700394 {
395 .ctl_name = CTL_UNNUMBERED,
396 .procname = "nsm_use_hostnames",
397 .data = &nsm_use_hostnames,
398 .maxlen = sizeof(int),
399 .mode = 0644,
400 .proc_handler = &proc_dointvec,
401 },
Olaf Kirch460f5ca2006-10-04 02:16:03 -0700402 {
403 .ctl_name = CTL_UNNUMBERED,
404 .procname = "nsm_local_state",
405 .data = &nsm_local_state,
406 .maxlen = sizeof(int),
407 .mode = 0644,
408 .proc_handler = &proc_dointvec,
409 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 { .ctl_name = 0 }
411};
412
413static ctl_table nlm_sysctl_dir[] = {
414 {
415 .ctl_name = CTL_UNNUMBERED,
416 .procname = "nfs",
417 .mode = 0555,
418 .child = nlm_sysctls,
419 },
420 { .ctl_name = 0 }
421};
422
423static ctl_table nlm_sysctl_root[] = {
424 {
425 .ctl_name = CTL_FS,
426 .procname = "fs",
427 .mode = 0555,
428 .child = nlm_sysctl_dir,
429 },
430 { .ctl_name = 0 }
431};
432
Chuck Lever90d5b182008-03-14 14:18:30 -0400433#endif /* CONFIG_SYSCTL */
434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100436 * Module (and sysfs) parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 */
438
439#define param_set_min_max(name, type, which_strtol, min, max) \
440static int param_set_##name(const char *val, struct kernel_param *kp) \
441{ \
442 char *endp; \
443 __typeof__(type) num = which_strtol(val, &endp, 0); \
444 if (endp == val || *endp || num < (min) || num > (max)) \
445 return -EINVAL; \
446 *((int *) kp->arg) = num; \
447 return 0; \
448}
449
450static inline int is_callback(u32 proc)
451{
452 return proc == NLMPROC_GRANTED
453 || proc == NLMPROC_GRANTED_MSG
454 || proc == NLMPROC_TEST_RES
455 || proc == NLMPROC_LOCK_RES
456 || proc == NLMPROC_CANCEL_RES
457 || proc == NLMPROC_UNLOCK_RES
458 || proc == NLMPROC_NSM_NOTIFY;
459}
460
461
462static int lockd_authenticate(struct svc_rqst *rqstp)
463{
464 rqstp->rq_client = NULL;
465 switch (rqstp->rq_authop->flavour) {
466 case RPC_AUTH_NULL:
467 case RPC_AUTH_UNIX:
468 if (rqstp->rq_proc == 0)
469 return SVC_OK;
470 if (is_callback(rqstp->rq_proc)) {
471 /* Leave it to individual procedures to
472 * call nlmsvc_lookup_host(rqstp)
473 */
474 return SVC_OK;
475 }
476 return svc_set_client(rqstp);
477 }
478 return SVC_DENIED;
479}
480
481
482param_set_min_max(port, int, simple_strtol, 0, 65535)
483param_set_min_max(grace_period, unsigned long, simple_strtoul,
484 nlm_grace_period_min, nlm_grace_period_max)
485param_set_min_max(timeout, unsigned long, simple_strtoul,
486 nlm_timeout_min, nlm_timeout_max)
487
488MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
489MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
490MODULE_LICENSE("GPL");
491
492module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
493 &nlm_grace_period, 0644);
494module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
495 &nlm_timeout, 0644);
496module_param_call(nlm_udpport, param_set_port, param_get_int,
497 &nlm_udpport, 0644);
498module_param_call(nlm_tcpport, param_set_port, param_get_int,
499 &nlm_tcpport, 0644);
Olaf Kirchabd1f502006-10-04 02:16:01 -0700500module_param(nsm_use_hostnames, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502/*
503 * Initialising and terminating the module.
504 */
505
506static int __init init_nlm(void)
507{
Chuck Lever90d5b182008-03-14 14:18:30 -0400508#ifdef CONFIG_SYSCTL
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800509 nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return nlm_sysctl_table ? 0 : -ENOMEM;
Chuck Lever90d5b182008-03-14 14:18:30 -0400511#else
512 return 0;
513#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
516static void __exit exit_nlm(void)
517{
518 /* FIXME: delete all NLM clients */
519 nlm_shutdown_hosts();
Chuck Lever90d5b182008-03-14 14:18:30 -0400520#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 unregister_sysctl_table(nlm_sysctl_table);
Chuck Lever90d5b182008-03-14 14:18:30 -0400522#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523}
524
525module_init(init_nlm);
526module_exit(exit_nlm);
527
528/*
529 * Define NLM program and procedures
530 */
531static struct svc_version nlmsvc_version1 = {
532 .vs_vers = 1,
533 .vs_nproc = 17,
534 .vs_proc = nlmsvc_procedures,
535 .vs_xdrsize = NLMSVC_XDRSIZE,
536};
537static struct svc_version nlmsvc_version3 = {
538 .vs_vers = 3,
539 .vs_nproc = 24,
540 .vs_proc = nlmsvc_procedures,
541 .vs_xdrsize = NLMSVC_XDRSIZE,
542};
543#ifdef CONFIG_LOCKD_V4
544static struct svc_version nlmsvc_version4 = {
545 .vs_vers = 4,
546 .vs_nproc = 24,
547 .vs_proc = nlmsvc_procedures4,
548 .vs_xdrsize = NLMSVC_XDRSIZE,
549};
550#endif
551static struct svc_version * nlmsvc_version[] = {
552 [1] = &nlmsvc_version1,
553 [3] = &nlmsvc_version3,
554#ifdef CONFIG_LOCKD_V4
555 [4] = &nlmsvc_version4,
556#endif
557};
558
559static struct svc_stat nlmsvc_stats;
560
Tobias Klausere8c96f82006-03-24 03:15:34 -0800561#define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562static struct svc_program nlmsvc_program = {
563 .pg_prog = NLM_PROGRAM, /* program number */
564 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */
565 .pg_vers = nlmsvc_version, /* version table */
566 .pg_name = "lockd", /* service name */
567 .pg_class = "nfsd", /* share authentication with nfsd */
568 .pg_stats = &nlmsvc_stats, /* stats table */
569 .pg_authenticate = &lockd_authenticate /* export authentication */
570};