Initial revision

3 files changed, 1923 insertions, 0 deletions

diff --git a/ufs-utils/Makefile b/ufs-utils/Makefile
new file mode 100644
index 00000000..4cc571a1
--- /dev/null
+++ b/ufs-utils/Makefile
@@ -0,0 +1,15 @@
+#	from: @(#)Makefile	8.2 (Berkeley) 3/27/94
+#	$Id: Makefile,v 1.1 1994/08/23 19:30:43 mib Exp $
+
+PROG=	newfs
+SRCS=	dkcksum.c getmntopts.c newfs.c mkfs.c
+MAN8=	newfs.0
+
+MOUNT=	${.CURDIR}/../mount
+CFLAGS+=-DMFS -I${MOUNT}
+.PATH:	${MOUNT} ${.CURDIR}/../disklabel
+
+LINKS=	${BINDIR}/newfs ${BINDIR}/mount_mfs
+MLINKS=	newfs.8 mount_mfs.8 newfs.8 mfs.8
+
+.include <bsd.prog.mk>
diff --git a/ufs-utils/mkfs.c b/ufs-utils/mkfs.c
new file mode 100644
index 00000000..d35dd10b
--- /dev/null
+++ b/ufs-utils/mkfs.c
@@ -0,0 +1,1229 @@
+/*
+ * Copyright (c) 1980, 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+/*static char sccsid[] = "from: @(#)mkfs.c	8.3 (Berkeley) 2/3/94";*/
+static char *rcsid = "$Id: mkfs.c,v 1.1 1994/08/23 19:30:42 mib Exp $";
+#endif /* not lint */
+
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <ufs/ufs/dinode.h>
+#include <ufs/ufs/dir.h>
+#include <ufs/ffs/fs.h>
+#include <sys/disklabel.h>
+
+#ifndef STANDALONE
+#include <a.out.h>
+#include <stdio.h>
+#endif
+
+/*
+ * make file system for cylinder-group style file systems
+ */
+
+/*
+ * We limit the size of the inode map to be no more than a
+ * third of the cylinder group space, since we must leave at
+ * least an equal amount of space for the block map.
+ *
+ * N.B.: MAXIPG must be a multiple of INOPB(fs).
+ */
+#define MAXIPG(fs)	roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs))
+
+#define UMASK		0755
+#define MAXINOPB	(MAXBSIZE / sizeof(struct dinode))
+#define POWEROF2(num)	(((num) & ((num) - 1)) == 0)
+
+/*
+ * variables set up by front end.
+ */
+extern int	mfs;		/* run as the memory based filesystem */
+extern int	Nflag;		/* run mkfs without writing file system */
+extern int	Oflag;		/* format as an 4.3BSD file system */
+extern int	fssize;		/* file system size */
+extern int	ntracks;	/* # tracks/cylinder */
+extern int	nsectors;	/* # sectors/track */
+extern int	nphyssectors;	/* # sectors/track including spares */
+extern int	secpercyl;	/* sectors per cylinder */
+extern int	sectorsize;	/* bytes/sector */
+extern int	rpm;		/* revolutions/minute of drive */
+extern int	interleave;	/* hardware sector interleave */
+extern int	trackskew;	/* sector 0 skew, per track */
+extern int	headswitch;	/* head switch time, usec */
+extern int	trackseek;	/* track-to-track seek, usec */
+extern int	fsize;		/* fragment size */
+extern int	bsize;		/* block size */
+extern int	cpg;		/* cylinders/cylinder group */
+extern int	cpgflg;		/* cylinders/cylinder group flag was given */
+extern int	minfree;	/* free space threshold */
+extern int	opt;		/* optimization preference (space or time) */
+extern int	density;	/* number of bytes per inode */
+extern int	maxcontig;	/* max contiguous blocks to allocate */
+extern int	rotdelay;	/* rotational delay between blocks */
+extern int	maxbpg;		/* maximum blocks per file in a cyl group */
+extern int	nrpos;		/* # of distinguished rotational positions */
+extern int	bbsize;		/* boot block size */
+extern int	sbsize;		/* superblock size */
+extern u_long	memleft;	/* virtual memory available */
+extern caddr_t	membase;	/* start address of memory based filesystem */
+extern caddr_t	malloc(), calloc();
+
+union {
+	struct fs fs;
+	char pad[SBSIZE];
+} fsun;
+#define	sblock	fsun.fs
+struct	csum *fscs;
+
+union {
+	struct cg cg;
+	char pad[MAXBSIZE];
+} cgun;
+#define	acg	cgun.cg
+
+struct dinode zino[MAXBSIZE / sizeof(struct dinode)];
+
+int	fsi, fso;
+daddr_t	alloc();
+
+mkfs(pp, fsys, fi, fo)
+	struct partition *pp;
+	char *fsys;
+	int fi, fo;
+{
+	register long i, mincpc, mincpg, inospercg;
+	long cylno, rpos, blk, j, warn = 0;
+	long used, mincpgcnt, bpcg;
+	long mapcramped, inodecramped;
+	long postblsize, rotblsize, totalsbsize;
+	int ppid, status;
+	time_t utime;
+	quad_t sizepb;
+	void started();
+
+#ifndef STANDALONE
+	time(&utime);
+#endif
+	if (mfs) {
+		ppid = getpid();
+		(void) signal(SIGUSR1, started);
+		if (i = fork()) {
+			if (i == -1) {
+				perror("mfs");
+				exit(10);
+			}
+			if (waitpid(i, &status, 0) != -1 && WIFEXITED(status))
+				exit(WEXITSTATUS(status));
+			exit(11);
+			/* NOTREACHED */
+		}
+		(void)malloc(0);
+		if (fssize * sectorsize > memleft)
+			fssize = (memleft - 16384) / sectorsize;
+		if ((membase = malloc(fssize * sectorsize)) == 0)
+			exit(12);
+	}
+	fsi = fi;
+	fso = fo;
+	if (Oflag) {
+		sblock.fs_inodefmt = FS_42INODEFMT;
+		sblock.fs_maxsymlinklen = 0;
+	} else {
+		sblock.fs_inodefmt = FS_44INODEFMT;
+		sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
+	}
+	/*
+	 * Validate the given file system size.
+	 * Verify that its last block can actually be accessed.
+	 */
+	if (fssize <= 0)
+		printf("preposterous size %d\n", fssize), exit(13);
+	wtfs(fssize - 1, sectorsize, (char *)&sblock);
+	/*
+	 * collect and verify the sector and track info
+	 */
+	sblock.fs_nsect = nsectors;
+	sblock.fs_ntrak = ntracks;
+	if (sblock.fs_ntrak <= 0)
+		printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(14);
+	if (sblock.fs_nsect <= 0)
+		printf("preposterous nsect %d\n", sblock.fs_nsect), exit(15);
+	/*
+	 * collect and verify the block and fragment sizes
+	 */
+	sblock.fs_bsize = bsize;
+	sblock.fs_fsize = fsize;
+	if (!POWEROF2(sblock.fs_bsize)) {
+		printf("block size must be a power of 2, not %d\n",
+		    sblock.fs_bsize);
+		exit(16);
+	}
+	if (!POWEROF2(sblock.fs_fsize)) {
+		printf("fragment size must be a power of 2, not %d\n",
+		    sblock.fs_fsize);
+		exit(17);
+	}
+	if (sblock.fs_fsize < sectorsize) {
+		printf("fragment size %d is too small, minimum is %d\n",
+		    sblock.fs_fsize, sectorsize);
+		exit(18);
+	}
+	if (sblock.fs_bsize < MINBSIZE) {
+		printf("block size %d is too small, minimum is %d\n",
+		    sblock.fs_bsize, MINBSIZE);
+		exit(19);
+	}
+	if (sblock.fs_bsize < sblock.fs_fsize) {
+		printf("block size (%d) cannot be smaller than fragment size (%d)\n",
+		    sblock.fs_bsize, sblock.fs_fsize);
+		exit(20);
+	}
+	sblock.fs_bmask = ~(sblock.fs_bsize - 1);
+	sblock.fs_fmask = ~(sblock.fs_fsize - 1);
+	sblock.fs_qbmask = ~sblock.fs_bmask;
+	sblock.fs_qfmask = ~sblock.fs_fmask;
+	for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
+		sblock.fs_bshift++;
+	for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
+		sblock.fs_fshift++;
+	sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
+	for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
+		sblock.fs_fragshift++;
+	if (sblock.fs_frag > MAXFRAG) {
+		printf("fragment size %d is too small, minimum with block size %d is %d\n",
+		    sblock.fs_fsize, sblock.fs_bsize,
+		    sblock.fs_bsize / MAXFRAG);
+		exit(21);
+	}
+	sblock.fs_nrpos = nrpos;
+	sblock.fs_nindir = sblock.fs_bsize / sizeof(daddr_t);
+	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct dinode);
+	sblock.fs_nspf = sblock.fs_fsize / sectorsize;
+	for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)
+		sblock.fs_fsbtodb++;
+	sblock.fs_sblkno =
+	    roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
+	sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
+	    roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
+	sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
+	sblock.fs_cgoffset = roundup(
+	    howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);
+	for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)
+		sblock.fs_cgmask <<= 1;
+	if (!POWEROF2(sblock.fs_ntrak))
+		sblock.fs_cgmask <<= 1;
+	sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
+	for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
+		sizepb *= NINDIR(&sblock);
+		sblock.fs_maxfilesize += sizepb;
+	}
+	/*
+	 * Validate specified/determined secpercyl
+	 * and calculate minimum cylinders per group.
+	 */
+	sblock.fs_spc = secpercyl;
+	for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
+	     sblock.fs_cpc > 1 && (i & 1) == 0;
+	     sblock.fs_cpc >>= 1, i >>= 1)
+		/* void */;
+	mincpc = sblock.fs_cpc;
+	bpcg = sblock.fs_spc * sectorsize;
+	inospercg = roundup(bpcg / sizeof(struct dinode), INOPB(&sblock));
+	if (inospercg > MAXIPG(&sblock))
+		inospercg = MAXIPG(&sblock);
+	used = (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);
+	mincpgcnt = howmany(sblock.fs_cgoffset * (~sblock.fs_cgmask) + used,
+	    sblock.fs_spc);
+	mincpg = roundup(mincpgcnt, mincpc);
+	/*
+	 * Ensure that cylinder group with mincpg has enough space
+	 * for block maps.
+	 */
+	sblock.fs_cpg = mincpg;
+	sblock.fs_ipg = inospercg;
+	if (maxcontig > 1)
+		sblock.fs_contigsumsize = MIN(maxcontig, FS_MAXCONTIG);
+	mapcramped = 0;
+	while (CGSIZE(&sblock) > sblock.fs_bsize) {
+		mapcramped = 1;
+		if (sblock.fs_bsize < MAXBSIZE) {
+			sblock.fs_bsize <<= 1;
+			if ((i & 1) == 0) {
+				i >>= 1;
+			} else {
+				sblock.fs_cpc <<= 1;
+				mincpc <<= 1;
+				mincpg = roundup(mincpgcnt, mincpc);
+				sblock.fs_cpg = mincpg;
+			}
+			sblock.fs_frag <<= 1;
+			sblock.fs_fragshift += 1;
+			if (sblock.fs_frag <= MAXFRAG)
+				continue;
+		}
+		if (sblock.fs_fsize == sblock.fs_bsize) {
+			printf("There is no block size that");
+			printf(" can support this disk\n");
+			exit(22);
+		}
+		sblock.fs_frag >>= 1;
+		sblock.fs_fragshift -= 1;
+		sblock.fs_fsize <<= 1;
+		sblock.fs_nspf <<= 1;
+	}
+	/*
+	 * Ensure that cylinder group with mincpg has enough space for inodes.
+	 */
+	inodecramped = 0;
+	used *= sectorsize;
+	inospercg = roundup((mincpg * bpcg - used) / density, INOPB(&sblock));
+	sblock.fs_ipg = inospercg;
+	while (inospercg > MAXIPG(&sblock)) {
+		inodecramped = 1;
+		if (mincpc == 1 || sblock.fs_frag == 1 ||
+		    sblock.fs_bsize == MINBSIZE)
+			break;
+		printf("With a block size of %d %s %d\n", sblock.fs_bsize,
+		    "minimum bytes per inode is",
+		    (mincpg * bpcg - used) / MAXIPG(&sblock) + 1);
+		sblock.fs_bsize >>= 1;
+		sblock.fs_frag >>= 1;
+		sblock.fs_fragshift -= 1;
+		mincpc >>= 1;
+		sblock.fs_cpg = roundup(mincpgcnt, mincpc);
+		if (CGSIZE(&sblock) > sblock.fs_bsize) {
+			sblock.fs_bsize <<= 1;
+			break;
+		}
+		mincpg = sblock.fs_cpg;
+		inospercg =
+		    roundup((mincpg * bpcg - used) / density, INOPB(&sblock));
+		sblock.fs_ipg = inospercg;
+	}
+	if (inodecramped) {
+		if (inospercg > MAXIPG(&sblock)) {
+			printf("Minimum bytes per inode is %d\n",
+			    (mincpg * bpcg - used) / MAXIPG(&sblock) + 1);
+		} else if (!mapcramped) {
+			printf("With %d bytes per inode, ", density);
+			printf("minimum cylinders per group is %d\n", mincpg);
+		}
+	}
+	if (mapcramped) {
+		printf("With %d sectors per cylinder, ", sblock.fs_spc);
+		printf("minimum cylinders per group is %d\n", mincpg);
+	}
+	if (inodecramped || mapcramped) {
+		if (sblock.fs_bsize != bsize)
+			printf("%s to be changed from %d to %d\n",
+			    "This requires the block size",
+			    bsize, sblock.fs_bsize);
+		if (sblock.fs_fsize != fsize)
+			printf("\t%s to be changed from %d to %d\n",
+			    "and the fragment size",
+			    fsize, sblock.fs_fsize);
+		exit(23);
+	}
+	/* 
+	 * Calculate the number of cylinders per group
+	 */
+	sblock.fs_cpg = cpg;
+	if (sblock.fs_cpg % mincpc != 0) {
+		printf("%s groups must have a multiple of %d cylinders\n",
+			cpgflg ? "Cylinder" : "Warning: cylinder", mincpc);
+		sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);
+		if (!cpgflg)
+			cpg = sblock.fs_cpg;
+	}
+	/*
+	 * Must ensure there is enough space for inodes.
+	 */
+	sblock.fs_ipg = roundup((sblock.fs_cpg * bpcg - used) / density,
+		INOPB(&sblock));
+	while (sblock.fs_ipg > MAXIPG(&sblock)) {
+		inodecramped = 1;
+		sblock.fs_cpg -= mincpc;
+		sblock.fs_ipg = roundup((sblock.fs_cpg * bpcg - used) / density,
+			INOPB(&sblock));
+	}
+	/*
+	 * Must ensure there is enough space to hold block map.
+	 */
+	while (CGSIZE(&sblock) > sblock.fs_bsize) {
+		mapcramped = 1;
+		sblock.fs_cpg -= mincpc;
+		sblock.fs_ipg = roundup((sblock.fs_cpg * bpcg - used) / density,
+			INOPB(&sblock));
+	}
+	sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
+	if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) {
+		printf("panic (fs_cpg * fs_spc) % NSPF != 0");
+		exit(24);
+	}
+	if (sblock.fs_cpg < mincpg) {
+		printf("cylinder groups must have at least %d cylinders\n",
+			mincpg);
+		exit(25);
+	} else if (sblock.fs_cpg != cpg) {
+		if (!cpgflg)
+			printf("Warning: ");
+		else if (!mapcramped && !inodecramped)
+			exit(26);
+		if (mapcramped && inodecramped)
+			printf("Block size and bytes per inode restrict");
+		else if (mapcramped)
+			printf("Block size restricts");
+		else
+			printf("Bytes per inode restrict");
+		printf(" cylinders per group to %d.\n", sblock.fs_cpg);
+		if (cpgflg)
+			exit(27);
+	}
+	sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
+	/*
+	 * Now have size for file system and nsect and ntrak.
+	 * Determine number of cylinders and blocks in the file system.
+	 */
+	sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
+	sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;
+	if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
+		sblock.fs_ncyl++;
+		warn = 1;
+	}
+	if (sblock.fs_ncyl < 1) {
+		printf("file systems must have at least one cylinder\n");
+		exit(28);
+	}
+	/*
+	 * Determine feasability/values of rotational layout tables.
+	 *
+	 * The size of the rotational layout tables is limited by the
+	 * size of the superblock, SBSIZE. The amount of space available
+	 * for tables is calculated as (SBSIZE - sizeof (struct fs)).
+	 * The size of these tables is inversely proportional to the block
+	 * size of the file system. The size increases if sectors per track
+	 * are not powers of two, because more cylinders must be described
+	 * by the tables before the rotational pattern repeats (fs_cpc).
+	 */
+	sblock.fs_interleave = interleave;
+	sblock.fs_trackskew = trackskew;
+	sblock.fs_npsect = nphyssectors;
+	sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
+	sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));
+	if (sblock.fs_ntrak == 1) {
+		sblock.fs_cpc = 0;
+		goto next;
+	}
+	postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof(short);
+	rotblsize = sblock.fs_cpc * sblock.fs_spc / NSPB(&sblock);
+	totalsbsize = sizeof(struct fs) + rotblsize;
+	if (sblock.fs_nrpos == 8 && sblock.fs_cpc <= 16) {
+		/* use old static table space */
+		sblock.fs_postbloff = (char *)(&sblock.fs_opostbl[0][0]) -
+		    (char *)(&sblock.fs_link);
+		sblock.fs_rotbloff = &sblock.fs_space[0] -
+		    (u_char *)(&sblock.fs_link);
+	} else {
+		/* use dynamic table space */
+		sblock.fs_postbloff = &sblock.fs_space[0] -
+		    (u_char *)(&sblock.fs_link);
+		sblock.fs_rotbloff = sblock.fs_postbloff + postblsize;
+		totalsbsize += postblsize;
+	}
+	if (totalsbsize > SBSIZE ||
+	    sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
+		printf("%s %s %d %s %d.%s",
+		    "Warning: insufficient space in super block for\n",
+		    "rotational layout tables with nsect", sblock.fs_nsect,
+		    "and ntrak", sblock.fs_ntrak,
+		    "\nFile system performance may be impaired.\n");
+		sblock.fs_cpc = 0;
+		goto next;
+	}
+	sblock.fs_sbsize = fragroundup(&sblock, totalsbsize);
+	/*
+	 * calculate the available blocks for each rotational position
+	 */
+	for (cylno = 0; cylno < sblock.fs_cpc; cylno++)
+		for (rpos = 0; rpos < sblock.fs_nrpos; rpos++)
+			fs_postbl(&sblock, cylno)[rpos] = -1;
+	for (i = (rotblsize - 1) * sblock.fs_frag;
+	     i >= 0; i -= sblock.fs_frag) {
+		cylno = cbtocylno(&sblock, i);
+		rpos = cbtorpos(&sblock, i);
+		blk = fragstoblks(&sblock, i);
+		if (fs_postbl(&sblock, cylno)[rpos] == -1)
+			fs_rotbl(&sblock)[blk] = 0;
+		else
+			fs_rotbl(&sblock)[blk] =
+			    fs_postbl(&sblock, cylno)[rpos] - blk;
+		fs_postbl(&sblock, cylno)[rpos] = blk;
+	}
+next:
+	/*
+	 * Compute/validate number of cylinder groups.
+	 */
+	sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
+	if (sblock.fs_ncyl % sblock.fs_cpg)
+		sblock.fs_ncg++;
+	sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
+	i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
+	if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) {
+		printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
+		    cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,
+		    sblock.fs_fpg / sblock.fs_frag);
+		printf("number of cylinders per cylinder group (%d) %s.\n",
+		    sblock.fs_cpg, "must be increased");
+		exit(29);
+	}
+	j = sblock.fs_ncg - 1;
+	if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg &&
+	    cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
+		if (j == 0) {
+			printf("Filesystem must have at least %d sectors\n",
+			    NSPF(&sblock) *
+			    (cgdmin(&sblock, 0) + 3 * sblock.fs_frag));
+			exit(30);
+		}
+		printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n",
+		    (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
+		    i / sblock.fs_frag);
+		printf("    cylinder group. This implies %d sector(s) cannot be allocated.\n",
+		    i * NSPF(&sblock));
+		sblock.fs_ncg--;
+		sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
+		sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
+		    NSPF(&sblock);
+		warn = 0;
+	}
+	if (warn && !mfs) {
+		printf("Warning: %d sector(s) in last cylinder unallocated\n",
+		    sblock.fs_spc -
+		    (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)
+		    * sblock.fs_spc));
+	}
+	/*
+	 * fill in remaining fields of the super block
+	 */
+	sblock.fs_csaddr = cgdmin(&sblock, 0);
+	sblock.fs_cssize =
+	    fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
+	i = sblock.fs_bsize / sizeof(struct csum);
+	sblock.fs_csmask = ~(i - 1);
+	for (sblock.fs_csshift = 0; i > 1; i >>= 1)
+		sblock.fs_csshift++;
+	fscs = (struct csum *)calloc(1, sblock.fs_cssize);
+	sblock.fs_magic = FS_MAGIC;
+	sblock.fs_rotdelay = rotdelay;
+	sblock.fs_minfree = minfree;
+	sblock.fs_maxcontig = maxcontig;
+	sblock.fs_headswitch = headswitch;
+	sblock.fs_trkseek = trackseek;
+	sblock.fs_maxbpg = maxbpg;
+	sblock.fs_rps = rpm / 60;
+	sblock.fs_optim = opt;
+	sblock.fs_cgrotor = 0;
+	sblock.fs_cstotal.cs_ndir = 0;
+	sblock.fs_cstotal.cs_nbfree = 0;
+	sblock.fs_cstotal.cs_nifree = 0;
+	sblock.fs_cstotal.cs_nffree = 0;
+	sblock.fs_fmod = 0;
+	sblock.fs_ronly = 0;
+	/*
+	 * Dump out summary information about file system.
+	 */
+	if (!mfs) {
+		printf("%s:\t%d sectors in %d %s of %d tracks, %d sectors\n",
+		    fsys, sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
+		    "cylinders", sblock.fs_ntrak, sblock.fs_nsect);
+#define B2MBFACTOR (1 / (1024.0 * 1024.0))
+		printf("\t%.1fMB in %d cyl groups (%d c/g, %.2fMB/g, %d i/g)\n",
+		    (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
+		    sblock.fs_ncg, sblock.fs_cpg,
+		    (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
+		    sblock.fs_ipg);
+#undef B2MBFACTOR
+	}
+	/*
+	 * Now build the cylinders group blocks and
+	 * then print out indices of cylinder groups.
+	 */
+	if (!mfs)
+		printf("super-block backups (for fsck -b #) at:");
+	for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
+		initcg(cylno, utime);
+		if (mfs)
+			continue;
+		if (cylno % 8 == 0)
+			printf("\n");
+		printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno)));
+	}
+	if (!mfs)
+		printf("\n");
+	if (Nflag && !mfs)
+		exit(0);
+	/*
+	 * Now construct the initial file system,
+	 * then write out the super-block.
+	 */
+	fsinit(utime);
+	sblock.fs_time = utime;
+	wtfs((int)SBOFF / sectorsize, sbsize, (char *)&sblock);
+	for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
+		wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
+			sblock.fs_cssize - i < sblock.fs_bsize ?
+			    sblock.fs_cssize - i : sblock.fs_bsize,
+			((char *)fscs) + i);
+	/* 
+	 * Write out the duplicate super blocks
+	 */
+	for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
+		wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
+		    sbsize, (char *)&sblock);
+	/*
+	 * Update information about this partion in pack
+	 * label, to that it may be updated on disk.
+	 */
+	pp->p_fstype = FS_BSDFFS;
+	pp->p_fsize = sblock.fs_fsize;
+	pp->p_frag = sblock.fs_frag;
+	pp->p_cpg = sblock.fs_cpg;
+	/*
+	 * Notify parent process of success.
+	 * Dissociate from session and tty.
+	 */
+	if (mfs) {
+		kill(ppid, SIGUSR1);
+		(void) setsid();
+		(void) close(0);
+		(void) close(1);
+		(void) close(2);
+		(void) chdir("/");
+	}
+}
+
+/*
+ * Initialize a cylinder group.
+ */
+initcg(cylno, utime)
+	int cylno;
+	time_t utime;
+{
+	daddr_t cbase, d, dlower, dupper, dmax, blkno;
+	long i, j, s;
+	register struct csum *cs;
+
+	/*
+	 * Determine block bounds for cylinder group.
+	 * Allow space for super block summary information in first
+	 * cylinder group.
+	 */
+	cbase = cgbase(&sblock, cylno);
+	dmax = cbase + sblock.fs_fpg;
+	if (dmax > sblock.fs_size)
+		dmax = sblock.fs_size;
+	dlower = cgsblock(&sblock, cylno) - cbase;
+	dupper = cgdmin(&sblock, cylno) - cbase;
+	if (cylno == 0)
+		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
+	cs = fscs + cylno;
+	bzero(&acg, sblock.fs_cgsize);
+	acg.cg_time = utime;
+	acg.cg_magic = CG_MAGIC;
+	acg.cg_cgx = cylno;
+	if (cylno == sblock.fs_ncg - 1)
+		acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
+	else
+		acg.cg_ncyl = sblock.fs_cpg;
+	acg.cg_niblk = sblock.fs_ipg;
+	acg.cg_ndblk = dmax - cbase;
+	if (sblock.fs_contigsumsize > 0)
+		acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
+	acg.cg_btotoff = &acg.cg_space[0] - (u_char *)(&acg.cg_link);
+	acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(long);
+	acg.cg_iusedoff = acg.cg_boff + 
+		sblock.fs_cpg * sblock.fs_nrpos * sizeof(short);
+	acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
+	if (sblock.fs_contigsumsize <= 0) {
+		acg.cg_nextfreeoff = acg.cg_freeoff +
+		   howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY);
+	} else {
+		acg.cg_clustersumoff = acg.cg_freeoff + howmany
+		    (sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -
+		    sizeof(long);
+		acg.cg_clustersumoff =
+		    roundup(acg.cg_clustersumoff, sizeof(long));
+		acg.cg_clusteroff = acg.cg_clustersumoff +
+		    (sblock.fs_contigsumsize + 1) * sizeof(long);
+		acg.cg_nextfreeoff = acg.cg_clusteroff + howmany
+		    (sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
+	}
+	if (acg.cg_nextfreeoff - (long)(&acg.cg_link) > sblock.fs_cgsize) {
+		printf("Panic: cylinder group too big\n");
+		exit(37);
+	}
+	acg.cg_cs.cs_nifree += sblock.fs_ipg;
+	if (cylno == 0)
+		for (i = 0; i < ROOTINO; i++) {
+			setbit(cg_inosused(&acg), i);
+			acg.cg_cs.cs_nifree--;
+		}
+	for (i = 0; i < sblock.fs_ipg / INOPF(&sblock); i += sblock.fs_frag)
+		wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
+		    sblock.fs_bsize, (char *)zino);
+	if (cylno > 0) {
+		/*
+		 * In cylno 0, beginning space is reserved
+		 * for boot and super blocks.
+		 */
+		for (d = 0; d < dlower; d += sblock.fs_frag) {
+			blkno = d / sblock.fs_frag;
+			setblock(&sblock, cg_blksfree(&acg), blkno);
+			if (sblock.fs_contigsumsize > 0)
+				setbit(cg_clustersfree(&acg), blkno);
+			acg.cg_cs.cs_nbfree++;
+			cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
+			cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
+			    [cbtorpos(&sblock, d)]++;
+		}
+		sblock.fs_dsize += dlower;
+	}
+	sblock.fs_dsize += acg.cg_ndblk - dupper;
+	if (i = dupper % sblock.fs_frag) {
+		acg.cg_frsum[sblock.fs_frag - i]++;
+		for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
+			setbit(cg_blksfree(&acg), dupper);
+			acg.cg_cs.cs_nffree++;
+		}
+	}
+	for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) {
+		blkno = d / sblock.fs_frag;
+		setblock(&sblock, cg_blksfree(&acg), blkno);
+		if (sblock.fs_contigsumsize > 0)
+			setbit(cg_clustersfree(&acg), blkno);
+		acg.cg_cs.cs_nbfree++;
+		cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
+		cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
+		    [cbtorpos(&sblock, d)]++;
+		d += sblock.fs_frag;
+	}
+	if (d < dmax - cbase) {
+		acg.cg_frsum[dmax - cbase - d]++;
+		for (; d < dmax - cbase; d++) {
+			setbit(cg_blksfree(&acg), d);
+			acg.cg_cs.cs_nffree++;
+		}
+	}
+	if (sblock.fs_contigsumsize > 0) {
+		long *sump = cg_clustersum(&acg);
+		u_char *mapp = cg_clustersfree(&acg);
+		int map = *mapp++;
+		int bit = 1;
+		int run = 0;
+
+		for (i = 0; i < acg.cg_nclusterblks; i++) {
+			if ((map & bit) != 0) {
+				run++;
+			} else if (run != 0) {
+				if (run > sblock.fs_contigsumsize)
+					run = sblock.fs_contigsumsize;
+				sump[run]++;
+				run = 0;
+			}
+			if ((i & (NBBY - 1)) != (NBBY - 1)) {
+				bit <<= 1;
+			} else {
+				map = *mapp++;
+				bit = 1;
+			}
+		}
+		if (run != 0) {
+			if (run > sblock.fs_contigsumsize)
+				run = sblock.fs_contigsumsize;
+			sump[run]++;
+		}
+	}
+	sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
+	sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
+	sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
+	sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
+	*cs = acg.cg_cs;
+	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
+		sblock.fs_bsize, (char *)&acg);
+}
+
+/*
+ * initialize the file system
+ */
+struct dinode node;
+
+#ifdef LOSTDIR
+#define PREDEFDIR 3
+#else
+#define PREDEFDIR 2
+#endif
+
+struct direct root_dir[] = {
+	{ ROOTINO, sizeof(struct direct), DT_DIR, 1, "." },
+	{ ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
+#ifdef LOSTDIR
+	{ LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 10, "lost+found" },
+#endif
+};
+struct odirect {
+	u_long	d_ino;
+	u_short	d_reclen;
+	u_short	d_namlen;
+	u_char	d_name[MAXNAMLEN + 1];
+} oroot_dir[] = {
+	{ ROOTINO, sizeof(struct direct), 1, "." },
+	{ ROOTINO, sizeof(struct direct), 2, ".." },
+#ifdef LOSTDIR
+	{ LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" },
+#endif
+};
+#ifdef LOSTDIR
+struct direct lost_found_dir[] = {
+	{ LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 1, "." },
+	{ ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
+	{ 0, DIRBLKSIZ, 0, 0, 0 },
+};
+struct odirect olost_found_dir[] = {
+	{ LOSTFOUNDINO, sizeof(struct direct), 1, "." },
+	{ ROOTINO, sizeof(struct direct), 2, ".." },
+	{ 0, DIRBLKSIZ, 0, 0 },
+};
+#endif
+char buf[MAXBSIZE];
+
+fsinit(utime)
+	time_t utime;
+{
+	int i;
+
+	/*
+	 * initialize the node
+	 */
+	node.di_atime.ts_sec = utime;
+	node.di_mtime.ts_sec = utime;
+	node.di_ctime.ts_sec = utime;
+#ifdef LOSTDIR
+	/*
+	 * create the lost+found directory
+	 */
+	if (Oflag) {
+		(void)makedir((struct direct *)olost_found_dir, 2);
+		for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
+			bcopy(&olost_found_dir[2], &buf[i],
+			    DIRSIZ(0, &olost_found_dir[2]));
+	} else {
+		(void)makedir(lost_found_dir, 2);
+		for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
+			bcopy(&lost_found_dir[2], &buf[i],
+			    DIRSIZ(0, &lost_found_dir[2]));
+	}
+	node.di_mode = IFDIR | UMASK;
+	node.di_nlink = 2;
+	node.di_size = sblock.fs_bsize;
+	node.di_db[0] = alloc(node.di_size, node.di_mode);
+	node.di_blocks = btodb(fragroundup(&sblock, node.di_size));
+	wtfs(fsbtodb(&sblock, node.di_db[0]), node.di_size, buf);
+	iput(&node, LOSTFOUNDINO);
+#endif
+	/*
+	 * create the root directory
+	 */
+	if (mfs)
+		node.di_mode = IFDIR | 01777;
+	else
+		node.di_mode = IFDIR | UMASK;
+	node.di_nlink = PREDEFDIR;
+	if (Oflag)
+		node.di_size = makedir((struct direct *)oroot_dir, PREDEFDIR);
+	else
+		node.di_size = makedir(root_dir, PREDEFDIR);
+	node.di_db[0] = alloc(sblock.fs_fsize, node.di_mode);
+	node.di_blocks = btodb(fragroundup(&sblock, node.di_size));
+	wtfs(fsbtodb(&sblock, node.di_db[0]), sblock.fs_fsize, buf);
+	iput(&node, ROOTINO);
+}
+
+/*
+ * construct a set of directory entries in "buf".
+ * return size of directory.
+ */
+makedir(protodir, entries)
+	register struct direct *protodir;
+	int entries;
+{
+	char *cp;
+	int i, spcleft;
+
+	spcleft = DIRBLKSIZ;
+	for (cp = buf, i = 0; i < entries - 1; i++) {
+		protodir[i].d_reclen = DIRSIZ(0, &protodir[i]);
+		bcopy(&protodir[i], cp, protodir[i].d_reclen);
+		cp += protodir[i].d_reclen;
+		spcleft -= protodir[i].d_reclen;
+	}
+	protodir[i].d_reclen = spcleft;
+	bcopy(&protodir[i], cp, DIRSIZ(0, &protodir[i]));
+	return (DIRBLKSIZ);
+}
+
+/*
+ * allocate a block or frag
+ */
+daddr_t
+alloc(size, mode)
+	int size;
+	int mode;
+{
+	int i, frag;
+	daddr_t d, blkno;
+
+	rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+	    (char *)&acg);
+	if (acg.cg_magic != CG_MAGIC) {
+		printf("cg 0: bad magic number\n");
+		return (0);
+	}
+	if (acg.cg_cs.cs_nbfree == 0) {
+		printf("first cylinder group ran out of space\n");
+		return (0);
+	}
+	for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
+		if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag))
+			goto goth;
+	printf("internal error: can't find block in cyl 0\n");
+	return (0);
+goth:
+	blkno = fragstoblks(&sblock, d);
+	clrblock(&sblock, cg_blksfree(&acg), blkno);
+	if (sblock.fs_contigsumsize > 0)
+		clrbit(cg_clustersfree(&acg), blkno);
+	acg.cg_cs.cs_nbfree--;
+	sblock.fs_cstotal.cs_nbfree--;
+	fscs[0].cs_nbfree--;
+	if (mode & IFDIR) {
+		acg.cg_cs.cs_ndir++;
+		sblock.fs_cstotal.cs_ndir++;
+		fscs[0].cs_ndir++;
+	}
+	cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
+	cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--;
+	if (size != sblock.fs_bsize) {
+		frag = howmany(size, sblock.fs_fsize);
+		fscs[0].cs_nffree += sblock.fs_frag - frag;
+		sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
+		acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
+		acg.cg_frsum[sblock.fs_frag - frag]++;
+		for (i = frag; i < sblock.fs_frag; i++)
+			setbit(cg_blksfree(&acg), d + i);
+	}
+	wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+	    (char *)&acg);
+	return (d);
+}
+
+/*
+ * Allocate an inode on the disk
+ */
+iput(ip, ino)
+	register struct dinode *ip;
+	register ino_t ino;
+{
+	struct dinode buf[MAXINOPB];
+	daddr_t d;
+	int c;
+
+	c = ino_to_cg(&sblock, ino);
+	rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+	    (char *)&acg);
+	if (acg.cg_magic != CG_MAGIC) {
+		printf("cg 0: bad magic number\n");
+		exit(31);
+	}
+	acg.cg_cs.cs_nifree--;
+	setbit(cg_inosused(&acg), ino);
+	wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+	    (char *)&acg);
+	sblock.fs_cstotal.cs_nifree--;
+	fscs[0].cs_nifree--;
+	if (ino >= sblock.fs_ipg * sblock.fs_ncg) {
+		printf("fsinit: inode value out of range (%d).\n", ino);
+		exit(32);
+	}
+	d = fsbtodb(&sblock, ino_to_fsba(&sblock, ino));
+	rdfs(d, sblock.fs_bsize, buf);
+	buf[ino_to_fsbo(&sblock, ino)] = *ip;
+	wtfs(d, sblock.fs_bsize, buf);
+}
+
+/*
+ * Notify parent process that the filesystem has created itself successfully.
+ */
+void
+started()
+{
+
+	exit(0);
+}
+
+/*
+ * Replace libc function with one suited to our needs.
+ */
+caddr_t
+malloc(size)
+	register u_long size;
+{
+	char *base, *i;
+	static u_long pgsz;
+	struct rlimit rlp;
+
+	if (pgsz == 0) {
+		base = sbrk(0);
+		pgsz = getpagesize() - 1;
+		i = (char *)((u_long)(base + pgsz) &~ pgsz);
+		base = sbrk(i - base);
+		if (getrlimit(RLIMIT_DATA, &rlp) < 0)
+			perror("getrlimit");
+		rlp.rlim_cur = rlp.rlim_max;
+		if (setrlimit(RLIMIT_DATA, &rlp) < 0)
+			perror("setrlimit");
+		memleft = rlp.rlim_max - (u_long)base;
+	}
+	size = (size + pgsz) &~ pgsz;
+	if (size > memleft)
+		size = memleft;
+	memleft -= size;
+	if (size == 0)
+		return (0);
+	return ((caddr_t)sbrk(size));
+}
+
+/*
+ * Replace libc function with one suited to our needs.
+ */
+caddr_t
+realloc(ptr, size)
+	char *ptr;
+	u_long size;
+{
+	void *p;
+
+	if ((p = malloc(size)) == NULL)
+		return (NULL);
+	bcopy(ptr, p, size);
+	free(ptr);
+	return (p);
+}
+
+/*
+ * Replace libc function with one suited to our needs.
+ */
+char *
+calloc(size, numelm)
+	u_long size, numelm;
+{
+	caddr_t base;
+
+	size *= numelm;
+	base = malloc(size);
+	bzero(base, size);
+	return (base);
+}
+
+/*
+ * Replace libc function with one suited to our needs.
+ */
+free(ptr)
+	char *ptr;
+{
+	
+	/* do not worry about it for now */
+}
+
+/*
+ * read a block from the file system
+ */
+rdfs(bno, size, bf)
+	daddr_t bno;
+	int size;
+	char *bf;
+{
+	int n;
+
+	if (mfs) {
+		bcopy(membase + bno * sectorsize, bf, size);
+		return;
+	}
+	if (lseek(fsi, (off_t)bno * sectorsize, 0) < 0) {
+		printf("seek error: %ld\n", bno);
+		perror("rdfs");
+		exit(33);
+	}
+	n = read(fsi, bf, size);
+	if (n != size) {
+		printf("read error: %ld\n", bno);
+		perror("rdfs");
+		exit(34);
+	}
+}
+
+/*
+ * write a block to the file system
+ */
+wtfs(bno, size, bf)
+	daddr_t bno;
+	int size;
+	char *bf;
+{
+	int n;
+
+	if (mfs) {
+		bcopy(bf, membase + bno * sectorsize, size);
+		return;
+	}
+	if (Nflag)
+		return;
+	if (lseek(fso, (off_t)bno * sectorsize, SEEK_SET) < 0) {
+		printf("seek error: %ld\n", bno);
+		perror("wtfs");
+		exit(35);
+	}
+	n = write(fso, bf, size);
+	if (n != size) {
+		printf("write error: %ld\n", bno);
+		perror("wtfs");
+		exit(36);
+	}
+}
+
+/*
+ * check if a block is available
+ */
+isblock(fs, cp, h)
+	struct fs *fs;
+	unsigned char *cp;
+	int h;
+{
+	unsigned char mask;
+
+	switch (fs->fs_frag) {
+	case 8:
+		return (cp[h] == 0xff);
+	case 4:
+		mask = 0x0f << ((h & 0x1) << 2);
+		return ((cp[h >> 1] & mask) == mask);
+	case 2:
+		mask = 0x03 << ((h & 0x3) << 1);
+		return ((cp[h >> 2] & mask) == mask);
+	case 1:
+		mask = 0x01 << (h & 0x7);
+		return ((cp[h >> 3] & mask) == mask);
+	default:
+#ifdef STANDALONE
+		printf("isblock bad fs_frag %d\n", fs->fs_frag);
+#else
+		fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+		return (0);
+	}
+}
+
+/*
+ * take a block out of the map
+ */
+clrblock(fs, cp, h)
+	struct fs *fs;
+	unsigned char *cp;
+	int h;
+{
+	switch ((fs)->fs_frag) {
+	case 8:
+		cp[h] = 0;
+		return;
+	case 4:
+		cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
+		return;
+	case 2:
+		cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
+		return;
+	case 1:
+		cp[h >> 3] &= ~(0x01 << (h & 0x7));
+		return;
+	default:
+#ifdef STANDALONE
+		printf("clrblock bad fs_frag %d\n", fs->fs_frag);
+#else
+		fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+		return;
+	}
+}
+
+/*
+ * put a block into the map
+ */
+setblock(fs, cp, h)
+	struct fs *fs;
+	unsigned char *cp;
+	int h;
+{
+	switch (fs->fs_frag) {
+	case 8:
+		cp[h] = 0xff;
+		return;
+	case 4:
+		cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
+		return;
+	case 2:
+		cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
+		return;
+	case 1:
+		cp[h >> 3] |= (0x01 << (h & 0x7));
+		return;
+	default:
+#ifdef STANDALONE
+		printf("setblock bad fs_frag %d\n", fs->fs_frag);
+#else
+		fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+		return;
+	}
+}
diff --git a/ufs-utils/newfs.c b/ufs-utils/newfs.c
new file mode 100644
index 00000000..f468ef24
--- /dev/null
+++ b/ufs-utils/newfs.c
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) 1983, 1989, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char copyright[] =
+"@(#) Copyright (c) 1983, 1989, 1993, 1994\n\
+	The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+/*static char sccsid[] = "from: @(#)newfs.c	8.8 (Berkeley) 4/18/94";*/
+static char *rcsid = "$Id: newfs.c,v 1.1 1994/08/23 19:30:43 mib Exp $";
+#endif /* not lint */
+
+/*
+ * newfs: friendly front end to mkfs
+ */
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/disklabel.h>
+#include <sys/file.h>
+#include <sys/mount.h>
+
+#include <ufs/ufs/dir.h>
+#include <ufs/ffs/fs.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <unistd.h>
+
+#if __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "mntopts.h"
+
+struct mntopt mopts[] = {
+	MOPT_STDOPTS,
+	MOPT_ASYNC,
+	{ NULL },
+};
+
+#if __STDC__
+void	fatal(const char *fmt, ...);
+#else
+void	fatal();
+#endif
+
+#define	COMPAT			/* allow non-labeled disks */
+
+/*
+ * The following two constants set the default block and fragment sizes.
+ * Both constants must be a power of 2 and meet the following constraints:
+ *	MINBSIZE <= DESBLKSIZE <= MAXBSIZE
+ *	sectorsize <= DESFRAGSIZE <= DESBLKSIZE
+ *	DESBLKSIZE / DESFRAGSIZE <= 8
+ */
+#define	DFL_FRAGSIZE	1024
+#define	DFL_BLKSIZE	8192
+
+/*
+ * Cylinder groups may have up to many cylinders. The actual
+ * number used depends upon how much information can be stored
+ * on a single cylinder. The default is to use 16 cylinders
+ * per group.
+ */
+#define	DESCPG		16	/* desired fs_cpg */
+
+/*
+ * ROTDELAY gives the minimum number of milliseconds to initiate
+ * another disk transfer on the same cylinder. It is used in
+ * determining the rotationally optimal layout for disk blocks
+ * within a file; the default of fs_rotdelay is 4ms.
+ */
+#define ROTDELAY	4
+
+/*
+ * MAXBLKPG determines the maximum number of data blocks which are
+ * placed in a single cylinder group. The default is one indirect
+ * block worth of data blocks.
+ */
+#define MAXBLKPG(bsize)	((bsize) / sizeof(daddr_t))
+
+/*
+ * Each file system has a number of inodes statically allocated.
+ * We allocate one inode slot per NFPI fragments, expecting this
+ * to be far more than we will ever need.
+ */
+#define	NFPI		4
+
+/*
+ * For each cylinder we keep track of the availability of blocks at different
+ * rotational positions, so that we can lay out the data to be picked
+ * up with minimum rotational latency.  NRPOS is the default number of
+ * rotational positions that we distinguish.  With NRPOS of 8 the resolution
+ * of our summary information is 2ms for a typical 3600 rpm drive.
+ */
+#define	NRPOS		8	/* number distinct rotational positions */
+
+
+int	mfs;			/* run as the memory based filesystem */
+int	Nflag;			/* run without writing file system */
+int	Oflag;			/* format as an 4.3BSD file system */
+int	fssize;			/* file system size */
+int	ntracks;		/* # tracks/cylinder */
+int	nsectors;		/* # sectors/track */
+int	nphyssectors;		/* # sectors/track including spares */
+int	secpercyl;		/* sectors per cylinder */
+int	trackspares = -1;	/* spare sectors per track */
+int	cylspares = -1;		/* spare sectors per cylinder */
+int	sectorsize;		/* bytes/sector */
+#ifdef tahoe
+int	realsectorsize;		/* bytes/sector in hardware */
+#endif
+int	rpm;			/* revolutions/minute of drive */
+int	interleave;		/* hardware sector interleave */
+int	trackskew = -1;		/* sector 0 skew, per track */
+int	headswitch;		/* head switch time, usec */
+int	trackseek;		/* track-to-track seek, usec */
+int	fsize = 0;		/* fragment size */
+int	bsize = 0;		/* block size */
+int	cpg = DESCPG;		/* cylinders/cylinder group */
+int	cpgflg;			/* cylinders/cylinder group flag was given */
+int	minfree = MINFREE;	/* free space threshold */
+int	opt = DEFAULTOPT;	/* optimization preference (space or time) */
+int	density;		/* number of bytes per inode */
+int	maxcontig = 0;		/* max contiguous blocks to allocate */
+int	rotdelay = ROTDELAY;	/* rotational delay between blocks */
+int	maxbpg;			/* maximum blocks per file in a cyl group */
+int	nrpos = NRPOS;		/* # of distinguished rotational positions */
+int	bbsize = BBSIZE;	/* boot block size */
+int	sbsize = SBSIZE;	/* superblock size */
+int	mntflags = MNT_ASYNC;	/* flags to be passed to mount */
+u_long	memleft;		/* virtual memory available */
+caddr_t	membase;		/* start address of memory based filesystem */
+#ifdef COMPAT
+char	*disktype;
+int	unlabeled;
+#endif
+
+char	device[MAXPATHLEN];
+char	*progname;
+
+int
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	extern char *optarg;
+	extern int optind;
+	register int ch;
+	register struct partition *pp;
+	register struct disklabel *lp;
+	struct disklabel *getdisklabel();
+	struct partition oldpartition;
+	struct stat st;
+	struct statfs *mp;
+	int fsi, fso, len, n;
+	char *cp, *s1, *s2, *special, *opstring, buf[BUFSIZ];
+
+	if (progname = rindex(*argv, '/'))
+		++progname;
+	else
+		progname = *argv;
+
+	if (strstr(progname, "mfs")) {
+		mfs = 1;
+		Nflag++;
+	}
+
+	opstring = mfs ?
+	    "NT:a:b:c:d:e:f:i:m:o:s:" :
+	    "NOS:T:a:b:c:d:e:f:i:k:l:m:n:o:p:r:s:t:u:x:";
+	while ((ch = getopt(argc, argv, opstring)) != EOF)
+		switch (ch) {
+		case 'N':
+			Nflag = 1;
+			break;
+		case 'O':
+			Oflag = 1;
+			break;
+		case 'S':
+			if ((sectorsize = atoi(optarg)) <= 0)
+				fatal("%s: bad sector size", optarg);
+			break;
+#ifdef COMPAT
+		case 'T':
+			disktype = optarg;
+			break;
+#endif
+		case 'a':
+			if ((maxcontig = atoi(optarg)) <= 0)
+				fatal("%s: bad maximum contiguous blocks\n",
+				    optarg);
+			break;
+		case 'b':
+			if ((bsize = atoi(optarg)) < MINBSIZE)
+				fatal("%s: bad block size", optarg);
+			break;
+		case 'c':
+			if ((cpg = atoi(optarg)) <= 0)
+				fatal("%s: bad cylinders/group", optarg);
+			cpgflg++;
+			break;
+		case 'd':
+			if ((rotdelay = atoi(optarg)) < 0)
+				fatal("%s: bad rotational delay\n", optarg);
+			break;
+		case 'e':
+			if ((maxbpg = atoi(optarg)) <= 0)
+		fatal("%s: bad blocks per file in a cylinder group\n",
+				    optarg);
+			break;
+		case 'f':
+			if ((fsize = atoi(optarg)) <= 0)
+				fatal("%s: bad fragment size", optarg);
+			break;
+		case 'i':
+			if ((density = atoi(optarg)) <= 0)
+				fatal("%s: bad bytes per inode\n", optarg);
+			break;
+		case 'k':
+			if ((trackskew = atoi(optarg)) < 0)
+				fatal("%s: bad track skew", optarg);
+			break;
+		case 'l':
+			if ((interleave = atoi(optarg)) <= 0)
+				fatal("%s: bad interleave", optarg);
+			break;
+		case 'm':
+			if ((minfree = atoi(optarg)) < 0 || minfree > 99)
+				fatal("%s: bad free space %%\n", optarg);
+			break;
+		case 'n':
+			if ((nrpos = atoi(optarg)) <= 0)
+				fatal("%s: bad rotational layout count\n",
+				    optarg);
+			break;
+		case 'o':
+			if (mfs)
+				getmntopts(optarg, mopts, &mntflags);
+			else {
+				if (strcmp(optarg, "space") == 0)
+					opt = FS_OPTSPACE;
+				else if (strcmp(optarg, "time") == 0)
+					opt = FS_OPTTIME;
+				else
+	fatal("%s: unknown optimization preference: use `space' or `time'.");
+			}
+			break;
+		case 'p':
+			if ((trackspares = atoi(optarg)) < 0)
+				fatal("%s: bad spare sectors per track",
+				    optarg);
+			break;
+		case 'r':
+			if ((rpm = atoi(optarg)) <= 0)
+				fatal("%s: bad revolutions/minute\n", optarg);
+			break;
+		case 's':
+			if ((fssize = atoi(optarg)) <= 0)
+				fatal("%s: bad file system size", optarg);
+			break;
+		case 't':
+			if ((ntracks = atoi(optarg)) <= 0)
+				fatal("%s: bad total tracks", optarg);
+			break;
+		case 'u':
+			if ((nsectors = atoi(optarg)) <= 0)
+				fatal("%s: bad sectors/track", optarg);
+			break;
+		case 'x':
+			if ((cylspares = atoi(optarg)) < 0)
+				fatal("%s: bad spare sectors per cylinder",
+				    optarg);
+			break;
+		case '?':
+		default:
+			usage();
+		}
+	argc -= optind;
+	argv += optind;
+
+	if (argc != 2 && (mfs || argc != 1))
+		usage();
+
+	special = argv[0];
+	cp = rindex(special, '/');
+	if (cp == 0) {
+		/*
+		 * No path prefix; try /dev/r%s then /dev/%s.
+		 */
+		(void)sprintf(device, "%sr%s", _PATH_DEV, special);
+		if (stat(device, &st) == -1)
+			(void)sprintf(device, "%s%s", _PATH_DEV, special);
+		special = device;
+	}
+	if (Nflag) {
+		fso = -1;
+	} else {
+		fso = open(special, O_WRONLY);
+		if (fso < 0)
+			fatal("%s: %s", special, strerror(errno));
+
+		/* 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 = open(special, O_RDONLY);
+		if (fsi < 0)
+			fatal("%s: %s", special, strerror(errno));
+		if (fstat(fsi, &st) < 0)
+			fatal("%s: %s", special, strerror(errno));
+		if ((st.st_mode & S_IFMT) != S_IFCHR && !mfs)
+			printf("%s: %s: not a character-special device\n",
+			    progname, special);
+		cp = index(argv[0], '\0') - 1;
+		if (cp == 0 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp))
+			fatal("%s: can't figure out file system partition",
+			    argv[0]);
+#ifdef COMPAT
+		if (!mfs && disktype == NULL)
+			disktype = argv[1];
+#endif
+		lp = getdisklabel(special, fsi);
+		if (isdigit(*cp))
+			pp = &lp->d_partitions[0];
+		else
+			pp = &lp->d_partitions[*cp - 'a'];
+		if (pp->p_size == 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);
+	}
+	if (fssize == 0)
+		fssize = pp->p_size;
+	if (fssize > pp->p_size && !mfs)
+	       fatal("%s: maximum file system size on the `%c' partition is %d",
+			argv[0], *cp, pp->p_size);
+	if (rpm == 0) {
+		rpm = lp->d_rpm;
+		if (rpm <= 0)
+			rpm = 3600;
+	}
+	if (ntracks == 0) {
+		ntracks = lp->d_ntracks;
+		if (ntracks <= 0)
+			fatal("%s: no default #tracks", argv[0]);
+	}
+	if (nsectors == 0) {
+		nsectors = lp->d_nsectors;
+		if (nsectors <= 0)
+			fatal("%s: no default #sectors/track", argv[0]);
+	}
+	if (sectorsize == 0) {
+		sectorsize = lp->d_secsize;
+		if (sectorsize <= 0)
+			fatal("%s: no default sector size", argv[0]);
+	}
+	if (trackskew == -1) {
+		trackskew = lp->d_trackskew;
+		if (trackskew < 0)
+			trackskew = 0;
+	}
+	if (interleave == 0) {
+		interleave = lp->d_interleave;
+		if (interleave <= 0)
+			interleave = 1;
+	}
+	if (fsize == 0) {
+		fsize = pp->p_fsize;
+		if (fsize <= 0)
+			fsize = MAX(DFL_FRAGSIZE, lp->d_secsize);
+	}
+	if (bsize == 0) {
+		bsize = pp->p_frag * pp->p_fsize;
+		if (bsize <= 0)
+			bsize = MIN(DFL_BLKSIZE, 8 * fsize);
+	}
+	/*
+	 * Maxcontig sets the default for the maximum number of blocks
+	 * that may be allocated sequentially. With filesystem clustering
+	 * it is possible to allocate contiguous blocks up to the maximum
+	 * transfer size permitted by the controller or buffering.
+	 */
+	if (maxcontig == 0)
+		maxcontig = MAX(1, MIN(MAXPHYS, MAXBSIZE) / bsize - 1);
+	if (density == 0)
+		density = NFPI * fsize;
+	if (minfree < MINFREE && opt != FS_OPTSPACE) {
+		fprintf(stderr, "Warning: changing optimization to space ");
+		fprintf(stderr, "because minfree is less than %d%%\n", MINFREE);
+		opt = FS_OPTSPACE;
+	}
+	if (trackspares == -1) {
+		trackspares = lp->d_sparespertrack;
+		if (trackspares < 0)
+			trackspares = 0;
+	}
+	nphyssectors = nsectors + trackspares;
+	if (cylspares == -1) {
+		cylspares = lp->d_sparespercyl;
+		if (cylspares < 0)
+			cylspares = 0;
+	}
+	secpercyl = nsectors * ntracks - cylspares;
+	if (secpercyl != lp->d_secpercyl)
+		fprintf(stderr, "%s (%d) %s (%lu)\n",
+			"Warning: calculated sectors per cylinder", secpercyl,
+			"disagrees with disk label", lp->d_secpercyl);
+	if (maxbpg == 0)
+		maxbpg = MAXBLKPG(bsize);
+	headswitch = lp->d_headswitch;
+	trackseek = lp->d_trkseek;
+#ifdef notdef /* label may be 0 if faked up by kernel */
+	bbsize = lp->d_bbsize;
+	sbsize = lp->d_sbsize;
+#endif
+	oldpartition = *pp;
+#ifdef tahoe
+	realsectorsize = sectorsize;
+	if (sectorsize != DEV_BSIZE) {		/* XXX */
+		int secperblk = DEV_BSIZE / sectorsize;
+
+		sectorsize = DEV_BSIZE;
+		nsectors /= secperblk;
+		nphyssectors /= secperblk;
+		secpercyl /= secperblk;
+		fssize /= secperblk;
+		pp->p_size /= secperblk;
+	}
+#endif
+	mkfs(pp, special, fsi, fso);
+#ifdef tahoe
+	if (realsectorsize != DEV_BSIZE)
+		pp->p_size *= DEV_BSIZE / realsectorsize;
+#endif
+	if (!Nflag && bcmp(pp, &oldpartition, sizeof(oldpartition)))
+		rewritelabel(special, fso, lp);
+	if (!Nflag)
+		close(fso);
+	close(fsi);
+#ifdef MFS
+	if (mfs) {
+		struct mfs_args args;
+
+		sprintf(buf, "mfs:%d", getpid());
+		args.fspec = buf;
+		args.export.ex_root = -2;
+		if (mntflags & MNT_RDONLY)
+			args.export.ex_flags = MNT_EXRDONLY;
+		else
+			args.export.ex_flags = 0;
+		args.base = membase;
+		args.size = fssize * sectorsize;
+		if (mount(MOUNT_MFS, argv[1], mntflags, &args) < 0)
+			fatal("%s: %s", argv[1], strerror(errno));
+	}
+#endif
+	exit(0);
+}
+
+#ifdef COMPAT
+char lmsg[] = "%s: can't read disk label; disk type must be specified";
+#else
+char lmsg[] = "%s: can't read disk label";
+#endif
+
+struct disklabel *
+getdisklabel(s, fd)
+	char *s;
+	int fd;
+{
+	static struct disklabel lab;
+
+	if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
+#ifdef COMPAT
+		if (disktype) {
+			struct disklabel *lp, *getdiskbyname();
+
+			unlabeled++;
+			lp = getdiskbyname(disktype);
+			if (lp == NULL)
+				fatal("%s: unknown disk type", disktype);
+			return (lp);
+		}
+#endif
+		warn("ioctl (GDINFO)");
+		fatal(lmsg, s);
+	}
+	return (&lab);
+}
+
+rewritelabel(s, fd, lp)
+	char *s;
+	int fd;
+	register struct disklabel *lp;
+{
+#ifdef COMPAT
+	if (unlabeled)
+		return;
+#endif
+	lp->d_checksum = 0;
+	lp->d_checksum = dkcksum(lp);
+	if (ioctl(fd, DIOCWDINFO, (char *)lp) < 0) {
+		warn("ioctl (WDINFO)");
+		fatal("%s: can't rewrite disk label", s);
+	}
+#if vax
+	if (lp->d_type == DTYPE_SMD && lp->d_flags & D_BADSECT) {
+		register i;
+		int cfd;
+		daddr_t alt;
+		char specname[64];
+		char blk[1024];
+		char *cp;
+
+		/*
+		 * Make name for 'c' partition.
+		 */
+		strcpy(specname, s);
+		cp = specname + strlen(specname) - 1;
+		if (!isdigit(*cp))
+			*cp = 'c';
+		cfd = open(specname, O_WRONLY);
+		if (cfd < 0)
+			fatal("%s: %s", specname, strerror(errno));
+		bzero(blk, sizeof(blk));
+		*(struct disklabel *)(blk + LABELOFFSET) = *lp;
+		alt = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors;
+		for (i = 1; i < 11 && i < lp->d_nsectors; i += 2) {
+			if (lseek(cfd, (off_t)(alt + i) * lp->d_secsize,
+			    L_SET) == -1)
+				fatal("lseek to badsector area: %s",
+				    strerror(errno));
+			if (write(cfd, blk, lp->d_secsize) < lp->d_secsize)
+				warn("alternate label %d write", i/2);
+		}
+		close(cfd);
+	}
+#endif
+}
+
+/*VARARGS*/
+void
+#if __STDC__
+fatal(const char *fmt, ...)
+#else
+fatal(fmt, va_alist)
+	char *fmt;
+	va_dcl
+#endif
+{
+	va_list ap;
+
+#if __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
+	if (fcntl(STDERR_FILENO, F_GETFL) < 0) {
+		openlog(progname, LOG_CONS, LOG_DAEMON);
+		vsyslog(LOG_ERR, fmt, ap);
+		closelog();
+	} else {
+		vwarnx(fmt, ap);
+	}
+	va_end(ap);
+	exit(1);
+	/*NOTREACHED*/
+}
+
+usage()
+{
+	if (mfs) {
+		fprintf(stderr,
+		    "usage: %s [ -fsoptions ] special-device mount-point\n",
+			progname);
+	} else
+		fprintf(stderr,
+		    "usage: %s [ -fsoptions ] special-device%s\n",
+		    progname,
+#ifdef COMPAT
+		    " [device-type]");
+#else
+		    "");
+#endif
+	fprintf(stderr, "where fsoptions are:\n");
+	fprintf(stderr,
+	    "\t-N do not create file system, just print out parameters\n");
+	fprintf(stderr, "\t-O create a 4.3BSD format filesystem\n");
+	fprintf(stderr, "\t-S sector size\n");
+#ifdef COMPAT
+	fprintf(stderr, "\t-T disktype\n");
+#endif
+	fprintf(stderr, "\t-a maximum contiguous blocks\n");
+	fprintf(stderr, "\t-b block size\n");
+	fprintf(stderr, "\t-c cylinders/group\n");
+	fprintf(stderr, "\t-d rotational delay between contiguous blocks\n");
+	fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n");
+	fprintf(stderr, "\t-f frag size\n");
+	fprintf(stderr, "\t-i number of bytes per inode\n");
+	fprintf(stderr, "\t-k sector 0 skew, per track\n");
+	fprintf(stderr, "\t-l hardware sector interleave\n");
+	fprintf(stderr, "\t-m minimum free space %%\n");
+	fprintf(stderr, "\t-n number of distinguished rotational positions\n");
+	fprintf(stderr, "\t-o optimization preference (`space' or `time')\n");
+	fprintf(stderr, "\t-p spare sectors per track\n");
+	fprintf(stderr, "\t-s file system size (sectors)\n");
+	fprintf(stderr, "\t-r revolutions/minute\n");
+	fprintf(stderr, "\t-t tracks/cylinder\n");
+	fprintf(stderr, "\t-u sectors/track\n");
+	fprintf(stderr, "\t-x spare sectors per cylinder\n");
+	exit(1);
+}