1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 * Copyright (c) 2012 by Delphix. All rights reserved.
26 */
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31 /*
32 * University Copyright- Copyright (c) 1982, 1986, 1988
33 * The Regents of the University of California
34 * All Rights Reserved
35 *
36 * University Acknowledgment- Portions of this document are derived from
37 * software developed by the University of California, Berkeley, and its
38 * contributors.
39 */
40
41 /* LINTLIBRARY */
42 /* PROTOLIB1 */
43
44 /*
45 * NLM server
46 *
47 * Most of this copied from ../nfsd/nfsd.c
48 * and then s:NFS:NLM: applied, etc.
49 */
50
51 #include <sys/param.h>
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <syslog.h>
55 #include <tiuser.h>
56 #include <rpc/rpc.h>
57 #include <errno.h>
58 #include <thread.h>
59 #include <sys/time.h>
60 #include <sys/file.h>
61 #include <nfs/nfs.h>
62 #include <nfs/nfssys.h>
63 #include <stdio.h>
64 #include <stdio_ext.h>
65 #include <stdlib.h>
66 #include <signal.h>
67 #include <netconfig.h>
68 #include <netdir.h>
69 #include <string.h>
70 #include <unistd.h>
71 #include <stropts.h>
72 #include <sys/tihdr.h>
73 #include <poll.h>
74 #include <priv_utils.h>
75 #include <sys/tiuser.h>
76 #include <netinet/tcp.h>
77 #include <deflt.h>
78 #include <rpcsvc/daemon_utils.h>
79 #include <rpcsvc/nlm_prot.h>
80 #include <libintl.h>
81 #include <libscf.h>
82 #include <libshare.h>
83 #include "nfs_tbind.h"
84 #include "thrpool.h"
85 #include "smfcfg.h"
86
87 /* Option defaults. See nfssys.h */
88 struct lm_svc_args lmargs = {
89 .version = LM_SVC_CUR_VERS,
90 /* fd, n_fmly, n_proto, n_rdev (below) */
91 .debug = 0,
92 .timout = 5 * 60,
93 .grace = 60,
94 .retransmittimeout = 15
95 };
96 int max_servers = 20;
97
98
99 #define RET_OK 0 /* return code for no error */
100 #define RET_ERR 33 /* return code for error(s) */
101
102 static int nlmsvc(int fd, struct netbuf addrmask,
103 struct netconfig *nconf);
104 static int nlmsvcpool(int max_servers);
105 static void usage(void);
106
107 extern int _nfssys(int, void *);
108 static void sigterm_handler(void);
109 static void shutdown_lockd(void);
110
111 extern int daemonize_init(void);
112 extern void daemonize_fini(int fd);
113
114 static char *MyName;
115
116 /*
117 * We want to bind to these TLI providers, and in this order,
118 * because the kernel NLM needs the loopback first for its
119 * initialization. (It uses it to talk to statd.)
120 */
121 static NETSELDECL(defaultproviders)[] = {
122 "/dev/ticotsord",
123 "/dev/tcp",
124 "/dev/udp",
125 "/dev/tcp6",
126 "/dev/udp6",
127 NULL
128 };
129
130 /*
131 * The following are all globals used by routines in nfs_tbind.c.
132 */
133 size_t end_listen_fds; /* used by conn_close_oldest() */
134 size_t num_fds = 0; /* used by multiple routines */
135 int listen_backlog = 32; /* used by bind_to_{provider,proto}() */
136 int (*Mysvc)(int, struct netbuf, struct netconfig *) = nlmsvc;
137 /* used by cots_listen_event() */
138 int max_conns_allowed = -1; /* used by cots_listen_event() */
139
140 int
141 main(int ac, char *av[])
142 {
143 char *propname = NULL;
144 char *dir = "/";
145 char *provider = (char *)NULL;
146 struct protob *protobp;
147 NETSELPDECL(providerp);
148 sigset_t sgset;
149 int i, c, pid, ret, val;
150 int pipe_fd = -1;
151 struct sigaction act;
152
153 MyName = *av;
154
155 /*
156 * Initializations that require more privileges than we need to run.
157 */
158 (void) _create_daemon_lock(LOCKD, DAEMON_UID, DAEMON_GID);
159 svcsetprio();
160
161 if (__init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET,
162 DAEMON_UID, DAEMON_GID, PRIV_SYS_NFS, NULL) == -1) {
163 (void) fprintf(stderr, "%s should be run with"
164 " sufficient privileges\n", av[0]);
165 exit(1);
166 }
167
168 (void) enable_extended_FILE_stdio(-1, -1);
169
170 /*
171 * Read in the values from SMF first before we check
172 * command line options so the options override SMF values.
173 */
174
175 /* How long to keep idle connections. */
176 propname = "conn_idle_timeout"; /* also -t */
177 ret = nfs_smf_get_iprop(propname, &val,
178 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
179 if (ret == SA_OK) {
180 if (val <= 0)
181 fprintf(stderr, gettext(
182 "Invalid %s from SMF"), propname);
183 else
184 lmargs.timout = val;
185 }
186
187 /* Note: debug_level can only be set by args. */
188
189 /* How long to wait for clients to re-establish locks. */
190 propname = "grace_period"; /* also -g */
191 ret = nfs_smf_get_iprop(propname, &val,
192 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
193 if (ret == SA_OK) {
194 if (val <= 0)
195 fprintf(stderr, gettext(
196 "Invalid %s from SMF"), propname);
197 else
198 lmargs.grace = val;
199 }
200
201 propname = "listen_backlog"; /* also -l */
202 ret = nfs_smf_get_iprop(propname, &val,
203 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
204 if (ret == SA_OK) {
205 if (val <= 0)
206 fprintf(stderr, gettext(
207 "Invalid %s from SMF"), propname);
208 else
209 listen_backlog = val;
210 }
211
212 propname = "max_connections"; /* also -c */
213 ret = nfs_smf_get_iprop(propname, &val,
214 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
215 if (ret == SA_OK) {
216 if (val <= 0)
217 fprintf(stderr, gettext(
218 "Invalid %s from SMF"), propname);
219 else
220 max_conns_allowed = val;
221 }
222
223 propname = "max_servers"; /* also argv[1] */
224 ret = nfs_smf_get_iprop(propname, &val,
225 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
226 if (ret == SA_OK) {
227 if (val <= 0)
228 fprintf(stderr, gettext(
229 "Invalid %s from SMF"), propname);
230 else
231 max_servers = val;
232 }
233
234 propname = "retrans_timeout"; /* also -r */
235 ret = nfs_smf_get_iprop(propname, &val,
236 DEFAULT_INSTANCE, SCF_TYPE_INTEGER, LOCKD);
237 if (ret == SA_OK) {
238 if (val <= 0)
239 fprintf(stderr, gettext(
240 "Invalid %s from SMF"), propname);
241 else
242 lmargs.retransmittimeout = val;
243 }
244
245
246 while ((c = getopt(ac, av, "c:d:g:l:r:t:")) != EOF)
247 switch (c) {
248 case 'c': /* max_connections */
249 if ((val = atoi(optarg)) <= 0)
250 goto badval;
251 max_conns_allowed = val;
252 break;
253
254 case 'd': /* debug */
255 lmargs.debug = atoi(optarg);
256 break;
257
258 case 'g': /* grace_period */
259 if ((val = atoi(optarg)) <= 0)
260 goto badval;
261 lmargs.grace = val;
262 break;
263
264 case 'l': /* listen_backlog */
265 if ((val = atoi(optarg)) <= 0)
266 goto badval;
267 listen_backlog = val;
268 break;
269
270 case 'r': /* retrans_timeout */
271 if ((val = atoi(optarg)) <= 0)
272 goto badval;
273 lmargs.retransmittimeout = val;
274 break;
275
276 case 't': /* conn_idle_timeout */
277 if ((val = atoi(optarg)) <= 0)
278 goto badval;
279 lmargs.timout = val;
280 break;
281
282 badval:
283 fprintf(stderr, gettext(
284 "Invalid -%c option value"), c);
285 /* FALLTHROUGH */
286 default:
287 usage();
288 /* NOTREACHED */
289 }
290
291 /*
292 * If there is exactly one more argument, it is the number of
293 * servers.
294 */
295 if (optind < ac) {
296 val = atoi(av[optind]);
297 if (val <= 0) {
298 fprintf(stderr, gettext(
299 "Invalid max_servers argument"));
300 usage();
301 }
302 max_servers = val;
303 optind++;
304 }
305 /*
306 * If there are two or more arguments, then this is a usage error.
307 */
308 if (optind != ac)
309 usage();
310
311 if (lmargs.debug) {
312 printf("%s: debug= %d, conn_idle_timout= %d,"
313 " grace_period= %d, listen_backlog= %d,"
314 " max_connections= %d, max_servers= %d,"
315 " retrans_timeout= %d\n",
316 MyName, lmargs.debug, lmargs.timout,
317 lmargs.grace, listen_backlog,
318 max_conns_allowed, max_servers,
319 lmargs.retransmittimeout);
320 }
321
322 /*
323 * Set current dir to server root
324 */
325 if (chdir(dir) < 0) {
326 (void) fprintf(stderr, "%s: ", MyName);
327 perror(dir);
328 exit(1);
329 }
330
331 /* Daemonize, if not debug. */
332 if (lmargs.debug == 0)
333 pipe_fd = daemonize_init();
334
335 openlog(MyName, LOG_PID | LOG_NDELAY, LOG_DAEMON);
336
337 /*
338 * establish our lock on the lock file and write our pid to it.
339 * exit if some other process holds the lock, or if there's any
340 * error in writing/locking the file.
341 */
342 pid = _enter_daemon_lock(LOCKD);
343 switch (pid) {
344 case 0:
345 break;
346 case -1:
347 fprintf(stderr, "error locking for %s: %s", LOCKD,
348 strerror(errno));
349 exit(2);
350 default:
351 /* daemon was already running */
352 exit(0);
353 }
354
355 /*
356 * Block all signals till we spawn other
357 * threads.
358 */
359 (void) sigfillset(&sgset);
360 (void) thr_sigsetmask(SIG_BLOCK, &sgset, NULL);
361
362 /* Unregister any previous versions. */
363 for (i = NLM_VERS; i < NLM4_VERS; i++) {
364 svc_unreg(NLM_PROG, i);
365 }
366
367 /*
368 * Set up kernel RPC thread pool for the NLM server.
369 */
370 if (nlmsvcpool(max_servers)) {
371 fprintf(stderr, "Can't set up kernel NLM service: %s. Exiting",
372 strerror(errno));
373 exit(1);
374 }
375
376 /*
377 * Set up blocked thread to do LWP creation on behalf of the kernel.
378 */
379 if (svcwait(NLM_SVCPOOL_ID)) {
380 fprintf(stderr, "Can't set up NLM pool creator: %s. Exiting",
381 strerror(errno));
382 exit(1);
383 }
384
385 /*
386 * Install atexit and sigterm handlers
387 */
388 act.sa_handler = sigterm_handler;
389 act.sa_flags = 0;
390
391 (void) sigaction(SIGTERM, &act, NULL);
392 (void) atexit(shutdown_lockd);
393
394 /*
395 * Now open up for signal delivery
396 */
397 (void) thr_sigsetmask(SIG_UNBLOCK, &sgset, NULL);
398
399 /*
400 * Build a protocol block list for registration.
401 */
402 protobp = (struct protob *)malloc(sizeof (struct protob));
403 protobp->serv = "NLM";
404 protobp->versmin = NLM_VERS;
405 protobp->versmax = NLM4_VERS;
406 protobp->program = NLM_PROG;
407 protobp->next = (struct protob *)NULL;
408
409 for (providerp = defaultproviders;
410 *providerp != NULL; providerp++) {
411 provider = *providerp;
412 do_one(provider, NULL, protobp, nlmsvc);
413 }
414
415 free(protobp);
416
417 if (num_fds == 0) {
418 fprintf(stderr, "Could not start NLM service for any protocol."
419 " Exiting");
420 exit(1);
421 }
422
423 end_listen_fds = num_fds;
424
425 /*
426 * lockd is up and running as far as we are concerned.
427 */
428 if (lmargs.debug == 0)
429 daemonize_fini(pipe_fd);
430
431 /*
432 * Get rid of unneeded privileges.
433 */
434 __fini_daemon_priv(PRIV_PROC_FORK, PRIV_PROC_EXEC, PRIV_PROC_SESSION,
435 PRIV_FILE_LINK_ANY, PRIV_PROC_INFO, (char *)NULL);
436
437 /*
438 * Poll for non-data control events on the transport descriptors.
439 */
440 poll_for_action();
441
442 /*
443 * If we get here, something failed in poll_for_action().
444 */
445 return (1);
446 }
447
448 static int
449 nlmsvcpool(int maxservers)
450 {
451 struct svcpool_args npa;
452
453 npa.id = NLM_SVCPOOL_ID;
454 npa.maxthreads = maxservers;
455 npa.redline = 0;
456 npa.qsize = 0;
457 npa.timeout = 0;
458 npa.stksize = 0;
459 npa.max_same_xprt = 0;
460 return (_nfssys(SVCPOOL_CREATE, &npa));
461 }
462
463 static int
464 ncfmly_to_lmfmly(const char *ncfmly)
465 {
466 if (0 == strcmp(ncfmly, NC_INET))
467 return (LM_INET);
468 if (0 == strcmp(ncfmly, NC_INET6))
469 return (LM_INET6);
470 if (0 == strcmp(ncfmly, NC_LOOPBACK))
471 return (LM_LOOPBACK);
472 return (-1);
473 }
474
475 static int
476 nctype_to_lmprot(uint_t semantics)
477 {
478 switch (semantics) {
479 case NC_TPI_CLTS:
480 return (LM_UDP);
481 case NC_TPI_COTS_ORD:
482 return (LM_TCP);
483 }
484 return (-1);
485 }
486
487 static dev_t
488 ncdev_to_rdev(const char *ncdev)
489 {
490 struct stat st;
491
492 if (stat(ncdev, &st) < 0)
493 return (NODEV);
494 return (st.st_rdev);
495 }
496
497 static void
498 sigterm_handler(void)
499 {
500 /* to call atexit handler */
501 exit(0);
502 }
503
504 static void
505 shutdown_lockd(void)
506 {
507 (void) _nfssys(KILL_LOCKMGR, NULL);
508 }
509
510
511 /*
512 * Establish NLM service thread.
513 */
514 static int
515 nlmsvc(int fd, struct netbuf addrmask, struct netconfig *nconf)
516 {
517 struct lm_svc_args lma;
518
519 lma = lmargs; /* init by struct copy */
520
521 /*
522 * The kernel code needs to reconstruct a complete
523 * knetconfig from n_fmly, n_proto. We use these
524 * two fields to convey the family and semantics.
525 */
526 lma.fd = fd;
527 lma.n_fmly = ncfmly_to_lmfmly(nconf->nc_protofmly);
528 lma.n_proto = nctype_to_lmprot(nconf->nc_semantics);
529 lma.n_rdev = ncdev_to_rdev(nconf->nc_device);
530
531 return (_nfssys(LM_SVC, &lma));
532 }
533
534 static void
535 usage(void)
536 {
537 (void) fprintf(stderr, gettext(
538 "usage: %s [options] [max_servers]\n"), MyName);
539 (void) fprintf(stderr, gettext(
540 "options: (see SMF property descriptions)\n"));
541 /* Note: don't translate these */
542 (void) fprintf(stderr, "\t-c max_connections\n");
543 (void) fprintf(stderr, "\t-d debug_level\n");
544 (void) fprintf(stderr, "\t-g grace_period\n");
545 (void) fprintf(stderr, "\t-l listen_backlog\n");
546 (void) fprintf(stderr, "\t-r retrans_timeout\n");
547 (void) fprintf(stderr, "\t-t conn_idle_timeout\n");
548
549 exit(1);
550 }