lockd: double unlock in next_host_state()
[linux-2.6.git] / fs / lockd / svc.c
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.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
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>
34 #include <net/ip.h>
35 #include <linux/lockd/lockd.h>
36 #include <linux/nfs.h>
37
38 #define NLMDBG_FACILITY         NLMDBG_SVC
39 #define LOCKD_BUFSIZE           (1024 + NLMSVC_XDRSIZE)
40 #define ALLOWED_SIGS            (sigmask(SIGKILL))
41
42 static struct svc_program       nlmsvc_program;
43
44 struct nlmsvc_binding *         nlmsvc_ops;
45 EXPORT_SYMBOL_GPL(nlmsvc_ops);
46
47 static DEFINE_MUTEX(nlmsvc_mutex);
48 static unsigned int             nlmsvc_users;
49 static struct task_struct       *nlmsvc_task;
50 static struct svc_rqst          *nlmsvc_rqst;
51 unsigned long                   nlmsvc_timeout;
52
53 /*
54  * These can be set at insmod time (useful for NFS as root filesystem),
55  * and also changed through the sysctl interface.  -- Jamie Lokier, Aug 2003
56  */
57 static unsigned long            nlm_grace_period;
58 static unsigned long            nlm_timeout = LOCKD_DFLT_TIMEO;
59 static int                      nlm_udpport, nlm_tcpport;
60
61 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
62 static unsigned int             nlm_max_connections = 1024;
63
64 /*
65  * Constants needed for the sysctl interface.
66  */
67 static const unsigned long      nlm_grace_period_min = 0;
68 static const unsigned long      nlm_grace_period_max = 240;
69 static const unsigned long      nlm_timeout_min = 3;
70 static const unsigned long      nlm_timeout_max = 20;
71 static const int                nlm_port_min = 0, nlm_port_max = 65535;
72
73 #ifdef CONFIG_SYSCTL
74 static struct ctl_table_header * nlm_sysctl_table;
75 #endif
76
77 static unsigned long get_lockd_grace_period(void)
78 {
79         /* Note: nlm_timeout should always be nonzero */
80         if (nlm_grace_period)
81                 return roundup(nlm_grace_period, nlm_timeout) * HZ;
82         else
83                 return nlm_timeout * 5 * HZ;
84 }
85
86 static struct lock_manager lockd_manager = {
87 };
88
89 static void grace_ender(struct work_struct *not_used)
90 {
91         locks_end_grace(&lockd_manager);
92 }
93
94 static DECLARE_DELAYED_WORK(grace_period_end, grace_ender);
95
96 static void set_grace_period(void)
97 {
98         unsigned long grace_period = get_lockd_grace_period();
99
100         locks_start_grace(&lockd_manager);
101         cancel_delayed_work_sync(&grace_period_end);
102         schedule_delayed_work(&grace_period_end, grace_period);
103 }
104
105 static void restart_grace(void)
106 {
107         if (nlmsvc_ops) {
108                 cancel_delayed_work_sync(&grace_period_end);
109                 locks_end_grace(&lockd_manager);
110                 nlmsvc_invalidate_all();
111                 set_grace_period();
112         }
113 }
114
115 /*
116  * This is the lockd kernel thread
117  */
118 static int
119 lockd(void *vrqstp)
120 {
121         int             err = 0, preverr = 0;
122         struct svc_rqst *rqstp = vrqstp;
123
124         /* try_to_freeze() is called from svc_recv() */
125         set_freezable();
126
127         /* Allow SIGKILL to tell lockd to drop all of its locks */
128         allow_signal(SIGKILL);
129
130         dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
131
132         if (!nlm_timeout)
133                 nlm_timeout = LOCKD_DFLT_TIMEO;
134         nlmsvc_timeout = nlm_timeout * HZ;
135
136         set_grace_period();
137
138         /*
139          * The main request loop. We don't terminate until the last
140          * NFS mount or NFS daemon has gone away.
141          */
142         while (!kthread_should_stop()) {
143                 long timeout = MAX_SCHEDULE_TIMEOUT;
144                 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
145
146                 /* update sv_maxconn if it has changed */
147                 rqstp->rq_server->sv_maxconn = nlm_max_connections;
148
149                 if (signalled()) {
150                         flush_signals(current);
151                         restart_grace();
152                         continue;
153                 }
154
155                 timeout = nlmsvc_retry_blocked();
156
157                 /*
158                  * Find a socket with data available and call its
159                  * recvfrom routine.
160                  */
161                 err = svc_recv(rqstp, timeout);
162                 if (err == -EAGAIN || err == -EINTR) {
163                         preverr = err;
164                         continue;
165                 }
166                 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;
176
177                 dprintk("lockd: request from %s\n",
178                                 svc_print_addr(rqstp, buf, sizeof(buf)));
179
180                 svc_process(rqstp);
181         }
182         flush_signals(current);
183         cancel_delayed_work_sync(&grace_period_end);
184         locks_end_grace(&lockd_manager);
185         if (nlmsvc_ops)
186                 nlmsvc_invalidate_all();
187         nlm_shutdown_hosts();
188         return 0;
189 }
190
191 static int create_lockd_listener(struct svc_serv *serv, const char *name,
192                                  const int family, const unsigned short port)
193 {
194         struct svc_xprt *xprt;
195
196         xprt = svc_find_xprt(serv, name, family, 0);
197         if (xprt == NULL)
198                 return svc_create_xprt(serv, name, &init_net, family, port,
199                                                 SVC_SOCK_DEFAULTS);
200         svc_xprt_put(xprt);
201         return 0;
202 }
203
204 static int create_lockd_family(struct svc_serv *serv, const int family)
205 {
206         int err;
207
208         err = create_lockd_listener(serv, "udp", family, nlm_udpport);
209         if (err < 0)
210                 return err;
211
212         return create_lockd_listener(serv, "tcp", 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  */
225 static int make_socks(struct svc_serv *serv)
226 {
227         static int warned;
228         int err;
229
230         err = create_lockd_family(serv, PF_INET);
231         if (err < 0)
232                 goto out_err;
233
234         err = create_lockd_family(serv, 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         return err;
246 }
247
248 /*
249  * Bring up the lockd process if it's not already up.
250  */
251 int lockd_up(void)
252 {
253         struct svc_serv *serv;
254         int             error = 0;
255
256         mutex_lock(&nlmsvc_mutex);
257         /*
258          * Check whether we're already up and running.
259          */
260         if (nlmsvc_rqst)
261                 goto out;
262
263         /*
264          * Sanity check: if there's no pid,
265          * we should be the first user ...
266          */
267         if (nlmsvc_users)
268                 printk(KERN_WARNING
269                         "lockd_up: no pid, %d users??\n", nlmsvc_users);
270
271         error = -ENOMEM;
272         serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, NULL);
273         if (!serv) {
274                 printk(KERN_WARNING "lockd_up: create service failed\n");
275                 goto out;
276         }
277
278         error = make_socks(serv);
279         if (error < 0)
280                 goto destroy_and_out;
281
282         /*
283          * Create the kernel thread and wait for it to start.
284          */
285         nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
286         if (IS_ERR(nlmsvc_rqst)) {
287                 error = PTR_ERR(nlmsvc_rqst);
288                 nlmsvc_rqst = NULL;
289                 printk(KERN_WARNING
290                         "lockd_up: svc_rqst allocation failed, error=%d\n",
291                         error);
292                 goto destroy_and_out;
293         }
294
295         svc_sock_update_bufs(serv);
296         serv->sv_maxconn = nlm_max_connections;
297
298         nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, serv->sv_name);
299         if (IS_ERR(nlmsvc_task)) {
300                 error = PTR_ERR(nlmsvc_task);
301                 svc_exit_thread(nlmsvc_rqst);
302                 nlmsvc_task = NULL;
303                 nlmsvc_rqst = NULL;
304                 printk(KERN_WARNING
305                         "lockd_up: kthread_run failed, error=%d\n", error);
306                 goto destroy_and_out;
307         }
308
309         /*
310          * Note: svc_serv structures have an initial use count of 1,
311          * so we exit through here on both success and failure.
312          */
313 destroy_and_out:
314         svc_destroy(serv);
315 out:
316         if (!error)
317                 nlmsvc_users++;
318         mutex_unlock(&nlmsvc_mutex);
319         return error;
320 }
321 EXPORT_SYMBOL_GPL(lockd_up);
322
323 /*
324  * Decrement the user count and bring down lockd if we're the last.
325  */
326 void
327 lockd_down(void)
328 {
329         mutex_lock(&nlmsvc_mutex);
330         if (nlmsvc_users) {
331                 if (--nlmsvc_users)
332                         goto out;
333         } else {
334                 printk(KERN_ERR "lockd_down: no users! task=%p\n",
335                         nlmsvc_task);
336                 BUG();
337         }
338
339         if (!nlmsvc_task) {
340                 printk(KERN_ERR "lockd_down: no lockd running.\n");
341                 BUG();
342         }
343         kthread_stop(nlmsvc_task);
344         svc_exit_thread(nlmsvc_rqst);
345         nlmsvc_task = NULL;
346         nlmsvc_rqst = NULL;
347 out:
348         mutex_unlock(&nlmsvc_mutex);
349 }
350 EXPORT_SYMBOL_GPL(lockd_down);
351
352 #ifdef CONFIG_SYSCTL
353
354 /*
355  * Sysctl parameters (same as module parameters, different interface).
356  */
357
358 static ctl_table nlm_sysctls[] = {
359         {
360                 .procname       = "nlm_grace_period",
361                 .data           = &nlm_grace_period,
362                 .maxlen         = sizeof(unsigned long),
363                 .mode           = 0644,
364                 .proc_handler   = proc_doulongvec_minmax,
365                 .extra1         = (unsigned long *) &nlm_grace_period_min,
366                 .extra2         = (unsigned long *) &nlm_grace_period_max,
367         },
368         {
369                 .procname       = "nlm_timeout",
370                 .data           = &nlm_timeout,
371                 .maxlen         = sizeof(unsigned long),
372                 .mode           = 0644,
373                 .proc_handler   = proc_doulongvec_minmax,
374                 .extra1         = (unsigned long *) &nlm_timeout_min,
375                 .extra2         = (unsigned long *) &nlm_timeout_max,
376         },
377         {
378                 .procname       = "nlm_udpport",
379                 .data           = &nlm_udpport,
380                 .maxlen         = sizeof(int),
381                 .mode           = 0644,
382                 .proc_handler   = proc_dointvec_minmax,
383                 .extra1         = (int *) &nlm_port_min,
384                 .extra2         = (int *) &nlm_port_max,
385         },
386         {
387                 .procname       = "nlm_tcpport",
388                 .data           = &nlm_tcpport,
389                 .maxlen         = sizeof(int),
390                 .mode           = 0644,
391                 .proc_handler   = proc_dointvec_minmax,
392                 .extra1         = (int *) &nlm_port_min,
393                 .extra2         = (int *) &nlm_port_max,
394         },
395         {
396                 .procname       = "nsm_use_hostnames",
397                 .data           = &nsm_use_hostnames,
398                 .maxlen         = sizeof(int),
399                 .mode           = 0644,
400                 .proc_handler   = proc_dointvec,
401         },
402         {
403                 .procname       = "nsm_local_state",
404                 .data           = &nsm_local_state,
405                 .maxlen         = sizeof(int),
406                 .mode           = 0644,
407                 .proc_handler   = proc_dointvec,
408         },
409         { }
410 };
411
412 static ctl_table nlm_sysctl_dir[] = {
413         {
414                 .procname       = "nfs",
415                 .mode           = 0555,
416                 .child          = nlm_sysctls,
417         },
418         { }
419 };
420
421 static ctl_table nlm_sysctl_root[] = {
422         {
423                 .procname       = "fs",
424                 .mode           = 0555,
425                 .child          = nlm_sysctl_dir,
426         },
427         { }
428 };
429
430 #endif  /* CONFIG_SYSCTL */
431
432 /*
433  * Module (and sysfs) parameters.
434  */
435
436 #define param_set_min_max(name, type, which_strtol, min, max)           \
437 static int param_set_##name(const char *val, struct kernel_param *kp)   \
438 {                                                                       \
439         char *endp;                                                     \
440         __typeof__(type) num = which_strtol(val, &endp, 0);             \
441         if (endp == val || *endp || num < (min) || num > (max))         \
442                 return -EINVAL;                                         \
443         *((int *) kp->arg) = num;                                       \
444         return 0;                                                       \
445 }
446
447 static inline int is_callback(u32 proc)
448 {
449         return proc == NLMPROC_GRANTED
450                 || proc == NLMPROC_GRANTED_MSG
451                 || proc == NLMPROC_TEST_RES
452                 || proc == NLMPROC_LOCK_RES
453                 || proc == NLMPROC_CANCEL_RES
454                 || proc == NLMPROC_UNLOCK_RES
455                 || proc == NLMPROC_NSM_NOTIFY;
456 }
457
458
459 static int lockd_authenticate(struct svc_rqst *rqstp)
460 {
461         rqstp->rq_client = NULL;
462         switch (rqstp->rq_authop->flavour) {
463                 case RPC_AUTH_NULL:
464                 case RPC_AUTH_UNIX:
465                         if (rqstp->rq_proc == 0)
466                                 return SVC_OK;
467                         if (is_callback(rqstp->rq_proc)) {
468                                 /* Leave it to individual procedures to
469                                  * call nlmsvc_lookup_host(rqstp)
470                                  */
471                                 return SVC_OK;
472                         }
473                         return svc_set_client(rqstp);
474         }
475         return SVC_DENIED;
476 }
477
478
479 param_set_min_max(port, int, simple_strtol, 0, 65535)
480 param_set_min_max(grace_period, unsigned long, simple_strtoul,
481                   nlm_grace_period_min, nlm_grace_period_max)
482 param_set_min_max(timeout, unsigned long, simple_strtoul,
483                   nlm_timeout_min, nlm_timeout_max)
484
485 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
486 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
487 MODULE_LICENSE("GPL");
488
489 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
490                   &nlm_grace_period, 0644);
491 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
492                   &nlm_timeout, 0644);
493 module_param_call(nlm_udpport, param_set_port, param_get_int,
494                   &nlm_udpport, 0644);
495 module_param_call(nlm_tcpport, param_set_port, param_get_int,
496                   &nlm_tcpport, 0644);
497 module_param(nsm_use_hostnames, bool, 0644);
498 module_param(nlm_max_connections, uint, 0644);
499
500 /*
501  * Initialising and terminating the module.
502  */
503
504 static int __init init_nlm(void)
505 {
506 #ifdef CONFIG_SYSCTL
507         nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
508         return nlm_sysctl_table ? 0 : -ENOMEM;
509 #else
510         return 0;
511 #endif
512 }
513
514 static void __exit exit_nlm(void)
515 {
516         /* FIXME: delete all NLM clients */
517         nlm_shutdown_hosts();
518 #ifdef CONFIG_SYSCTL
519         unregister_sysctl_table(nlm_sysctl_table);
520 #endif
521 }
522
523 module_init(init_nlm);
524 module_exit(exit_nlm);
525
526 /*
527  * Define NLM program and procedures
528  */
529 static struct svc_version       nlmsvc_version1 = {
530                 .vs_vers        = 1,
531                 .vs_nproc       = 17,
532                 .vs_proc        = nlmsvc_procedures,
533                 .vs_xdrsize     = NLMSVC_XDRSIZE,
534 };
535 static struct svc_version       nlmsvc_version3 = {
536                 .vs_vers        = 3,
537                 .vs_nproc       = 24,
538                 .vs_proc        = nlmsvc_procedures,
539                 .vs_xdrsize     = NLMSVC_XDRSIZE,
540 };
541 #ifdef CONFIG_LOCKD_V4
542 static struct svc_version       nlmsvc_version4 = {
543                 .vs_vers        = 4,
544                 .vs_nproc       = 24,
545                 .vs_proc        = nlmsvc_procedures4,
546                 .vs_xdrsize     = NLMSVC_XDRSIZE,
547 };
548 #endif
549 static struct svc_version *     nlmsvc_version[] = {
550         [1] = &nlmsvc_version1,
551         [3] = &nlmsvc_version3,
552 #ifdef CONFIG_LOCKD_V4
553         [4] = &nlmsvc_version4,
554 #endif
555 };
556
557 static struct svc_stat          nlmsvc_stats;
558
559 #define NLM_NRVERS      ARRAY_SIZE(nlmsvc_version)
560 static struct svc_program       nlmsvc_program = {
561         .pg_prog                = NLM_PROGRAM,          /* program number */
562         .pg_nvers               = NLM_NRVERS,           /* number of entries in nlmsvc_version */
563         .pg_vers                = nlmsvc_version,       /* version table */
564         .pg_name                = "lockd",              /* service name */
565         .pg_class               = "nfsd",               /* share authentication with nfsd */
566         .pg_stats               = &nlmsvc_stats,        /* stats table */
567         .pg_authenticate = &lockd_authenticate  /* export authentication */
568 };