Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
svc.c
Go to the documentation of this file.
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 ([email protected])
11  *
12  * Copyright (C) 1995, 1996 Olaf Kirch <[email protected]>
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 #include "netns.h"
39 
40 #define NLMDBG_FACILITY NLMDBG_SVC
41 #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
42 #define ALLOWED_SIGS (sigmask(SIGKILL))
43 
44 static struct svc_program nlmsvc_program;
45 
47 EXPORT_SYMBOL_GPL(nlmsvc_ops);
48 
49 static DEFINE_MUTEX(nlmsvc_mutex);
50 static unsigned int nlmsvc_users;
51 static struct task_struct *nlmsvc_task;
52 static struct svc_rqst *nlmsvc_rqst;
53 unsigned long nlmsvc_timeout;
54 
56 
57 /*
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  */
61 static unsigned long nlm_grace_period;
62 static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO;
63 static int nlm_udpport, nlm_tcpport;
64 
65 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
66 static unsigned int nlm_max_connections = 1024;
67 
68 /*
69  * Constants needed for the sysctl interface.
70  */
71 static const unsigned long nlm_grace_period_min = 0;
72 static const unsigned long nlm_grace_period_max = 240;
73 static const unsigned long nlm_timeout_min = 3;
74 static const unsigned long nlm_timeout_max = 20;
75 static const int nlm_port_min = 0, nlm_port_max = 65535;
76 
77 #ifdef CONFIG_SYSCTL
78 static struct ctl_table_header * nlm_sysctl_table;
79 #endif
80 
81 static unsigned long get_lockd_grace_period(void)
82 {
83  /* Note: nlm_timeout should always be nonzero */
84  if (nlm_grace_period)
85  return roundup(nlm_grace_period, nlm_timeout) * HZ;
86  else
87  return nlm_timeout * 5 * HZ;
88 }
89 
90 static void grace_ender(struct work_struct *grace)
91 {
92  struct delayed_work *dwork = container_of(grace, struct delayed_work,
93  work);
94  struct lockd_net *ln = container_of(dwork, struct lockd_net,
96 
98 }
99 
100 static void set_grace_period(struct net *net)
101 {
102  unsigned long grace_period = get_lockd_grace_period();
103  struct lockd_net *ln = net_generic(net, lockd_net_id);
104 
105  locks_start_grace(net, &ln->lockd_manager);
107  schedule_delayed_work(&ln->grace_period_end, grace_period);
108 }
109 
110 static void restart_grace(void)
111 {
112  if (nlmsvc_ops) {
113  struct net *net = &init_net;
114  struct lockd_net *ln = net_generic(net, lockd_net_id);
115 
119  set_grace_period(net);
120  }
121 }
122 
123 /*
124  * This is the lockd kernel thread
125  */
126 static int
127 lockd(void *vrqstp)
128 {
129  int err = 0;
130  struct svc_rqst *rqstp = vrqstp;
131 
132  /* try_to_freeze() is called from svc_recv() */
133  set_freezable();
134 
135  /* Allow SIGKILL to tell lockd to drop all of its locks */
137 
138  dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
139 
140  if (!nlm_timeout)
141  nlm_timeout = LOCKD_DFLT_TIMEO;
142  nlmsvc_timeout = nlm_timeout * HZ;
143 
144  /*
145  * The main request loop. We don't terminate until the last
146  * NFS mount or NFS daemon has gone away.
147  */
148  while (!kthread_should_stop()) {
151 
152  /* update sv_maxconn if it has changed */
153  rqstp->rq_server->sv_maxconn = nlm_max_connections;
154 
155  if (signalled()) {
157  restart_grace();
158  continue;
159  }
160 
161  timeout = nlmsvc_retry_blocked();
162 
163  /*
164  * Find a socket with data available and call its
165  * recvfrom routine.
166  */
167  err = svc_recv(rqstp, timeout);
168  if (err == -EAGAIN || err == -EINTR)
169  continue;
170  dprintk("lockd: request from %s\n",
171  svc_print_addr(rqstp, buf, sizeof(buf)));
172 
173  svc_process(rqstp);
174  }
176  if (nlmsvc_ops)
179  return 0;
180 }
181 
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)
185 {
186  struct svc_xprt *xprt;
187 
188  xprt = svc_find_xprt(serv, name, net, family, 0);
189  if (xprt == NULL)
190  return svc_create_xprt(serv, name, net, family, port,
192  svc_xprt_put(xprt);
193  return 0;
194 }
195 
196 static int create_lockd_family(struct svc_serv *serv, struct net *net,
197  const int family)
198 {
199  int err;
200 
201  err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
202  if (err < 0)
203  return err;
204 
205  return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
206 }
207 
208 /*
209  * Ensure there are active UDP and TCP listeners for lockd.
210  *
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.
214  *
215  * Returns zero if all listeners are available; otherwise a
216  * negative errno value is returned.
217  */
218 static int make_socks(struct svc_serv *serv, struct net *net)
219 {
220  static int warned;
221  int err;
222 
223  err = create_lockd_family(serv, net, PF_INET);
224  if (err < 0)
225  goto out_err;
226 
227  err = create_lockd_family(serv, net, PF_INET6);
228  if (err < 0 && err != -EAFNOSUPPORT)
229  goto out_err;
230 
231  warned = 0;
232  return 0;
233 
234 out_err:
235  if (warned++ == 0)
237  "lockd_up: makesock failed, error=%d\n", err);
238  return err;
239 }
240 
241 static int lockd_up_net(struct svc_serv *serv, struct net *net)
242 {
243  struct lockd_net *ln = net_generic(net, lockd_net_id);
244  int error;
245 
246  if (ln->nlmsvc_users++)
247  return 0;
248 
249  error = svc_bind(serv, net);
250  if (error)
251  goto err_bind;
252 
253  error = make_socks(serv, net);
254  if (error < 0)
255  goto err_socks;
256  set_grace_period(net);
257  dprintk("lockd_up_net: per-net data created; net=%p\n", net);
258  return 0;
259 
260 err_socks:
261  svc_rpcb_cleanup(serv, net);
262 err_bind:
263  ln->nlmsvc_users--;
264  return error;
265 }
266 
267 static void lockd_down_net(struct svc_serv *serv, struct net *net)
268 {
269  struct lockd_net *ln = net_generic(net, lockd_net_id);
270 
271  if (ln->nlmsvc_users) {
272  if (--ln->nlmsvc_users == 0) {
276  svc_shutdown_net(serv, net);
277  dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net);
278  }
279  } else {
280  printk(KERN_ERR "lockd_down_net: no users! task=%p, net=%p\n",
281  nlmsvc_task, net);
282  BUG();
283  }
284 }
285 
286 static int lockd_start_svc(struct svc_serv *serv)
287 {
288  int error;
289 
290  if (nlmsvc_rqst)
291  return 0;
292 
293  /*
294  * Create the kernel thread and wait for it to start.
295  */
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",
301  error);
302  goto out_rqst;
303  }
304 
305  svc_sock_update_bufs(serv);
306  serv->sv_maxconn = nlm_max_connections;
307 
308  nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, 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);
313  goto out_task;
314  }
315  dprintk("lockd_up: service started\n");
316  return 0;
317 
318 out_task:
319  svc_exit_thread(nlmsvc_rqst);
320  nlmsvc_task = NULL;
321 out_rqst:
322  nlmsvc_rqst = NULL;
323  return error;
324 }
325 
326 static struct svc_serv *lockd_create_svc(void)
327 {
328  struct svc_serv *serv;
329 
330  /*
331  * Check whether we're already up and running.
332  */
333  if (nlmsvc_rqst) {
334  /*
335  * Note: increase service usage, because later in case of error
336  * svc_destroy() will be called.
337  */
338  svc_get(nlmsvc_rqst->rq_server);
339  return nlmsvc_rqst->rq_server;
340  }
341 
342  /*
343  * Sanity check: if there's no pid,
344  * we should be the first user ...
345  */
346  if (nlmsvc_users)
348  "lockd_up: no pid, %d users??\n", nlmsvc_users);
349 
350  serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, NULL);
351  if (!serv) {
352  printk(KERN_WARNING "lockd_up: create service failed\n");
353  return ERR_PTR(-ENOMEM);
354  }
355  dprintk("lockd_up: service created\n");
356  return serv;
357 }
358 
359 /*
360  * Bring up the lockd process if it's not already up.
361  */
362 int lockd_up(struct net *net)
363 {
364  struct svc_serv *serv;
365  int error;
366 
367  mutex_lock(&nlmsvc_mutex);
368 
369  serv = lockd_create_svc();
370  if (IS_ERR(serv)) {
371  error = PTR_ERR(serv);
372  goto err_create;
373  }
374 
375  error = lockd_up_net(serv, net);
376  if (error < 0)
377  goto err_net;
378 
379  error = lockd_start_svc(serv);
380  if (error < 0)
381  goto err_start;
382 
383  nlmsvc_users++;
384  /*
385  * Note: svc_serv structures have an initial use count of 1,
386  * so we exit through here on both success and failure.
387  */
388 err_net:
389  svc_destroy(serv);
390 err_create:
391  mutex_unlock(&nlmsvc_mutex);
392  return error;
393 
394 err_start:
395  lockd_down_net(serv, net);
396  goto err_net;
397 }
399 
400 /*
401  * Decrement the user count and bring down lockd if we're the last.
402  */
403 void
404 lockd_down(struct net *net)
405 {
406  mutex_lock(&nlmsvc_mutex);
407  lockd_down_net(nlmsvc_rqst->rq_server, net);
408  if (nlmsvc_users) {
409  if (--nlmsvc_users)
410  goto out;
411  } else {
412  printk(KERN_ERR "lockd_down: no users! task=%p\n",
413  nlmsvc_task);
414  BUG();
415  }
416 
417  if (!nlmsvc_task) {
418  printk(KERN_ERR "lockd_down: no lockd running.\n");
419  BUG();
420  }
421  kthread_stop(nlmsvc_task);
422  dprintk("lockd_down: service stopped\n");
423  svc_exit_thread(nlmsvc_rqst);
424  dprintk("lockd_down: service destroyed\n");
425  nlmsvc_task = NULL;
426  nlmsvc_rqst = NULL;
427 out:
428  mutex_unlock(&nlmsvc_mutex);
429 }
431 
432 #ifdef CONFIG_SYSCTL
433 
434 /*
435  * Sysctl parameters (same as module parameters, different interface).
436  */
437 
438 static ctl_table nlm_sysctls[] = {
439  {
440  .procname = "nlm_grace_period",
441  .data = &nlm_grace_period,
442  .maxlen = sizeof(unsigned long),
443  .mode = 0644,
445  .extra1 = (unsigned long *) &nlm_grace_period_min,
446  .extra2 = (unsigned long *) &nlm_grace_period_max,
447  },
448  {
449  .procname = "nlm_timeout",
450  .data = &nlm_timeout,
451  .maxlen = sizeof(unsigned long),
452  .mode = 0644,
454  .extra1 = (unsigned long *) &nlm_timeout_min,
455  .extra2 = (unsigned long *) &nlm_timeout_max,
456  },
457  {
458  .procname = "nlm_udpport",
459  .data = &nlm_udpport,
460  .maxlen = sizeof(int),
461  .mode = 0644,
463  .extra1 = (int *) &nlm_port_min,
464  .extra2 = (int *) &nlm_port_max,
465  },
466  {
467  .procname = "nlm_tcpport",
468  .data = &nlm_tcpport,
469  .maxlen = sizeof(int),
470  .mode = 0644,
472  .extra1 = (int *) &nlm_port_min,
473  .extra2 = (int *) &nlm_port_max,
474  },
475  {
476  .procname = "nsm_use_hostnames",
477  .data = &nsm_use_hostnames,
478  .maxlen = sizeof(int),
479  .mode = 0644,
481  },
482  {
483  .procname = "nsm_local_state",
484  .data = &nsm_local_state,
485  .maxlen = sizeof(int),
486  .mode = 0644,
488  },
489  { }
490 };
491 
492 static ctl_table nlm_sysctl_dir[] = {
493  {
494  .procname = "nfs",
495  .mode = 0555,
496  .child = nlm_sysctls,
497  },
498  { }
499 };
500 
501 static ctl_table nlm_sysctl_root[] = {
502  {
503  .procname = "fs",
504  .mode = 0555,
505  .child = nlm_sysctl_dir,
506  },
507  { }
508 };
509 
510 #endif /* CONFIG_SYSCTL */
511 
512 /*
513  * Module (and sysfs) parameters.
514  */
515 
516 #define param_set_min_max(name, type, which_strtol, min, max) \
517 static int param_set_##name(const char *val, struct kernel_param *kp) \
518 { \
519  char *endp; \
520  __typeof__(type) num = which_strtol(val, &endp, 0); \
521  if (endp == val || *endp || num < (min) || num > (max)) \
522  return -EINVAL; \
523  *((type *) kp->arg) = num; \
524  return 0; \
525 }
526 
527 static inline int is_callback(u32 proc)
528 {
529  return proc == NLMPROC_GRANTED
530  || proc == NLMPROC_GRANTED_MSG
531  || proc == NLMPROC_TEST_RES
532  || proc == NLMPROC_LOCK_RES
533  || proc == NLMPROC_CANCEL_RES
534  || proc == NLMPROC_UNLOCK_RES
535  || proc == NLMPROC_NSM_NOTIFY;
536 }
537 
538 
539 static int lockd_authenticate(struct svc_rqst *rqstp)
540 {
541  rqstp->rq_client = NULL;
542  switch (rqstp->rq_authop->flavour) {
543  case RPC_AUTH_NULL:
544  case RPC_AUTH_UNIX:
545  if (rqstp->rq_proc == 0)
546  return SVC_OK;
547  if (is_callback(rqstp->rq_proc)) {
548  /* Leave it to individual procedures to
549  * call nlmsvc_lookup_host(rqstp)
550  */
551  return SVC_OK;
552  }
553  return svc_set_client(rqstp);
554  }
555  return SVC_DENIED;
556 }
557 
558 
559 param_set_min_max(port, int, simple_strtol, 0, 65535)
560 param_set_min_max(grace_period, unsigned long, simple_strtoul,
561  nlm_grace_period_min, nlm_grace_period_max)
562 param_set_min_max(timeout, unsigned long, simple_strtoul,
563  nlm_timeout_min, nlm_timeout_max)
564 
565 MODULE_AUTHOR("Olaf Kirch <[email protected]>");
566 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
567 MODULE_LICENSE("GPL");
568 
569 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
570  &nlm_grace_period, 0644);
571 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
572  &nlm_timeout, 0644);
573 module_param_call(nlm_udpport, param_set_port, param_get_int,
574  &nlm_udpport, 0644);
575 module_param_call(nlm_tcpport, param_set_port, param_get_int,
576  &nlm_tcpport, 0644);
577 module_param(nsm_use_hostnames, bool, 0644);
578 module_param(nlm_max_connections, uint, 0644);
579 
580 static int lockd_init_net(struct net *net)
581 {
582  struct lockd_net *ln = net_generic(net, lockd_net_id);
583 
584  INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
585  INIT_LIST_HEAD(&ln->grace_list);
587  return 0;
588 }
589 
590 static void lockd_exit_net(struct net *net)
591 {
592 }
593 
594 static struct pernet_operations lockd_net_ops = {
595  .init = lockd_init_net,
596  .exit = lockd_exit_net,
597  .id = &lockd_net_id,
598  .size = sizeof(struct lockd_net),
599 };
600 
601 
602 /*
603  * Initialising and terminating the module.
604  */
605 
606 static int __init init_nlm(void)
607 {
608  int err;
609 
610 #ifdef CONFIG_SYSCTL
611  err = -ENOMEM;
612  nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
613  if (nlm_sysctl_table == NULL)
614  goto err_sysctl;
615 #endif
616  err = register_pernet_subsys(&lockd_net_ops);
617  if (err)
618  goto err_pernet;
619  return 0;
620 
621 err_pernet:
622 #ifdef CONFIG_SYSCTL
623  unregister_sysctl_table(nlm_sysctl_table);
624 #endif
625 err_sysctl:
626  return err;
627 }
628 
629 static void __exit exit_nlm(void)
630 {
631  /* FIXME: delete all NLM clients */
633  unregister_pernet_subsys(&lockd_net_ops);
634 #ifdef CONFIG_SYSCTL
635  unregister_sysctl_table(nlm_sysctl_table);
636 #endif
637 }
638 
639 module_init(init_nlm);
640 module_exit(exit_nlm);
641 
642 /*
643  * Define NLM program and procedures
644  */
645 static struct svc_version nlmsvc_version1 = {
646  .vs_vers = 1,
647  .vs_nproc = 17,
648  .vs_proc = nlmsvc_procedures,
649  .vs_xdrsize = NLMSVC_XDRSIZE,
650 };
651 static struct svc_version nlmsvc_version3 = {
652  .vs_vers = 3,
653  .vs_nproc = 24,
654  .vs_proc = nlmsvc_procedures,
655  .vs_xdrsize = NLMSVC_XDRSIZE,
656 };
657 #ifdef CONFIG_LOCKD_V4
658 static struct svc_version nlmsvc_version4 = {
659  .vs_vers = 4,
660  .vs_nproc = 24,
661  .vs_proc = nlmsvc_procedures4,
662  .vs_xdrsize = NLMSVC_XDRSIZE,
663 };
664 #endif
665 static struct svc_version * nlmsvc_version[] = {
666  [1] = &nlmsvc_version1,
667  [3] = &nlmsvc_version3,
668 #ifdef CONFIG_LOCKD_V4
669  [4] = &nlmsvc_version4,
670 #endif
671 };
672 
673 static struct svc_stat nlmsvc_stats;
674 
675 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
676 static struct svc_program nlmsvc_program = {
677  .pg_prog = NLM_PROGRAM, /* program number */
678  .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */
679  .pg_vers = nlmsvc_version, /* version table */
680  .pg_name = "lockd", /* service name */
681  .pg_class = "nfsd", /* share authentication with nfsd */
682  .pg_stats = &nlmsvc_stats, /* stats table */
683  .pg_authenticate = &lockd_authenticate /* export authentication */
684 };