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/signal.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 #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 #define ALLOWED_SIGS (sigmask(SIGKILL)) 48 49 static struct svc_program nlmsvc_program; 50 51 const struct nlmsvc_binding *nlmsvc_ops; 52 EXPORT_SYMBOL_GPL(nlmsvc_ops); 53 54 static DEFINE_MUTEX(nlmsvc_mutex); 55 static unsigned int nlmsvc_users; 56 static struct task_struct *nlmsvc_task; 57 static struct svc_rqst *nlmsvc_rqst; 58 unsigned long nlmsvc_timeout; 59 60 static atomic_t nlm_ntf_refcnt = ATOMIC_INIT(0); 61 static DECLARE_WAIT_QUEUE_HEAD(nlm_ntf_wq); 62 63 unsigned int lockd_net_id; 64 65 /* 66 * These can be set at insmod time (useful for NFS as root filesystem), 67 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003 68 */ 69 static unsigned long nlm_grace_period; 70 static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO; 71 static int nlm_udpport, nlm_tcpport; 72 73 /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */ 74 static unsigned int nlm_max_connections = 1024; 75 76 /* 77 * Constants needed for the sysctl interface. 78 */ 79 static const unsigned long nlm_grace_period_min = 0; 80 static const unsigned long nlm_grace_period_max = 240; 81 static const unsigned long nlm_timeout_min = 3; 82 static const unsigned long nlm_timeout_max = 20; 83 static const int nlm_port_min = 0, nlm_port_max = 65535; 84 85 #ifdef CONFIG_SYSCTL 86 static struct ctl_table_header * nlm_sysctl_table; 87 #endif 88 89 static unsigned long get_lockd_grace_period(void) 90 { 91 /* Note: nlm_timeout should always be nonzero */ 92 if (nlm_grace_period) 93 return roundup(nlm_grace_period, nlm_timeout) * HZ; 94 else 95 return nlm_timeout * 5 * HZ; 96 } 97 98 static void grace_ender(struct work_struct *grace) 99 { 100 struct delayed_work *dwork = to_delayed_work(grace); 101 struct lockd_net *ln = container_of(dwork, struct lockd_net, 102 grace_period_end); 103 104 locks_end_grace(&ln->lockd_manager); 105 } 106 107 static void set_grace_period(struct net *net) 108 { 109 unsigned long grace_period = get_lockd_grace_period(); 110 struct lockd_net *ln = net_generic(net, lockd_net_id); 111 112 locks_start_grace(net, &ln->lockd_manager); 113 cancel_delayed_work_sync(&ln->grace_period_end); 114 schedule_delayed_work(&ln->grace_period_end, grace_period); 115 } 116 117 static void restart_grace(void) 118 { 119 if (nlmsvc_ops) { 120 struct net *net = &init_net; 121 struct lockd_net *ln = net_generic(net, lockd_net_id); 122 123 cancel_delayed_work_sync(&ln->grace_period_end); 124 locks_end_grace(&ln->lockd_manager); 125 nlmsvc_invalidate_all(); 126 set_grace_period(net); 127 } 128 } 129 130 /* 131 * This is the lockd kernel thread 132 */ 133 static int 134 lockd(void *vrqstp) 135 { 136 int err = 0; 137 struct svc_rqst *rqstp = vrqstp; 138 struct net *net = &init_net; 139 struct lockd_net *ln = net_generic(net, lockd_net_id); 140 141 /* try_to_freeze() is called from svc_recv() */ 142 set_freezable(); 143 144 /* Allow SIGKILL to tell lockd to drop all of its locks */ 145 allow_signal(SIGKILL); 146 147 dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n"); 148 149 /* 150 * The main request loop. We don't terminate until the last 151 * NFS mount or NFS daemon has gone away. 152 */ 153 while (!kthread_should_stop()) { 154 long timeout = MAX_SCHEDULE_TIMEOUT; 155 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]); 156 157 /* update sv_maxconn if it has changed */ 158 rqstp->rq_server->sv_maxconn = nlm_max_connections; 159 160 if (signalled()) { 161 flush_signals(current); 162 restart_grace(); 163 continue; 164 } 165 166 timeout = nlmsvc_retry_blocked(); 167 168 /* 169 * Find a socket with data available and call its 170 * recvfrom routine. 171 */ 172 err = svc_recv(rqstp, timeout); 173 if (err == -EAGAIN || err == -EINTR) 174 continue; 175 dprintk("lockd: request from %s\n", 176 svc_print_addr(rqstp, buf, sizeof(buf))); 177 178 svc_process(rqstp); 179 } 180 flush_signals(current); 181 if (nlmsvc_ops) 182 nlmsvc_invalidate_all(); 183 nlm_shutdown_hosts(); 184 cancel_delayed_work_sync(&ln->grace_period_end); 185 locks_end_grace(&ln->lockd_manager); 186 return 0; 187 } 188 189 static int create_lockd_listener(struct svc_serv *serv, const char *name, 190 struct net *net, const int family, 191 const unsigned short port, 192 const struct cred *cred) 193 { 194 struct svc_xprt *xprt; 195 196 xprt = svc_find_xprt(serv, name, net, family, 0); 197 if (xprt == NULL) 198 return svc_create_xprt(serv, name, net, family, port, 199 SVC_SOCK_DEFAULTS, cred); 200 svc_xprt_put(xprt); 201 return 0; 202 } 203 204 static int create_lockd_family(struct svc_serv *serv, struct net *net, 205 const int family, const struct cred *cred) 206 { 207 int err; 208 209 err = create_lockd_listener(serv, "udp", net, family, nlm_udpport, 210 cred); 211 if (err < 0) 212 return err; 213 214 return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport, 215 cred); 216 } 217 218 /* 219 * Ensure there are active UDP and TCP listeners for lockd. 220 * 221 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some 222 * local services (such as rpc.statd) still require UDP, and 223 * some NFS servers do not yet support NLM over TCP. 224 * 225 * Returns zero if all listeners are available; otherwise a 226 * negative errno value is returned. 227 */ 228 static int make_socks(struct svc_serv *serv, struct net *net, 229 const struct cred *cred) 230 { 231 static int warned; 232 int err; 233 234 err = create_lockd_family(serv, net, PF_INET, cred); 235 if (err < 0) 236 goto out_err; 237 238 err = create_lockd_family(serv, net, PF_INET6, cred); 239 if (err < 0 && err != -EAFNOSUPPORT) 240 goto out_err; 241 242 warned = 0; 243 return 0; 244 245 out_err: 246 if (warned++ == 0) 247 printk(KERN_WARNING 248 "lockd_up: makesock failed, error=%d\n", err); 249 svc_shutdown_net(serv, net); 250 return err; 251 } 252 253 static int lockd_up_net(struct svc_serv *serv, struct net *net, 254 const struct cred *cred) 255 { 256 struct lockd_net *ln = net_generic(net, lockd_net_id); 257 int error; 258 259 if (ln->nlmsvc_users++) 260 return 0; 261 262 error = svc_bind(serv, net); 263 if (error) 264 goto err_bind; 265 266 error = make_socks(serv, net, cred); 267 if (error < 0) 268 goto err_bind; 269 set_grace_period(net); 270 dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum); 271 return 0; 272 273 err_bind: 274 ln->nlmsvc_users--; 275 return error; 276 } 277 278 static void lockd_down_net(struct svc_serv *serv, struct net *net) 279 { 280 struct lockd_net *ln = net_generic(net, lockd_net_id); 281 282 if (ln->nlmsvc_users) { 283 if (--ln->nlmsvc_users == 0) { 284 nlm_shutdown_hosts_net(net); 285 cancel_delayed_work_sync(&ln->grace_period_end); 286 locks_end_grace(&ln->lockd_manager); 287 svc_shutdown_net(serv, net); 288 dprintk("%s: per-net data destroyed; net=%x\n", 289 __func__, net->ns.inum); 290 } 291 } else { 292 pr_err("%s: no users! task=%p, net=%x\n", 293 __func__, nlmsvc_task, net->ns.inum); 294 BUG(); 295 } 296 } 297 298 static int lockd_inetaddr_event(struct notifier_block *this, 299 unsigned long event, void *ptr) 300 { 301 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 302 struct sockaddr_in sin; 303 304 if ((event != NETDEV_DOWN) || 305 !atomic_inc_not_zero(&nlm_ntf_refcnt)) 306 goto out; 307 308 if (nlmsvc_rqst) { 309 dprintk("lockd_inetaddr_event: removed %pI4\n", 310 &ifa->ifa_local); 311 sin.sin_family = AF_INET; 312 sin.sin_addr.s_addr = ifa->ifa_local; 313 svc_age_temp_xprts_now(nlmsvc_rqst->rq_server, 314 (struct sockaddr *)&sin); 315 } 316 atomic_dec(&nlm_ntf_refcnt); 317 wake_up(&nlm_ntf_wq); 318 319 out: 320 return NOTIFY_DONE; 321 } 322 323 static struct notifier_block lockd_inetaddr_notifier = { 324 .notifier_call = lockd_inetaddr_event, 325 }; 326 327 #if IS_ENABLED(CONFIG_IPV6) 328 static int lockd_inet6addr_event(struct notifier_block *this, 329 unsigned long event, void *ptr) 330 { 331 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 332 struct sockaddr_in6 sin6; 333 334 if ((event != NETDEV_DOWN) || 335 !atomic_inc_not_zero(&nlm_ntf_refcnt)) 336 goto out; 337 338 if (nlmsvc_rqst) { 339 dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr); 340 sin6.sin6_family = AF_INET6; 341 sin6.sin6_addr = ifa->addr; 342 if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL) 343 sin6.sin6_scope_id = ifa->idev->dev->ifindex; 344 svc_age_temp_xprts_now(nlmsvc_rqst->rq_server, 345 (struct sockaddr *)&sin6); 346 } 347 atomic_dec(&nlm_ntf_refcnt); 348 wake_up(&nlm_ntf_wq); 349 350 out: 351 return NOTIFY_DONE; 352 } 353 354 static struct notifier_block lockd_inet6addr_notifier = { 355 .notifier_call = lockd_inet6addr_event, 356 }; 357 #endif 358 359 static void lockd_unregister_notifiers(void) 360 { 361 unregister_inetaddr_notifier(&lockd_inetaddr_notifier); 362 #if IS_ENABLED(CONFIG_IPV6) 363 unregister_inet6addr_notifier(&lockd_inet6addr_notifier); 364 #endif 365 wait_event(nlm_ntf_wq, atomic_read(&nlm_ntf_refcnt) == 0); 366 } 367 368 static void lockd_svc_exit_thread(void) 369 { 370 atomic_dec(&nlm_ntf_refcnt); 371 lockd_unregister_notifiers(); 372 svc_exit_thread(nlmsvc_rqst); 373 } 374 375 static int lockd_start_svc(struct svc_serv *serv) 376 { 377 int error; 378 379 if (nlmsvc_rqst) 380 return 0; 381 382 /* 383 * Create the kernel thread and wait for it to start. 384 */ 385 nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE); 386 if (IS_ERR(nlmsvc_rqst)) { 387 error = PTR_ERR(nlmsvc_rqst); 388 printk(KERN_WARNING 389 "lockd_up: svc_rqst allocation failed, error=%d\n", 390 error); 391 lockd_unregister_notifiers(); 392 goto out_rqst; 393 } 394 395 atomic_inc(&nlm_ntf_refcnt); 396 svc_sock_update_bufs(serv); 397 serv->sv_maxconn = nlm_max_connections; 398 399 nlmsvc_task = kthread_create(lockd, nlmsvc_rqst, "%s", serv->sv_name); 400 if (IS_ERR(nlmsvc_task)) { 401 error = PTR_ERR(nlmsvc_task); 402 printk(KERN_WARNING 403 "lockd_up: kthread_run failed, error=%d\n", error); 404 goto out_task; 405 } 406 nlmsvc_rqst->rq_task = nlmsvc_task; 407 wake_up_process(nlmsvc_task); 408 409 dprintk("lockd_up: service started\n"); 410 return 0; 411 412 out_task: 413 lockd_svc_exit_thread(); 414 nlmsvc_task = NULL; 415 out_rqst: 416 nlmsvc_rqst = NULL; 417 return error; 418 } 419 420 static const struct svc_serv_ops lockd_sv_ops = { 421 .svo_shutdown = svc_rpcb_cleanup, 422 .svo_enqueue_xprt = svc_xprt_do_enqueue, 423 }; 424 425 static struct svc_serv *lockd_create_svc(void) 426 { 427 struct svc_serv *serv; 428 429 /* 430 * Check whether we're already up and running. 431 */ 432 if (nlmsvc_rqst) { 433 /* 434 * Note: increase service usage, because later in case of error 435 * svc_destroy() will be called. 436 */ 437 svc_get(nlmsvc_rqst->rq_server); 438 return nlmsvc_rqst->rq_server; 439 } 440 441 /* 442 * Sanity check: if there's no pid, 443 * we should be the first user ... 444 */ 445 if (nlmsvc_users) 446 printk(KERN_WARNING 447 "lockd_up: no pid, %d users??\n", nlmsvc_users); 448 449 if (!nlm_timeout) 450 nlm_timeout = LOCKD_DFLT_TIMEO; 451 nlmsvc_timeout = nlm_timeout * HZ; 452 453 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops); 454 if (!serv) { 455 printk(KERN_WARNING "lockd_up: create service failed\n"); 456 return ERR_PTR(-ENOMEM); 457 } 458 register_inetaddr_notifier(&lockd_inetaddr_notifier); 459 #if IS_ENABLED(CONFIG_IPV6) 460 register_inet6addr_notifier(&lockd_inet6addr_notifier); 461 #endif 462 dprintk("lockd_up: service created\n"); 463 return serv; 464 } 465 466 /* 467 * Bring up the lockd process if it's not already up. 468 */ 469 int lockd_up(struct net *net, const struct cred *cred) 470 { 471 struct svc_serv *serv; 472 int error; 473 474 mutex_lock(&nlmsvc_mutex); 475 476 serv = lockd_create_svc(); 477 if (IS_ERR(serv)) { 478 error = PTR_ERR(serv); 479 goto err_create; 480 } 481 482 error = lockd_up_net(serv, net, cred); 483 if (error < 0) { 484 lockd_unregister_notifiers(); 485 goto err_put; 486 } 487 488 error = lockd_start_svc(serv); 489 if (error < 0) { 490 lockd_down_net(serv, net); 491 goto err_put; 492 } 493 nlmsvc_users++; 494 /* 495 * Note: svc_serv structures have an initial use count of 1, 496 * so we exit through here on both success and failure. 497 */ 498 err_put: 499 svc_destroy(serv); 500 err_create: 501 mutex_unlock(&nlmsvc_mutex); 502 return error; 503 } 504 EXPORT_SYMBOL_GPL(lockd_up); 505 506 /* 507 * Decrement the user count and bring down lockd if we're the last. 508 */ 509 void 510 lockd_down(struct net *net) 511 { 512 mutex_lock(&nlmsvc_mutex); 513 lockd_down_net(nlmsvc_rqst->rq_server, net); 514 if (nlmsvc_users) { 515 if (--nlmsvc_users) 516 goto out; 517 } else { 518 printk(KERN_ERR "lockd_down: no users! task=%p\n", 519 nlmsvc_task); 520 BUG(); 521 } 522 523 if (!nlmsvc_task) { 524 printk(KERN_ERR "lockd_down: no lockd running.\n"); 525 BUG(); 526 } 527 kthread_stop(nlmsvc_task); 528 dprintk("lockd_down: service stopped\n"); 529 lockd_svc_exit_thread(); 530 dprintk("lockd_down: service destroyed\n"); 531 nlmsvc_task = NULL; 532 nlmsvc_rqst = NULL; 533 out: 534 mutex_unlock(&nlmsvc_mutex); 535 } 536 EXPORT_SYMBOL_GPL(lockd_down); 537 538 #ifdef CONFIG_SYSCTL 539 540 /* 541 * Sysctl parameters (same as module parameters, different interface). 542 */ 543 544 static struct ctl_table nlm_sysctls[] = { 545 { 546 .procname = "nlm_grace_period", 547 .data = &nlm_grace_period, 548 .maxlen = sizeof(unsigned long), 549 .mode = 0644, 550 .proc_handler = proc_doulongvec_minmax, 551 .extra1 = (unsigned long *) &nlm_grace_period_min, 552 .extra2 = (unsigned long *) &nlm_grace_period_max, 553 }, 554 { 555 .procname = "nlm_timeout", 556 .data = &nlm_timeout, 557 .maxlen = sizeof(unsigned long), 558 .mode = 0644, 559 .proc_handler = proc_doulongvec_minmax, 560 .extra1 = (unsigned long *) &nlm_timeout_min, 561 .extra2 = (unsigned long *) &nlm_timeout_max, 562 }, 563 { 564 .procname = "nlm_udpport", 565 .data = &nlm_udpport, 566 .maxlen = sizeof(int), 567 .mode = 0644, 568 .proc_handler = proc_dointvec_minmax, 569 .extra1 = (int *) &nlm_port_min, 570 .extra2 = (int *) &nlm_port_max, 571 }, 572 { 573 .procname = "nlm_tcpport", 574 .data = &nlm_tcpport, 575 .maxlen = sizeof(int), 576 .mode = 0644, 577 .proc_handler = proc_dointvec_minmax, 578 .extra1 = (int *) &nlm_port_min, 579 .extra2 = (int *) &nlm_port_max, 580 }, 581 { 582 .procname = "nsm_use_hostnames", 583 .data = &nsm_use_hostnames, 584 .maxlen = sizeof(int), 585 .mode = 0644, 586 .proc_handler = proc_dointvec, 587 }, 588 { 589 .procname = "nsm_local_state", 590 .data = &nsm_local_state, 591 .maxlen = sizeof(int), 592 .mode = 0644, 593 .proc_handler = proc_dointvec, 594 }, 595 { } 596 }; 597 598 static struct ctl_table nlm_sysctl_dir[] = { 599 { 600 .procname = "nfs", 601 .mode = 0555, 602 .child = nlm_sysctls, 603 }, 604 { } 605 }; 606 607 static struct ctl_table nlm_sysctl_root[] = { 608 { 609 .procname = "fs", 610 .mode = 0555, 611 .child = nlm_sysctl_dir, 612 }, 613 { } 614 }; 615 616 #endif /* CONFIG_SYSCTL */ 617 618 /* 619 * Module (and sysfs) parameters. 620 */ 621 622 #define param_set_min_max(name, type, which_strtol, min, max) \ 623 static int param_set_##name(const char *val, const struct kernel_param *kp) \ 624 { \ 625 char *endp; \ 626 __typeof__(type) num = which_strtol(val, &endp, 0); \ 627 if (endp == val || *endp || num < (min) || num > (max)) \ 628 return -EINVAL; \ 629 *((type *) kp->arg) = num; \ 630 return 0; \ 631 } 632 633 static inline int is_callback(u32 proc) 634 { 635 return proc == NLMPROC_GRANTED 636 || proc == NLMPROC_GRANTED_MSG 637 || proc == NLMPROC_TEST_RES 638 || proc == NLMPROC_LOCK_RES 639 || proc == NLMPROC_CANCEL_RES 640 || proc == NLMPROC_UNLOCK_RES 641 || proc == NLMPROC_NSM_NOTIFY; 642 } 643 644 645 static int lockd_authenticate(struct svc_rqst *rqstp) 646 { 647 rqstp->rq_client = NULL; 648 switch (rqstp->rq_authop->flavour) { 649 case RPC_AUTH_NULL: 650 case RPC_AUTH_UNIX: 651 if (rqstp->rq_proc == 0) 652 return SVC_OK; 653 if (is_callback(rqstp->rq_proc)) { 654 /* Leave it to individual procedures to 655 * call nlmsvc_lookup_host(rqstp) 656 */ 657 return SVC_OK; 658 } 659 return svc_set_client(rqstp); 660 } 661 return SVC_DENIED; 662 } 663 664 665 param_set_min_max(port, int, simple_strtol, 0, 65535) 666 param_set_min_max(grace_period, unsigned long, simple_strtoul, 667 nlm_grace_period_min, nlm_grace_period_max) 668 param_set_min_max(timeout, unsigned long, simple_strtoul, 669 nlm_timeout_min, nlm_timeout_max) 670 671 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 672 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION "."); 673 MODULE_LICENSE("GPL"); 674 675 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong, 676 &nlm_grace_period, 0644); 677 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong, 678 &nlm_timeout, 0644); 679 module_param_call(nlm_udpport, param_set_port, param_get_int, 680 &nlm_udpport, 0644); 681 module_param_call(nlm_tcpport, param_set_port, param_get_int, 682 &nlm_tcpport, 0644); 683 module_param(nsm_use_hostnames, bool, 0644); 684 module_param(nlm_max_connections, uint, 0644); 685 686 static int lockd_init_net(struct net *net) 687 { 688 struct lockd_net *ln = net_generic(net, lockd_net_id); 689 690 INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender); 691 INIT_LIST_HEAD(&ln->lockd_manager.list); 692 ln->lockd_manager.block_opens = false; 693 INIT_LIST_HEAD(&ln->nsm_handles); 694 return 0; 695 } 696 697 static void lockd_exit_net(struct net *net) 698 { 699 struct lockd_net *ln = net_generic(net, lockd_net_id); 700 701 WARN_ONCE(!list_empty(&ln->lockd_manager.list), 702 "net %x %s: lockd_manager.list is not empty\n", 703 net->ns.inum, __func__); 704 WARN_ONCE(!list_empty(&ln->nsm_handles), 705 "net %x %s: nsm_handles list is not empty\n", 706 net->ns.inum, __func__); 707 WARN_ONCE(delayed_work_pending(&ln->grace_period_end), 708 "net %x %s: grace_period_end was not cancelled\n", 709 net->ns.inum, __func__); 710 } 711 712 static struct pernet_operations lockd_net_ops = { 713 .init = lockd_init_net, 714 .exit = lockd_exit_net, 715 .id = &lockd_net_id, 716 .size = sizeof(struct lockd_net), 717 }; 718 719 720 /* 721 * Initialising and terminating the module. 722 */ 723 724 static int __init init_nlm(void) 725 { 726 int err; 727 728 #ifdef CONFIG_SYSCTL 729 err = -ENOMEM; 730 nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root); 731 if (nlm_sysctl_table == NULL) 732 goto err_sysctl; 733 #endif 734 err = register_pernet_subsys(&lockd_net_ops); 735 if (err) 736 goto err_pernet; 737 738 err = lockd_create_procfs(); 739 if (err) 740 goto err_procfs; 741 742 return 0; 743 744 err_procfs: 745 unregister_pernet_subsys(&lockd_net_ops); 746 err_pernet: 747 #ifdef CONFIG_SYSCTL 748 unregister_sysctl_table(nlm_sysctl_table); 749 err_sysctl: 750 #endif 751 return err; 752 } 753 754 static void __exit exit_nlm(void) 755 { 756 /* FIXME: delete all NLM clients */ 757 nlm_shutdown_hosts(); 758 lockd_remove_procfs(); 759 unregister_pernet_subsys(&lockd_net_ops); 760 #ifdef CONFIG_SYSCTL 761 unregister_sysctl_table(nlm_sysctl_table); 762 #endif 763 } 764 765 module_init(init_nlm); 766 module_exit(exit_nlm); 767 768 /* 769 * Define NLM program and procedures 770 */ 771 static unsigned int nlmsvc_version1_count[17]; 772 static const struct svc_version nlmsvc_version1 = { 773 .vs_vers = 1, 774 .vs_nproc = 17, 775 .vs_proc = nlmsvc_procedures, 776 .vs_count = nlmsvc_version1_count, 777 .vs_xdrsize = NLMSVC_XDRSIZE, 778 }; 779 static unsigned int nlmsvc_version3_count[24]; 780 static const struct svc_version nlmsvc_version3 = { 781 .vs_vers = 3, 782 .vs_nproc = 24, 783 .vs_proc = nlmsvc_procedures, 784 .vs_count = nlmsvc_version3_count, 785 .vs_xdrsize = NLMSVC_XDRSIZE, 786 }; 787 #ifdef CONFIG_LOCKD_V4 788 static unsigned int nlmsvc_version4_count[24]; 789 static const struct svc_version nlmsvc_version4 = { 790 .vs_vers = 4, 791 .vs_nproc = 24, 792 .vs_proc = nlmsvc_procedures4, 793 .vs_count = nlmsvc_version4_count, 794 .vs_xdrsize = NLMSVC_XDRSIZE, 795 }; 796 #endif 797 static const struct svc_version *nlmsvc_version[] = { 798 [1] = &nlmsvc_version1, 799 [3] = &nlmsvc_version3, 800 #ifdef CONFIG_LOCKD_V4 801 [4] = &nlmsvc_version4, 802 #endif 803 }; 804 805 static struct svc_stat nlmsvc_stats; 806 807 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version) 808 static struct svc_program nlmsvc_program = { 809 .pg_prog = NLM_PROGRAM, /* program number */ 810 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */ 811 .pg_vers = nlmsvc_version, /* version table */ 812 .pg_name = "lockd", /* service name */ 813 .pg_class = "nfsd", /* share authentication with nfsd */ 814 .pg_stats = &nlmsvc_stats, /* stats table */ 815 .pg_authenticate = &lockd_authenticate, /* export authentication */ 816 .pg_init_request = svc_generic_init_request, 817 .pg_rpcbind_set = svc_generic_rpcbind_set, 818 }; 819