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 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 22 /* All Rights Reserved */ 23 24 25 /* 26 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 /* 30 * Copyright 2012 Nexenta Systems, Inc. All rights reserved. 31 */ 32 33 #include <stdio.h> 34 #include <stdio_ext.h> 35 #include <limits.h> 36 #include <fcntl.h> 37 #include <unistd.h> 38 #include <stdlib.h> 39 #include <string.h> 40 #include <stdarg.h> 41 #include <sys/types.h> 42 #include <sys/stat.h> 43 #include <sys/statvfs.h> 44 #include <errno.h> 45 #include <sys/mnttab.h> 46 #include <sys/mntent.h> 47 #include <sys/mount.h> 48 #include <sys/vfstab.h> 49 #include <sys/param.h> 50 #include <sys/wait.h> 51 #include <sys/signal.h> 52 #include <sys/resource.h> 53 #include <stropts.h> 54 #include <sys/conf.h> 55 #include <locale.h> 56 #include "fslib.h" 57 58 #define VFS_PATH "/usr/lib/fs" 59 #define ALT_PATH "/etc/fs" 60 #define REMOTE "/etc/dfs/fstypes" 61 62 #define ARGV_MAX 16 63 #define TIME_MAX 50 64 #define FSTYPE_MAX 8 65 #define REMOTE_MAX 64 66 67 #define OLD 0 68 #define NEW 1 69 70 #define READONLY 0 71 #define READWRITE 1 72 #define SUID 2 73 #define NOSUID 3 74 #define SETUID 4 75 #define NOSETUID 5 76 #define DEVICES 6 77 #define NODEVICES 7 78 79 #define FORMAT "%a %b %e %H:%M:%S %Y\n" /* date time format */ 80 /* a - abbreviated weekday name */ 81 /* b - abbreviated month name */ 82 /* e - day of month */ 83 /* H - hour */ 84 /* M - minute */ 85 /* S - second */ 86 /* Y - Year */ 87 /* n - newline */ 88 89 /* 90 * The fs-local method understands this exit code to mean that one or 91 * more failures occurred and that all the failures were of attempted 92 * lofs mounts. 93 */ 94 #define ALL_LOFS_FAILURES 111 95 96 extern int optind; 97 extern char *optarg; 98 99 extern void usage(void); 100 extern char *flags(char *, int); 101 extern char *remote(char *, FILE *); 102 extern char *default_fstype(char *); 103 104 char *myopts[] = { 105 MNTOPT_RO, 106 MNTOPT_RW, 107 MNTOPT_SUID, 108 MNTOPT_NOSUID, 109 MNTOPT_SETUID, 110 MNTOPT_NOSETUID, 111 MNTOPT_DEVICES, 112 MNTOPT_NODEVICES, 113 NULL 114 }; 115 116 static char *myname; /* point to argv[0] */ 117 118 /* 119 * Set the limit to double the number of characters a user should be allowed to 120 * type in one line. 121 * This should cover the different shells, which don't use POSIX_MAX_INPUT, 122 * and should cover the case where a long option string can be in 123 * the /etc/vfstab file. 124 */ 125 char mntflags[(_POSIX_MAX_INPUT+1) * 2]; 126 127 char realdir[MAXPATHLEN]; /* buffer for realpath() calls */ 128 char *vfstab = VFSTAB; 129 char *mnttab = MNTTAB; 130 char *specific_opts; /* holds specific mount options */ 131 char *generic_opts; /* holds generic mount options */ 132 int maxrun; 133 int nrun; 134 int failcnt; /* total count of failures */ 135 int lofscnt; /* presence of lofs prohibits parallel */ 136 /* mounting */ 137 int lofsfail; /* count of failures of lofs mounts */ 138 int exitcode; 139 int aflg, cflg, fflg, Fflg, gflg, oflg, pflg, rflg, vflg, Vflg, mflg, Oflg, 140 dashflg, questflg, dflg, qflg; 141 142 /* 143 * Currently, mounting cachefs instances simultaneously uncovers various 144 * problems. For the short term, we serialize cachefs activity while we fix 145 * these cachefs bugs. 146 */ 147 #define CACHEFS_BUG 148 #ifdef CACHEFS_BUG 149 int cachefs_running; /* parallel cachefs not supported yet */ 150 #endif 151 152 /* 153 * Each vfsent_t describes a vfstab entry. It is used to manage and cleanup 154 * each child that performs the particular mount for the entry. 155 */ 156 157 typedef struct vfsent { 158 struct vfstab v; /* the vfstab entry */ 159 char *rpath; /* resolved pathname so far */ 160 int mlevel; /* how deep is this mount point */ 161 int order; /* vfstab serial order of this vfs */ 162 int flag; 163 pid_t pid; /* the pid of this mount process */ 164 int exitcode; /* process's exitcode */ 165 #define RDPIPE 0 166 #define WRPIPE 1 167 int sopipe[2]; /* pipe attached to child's stdout */ 168 int sepipe[2]; /* pipe attached to child's stderr */ 169 struct vfsent *next; /* used when in linked list */ 170 } vfsent_t; 171 172 #define VRPFAILED 0x01 /* most recent realpath failed on */ 173 /* this mount point */ 174 #define VNOTMOUNTED 0x02 /* mount point could not be mounted */ 175 176 vfsent_t *vfsll, *vfslltail; /* head and tail of the global */ 177 /* linked list of vfstab entries */ 178 vfsent_t **vfsarray; /* global array of vfsent_t's */ 179 int vfsarraysize; /* length of the list */ 180 181 /* 182 * This structure is used to build a linked list of 183 * mnttab structures from /etc/mnttab. 184 */ 185 typedef struct mountent { 186 struct extmnttab *ment; 187 int flag; 188 struct mountent *next; 189 } mountent_t; 190 191 #define MSORTED 0x1 192 193 static vfsent_t **make_vfsarray(char **, int); 194 static vfsent_t *new_vfsent(struct vfstab *, int); 195 static vfsent_t *getvfsall(char *, int); 196 197 static void doexec(char *, char **); 198 static void nomem(); 199 static void cleanup(int); 200 static char *setrpath(vfsent_t *); 201 static int dowait(); 202 static int setup_iopipe(vfsent_t *); 203 static void setup_output(vfsent_t *); 204 static void doio(vfsent_t *); 205 static void do_mounts(); 206 static int parmount(char **, int, char *); 207 static int mlevelcmp(const void *, const void *); 208 static int mordercmp(const void *, const void *); 209 static int check_fields(char *, char *); 210 static int cleanupkid(pid_t, int); 211 static void print_mnttab(int, int); 212 static void vfserror(int, char *); 213 static void mnterror(int); 214 static int ignore(char *); 215 216 /* 217 * This is /usr/sbin/mount: the generic command that in turn 218 * execs the appropriate /usr/lib/fs/{fstype}/mount. 219 * The -F flag and argument are NOT passed. 220 * If the usr file system is not mounted a duplicate copy 221 * can be found in /sbin and this version execs the 222 * appropriate /etc/fs/{fstype}/mount 223 * 224 * If the -F fstype, special or directory are missing, 225 * /etc/vfstab is searched to fill in the missing arguments. 226 * 227 * -V will print the built command on the stdout. 228 * It isn't passed either. 229 */ 230 int 231 main(int argc, char *argv[]) 232 { 233 char *special, /* argument of special/resource */ 234 *mountp, /* argument of mount directory */ 235 *fstype, /* wherein the fstype name is filled */ 236 *newargv[ARGV_MAX], /* arg list for specific command */ 237 *farg = NULL, *Farg = NULL; 238 int ii, ret, cc, fscnt; 239 struct stat64 stbuf; 240 struct vfstab vget, vref; 241 mode_t mode; 242 FILE *fd; 243 244 (void) setlocale(LC_ALL, ""); 245 246 #if !defined(TEXT_DOMAIN) 247 #define TEXT_DOMAIN "SYS_TEST" 248 #endif 249 (void) textdomain(TEXT_DOMAIN); 250 251 myname = strrchr(argv[0], '/'); 252 if (myname) 253 myname++; 254 else 255 myname = argv[0]; 256 if (myname == 0) myname = "path unknown"; 257 258 /* Process the args. */ 259 260 while ((cc = getopt(argc, argv, "?acd:f:F:gmno:pqrvVO")) != -1) 261 switch (cc) { 262 case 'a': 263 aflg++; 264 break; 265 case 'c': 266 cflg++; 267 break; 268 269 #ifdef DEBUG 270 case 'd': 271 dflg = atoi(optarg); 272 break; 273 #endif 274 275 case 'f': 276 fflg++; 277 farg = optarg; 278 break; 279 case 'F': 280 Fflg++; 281 Farg = optarg; 282 break; 283 case 'g': 284 gflg++; 285 break; 286 case 'm': 287 mflg++; 288 break; /* do not update /etc/mnttab */ 289 case 'o': 290 oflg++; 291 if ((specific_opts = strdup(optarg)) == NULL) 292 nomem(); 293 break; /* fstype dependent options */ 294 case 'O': 295 Oflg++; 296 break; 297 case 'p': 298 pflg++; 299 break; 300 case 'q': 301 qflg++; 302 break; 303 case 'r': 304 rflg++; 305 generic_opts = "ro"; 306 break; 307 case 'v': 308 vflg++; 309 break; 310 case 'V': 311 Vflg++; 312 break; 313 case '?': 314 questflg++; 315 break; 316 } 317 318 /* copy '--' to specific */ 319 if (strcmp(argv[optind-1], "--") == 0) 320 dashflg++; 321 322 /* option checking */ 323 /* more than two args not allowed if !aflg */ 324 if (!aflg && (argc - optind > 2)) 325 usage(); 326 327 /* pv mututally exclusive */ 328 if (pflg + vflg + aflg > 1) { 329 fprintf(stderr, gettext 330 ("%s: -a, -p, and -v are mutually exclusive\n"), 331 myname); 332 usage(); 333 } 334 335 /* 336 * Can't have overlaying mounts on the same mount point during 337 * a parallel mount. 338 */ 339 if (aflg && Oflg) { 340 fprintf(stderr, gettext 341 ("%s: -a and -O are mutually exclusive\n"), myname); 342 usage(); 343 } 344 345 /* dfF mutually exclusive */ 346 if (fflg + Fflg > 1) { 347 fprintf(stderr, gettext 348 ("%s: More than one FSType specified\n"), myname); 349 usage(); 350 } 351 352 /* no arguments, only allow p,v,V or [F]? */ 353 if (!aflg && optind == argc) { 354 if (cflg || fflg || mflg || oflg || rflg || qflg) 355 usage(); 356 357 if (Fflg && !questflg) 358 usage(); 359 360 if (questflg) { 361 if (Fflg) { 362 newargv[2] = "-?"; 363 newargv[3] = NULL; 364 doexec(Farg, newargv); 365 } 366 usage(); 367 } 368 } 369 370 if (questflg) 371 usage(); 372 373 /* one or two args, allow any but p,v */ 374 if (optind != argc && (pflg || vflg)) { 375 fprintf(stderr, 376 gettext("%s: Cannot use -p and -v with arguments\n"), myname); 377 usage(); 378 } 379 380 381 /* if only reporting mnttab, generic prints mnttab and exits */ 382 if (!aflg && optind == argc) { 383 if (Vflg) { 384 printf("%s", myname); 385 if (pflg) 386 printf(" -p"); 387 if (vflg) 388 printf(" -v"); 389 printf("\n"); 390 exit(0); 391 } 392 393 print_mnttab(vflg, pflg); 394 exit(0); 395 } 396 397 /* 398 * Get filesystem type here. If "-F FStype" is specified, use 399 * that fs type. Otherwise, determine the fs type from /etc/vfstab 400 * if the entry exists. Otherwise, determine the local or remote 401 * fs type from /etc/default/df or /etc/dfs/fstypes respectively. 402 */ 403 if (fflg) { 404 if ((strcmp(farg, "S51K") != 0) && 405 (strcmp(farg, "S52K") != 0)) { 406 fstype = farg; 407 } 408 else 409 fstype = "ufs"; 410 } else /* if (Fflg) */ 411 fstype = Farg; 412 413 fscnt = argc - optind; 414 if (aflg && (fscnt != 1)) 415 exit(parmount(argv + optind, fscnt, fstype)); 416 417 /* 418 * Then don't bother with the parallel over head. Everything 419 * from this point is simple/normal single execution. 420 */ 421 aflg = 0; 422 423 /* get special and/or mount-point from arg(s) */ 424 if (fscnt == 2) 425 special = argv[optind++]; 426 else 427 special = NULL; 428 if (optind < argc) 429 mountp = argv[optind++]; 430 else 431 mountp = NULL; 432 433 /* lookup only if we need to */ 434 if (fstype == NULL || specific_opts == NULL || special == NULL || 435 mountp == NULL) { 436 if ((fd = fopen(vfstab, "r")) == NULL) { 437 if (fstype == NULL || special == NULL || 438 mountp == NULL) { 439 fprintf(stderr, gettext( 440 "%s: Cannot open %s\n"), 441 myname, vfstab); 442 exit(1); 443 } else { 444 /* 445 * No vfstab, but we know what we want 446 * to mount. 447 */ 448 goto out; 449 } 450 } 451 vfsnull(&vref); 452 vref.vfs_special = special; 453 vref.vfs_mountp = mountp; 454 vref.vfs_fstype = fstype; 455 456 /* get a vfstab entry matching mountp or special */ 457 while ((ret = getvfsany(fd, &vget, &vref)) > 0) 458 vfserror(ret, vget.vfs_special); 459 460 /* if no entry and there was only one argument */ 461 /* then the argument could be the special */ 462 /* and not mount point as we thought earlier */ 463 if (ret == -1 && special == NULL) { 464 rewind(fd); 465 special = vref.vfs_special = mountp; 466 mountp = vref.vfs_mountp = NULL; 467 /* skip erroneous lines; they were reported above */ 468 while ((ret = getvfsany(fd, &vget, &vref)) > 0) 469 ; 470 } 471 472 fclose(fd); 473 474 if (ret == 0) { 475 if (fstype == NULL) 476 fstype = vget.vfs_fstype; 477 if (special == NULL) 478 special = vget.vfs_special; 479 if (mountp == NULL) 480 mountp = vget.vfs_mountp; 481 if (oflg == 0 && vget.vfs_mntopts) { 482 oflg++; 483 specific_opts = vget.vfs_mntopts; 484 } 485 } else if (special == NULL) { 486 if (stat64(mountp, &stbuf) == -1) { 487 fprintf(stderr, gettext("%s: cannot stat %s\n"), 488 myname, mountp); 489 exit(2); 490 } 491 if (((mode = (stbuf.st_mode & S_IFMT)) == S_IFBLK) || 492 (mode == S_IFCHR)) { 493 fprintf(stderr, 494 gettext("%s: mount point cannot be determined\n"), 495 myname); 496 exit(1); 497 } else 498 { 499 fprintf(stderr, 500 gettext("%s: special cannot be determined\n"), 501 myname); 502 exit(1); 503 } 504 } else if (fstype == NULL) 505 fstype = default_fstype(special); 506 } 507 508 out: 509 if (realpath(mountp, realdir) == NULL) { 510 (void) fprintf(stderr, "mount: "); 511 perror(mountp); 512 exit(1); 513 } 514 515 if ((mountp = strdup(realdir)) == NULL) 516 nomem(); 517 518 if (check_fields(fstype, mountp)) 519 exit(1); 520 521 /* create the new arg list, and end the list with a null pointer */ 522 ii = 2; 523 if (cflg) 524 newargv[ii++] = "-c"; 525 if (gflg) 526 newargv[ii++] = "-g"; 527 if (mflg) 528 newargv[ii++] = "-m"; 529 /* 530 * The q option needs to go before the -o option as some 531 * filesystems complain during first pass option parsing. 532 */ 533 if (qflg) 534 newargv[ii++] = "-q"; 535 if (oflg) { 536 newargv[ii++] = "-o"; 537 newargv[ii++] = specific_opts; 538 } 539 if (Oflg) 540 newargv[ii++] = "-O"; 541 if (rflg) 542 newargv[ii++] = "-r"; 543 if (dashflg) 544 newargv[ii++] = "--"; 545 newargv[ii++] = special; 546 newargv[ii++] = mountp; 547 newargv[ii] = NULL; 548 549 doexec(fstype, newargv); 550 return (0); 551 } 552 553 void 554 usage(void) 555 { 556 fprintf(stderr, gettext("Usage:\n%s [-v | -p]\n"), myname); 557 fprintf(stderr, gettext( 558 "%s [-F FSType] [-V] [current_options] [-o specific_options]"), 559 myname); 560 fprintf(stderr, gettext("\n\t{special | mount_point}\n")); 561 562 fprintf(stderr, gettext( 563 "%s [-F FSType] [-V] [current_options] [-o specific_options]"), 564 myname); 565 fprintf(stderr, gettext("\n\tspecial mount_point\n")); 566 567 fprintf(stderr, gettext( 568 "%s -a [-F FSType ] [-V] [current_options] [-o specific_options]\n"), 569 myname); 570 fprintf(stderr, gettext("\t[mount_point ...]\n")); 571 572 exit(1); 573 } 574 575 /* 576 * Get rid of "dev=[hex string]" clause, if any. It's not legal 577 * when printing in vfstab format. 578 */ 579 void 580 elide_dev(char *mntopts) 581 { 582 char *dev, *other; 583 584 if (mntopts != NULL) { 585 dev = strstr(mntopts, "dev="); 586 if (dev != NULL) { 587 other = strpbrk(dev, ","); 588 if (other == NULL) { 589 /* last option */ 590 if (dev != mntopts) { 591 *--dev = '\0'; 592 } else { 593 *dev = '\0'; 594 } 595 } else { 596 /* first or intermediate option */ 597 memmove(dev, other+1, strlen(other+1)+1); 598 } 599 } 600 } 601 } 602 603 void 604 print_mnttab(int vflg, int pflg) 605 { 606 FILE *fd; 607 FILE *rfp; /* this will be NULL if fopen fails */ 608 int ret; 609 char time_buf[TIME_MAX]; /* array to hold date and time */ 610 struct extmnttab mget; 611 time_t ltime; 612 613 if ((fd = fopen(mnttab, "r")) == NULL) { 614 fprintf(stderr, gettext("%s: Cannot open mnttab\n"), myname); 615 exit(1); 616 } 617 rfp = fopen(REMOTE, "r"); 618 while ((ret = getextmntent(fd, &mget, sizeof (struct extmnttab))) 619 == 0) { 620 if (ignore(mget.mnt_mntopts)) 621 continue; 622 if (mget.mnt_special && mget.mnt_mountp && 623 mget.mnt_fstype && mget.mnt_time) { 624 ltime = atol(mget.mnt_time); 625 cftime(time_buf, FORMAT, <ime); 626 if (pflg) { 627 elide_dev(mget.mnt_mntopts); 628 printf("%s - %s %s - no %s\n", 629 mget.mnt_special, 630 mget.mnt_mountp, 631 mget.mnt_fstype, 632 mget.mnt_mntopts != NULL ? 633 mget.mnt_mntopts : "-"); 634 } else if (vflg) { 635 printf("%s on %s type %s %s%s on %s", 636 mget.mnt_special, 637 mget.mnt_mountp, 638 mget.mnt_fstype, 639 remote(mget.mnt_fstype, rfp), 640 flags(mget.mnt_mntopts, NEW), 641 time_buf); 642 } else 643 printf("%s on %s %s%s on %s", 644 mget.mnt_mountp, 645 mget.mnt_special, 646 remote(mget.mnt_fstype, rfp), 647 flags(mget.mnt_mntopts, OLD), 648 time_buf); 649 } 650 } 651 if (ret > 0) 652 mnterror(ret); 653 } 654 655 char * 656 flags(char *mntopts, int flag) 657 { 658 char opts[sizeof (mntflags)]; 659 char *value; 660 int rdwr = 1; 661 int suid = 1; 662 int devices = 1; 663 int setuid = 1; 664 665 if (mntopts == NULL || *mntopts == '\0') 666 return ("read/write/setuid/devices"); 667 668 strcpy(opts, ""); 669 while (*mntopts != '\0') { 670 switch (getsubopt(&mntopts, myopts, &value)) { 671 case READONLY: 672 rdwr = 0; 673 break; 674 case READWRITE: 675 rdwr = 1; 676 break; 677 case SUID: 678 suid = 1; 679 break; 680 case NOSUID: 681 suid = 0; 682 break; 683 case SETUID: 684 setuid = 1; 685 break; 686 case NOSETUID: 687 setuid = 0; 688 break; 689 case DEVICES: 690 devices = 1; 691 break; 692 case NODEVICES: 693 devices = 0; 694 break; 695 default: 696 /* cat '/' separator to mntflags */ 697 if (*opts != '\0' && value != NULL) 698 strcat(opts, "/"); 699 strcat(opts, value); 700 break; 701 } 702 } 703 704 strcpy(mntflags, ""); 705 if (rdwr) 706 strcat(mntflags, "read/write"); 707 else if (flag == OLD) 708 strcat(mntflags, "read only"); 709 else 710 strcat(mntflags, "read-only"); 711 if (suid) { 712 if (setuid) 713 strcat(mntflags, "/setuid"); 714 else 715 strcat(mntflags, "/nosetuid"); 716 if (devices) 717 strcat(mntflags, "/devices"); 718 else 719 strcat(mntflags, "/nodevices"); 720 } else { 721 strcat(mntflags, "/nosetuid/nodevices"); 722 } 723 if (*opts != '\0') { 724 strcat(mntflags, "/"); 725 strcat(mntflags, opts); 726 } 727 728 /* 729 * The assumed assertion 730 * assert (strlen(mntflags) < sizeof mntflags); 731 * is valid at this point in the code. Note that a call to "assert" 732 * is not appropriate in production code since it halts the program. 733 */ 734 return (mntflags); 735 } 736 737 char * 738 remote(char *fstype, FILE *rfp) 739 { 740 char buf[BUFSIZ]; 741 char *fs; 742 extern char *strtok(); 743 744 if (rfp == NULL || fstype == NULL || 745 strlen(fstype) > (size_t)FSTYPE_MAX) 746 return (""); /* not a remote */ 747 rewind(rfp); 748 while (fgets(buf, sizeof (buf), rfp) != NULL) { 749 fs = strtok(buf, " \t\n"); 750 if (strcmp(fstype, fs) == 0) 751 return ("remote/"); /* is a remote fs */ 752 } 753 return (""); /* not a remote */ 754 } 755 756 757 void 758 vfserror(int flag, char *special) 759 { 760 if (special == NULL) 761 special = "<null>"; 762 switch (flag) { 763 case VFS_TOOLONG: 764 fprintf(stderr, 765 gettext("%s: Warning: Line in vfstab for \"%s\" exceeds %d characters\n"), 766 myname, special, VFS_LINE_MAX-1); 767 break; 768 case VFS_TOOFEW: 769 fprintf(stderr, 770 gettext("%s: Warning: Line for \"%s\" in vfstab has too few entries\n"), 771 myname, special); 772 break; 773 case VFS_TOOMANY: 774 fprintf(stderr, 775 gettext("%s: Warning: Line for \"%s\" in vfstab has too many entries\n"), 776 myname, special); 777 break; 778 default: 779 fprintf(stderr, gettext( 780 "%s: Warning: Error in line for \"%s\" in vfstab\n"), 781 myname, special); 782 } 783 } 784 785 void 786 mnterror(int flag) 787 { 788 switch (flag) { 789 case MNT_TOOLONG: 790 fprintf(stderr, 791 gettext("%s: Line in mnttab exceeds %d characters\n"), 792 myname, MNT_LINE_MAX-2); 793 break; 794 case MNT_TOOFEW: 795 fprintf(stderr, 796 gettext("%s: Line in mnttab has too few entries\n"), 797 myname); 798 break; 799 case MNT_TOOMANY: 800 fprintf(stderr, 801 gettext("%s: Line in mnttab has too many entries\n"), 802 myname); 803 break; 804 } 805 exit(1); 806 } 807 808 void 809 doexec(char *fstype, char *newargv[]) 810 { 811 char full_path[PATH_MAX]; 812 char alter_path[PATH_MAX]; 813 char *vfs_path = VFS_PATH; 814 char *alt_path = ALT_PATH; 815 int i; 816 817 /* build the full pathname of the fstype dependent command. */ 818 sprintf(full_path, "%s/%s/%s", vfs_path, fstype, myname); 819 sprintf(alter_path, "%s/%s/%s", alt_path, fstype, myname); 820 newargv[1] = myname; 821 822 if (Vflg) { 823 printf("%s -F %s", newargv[1], fstype); 824 for (i = 2; newargv[i]; i++) 825 printf(" %s", newargv[i]); 826 printf("\n"); 827 fflush(stdout); 828 exit(0); 829 } 830 831 /* 832 * Try to exec the fstype dependent portion of the mount. 833 * See if the directory is there before trying to exec dependent 834 * portion. This is only useful for eliminating the 835 * '..mount: not found' message when '/usr' is mounted 836 */ 837 if (access(full_path, 0) == 0) { 838 execv(full_path, &newargv[1]); 839 if (errno == EACCES) { 840 fprintf(stderr, 841 gettext("%s: Cannot execute %s - permission denied\n"), 842 myname, full_path); 843 } 844 if (errno == ENOEXEC) { 845 newargv[0] = "sh"; 846 newargv[1] = full_path; 847 execv("/sbin/sh", &newargv[0]); 848 } 849 } 850 execv(alter_path, &newargv[1]); 851 if (errno == EACCES) { 852 fprintf(stderr, gettext( 853 "%s: Cannot execute %s - permission denied\n"), 854 myname, alter_path); 855 exit(1); 856 } 857 if (errno == ENOEXEC) { 858 newargv[0] = "sh"; 859 newargv[1] = alter_path; 860 execv("/sbin/sh", &newargv[0]); 861 } 862 fprintf(stderr, 863 gettext("%s: Operation not applicable to FSType %s\n"), 864 myname, fstype); 865 exit(1); 866 } 867 868 char *mntopts[] = { MNTOPT_IGNORE, NULL }; 869 #define IGNORE 0 870 871 /* 872 * Return 1 if "ignore" appears in the options string 873 */ 874 int 875 ignore(char *opts) 876 { 877 char *value; 878 char *saveptr, *my_opts; 879 int rval = 0; 880 881 if (opts == NULL || *opts == NULL) 882 return (0); 883 884 /* 885 * we make a copy of the option string to pass to getsubopt(), 886 * because getsubopt() modifies the string. We also save 887 * the original pointer returned by strdup, because getsubopt 888 * changes the pointer passed into it. If strdup fails (unlikely), 889 * we act as if the "ignore" option isn't set rather than fail. 890 */ 891 892 if ((saveptr = my_opts = strdup(opts)) == NULL) 893 nomem(); 894 895 while (*my_opts != '\0') { 896 if (getsubopt(&my_opts, mntopts, &value) == IGNORE) 897 rval = 1; 898 } 899 900 free(saveptr); 901 902 return (rval); 903 } 904 905 /* 906 * Perform the parallel version of mount. If count == 0, mount all 907 * vfstab filesystems with the automnt field == "yes". Use fstype if 908 * supplied. If mntlist supplied, then attempt to only mount those. 909 */ 910 911 int 912 parmount(char **mntlist, int count, char *fstype) 913 { 914 int maxfd = OPEN_MAX; 915 struct rlimit rl; 916 vfsent_t **vl, *vp; 917 918 /* 919 * Process scaling. After running a series 920 * of tests based on the number of simultaneous processes and 921 * processors available, optimum performance was achieved near or 922 * at (PROCN * 2). 923 */ 924 if ((maxrun = sysconf(_SC_NPROCESSORS_ONLN)) == -1) 925 maxrun = 4; 926 else 927 maxrun = maxrun * 2 + 1; 928 929 if (getrlimit(RLIMIT_NOFILE, &rl) == 0) { 930 rl.rlim_cur = rl.rlim_max; 931 if (setrlimit(RLIMIT_NOFILE, &rl) == 0) 932 maxfd = (int)rl.rlim_cur; 933 } 934 (void) enable_extended_FILE_stdio(-1, -1); 935 936 /* 937 * The parent needs to maintain 3 of its own fd's, plus 2 for 938 * each child (the stdout and stderr pipes). 939 */ 940 maxfd = (maxfd / 2) - 6; /* 6 takes care of temporary */ 941 /* periods of open fds */ 942 if (maxfd < maxrun) 943 maxrun = maxfd; 944 if (maxrun < 4) 945 maxrun = 4; /* sanity check */ 946 947 if (count == 0) 948 mntlist = NULL; /* used as a flag later */ 949 else 950 fstype = NULL; /* mount points supplied: */ 951 /* ignore fstype */ 952 /* 953 * Read the whole vfstab into a linked list for quick processing. 954 * On average, this is the most efficient way to collect and 955 * manipulate the vfstab data. 956 */ 957 vfsll = getvfsall(fstype, mntlist == NULL); 958 959 /* 960 * Make an array out of the vfs linked list for sorting purposes. 961 */ 962 if (vfsll == NULL || 963 (vfsarray = make_vfsarray(mntlist, count)) == NULL) { 964 if (mntlist == NULL) /* not an error - just none found */ 965 return (0); 966 967 fprintf(stderr, gettext("%s: No valid entries found in %s\n"), 968 myname, vfstab); 969 return (1); 970 } 971 972 /* 973 * Sort the entries based on their resolved path names 974 * 975 * If an lofs is encountered, then the original order of the vfstab 976 * file needs to be maintained until we are done mounting lofs's. 977 */ 978 if (!lofscnt) 979 qsort((void *)vfsarray, vfsarraysize, sizeof (vfsent_t *), 980 mlevelcmp); 981 982 /* 983 * Shrink the vfsll linked list down to the new list. This will 984 * speed up the pid search in cleanupkid() later. 985 */ 986 vfsll = vfsarray[0]; 987 for (vl = vfsarray; vp = *vl; ) 988 vp->next = *++vl; 989 990 /* 991 * Try to handle interrupts in a reasonable way. 992 */ 993 sigset(SIGHUP, cleanup); 994 sigset(SIGQUIT, cleanup); 995 sigset(SIGINT, cleanup); 996 997 do_mounts(); /* do the mounts */ 998 999 if (failcnt > 0 && failcnt == lofsfail) 1000 return (ALL_LOFS_FAILURES); 1001 1002 return (exitcode); 1003 } 1004 1005 /* 1006 * Read all vstab (fp) entries into memory if fstype == NULL. 1007 * If fstype is specified, than read all those that match it. 1008 * 1009 * Returns a linked list. 1010 */ 1011 vfsent_t * 1012 getvfsall(char *fstype, int takeall) 1013 { 1014 vfsent_t *vhead, *vtail; 1015 struct vfstab vget; 1016 FILE *fp; 1017 int cnt = 0, ret; 1018 1019 if ((fp = fopen(vfstab, "r")) == NULL) { 1020 fprintf(stderr, gettext("%s: Cannot open %s\n"), 1021 myname, vfstab); 1022 exit(1); 1023 } 1024 1025 vhead = vtail = NULL; 1026 1027 while ((ret = getvfsent(fp, &vget)) != -1) { 1028 vfsent_t *vp; 1029 1030 if (ret > 0) { 1031 vfserror(ret, vget.vfs_mountp); 1032 continue; 1033 } 1034 1035 /* 1036 * If mount points were not specified, then we ignore 1037 * entries that aren't marked "yes". 1038 */ 1039 if (takeall && 1040 (vget.vfs_automnt == NULL || 1041 strcmp(vget.vfs_automnt, "yes"))) 1042 continue; 1043 1044 if (fstype && vget.vfs_fstype && 1045 strcmp(fstype, vget.vfs_fstype)) 1046 continue; 1047 1048 if (vget.vfs_mountp == NULL || 1049 (vget.vfs_fstype && (strcmp(vget.vfs_fstype, "swap") == 0))) 1050 continue; 1051 1052 if (check_fields(vget.vfs_fstype, vget.vfs_mountp)) { 1053 exitcode = 1; 1054 continue; 1055 } 1056 1057 vp = new_vfsent(&vget, cnt); /* create new vfs entry */ 1058 if (vhead == NULL) 1059 vhead = vp; 1060 else 1061 vtail->next = vp; 1062 vtail = vp; 1063 cnt++; 1064 } 1065 fclose(fp); 1066 if (vtail == NULL) { 1067 vfsarraysize = 0; 1068 vfslltail = NULL; 1069 return (NULL); 1070 } 1071 vtail->next = NULL; 1072 vfslltail = vtail; /* save it in the global variable */ 1073 vfsarraysize = cnt; 1074 return (vhead); 1075 } 1076 1077 1078 /* 1079 * Returns an array of vfsent_t's based on vfsll & mntlist. 1080 */ 1081 vfsent_t ** 1082 make_vfsarray(char **mntlist, int count) 1083 { 1084 vfsent_t *vp, *vmark, *vpprev, **vpp; 1085 int ndx, found; 1086 1087 if (vfsll == NULL) 1088 return (NULL); 1089 1090 if (count > 0) 1091 vfsarraysize = count; 1092 1093 vpp = (vfsent_t **)malloc(sizeof (*vpp) * (vfsarraysize + 1)); 1094 if (vpp == NULL) 1095 nomem(); 1096 1097 if (mntlist == NULL) { 1098 /* 1099 * No mount list specified: take all vfstab mount points. 1100 */ 1101 for (ndx = 0, vp = vfsll; vp; vp = vp->next) { 1102 (void) setrpath(vp); 1103 /* 1104 * Sigh. lofs entries can complicate matters so much 1105 * that the best way to avoid problems is to 1106 * stop parallel mounting when an lofs is 1107 * encountered, so we keep a count of how many 1108 * there are. 1109 * Fortunately this is rare. 1110 */ 1111 if (vp->v.vfs_fstype && 1112 (strcmp(vp->v.vfs_fstype, MNTTYPE_LOFS) == 0)) 1113 lofscnt++; 1114 1115 vpp[ndx++] = vp; 1116 } 1117 vpp[ndx] = NULL; 1118 return (vpp); 1119 } 1120 1121 /* 1122 * A list of mount points was specified on the command line 1123 * and we need to search for each one. 1124 */ 1125 vpprev = vfslltail; 1126 vpprev->next = vfsll; /* make a circle out of it */ 1127 vmark = vp = vfsll; 1128 /* 1129 * For each specified mount point: 1130 */ 1131 for (ndx = 0; *mntlist; mntlist++) { 1132 found = 0; 1133 /* 1134 * Circle our entire linked list, looking for *mntlist. 1135 */ 1136 while (vp) { 1137 if (strcmp(*mntlist, vp->v.vfs_mountp) == 0) { 1138 vpp[ndx++] = vp; /* found it. */ 1139 (void) setrpath(vp); 1140 if (vp->v.vfs_fstype && 1141 (strcmp(vp->v.vfs_fstype, 1142 MNTTYPE_LOFS) == 0)) 1143 lofscnt++; 1144 1145 if (vp == vpprev) { /* list exhausted */ 1146 vp = NULL; 1147 found++; 1148 break; 1149 } 1150 /* 1151 * Remove it from the circular list. vpprev 1152 * remains unchanged. 1153 */ 1154 vp = vp->next; 1155 vpprev->next->next = NULL; 1156 vpprev->next = vp; 1157 /* 1158 * Set vmark to the first elem that we check 1159 * each time. 1160 */ 1161 vmark = vp; 1162 found++; 1163 break; 1164 } 1165 vpprev = vp; 1166 vp = vp->next; 1167 if (vp == vmark) /* break out if we completed */ 1168 /* the circle */ 1169 break; 1170 } 1171 1172 if (!found) { 1173 fprintf(stderr, gettext( 1174 "%s: Warning: %s not found in %s\n"), 1175 myname, *mntlist, vfstab); 1176 exitcode = 1; 1177 } 1178 } 1179 if (ndx == 0) 1180 return (NULL); 1181 1182 vpp[ndx] = NULL; /* null terminate the list */ 1183 vfsarraysize = ndx; /* adjust vfsarraysize */ 1184 return (vpp); 1185 } 1186 1187 /* 1188 * Performs the exec argument processing, all of the child forking and 1189 * execing, and child cleanup. 1190 * Sets exitcode to non-zero if any errors occurred. 1191 */ 1192 void 1193 do_mounts(void) 1194 { 1195 int i, isave, cnt; 1196 vfsent_t *vp, *vpprev, **vl; 1197 char *newargv[ARGV_MAX]; 1198 pid_t child; 1199 1200 /* 1201 * create the arg list once; the only differences among 1202 * the calls are the options, special and mountp fields. 1203 */ 1204 i = 2; 1205 if (cflg) 1206 newargv[i++] = "-c"; 1207 if (gflg) 1208 newargv[i++] = "-g"; 1209 if (mflg) 1210 newargv[i++] = "-m"; 1211 if (Oflg) 1212 newargv[i++] = "-O"; 1213 if (qflg) 1214 newargv[i++] = "-q"; 1215 if (rflg) 1216 newargv[i++] = "-r"; 1217 if (dashflg) 1218 newargv[i++] = "--"; 1219 if (oflg) { 1220 newargv[i++] = "-o"; 1221 newargv[i++] = specific_opts; 1222 } 1223 isave = i; 1224 1225 /* 1226 * Main loop for the mount processes 1227 */ 1228 vl = vfsarray; 1229 cnt = vfsarraysize; 1230 for (vpprev = *vl; vp = *vl; vpprev = vp, vl++, cnt--) { 1231 /* 1232 * Check to see if we cross a mount level: e.g., 1233 * /a/b -> /a/b/c. If so, we need to wait for all current 1234 * mounts to finish, rerun realpath on the remaining mount 1235 * points, and resort the list. 1236 * 1237 * Also, we mount serially as long as there are lofs's 1238 * to mount to avoid improper mount ordering. 1239 */ 1240 if (vp->mlevel > vpprev->mlevel || lofscnt > 0) { 1241 vfsent_t **vlp; 1242 1243 while (nrun > 0 && (dowait() != -1)) 1244 ; 1245 /* 1246 * Gads! It's possible for real path mounts points to 1247 * change after mounts are done at a lower mount 1248 * level. 1249 * Thus, we need to recalculate mount levels and 1250 * resort the list from this point. 1251 */ 1252 for (vlp = vl; *vlp; vlp++) 1253 (void) setrpath(*vlp); 1254 /* 1255 * Sort the remaining entries based on their newly 1256 * resolved path names. 1257 * Do not sort if we still have lofs's to mount. 1258 */ 1259 if (lofscnt == 0) { 1260 qsort((void *)vl, cnt, sizeof (vfsent_t *), 1261 mlevelcmp); 1262 vp = *vl; 1263 } 1264 } 1265 1266 if (vp->flag & VRPFAILED) { 1267 fprintf(stderr, gettext( 1268 "%s: Nonexistent mount point: %s\n"), 1269 myname, vp->v.vfs_mountp); 1270 vp->flag |= VNOTMOUNTED; 1271 exitcode = 1; 1272 continue; 1273 } 1274 1275 /* 1276 * If mount options were not specified on the command 1277 * line, then use the ones found in the vfstab entry, 1278 * if any. 1279 */ 1280 i = isave; 1281 if (!oflg && vp->v.vfs_mntopts) { 1282 newargv[i++] = "-o"; 1283 newargv[i++] = vp->v.vfs_mntopts; 1284 } 1285 newargv[i++] = vp->v.vfs_special; 1286 newargv[i++] = vp->rpath; 1287 newargv[i] = NULL; 1288 1289 /* 1290 * This should never really fail. 1291 */ 1292 while (setup_iopipe(vp) == -1 && (dowait() != -1)) 1293 ; 1294 1295 while (nrun >= maxrun && (dowait() != -1)) /* throttle */ 1296 ; 1297 1298 #ifdef CACHEFS_BUG 1299 if (vp->v.vfs_fstype && 1300 (strcmp(vp->v.vfs_fstype, "cachefs") == 0)) { 1301 while (cachefs_running && (dowait() != -1)) 1302 ; 1303 cachefs_running = 1; 1304 } 1305 #endif 1306 1307 if ((child = fork()) == -1) { 1308 perror("fork"); 1309 cleanup(-1); 1310 /* not reached */ 1311 } 1312 if (child == 0) { /* child */ 1313 signal(SIGHUP, SIG_IGN); 1314 signal(SIGQUIT, SIG_IGN); 1315 signal(SIGINT, SIG_IGN); 1316 setup_output(vp); 1317 doexec(vp->v.vfs_fstype, newargv); 1318 perror("exec"); 1319 exit(1); 1320 } 1321 1322 /* parent */ 1323 (void) close(vp->sopipe[WRPIPE]); 1324 (void) close(vp->sepipe[WRPIPE]); 1325 vp->pid = child; 1326 nrun++; 1327 } 1328 /* 1329 * Mostly done by now - wait and clean up the stragglers. 1330 */ 1331 cleanup(0); 1332 } 1333 1334 1335 /* 1336 * Setup stdout and stderr pipes for the children's output. 1337 */ 1338 int 1339 setup_iopipe(vfsent_t *mp) 1340 { 1341 /* 1342 * Make a stdout and stderr pipe. This should never fail. 1343 */ 1344 if (pipe(mp->sopipe) == -1) 1345 return (-1); 1346 if (pipe(mp->sepipe) == -1) { 1347 (void) close(mp->sopipe[RDPIPE]); 1348 (void) close(mp->sopipe[WRPIPE]); 1349 return (-1); 1350 } 1351 /* 1352 * Don't block on an empty pipe. 1353 */ 1354 (void) fcntl(mp->sopipe[RDPIPE], F_SETFL, O_NDELAY|O_NONBLOCK); 1355 (void) fcntl(mp->sepipe[RDPIPE], F_SETFL, O_NDELAY|O_NONBLOCK); 1356 /* 1357 * Don't pass extra fds into children. 1358 */ 1359 (void) fcntl(mp->sopipe[RDPIPE], F_SETFD, FD_CLOEXEC); 1360 (void) fcntl(mp->sepipe[RDPIPE], F_SETFD, FD_CLOEXEC); 1361 1362 return (0); 1363 } 1364 1365 /* 1366 * Called by a child to attach its stdout and stderr to the write side of 1367 * the pipes. 1368 */ 1369 void 1370 setup_output(vfsent_t *vp) 1371 { 1372 1373 (void) close(fileno(stdout)); 1374 (void) dup(vp->sopipe[WRPIPE]); 1375 (void) close(vp->sopipe[WRPIPE]); 1376 1377 (void) close(fileno(stderr)); 1378 (void) dup(vp->sepipe[WRPIPE]); 1379 (void) close(vp->sepipe[WRPIPE]); 1380 } 1381 1382 /* 1383 * Parent uses this to print any stdout or stderr output issued by 1384 * the child. 1385 */ 1386 static void 1387 doio(vfsent_t *vp) 1388 { 1389 int bytes; 1390 char ibuf[BUFSIZ]; 1391 1392 while ((bytes = read(vp->sepipe[RDPIPE], ibuf, sizeof (ibuf))) > 0) 1393 write(fileno(stderr), ibuf, bytes); 1394 while ((bytes = read(vp->sopipe[RDPIPE], ibuf, sizeof (ibuf))) > 0) 1395 write(fileno(stdout), ibuf, bytes); 1396 1397 (void) close(vp->sopipe[RDPIPE]); 1398 (void) close(vp->sepipe[RDPIPE]); 1399 } 1400 1401 /* 1402 * Waits for 1 child to die. 1403 * 1404 * Returns -1 if no children are left to wait for. 1405 * Returns 0 if a child died without an error. 1406 * Returns 1 if a child died with an error. 1407 */ 1408 int 1409 dowait(void) 1410 { 1411 int child, wstat; 1412 1413 if ((child = wait(&wstat)) == -1) 1414 return (-1); 1415 nrun--; 1416 return (cleanupkid(child, wstat) != 0); 1417 } 1418 1419 /* 1420 * Locates the child mount process represented by pid, outputs any io 1421 * it may have, and returns its exit code. 1422 * Sets the global exitcode if an error occurred. 1423 */ 1424 int 1425 cleanupkid(pid_t pid, int wstat) 1426 { 1427 vfsent_t *vp, *prevp; 1428 int ret; 1429 1430 if (WIFEXITED(wstat)) /* this should always be true */ 1431 ret = WEXITSTATUS(wstat); 1432 else 1433 ret = 1; /* assume some kind of error */ 1434 if (ret) { 1435 exitcode = 1; 1436 failcnt++; 1437 } 1438 1439 /* 1440 * Find our child. 1441 * This search gets smaller and smaller as children are cleaned 1442 * up. 1443 */ 1444 for (prevp = NULL, vp = vfsll; vp; vp = vp->next) { 1445 if (vp->pid != pid) { 1446 prevp = vp; 1447 continue; 1448 } 1449 /* 1450 * Found: let's remove it from this linked list. 1451 */ 1452 if (prevp) { 1453 prevp->next = vp->next; 1454 vp->next = NULL; 1455 } 1456 break; 1457 } 1458 1459 if (vp == NULL) { 1460 /* 1461 * This should never happen. 1462 */ 1463 fprintf(stderr, gettext( 1464 "%s: Unknown child %d\n"), myname, pid); 1465 exitcode = 1; 1466 return (ret); 1467 } 1468 doio(vp); /* Any output? */ 1469 1470 if (vp->v.vfs_fstype && 1471 (strcmp(vp->v.vfs_fstype, MNTTYPE_LOFS) == 0)) { 1472 lofscnt--; 1473 if (ret) 1474 lofsfail++; 1475 } 1476 1477 #ifdef CACHEFS_BUG 1478 if (vp->v.vfs_fstype && (strcmp(vp->v.vfs_fstype, "cachefs") == 0)) 1479 cachefs_running = 0; 1480 #endif 1481 1482 vp->exitcode = ret; 1483 return (ret); 1484 } 1485 1486 1487 static vfsent_t zvmount = { 0 }; 1488 1489 vfsent_t * 1490 new_vfsent(struct vfstab *vin, int order) 1491 { 1492 vfsent_t *new; 1493 1494 new = (vfsent_t *)malloc(sizeof (*new)); 1495 if (new == NULL) 1496 nomem(); 1497 1498 *new = zvmount; 1499 if (vin->vfs_special && 1500 (new->v.vfs_special = strdup(vin->vfs_special)) == NULL) 1501 nomem(); 1502 if (vin->vfs_mountp && 1503 (new->v.vfs_mountp = strdup(vin->vfs_mountp)) == NULL) 1504 nomem(); 1505 if (vin->vfs_fstype && 1506 (new->v.vfs_fstype = strdup(vin->vfs_fstype)) == NULL) 1507 nomem(); 1508 /* 1509 * If specific mount options were specified on the command 1510 * line, then use those. Else, use the ones on the vfstab 1511 * line, if any. In other words, specific options on the 1512 * command line override those in /etc/vfstab. 1513 */ 1514 if (oflg) { 1515 if ((new->v.vfs_mntopts = strdup(specific_opts)) == NULL) 1516 nomem(); 1517 } else if (vin->vfs_mntopts && 1518 (new->v.vfs_mntopts = strdup(vin->vfs_mntopts)) == NULL) 1519 nomem(); 1520 1521 new->order = order; 1522 return (new); 1523 } 1524 1525 /* 1526 * Runs realpath on vp's mount point, records success or failure, 1527 * resets the mount level based on the new realpath, and returns 1528 * realpath()'s return value. 1529 */ 1530 char * 1531 setrpath(vfsent_t *vp) 1532 { 1533 char *rp; 1534 1535 if ((rp = realpath(vp->v.vfs_mountp, realdir)) == NULL) 1536 vp->flag |= VRPFAILED; 1537 else 1538 vp->flag &= ~VRPFAILED; 1539 1540 if (vp->rpath) 1541 free(vp->rpath); 1542 if ((vp->rpath = strdup(realdir)) == NULL) 1543 nomem(); 1544 vp->mlevel = fsgetmlevel(vp->rpath); 1545 return (rp); 1546 } 1547 1548 1549 /* 1550 * sort first by mlevel (1...N), then by vfstab order. 1551 */ 1552 int 1553 mlevelcmp(const void *a, const void *b) 1554 { 1555 vfsent_t *a1, *b1; 1556 int lcmp; 1557 1558 a1 = *(vfsent_t **)a; 1559 b1 = *(vfsent_t **)b; 1560 1561 lcmp = a1->mlevel - b1->mlevel; 1562 if (lcmp == 0) 1563 lcmp = a1->order - b1->order; 1564 return (lcmp); 1565 } 1566 1567 /* sort by vfstab order. 0..N */ 1568 static int 1569 mordercmp(const void *a, const void *b) 1570 { 1571 vfsent_t *a1, *b1; 1572 1573 a1 = *(vfsent_t **)a; 1574 b1 = *(vfsent_t **)b; 1575 return (a1->order - b1->order); 1576 } 1577 1578 /* 1579 * cleanup the existing children and exit with an error 1580 * if asig != 0. 1581 */ 1582 void 1583 cleanup(int asig) 1584 { 1585 while (nrun > 0 && (dowait() != -1)) 1586 ; 1587 1588 if (asig != 0) 1589 exit(1); 1590 } 1591 1592 1593 int 1594 check_fields(char *fstype, char *mountp) 1595 { 1596 struct stat64 stbuf; 1597 1598 if (strlen(fstype) > (size_t)FSTYPE_MAX) { 1599 fprintf(stderr, 1600 gettext("%s: FSType %s exceeds %d characters\n"), 1601 myname, fstype, FSTYPE_MAX); 1602 return (1); 1603 } 1604 1605 if (mountp == NULL) { 1606 fprintf(stderr, 1607 gettext("%s: Mount point cannot be determined\n"), 1608 myname); 1609 return (1); 1610 } 1611 if (*mountp != '/') { 1612 fprintf(stderr, gettext( 1613 "%s: Mount point %s is not an absolute pathname.\n"), 1614 myname, mountp); 1615 return (1); 1616 } 1617 /* 1618 * Don't do some of these checks if aflg because a mount point may 1619 * not exist now, but will be mounted before we get to it. 1620 * This is one of the quirks of "secondary mounting". 1621 */ 1622 if (!aflg && stat64(mountp, &stbuf) < 0) { 1623 if (errno == ENOENT || errno == ENOTDIR) 1624 fprintf(stderr, 1625 gettext("%s: Mount point %s does not exist.\n"), 1626 myname, mountp); 1627 else { 1628 fprintf(stderr, 1629 gettext("%s: Cannot stat mount point %s.\n"), 1630 myname, mountp); 1631 perror(myname); 1632 } 1633 return (1); 1634 } 1635 return (0); 1636 } 1637 1638 void 1639 nomem(void) 1640 { 1641 fprintf(stderr, gettext("%s: Out of memory\n"), myname); 1642 while (nrun > 0 && (dowait() != -1)) 1643 ; 1644 exit(1); 1645 } 1646