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