struct disklabel * getdisklabel(char *s) { static struct disklabel lab; struct disklabel *lp; if (is_file) { if (read(disk.d_fd, bootarea, BBSIZE) != BBSIZE) err(4, "cannot read bootarea"); if (bsd_disklabel_le_dec( bootarea + (0 /* labeloffset */ + 1 /* labelsoffset */ * sectorsize), &lab, MAXPARTITIONS)) errx(1, "no valid label found"); lp = &lab; return &lab; } if (ioctl(disk.d_fd, DIOCGDINFO, (char *)&lab) != -1) return (&lab); unlabeled++; if (disktype) { lp = getdiskbyname(disktype); if (lp != NULL) return (lp); } return (NULL); }
/* * Construct a prototype disklabel from /etc/disktab. As a side * effect, set the names of the primary and secondary boot files * if specified. */ void makelabel(char *type, char *name, struct disklabel *lp) { struct disklabel *dp; dp = getdiskbyname(type); if (dp == NULL) errx(1, "unknown disk type: %s", type); *lp = *dp; #if NUMBOOT > 0 /* * Set bootstrap name(s). * 1. If set from command line, use those, * 2. otherwise, check if disktab specifies them (b0 or b1), * 3. otherwise, makebootarea() will choose ones based on the name * of the disk special file. E.g. /dev/ra0 -> raboot, bootra */ if (!xxboot && lp->d_boot0) { if (*lp->d_boot0 != '/') (void)snprintf(boot0, sizeof boot0, "%s%s", _PATH_BOOTDIR, lp->d_boot0); else (void)strlcpy(boot0, lp->d_boot0, sizeof boot0); xxboot = boot0; } #endif /* d_packname is union d_boot[01], so zero */ memset(lp->d_packname, 0, sizeof(lp->d_packname)); if (name) (void)strncpy(lp->d_packname, name, sizeof(lp->d_packname)); }
/* * Construct a prototype disklabel from /etc/disktab. */ static void makelabel(const char *type, struct disklabel *lp) { struct disklabel *dp; if (strcmp(type, "auto") == 0) dp = getvirginlabel(); else dp = getdiskbyname(type); if (dp == NULL) errx(1, "%s: unknown disk type", type); *lp = *dp; bzero(lp->d_packname, sizeof(lp->d_packname)); }
/* * Construct a prototype disklabel from /etc/disktab. As a side * effect, set the names of the primary and secondary boot files * if specified. */ void makelabel(char *type, char *name, struct disklabel *lp) { struct disklabel *dp; dp = getdiskbyname(type); if (dp == NULL) errx(1, "unknown disk type: %s", type); *lp = *dp; /* d_packname is union d_boot[01], so zero */ memset(lp->d_packname, 0, sizeof(lp->d_packname)); if (name) (void)strncpy(lp->d_packname, name, sizeof(lp->d_packname)); }
struct disklabel * getdisklabel(char *s, int fd) { static struct disklabel lab; if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) { if (disktype != NULL) { struct disklabel *lp; unlabeled++; lp = getdiskbyname(disktype); if (lp == NULL) fatal("%s: unknown disk type", disktype); return (lp); } warn("ioctl (GDINFO)"); fatal("%s: can't read disk label; disk type must be specified", s); } return (&lab); }
static int config(char *dev, char *file, char *geom, int action) { struct vnd_ioctl vndio; struct disklabel *lp; char rdev[MAXPATHLEN + 1]; int fd, rv; fd = opendisk(dev, O_RDWR, rdev, sizeof(rdev), 0); if (fd < 0) { warn("%s: opendisk", rdev); return (1); } memset(&vndio, 0, sizeof(vndio)); #ifdef __GNUC__ rv = 0; /* XXX */ #endif vndio.vnd_file = file; if (geom != NULL) { rv = getgeom(&vndio.vnd_geom, geom); if (rv != 0) errx(1, "invalid geometry: %s", geom); vndio.vnd_flags = VNDIOF_HASGEOM; } else if (tabname != NULL) { lp = getdiskbyname(tabname); if (lp == NULL) errx(1, "unknown disk type: %s", tabname); vndio.vnd_geom.vng_secsize = lp->d_secsize; vndio.vnd_geom.vng_nsectors = lp->d_nsectors; vndio.vnd_geom.vng_ntracks = lp->d_ntracks; vndio.vnd_geom.vng_ncylinders = lp->d_ncylinders; vndio.vnd_flags = VNDIOF_HASGEOM; } if (readonly) vndio.vnd_flags |= VNDIOF_READONLY; if (compressed) vndio.vnd_flags |= VNF_COMP; /* * Clear (un-configure) the device */ if (action == VND_UNCONFIG) { if (force) vndio.vnd_flags |= VNDIOF_FORCE; rv = ioctl(fd, VNDIOCCLR, &vndio); #ifdef VNDIOOCCLR if (rv && errno == ENOTTY) rv = ioctl(fd, VNDIOOCCLR, &vndio); #endif if (rv) warn("%s: VNDIOCCLR", rdev); else if (verbose) printf("%s: cleared\n", rdev); } /* * Configure the device */ if (action == VND_CONFIG) { int ffd; ffd = open(file, readonly ? O_RDONLY : O_RDWR); if (ffd < 0) { warn("%s", file); rv = -1; } else { (void) close(ffd); rv = ioctl(fd, VNDIOCSET, &vndio); #ifdef VNDIOOCSET if (rv && errno == ENOTTY) { rv = ioctl(fd, VNDIOOCSET, &vndio); vndio.vnd_size = vndio.vnd_osize; } #endif if (rv) warn("%s: VNDIOCSET", rdev); else if (verbose) { printf("%s: %" PRIu64 " bytes on %s", rdev, vndio.vnd_size, file); if (vndio.vnd_flags & VNDIOF_HASGEOM) printf(" using geometry %d/%d/%d/%d", vndio.vnd_geom.vng_secsize, vndio.vnd_geom.vng_nsectors, vndio.vnd_geom.vng_ntracks, vndio.vnd_geom.vng_ncylinders); printf("\n"); } } } (void) close(fd); fflush(stdout); return (rv < 0); }
int main(int argc, char *argv[]) { struct disklabel *dp; int spc, def, part, layout, j, ch; uint32_t curcyl; int threshhold, numcyls[NPARTITIONS], startcyl[NPARTITIONS]; off_t totsize = 0; const char *tyname; char *lp; while ((ch = getopt(argc, argv, "pds:")) != -1) { switch (ch) { case 'd': dflag++; break; case 'p': pflag++; break; case 's': totsize = strtoul(optarg, &lp, 10); if (*lp != '\0') usage(); break; case '?': default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (argc != 1) { usage(); /* NOTREACHED */ } dp = getdiskbyname(*argv); if (dp == NULL) { if (isatty(0)) dp = promptfordisk(*argv); if (dp == NULL) { fprintf(stderr, "%s: unknown disk type\n", *argv); exit(1); } } if (dp->d_flags & D_REMOVABLE) tyname = "removable"; else if (dp->d_flags & D_RAMDISK) tyname = "simulated"; else tyname = "winchester"; spc = dp->d_secpercyl; /* * Bad sector table contains one track for the replicated * copies of the table and enough full tracks preceding * the last track to hold the pool of free blocks to which * bad sectors are mapped. * If disk size was specified explicitly, use specified size. */ if (dp->d_type == DKTYPE_SMD && dp->d_flags & D_BADSECT && totsize == 0) { badsecttable = dp->d_nsectors + roundup(badsecttable, dp->d_nsectors); threshhold = howmany(spc, badsecttable); } else { badsecttable = 0; threshhold = 0; } /* * If disk size was specified, recompute number of cylinders * that may be used, and set badsecttable to any remaining * fraction of the last cylinder. */ if (totsize != 0) { dp->d_ncylinders = howmany(totsize, spc); badsecttable = spc * dp->d_ncylinders - totsize; } /* * Figure out if disk is large enough for * expanded swap area and 'd', 'e', and 'f' * partitions. Otherwise, use smaller defaults * based on RK07. */ for (def = 0; def < NDEFAULTS; def++) { curcyl = 0; for (part = PART('a'); part < NPARTITIONS; part++) curcyl += howmany(defpart[def][part], spc); if (curcyl < dp->d_ncylinders - threshhold) break; } if (def >= NDEFAULTS) { fprintf(stderr, "%s: disk too small, calculate by hand\n", *argv); exit(1); } /* * Calculate number of cylinders allocated to each disk * partition. We may waste a bit of space here, but it's * in the interest of (very backward) compatibility * (for mixed disk systems). */ for (curcyl = 0, part = PART('a'); part < NPARTITIONS; part++) { numcyls[part] = 0; if (defpart[def][part] != 0) { numcyls[part] = howmany(defpart[def][part], spc); curcyl += numcyls[part]; } } numcyls[PART('f')] = dp->d_ncylinders - curcyl; numcyls[PART('g')] = numcyls[PART('d')] + numcyls[PART('e')] + numcyls[PART('f')]; numcyls[PART('c')] = dp->d_ncylinders; defpart[def][PART('f')] = numcyls[PART('f')] * spc - badsecttable; defpart[def][PART('g')] = numcyls[PART('g')] * spc - badsecttable; defpart[def][PART('c')] = numcyls[PART('c')] * spc; #ifndef for_now if (totsize || !pflag) #else if (totsize) #endif defpart[def][PART('c')] -= badsecttable; /* * Calculate starting cylinder number for each partition. * Note the 'h' partition is physically located before the * 'g' or 'd' partition. This is reflected in the layout * arrays defined above. */ for (layout = 0; layout < NLAYOUTS; layout++) { curcyl = 0; for (lp = layouts[layout]; *lp != 0; lp++) { startcyl[PART(*lp)] = curcyl; curcyl += numcyls[PART(*lp)]; } } if (pflag) { printf("}, %s_sizes[%d] = {\n", dp->d_typename, NPARTITIONS); for (part = PART('a'); part < NPARTITIONS; part++) { if (numcyls[part] == 0) { printf("\t0,\t0,\n"); continue; } if (dp->d_type != DKTYPE_MSCP) { printf("\t%d,\t%d,\t\t/* %c=cyl %d thru %d */\n", defpart[def][part], startcyl[part], 'A' + part, startcyl[part], startcyl[part] + numcyls[part] - 1); continue; } printf("\t%d,\t%d,\t\t/* %c=sectors %d thru %d */\n", defpart[def][part], spc * startcyl[part], 'A' + part, spc * startcyl[part], spc * startcyl[part] + defpart[def][part] - 1); } exit(0); } if (dflag) { int nparts; /* * In case the disk is in the ``in-between'' range * where the 'g' partition is smaller than the 'h' * partition, reverse the frag sizes so the /usr partition * is always set up with a frag size larger than the * user's partition. */ if (defpart[def][PART('g')] < defpart[def][PART('h')]) { int temp; temp = defparam[PART('h')].p_fsize; defparam[PART('h')].p_fsize = defparam[PART('g')].p_fsize; defparam[PART('g')].p_fsize = temp; } printf("%s:\\\n", dp->d_typename); printf("\t:ty=%s:ns#%d:nt#%d:nc#%d:", tyname, dp->d_nsectors, dp->d_ntracks, dp->d_ncylinders); if (dp->d_secpercyl != dp->d_nsectors * dp->d_ntracks) printf("sc#%d:", dp->d_secpercyl); if (dp->d_type == DKTYPE_SMD && dp->d_flags & D_BADSECT) printf("sf:"); printf("\\\n\t:dt=%s:", dktypenames[dp->d_type]); for (part = NDDATA - 1; part >= 0; part--) if (dp->d_drivedata[part]) break; for (j = 0; j <= part; j++) printf("d%d#%d:", j, dp->d_drivedata[j]); printf("\\\n"); for (nparts = 0, part = PART('a'); part < NPARTITIONS; part++) if (defpart[def][part] != 0) nparts++; for (part = PART('a'); part < NPARTITIONS; part++) { if (defpart[def][part] == 0) continue; printf("\t:p%c#%d:", 'a' + part, defpart[def][part]); printf("o%c#%d:b%c#%d:f%c#%d:", 'a' + part, spc * startcyl[part], 'a' + part, defparam[part].p_frag * defparam[part].p_fsize, 'a' + part, defparam[part].p_fsize); if (defparam[part].p_fstype == FS_SWAP) printf("t%c=swap:", 'a' + part); nparts--; printf("%s\n", nparts > 0 ? "\\" : ""); } #ifdef for_now defpart[def][PART('c')] -= badsecttable; part = PART('c'); printf("#\t:p%c#%d:", 'a' + part, defpart[def][part]); printf("o%c#%d:b%c#%d:f%c#%d:\n", 'a' + part, spc * startcyl[part], 'a' + part, defparam[part].p_frag * defparam[part].p_fsize, 'a' + part, defparam[part].p_fsize); #endif exit(0); } printf("%s: #sectors/track=%d, #tracks/cylinder=%d #cylinders=%d\n", dp->d_typename, dp->d_nsectors, dp->d_ntracks, dp->d_ncylinders); printf("\n Partition\t Size\t Offset\t Range\n"); for (part = PART('a'); part < NPARTITIONS; part++) { printf("\t%c\t", 'a' + part); if (numcyls[part] == 0) { printf(" unused\n"); continue; } printf("%7d\t%7d\t%4d - %d%s\n", defpart[def][part], startcyl[part] * spc, startcyl[part], startcyl[part] + numcyls[part] - 1, defpart[def][part] % spc ? "*" : ""); } exit(0); }
int main(int argc, char **argv) { int ch, rv, action, opt_c, opt_k, opt_K, opt_l, opt_u; char *key, *mntopts, *rounds, *saltopt; size_t keylen = 0; const char *errstr; extern char *__progname; struct disklabel *dp = NULL; if (strcasecmp(__progname, "mount_vnd") == 0) run_mount_vnd = 1; opt_c = opt_k = opt_K = opt_l = opt_u = 0; key = mntopts = rounds = saltopt = NULL; action = VND_CONFIG; while ((ch = getopt(argc, argv, "ckK:lo:S:t:uv")) != -1) { switch (ch) { case 'c': opt_c = 1; break; case 'k': opt_k = 1; break; case 'K': opt_K = 1; rounds = optarg; break; case 'l': opt_l = 1; break; case 'o': mntopts = optarg; break; case 'S': saltopt = optarg; break; case 't': dp = getdiskbyname(optarg); if (dp == NULL) errx(1, "unknown disk type: %s", optarg); break; case 'u': opt_u = 1; break; case 'v': verbose = 1; break; default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (opt_c + opt_l + opt_u > 1) errx(1, "-c, -l and -u are mutually exclusive options"); if (opt_l) action = VND_GET; else if (opt_u) action = VND_UNCONFIG; else action = VND_CONFIG; /* default behavior */ if (saltopt && (!opt_K)) errx(1, "-S only makes sense when used with -K"); if (action == VND_CONFIG && argc == 2) { int ind_raw, ind_reg; if (opt_k) { if (opt_K) errx(1, "-k and -K are mutually exclusive"); key = getpass("Encryption key: "); if (key == NULL || (keylen = strlen(key)) == 0) errx(1, "Need an encryption key"); } else if (opt_K) { key = get_pkcs_key(rounds, saltopt); keylen = BLF_MAXUTILIZED; } /* fix order of arguments. */ if (run_mount_vnd) { ind_raw = 1; ind_reg = 0; } else { ind_raw = 0; ind_reg = 1; } rv = config(argv[ind_raw], argv[ind_reg], action, dp, key, keylen); } else if (action == VND_UNCONFIG && argc == 1) rv = config(argv[0], NULL, action, NULL, NULL, 0); else if (action == VND_GET) rv = getinfo(argc ? argv[0] : NULL); else usage(); exit(rv); }
int main(int argc, char *argv[]) { int ch; struct partition *pp; struct disklabel *lp; struct disklabel mfsfakelabel; struct partition oldpartition; struct stat st; struct statfs *mp; struct rlimit rl; int fsi = -1, oflagset = 0, fso, len, n, maxpartitions; char *cp = NULL, *s1, *s2, *special, *opstring, *realdev; #ifdef MFS char mountfromname[BUFSIZ]; char *pop = NULL, node[PATH_MAX]; pid_t pid, res; struct statfs sf; struct stat mountpoint; int status; #endif uid_t mfsuid = 0; gid_t mfsgid = 0; mode_t mfsmode = 0; char *fstype = NULL; char **saveargv = argv; int ffsflag = 1; const char *errstr; long long fssize_input = 0; int fssize_usebytes = 0; u_int64_t nsecs; if (strstr(__progname, "mfs")) mfs = Nflag = quiet = 1; getphysmem(); maxpartitions = getmaxpartitions(); if (maxpartitions > 26) fatal("insane maxpartitions value %d", maxpartitions); opstring = mfs ? "P:T:b:c:e:f:i:m:o:s:" : "NO:S:T:b:c:e:f:g:h:i:m:o:qs:t:"; while ((ch = getopt(argc, argv, opstring)) != -1) { switch (ch) { case 'N': Nflag = 1; break; case 'O': Oflag = strtonum(optarg, 0, 2, &errstr); if (errstr) fatal("%s: invalid ffs version", optarg); oflagset = 1; break; case 'S': if (scan_scaled(optarg, §orsize) == -1 || sectorsize <= 0 || (sectorsize % DEV_BSIZE)) fatal("sector size invalid: %s", optarg); break; case 'T': disktype = optarg; break; case 'b': bsize = strtonum(optarg, MINBSIZE, MAXBSIZE, &errstr); if (errstr) fatal("block size is %s: %s", errstr, optarg); break; case 'c': maxfrgspercg = strtonum(optarg, 1, INT_MAX, &errstr); if (errstr) fatal("fragments per cylinder group is %s: %s", errstr, optarg); break; case 'e': maxbpg = strtonum(optarg, 1, INT_MAX, &errstr); if (errstr) fatal("blocks per file in a cylinder group is" " %s: %s", errstr, optarg); break; case 'f': fsize = strtonum(optarg, MINBSIZE / MAXFRAG, MAXBSIZE, &errstr); if (errstr) fatal("fragment size is %s: %s", errstr, optarg); break; case 'g': avgfilesize = strtonum(optarg, 1, INT_MAX, &errstr); if (errstr) fatal("average file size is %s: %s", errstr, optarg); break; case 'h': avgfilesperdir = strtonum(optarg, 1, INT_MAX, &errstr); if (errstr) fatal("average files per dir is %s: %s", errstr, optarg); break; case 'i': density = strtonum(optarg, 1, INT_MAX, &errstr); if (errstr) fatal("bytes per inode is %s: %s", errstr, optarg); break; case 'm': minfree = strtonum(optarg, 0, 99, &errstr); if (errstr) fatal("free space %% is %s: %s", errstr, optarg); break; case 'o': if (mfs) getmntopts(optarg, mopts, &mntflags); else { if (strcmp(optarg, "space") == 0) reqopt = opt = FS_OPTSPACE; else if (strcmp(optarg, "time") == 0) reqopt = opt = FS_OPTTIME; else fatal("%s: unknown optimization " "preference: use `space' or `time'.", optarg); } break; case 'q': quiet = 1; break; case 's': if (scan_scaled(optarg, &fssize_input) == -1 || fssize_input <= 0) fatal("file system size invalid: %s", optarg); fssize_usebytes = 0; /* in case of multiple -s */ for (s1 = optarg; *s1 != '\0'; s1++) if (isalpha((unsigned char)*s1)) { fssize_usebytes = 1; break; } break; case 't': fstype = optarg; if (strcmp(fstype, "ffs")) ffsflag = 0; break; #ifdef MFS case 'P': pop = optarg; break; #endif case '?': default: usage(); } if (!ffsflag) break; } argc -= optind; argv += optind; if (ffsflag && argc - mfs != 1) usage(); if (mfs) { /* Increase our data size to the max */ if (getrlimit(RLIMIT_DATA, &rl) == 0) { rl.rlim_cur = rl.rlim_max; (void)setrlimit(RLIMIT_DATA, &rl); } } special = argv[0]; if (!mfs) { char execname[PATH_MAX], name[PATH_MAX]; if (fstype == NULL) fstype = readlabelfs(special, 0); if (fstype != NULL && strcmp(fstype, "ffs")) { snprintf(name, sizeof name, "newfs_%s", fstype); saveargv[0] = name; snprintf(execname, sizeof execname, "%s/newfs_%s", _PATH_SBIN, fstype); (void)execv(execname, saveargv); snprintf(execname, sizeof execname, "%s/newfs_%s", _PATH_USRSBIN, fstype); (void)execv(execname, saveargv); err(1, "%s not found", name); } } if (mfs && !strcmp(special, "swap")) { /* * it's an MFS, mounted on "swap." fake up a label. * XXX XXX XXX */ fso = -1; /* XXX; normally done below. */ memset(&mfsfakelabel, 0, sizeof(mfsfakelabel)); mfsfakelabel.d_secsize = 512; mfsfakelabel.d_nsectors = 64; mfsfakelabel.d_ntracks = 16; mfsfakelabel.d_ncylinders = 16; mfsfakelabel.d_secpercyl = 1024; DL_SETDSIZE(&mfsfakelabel, 16384); mfsfakelabel.d_npartitions = 1; mfsfakelabel.d_version = 1; DL_SETPSIZE(&mfsfakelabel.d_partitions[0], 16384); mfsfakelabel.d_partitions[0].p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(1024, 8); mfsfakelabel.d_partitions[0].p_cpg = 16; lp = &mfsfakelabel; pp = &mfsfakelabel.d_partitions[0]; goto havelabel; } if (Nflag) { fso = -1; } else { fso = opendev(special, O_WRONLY, 0, &realdev); if (fso < 0) fatal("%s: %s", special, strerror(errno)); special = realdev; /* Bail if target special is mounted */ n = getmntinfo(&mp, MNT_NOWAIT); if (n == 0) fatal("%s: getmntinfo: %s", special, strerror(errno)); len = sizeof(_PATH_DEV) - 1; s1 = special; if (strncmp(_PATH_DEV, s1, len) == 0) s1 += len; while (--n >= 0) { s2 = mp->f_mntfromname; if (strncmp(_PATH_DEV, s2, len) == 0) { s2 += len - 1; *s2 = 'r'; } if (strcmp(s1, s2) == 0 || strcmp(s1, &s2[1]) == 0) fatal("%s is mounted on %s", special, mp->f_mntonname); ++mp; } } if (mfs && disktype != NULL) { lp = (struct disklabel *)getdiskbyname(disktype); if (lp == NULL) fatal("%s: unknown disk type", disktype); pp = &lp->d_partitions[1]; } else { fsi = opendev(special, O_RDONLY, 0, NULL); if (fsi < 0) fatal("%s: %s", special, strerror(errno)); if (fstat(fsi, &st) < 0) fatal("%s: %s", special, strerror(errno)); if (!mfs) { if (S_ISBLK(st.st_mode)) fatal("%s: block device", special); if (!S_ISCHR(st.st_mode)) warnx("%s: not a character-special device", special); } if (*argv[0] == '\0') fatal("empty partition name supplied"); cp = argv[0] + strlen(argv[0]) - 1; if ((*cp < 'a' || *cp > ('a' + maxpartitions - 1)) && !isdigit((unsigned char)*cp)) fatal("%s: can't figure out file system partition", argv[0]); lp = getdisklabel(special, fsi); if (!mfs) { if (pledge("stdio disklabel tty", NULL) == -1) err(1, "pledge"); } if (isdigit((unsigned char)*cp)) pp = &lp->d_partitions[0]; else pp = &lp->d_partitions[*cp - 'a']; if (DL_GETPSIZE(pp) == 0) fatal("%s: `%c' partition is unavailable", argv[0], *cp); if (pp->p_fstype == FS_BOOT) fatal("%s: `%c' partition overlaps boot program", argv[0], *cp); } havelabel: if (sectorsize == 0) { sectorsize = lp->d_secsize; if (sectorsize <= 0) fatal("%s: no default sector size", argv[0]); } if (fssize_usebytes) { nsecs = fssize_input / sectorsize; if (fssize_input % sectorsize != 0) nsecs++; } else if (fssize_input == 0) nsecs = DL_GETPSIZE(pp); else nsecs = fssize_input; if (nsecs > DL_GETPSIZE(pp) && !mfs) fatal("%s: maximum file system size on the `%c' partition is " "%llu sectors", argv[0], *cp, DL_GETPSIZE(pp)); /* Can't use DL_SECTOBLK() because sectorsize may not be from label! */ fssize = nsecs * (sectorsize / DEV_BSIZE); if (oflagset == 0 && fssize >= INT_MAX) Oflag = 2; /* FFS2 */ if (fsize == 0) { fsize = DISKLABELV1_FFS_FSIZE(pp->p_fragblock); if (fsize <= 0) fsize = MAXIMUM(DFL_FRAGSIZE, lp->d_secsize); } if (bsize == 0) { bsize = DISKLABELV1_FFS_BSIZE(pp->p_fragblock); if (bsize <= 0) bsize = MINIMUM(DFL_BLKSIZE, 8 * fsize); } if (density == 0) density = NFPI * fsize; if (minfree < MINFREE && opt != FS_OPTSPACE && reqopt == -1) { warnx("warning: changing optimization to space " "because minfree is less than %d%%\n", MINFREE); opt = FS_OPTSPACE; } if (maxbpg == 0) { if (Oflag <= 1) maxbpg = MAXBLKPG_FFS1(bsize); else maxbpg = MAXBLKPG_FFS2(bsize); } oldpartition = *pp; #ifdef MFS if (mfs) { if (realpath(argv[1], node) == NULL) err(1, "realpath %s", argv[1]); if (stat(node, &mountpoint) < 0) err(ECANCELED, "stat %s", node); mfsuid = mountpoint.st_uid; mfsgid = mountpoint.st_gid; mfsmode = mountpoint.st_mode & ALLPERMS; } #endif mkfs(pp, special, fsi, fso, mfsmode, mfsuid, mfsgid); if (!Nflag && memcmp(pp, &oldpartition, sizeof(oldpartition))) rewritelabel(special, fso, lp); if (!Nflag) close(fso); close(fsi); #ifdef MFS if (mfs) { struct mfs_args args; memset(&args, 0, sizeof(args)); args.base = membase; args.size = fssize * DEV_BSIZE; args.export_info.ex_root = -2; if (mntflags & MNT_RDONLY) args.export_info.ex_flags = MNT_EXRDONLY; switch (pid = fork()) { case -1: err(10, "mfs"); case 0: snprintf(mountfromname, sizeof(mountfromname), "mfs:%d", getpid()); break; default: snprintf(mountfromname, sizeof(mountfromname), "mfs:%d", pid); for (;;) { /* * spin until the mount succeeds * or the child exits */ usleep(1); /* * XXX Here is a race condition: another process * can mount a filesystem which hides our * ramdisk before we see the success. */ if (statfs(node, &sf) < 0) err(ECANCELED, "statfs %s", node); if (!strcmp(sf.f_mntfromname, mountfromname) && !strncmp(sf.f_mntonname, node, MNAMELEN) && !strcmp(sf.f_fstypename, "mfs")) { if (pop != NULL) copy(pop, node, &args); exit(0); } res = waitpid(pid, &status, WNOHANG); if (res == -1) err(EDEADLK, "waitpid"); if (res != pid) continue; if (WIFEXITED(status)) { if (WEXITSTATUS(status) == 0) exit(0); errx(1, "%s: mount: %s", node, strerror(WEXITSTATUS(status))); } else errx(EDEADLK, "abnormal termination"); } /* NOTREACHED */ } (void) setsid(); (void) close(0); (void) close(1); (void) close(2); (void) chdir("/"); args.fspec = mountfromname; if (mntflags & MNT_RDONLY && pop != NULL) mntflags &= ~MNT_RDONLY; if (mount(MOUNT_MFS, node, mntflags, &args) < 0) exit(errno); /* parent prints message */ } #endif exit(0); }