svc.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694
  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. #include <linux/module.h>
  15. #include <linux/init.h>
  16. #include <linux/sysctl.h>
  17. #include <linux/moduleparam.h>
  18. #include <linux/sched.h>
  19. #include <linux/errno.h>
  20. #include <linux/in.h>
  21. #include <linux/uio.h>
  22. #include <linux/smp.h>
  23. #include <linux/mutex.h>
  24. #include <linux/kthread.h>
  25. #include <linux/freezer.h>
  26. #include <linux/sunrpc/types.h>
  27. #include <linux/sunrpc/stats.h>
  28. #include <linux/sunrpc/clnt.h>
  29. #include <linux/sunrpc/svc.h>
  30. #include <linux/sunrpc/svcsock.h>
  31. #include <net/ip.h>
  32. #include <linux/lockd/lockd.h>
  33. #include <linux/nfs.h>
  34. #include "netns.h"
  35. #define NLMDBG_FACILITY NLMDBG_SVC
  36. #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
  37. #define ALLOWED_SIGS (sigmask(SIGKILL))
  38. static struct svc_program nlmsvc_program;
  39. struct nlmsvc_binding * nlmsvc_ops;
  40. EXPORT_SYMBOL_GPL(nlmsvc_ops);
  41. static DEFINE_MUTEX(nlmsvc_mutex);
  42. static unsigned int nlmsvc_users;
  43. static struct task_struct *nlmsvc_task;
  44. static struct svc_rqst *nlmsvc_rqst;
  45. unsigned long nlmsvc_timeout;
  46. int lockd_net_id;
  47. /*
  48. * These can be set at insmod time (useful for NFS as root filesystem),
  49. * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
  50. */
  51. static unsigned long nlm_grace_period;
  52. static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO;
  53. static int nlm_udpport, nlm_tcpport;
  54. /* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
  55. static unsigned int nlm_max_connections = 1024;
  56. /*
  57. * Constants needed for the sysctl interface.
  58. */
  59. static const unsigned long nlm_grace_period_min = 0;
  60. static const unsigned long nlm_grace_period_max = 240;
  61. static const unsigned long nlm_timeout_min = 3;
  62. static const unsigned long nlm_timeout_max = 20;
  63. static const int nlm_port_min = 0, nlm_port_max = 65535;
  64. #ifdef CONFIG_SYSCTL
  65. static struct ctl_table_header * nlm_sysctl_table;
  66. #endif
  67. static unsigned long get_lockd_grace_period(void)
  68. {
  69. /* Note: nlm_timeout should always be nonzero */
  70. if (nlm_grace_period)
  71. return roundup(nlm_grace_period, nlm_timeout) * HZ;
  72. else
  73. return nlm_timeout * 5 * HZ;
  74. }
  75. static struct lock_manager lockd_manager = {
  76. };
  77. static void grace_ender(struct work_struct *not_used)
  78. {
  79. locks_end_grace(&lockd_manager);
  80. }
  81. static void set_grace_period(void)
  82. {
  83. unsigned long grace_period = get_lockd_grace_period();
  84. struct lockd_net *ln = net_generic(&init_net, lockd_net_id);
  85. locks_start_grace(&lockd_manager);
  86. cancel_delayed_work_sync(&ln->grace_period_end);
  87. schedule_delayed_work(&ln->grace_period_end, grace_period);
  88. }
  89. static void restart_grace(void)
  90. {
  91. if (nlmsvc_ops) {
  92. struct lockd_net *ln = net_generic(&init_net, lockd_net_id);
  93. cancel_delayed_work_sync(&ln->grace_period_end);
  94. locks_end_grace(&lockd_manager);
  95. nlmsvc_invalidate_all();
  96. set_grace_period();
  97. }
  98. }
  99. /*
  100. * This is the lockd kernel thread
  101. */
  102. static int
  103. lockd(void *vrqstp)
  104. {
  105. int err = 0, preverr = 0;
  106. struct svc_rqst *rqstp = vrqstp;
  107. struct lockd_net *ln = net_generic(&init_net, lockd_net_id);
  108. /* try_to_freeze() is called from svc_recv() */
  109. set_freezable();
  110. /* Allow SIGKILL to tell lockd to drop all of its locks */
  111. allow_signal(SIGKILL);
  112. dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
  113. if (!nlm_timeout)
  114. nlm_timeout = LOCKD_DFLT_TIMEO;
  115. nlmsvc_timeout = nlm_timeout * HZ;
  116. set_grace_period();
  117. /*
  118. * The main request loop. We don't terminate until the last
  119. * NFS mount or NFS daemon has gone away.
  120. */
  121. while (!kthread_should_stop()) {
  122. long timeout = MAX_SCHEDULE_TIMEOUT;
  123. RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
  124. /* update sv_maxconn if it has changed */
  125. rqstp->rq_server->sv_maxconn = nlm_max_connections;
  126. if (signalled()) {
  127. flush_signals(current);
  128. restart_grace();
  129. continue;
  130. }
  131. timeout = nlmsvc_retry_blocked();
  132. /*
  133. * Find a socket with data available and call its
  134. * recvfrom routine.
  135. */
  136. err = svc_recv(rqstp, timeout);
  137. if (err == -EAGAIN || err == -EINTR) {
  138. preverr = err;
  139. continue;
  140. }
  141. if (err < 0) {
  142. if (err != preverr) {
  143. printk(KERN_WARNING "%s: unexpected error "
  144. "from svc_recv (%d)\n", __func__, err);
  145. preverr = err;
  146. }
  147. schedule_timeout_interruptible(HZ);
  148. continue;
  149. }
  150. preverr = err;
  151. dprintk("lockd: request from %s\n",
  152. svc_print_addr(rqstp, buf, sizeof(buf)));
  153. svc_process(rqstp);
  154. }
  155. flush_signals(current);
  156. cancel_delayed_work_sync(&ln->grace_period_end);
  157. locks_end_grace(&lockd_manager);
  158. if (nlmsvc_ops)
  159. nlmsvc_invalidate_all();
  160. nlm_shutdown_hosts();
  161. return 0;
  162. }
  163. static int create_lockd_listener(struct svc_serv *serv, const char *name,
  164. struct net *net, const int family,
  165. const unsigned short port)
  166. {
  167. struct svc_xprt *xprt;
  168. xprt = svc_find_xprt(serv, name, net, family, 0);
  169. if (xprt == NULL)
  170. return svc_create_xprt(serv, name, net, family, port,
  171. SVC_SOCK_DEFAULTS);
  172. svc_xprt_put(xprt);
  173. return 0;
  174. }
  175. static int create_lockd_family(struct svc_serv *serv, struct net *net,
  176. const int family)
  177. {
  178. int err;
  179. err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
  180. if (err < 0)
  181. return err;
  182. return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
  183. }
  184. /*
  185. * Ensure there are active UDP and TCP listeners for lockd.
  186. *
  187. * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
  188. * local services (such as rpc.statd) still require UDP, and
  189. * some NFS servers do not yet support NLM over TCP.
  190. *
  191. * Returns zero if all listeners are available; otherwise a
  192. * negative errno value is returned.
  193. */
  194. static int make_socks(struct svc_serv *serv, struct net *net)
  195. {
  196. static int warned;
  197. int err;
  198. err = create_lockd_family(serv, net, PF_INET);
  199. if (err < 0)
  200. goto out_err;
  201. err = create_lockd_family(serv, net, PF_INET6);
  202. if (err < 0 && err != -EAFNOSUPPORT)
  203. goto out_err;
  204. warned = 0;
  205. return 0;
  206. out_err:
  207. if (warned++ == 0)
  208. printk(KERN_WARNING
  209. "lockd_up: makesock failed, error=%d\n", err);
  210. return err;
  211. }
  212. static int lockd_up_net(struct svc_serv *serv, struct net *net)
  213. {
  214. struct lockd_net *ln = net_generic(net, lockd_net_id);
  215. int error;
  216. if (ln->nlmsvc_users++)
  217. return 0;
  218. error = svc_bind(serv, net);
  219. if (error)
  220. goto err_bind;
  221. error = make_socks(serv, net);
  222. if (error < 0)
  223. goto err_socks;
  224. dprintk("lockd_up_net: per-net data created; net=%p\n", net);
  225. return 0;
  226. err_socks:
  227. svc_rpcb_cleanup(serv, net);
  228. err_bind:
  229. ln->nlmsvc_users--;
  230. return error;
  231. }
  232. static void lockd_down_net(struct svc_serv *serv, struct net *net)
  233. {
  234. struct lockd_net *ln = net_generic(net, lockd_net_id);
  235. if (ln->nlmsvc_users) {
  236. if (--ln->nlmsvc_users == 0) {
  237. nlm_shutdown_hosts_net(net);
  238. svc_shutdown_net(serv, net);
  239. dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net);
  240. }
  241. } else {
  242. printk(KERN_ERR "lockd_down_net: no users! task=%p, net=%p\n",
  243. nlmsvc_task, net);
  244. BUG();
  245. }
  246. }
  247. static int lockd_start_svc(struct svc_serv *serv)
  248. {
  249. int error;
  250. if (nlmsvc_rqst)
  251. return 0;
  252. /*
  253. * Create the kernel thread and wait for it to start.
  254. */
  255. nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
  256. if (IS_ERR(nlmsvc_rqst)) {
  257. error = PTR_ERR(nlmsvc_rqst);
  258. printk(KERN_WARNING
  259. "lockd_up: svc_rqst allocation failed, error=%d\n",
  260. error);
  261. goto out_rqst;
  262. }
  263. svc_sock_update_bufs(serv);
  264. serv->sv_maxconn = nlm_max_connections;
  265. nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, serv->sv_name);
  266. if (IS_ERR(nlmsvc_task)) {
  267. error = PTR_ERR(nlmsvc_task);
  268. printk(KERN_WARNING
  269. "lockd_up: kthread_run failed, error=%d\n", error);
  270. goto out_task;
  271. }
  272. dprintk("lockd_up: service started\n");
  273. return 0;
  274. out_task:
  275. svc_exit_thread(nlmsvc_rqst);
  276. nlmsvc_task = NULL;
  277. out_rqst:
  278. nlmsvc_rqst = NULL;
  279. return error;
  280. }
  281. static struct svc_serv *lockd_create_svc(void)
  282. {
  283. struct svc_serv *serv;
  284. /*
  285. * Check whether we're already up and running.
  286. */
  287. if (nlmsvc_rqst) {
  288. /*
  289. * Note: increase service usage, because later in case of error
  290. * svc_destroy() will be called.
  291. */
  292. svc_get(nlmsvc_rqst->rq_server);
  293. return nlmsvc_rqst->rq_server;
  294. }
  295. /*
  296. * Sanity check: if there's no pid,
  297. * we should be the first user ...
  298. */
  299. if (nlmsvc_users)
  300. printk(KERN_WARNING
  301. "lockd_up: no pid, %d users??\n", nlmsvc_users);
  302. serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, NULL);
  303. if (!serv) {
  304. printk(KERN_WARNING "lockd_up: create service failed\n");
  305. return ERR_PTR(-ENOMEM);
  306. }
  307. dprintk("lockd_up: service created\n");
  308. return serv;
  309. }
  310. /*
  311. * Bring up the lockd process if it's not already up.
  312. */
  313. int lockd_up(struct net *net)
  314. {
  315. struct svc_serv *serv;
  316. int error;
  317. mutex_lock(&nlmsvc_mutex);
  318. serv = lockd_create_svc();
  319. if (IS_ERR(serv)) {
  320. error = PTR_ERR(serv);
  321. goto err_create;
  322. }
  323. error = lockd_up_net(serv, net);
  324. if (error < 0)
  325. goto err_net;
  326. error = lockd_start_svc(serv);
  327. if (error < 0)
  328. goto err_start;
  329. nlmsvc_users++;
  330. /*
  331. * Note: svc_serv structures have an initial use count of 1,
  332. * so we exit through here on both success and failure.
  333. */
  334. err_net:
  335. svc_destroy(serv);
  336. err_create:
  337. mutex_unlock(&nlmsvc_mutex);
  338. return error;
  339. err_start:
  340. lockd_down_net(serv, net);
  341. goto err_net;
  342. }
  343. EXPORT_SYMBOL_GPL(lockd_up);
  344. /*
  345. * Decrement the user count and bring down lockd if we're the last.
  346. */
  347. void
  348. lockd_down(struct net *net)
  349. {
  350. mutex_lock(&nlmsvc_mutex);
  351. lockd_down_net(nlmsvc_rqst->rq_server, net);
  352. if (nlmsvc_users) {
  353. if (--nlmsvc_users)
  354. goto out;
  355. } else {
  356. printk(KERN_ERR "lockd_down: no users! task=%p\n",
  357. nlmsvc_task);
  358. BUG();
  359. }
  360. if (!nlmsvc_task) {
  361. printk(KERN_ERR "lockd_down: no lockd running.\n");
  362. BUG();
  363. }
  364. kthread_stop(nlmsvc_task);
  365. dprintk("lockd_down: service stopped\n");
  366. svc_exit_thread(nlmsvc_rqst);
  367. dprintk("lockd_down: service destroyed\n");
  368. nlmsvc_task = NULL;
  369. nlmsvc_rqst = NULL;
  370. out:
  371. mutex_unlock(&nlmsvc_mutex);
  372. }
  373. EXPORT_SYMBOL_GPL(lockd_down);
  374. #ifdef CONFIG_SYSCTL
  375. /*
  376. * Sysctl parameters (same as module parameters, different interface).
  377. */
  378. static ctl_table nlm_sysctls[] = {
  379. {
  380. .procname = "nlm_grace_period",
  381. .data = &nlm_grace_period,
  382. .maxlen = sizeof(unsigned long),
  383. .mode = 0644,
  384. .proc_handler = proc_doulongvec_minmax,
  385. .extra1 = (unsigned long *) &nlm_grace_period_min,
  386. .extra2 = (unsigned long *) &nlm_grace_period_max,
  387. },
  388. {
  389. .procname = "nlm_timeout",
  390. .data = &nlm_timeout,
  391. .maxlen = sizeof(unsigned long),
  392. .mode = 0644,
  393. .proc_handler = proc_doulongvec_minmax,
  394. .extra1 = (unsigned long *) &nlm_timeout_min,
  395. .extra2 = (unsigned long *) &nlm_timeout_max,
  396. },
  397. {
  398. .procname = "nlm_udpport",
  399. .data = &nlm_udpport,
  400. .maxlen = sizeof(int),
  401. .mode = 0644,
  402. .proc_handler = proc_dointvec_minmax,
  403. .extra1 = (int *) &nlm_port_min,
  404. .extra2 = (int *) &nlm_port_max,
  405. },
  406. {
  407. .procname = "nlm_tcpport",
  408. .data = &nlm_tcpport,
  409. .maxlen = sizeof(int),
  410. .mode = 0644,
  411. .proc_handler = proc_dointvec_minmax,
  412. .extra1 = (int *) &nlm_port_min,
  413. .extra2 = (int *) &nlm_port_max,
  414. },
  415. {
  416. .procname = "nsm_use_hostnames",
  417. .data = &nsm_use_hostnames,
  418. .maxlen = sizeof(int),
  419. .mode = 0644,
  420. .proc_handler = proc_dointvec,
  421. },
  422. {
  423. .procname = "nsm_local_state",
  424. .data = &nsm_local_state,
  425. .maxlen = sizeof(int),
  426. .mode = 0644,
  427. .proc_handler = proc_dointvec,
  428. },
  429. { }
  430. };
  431. static ctl_table nlm_sysctl_dir[] = {
  432. {
  433. .procname = "nfs",
  434. .mode = 0555,
  435. .child = nlm_sysctls,
  436. },
  437. { }
  438. };
  439. static ctl_table nlm_sysctl_root[] = {
  440. {
  441. .procname = "fs",
  442. .mode = 0555,
  443. .child = nlm_sysctl_dir,
  444. },
  445. { }
  446. };
  447. #endif /* CONFIG_SYSCTL */
  448. /*
  449. * Module (and sysfs) parameters.
  450. */
  451. #define param_set_min_max(name, type, which_strtol, min, max) \
  452. static int param_set_##name(const char *val, struct kernel_param *kp) \
  453. { \
  454. char *endp; \
  455. __typeof__(type) num = which_strtol(val, &endp, 0); \
  456. if (endp == val || *endp || num < (min) || num > (max)) \
  457. return -EINVAL; \
  458. *((type *) kp->arg) = num; \
  459. return 0; \
  460. }
  461. static inline int is_callback(u32 proc)
  462. {
  463. return proc == NLMPROC_GRANTED
  464. || proc == NLMPROC_GRANTED_MSG
  465. || proc == NLMPROC_TEST_RES
  466. || proc == NLMPROC_LOCK_RES
  467. || proc == NLMPROC_CANCEL_RES
  468. || proc == NLMPROC_UNLOCK_RES
  469. || proc == NLMPROC_NSM_NOTIFY;
  470. }
  471. static int lockd_authenticate(struct svc_rqst *rqstp)
  472. {
  473. rqstp->rq_client = NULL;
  474. switch (rqstp->rq_authop->flavour) {
  475. case RPC_AUTH_NULL:
  476. case RPC_AUTH_UNIX:
  477. if (rqstp->rq_proc == 0)
  478. return SVC_OK;
  479. if (is_callback(rqstp->rq_proc)) {
  480. /* Leave it to individual procedures to
  481. * call nlmsvc_lookup_host(rqstp)
  482. */
  483. return SVC_OK;
  484. }
  485. return svc_set_client(rqstp);
  486. }
  487. return SVC_DENIED;
  488. }
  489. param_set_min_max(port, int, simple_strtol, 0, 65535)
  490. param_set_min_max(grace_period, unsigned long, simple_strtoul,
  491. nlm_grace_period_min, nlm_grace_period_max)
  492. param_set_min_max(timeout, unsigned long, simple_strtoul,
  493. nlm_timeout_min, nlm_timeout_max)
  494. MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
  495. MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
  496. MODULE_LICENSE("GPL");
  497. module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
  498. &nlm_grace_period, 0644);
  499. module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
  500. &nlm_timeout, 0644);
  501. module_param_call(nlm_udpport, param_set_port, param_get_int,
  502. &nlm_udpport, 0644);
  503. module_param_call(nlm_tcpport, param_set_port, param_get_int,
  504. &nlm_tcpport, 0644);
  505. module_param(nsm_use_hostnames, bool, 0644);
  506. module_param(nlm_max_connections, uint, 0644);
  507. static int lockd_init_net(struct net *net)
  508. {
  509. struct lockd_net *ln = net_generic(net, lockd_net_id);
  510. INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
  511. return 0;
  512. }
  513. static void lockd_exit_net(struct net *net)
  514. {
  515. }
  516. static struct pernet_operations lockd_net_ops = {
  517. .init = lockd_init_net,
  518. .exit = lockd_exit_net,
  519. .id = &lockd_net_id,
  520. .size = sizeof(struct lockd_net),
  521. };
  522. /*
  523. * Initialising and terminating the module.
  524. */
  525. static int __init init_nlm(void)
  526. {
  527. int err;
  528. #ifdef CONFIG_SYSCTL
  529. err = -ENOMEM;
  530. nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
  531. if (nlm_sysctl_table == NULL)
  532. goto err_sysctl;
  533. #endif
  534. err = register_pernet_subsys(&lockd_net_ops);
  535. if (err)
  536. goto err_pernet;
  537. return 0;
  538. err_pernet:
  539. #ifdef CONFIG_SYSCTL
  540. unregister_sysctl_table(nlm_sysctl_table);
  541. #endif
  542. err_sysctl:
  543. return err;
  544. }
  545. static void __exit exit_nlm(void)
  546. {
  547. /* FIXME: delete all NLM clients */
  548. nlm_shutdown_hosts();
  549. unregister_pernet_subsys(&lockd_net_ops);
  550. #ifdef CONFIG_SYSCTL
  551. unregister_sysctl_table(nlm_sysctl_table);
  552. #endif
  553. }
  554. module_init(init_nlm);
  555. module_exit(exit_nlm);
  556. /*
  557. * Define NLM program and procedures
  558. */
  559. static struct svc_version nlmsvc_version1 = {
  560. .vs_vers = 1,
  561. .vs_nproc = 17,
  562. .vs_proc = nlmsvc_procedures,
  563. .vs_xdrsize = NLMSVC_XDRSIZE,
  564. };
  565. static struct svc_version nlmsvc_version3 = {
  566. .vs_vers = 3,
  567. .vs_nproc = 24,
  568. .vs_proc = nlmsvc_procedures,
  569. .vs_xdrsize = NLMSVC_XDRSIZE,
  570. };
  571. #ifdef CONFIG_LOCKD_V4
  572. static struct svc_version nlmsvc_version4 = {
  573. .vs_vers = 4,
  574. .vs_nproc = 24,
  575. .vs_proc = nlmsvc_procedures4,
  576. .vs_xdrsize = NLMSVC_XDRSIZE,
  577. };
  578. #endif
  579. static struct svc_version * nlmsvc_version[] = {
  580. [1] = &nlmsvc_version1,
  581. [3] = &nlmsvc_version3,
  582. #ifdef CONFIG_LOCKD_V4
  583. [4] = &nlmsvc_version4,
  584. #endif
  585. };
  586. static struct svc_stat nlmsvc_stats;
  587. #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
  588. static struct svc_program nlmsvc_program = {
  589. .pg_prog = NLM_PROGRAM, /* program number */
  590. .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */
  591. .pg_vers = nlmsvc_version, /* version table */
  592. .pg_name = "lockd", /* service name */
  593. .pg_class = "nfsd", /* share authentication with nfsd */
  594. .pg_stats = &nlmsvc_stats, /* stats table */
  595. .pg_authenticate = &lockd_authenticate /* export authentication */
  596. };