1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * linux/fs/lockd/svc.c |
4 | * |
5 | * This is the central lockd service. |
6 | * |
7 | * FIXME: Separate the lockd NFS server functionality from the lockd NFS |
8 | * client functionality. Oh why didn't Sun create two separate |
9 | * services in the first place? |
10 | * |
11 | * Authors: Olaf Kirch (okir@monad.swb.de) |
12 | * |
13 | * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> |
14 | */ |
15 | |
16 | #include <linux/module.h> |
17 | #include <linux/init.h> |
18 | #include <linux/sysctl.h> |
19 | #include <linux/moduleparam.h> |
20 | |
21 | #include <linux/sched/signal.h> |
22 | #include <linux/errno.h> |
23 | #include <linux/in.h> |
24 | #include <linux/uio.h> |
25 | #include <linux/smp.h> |
26 | #include <linux/mutex.h> |
27 | #include <linux/freezer.h> |
28 | #include <linux/inetdevice.h> |
29 | |
30 | #include <linux/sunrpc/types.h> |
31 | #include <linux/sunrpc/stats.h> |
32 | #include <linux/sunrpc/clnt.h> |
33 | #include <linux/sunrpc/svc.h> |
34 | #include <linux/sunrpc/svcsock.h> |
35 | #include <linux/sunrpc/svc_xprt.h> |
36 | #include <net/ip.h> |
37 | #include <net/addrconf.h> |
38 | #include <net/ipv6.h> |
39 | #include <linux/lockd/lockd.h> |
40 | #include <linux/nfs.h> |
41 | |
42 | #include "netns.h" |
43 | #include "procfs.h" |
44 | |
45 | #define NLMDBG_FACILITY NLMDBG_SVC |
46 | #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE) |
47 | |
48 | static struct svc_program nlmsvc_program; |
49 | |
50 | const struct nlmsvc_binding *nlmsvc_ops; |
51 | EXPORT_SYMBOL_GPL(nlmsvc_ops); |
52 | |
53 | static DEFINE_MUTEX(nlmsvc_mutex); |
54 | static unsigned int nlmsvc_users; |
55 | static struct svc_serv *nlmsvc_serv; |
56 | unsigned long nlmsvc_timeout; |
57 | |
58 | static void nlmsvc_request_retry(struct timer_list *tl) |
59 | { |
60 | svc_wake_up(nlmsvc_serv); |
61 | } |
62 | DEFINE_TIMER(nlmsvc_retry, nlmsvc_request_retry); |
63 | |
64 | unsigned int lockd_net_id; |
65 | |
66 | /* |
67 | * These can be set at insmod time (useful for NFS as root filesystem), |
68 | * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003 |
69 | */ |
70 | static unsigned long nlm_grace_period; |
71 | static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO; |
72 | static int nlm_udpport, nlm_tcpport; |
73 | |
74 | /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */ |
75 | static unsigned int nlm_max_connections = 1024; |
76 | |
77 | /* |
78 | * Constants needed for the sysctl interface. |
79 | */ |
80 | static const unsigned long nlm_grace_period_min = 0; |
81 | static const unsigned long nlm_grace_period_max = 240; |
82 | static const unsigned long nlm_timeout_min = 3; |
83 | static const unsigned long nlm_timeout_max = 20; |
84 | |
85 | #ifdef CONFIG_SYSCTL |
86 | static const int nlm_port_min = 0, nlm_port_max = 65535; |
87 | static struct ctl_table_header * nlm_sysctl_table; |
88 | #endif |
89 | |
90 | static unsigned long get_lockd_grace_period(void) |
91 | { |
92 | /* Note: nlm_timeout should always be nonzero */ |
93 | if (nlm_grace_period) |
94 | return roundup(nlm_grace_period, nlm_timeout) * HZ; |
95 | else |
96 | return nlm_timeout * 5 * HZ; |
97 | } |
98 | |
99 | static void grace_ender(struct work_struct *grace) |
100 | { |
101 | struct delayed_work *dwork = to_delayed_work(work: grace); |
102 | struct lockd_net *ln = container_of(dwork, struct lockd_net, |
103 | grace_period_end); |
104 | |
105 | locks_end_grace(&ln->lockd_manager); |
106 | } |
107 | |
108 | static void set_grace_period(struct net *net) |
109 | { |
110 | unsigned long grace_period = get_lockd_grace_period(); |
111 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
112 | |
113 | locks_start_grace(net, &ln->lockd_manager); |
114 | cancel_delayed_work_sync(dwork: &ln->grace_period_end); |
115 | schedule_delayed_work(dwork: &ln->grace_period_end, delay: grace_period); |
116 | } |
117 | |
118 | /* |
119 | * This is the lockd kernel thread |
120 | */ |
121 | static int |
122 | lockd(void *vrqstp) |
123 | { |
124 | struct svc_rqst *rqstp = vrqstp; |
125 | struct net *net = &init_net; |
126 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
127 | |
128 | /* try_to_freeze() is called from svc_recv() */ |
129 | set_freezable(); |
130 | |
131 | dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n" ); |
132 | |
133 | /* |
134 | * The main request loop. We don't terminate until the last |
135 | * NFS mount or NFS daemon has gone away. |
136 | */ |
137 | while (!svc_thread_should_stop(rqstp)) { |
138 | /* update sv_maxconn if it has changed */ |
139 | rqstp->rq_server->sv_maxconn = nlm_max_connections; |
140 | |
141 | nlmsvc_retry_blocked(rqstp); |
142 | svc_recv(rqstp); |
143 | } |
144 | if (nlmsvc_ops) |
145 | nlmsvc_invalidate_all(); |
146 | nlm_shutdown_hosts(); |
147 | cancel_delayed_work_sync(dwork: &ln->grace_period_end); |
148 | locks_end_grace(&ln->lockd_manager); |
149 | |
150 | dprintk("lockd_down: service stopped\n" ); |
151 | |
152 | svc_exit_thread(rqstp); |
153 | return 0; |
154 | } |
155 | |
156 | static int create_lockd_listener(struct svc_serv *serv, const char *name, |
157 | struct net *net, const int family, |
158 | const unsigned short port, |
159 | const struct cred *cred) |
160 | { |
161 | struct svc_xprt *xprt; |
162 | |
163 | xprt = svc_find_xprt(serv, xcl_name: name, net, af: family, port: 0); |
164 | if (xprt == NULL) |
165 | return svc_xprt_create(serv, xprt_name: name, net, family, port, |
166 | SVC_SOCK_DEFAULTS, cred); |
167 | svc_xprt_put(xprt); |
168 | return 0; |
169 | } |
170 | |
171 | static int create_lockd_family(struct svc_serv *serv, struct net *net, |
172 | const int family, const struct cred *cred) |
173 | { |
174 | int err; |
175 | |
176 | err = create_lockd_listener(serv, name: "udp" , net, family, port: nlm_udpport, |
177 | cred); |
178 | if (err < 0) |
179 | return err; |
180 | |
181 | return create_lockd_listener(serv, name: "tcp" , net, family, port: nlm_tcpport, |
182 | cred); |
183 | } |
184 | |
185 | /* |
186 | * Ensure there are active UDP and TCP listeners for lockd. |
187 | * |
188 | * Even if we have only TCP NFS mounts and/or TCP NFSDs, some |
189 | * local services (such as rpc.statd) still require UDP, and |
190 | * some NFS servers do not yet support NLM over TCP. |
191 | * |
192 | * Returns zero if all listeners are available; otherwise a |
193 | * negative errno value is returned. |
194 | */ |
195 | static int make_socks(struct svc_serv *serv, struct net *net, |
196 | const struct cred *cred) |
197 | { |
198 | static int warned; |
199 | int err; |
200 | |
201 | err = create_lockd_family(serv, net, PF_INET, cred); |
202 | if (err < 0) |
203 | goto out_err; |
204 | |
205 | err = create_lockd_family(serv, net, PF_INET6, cred); |
206 | if (err < 0 && err != -EAFNOSUPPORT) |
207 | goto out_err; |
208 | |
209 | warned = 0; |
210 | return 0; |
211 | |
212 | out_err: |
213 | if (warned++ == 0) |
214 | printk(KERN_WARNING |
215 | "lockd_up: makesock failed, error=%d\n" , err); |
216 | svc_xprt_destroy_all(serv, net); |
217 | svc_rpcb_cleanup(serv, net); |
218 | return err; |
219 | } |
220 | |
221 | static int lockd_up_net(struct svc_serv *serv, struct net *net, |
222 | const struct cred *cred) |
223 | { |
224 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
225 | int error; |
226 | |
227 | if (ln->nlmsvc_users++) |
228 | return 0; |
229 | |
230 | error = svc_bind(serv, net); |
231 | if (error) |
232 | goto err_bind; |
233 | |
234 | error = make_socks(serv, net, cred); |
235 | if (error < 0) |
236 | goto err_bind; |
237 | set_grace_period(net); |
238 | dprintk("%s: per-net data created; net=%x\n" , __func__, net->ns.inum); |
239 | return 0; |
240 | |
241 | err_bind: |
242 | ln->nlmsvc_users--; |
243 | return error; |
244 | } |
245 | |
246 | static void lockd_down_net(struct svc_serv *serv, struct net *net) |
247 | { |
248 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
249 | |
250 | if (ln->nlmsvc_users) { |
251 | if (--ln->nlmsvc_users == 0) { |
252 | nlm_shutdown_hosts_net(net); |
253 | cancel_delayed_work_sync(dwork: &ln->grace_period_end); |
254 | locks_end_grace(&ln->lockd_manager); |
255 | svc_xprt_destroy_all(serv, net); |
256 | svc_rpcb_cleanup(serv, net); |
257 | } |
258 | } else { |
259 | pr_err("%s: no users! net=%x\n" , |
260 | __func__, net->ns.inum); |
261 | BUG(); |
262 | } |
263 | } |
264 | |
265 | static int lockd_inetaddr_event(struct notifier_block *this, |
266 | unsigned long event, void *ptr) |
267 | { |
268 | struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; |
269 | struct sockaddr_in sin; |
270 | |
271 | if (event != NETDEV_DOWN) |
272 | goto out; |
273 | |
274 | if (nlmsvc_serv) { |
275 | dprintk("lockd_inetaddr_event: removed %pI4\n" , |
276 | &ifa->ifa_local); |
277 | sin.sin_family = AF_INET; |
278 | sin.sin_addr.s_addr = ifa->ifa_local; |
279 | svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin); |
280 | } |
281 | |
282 | out: |
283 | return NOTIFY_DONE; |
284 | } |
285 | |
286 | static struct notifier_block lockd_inetaddr_notifier = { |
287 | .notifier_call = lockd_inetaddr_event, |
288 | }; |
289 | |
290 | #if IS_ENABLED(CONFIG_IPV6) |
291 | static int lockd_inet6addr_event(struct notifier_block *this, |
292 | unsigned long event, void *ptr) |
293 | { |
294 | struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; |
295 | struct sockaddr_in6 sin6; |
296 | |
297 | if (event != NETDEV_DOWN) |
298 | goto out; |
299 | |
300 | if (nlmsvc_serv) { |
301 | dprintk("lockd_inet6addr_event: removed %pI6\n" , &ifa->addr); |
302 | sin6.sin6_family = AF_INET6; |
303 | sin6.sin6_addr = ifa->addr; |
304 | if (ipv6_addr_type(addr: &sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL) |
305 | sin6.sin6_scope_id = ifa->idev->dev->ifindex; |
306 | svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6); |
307 | } |
308 | |
309 | out: |
310 | return NOTIFY_DONE; |
311 | } |
312 | |
313 | static struct notifier_block lockd_inet6addr_notifier = { |
314 | .notifier_call = lockd_inet6addr_event, |
315 | }; |
316 | #endif |
317 | |
318 | static int lockd_get(void) |
319 | { |
320 | struct svc_serv *serv; |
321 | int error; |
322 | |
323 | if (nlmsvc_serv) { |
324 | nlmsvc_users++; |
325 | return 0; |
326 | } |
327 | |
328 | /* |
329 | * Sanity check: if there's no pid, |
330 | * we should be the first user ... |
331 | */ |
332 | if (nlmsvc_users) |
333 | printk(KERN_WARNING |
334 | "lockd_up: no pid, %d users??\n" , nlmsvc_users); |
335 | |
336 | if (!nlm_timeout) |
337 | nlm_timeout = LOCKD_DFLT_TIMEO; |
338 | nlmsvc_timeout = nlm_timeout * HZ; |
339 | |
340 | serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, threadfn: lockd); |
341 | if (!serv) { |
342 | printk(KERN_WARNING "lockd_up: create service failed\n" ); |
343 | return -ENOMEM; |
344 | } |
345 | |
346 | serv->sv_maxconn = nlm_max_connections; |
347 | error = svc_set_num_threads(serv, NULL, 1); |
348 | /* The thread now holds the only reference */ |
349 | svc_put(serv); |
350 | if (error < 0) |
351 | return error; |
352 | |
353 | nlmsvc_serv = serv; |
354 | register_inetaddr_notifier(nb: &lockd_inetaddr_notifier); |
355 | #if IS_ENABLED(CONFIG_IPV6) |
356 | register_inet6addr_notifier(nb: &lockd_inet6addr_notifier); |
357 | #endif |
358 | dprintk("lockd_up: service created\n" ); |
359 | nlmsvc_users++; |
360 | return 0; |
361 | } |
362 | |
363 | static void lockd_put(void) |
364 | { |
365 | if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n" )) |
366 | return; |
367 | if (--nlmsvc_users) |
368 | return; |
369 | |
370 | unregister_inetaddr_notifier(nb: &lockd_inetaddr_notifier); |
371 | #if IS_ENABLED(CONFIG_IPV6) |
372 | unregister_inet6addr_notifier(nb: &lockd_inet6addr_notifier); |
373 | #endif |
374 | |
375 | svc_get(serv: nlmsvc_serv); |
376 | svc_set_num_threads(nlmsvc_serv, NULL, 0); |
377 | svc_put(serv: nlmsvc_serv); |
378 | timer_delete_sync(timer: &nlmsvc_retry); |
379 | nlmsvc_serv = NULL; |
380 | dprintk("lockd_down: service destroyed\n" ); |
381 | } |
382 | |
383 | /* |
384 | * Bring up the lockd process if it's not already up. |
385 | */ |
386 | int lockd_up(struct net *net, const struct cred *cred) |
387 | { |
388 | int error; |
389 | |
390 | mutex_lock(&nlmsvc_mutex); |
391 | |
392 | error = lockd_get(); |
393 | if (error) |
394 | goto err; |
395 | |
396 | error = lockd_up_net(serv: nlmsvc_serv, net, cred); |
397 | if (error < 0) { |
398 | lockd_put(); |
399 | goto err; |
400 | } |
401 | |
402 | err: |
403 | mutex_unlock(lock: &nlmsvc_mutex); |
404 | return error; |
405 | } |
406 | EXPORT_SYMBOL_GPL(lockd_up); |
407 | |
408 | /* |
409 | * Decrement the user count and bring down lockd if we're the last. |
410 | */ |
411 | void |
412 | lockd_down(struct net *net) |
413 | { |
414 | mutex_lock(&nlmsvc_mutex); |
415 | lockd_down_net(serv: nlmsvc_serv, net); |
416 | lockd_put(); |
417 | mutex_unlock(lock: &nlmsvc_mutex); |
418 | } |
419 | EXPORT_SYMBOL_GPL(lockd_down); |
420 | |
421 | #ifdef CONFIG_SYSCTL |
422 | |
423 | /* |
424 | * Sysctl parameters (same as module parameters, different interface). |
425 | */ |
426 | |
427 | static struct ctl_table nlm_sysctls[] = { |
428 | { |
429 | .procname = "nlm_grace_period" , |
430 | .data = &nlm_grace_period, |
431 | .maxlen = sizeof(unsigned long), |
432 | .mode = 0644, |
433 | .proc_handler = proc_doulongvec_minmax, |
434 | .extra1 = (unsigned long *) &nlm_grace_period_min, |
435 | .extra2 = (unsigned long *) &nlm_grace_period_max, |
436 | }, |
437 | { |
438 | .procname = "nlm_timeout" , |
439 | .data = &nlm_timeout, |
440 | .maxlen = sizeof(unsigned long), |
441 | .mode = 0644, |
442 | .proc_handler = proc_doulongvec_minmax, |
443 | .extra1 = (unsigned long *) &nlm_timeout_min, |
444 | .extra2 = (unsigned long *) &nlm_timeout_max, |
445 | }, |
446 | { |
447 | .procname = "nlm_udpport" , |
448 | .data = &nlm_udpport, |
449 | .maxlen = sizeof(int), |
450 | .mode = 0644, |
451 | .proc_handler = proc_dointvec_minmax, |
452 | .extra1 = (int *) &nlm_port_min, |
453 | .extra2 = (int *) &nlm_port_max, |
454 | }, |
455 | { |
456 | .procname = "nlm_tcpport" , |
457 | .data = &nlm_tcpport, |
458 | .maxlen = sizeof(int), |
459 | .mode = 0644, |
460 | .proc_handler = proc_dointvec_minmax, |
461 | .extra1 = (int *) &nlm_port_min, |
462 | .extra2 = (int *) &nlm_port_max, |
463 | }, |
464 | { |
465 | .procname = "nsm_use_hostnames" , |
466 | .data = &nsm_use_hostnames, |
467 | .maxlen = sizeof(bool), |
468 | .mode = 0644, |
469 | .proc_handler = proc_dobool, |
470 | }, |
471 | { |
472 | .procname = "nsm_local_state" , |
473 | .data = &nsm_local_state, |
474 | .maxlen = sizeof(int), |
475 | .mode = 0644, |
476 | .proc_handler = proc_dointvec, |
477 | }, |
478 | { } |
479 | }; |
480 | |
481 | #endif /* CONFIG_SYSCTL */ |
482 | |
483 | /* |
484 | * Module (and sysfs) parameters. |
485 | */ |
486 | |
487 | #define param_set_min_max(name, type, which_strtol, min, max) \ |
488 | static int param_set_##name(const char *val, const struct kernel_param *kp) \ |
489 | { \ |
490 | char *endp; \ |
491 | __typeof__(type) num = which_strtol(val, &endp, 0); \ |
492 | if (endp == val || *endp || num < (min) || num > (max)) \ |
493 | return -EINVAL; \ |
494 | *((type *) kp->arg) = num; \ |
495 | return 0; \ |
496 | } |
497 | |
498 | static inline int is_callback(u32 proc) |
499 | { |
500 | return proc == NLMPROC_GRANTED |
501 | || proc == NLMPROC_GRANTED_MSG |
502 | || proc == NLMPROC_TEST_RES |
503 | || proc == NLMPROC_LOCK_RES |
504 | || proc == NLMPROC_CANCEL_RES |
505 | || proc == NLMPROC_UNLOCK_RES |
506 | || proc == NLMPROC_NSM_NOTIFY; |
507 | } |
508 | |
509 | |
510 | static enum svc_auth_status lockd_authenticate(struct svc_rqst *rqstp) |
511 | { |
512 | rqstp->rq_client = NULL; |
513 | switch (rqstp->rq_authop->flavour) { |
514 | case RPC_AUTH_NULL: |
515 | case RPC_AUTH_UNIX: |
516 | rqstp->rq_auth_stat = rpc_auth_ok; |
517 | if (rqstp->rq_proc == 0) |
518 | return SVC_OK; |
519 | if (is_callback(proc: rqstp->rq_proc)) { |
520 | /* Leave it to individual procedures to |
521 | * call nlmsvc_lookup_host(rqstp) |
522 | */ |
523 | return SVC_OK; |
524 | } |
525 | return svc_set_client(rqstp); |
526 | } |
527 | rqstp->rq_auth_stat = rpc_autherr_badcred; |
528 | return SVC_DENIED; |
529 | } |
530 | |
531 | |
532 | param_set_min_max(port, int, simple_strtol, 0, 65535) |
533 | param_set_min_max(grace_period, unsigned long, simple_strtoul, |
534 | nlm_grace_period_min, nlm_grace_period_max) |
535 | param_set_min_max(timeout, unsigned long, simple_strtoul, |
536 | nlm_timeout_min, nlm_timeout_max) |
537 | |
538 | MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>" ); |
539 | MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION "." ); |
540 | MODULE_LICENSE("GPL" ); |
541 | |
542 | module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong, |
543 | &nlm_grace_period, 0644); |
544 | module_param_call(nlm_timeout, param_set_timeout, param_get_ulong, |
545 | &nlm_timeout, 0644); |
546 | module_param_call(nlm_udpport, param_set_port, param_get_int, |
547 | &nlm_udpport, 0644); |
548 | module_param_call(nlm_tcpport, param_set_port, param_get_int, |
549 | &nlm_tcpport, 0644); |
550 | module_param(nsm_use_hostnames, bool, 0644); |
551 | module_param(nlm_max_connections, uint, 0644); |
552 | |
553 | static int lockd_init_net(struct net *net) |
554 | { |
555 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
556 | |
557 | INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender); |
558 | INIT_LIST_HEAD(list: &ln->lockd_manager.list); |
559 | ln->lockd_manager.block_opens = false; |
560 | INIT_LIST_HEAD(list: &ln->nsm_handles); |
561 | return 0; |
562 | } |
563 | |
564 | static void lockd_exit_net(struct net *net) |
565 | { |
566 | struct lockd_net *ln = net_generic(net, id: lockd_net_id); |
567 | |
568 | WARN_ONCE(!list_empty(&ln->lockd_manager.list), |
569 | "net %x %s: lockd_manager.list is not empty\n" , |
570 | net->ns.inum, __func__); |
571 | WARN_ONCE(!list_empty(&ln->nsm_handles), |
572 | "net %x %s: nsm_handles list is not empty\n" , |
573 | net->ns.inum, __func__); |
574 | WARN_ONCE(delayed_work_pending(&ln->grace_period_end), |
575 | "net %x %s: grace_period_end was not cancelled\n" , |
576 | net->ns.inum, __func__); |
577 | } |
578 | |
579 | static struct pernet_operations lockd_net_ops = { |
580 | .init = lockd_init_net, |
581 | .exit = lockd_exit_net, |
582 | .id = &lockd_net_id, |
583 | .size = sizeof(struct lockd_net), |
584 | }; |
585 | |
586 | |
587 | /* |
588 | * Initialising and terminating the module. |
589 | */ |
590 | |
591 | static int __init init_nlm(void) |
592 | { |
593 | int err; |
594 | |
595 | #ifdef CONFIG_SYSCTL |
596 | err = -ENOMEM; |
597 | nlm_sysctl_table = register_sysctl("fs/nfs" , nlm_sysctls); |
598 | if (nlm_sysctl_table == NULL) |
599 | goto err_sysctl; |
600 | #endif |
601 | err = register_pernet_subsys(&lockd_net_ops); |
602 | if (err) |
603 | goto err_pernet; |
604 | |
605 | err = lockd_create_procfs(); |
606 | if (err) |
607 | goto err_procfs; |
608 | |
609 | return 0; |
610 | |
611 | err_procfs: |
612 | unregister_pernet_subsys(&lockd_net_ops); |
613 | err_pernet: |
614 | #ifdef CONFIG_SYSCTL |
615 | unregister_sysctl_table(table: nlm_sysctl_table); |
616 | err_sysctl: |
617 | #endif |
618 | return err; |
619 | } |
620 | |
621 | static void __exit exit_nlm(void) |
622 | { |
623 | /* FIXME: delete all NLM clients */ |
624 | nlm_shutdown_hosts(); |
625 | lockd_remove_procfs(); |
626 | unregister_pernet_subsys(&lockd_net_ops); |
627 | #ifdef CONFIG_SYSCTL |
628 | unregister_sysctl_table(table: nlm_sysctl_table); |
629 | #endif |
630 | } |
631 | |
632 | module_init(init_nlm); |
633 | module_exit(exit_nlm); |
634 | |
635 | /** |
636 | * nlmsvc_dispatch - Process an NLM Request |
637 | * @rqstp: incoming request |
638 | * |
639 | * Return values: |
640 | * %0: Processing complete; do not send a Reply |
641 | * %1: Processing complete; send Reply in rqstp->rq_res |
642 | */ |
643 | static int nlmsvc_dispatch(struct svc_rqst *rqstp) |
644 | { |
645 | const struct svc_procedure *procp = rqstp->rq_procinfo; |
646 | __be32 *statp = rqstp->rq_accept_statp; |
647 | |
648 | if (!procp->pc_decode(rqstp, &rqstp->rq_arg_stream)) |
649 | goto out_decode_err; |
650 | |
651 | *statp = procp->pc_func(rqstp); |
652 | if (*statp == rpc_drop_reply) |
653 | return 0; |
654 | if (*statp != rpc_success) |
655 | return 1; |
656 | |
657 | if (!procp->pc_encode(rqstp, &rqstp->rq_res_stream)) |
658 | goto out_encode_err; |
659 | |
660 | return 1; |
661 | |
662 | out_decode_err: |
663 | *statp = rpc_garbage_args; |
664 | return 1; |
665 | |
666 | out_encode_err: |
667 | *statp = rpc_system_err; |
668 | return 1; |
669 | } |
670 | |
671 | /* |
672 | * Define NLM program and procedures |
673 | */ |
674 | static DEFINE_PER_CPU_ALIGNED(unsigned long, nlmsvc_version1_count[17]); |
675 | static const struct svc_version nlmsvc_version1 = { |
676 | .vs_vers = 1, |
677 | .vs_nproc = 17, |
678 | .vs_proc = nlmsvc_procedures, |
679 | .vs_count = nlmsvc_version1_count, |
680 | .vs_dispatch = nlmsvc_dispatch, |
681 | .vs_xdrsize = NLMSVC_XDRSIZE, |
682 | }; |
683 | |
684 | static DEFINE_PER_CPU_ALIGNED(unsigned long, |
685 | nlmsvc_version3_count[ARRAY_SIZE(nlmsvc_procedures)]); |
686 | static const struct svc_version nlmsvc_version3 = { |
687 | .vs_vers = 3, |
688 | .vs_nproc = ARRAY_SIZE(nlmsvc_procedures), |
689 | .vs_proc = nlmsvc_procedures, |
690 | .vs_count = nlmsvc_version3_count, |
691 | .vs_dispatch = nlmsvc_dispatch, |
692 | .vs_xdrsize = NLMSVC_XDRSIZE, |
693 | }; |
694 | |
695 | #ifdef CONFIG_LOCKD_V4 |
696 | static DEFINE_PER_CPU_ALIGNED(unsigned long, |
697 | nlmsvc_version4_count[ARRAY_SIZE(nlmsvc_procedures4)]); |
698 | static const struct svc_version nlmsvc_version4 = { |
699 | .vs_vers = 4, |
700 | .vs_nproc = ARRAY_SIZE(nlmsvc_procedures4), |
701 | .vs_proc = nlmsvc_procedures4, |
702 | .vs_count = nlmsvc_version4_count, |
703 | .vs_dispatch = nlmsvc_dispatch, |
704 | .vs_xdrsize = NLMSVC_XDRSIZE, |
705 | }; |
706 | #endif |
707 | |
708 | static const struct svc_version *nlmsvc_version[] = { |
709 | [1] = &nlmsvc_version1, |
710 | [3] = &nlmsvc_version3, |
711 | #ifdef CONFIG_LOCKD_V4 |
712 | [4] = &nlmsvc_version4, |
713 | #endif |
714 | }; |
715 | |
716 | static struct svc_stat nlmsvc_stats; |
717 | |
718 | #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version) |
719 | static struct svc_program nlmsvc_program = { |
720 | .pg_prog = NLM_PROGRAM, /* program number */ |
721 | .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */ |
722 | .pg_vers = nlmsvc_version, /* version table */ |
723 | .pg_name = "lockd" , /* service name */ |
724 | .pg_class = "nfsd" , /* share authentication with nfsd */ |
725 | .pg_stats = &nlmsvc_stats, /* stats table */ |
726 | .pg_authenticate = &lockd_authenticate, /* export authentication */ |
727 | .pg_init_request = svc_generic_init_request, |
728 | .pg_rpcbind_set = svc_generic_rpcbind_set, |
729 | }; |
730 | |