xref: /titanic_51/usr/src/cmd/fs.d/umount.c (revision 10144ea86a21f583d4eec553d1a18da7544ba6de)
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  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"
31 
32 #include	<stdio.h>
33 #include	<stdio_ext.h>
34 #include	<limits.h>
35 #include	<unistd.h>
36 #include	<stdlib.h>
37 #include	<string.h>
38 #include	<sys/signal.h>
39 #include	<sys/mnttab.h>
40 #include	<errno.h>
41 #include	<sys/types.h>
42 #include	<sys/stat.h>
43 #include	<sys/param.h>
44 #include	<sys/wait.h>
45 #include	<sys/vfstab.h>
46 #include	<sys/fcntl.h>
47 #include	<sys/resource.h>
48 #include	<sys/mntent.h>
49 #include	<sys/ctfs.h>
50 #include	<locale.h>
51 #include	<stdarg.h>
52 #include	<sys/mount.h>
53 #include	<sys/objfs.h>
54 #include	"fslib.h"
55 #include	<sharefs/share.h>
56 
57 #define	FS_PATH		"/usr/lib/fs"
58 #define	ALT_PATH	"/etc/fs"
59 #define	FULLPATH_MAX	32
60 #define	FSTYPE_MAX	8
61 #define	ARGV_MAX	16
62 
63 int	aflg, oflg, Vflg, dashflg, dflg, fflg;
64 
65 extern void	rpterr(), usage(), mnterror();
66 
67 extern	char	*optarg;	/* used by getopt */
68 extern	int	optind, opterr;
69 
70 static char	*myname;
71 char	fs_path[] = FS_PATH;
72 char	alt_path[] = ALT_PATH;
73 char	mnttab[MAXPATHLEN + 1];
74 char	*oarg, *farg;
75 int	maxrun, nrun;
76 int	no_mnttab;
77 int	lofscnt;		/* presence of lofs prohibits parallel */
78 				/* umounting */
79 int	exitcode;
80 char	resolve[MAXPATHLEN];
81 static  char ibuf[BUFSIZ];
82 
83 /*
84  * Currently, mounting cachefs's simultaneous uncovers various problems.
85  * For the short term, we serialize cachefs activity while we fix
86  * these cachefs bugs.
87  */
88 #define	CACHEFS_BUG
89 #ifdef	CACHEFS_BUG
90 #include	<sys/fs/cachefs_fs.h>	/* for BACKMNT_NAME */
91 int	cachefs_running;	/* parallel cachefs not supported yet */
92 #endif
93 
94 /*
95  * The basic mount struct that describes an mnttab entry.
96  * It is used both in an array and as a linked list elem.
97  */
98 
99 typedef struct mountent {
100 	struct mnttab	ment;		/* the mnttab data */
101 	int		mlevel;		/* mount level of the mount pt */
102 	pid_t		pid;		/* the pid of this mount process */
103 #define	RDPIPE		0
104 #define	WRPIPE		1
105 	int		sopipe[2];	/* pipe attached to child's stdout */
106 	int		sepipe[2];	/* pipe attached to child's stderr */
107 	struct mountent *link;		/* used when in linked list */
108 } mountent_t;
109 
110 static mountent_t	*mntll;		/* head of global linked list of */
111 					/* mountents */
112 int			listlength;	/* # of elems in this list */
113 
114 /*
115  * If the automatic flag (-a) is given and mount points are not specified
116  * on the command line, then do not attempt to umount these.  These
117  * generally need to be kept mounted until system shutdown.
118  */
119 static const char   *keeplist[] = {
120 	"/",
121 	"/dev",
122 	"/dev/fd",
123 	"/devices",
124 	"/etc/mnttab",
125 	"/etc/svc/volatile",
126 	"/lib",
127 	"/proc",
128 	"/sbin",
129 	CTFS_ROOT,
130 	OBJFS_ROOT,
131 	"/tmp",
132 	"/usr",
133 	"/var",
134 	"/var/adm",
135 	"/var/run",
136 	SHARETAB,
137 	NULL
138 };
139 
140 static void	nomem();
141 static void	doexec(struct mnttab *);
142 static int	setup_iopipe(mountent_t *);
143 static void	setup_output(mountent_t *);
144 static void	doio(mountent_t *);
145 static void	do_umounts(mountent_t **);
146 static int	dowait();
147 static int	parumount();
148 static int	mcompar(const void *, const void *);
149 static void	cleanup(int);
150 
151 static mountent_t	**make_mntarray(char **, int);
152 static mountent_t	*getmntall();
153 static mountent_t 	*new_mountent(struct mnttab *);
154 static mountent_t	*getmntlast(mountent_t *, char *, char *);
155 
156 int
157 main(int argc, char **argv)
158 {
159 	int 	cc;
160 	struct mnttab  mget;
161 	char 	*mname, *is_special;
162 	int	fscnt;
163 	mountent_t	*mp;
164 
165 	(void) setlocale(LC_ALL, "");
166 
167 #if !defined(TEXT_DOMAIN)
168 #define	TEXT_DOMAIN "SYS_TEST"
169 #endif
170 	(void) textdomain(TEXT_DOMAIN);
171 
172 	myname = strrchr(argv[0], '/');
173 	if (myname)
174 		myname++;
175 	else
176 		myname = argv[0];
177 
178 	/*
179 	 * Process the args.
180 	 * "-d" for compatibility
181 	 */
182 	while ((cc = getopt(argc, argv, "ado:Vf?")) != -1)
183 		switch (cc) {
184 		case 'a':
185 			aflg++;
186 			break;
187 #ifdef DEBUG
188 		case 'd':
189 			dflg++;
190 			break;
191 #endif
192 
193 		case '?':
194 			usage();
195 			break;
196 		case 'o':
197 			if (oflg)
198 				usage();
199 			else {
200 				oflg++;
201 				oarg = optarg;
202 			}
203 			break;
204 		case 'f':
205 			fflg++;
206 			break;
207 		case 'V':
208 			if (Vflg)
209 				usage();
210 			else
211 				Vflg++;
212 			break;
213 		default:
214 			usage();
215 			break;
216 		}
217 
218 	fscnt = argc - optind;
219 	if (!aflg && fscnt != 1)
220 		usage();
221 
222 	/* copy '--' to specific */
223 	if (strcmp(argv[optind-1], "--") == 0)
224 		dashflg++;
225 
226 	/*
227 	 * mnttab may be a symlink to a file in another file system.
228 	 * This happens during install when / is mounted read-only
229 	 * and /etc/mnttab is symlinked to a file in /tmp.
230 	 * If this is the case, we need to follow the symlink to the
231 	 * read-write file itself so that the subsequent mnttab.temp
232 	 * open and rename will work.
233 	 */
234 	if (realpath(MNTTAB, mnttab) == NULL) {
235 		strcpy(mnttab, MNTTAB);
236 	}
237 
238 	/*
239 	 * bugid 1205242
240 	 * call the realpath() here, so that if the user is
241 	 * trying to umount an autofs directory, the directory
242 	 * is forced to mount.
243 	 */
244 
245 	mname = argv[optind];
246 	is_special = realpath(mname, resolve);
247 
248 	/*
249 	 * Read the whole mnttab into memory.
250 	 */
251 	mntll = getmntall();
252 
253 	if (aflg && fscnt != 1)
254 		exit(parumount(argv + optind, fscnt));
255 
256 	aflg = 0;
257 
258 	mntnull(&mget);
259 	if (listlength == 0) {
260 		fprintf(stderr, gettext(
261 			"%s: warning: no entries found in %s\n"),
262 				myname, mnttab);
263 		mget.mnt_mountp = mname;	/* assume mount point */
264 		no_mnttab++;
265 		doexec(&mget);
266 		exit(0);
267 	}
268 
269 	mp = NULL;
270 
271 	/*
272 	 * if realpath fails, it can't be a mount point, so we'll
273 	 * go straight to the code that treats the arg as a special.
274 	 * if realpath succeeds, it could be a special or a mount point;
275 	 * we'll start by assuming it's a mount point, and if it's not,
276 	 * try to treat it as a special.
277 	 */
278 	if (is_special != NULL) {
279 		/*
280 		 * if this succeeds,
281 		 * we'll have the appropriate record; if it fails
282 		 * we'll assume the arg is a special of some sort
283 		 */
284 		mp = getmntlast(mntll, NULL, resolve);
285 	}
286 	/*
287 	 * Since stackable mount is allowed (RFE 2001535),
288 	 * we will un-mount the last entry in the MNTTAB that matches.
289 	 */
290 	if (mp == NULL) {
291 		/*
292 		 * Perhaps there is a bogus mnttab entry that
293 		 * can't be resolved:
294 		 */
295 		if ((mp = getmntlast(mntll, NULL, mname)) == NULL)
296 			/*
297 			 * assume it's a device (special) now
298 			 */
299 			mp = getmntlast(mntll, mname, NULL);
300 		if (mp) {
301 			/*
302 			 * Found it.
303 			 * This is a device. Now we want to know if
304 			 * it stackmounted on by something else.
305 			 * The original fix for bug 1103850 has a
306 			 * problem with lockfs (bug 1119731). This
307 			 * is a revised method.
308 			 */
309 			mountent_t *lmp;
310 			lmp = getmntlast(mntll, NULL, mp->ment.mnt_mountp);
311 
312 			if (lmp && strcmp(lmp->ment.mnt_special,
313 					mp->ment.mnt_special)) {
314 				errno = EBUSY;
315 				rpterr(mname);
316 				exit(1);
317 			}
318 		} else {
319 			fprintf(stderr, gettext(
320 				"%s: warning: %s not in mnttab\n"),
321 				myname, mname);
322 			if (Vflg)
323 				exit(1);
324 				/*
325 				 * same error as mount -V
326 				 * would give for unknown
327 				 * mount point
328 				 */
329 			mget.mnt_special = mget.mnt_mountp = mname;
330 		}
331 	}
332 
333 	if (mp)
334 		doexec(&mp->ment);
335 	else
336 		doexec(&mget);
337 
338 	return (0);
339 }
340 
341 void
342 doexec(struct mnttab *ment)
343 {
344 	int 	ret;
345 
346 #ifdef DEBUG
347 	if (dflg)
348 		fprintf(stderr, "%d: umounting %s\n",
349 			getpid(), ment->mnt_mountp);
350 #endif
351 
352 	/* try to exec the dependent portion */
353 	if ((ment->mnt_fstype != NULL) || Vflg) {
354 		char	full_path[FULLPATH_MAX];
355 		char	alter_path[FULLPATH_MAX];
356 		char	*newargv[ARGV_MAX];
357 		int 	ii;
358 
359 		if (strlen(ment->mnt_fstype) > (size_t)FSTYPE_MAX) {
360 			fprintf(stderr, gettext(
361 				"%s: FSType %s exceeds %d characters\n"),
362 				myname, ment->mnt_fstype, FSTYPE_MAX);
363 			exit(1);
364 		}
365 
366 		/* build the full pathname of the fstype dependent command. */
367 		sprintf(full_path, "%s/%s/%s", fs_path, ment->mnt_fstype,
368 					myname);
369 		sprintf(alter_path, "%s/%s/%s", alt_path, ment->mnt_fstype,
370 					myname);
371 
372 		/*
373 		 * create the new arg list, and end the list with a
374 		 * null pointer
375 		 */
376 		ii = 2;
377 		if (oflg) {
378 			newargv[ii++] = "-o";
379 			newargv[ii++] = oarg;
380 		}
381 		if (dashflg) {
382 			newargv[ii++] = "--";
383 		}
384 		if (fflg) {
385 			newargv[ii++] = "-f";
386 		}
387 		newargv[ii++] = (ment->mnt_mountp)
388 				? ment->mnt_mountp : ment->mnt_special;
389 		newargv[ii] = NULL;
390 
391 		/* set the new argv[0] to the filename */
392 		newargv[1] = myname;
393 
394 		if (Vflg) {
395 			printf("%s", myname);
396 			for (ii = 2; newargv[ii]; ii++)
397 				printf(" %s", newargv[ii]);
398 			printf("\n");
399 			fflush(stdout);
400 			exit(0);
401 		}
402 
403 		/* Try to exec the fstype dependent umount. */
404 		execv(full_path, &newargv[1]);
405 		if (errno == ENOEXEC) {
406 			newargv[0] = "sh";
407 			newargv[1] = full_path;
408 			execv("/sbin/sh", &newargv[0]);
409 		}
410 		newargv[1] = myname;
411 		execv(alter_path, &newargv[1]);
412 		if (errno == ENOEXEC) {
413 			newargv[0] = "sh";
414 			newargv[1] = alter_path;
415 			execv("/sbin/sh", &newargv[0]);
416 		}
417 		/* exec failed */
418 		if (errno != ENOENT) {
419 			fprintf(stderr, gettext("umount: cannot execute %s\n"),
420 					full_path);
421 			exit(1);
422 		}
423 	}
424 	/*
425 	 * No fstype independent executable then.  We'll go generic
426 	 * from here.
427 	 */
428 
429 	/* don't use -o with generic */
430 	if (oflg) {
431 		fprintf(stderr, gettext(
432 	"%s: %s specific umount does not exist; -o suboption ignored\n"),
433 		myname, ment->mnt_fstype ? ment->mnt_fstype : "<null>");
434 	}
435 
436 	signal(SIGHUP,  SIG_IGN);
437 	signal(SIGQUIT, SIG_IGN);
438 	signal(SIGINT,  SIG_IGN);
439 	/*
440 	 * Try to umount the mountpoint.
441 	 * If that fails, try the corresponding special.
442 	 * (This ordering is necessary for nfs umounts.)
443 	 * (for remote resources:  if the first umount returns EBUSY
444 	 * don't call umount again - umount() with a resource name
445 	 * will return a misleading error to the user
446 	 */
447 	if (fflg) {
448 		if (((ret = umount2(ment->mnt_mountp, MS_FORCE)) < 0) &&
449 				(errno != EBUSY && errno != ENOTSUP &&
450 				errno != EPERM))
451 			ret = umount2(ment->mnt_special, MS_FORCE);
452 	} else {
453 		if (((ret = umount2(ment->mnt_mountp, 0)) < 0) &&
454 				(errno != EBUSY) && (errno != EPERM))
455 			ret = umount2(ment->mnt_special, 0);
456 	}
457 
458 	if (ret < 0) {
459 		rpterr(ment->mnt_mountp);
460 		if (errno != EINVAL && errno != EFAULT)
461 			exit(1);
462 
463 		exitcode = 1;
464 	}
465 
466 	exit(exitcode);
467 }
468 
469 void
470 rpterr(char *sp)
471 {
472 	switch (errno) {
473 	case EPERM:
474 		fprintf(stderr, gettext("%s: permission denied\n"), myname);
475 		break;
476 	case ENXIO:
477 		fprintf(stderr, gettext("%s: %s no device\n"), myname, sp);
478 		break;
479 	case ENOENT:
480 		fprintf(stderr,
481 			gettext("%s: %s no such file or directory\n"),
482 			myname, sp);
483 		break;
484 	case EINVAL:
485 		fprintf(stderr, gettext("%s: %s not mounted\n"), myname, sp);
486 		break;
487 	case EBUSY:
488 		fprintf(stderr, gettext("%s: %s busy\n"), myname, sp);
489 		break;
490 	case ENOTBLK:
491 		fprintf(stderr,
492 			gettext("%s: %s block device required\n"), myname, sp);
493 		break;
494 	case ECOMM:
495 		fprintf(stderr,
496 			gettext("%s: warning: broken link detected\n"), myname);
497 		break;
498 	default:
499 		perror(myname);
500 		fprintf(stderr, gettext("%s: cannot unmount %s\n"), myname, sp);
501 	}
502 }
503 
504 void
505 usage(void)
506 {
507 	fprintf(stderr, gettext(
508 "Usage:\n%s [-f] [-V] [-o specific_options] {special | mount-point}\n"),
509 		myname);
510 	fprintf(stderr, gettext(
511 "%s -a [-f] [-V] [-o specific_options] [mount_point ...]\n"), myname);
512 	exit(1);
513 }
514 
515 void
516 mnterror(int flag)
517 {
518 	switch (flag) {
519 	case MNT_TOOLONG:
520 		fprintf(stderr,
521 			gettext("%s: line in mnttab exceeds %d characters\n"),
522 			myname, MNT_LINE_MAX-2);
523 		break;
524 	case MNT_TOOFEW:
525 		fprintf(stderr,
526 			gettext("%s: line in mnttab has too few entries\n"),
527 			myname);
528 		break;
529 	default:
530 		break;
531 	}
532 }
533 
534 /*
535  * Search the mlist linked list for the
536  * first match of specp or mntp.  The list is expected to be in reverse
537  * order of /etc/mnttab.
538  * If both are specified, then both have to match.
539  * Returns the (mountent_t *) of the match, otherwise returns NULL.
540  */
541 mountent_t *
542 getmntlast(mountent_t *mlist, char *specp, char *mntp)
543 {
544 	int		mfound, sfound;
545 
546 	for (/* */; mlist; mlist = mlist->link) {
547 		mfound = sfound = 0;
548 		if (mntp && (strcmp(mlist->ment.mnt_mountp, mntp) == 0)) {
549 			if (specp == NULL)
550 				return (mlist);
551 			mfound++;
552 		}
553 		if (specp && (strcmp(mlist->ment.mnt_special, specp) == 0)) {
554 			if (mntp == NULL)
555 				return (mlist);
556 			sfound++;
557 		}
558 		if (mfound && sfound)
559 			return (mlist);
560 	}
561 	return (NULL);
562 }
563 
564 
565 
566 /*
567  * Perform the parallel version of umount.  Returns 0 if no errors occurred,
568  * non zero otherwise.
569  */
570 int
571 parumount(char **mntlist, int count)
572 {
573 	int 		maxfd = OPEN_MAX;
574 	struct rlimit 	rl;
575 	mountent_t	**mntarray, **ml, *mp;
576 
577 	/*
578 	 * If no mount points are specified and none were found in mnttab,
579 	 * then end it all here.
580 	 */
581 	if (count == 0 && mntll == NULL)
582 		return (0);
583 
584 	/*
585 	 * This is the process scaling section.  After running a series
586 	 * of tests based on the number of simultaneous processes and
587 	 * processors available, optimum performance was achieved near or
588 	 * at (PROCN * 2).
589 	 */
590 	if ((maxrun = sysconf(_SC_NPROCESSORS_ONLN)) == -1)
591 		maxrun = 4;
592 	else
593 		maxrun = maxrun * 2 + 1;
594 
595 	if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
596 		rl.rlim_cur = rl.rlim_max;
597 		if (setrlimit(RLIMIT_NOFILE, &rl) == 0)
598 			maxfd = (int)rl.rlim_cur;
599 		(void) enable_extended_FILE_stdio(-1, -1);
600 	}
601 
602 	/*
603 	 * The parent needs to maintain 3 of its own fd's, plus 2 for
604 	 * each child (the stdout and stderr pipes).
605 	 */
606 	maxfd = (maxfd / 2) - 6;	/* 6 takes care of temporary  */
607 					/* periods of open fds */
608 	if (maxfd < maxrun)
609 		maxrun = maxfd;
610 	if (maxrun < 4)
611 		maxrun = 4;		/* sanity check */
612 
613 	mntarray = make_mntarray(mntlist, count);
614 
615 	if (listlength == 0) {
616 		if (count == 0)		/* not an error, just none found */
617 			return (0);
618 		fprintf(stderr, gettext("%s: no valid entries found in %s\n"),
619 				myname, mnttab);
620 		return (1);
621 	}
622 
623 	/*
624 	 * Sort the entries based on their mount level only if lofs's are
625 	 * not present.
626 	 */
627 	if (lofscnt == 0) {
628 		qsort((void *)mntarray, listlength, sizeof (mountent_t *),
629 			mcompar);
630 		/*
631 		 * If we do not detect a lofs by now, we never will.
632 		 */
633 		lofscnt = -1;
634 	}
635 	/*
636 	 * Now link them up so that a given pid is easier to find when
637 	 * we go to clean up after they are done.
638 	 */
639 	mntll = mntarray[0];
640 	for (ml = mntarray; mp = *ml; /* */)
641 		mp->link = *++ml;
642 
643 	/*
644 	 * Try to handle interrupts in a reasonable way.
645 	 */
646 	sigset(SIGHUP, cleanup);
647 	sigset(SIGQUIT, cleanup);
648 	sigset(SIGINT, cleanup);
649 
650 	do_umounts(mntarray);	/* do the umounts */
651 	return (exitcode);
652 }
653 
654 /*
655  * Returns a mountent_t array based on mntlist.  If mntlist is NULL, then
656  * it returns all mnttab entries with a few exceptions.  Sets the global
657  * variable listlength to the number of entries in the array.
658  */
659 mountent_t **
660 make_mntarray(char **mntlist, int count)
661 {
662 	mountent_t 	*mp, **mpp;
663 	int 		ndx;
664 	char		*cp;
665 
666 	if (count > 0)
667 		listlength = count;
668 
669 	mpp = (mountent_t **)malloc(sizeof (*mp) * (listlength + 1));
670 	if (mpp == NULL)
671 		nomem();
672 
673 	if (count == 0) {
674 		if (mntll == NULL) {	/* no entries? */
675 			listlength = 0;
676 			return (NULL);
677 		}
678 		/*
679 		 * No mount list specified: take all mnttab mount points
680 		 * except for a few cases.
681 		 */
682 		for (ndx = 0, mp = mntll; mp; mp = mp->link) {
683 			if (fsstrinlist(mp->ment.mnt_mountp, keeplist))
684 				continue;
685 			mp->mlevel = fsgetmlevel(mp->ment.mnt_mountp);
686 			if (mp->ment.mnt_fstype &&
687 			    (strcmp(mp->ment.mnt_fstype, MNTTYPE_LOFS) == 0))
688 				lofscnt++;
689 
690 			mpp[ndx++] = mp;
691 		}
692 		mpp[ndx] = NULL;
693 		listlength = ndx;
694 		return (mpp);
695 	}
696 
697 	/*
698 	 * A list of mount points was specified on the command line.
699 	 * Build an array out of these.
700 	 */
701 	for (ndx = 0; count--; ) {
702 		cp = *mntlist++;
703 		if (realpath(cp, resolve) == NULL) {
704 			fprintf(stderr,
705 				gettext("%s: warning: can't resolve %s\n"),
706 				myname, cp);
707 			exitcode = 1;
708 			mp = getmntlast(mntll, NULL, cp); /* try anyways */
709 		} else
710 			mp = getmntlast(mntll, NULL, resolve);
711 		if (mp == NULL) {
712 			struct mnttab mnew;
713 			/*
714 			 * Then we've reached the end without finding
715 			 * what we are looking for, but we still have to
716 			 * try to umount it: append it to mntarray.
717 			 */
718 			fprintf(stderr, gettext(
719 				"%s: warning: %s not found in %s\n"),
720 				myname, resolve, mnttab);
721 			exitcode = 1;
722 			mntnull(&mnew);
723 			mnew.mnt_special = mnew.mnt_mountp = strdup(resolve);
724 			if (mnew.mnt_special == NULL)
725 				nomem();
726 			mp = new_mountent(&mnew);
727 		}
728 		if (mp->ment.mnt_fstype &&
729 		    (strcmp(mp->ment.mnt_fstype, MNTTYPE_LOFS) == 0))
730 			lofscnt++;
731 
732 		mp->mlevel = fsgetmlevel(mp->ment.mnt_mountp);
733 		mpp[ndx++] = mp;
734 	}
735 	mpp[ndx] = NULL;
736 	listlength = ndx;
737 	return (mpp);
738 }
739 
740 /*
741  * Returns the tail of a linked list of all mnttab entries.  I.e, it's faster
742  * to return the mnttab in reverse order.
743  * Sets listlength to the number of entries in the list.
744  * Returns NULL if none are found.
745  */
746 mountent_t *
747 getmntall(void)
748 {
749 	FILE		*fp;
750 	mountent_t	*mtail;
751 	int		cnt = 0, ret;
752 	struct mnttab	mget;
753 
754 	if ((fp = fopen(mnttab, "r")) == NULL) {
755 		fprintf(stderr, gettext("%s: warning cannot open %s\n"),
756 				myname, mnttab);
757 		return (0);
758 	}
759 	mtail = NULL;
760 
761 	while ((ret = getmntent(fp, &mget)) != -1) {
762 		mountent_t	*mp;
763 
764 		if (ret > 0) {
765 			mnterror(ret);
766 			continue;
767 		}
768 
769 		mp = new_mountent(&mget);
770 		mp->link = mtail;
771 		mtail = mp;
772 		cnt++;
773 	}
774 	fclose(fp);
775 	if (mtail == NULL) {
776 		listlength = 0;
777 		return (NULL);
778 	}
779 	listlength = cnt;
780 	return (mtail);
781 }
782 
783 void
784 do_umounts(mountent_t **mntarray)
785 {
786 	mountent_t *mp, *mpprev, **ml = mntarray;
787 	int	cnt = listlength;
788 
789 	/*
790 	 * Main loop for the forked children:
791 	 */
792 	for (mpprev = *ml; mp = *ml; mpprev = mp, ml++, cnt--) {
793 		pid_t	pid;
794 
795 		/*
796 		 * Check to see if we cross a mount level: e.g.,
797 		 * /a/b/c -> /a/b.  If so, we need to wait for all current
798 		 * umounts to finish before umounting the rest.
799 		 *
800 		 * Also, we unmount serially as long as there are lofs's
801 		 * to mount to avoid improper umount ordering.
802 		 */
803 		if (mp->mlevel < mpprev->mlevel || lofscnt > 0)
804 			while (nrun > 0 && (dowait() != -1))
805 				;
806 
807 		if (lofscnt == 0) {
808 			/*
809 			 * We can now go to parallel umounting.
810 			 */
811 			qsort((void *)ml, cnt, sizeof (mountent_t *), mcompar);
812 			mp = *ml;	/* possible first entry */
813 			lofscnt--;	/* so we don't do this again */
814 		}
815 
816 		while (setup_iopipe(mp) == -1 && (dowait() != -1))
817 			;
818 
819 		while (nrun >= maxrun && (dowait() != -1))	/* throttle */
820 			;
821 
822 #ifdef CACHEFS_BUG
823 		/*
824 		 * If this is the back file system, then let cachefs/umount
825 		 * unmount it.
826 		 */
827 		if (strstr(mp->ment.mnt_mountp, BACKMNT_NAME))
828 			continue;
829 
830 
831 		if (mp->ment.mnt_fstype &&
832 		    (strcmp(mp->ment.mnt_fstype, "cachefs") == 0)) {
833 			while (cachefs_running && (dowait() != -1))
834 					;
835 			cachefs_running = 1;
836 		}
837 #endif
838 
839 		if ((pid = fork()) == -1) {
840 			perror("fork");
841 			cleanup(-1);
842 			/* not reached */
843 		}
844 #ifdef DEBUG
845 		if (dflg && pid > 0) {
846 			fprintf(stderr, "parent %d: umounting %d %s\n",
847 				getpid(), pid, mp->ment.mnt_mountp);
848 		}
849 #endif
850 		if (pid == 0) {		/* child */
851 			signal(SIGHUP, SIG_IGN);
852 			signal(SIGQUIT, SIG_IGN);
853 			signal(SIGINT, SIG_IGN);
854 			setup_output(mp);
855 			doexec(&mp->ment);
856 			perror("exec");
857 			exit(1);
858 		}
859 
860 		/* parent */
861 		(void) close(mp->sopipe[WRPIPE]);
862 		(void) close(mp->sepipe[WRPIPE]);
863 		mp->pid = pid;
864 		nrun++;
865 	}
866 	cleanup(0);
867 }
868 
869 /*
870  * cleanup the existing children and exit with an error
871  * if asig != 0.
872  */
873 void
874 cleanup(int asig)
875 {
876 	/*
877 	 * Let the stragglers finish.
878 	 */
879 	while (nrun > 0 && (dowait() != -1))
880 		;
881 	if (asig != 0)
882 		exit(1);
883 }
884 
885 
886 /*
887  * Waits for 1 child to die.
888  *
889  * Returns -1 if no children are left to wait for.
890  * Returns 0 if a child died without an error.
891  * Returns 1 if a child died with an error.
892  * Sets the global exitcode if an error occurred.
893  */
894 int
895 dowait(void)
896 {
897 	int		wstat, child, ret;
898 	mountent_t 	*mp, *prevp;
899 
900 	if ((child = wait(&wstat)) == -1)
901 		return (-1);
902 
903 	if (WIFEXITED(wstat))		/* this should always be true */
904 		ret = WEXITSTATUS(wstat);
905 	else
906 		ret = 1;		/* assume some kind of error */
907 	nrun--;
908 	if (ret)
909 		exitcode = 1;
910 
911 	/*
912 	 * Find our child so we can process its std output, if any.
913 	 * This search gets smaller and smaller as children are cleaned
914 	 * up.
915 	 */
916 	for (prevp = NULL, mp = mntll; mp; mp = mp->link) {
917 		if (mp->pid != child) {
918 			prevp = mp;
919 			continue;
920 		}
921 		/*
922 		 * Found: let's remove it from this list.
923 		 */
924 		if (prevp) {
925 			prevp->link = mp->link;
926 			mp->link = NULL;
927 		}
928 		break;
929 	}
930 
931 	if (mp == NULL) {
932 		/*
933 		 * This should never happen.
934 		 */
935 #ifdef DEBUG
936 		fprintf(stderr, gettext(
937 			"%s: unknown child %d\n"), myname, child);
938 #endif
939 		exitcode = 1;
940 		return (1);
941 	}
942 	doio(mp);	/* Any output? */
943 
944 	if (mp->ment.mnt_fstype &&
945 	    (strcmp(mp->ment.mnt_fstype, MNTTYPE_LOFS) == 0))
946 		lofscnt--;
947 
948 #ifdef CACHEFS_BUG
949 	if (mp->ment.mnt_fstype &&
950 	    (strcmp(mp->ment.mnt_fstype, "cachefs") == 0))
951 		cachefs_running = 0;
952 #endif
953 
954 	return (ret);
955 }
956 
957 static const mountent_t zmount = { 0 };
958 
959 mountent_t *
960 new_mountent(struct mnttab *ment)
961 {
962 	mountent_t *new;
963 
964 	new = (mountent_t *)malloc(sizeof (*new));
965 	if (new == NULL)
966 		nomem();
967 
968 	*new = zmount;
969 	if (ment->mnt_special &&
970 	    (new->ment.mnt_special = strdup(ment->mnt_special)) == NULL)
971 		nomem();
972 	if (ment->mnt_mountp &&
973 	    (new->ment.mnt_mountp = strdup(ment->mnt_mountp)) == NULL)
974 		nomem();
975 	if (ment->mnt_fstype &&
976 	    (new->ment.mnt_fstype = strdup(ment->mnt_fstype)) == NULL)
977 		nomem();
978 	return (new);
979 }
980 
981 
982 /*
983  * Sort in descending order of "mount level".  For example, /a/b/c is
984  * placed before /a/b .
985  */
986 int
987 mcompar(const void *a, const void *b)
988 {
989 	mountent_t *a1, *b1;
990 
991 	a1 = *(mountent_t **)a;
992 	b1 = *(mountent_t **)b;
993 	return (b1->mlevel - a1->mlevel);
994 }
995 
996 /*
997  * The purpose of this routine is to form stdout and stderr
998  * pipes for the children's output.  The parent then reads and writes it
999  * out it serially in order to ensure that the output is
1000  * not garbled.
1001  */
1002 
1003 int
1004 setup_iopipe(mountent_t *mp)
1005 {
1006 	/*
1007 	 * Make a stdout and stderr pipe.  This should never fail.
1008 	 */
1009 	if (pipe(mp->sopipe) == -1)
1010 		return (-1);
1011 	if (pipe(mp->sepipe) == -1) {
1012 		(void) close(mp->sopipe[RDPIPE]);
1013 		(void) close(mp->sopipe[WRPIPE]);
1014 		return (-1);
1015 	}
1016 	/*
1017 	 * Don't block on an empty pipe.
1018 	 */
1019 	(void) fcntl(mp->sopipe[RDPIPE], F_SETFL, O_NDELAY|O_NONBLOCK);
1020 	(void) fcntl(mp->sepipe[RDPIPE], F_SETFL, O_NDELAY|O_NONBLOCK);
1021 	return (0);
1022 }
1023 
1024 /*
1025  * Called by a child to attach its stdout and stderr to the write side of
1026  * the pipes.
1027  */
1028 void
1029 setup_output(mountent_t *mp)
1030 {
1031 	(void) close(fileno(stdout));
1032 	(void) dup(mp->sopipe[WRPIPE]);
1033 	(void) close(mp->sopipe[WRPIPE]);
1034 
1035 	(void) close(fileno(stderr));
1036 	(void) dup(mp->sepipe[WRPIPE]);
1037 	(void) close(mp->sepipe[WRPIPE]);
1038 }
1039 
1040 /*
1041  * Parent uses this to print any stdout or stderr output issued by
1042  * the child.
1043  */
1044 static void
1045 doio(mountent_t *mp)
1046 {
1047 	int bytes;
1048 
1049 	while ((bytes = read(mp->sepipe[RDPIPE], ibuf, sizeof (ibuf))) > 0)
1050 		write(fileno(stderr), ibuf, bytes);
1051 	while ((bytes = read(mp->sopipe[RDPIPE], ibuf, sizeof (ibuf))) > 0)
1052 		write(fileno(stdout), ibuf, bytes);
1053 
1054 	(void) close(mp->sopipe[RDPIPE]);
1055 	(void) close(mp->sepipe[RDPIPE]);
1056 }
1057 
1058 void
1059 nomem(void)
1060 {
1061 	fprintf(stderr, gettext("%s: out of memory\n"), myname);
1062 	/*
1063 	 * Let the stragglers finish.
1064 	 */
1065 	while (nrun > 0 && (dowait() != -1))
1066 		;
1067 	exit(1);
1068 }
1069