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(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, lockd_net_id); 112 113 locks_start_grace(net, &ln->lockd_manager); 114 cancel_delayed_work_sync(&ln->grace_period_end); 115 schedule_delayed_work(&ln->grace_period_end, 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, 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(&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, name, net, family, 0); 164 if (xprt == NULL) 165 return svc_xprt_create(serv, 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, "udp", net, family, nlm_udpport, 177 cred); 178 if (err < 0) 179 return err; 180 181 return create_lockd_listener(serv, "tcp", net, family, 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, 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, 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(&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(&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, 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(&lockd_inetaddr_notifier); 355 #if IS_ENABLED(CONFIG_IPV6) 356 register_inet6addr_notifier(&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(&lockd_inetaddr_notifier); 371 #if IS_ENABLED(CONFIG_IPV6) 372 unregister_inet6addr_notifier(&lockd_inet6addr_notifier); 373 #endif 374 375 svc_get(nlmsvc_serv); 376 svc_set_num_threads(nlmsvc_serv, NULL, 0); 377 svc_put(nlmsvc_serv); 378 timer_delete_sync(&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(nlmsvc_serv, net, cred); 397 if (error < 0) { 398 lockd_put(); 399 goto err; 400 } 401 402 err: 403 mutex_unlock(&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(nlmsvc_serv, net); 416 lockd_put(); 417 mutex_unlock(&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(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, lockd_net_id); 556 557 INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender); 558 INIT_LIST_HEAD(&ln->lockd_manager.list); 559 ln->lockd_manager.block_opens = false; 560 INIT_LIST_HEAD(&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, 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(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(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