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/kthread.h> 28 #include <linux/freezer.h> 29 #include <linux/inetdevice.h> 30 31 #include <linux/sunrpc/types.h> 32 #include <linux/sunrpc/stats.h> 33 #include <linux/sunrpc/clnt.h> 34 #include <linux/sunrpc/svc.h> 35 #include <linux/sunrpc/svcsock.h> 36 #include <linux/sunrpc/svc_xprt.h> 37 #include <net/ip.h> 38 #include <net/addrconf.h> 39 #include <net/ipv6.h> 40 #include <linux/lockd/lockd.h> 41 #include <linux/nfs.h> 42 43 #include "netns.h" 44 #include "procfs.h" 45 46 #define NLMDBG_FACILITY NLMDBG_SVC 47 #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE) 48 #define ALLOWED_SIGS (sigmask(SIGKILL)) 49 50 static struct svc_program nlmsvc_program; 51 52 const struct nlmsvc_binding *nlmsvc_ops; 53 EXPORT_SYMBOL_GPL(nlmsvc_ops); 54 55 static DEFINE_MUTEX(nlmsvc_mutex); 56 static unsigned int nlmsvc_users; 57 static struct svc_serv *nlmsvc_serv; 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 184 dprintk("lockd_down: service stopped\n"); 185 186 svc_exit_thread(rqstp); 187 188 module_put_and_kthread_exit(0); 189 } 190 191 static int create_lockd_listener(struct svc_serv *serv, const char *name, 192 struct net *net, const int family, 193 const unsigned short port, 194 const struct cred *cred) 195 { 196 struct svc_xprt *xprt; 197 198 xprt = svc_find_xprt(serv, name, net, family, 0); 199 if (xprt == NULL) 200 return svc_create_xprt(serv, name, net, family, port, 201 SVC_SOCK_DEFAULTS, cred); 202 svc_xprt_put(xprt); 203 return 0; 204 } 205 206 static int create_lockd_family(struct svc_serv *serv, struct net *net, 207 const int family, const struct cred *cred) 208 { 209 int err; 210 211 err = create_lockd_listener(serv, "udp", net, family, nlm_udpport, 212 cred); 213 if (err < 0) 214 return err; 215 216 return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport, 217 cred); 218 } 219 220 /* 221 * Ensure there are active UDP and TCP listeners for lockd. 222 * 223 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some 224 * local services (such as rpc.statd) still require UDP, and 225 * some NFS servers do not yet support NLM over TCP. 226 * 227 * Returns zero if all listeners are available; otherwise a 228 * negative errno value is returned. 229 */ 230 static int make_socks(struct svc_serv *serv, struct net *net, 231 const struct cred *cred) 232 { 233 static int warned; 234 int err; 235 236 err = create_lockd_family(serv, net, PF_INET, cred); 237 if (err < 0) 238 goto out_err; 239 240 err = create_lockd_family(serv, net, PF_INET6, cred); 241 if (err < 0 && err != -EAFNOSUPPORT) 242 goto out_err; 243 244 warned = 0; 245 return 0; 246 247 out_err: 248 if (warned++ == 0) 249 printk(KERN_WARNING 250 "lockd_up: makesock failed, error=%d\n", err); 251 svc_shutdown_net(serv, net); 252 return err; 253 } 254 255 static int lockd_up_net(struct svc_serv *serv, struct net *net, 256 const struct cred *cred) 257 { 258 struct lockd_net *ln = net_generic(net, lockd_net_id); 259 int error; 260 261 if (ln->nlmsvc_users++) 262 return 0; 263 264 error = svc_bind(serv, net); 265 if (error) 266 goto err_bind; 267 268 error = make_socks(serv, net, cred); 269 if (error < 0) 270 goto err_bind; 271 set_grace_period(net); 272 dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum); 273 return 0; 274 275 err_bind: 276 ln->nlmsvc_users--; 277 return error; 278 } 279 280 static void lockd_down_net(struct svc_serv *serv, struct net *net) 281 { 282 struct lockd_net *ln = net_generic(net, lockd_net_id); 283 284 if (ln->nlmsvc_users) { 285 if (--ln->nlmsvc_users == 0) { 286 nlm_shutdown_hosts_net(net); 287 cancel_delayed_work_sync(&ln->grace_period_end); 288 locks_end_grace(&ln->lockd_manager); 289 svc_shutdown_net(serv, net); 290 dprintk("%s: per-net data destroyed; net=%x\n", 291 __func__, net->ns.inum); 292 } 293 } else { 294 pr_err("%s: no users! net=%x\n", 295 __func__, net->ns.inum); 296 BUG(); 297 } 298 } 299 300 static int lockd_inetaddr_event(struct notifier_block *this, 301 unsigned long event, void *ptr) 302 { 303 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 304 struct sockaddr_in sin; 305 306 if (event != NETDEV_DOWN) 307 goto out; 308 309 if (nlmsvc_serv) { 310 dprintk("lockd_inetaddr_event: removed %pI4\n", 311 &ifa->ifa_local); 312 sin.sin_family = AF_INET; 313 sin.sin_addr.s_addr = ifa->ifa_local; 314 svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin); 315 } 316 317 out: 318 return NOTIFY_DONE; 319 } 320 321 static struct notifier_block lockd_inetaddr_notifier = { 322 .notifier_call = lockd_inetaddr_event, 323 }; 324 325 #if IS_ENABLED(CONFIG_IPV6) 326 static int lockd_inet6addr_event(struct notifier_block *this, 327 unsigned long event, void *ptr) 328 { 329 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 330 struct sockaddr_in6 sin6; 331 332 if (event != NETDEV_DOWN) 333 goto out; 334 335 if (nlmsvc_serv) { 336 dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr); 337 sin6.sin6_family = AF_INET6; 338 sin6.sin6_addr = ifa->addr; 339 if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL) 340 sin6.sin6_scope_id = ifa->idev->dev->ifindex; 341 svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6); 342 } 343 344 out: 345 return NOTIFY_DONE; 346 } 347 348 static struct notifier_block lockd_inet6addr_notifier = { 349 .notifier_call = lockd_inet6addr_event, 350 }; 351 #endif 352 353 static const struct svc_serv_ops lockd_sv_ops = { 354 .svo_shutdown = svc_rpcb_cleanup, 355 .svo_function = lockd, 356 .svo_enqueue_xprt = svc_xprt_do_enqueue, 357 .svo_module = THIS_MODULE, 358 }; 359 360 static int lockd_get(void) 361 { 362 struct svc_serv *serv; 363 int error; 364 365 if (nlmsvc_serv) { 366 svc_get(nlmsvc_serv); 367 nlmsvc_users++; 368 return 0; 369 } 370 371 /* 372 * Sanity check: if there's no pid, 373 * we should be the first user ... 374 */ 375 if (nlmsvc_users) 376 printk(KERN_WARNING 377 "lockd_up: no pid, %d users??\n", nlmsvc_users); 378 379 if (!nlm_timeout) 380 nlm_timeout = LOCKD_DFLT_TIMEO; 381 nlmsvc_timeout = nlm_timeout * HZ; 382 383 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops); 384 if (!serv) { 385 printk(KERN_WARNING "lockd_up: create service failed\n"); 386 return -ENOMEM; 387 } 388 389 serv->sv_maxconn = nlm_max_connections; 390 error = svc_set_num_threads(serv, NULL, 1); 391 /* The thread now holds the only reference */ 392 svc_put(serv); 393 if (error < 0) 394 return error; 395 396 nlmsvc_serv = serv; 397 register_inetaddr_notifier(&lockd_inetaddr_notifier); 398 #if IS_ENABLED(CONFIG_IPV6) 399 register_inet6addr_notifier(&lockd_inet6addr_notifier); 400 #endif 401 dprintk("lockd_up: service created\n"); 402 nlmsvc_users++; 403 return 0; 404 } 405 406 static void lockd_put(void) 407 { 408 if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n")) 409 return; 410 if (--nlmsvc_users) 411 return; 412 413 unregister_inetaddr_notifier(&lockd_inetaddr_notifier); 414 #if IS_ENABLED(CONFIG_IPV6) 415 unregister_inet6addr_notifier(&lockd_inet6addr_notifier); 416 #endif 417 418 svc_set_num_threads(nlmsvc_serv, NULL, 0); 419 nlmsvc_serv = NULL; 420 dprintk("lockd_down: service destroyed\n"); 421 } 422 423 /* 424 * Bring up the lockd process if it's not already up. 425 */ 426 int lockd_up(struct net *net, const struct cred *cred) 427 { 428 int error; 429 430 mutex_lock(&nlmsvc_mutex); 431 432 error = lockd_get(); 433 if (error) 434 goto err; 435 436 error = lockd_up_net(nlmsvc_serv, net, cred); 437 if (error < 0) { 438 lockd_put(); 439 goto err; 440 } 441 442 err: 443 mutex_unlock(&nlmsvc_mutex); 444 return error; 445 } 446 EXPORT_SYMBOL_GPL(lockd_up); 447 448 /* 449 * Decrement the user count and bring down lockd if we're the last. 450 */ 451 void 452 lockd_down(struct net *net) 453 { 454 mutex_lock(&nlmsvc_mutex); 455 lockd_down_net(nlmsvc_serv, net); 456 lockd_put(); 457 mutex_unlock(&nlmsvc_mutex); 458 } 459 EXPORT_SYMBOL_GPL(lockd_down); 460 461 #ifdef CONFIG_SYSCTL 462 463 /* 464 * Sysctl parameters (same as module parameters, different interface). 465 */ 466 467 static struct ctl_table nlm_sysctls[] = { 468 { 469 .procname = "nlm_grace_period", 470 .data = &nlm_grace_period, 471 .maxlen = sizeof(unsigned long), 472 .mode = 0644, 473 .proc_handler = proc_doulongvec_minmax, 474 .extra1 = (unsigned long *) &nlm_grace_period_min, 475 .extra2 = (unsigned long *) &nlm_grace_period_max, 476 }, 477 { 478 .procname = "nlm_timeout", 479 .data = &nlm_timeout, 480 .maxlen = sizeof(unsigned long), 481 .mode = 0644, 482 .proc_handler = proc_doulongvec_minmax, 483 .extra1 = (unsigned long *) &nlm_timeout_min, 484 .extra2 = (unsigned long *) &nlm_timeout_max, 485 }, 486 { 487 .procname = "nlm_udpport", 488 .data = &nlm_udpport, 489 .maxlen = sizeof(int), 490 .mode = 0644, 491 .proc_handler = proc_dointvec_minmax, 492 .extra1 = (int *) &nlm_port_min, 493 .extra2 = (int *) &nlm_port_max, 494 }, 495 { 496 .procname = "nlm_tcpport", 497 .data = &nlm_tcpport, 498 .maxlen = sizeof(int), 499 .mode = 0644, 500 .proc_handler = proc_dointvec_minmax, 501 .extra1 = (int *) &nlm_port_min, 502 .extra2 = (int *) &nlm_port_max, 503 }, 504 { 505 .procname = "nsm_use_hostnames", 506 .data = &nsm_use_hostnames, 507 .maxlen = sizeof(int), 508 .mode = 0644, 509 .proc_handler = proc_dobool, 510 }, 511 { 512 .procname = "nsm_local_state", 513 .data = &nsm_local_state, 514 .maxlen = sizeof(int), 515 .mode = 0644, 516 .proc_handler = proc_dointvec, 517 }, 518 { } 519 }; 520 521 static struct ctl_table nlm_sysctl_dir[] = { 522 { 523 .procname = "nfs", 524 .mode = 0555, 525 .child = nlm_sysctls, 526 }, 527 { } 528 }; 529 530 static struct ctl_table nlm_sysctl_root[] = { 531 { 532 .procname = "fs", 533 .mode = 0555, 534 .child = nlm_sysctl_dir, 535 }, 536 { } 537 }; 538 539 #endif /* CONFIG_SYSCTL */ 540 541 /* 542 * Module (and sysfs) parameters. 543 */ 544 545 #define param_set_min_max(name, type, which_strtol, min, max) \ 546 static int param_set_##name(const char *val, const struct kernel_param *kp) \ 547 { \ 548 char *endp; \ 549 __typeof__(type) num = which_strtol(val, &endp, 0); \ 550 if (endp == val || *endp || num < (min) || num > (max)) \ 551 return -EINVAL; \ 552 *((type *) kp->arg) = num; \ 553 return 0; \ 554 } 555 556 static inline int is_callback(u32 proc) 557 { 558 return proc == NLMPROC_GRANTED 559 || proc == NLMPROC_GRANTED_MSG 560 || proc == NLMPROC_TEST_RES 561 || proc == NLMPROC_LOCK_RES 562 || proc == NLMPROC_CANCEL_RES 563 || proc == NLMPROC_UNLOCK_RES 564 || proc == NLMPROC_NSM_NOTIFY; 565 } 566 567 568 static int lockd_authenticate(struct svc_rqst *rqstp) 569 { 570 rqstp->rq_client = NULL; 571 switch (rqstp->rq_authop->flavour) { 572 case RPC_AUTH_NULL: 573 case RPC_AUTH_UNIX: 574 rqstp->rq_auth_stat = rpc_auth_ok; 575 if (rqstp->rq_proc == 0) 576 return SVC_OK; 577 if (is_callback(rqstp->rq_proc)) { 578 /* Leave it to individual procedures to 579 * call nlmsvc_lookup_host(rqstp) 580 */ 581 return SVC_OK; 582 } 583 return svc_set_client(rqstp); 584 } 585 rqstp->rq_auth_stat = rpc_autherr_badcred; 586 return SVC_DENIED; 587 } 588 589 590 param_set_min_max(port, int, simple_strtol, 0, 65535) 591 param_set_min_max(grace_period, unsigned long, simple_strtoul, 592 nlm_grace_period_min, nlm_grace_period_max) 593 param_set_min_max(timeout, unsigned long, simple_strtoul, 594 nlm_timeout_min, nlm_timeout_max) 595 596 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 597 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION "."); 598 MODULE_LICENSE("GPL"); 599 600 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong, 601 &nlm_grace_period, 0644); 602 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong, 603 &nlm_timeout, 0644); 604 module_param_call(nlm_udpport, param_set_port, param_get_int, 605 &nlm_udpport, 0644); 606 module_param_call(nlm_tcpport, param_set_port, param_get_int, 607 &nlm_tcpport, 0644); 608 module_param(nsm_use_hostnames, bool, 0644); 609 module_param(nlm_max_connections, uint, 0644); 610 611 static int lockd_init_net(struct net *net) 612 { 613 struct lockd_net *ln = net_generic(net, lockd_net_id); 614 615 INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender); 616 INIT_LIST_HEAD(&ln->lockd_manager.list); 617 ln->lockd_manager.block_opens = false; 618 INIT_LIST_HEAD(&ln->nsm_handles); 619 return 0; 620 } 621 622 static void lockd_exit_net(struct net *net) 623 { 624 struct lockd_net *ln = net_generic(net, lockd_net_id); 625 626 WARN_ONCE(!list_empty(&ln->lockd_manager.list), 627 "net %x %s: lockd_manager.list is not empty\n", 628 net->ns.inum, __func__); 629 WARN_ONCE(!list_empty(&ln->nsm_handles), 630 "net %x %s: nsm_handles list is not empty\n", 631 net->ns.inum, __func__); 632 WARN_ONCE(delayed_work_pending(&ln->grace_period_end), 633 "net %x %s: grace_period_end was not cancelled\n", 634 net->ns.inum, __func__); 635 } 636 637 static struct pernet_operations lockd_net_ops = { 638 .init = lockd_init_net, 639 .exit = lockd_exit_net, 640 .id = &lockd_net_id, 641 .size = sizeof(struct lockd_net), 642 }; 643 644 645 /* 646 * Initialising and terminating the module. 647 */ 648 649 static int __init init_nlm(void) 650 { 651 int err; 652 653 #ifdef CONFIG_SYSCTL 654 err = -ENOMEM; 655 nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root); 656 if (nlm_sysctl_table == NULL) 657 goto err_sysctl; 658 #endif 659 err = register_pernet_subsys(&lockd_net_ops); 660 if (err) 661 goto err_pernet; 662 663 err = lockd_create_procfs(); 664 if (err) 665 goto err_procfs; 666 667 return 0; 668 669 err_procfs: 670 unregister_pernet_subsys(&lockd_net_ops); 671 err_pernet: 672 #ifdef CONFIG_SYSCTL 673 unregister_sysctl_table(nlm_sysctl_table); 674 err_sysctl: 675 #endif 676 return err; 677 } 678 679 static void __exit exit_nlm(void) 680 { 681 /* FIXME: delete all NLM clients */ 682 nlm_shutdown_hosts(); 683 lockd_remove_procfs(); 684 unregister_pernet_subsys(&lockd_net_ops); 685 #ifdef CONFIG_SYSCTL 686 unregister_sysctl_table(nlm_sysctl_table); 687 #endif 688 } 689 690 module_init(init_nlm); 691 module_exit(exit_nlm); 692 693 /** 694 * nlmsvc_dispatch - Process an NLM Request 695 * @rqstp: incoming request 696 * @statp: pointer to location of accept_stat field in RPC Reply buffer 697 * 698 * Return values: 699 * %0: Processing complete; do not send a Reply 700 * %1: Processing complete; send Reply in rqstp->rq_res 701 */ 702 static int nlmsvc_dispatch(struct svc_rqst *rqstp, __be32 *statp) 703 { 704 const struct svc_procedure *procp = rqstp->rq_procinfo; 705 706 svcxdr_init_decode(rqstp); 707 if (!procp->pc_decode(rqstp, &rqstp->rq_arg_stream)) 708 goto out_decode_err; 709 710 *statp = procp->pc_func(rqstp); 711 if (*statp == rpc_drop_reply) 712 return 0; 713 if (*statp != rpc_success) 714 return 1; 715 716 svcxdr_init_encode(rqstp); 717 if (!procp->pc_encode(rqstp, &rqstp->rq_res_stream)) 718 goto out_encode_err; 719 720 return 1; 721 722 out_decode_err: 723 *statp = rpc_garbage_args; 724 return 1; 725 726 out_encode_err: 727 *statp = rpc_system_err; 728 return 1; 729 } 730 731 /* 732 * Define NLM program and procedures 733 */ 734 static unsigned int nlmsvc_version1_count[17]; 735 static const struct svc_version nlmsvc_version1 = { 736 .vs_vers = 1, 737 .vs_nproc = 17, 738 .vs_proc = nlmsvc_procedures, 739 .vs_count = nlmsvc_version1_count, 740 .vs_dispatch = nlmsvc_dispatch, 741 .vs_xdrsize = NLMSVC_XDRSIZE, 742 }; 743 static unsigned int nlmsvc_version3_count[24]; 744 static const struct svc_version nlmsvc_version3 = { 745 .vs_vers = 3, 746 .vs_nproc = 24, 747 .vs_proc = nlmsvc_procedures, 748 .vs_count = nlmsvc_version3_count, 749 .vs_dispatch = nlmsvc_dispatch, 750 .vs_xdrsize = NLMSVC_XDRSIZE, 751 }; 752 #ifdef CONFIG_LOCKD_V4 753 static unsigned int nlmsvc_version4_count[24]; 754 static const struct svc_version nlmsvc_version4 = { 755 .vs_vers = 4, 756 .vs_nproc = 24, 757 .vs_proc = nlmsvc_procedures4, 758 .vs_count = nlmsvc_version4_count, 759 .vs_dispatch = nlmsvc_dispatch, 760 .vs_xdrsize = NLMSVC_XDRSIZE, 761 }; 762 #endif 763 static const struct svc_version *nlmsvc_version[] = { 764 [1] = &nlmsvc_version1, 765 [3] = &nlmsvc_version3, 766 #ifdef CONFIG_LOCKD_V4 767 [4] = &nlmsvc_version4, 768 #endif 769 }; 770 771 static struct svc_stat nlmsvc_stats; 772 773 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version) 774 static struct svc_program nlmsvc_program = { 775 .pg_prog = NLM_PROGRAM, /* program number */ 776 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */ 777 .pg_vers = nlmsvc_version, /* version table */ 778 .pg_name = "lockd", /* service name */ 779 .pg_class = "nfsd", /* share authentication with nfsd */ 780 .pg_stats = &nlmsvc_stats, /* stats table */ 781 .pg_authenticate = &lockd_authenticate, /* export authentication */ 782 .pg_init_request = svc_generic_init_request, 783 .pg_rpcbind_set = svc_generic_rpcbind_set, 784 }; 785