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