xref: /freebsd/usr.sbin/nfsd/nfsd.c (revision 952364486a4b9d135e4b28f7f88a8703a74eae6f)
1 /*
2  * Copyright (c) 1989, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Rick Macklem at The University of Guelph.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #ifndef lint
34 static const char copyright[] =
35 "@(#) Copyright (c) 1989, 1993, 1994\n\
36 	The Regents of the University of California.  All rights reserved.\n";
37 #endif /* not lint */
38 
39 #ifndef lint
40 #if 0
41 static char sccsid[] = "@(#)nfsd.c	8.9 (Berkeley) 3/29/95";
42 #endif
43 static const char rcsid[] =
44   "$FreeBSD$";
45 #endif /* not lint */
46 
47 #include <sys/param.h>
48 #include <sys/syslog.h>
49 #include <sys/wait.h>
50 #include <sys/mount.h>
51 #include <sys/fcntl.h>
52 #include <sys/linker.h>
53 #include <sys/module.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
56 #include <sys/sysctl.h>
57 #include <sys/ucred.h>
58 
59 #include <rpc/rpc.h>
60 #include <rpc/pmap_clnt.h>
61 #include <rpcsvc/nfs_prot.h>
62 
63 #include <netdb.h>
64 #include <arpa/inet.h>
65 #include <nfsserver/nfs.h>
66 #include <nfs/nfssvc.h>
67 
68 #include <err.h>
69 #include <errno.h>
70 #include <signal.h>
71 #include <stdio.h>
72 #include <stdlib.h>
73 #include <string.h>
74 #include <unistd.h>
75 #include <sysexits.h>
76 
77 #include <getopt.h>
78 
79 static int	debug = 0;
80 
81 #define	NFSD_STABLERESTART	"/var/db/nfs-stablerestart"
82 #define	NFSD_STABLEBACKUP	"/var/db/nfs-stablerestart.bak"
83 #define	MAXNFSDCNT	256
84 #define	DEFNFSDCNT	 4
85 static pid_t children[MAXNFSDCNT]; /* PIDs of children */
86 static int nfsdcnt;		/* number of children */
87 static int nfsdcnt_set;
88 static int minthreads;
89 static int maxthreads;
90 static int new_syscall;
91 static int run_v4server = 1;	/* Force running of nfsv4 server */
92 static int nfssvc_nfsd;		/* Set to correct NFSSVC_xxx flag */
93 static int stablefd = -1;	/* Fd for the stable restart file */
94 static int backupfd;		/* Fd for the backup stable restart file */
95 static const char *getopt_shortopts;
96 static const char *getopt_usage;
97 
98 static int minthreads_set;
99 static int maxthreads_set;
100 
101 static struct option longopts[] = {
102 	{ "debug", no_argument, &debug, 1 },
103 	{ "minthreads", required_argument, &minthreads_set, 1 },
104 	{ "maxthreads", required_argument, &maxthreads_set, 1 },
105 	{ NULL, 0, NULL, 0}
106 };
107 
108 static void	cleanup(int);
109 static void	child_cleanup(int);
110 static void	killchildren(void);
111 static void	nfsd_exit(int);
112 static void	nonfs(int);
113 static void	reapchild(int);
114 static int	setbindhost(struct addrinfo **ia, const char *bindhost,
115 		    struct addrinfo hints);
116 static void	start_server(int);
117 static void	unregistration(void);
118 static void	usage(void);
119 static void	open_stable(int *, int *);
120 static void	copy_stable(int, int);
121 static void	backup_stable(int);
122 static void	set_nfsdcnt(int);
123 
124 /*
125  * Nfs server daemon mostly just a user context for nfssvc()
126  *
127  * 1 - do file descriptor and signal cleanup
128  * 2 - fork the nfsd(s)
129  * 3 - create server socket(s)
130  * 4 - register socket with rpcbind
131  *
132  * For connectionless protocols, just pass the socket into the kernel via.
133  * nfssvc().
134  * For connection based sockets, loop doing accepts. When you get a new
135  * socket from accept, pass the msgsock into the kernel via. nfssvc().
136  * The arguments are:
137  *	-r - reregister with rpcbind
138  *	-d - unregister with rpcbind
139  *	-t - support tcp nfs clients
140  *	-u - support udp nfs clients
141  *	-e - forces it to run a server that supports nfsv4
142  * followed by "n" which is the number of nfsds' to fork off
143  */
144 int
145 main(int argc, char **argv)
146 {
147 	struct nfsd_addsock_args addsockargs;
148 	struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints;
149 	struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6;
150 	struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6;
151 	struct sockaddr_in inetpeer;
152 	struct sockaddr_in6 inet6peer;
153 	fd_set ready, sockbits;
154 	fd_set v4bits, v6bits;
155 	int ch, connect_type_cnt, i, maxsock, msgsock;
156 	socklen_t len;
157 	int on = 1, unregister, reregister, sock;
158 	int tcp6sock, ip6flag, tcpflag, tcpsock;
159 	int udpflag, ecode, error, s, srvcnt;
160 	int bindhostc, bindanyflag, rpcbreg, rpcbregcnt;
161 	int nfssvc_addsock;
162 	int longindex = 0;
163 	const char *lopt;
164 	char **bindhost = NULL;
165 	pid_t pid;
166 
167 	nfsdcnt = DEFNFSDCNT;
168 	unregister = reregister = tcpflag = maxsock = 0;
169 	bindanyflag = udpflag = connect_type_cnt = bindhostc = 0;
170 	getopt_shortopts = "ah:n:rdtueo";
171 	getopt_usage =
172 	    "usage:\n"
173 	    "  nfsd [-ardtueo] [-h bindip]\n"
174 	    "       [-n numservers] [--minthreads #] [--maxthreads #]\n";
175 	while ((ch = getopt_long(argc, argv, getopt_shortopts, longopts,
176 		    &longindex)) != -1)
177 		switch (ch) {
178 		case 'a':
179 			bindanyflag = 1;
180 			break;
181 		case 'n':
182 			set_nfsdcnt(atoi(optarg));
183 			break;
184 		case 'h':
185 			bindhostc++;
186 			bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
187 			if (bindhost == NULL)
188 				errx(1, "Out of memory");
189 			bindhost[bindhostc-1] = strdup(optarg);
190 			if (bindhost[bindhostc-1] == NULL)
191 				errx(1, "Out of memory");
192 			break;
193 		case 'r':
194 			reregister = 1;
195 			break;
196 		case 'd':
197 			unregister = 1;
198 			break;
199 		case 't':
200 			tcpflag = 1;
201 			break;
202 		case 'u':
203 			udpflag = 1;
204 			break;
205 		case 'e':
206 			/* now a no-op, since this is the default */
207 			break;
208 		case 'o':
209 			run_v4server = 0;
210 			break;
211 		case 0:
212 			lopt = longopts[longindex].name;
213 			if (!strcmp(lopt, "minthreads")) {
214 				minthreads = atoi(optarg);
215 			} else if (!strcmp(lopt, "maxthreads")) {
216 				maxthreads = atoi(optarg);
217 			}
218 			break;
219 		default:
220 		case '?':
221 			usage();
222 		};
223 	if (!tcpflag && !udpflag)
224 		udpflag = 1;
225 	argv += optind;
226 	argc -= optind;
227 	if (minthreads_set && maxthreads_set && minthreads > maxthreads)
228 		errx(EX_USAGE,
229 		    "error: minthreads(%d) can't be greater than "
230 		    "maxthreads(%d)", minthreads, maxthreads);
231 
232 	/*
233 	 * XXX
234 	 * Backward compatibility, trailing number is the count of daemons.
235 	 */
236 	if (argc > 1)
237 		usage();
238 	if (argc == 1)
239 		set_nfsdcnt(atoi(argv[0]));
240 
241 	/*
242 	 * Unless the "-o" option was specified, try and run "nfsd".
243 	 * If "-o" was specified, try and run "nfsserver".
244 	 */
245 	if (run_v4server > 0) {
246 		if (modfind("nfsd") < 0) {
247 			/* Not present in kernel, try loading it */
248 			if (kldload("nfsd") < 0 || modfind("nfsd") < 0)
249 				errx(1, "NFS server is not available");
250 		}
251 	} else if (modfind("nfsserver") < 0) {
252 		/* Not present in kernel, try loading it */
253 		if (kldload("nfsserver") < 0 || modfind("nfsserver") < 0)
254 			errx(1, "NFS server is not available");
255 	}
256 
257 	ip6flag = 1;
258 	s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
259 	if (s == -1) {
260 		if (errno != EPROTONOSUPPORT && errno != EAFNOSUPPORT)
261 			err(1, "socket");
262 		ip6flag = 0;
263 	} else if (getnetconfigent("udp6") == NULL ||
264 		getnetconfigent("tcp6") == NULL) {
265 		ip6flag = 0;
266 	}
267 	if (s != -1)
268 		close(s);
269 
270 	if (bindhostc == 0 || bindanyflag) {
271 		bindhostc++;
272 		bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
273 		if (bindhost == NULL)
274 			errx(1, "Out of memory");
275 		bindhost[bindhostc-1] = strdup("*");
276 		if (bindhost[bindhostc-1] == NULL)
277 			errx(1, "Out of memory");
278 	}
279 
280 	if (unregister) {
281 		unregistration();
282 		exit (0);
283 	}
284 	if (reregister) {
285 		if (udpflag) {
286 			memset(&hints, 0, sizeof hints);
287 			hints.ai_flags = AI_PASSIVE;
288 			hints.ai_family = AF_INET;
289 			hints.ai_socktype = SOCK_DGRAM;
290 			hints.ai_protocol = IPPROTO_UDP;
291 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
292 			if (ecode != 0)
293 				err(1, "getaddrinfo udp: %s", gai_strerror(ecode));
294 			nconf_udp = getnetconfigent("udp");
295 			if (nconf_udp == NULL)
296 				err(1, "getnetconfigent udp failed");
297 			nb_udp.buf = ai_udp->ai_addr;
298 			nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
299 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
300 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, &nb_udp)))
301 				err(1, "rpcb_set udp failed");
302 			freeaddrinfo(ai_udp);
303 		}
304 		if (udpflag && ip6flag) {
305 			memset(&hints, 0, sizeof hints);
306 			hints.ai_flags = AI_PASSIVE;
307 			hints.ai_family = AF_INET6;
308 			hints.ai_socktype = SOCK_DGRAM;
309 			hints.ai_protocol = IPPROTO_UDP;
310 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
311 			if (ecode != 0)
312 				err(1, "getaddrinfo udp6: %s", gai_strerror(ecode));
313 			nconf_udp6 = getnetconfigent("udp6");
314 			if (nconf_udp6 == NULL)
315 				err(1, "getnetconfigent udp6 failed");
316 			nb_udp6.buf = ai_udp6->ai_addr;
317 			nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
318 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
319 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, &nb_udp6)))
320 				err(1, "rpcb_set udp6 failed");
321 			freeaddrinfo(ai_udp6);
322 		}
323 		if (tcpflag) {
324 			memset(&hints, 0, sizeof hints);
325 			hints.ai_flags = AI_PASSIVE;
326 			hints.ai_family = AF_INET;
327 			hints.ai_socktype = SOCK_STREAM;
328 			hints.ai_protocol = IPPROTO_TCP;
329 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp);
330 			if (ecode != 0)
331 				err(1, "getaddrinfo tcp: %s", gai_strerror(ecode));
332 			nconf_tcp = getnetconfigent("tcp");
333 			if (nconf_tcp == NULL)
334 				err(1, "getnetconfigent tcp failed");
335 			nb_tcp.buf = ai_tcp->ai_addr;
336 			nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
337 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, &nb_tcp)) ||
338 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, &nb_tcp)))
339 				err(1, "rpcb_set tcp failed");
340 			freeaddrinfo(ai_tcp);
341 		}
342 		if (tcpflag && ip6flag) {
343 			memset(&hints, 0, sizeof hints);
344 			hints.ai_flags = AI_PASSIVE;
345 			hints.ai_family = AF_INET6;
346 			hints.ai_socktype = SOCK_STREAM;
347 			hints.ai_protocol = IPPROTO_TCP;
348 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
349 			if (ecode != 0)
350 				err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode));
351 			nconf_tcp6 = getnetconfigent("tcp6");
352 			if (nconf_tcp6 == NULL)
353 				err(1, "getnetconfigent tcp6 failed");
354 			nb_tcp6.buf = ai_tcp6->ai_addr;
355 			nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
356 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
357 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, &nb_tcp6)))
358 				err(1, "rpcb_set tcp6 failed");
359 			freeaddrinfo(ai_tcp6);
360 		}
361 		exit (0);
362 	}
363 	if (debug == 0) {
364 		daemon(0, 0);
365 		(void)signal(SIGHUP, SIG_IGN);
366 		(void)signal(SIGINT, SIG_IGN);
367 		/*
368 		 * nfsd sits in the kernel most of the time.  It needs
369 		 * to ignore SIGTERM/SIGQUIT in order to stay alive as long
370 		 * as possible during a shutdown, otherwise loopback
371 		 * mounts will not be able to unmount.
372 		 */
373 		(void)signal(SIGTERM, SIG_IGN);
374 		(void)signal(SIGQUIT, SIG_IGN);
375 	}
376 	(void)signal(SIGSYS, nonfs);
377 	(void)signal(SIGCHLD, reapchild);
378 	(void)signal(SIGUSR2, backup_stable);
379 
380 	openlog("nfsd", LOG_PID | (debug ? LOG_PERROR : 0), LOG_DAEMON);
381 
382 	/*
383 	 * For V4, we open the stablerestart file and call nfssvc()
384 	 * to get it loaded. This is done before the daemons do the
385 	 * regular nfssvc() call to service NFS requests.
386 	 * (This way the file remains open until the last nfsd is killed
387 	 *  off.)
388 	 * It and the backup copy will be created as empty files
389 	 * the first time this nfsd is started and should never be
390 	 * deleted/replaced if at all possible. It should live on a
391 	 * local, non-volatile storage device that does not do hardware
392 	 * level write-back caching. (See SCSI doc for more information
393 	 * on how to prevent write-back caching on SCSI disks.)
394 	 */
395 	if (run_v4server > 0) {
396 		open_stable(&stablefd, &backupfd);
397 		if (stablefd < 0) {
398 			syslog(LOG_ERR, "Can't open %s: %m\n", NFSD_STABLERESTART);
399 			exit(1);
400 		}
401 		/* This system call will fail for old kernels, but that's ok. */
402 		nfssvc(NFSSVC_BACKUPSTABLE, NULL);
403 		if (nfssvc(NFSSVC_STABLERESTART, (caddr_t)&stablefd) < 0) {
404 			syslog(LOG_ERR, "Can't read stable storage file: %m\n");
405 			exit(1);
406 		}
407 		nfssvc_addsock = NFSSVC_NFSDADDSOCK;
408 		nfssvc_nfsd = NFSSVC_NFSDNFSD;
409 		new_syscall = TRUE;
410 	} else {
411 		nfssvc_addsock = NFSSVC_ADDSOCK;
412 		nfssvc_nfsd = NFSSVC_NFSD;
413 		/*
414 		 * Figure out if the kernel supports the new-style
415 		 * NFSSVC_NFSD. Old kernels will return ENXIO because they
416 		 * don't recognise the flag value, new ones will return EINVAL
417 		 * because argp is NULL.
418 		 */
419 		new_syscall = FALSE;
420 		if (nfssvc(NFSSVC_NFSD, NULL) < 0 && errno == EINVAL)
421 			new_syscall = TRUE;
422 	}
423 
424 	if (!new_syscall) {
425 		/* If we use UDP only, we start the last server below. */
426 		srvcnt = tcpflag ? nfsdcnt : nfsdcnt - 1;
427 		for (i = 0; i < srvcnt; i++) {
428 			switch ((pid = fork())) {
429 			case -1:
430 				syslog(LOG_ERR, "fork: %m");
431 				nfsd_exit(1);
432 			case 0:
433 				break;
434 			default:
435 				children[i] = pid;
436 				continue;
437 			}
438 			(void)signal(SIGUSR1, child_cleanup);
439 			setproctitle("server");
440 
441 			start_server(0);
442 		}
443 	} else if (tcpflag) {
444 		/*
445 		 * For TCP mode, we fork once to start the first
446 		 * kernel nfsd thread. The kernel will add more
447 		 * threads as needed.
448 		 */
449 		pid = fork();
450 		if (pid == -1) {
451 			syslog(LOG_ERR, "fork: %m");
452 			nfsd_exit(1);
453 		}
454 		if (pid) {
455 			children[0] = pid;
456 		} else {
457 			(void)signal(SIGUSR1, child_cleanup);
458 			setproctitle("server");
459 			start_server(0);
460 		}
461 	}
462 
463 	(void)signal(SIGUSR1, cleanup);
464 	FD_ZERO(&v4bits);
465 	FD_ZERO(&v6bits);
466 	FD_ZERO(&sockbits);
467 
468 	rpcbregcnt = 0;
469 	/* Set up the socket for udp and rpcb register it. */
470 	if (udpflag) {
471 		rpcbreg = 0;
472 		for (i = 0; i < bindhostc; i++) {
473 			memset(&hints, 0, sizeof hints);
474 			hints.ai_flags = AI_PASSIVE;
475 			hints.ai_family = AF_INET;
476 			hints.ai_socktype = SOCK_DGRAM;
477 			hints.ai_protocol = IPPROTO_UDP;
478 			if (setbindhost(&ai_udp, bindhost[i], hints) == 0) {
479 				rpcbreg = 1;
480 				rpcbregcnt++;
481 				if ((sock = socket(ai_udp->ai_family,
482 				    ai_udp->ai_socktype,
483 				    ai_udp->ai_protocol)) < 0) {
484 					syslog(LOG_ERR,
485 					    "can't create udp socket");
486 					nfsd_exit(1);
487 				}
488 				if (bind(sock, ai_udp->ai_addr,
489 				    ai_udp->ai_addrlen) < 0) {
490 					syslog(LOG_ERR,
491 					    "can't bind udp addr %s: %m",
492 					    bindhost[i]);
493 					nfsd_exit(1);
494 				}
495 				freeaddrinfo(ai_udp);
496 				addsockargs.sock = sock;
497 				addsockargs.name = NULL;
498 				addsockargs.namelen = 0;
499 				if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
500 					syslog(LOG_ERR, "can't Add UDP socket");
501 					nfsd_exit(1);
502 				}
503 				(void)close(sock);
504 			}
505 		}
506 		if (rpcbreg == 1) {
507 			memset(&hints, 0, sizeof hints);
508 			hints.ai_flags = AI_PASSIVE;
509 			hints.ai_family = AF_INET;
510 			hints.ai_socktype = SOCK_DGRAM;
511 			hints.ai_protocol = IPPROTO_UDP;
512 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
513 			if (ecode != 0) {
514 				syslog(LOG_ERR, "getaddrinfo udp: %s",
515 				   gai_strerror(ecode));
516 				nfsd_exit(1);
517 			}
518 			nconf_udp = getnetconfigent("udp");
519 			if (nconf_udp == NULL)
520 				err(1, "getnetconfigent udp failed");
521 			nb_udp.buf = ai_udp->ai_addr;
522 			nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
523 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
524 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, &nb_udp)))
525 				err(1, "rpcb_set udp failed");
526 			freeaddrinfo(ai_udp);
527 		}
528 	}
529 
530 	/* Set up the socket for udp6 and rpcb register it. */
531 	if (udpflag && ip6flag) {
532 		rpcbreg = 0;
533 		for (i = 0; i < bindhostc; i++) {
534 			memset(&hints, 0, sizeof hints);
535 			hints.ai_flags = AI_PASSIVE;
536 			hints.ai_family = AF_INET6;
537 			hints.ai_socktype = SOCK_DGRAM;
538 			hints.ai_protocol = IPPROTO_UDP;
539 			if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) {
540 				rpcbreg = 1;
541 				rpcbregcnt++;
542 				if ((sock = socket(ai_udp6->ai_family,
543 				    ai_udp6->ai_socktype,
544 				    ai_udp6->ai_protocol)) < 0) {
545 					syslog(LOG_ERR,
546 						"can't create udp6 socket");
547 					nfsd_exit(1);
548 				}
549 				if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
550 				    &on, sizeof on) < 0) {
551 					syslog(LOG_ERR,
552 					    "can't set v6-only binding for "
553 					    "udp6 socket: %m");
554 					nfsd_exit(1);
555 				}
556 				if (bind(sock, ai_udp6->ai_addr,
557 				    ai_udp6->ai_addrlen) < 0) {
558 					syslog(LOG_ERR,
559 					    "can't bind udp6 addr %s: %m",
560 					    bindhost[i]);
561 					nfsd_exit(1);
562 				}
563 				freeaddrinfo(ai_udp6);
564 				addsockargs.sock = sock;
565 				addsockargs.name = NULL;
566 				addsockargs.namelen = 0;
567 				if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
568 					syslog(LOG_ERR,
569 					    "can't add UDP6 socket");
570 					nfsd_exit(1);
571 				}
572 				(void)close(sock);
573 			}
574 		}
575 		if (rpcbreg == 1) {
576 			memset(&hints, 0, sizeof hints);
577 			hints.ai_flags = AI_PASSIVE;
578 			hints.ai_family = AF_INET6;
579 			hints.ai_socktype = SOCK_DGRAM;
580 			hints.ai_protocol = IPPROTO_UDP;
581 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
582 			if (ecode != 0) {
583 				syslog(LOG_ERR, "getaddrinfo udp6: %s",
584 				   gai_strerror(ecode));
585 				nfsd_exit(1);
586 			}
587 			nconf_udp6 = getnetconfigent("udp6");
588 			if (nconf_udp6 == NULL)
589 				err(1, "getnetconfigent udp6 failed");
590 			nb_udp6.buf = ai_udp6->ai_addr;
591 			nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
592 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
593 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, &nb_udp6)))
594 				err(1, "rpcb_set udp6 failed");
595 			freeaddrinfo(ai_udp6);
596 		}
597 	}
598 
599 	/* Set up the socket for tcp and rpcb register it. */
600 	if (tcpflag) {
601 		rpcbreg = 0;
602 		for (i = 0; i < bindhostc; i++) {
603 			memset(&hints, 0, sizeof hints);
604 			hints.ai_flags = AI_PASSIVE;
605 			hints.ai_family = AF_INET;
606 			hints.ai_socktype = SOCK_STREAM;
607 			hints.ai_protocol = IPPROTO_TCP;
608 			if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) {
609 				rpcbreg = 1;
610 				rpcbregcnt++;
611 				if ((tcpsock = socket(AF_INET, SOCK_STREAM,
612 				    0)) < 0) {
613 					syslog(LOG_ERR,
614 					    "can't create tcp socket");
615 					nfsd_exit(1);
616 				}
617 				if (setsockopt(tcpsock, SOL_SOCKET,
618 				    SO_REUSEADDR,
619 				    (char *)&on, sizeof(on)) < 0)
620 					syslog(LOG_ERR,
621 					     "setsockopt SO_REUSEADDR: %m");
622 				if (bind(tcpsock, ai_tcp->ai_addr,
623 				    ai_tcp->ai_addrlen) < 0) {
624 					syslog(LOG_ERR,
625 					    "can't bind tcp addr %s: %m",
626 					    bindhost[i]);
627 					nfsd_exit(1);
628 				}
629 				if (listen(tcpsock, -1) < 0) {
630 					syslog(LOG_ERR, "listen failed");
631 					nfsd_exit(1);
632 				}
633 				freeaddrinfo(ai_tcp);
634 				FD_SET(tcpsock, &sockbits);
635 				FD_SET(tcpsock, &v4bits);
636 				maxsock = tcpsock;
637 				connect_type_cnt++;
638 			}
639 		}
640 		if (rpcbreg == 1) {
641 			memset(&hints, 0, sizeof hints);
642 			hints.ai_flags = AI_PASSIVE;
643 			hints.ai_family = AF_INET;
644 			hints.ai_socktype = SOCK_STREAM;
645 			hints.ai_protocol = IPPROTO_TCP;
646 			ecode = getaddrinfo(NULL, "nfs", &hints,
647 			     &ai_tcp);
648 			if (ecode != 0) {
649 				syslog(LOG_ERR, "getaddrinfo tcp: %s",
650 				   gai_strerror(ecode));
651 				nfsd_exit(1);
652 			}
653 			nconf_tcp = getnetconfigent("tcp");
654 			if (nconf_tcp == NULL)
655 				err(1, "getnetconfigent tcp failed");
656 			nb_tcp.buf = ai_tcp->ai_addr;
657 			nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
658 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp,
659 			    &nb_tcp)) || (!rpcb_set(NFS_PROGRAM, 3,
660 			    nconf_tcp, &nb_tcp)))
661 				err(1, "rpcb_set tcp failed");
662 			freeaddrinfo(ai_tcp);
663 		}
664 	}
665 
666 	/* Set up the socket for tcp6 and rpcb register it. */
667 	if (tcpflag && ip6flag) {
668 		rpcbreg = 0;
669 		for (i = 0; i < bindhostc; i++) {
670 			memset(&hints, 0, sizeof hints);
671 			hints.ai_flags = AI_PASSIVE;
672 			hints.ai_family = AF_INET6;
673 			hints.ai_socktype = SOCK_STREAM;
674 			hints.ai_protocol = IPPROTO_TCP;
675 			if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) {
676 				rpcbreg = 1;
677 				rpcbregcnt++;
678 				if ((tcp6sock = socket(ai_tcp6->ai_family,
679 				    ai_tcp6->ai_socktype,
680 				    ai_tcp6->ai_protocol)) < 0) {
681 					syslog(LOG_ERR,
682 					    "can't create tcp6 socket");
683 					nfsd_exit(1);
684 				}
685 				if (setsockopt(tcp6sock, SOL_SOCKET,
686 				    SO_REUSEADDR,
687 				    (char *)&on, sizeof(on)) < 0)
688 					syslog(LOG_ERR,
689 					    "setsockopt SO_REUSEADDR: %m");
690 				if (setsockopt(tcp6sock, IPPROTO_IPV6,
691 				    IPV6_V6ONLY, &on, sizeof on) < 0) {
692 					syslog(LOG_ERR,
693 					"can't set v6-only binding for tcp6 "
694 					    "socket: %m");
695 					nfsd_exit(1);
696 				}
697 				if (bind(tcp6sock, ai_tcp6->ai_addr,
698 				    ai_tcp6->ai_addrlen) < 0) {
699 					syslog(LOG_ERR,
700 					    "can't bind tcp6 addr %s: %m",
701 					    bindhost[i]);
702 					nfsd_exit(1);
703 				}
704 				if (listen(tcp6sock, -1) < 0) {
705 					syslog(LOG_ERR, "listen failed");
706 					nfsd_exit(1);
707 				}
708 				freeaddrinfo(ai_tcp6);
709 				FD_SET(tcp6sock, &sockbits);
710 				FD_SET(tcp6sock, &v6bits);
711 				if (maxsock < tcp6sock)
712 					maxsock = tcp6sock;
713 				connect_type_cnt++;
714 			}
715 		}
716 		if (rpcbreg == 1) {
717 			memset(&hints, 0, sizeof hints);
718 			hints.ai_flags = AI_PASSIVE;
719 			hints.ai_family = AF_INET6;
720 			hints.ai_socktype = SOCK_STREAM;
721 			hints.ai_protocol = IPPROTO_TCP;
722 			ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
723 			if (ecode != 0) {
724 				syslog(LOG_ERR, "getaddrinfo tcp6: %s",
725 				   gai_strerror(ecode));
726 				nfsd_exit(1);
727 			}
728 			nconf_tcp6 = getnetconfigent("tcp6");
729 			if (nconf_tcp6 == NULL)
730 				err(1, "getnetconfigent tcp6 failed");
731 			nb_tcp6.buf = ai_tcp6->ai_addr;
732 			nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
733 			if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
734 			    (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, &nb_tcp6)))
735 				err(1, "rpcb_set tcp6 failed");
736 			freeaddrinfo(ai_tcp6);
737 		}
738 	}
739 
740 	if (rpcbregcnt == 0) {
741 		syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m");
742 		nfsd_exit(1);
743 	}
744 
745 	if (tcpflag && connect_type_cnt == 0) {
746 		syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m");
747 		nfsd_exit(1);
748 	}
749 
750 	setproctitle("master");
751 	/*
752 	 * We always want a master to have a clean way to to shut nfsd down
753 	 * (with unregistration): if the master is killed, it unregisters and
754 	 * kills all children. If we run for UDP only (and so do not have to
755 	 * loop waiting waiting for accept), we instead make the parent
756 	 * a "server" too. start_server will not return.
757 	 */
758 	if (!tcpflag)
759 		start_server(1);
760 
761 	/*
762 	 * Loop forever accepting connections and passing the sockets
763 	 * into the kernel for the mounts.
764 	 */
765 	for (;;) {
766 		ready = sockbits;
767 		if (connect_type_cnt > 1) {
768 			if (select(maxsock + 1,
769 			    &ready, NULL, NULL, NULL) < 1) {
770 				error = errno;
771 				if (error == EINTR)
772 					continue;
773 				syslog(LOG_ERR, "select failed: %m");
774 				nfsd_exit(1);
775 			}
776 		}
777 		for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) {
778 			if (FD_ISSET(tcpsock, &ready)) {
779 				if (FD_ISSET(tcpsock, &v4bits)) {
780 					len = sizeof(inetpeer);
781 					if ((msgsock = accept(tcpsock,
782 					    (struct sockaddr *)&inetpeer, &len)) < 0) {
783 						error = errno;
784 						syslog(LOG_ERR, "accept failed: %m");
785 						if (error == ECONNABORTED ||
786 						    error == EINTR)
787 							continue;
788 						nfsd_exit(1);
789 					}
790 					memset(inetpeer.sin_zero, 0,
791 						sizeof(inetpeer.sin_zero));
792 					if (setsockopt(msgsock, SOL_SOCKET,
793 					    SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0)
794 						syslog(LOG_ERR,
795 						    "setsockopt SO_KEEPALIVE: %m");
796 					addsockargs.sock = msgsock;
797 					addsockargs.name = (caddr_t)&inetpeer;
798 					addsockargs.namelen = len;
799 					nfssvc(nfssvc_addsock, &addsockargs);
800 					(void)close(msgsock);
801 				} else if (FD_ISSET(tcpsock, &v6bits)) {
802 					len = sizeof(inet6peer);
803 					if ((msgsock = accept(tcpsock,
804 					    (struct sockaddr *)&inet6peer,
805 					    &len)) < 0) {
806 						error = errno;
807 						syslog(LOG_ERR,
808 						     "accept failed: %m");
809 						if (error == ECONNABORTED ||
810 						    error == EINTR)
811 							continue;
812 						nfsd_exit(1);
813 					}
814 					if (setsockopt(msgsock, SOL_SOCKET,
815 					    SO_KEEPALIVE, (char *)&on,
816 					    sizeof(on)) < 0)
817 						syslog(LOG_ERR, "setsockopt "
818 						    "SO_KEEPALIVE: %m");
819 					addsockargs.sock = msgsock;
820 					addsockargs.name = (caddr_t)&inet6peer;
821 					addsockargs.namelen = len;
822 					nfssvc(nfssvc_addsock, &addsockargs);
823 					(void)close(msgsock);
824 				}
825 			}
826 		}
827 	}
828 }
829 
830 static int
831 setbindhost(struct addrinfo **ai, const char *bindhost, struct addrinfo hints)
832 {
833 	int ecode;
834 	u_int32_t host_addr[4];  /* IPv4 or IPv6 */
835 	const char *hostptr;
836 
837 	if (bindhost == NULL || strcmp("*", bindhost) == 0)
838 		hostptr = NULL;
839 	else
840 		hostptr = bindhost;
841 
842 	if (hostptr != NULL) {
843 		switch (hints.ai_family) {
844 		case AF_INET:
845 			if (inet_pton(AF_INET, hostptr, host_addr) == 1) {
846 				hints.ai_flags = AI_NUMERICHOST;
847 			} else {
848 				if (inet_pton(AF_INET6, hostptr,
849 				    host_addr) == 1)
850 					return (1);
851 			}
852 			break;
853 		case AF_INET6:
854 			if (inet_pton(AF_INET6, hostptr, host_addr) == 1) {
855 				hints.ai_flags = AI_NUMERICHOST;
856 			} else {
857 				if (inet_pton(AF_INET, hostptr,
858 				    host_addr) == 1)
859 					return (1);
860 			}
861 			break;
862 		default:
863 			break;
864 		}
865 	}
866 
867 	ecode = getaddrinfo(hostptr, "nfs", &hints, ai);
868 	if (ecode != 0) {
869 		syslog(LOG_ERR, "getaddrinfo %s: %s", bindhost,
870 		    gai_strerror(ecode));
871 		return (1);
872 	}
873 	return (0);
874 }
875 
876 static void
877 set_nfsdcnt(int proposed)
878 {
879 
880 	if (proposed < 1) {
881 		warnx("nfsd count too low %d; reset to %d", proposed,
882 		    DEFNFSDCNT);
883 		nfsdcnt = DEFNFSDCNT;
884 	} else if (proposed > MAXNFSDCNT) {
885 		warnx("nfsd count too high %d; truncated to %d", proposed,
886 		    MAXNFSDCNT);
887 		nfsdcnt = MAXNFSDCNT;
888 	} else
889 		nfsdcnt = proposed;
890 	nfsdcnt_set = 1;
891 }
892 
893 static void
894 usage(void)
895 {
896 	(void)fprintf(stderr, "%s", getopt_usage);
897 	exit(1);
898 }
899 
900 static void
901 nonfs(__unused int signo)
902 {
903 	syslog(LOG_ERR, "missing system call: NFS not available");
904 }
905 
906 static void
907 reapchild(__unused int signo)
908 {
909 	pid_t pid;
910 	int i;
911 
912 	while ((pid = wait3(NULL, WNOHANG, NULL)) > 0) {
913 		for (i = 0; i < nfsdcnt; i++)
914 			if (pid == children[i])
915 				children[i] = -1;
916 	}
917 }
918 
919 static void
920 unregistration(void)
921 {
922 	if ((!rpcb_unset(NFS_PROGRAM, 2, NULL)) ||
923 	    (!rpcb_unset(NFS_PROGRAM, 3, NULL)))
924 		syslog(LOG_ERR, "rpcb_unset failed");
925 }
926 
927 static void
928 killchildren(void)
929 {
930 	int i;
931 
932 	for (i = 0; i < nfsdcnt; i++) {
933 		if (children[i] > 0)
934 			kill(children[i], SIGKILL);
935 	}
936 }
937 
938 /*
939  * Cleanup master after SIGUSR1.
940  */
941 static void
942 cleanup(__unused int signo)
943 {
944 	nfsd_exit(0);
945 }
946 
947 /*
948  * Cleanup child after SIGUSR1.
949  */
950 static void
951 child_cleanup(__unused int signo)
952 {
953 	exit(0);
954 }
955 
956 static void
957 nfsd_exit(int status)
958 {
959 	killchildren();
960 	unregistration();
961 	exit(status);
962 }
963 
964 static int
965 get_tuned_nfsdcount(void)
966 {
967 	int ncpu, error, tuned_nfsdcnt;
968 	size_t ncpu_size;
969 
970 	ncpu_size = sizeof(ncpu);
971 	error = sysctlbyname("hw.ncpu", &ncpu, &ncpu_size, NULL, 0);
972 	if (error) {
973 		warnx("sysctlbyname(hw.ncpu) failed defaulting to %d nfs servers",
974 		    DEFNFSDCNT);
975 		tuned_nfsdcnt = DEFNFSDCNT;
976 	} else {
977 		tuned_nfsdcnt = ncpu * 8;
978 	}
979 	if (!new_syscall && tuned_nfsdcnt > MAXNFSDCNT) {
980 		warnx("nfsd count %d; truncated to %d", tuned_nfsdcnt,
981 		    MAXNFSDCNT);
982 		tuned_nfsdcnt = MAXNFSDCNT;
983 	}
984 	return tuned_nfsdcnt;
985 }
986 
987 static void
988 start_server(int master)
989 {
990 	char principal[MAXHOSTNAMELEN + 5];
991 	struct nfsd_nfsd_args nfsdargs;
992 	int status, error;
993 	char hostname[MAXHOSTNAMELEN + 1], *cp;
994 	struct addrinfo *aip, hints;
995 
996 	status = 0;
997 	if (new_syscall) {
998 		gethostname(hostname, sizeof (hostname));
999 		snprintf(principal, sizeof (principal), "nfs@%s", hostname);
1000 		if ((cp = strchr(hostname, '.')) == NULL ||
1001 		    *(cp + 1) == '\0') {
1002 			/* If not fully qualified, try getaddrinfo() */
1003 			memset((void *)&hints, 0, sizeof (hints));
1004 			hints.ai_flags = AI_CANONNAME;
1005 			error = getaddrinfo(hostname, NULL, &hints, &aip);
1006 			if (error == 0) {
1007 				if (aip->ai_canonname != NULL &&
1008 				    (cp = strchr(aip->ai_canonname, '.')) !=
1009 				    NULL && *(cp + 1) != '\0')
1010 					snprintf(principal, sizeof (principal),
1011 					    "nfs@%s", aip->ai_canonname);
1012 				freeaddrinfo(aip);
1013 			}
1014 		}
1015 		nfsdargs.principal = principal;
1016 
1017 		if (nfsdcnt_set)
1018 			nfsdargs.minthreads = nfsdargs.maxthreads = nfsdcnt;
1019 		else {
1020 			nfsdargs.minthreads = minthreads_set ? minthreads : get_tuned_nfsdcount();
1021 			nfsdargs.maxthreads = maxthreads_set ? maxthreads : nfsdargs.minthreads;
1022 			if (nfsdargs.maxthreads < nfsdargs.minthreads)
1023 				nfsdargs.maxthreads = nfsdargs.minthreads;
1024 		}
1025 		error = nfssvc(nfssvc_nfsd, &nfsdargs);
1026 		if (error < 0 && errno == EAUTH) {
1027 			/*
1028 			 * This indicates that it could not register the
1029 			 * rpcsec_gss credentials, usually because the
1030 			 * gssd daemon isn't running.
1031 			 * (only the experimental server with nfsv4)
1032 			 */
1033 			syslog(LOG_ERR, "No gssd, using AUTH_SYS only");
1034 			principal[0] = '\0';
1035 			error = nfssvc(nfssvc_nfsd, &nfsdargs);
1036 		}
1037 		if (error < 0) {
1038 			syslog(LOG_ERR, "nfssvc: %m");
1039 			status = 1;
1040 		}
1041 	} else {
1042 		if (nfssvc(NFSSVC_OLDNFSD, NULL) < 0) {
1043 			syslog(LOG_ERR, "nfssvc: %m");
1044 			status = 1;
1045 		}
1046 	}
1047 	if (master)
1048 		nfsd_exit(status);
1049 	else
1050 		exit(status);
1051 }
1052 
1053 /*
1054  * Open the stable restart file and return the file descriptor for it.
1055  */
1056 static void
1057 open_stable(int *stable_fdp, int *backup_fdp)
1058 {
1059 	int stable_fd, backup_fd = -1, ret;
1060 	struct stat st, backup_st;
1061 
1062 	/* Open and stat the stable restart file. */
1063 	stable_fd = open(NFSD_STABLERESTART, O_RDWR, 0);
1064 	if (stable_fd < 0)
1065 		stable_fd = open(NFSD_STABLERESTART, O_RDWR | O_CREAT, 0600);
1066 	if (stable_fd >= 0) {
1067 		ret = fstat(stable_fd, &st);
1068 		if (ret < 0) {
1069 			close(stable_fd);
1070 			stable_fd = -1;
1071 		}
1072 	}
1073 
1074 	/* Open and stat the backup stable restart file. */
1075 	if (stable_fd >= 0) {
1076 		backup_fd = open(NFSD_STABLEBACKUP, O_RDWR, 0);
1077 		if (backup_fd < 0)
1078 			backup_fd = open(NFSD_STABLEBACKUP, O_RDWR | O_CREAT,
1079 			    0600);
1080 		if (backup_fd >= 0) {
1081 			ret = fstat(backup_fd, &backup_st);
1082 			if (ret < 0) {
1083 				close(backup_fd);
1084 				backup_fd = -1;
1085 			}
1086 		}
1087 		if (backup_fd < 0) {
1088 			close(stable_fd);
1089 			stable_fd = -1;
1090 		}
1091 	}
1092 
1093 	*stable_fdp = stable_fd;
1094 	*backup_fdp = backup_fd;
1095 	if (stable_fd < 0)
1096 		return;
1097 
1098 	/* Sync up the 2 files, as required. */
1099 	if (st.st_size > 0)
1100 		copy_stable(stable_fd, backup_fd);
1101 	else if (backup_st.st_size > 0)
1102 		copy_stable(backup_fd, stable_fd);
1103 }
1104 
1105 /*
1106  * Copy the stable restart file to the backup or vice versa.
1107  */
1108 static void
1109 copy_stable(int from_fd, int to_fd)
1110 {
1111 	int cnt, ret;
1112 	static char buf[1024];
1113 
1114 	ret = lseek(from_fd, (off_t)0, SEEK_SET);
1115 	if (ret >= 0)
1116 		ret = lseek(to_fd, (off_t)0, SEEK_SET);
1117 	if (ret >= 0)
1118 		ret = ftruncate(to_fd, (off_t)0);
1119 	if (ret >= 0)
1120 		do {
1121 			cnt = read(from_fd, buf, 1024);
1122 			if (cnt > 0)
1123 				ret = write(to_fd, buf, cnt);
1124 			else if (cnt < 0)
1125 				ret = cnt;
1126 		} while (cnt > 0 && ret >= 0);
1127 	if (ret >= 0)
1128 		ret = fsync(to_fd);
1129 	if (ret < 0)
1130 		syslog(LOG_ERR, "stable restart copy failure: %m");
1131 }
1132 
1133 /*
1134  * Back up the stable restart file when indicated by the kernel.
1135  */
1136 static void
1137 backup_stable(__unused int signo)
1138 {
1139 
1140 	if (stablefd >= 0)
1141 		copy_stable(stablefd, backupfd);
1142 }
1143 
1144