BSD 4.4 Lite sbin Sources

Note:  XNSrouted and routed NOT imported here, they shall be imported with
usr.sbin.

7 files changed, 1505 insertions, 0 deletions

diff --git a/sbin/newlfs/Makefile b/sbin/newlfs/Makefile
new file mode 100644
index 000000000000..c79c83e2116c
--- /dev/null
+++ b/sbin/newlfs/Makefile
@@ -0,0 +1,9 @@
+#	@(#)Makefile	8.1 (Berkeley) 6/18/93
+
+PROG=	newlfs
+CFLAGS+=-I/sys/ufs/lfs
+SRCS=	dkcksum.c lfs.c lfs_cksum.c misc.c newfs.c
+MAN8=	newlfs.0
+.PATH:	/sys/ufs/lfs ${.CURDIR}/../disklabel
+
+.include <bsd.prog.mk>
diff --git a/sbin/newlfs/config.h b/sbin/newlfs/config.h
new file mode 100644
index 000000000000..9c8b394a9d5b
--- /dev/null
+++ b/sbin/newlfs/config.h
@@ -0,0 +1,134 @@
+/*-
+ * Copyright (c) 1991, 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.
+ *
+ *	@(#)config.h	8.2 (Berkeley) 4/22/94
+ */
+
+/*
+ * The first boot and super blocks are given in absolute disk addresses.
+ * The byte-offset forms are preferred, as they don't imply a sector size.
+ */
+#define BBSIZE		8192
+#define SBSIZE		8192
+
+/*
+ * 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 */
+
+/*
+ * MINFREE gives the minimum acceptable percentage of file system
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the file system
+ * is run at between 90% and 100% full; thus the default value of
+ * fs_minfree is 10%. With 10% free space, fragmentation is not a
+ * problem, so we choose to optimize for time.
+ */
+#define MINFREE		10
+#define DEFAULTOPT	FS_OPTTIME
+
+/*
+ * Preference for optimization.
+ */
+#define FS_OPTTIME	0	/* minimize allocation time */
+#define FS_OPTSPACE	1	/* minimize disk fragmentation */
+
+
+/*
+ * 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
+
+/*
+ * MAXCONTIG sets the default for the maximum number of blocks
+ * that may be allocated sequentially. Since UNIX drivers are
+ * not capable of scheduling multi-block transfers, this defaults
+ * to 1 (ie no contiguous blocks are allocated).
+ */
+#define MAXCONTIG	1
+
+/*
+ * 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 */
+
+/*
+ * The following constants set the default block and segment size for a log
+ * structured file system.  Both must be powers of two and the segment size
+ * must be a multiple of the block size.  We also set minimum block and segment
+ * sizes.
+ */
+#define	LFS_MINSEGSIZE		(64*1024)
+#define	DFL_LFSSEG		(1024 * 1024)
+#define	DFL_LFSSEG_SHIFT	20
+#define	DFL_LFSSEG_MASK		0xFFFFF
+
+#define	LFS_MINBLOCKSIZE	1024
+#define	DFL_LFSBLOCK		4096
+#define	DFL_LFSBLOCK_SHIFT	12
+#define	DFL_LFSBLOCK_MASK	0xFFF
diff --git a/sbin/newlfs/extern.h b/sbin/newlfs/extern.h
new file mode 100644
index 000000000000..c65cdba30589
--- /dev/null
+++ b/sbin/newlfs/extern.h
@@ -0,0 +1,45 @@
+/*-
+ * Copyright (c) 1991, 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.
+ *
+ *	@(#)extern.h	8.1 (Berkeley) 6/5/93
+ */
+
+u_long	cksum __P((void *, size_t));
+u_short	dkcksum __P((struct disklabel *));
+void	fatal __P((const char *fmt, ...));
+u_int	log2 __P((u_int));
+int	make_lfs
+	    __P((int, struct disklabel *, struct partition *, int, int, int));
+int	mkfs __P((struct partition *, char *, int, int));
+
+extern char	*progname;
+extern char	*special;
diff --git a/sbin/newlfs/lfs.c b/sbin/newlfs/lfs.c
new file mode 100644
index 000000000000..c79a0dcb8349
--- /dev/null
+++ b/sbin/newlfs/lfs.c
@@ -0,0 +1,673 @@
+/*-
+ * Copyright (c) 1991, 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[] = "@(#)lfs.c	8.1 (Berkeley) 6/5/93";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/disklabel.h>
+#include <sys/time.h>
+#include <sys/mount.h>
+
+#include <ufs/ufs/dir.h>
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/dinode.h>
+#include <ufs/lfs/lfs.h>
+
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include "config.h"
+#include "extern.h"
+
+/*
+ * This table is indexed by the log base 2 of the block size.
+ * It returns the maximum file size allowed in a file system
+ * with the specified block size.  For block sizes smaller than
+ * 8K, the size is limited by tha maximum number of blocks that
+ * can be reached by triply indirect blocks:
+ *	NDADDR + INOPB(bsize) + INOPB(bsize)^2 + INOPB(bsize)^3
+ * For block size of 8K or larger, the file size is limited by the
+ * number of blocks that can be represented in the file system.  Since
+ * we use negative block numbers to represent indirect blocks, we can
+ * have a maximum of 2^31 blocks.
+ */
+
+u_quad_t maxtable[] = {
+	/*    1 */ -1,
+	/*    2 */ -1,
+	/*    4 */ -1,
+	/*    8 */ -1,
+	/*   16 */ -1,
+	/*   32 */ -1,
+	/*   64 */ -1,
+	/*  128 */ -1,
+	/*  256 */ -1,
+	/*  512 */ NDADDR + 128 + 128 * 128 + 128 * 128 * 128,
+	/* 1024 */ NDADDR + 256 + 256 * 256 + 256 * 256 * 256,
+	/* 2048 */ NDADDR + 512 + 512 * 512 + 512 * 512 * 512,
+	/* 4096 */ NDADDR + 1024 + 1024 * 1024 + 1024 * 1024 * 1024,
+	/* 8192 */ 1 << 31,
+	/* 16 K */ 1 << 31,
+	/* 32 K */ 1 << 31,
+};
+
+static struct lfs lfs_default =  {
+	/* lfs_magic */		LFS_MAGIC,
+	/* lfs_version */	LFS_VERSION,
+	/* lfs_size */		0,
+	/* lfs_ssize */		DFL_LFSSEG/DFL_LFSBLOCK,
+	/* lfs_dsize */		0,
+	/* lfs_bsize */		DFL_LFSBLOCK,
+	/* lfs_fsize */		DFL_LFSBLOCK,
+	/* lfs_frag */		1,
+	/* lfs_free */		LFS_FIRST_INUM,
+	/* lfs_bfree */		0,
+	/* lfs_nfiles */	0,
+	/* lfs_avail */		0,
+	/* lfs_uinodes */	0,
+	/* lfs_idaddr */	0,
+	/* lfs_ifile */		LFS_IFILE_INUM,
+	/* lfs_lastseg */	0,
+	/* lfs_nextseg */	0,
+	/* lfs_curseg */	0,
+	/* lfs_offset */	0,
+	/* lfs_lastpseg */	0,
+	/* lfs_tstamp */	0,
+	/* lfs_minfree */	MINFREE,
+	/* lfs_maxfilesize */	0,
+	/* lfs_dbpseg */	DFL_LFSSEG/DEV_BSIZE,
+	/* lfs_inopb */		DFL_LFSBLOCK/sizeof(struct dinode),
+	/* lfs_ifpb */		DFL_LFSBLOCK/sizeof(IFILE),
+	/* lfs_sepb */		DFL_LFSBLOCK/sizeof(SEGUSE),
+	/* lfs_nindir */	DFL_LFSBLOCK/sizeof(daddr_t),
+	/* lfs_nseg */		0,
+	/* lfs_nspf */		0,
+	/* lfs_cleansz */	0,
+	/* lfs_segtabsz */	0,
+	/* lfs_segmask */	DFL_LFSSEG_MASK,
+	/* lfs_segshift */	DFL_LFSSEG_SHIFT,
+	/* lfs_bmask */		DFL_LFSBLOCK_MASK,
+	/* lfs_bshift */	DFL_LFSBLOCK_SHIFT,
+	/* lfs_ffmask */	0,
+	/* lfs_ffshift */	0,
+	/* lfs_fbmask */	0,
+	/* lfs_fbshift */	0,
+	/* lfs_fsbtodb */	0,
+	/* lfs_sushift */	0,
+	/* lfs_sboffs */	{ 0 },
+	/* lfs_sp */		NULL,
+	/* lfs_ivnode */	NULL,
+	/* lfs_seglock */	0,
+	/* lfs_lockpid */	0,
+	/* lfs_iocount */	0,
+	/* lfs_writer */	0,
+	/* lfs_dirops */	0,
+	/* lfs_doifile */	0,
+	/* lfs_nactive */	0,
+	/* lfs_fmod */		0,
+	/* lfs_clean */		0,
+	/* lfs_ronly */		0,
+	/* lfs_flags */		0,
+	/* lfs_fsmnt */		{ 0 },
+	/* lfs_pad */		{ 0 },
+	/* lfs_cksum */		0
+};
+
+
+struct direct lfs_root_dir[] = {
+	{ ROOTINO, sizeof(struct direct), DT_DIR, 1, "."},
+	{ ROOTINO, sizeof(struct direct), DT_DIR, 2, ".."},
+	{ LFS_IFILE_INUM, sizeof(struct direct), DT_REG, 5, "ifile"},
+	{ LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 10, "lost+found"},
+};
+
+struct direct lfs_lf_dir[] = {
+        { LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 1, "." },
+        { ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
+};
+
+static daddr_t make_dinode 
+	__P((ino_t, struct dinode *, int, daddr_t, struct lfs *));
+static void make_dir __P(( void *, struct direct *, int));
+static void put __P((int, off_t, void *, size_t));
+
+int
+make_lfs(fd, lp, partp, minfree, block_size, seg_size)
+	int fd;
+	struct disklabel *lp;
+	struct partition *partp;
+	int minfree;
+	int block_size;
+	int seg_size;
+{
+	struct dinode *dip;	/* Pointer to a disk inode */
+	struct dinode *dpagep;	/* Pointer to page of disk inodes */
+	CLEANERINFO *cleaninfo;	/* Segment cleaner information table */
+	FINFO file_info;	/* File info structure in summary blocks */
+	IFILE *ifile;		/* Pointer to array of ifile structures */
+	IFILE *ip;		/* Pointer to array of ifile structures */
+	struct lfs *lfsp;	/* Superblock */
+	SEGUSE *segp;		/* Segment usage table */
+	SEGUSE *segtable;	/* Segment usage table */
+	SEGSUM summary;		/* Segment summary structure */
+	SEGSUM *sp;		/* Segment summary pointer */
+	daddr_t	last_sb_addr;	/* Address of superblocks */
+	daddr_t last_addr;	/* Previous segment address */
+	daddr_t	sb_addr;	/* Address of superblocks */
+	daddr_t	seg_addr;	/* Address of current segment */
+	void *ipagep;		/* Pointer to the page we use to write stuff */
+	void *sump;		/* Used to copy stuff into segment buffer */
+	u_long *block_array;	/* Array of logical block nos to put in sum */
+	u_long blocks_used;	/* Number of blocks in first segment */
+	u_long *dp;		/* Used to computed checksum on data */
+	u_long *datasump;	/* Used to computed checksum on data */
+	int block_array_size;	/* How many entries in block array */
+	int bsize;		/* Block size */
+	int db_per_fb;		/* Disk blocks per file block */
+	int i, j;
+	int off;		/* Offset at which to write */
+	int sb_interval;	/* number of segs between super blocks */
+	int seg_seek;		/* Seek offset for a segment */
+	int ssize;		/* Segment size */
+	int sum_size;		/* Size of the summary block */
+
+	lfsp = &lfs_default;
+
+	if (!(bsize = block_size))
+		bsize = DFL_LFSBLOCK;
+	if (!(ssize = seg_size))
+		ssize = DFL_LFSSEG;
+
+	/* Modify parts of superblock overridden by command line arguments */
+	if (bsize != DFL_LFSBLOCK) {
+		lfsp->lfs_bshift = log2(bsize);
+		if (1 << lfsp->lfs_bshift != bsize)
+			fatal("%d: block size not a power of 2", bsize);
+		lfsp->lfs_bsize = bsize;
+		lfsp->lfs_fsize = bsize;
+		lfsp->lfs_bmask = bsize - 1;
+		lfsp->lfs_inopb = bsize / sizeof(struct dinode);
+/* MIS -- should I round to power of 2 */
+		lfsp->lfs_ifpb = bsize / sizeof(IFILE);
+		lfsp->lfs_sepb = bsize / sizeof(SEGUSE);
+		lfsp->lfs_nindir = bsize / sizeof(daddr_t);
+	}
+
+	if (ssize != DFL_LFSSEG) {
+		lfsp->lfs_segshift = log2(ssize);
+		if (1 << lfsp->lfs_segshift != ssize)
+			fatal("%d: segment size not power of 2", ssize);
+		lfsp->lfs_ssize = ssize;
+		lfsp->lfs_segmask = ssize - 1;
+		lfsp->lfs_dbpseg = ssize / DEV_BSIZE;
+	}
+	lfsp->lfs_ssize = ssize >> lfsp->lfs_bshift;
+
+	if (minfree)
+		lfsp->lfs_minfree = minfree;
+
+	/*
+	 * Fill in parts of superblock that can be computed from file system
+	 * size, disk geometry and current time.
+	 */
+	db_per_fb = bsize/lp->d_secsize;
+	lfsp->lfs_fsbtodb = log2(db_per_fb);
+	lfsp->lfs_sushift = log2(lfsp->lfs_sepb);
+	lfsp->lfs_size = partp->p_size >> lfsp->lfs_fsbtodb;
+	lfsp->lfs_dsize = lfsp->lfs_size - (LFS_LABELPAD >> lfsp->lfs_bshift);
+	lfsp->lfs_nseg = lfsp->lfs_dsize / lfsp->lfs_ssize;
+	lfsp->lfs_maxfilesize = maxtable[lfsp->lfs_bshift] << lfsp->lfs_bshift;
+
+	/* 
+	 * The number of free blocks is set from the number of segments times
+	 * the segment size - 2 (that we never write because we need to make
+	 * sure the cleaner can run).  Then we'll subtract off the room for the
+	 * superblocks ifile entries and segment usage table.
+	 */
+	lfsp->lfs_dsize = fsbtodb(lfsp, (lfsp->lfs_nseg - 2) * lfsp->lfs_ssize);
+	lfsp->lfs_bfree = lfsp->lfs_dsize;
+	lfsp->lfs_segtabsz = SEGTABSIZE_SU(lfsp);
+	lfsp->lfs_cleansz = CLEANSIZE_SU(lfsp);
+	if ((lfsp->lfs_tstamp = time(NULL)) == -1)
+		fatal("time: %s", strerror(errno));
+	if ((sb_interval = lfsp->lfs_nseg / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)
+		sb_interval = LFS_MIN_SBINTERVAL;
+
+	/*
+	 * Now, lay out the file system.  We need to figure out where
+	 * the superblocks go, initialize the checkpoint information
+	 * for the first two superblocks, initialize the segment usage
+	 * information, put the segusage information in the ifile, create
+	 * the first block of IFILE structures, and link all the IFILE
+	 * structures into a free list.
+	 */
+
+	/* Figure out where the superblocks are going to live */
+	lfsp->lfs_sboffs[0] = LFS_LABELPAD/lp->d_secsize;
+	for (i = 1; i < LFS_MAXNUMSB; i++) {
+		sb_addr = ((i * sb_interval) << 
+		    (lfsp->lfs_segshift - lfsp->lfs_bshift + lfsp->lfs_fsbtodb))
+		    + lfsp->lfs_sboffs[0];
+		if (sb_addr > partp->p_size)
+			break;
+		lfsp->lfs_sboffs[i] = sb_addr;
+	}
+	last_sb_addr = lfsp->lfs_sboffs[i - 1];
+	lfsp->lfs_lastseg = lfsp->lfs_sboffs[0];
+	lfsp->lfs_nextseg = 
+	    lfsp->lfs_sboffs[1] ? lfsp->lfs_sboffs[1] : lfsp->lfs_sboffs[0];
+	lfsp->lfs_curseg = lfsp->lfs_lastseg;
+
+	/*
+	 * Initialize the segment usage table.  The first segment will
+	 * contain the superblock, the cleanerinfo (cleansz), the segusage 
+	 * table * (segtabsz), 1 block's worth of IFILE entries, the root 
+	 * directory, the lost+found directory and one block's worth of 
+	 * inodes (containing the ifile, root, and l+f inodes).
+	 */
+	if (!(cleaninfo = malloc(lfsp->lfs_cleansz << lfsp->lfs_bshift)))
+		fatal("%s", strerror(errno));
+	cleaninfo->clean = lfsp->lfs_nseg - 1;
+	cleaninfo->dirty = 1;
+
+	if (!(segtable = malloc(lfsp->lfs_segtabsz << lfsp->lfs_bshift)))
+		fatal("%s", strerror(errno));
+	segp = segtable;
+	blocks_used = lfsp->lfs_segtabsz + lfsp->lfs_cleansz + 4;
+	segp->su_nbytes = ((blocks_used - 1) << lfsp->lfs_bshift) +
+	    3 * sizeof(struct dinode) + LFS_SUMMARY_SIZE;
+	segp->su_lastmod = lfsp->lfs_tstamp;
+	segp->su_nsums = 1;	/* 1 summary blocks */
+	segp->su_ninos = 1;	/* 1 inode block */
+	segp->su_flags = SEGUSE_SUPERBLOCK | SEGUSE_DIRTY;
+	lfsp->lfs_bfree -= LFS_SUMMARY_SIZE / lp->d_secsize;
+	lfsp->lfs_bfree -=
+	     fsbtodb(lfsp, lfsp->lfs_cleansz + lfsp->lfs_segtabsz + 4);
+
+	/* 
+	 * Now figure out the address of the ifile inode. The inode block
+	 * appears immediately after the segment summary.
+	 */
+	lfsp->lfs_idaddr = (LFS_LABELPAD + LFS_SBPAD + LFS_SUMMARY_SIZE) /
+	    lp->d_secsize;
+
+	for (segp = segtable + 1, i = 1; i < lfsp->lfs_nseg; i++, segp++) {
+		if ((i % sb_interval) == 0) {
+			segp->su_flags = SEGUSE_SUPERBLOCK;
+			lfsp->lfs_bfree -= (LFS_SBPAD / lp->d_secsize);
+		} else
+			segp->su_flags = 0;
+		segp->su_lastmod = 0;
+		segp->su_nbytes = 0;
+		segp->su_ninos = 0;
+		segp->su_nsums = 0;
+	}
+
+	/* 
+	 * Initialize dynamic accounting.  The blocks available for
+	 * writing are the bfree blocks minus 1 segment summary for
+	 * each segment since you can't write any new data without
+	 * creating a segment summary - 2 segments that the cleaner
+	 * needs.
+	 */
+	lfsp->lfs_avail = lfsp->lfs_bfree - lfsp->lfs_nseg - 
+		fsbtodb(lfsp, 2 * lfsp->lfs_ssize);
+	lfsp->lfs_uinodes = 0;
+	/*
+	 * Ready to start writing segments.  The first segment is different
+	 * because it contains the segment usage table and the ifile inode
+	 * as well as a superblock.  For the rest of the segments, set the 
+	 * time stamp to be 0 so that the first segment is the most recent.
+	 * For each segment that is supposed to contain a copy of the super
+	 * block, initialize its first few blocks and its segment summary 
+	 * to indicate this.
+	 */
+	lfsp->lfs_nfiles = LFS_FIRST_INUM - 1;
+	lfsp->lfs_cksum = 
+	    cksum(lfsp, sizeof(struct lfs) - sizeof(lfsp->lfs_cksum));
+
+	/* Now create a block of disk inodes */
+	if (!(dpagep = malloc(lfsp->lfs_bsize)))
+		fatal("%s", strerror(errno));
+	dip = (struct dinode *)dpagep;
+	bzero(dip, lfsp->lfs_bsize);
+
+	/* Create a block of IFILE structures. */
+	if (!(ipagep = malloc(lfsp->lfs_bsize)))
+		fatal("%s", strerror(errno));
+	ifile = (IFILE *)ipagep;
+
+	/* 
+	 * Initialize IFILE.  It is the next block following the
+	 * block of inodes (whose address has been calculated in
+	 * lfsp->lfs_idaddr;
+	 */
+	sb_addr = lfsp->lfs_idaddr + lfsp->lfs_bsize / lp->d_secsize;
+	sb_addr = make_dinode(LFS_IFILE_INUM, dip, 
+	    lfsp->lfs_cleansz + lfsp->lfs_segtabsz+1, sb_addr, lfsp);
+	dip->di_mode = IFREG|IREAD|IWRITE;
+	ip = &ifile[LFS_IFILE_INUM];
+	ip->if_version = 1;
+	ip->if_daddr = lfsp->lfs_idaddr;
+
+	/* Initialize the ROOT Directory */
+	sb_addr = make_dinode(ROOTINO, ++dip, 1, sb_addr, lfsp);
+	dip->di_mode = IFDIR|IREAD|IWRITE|IEXEC;
+	dip->di_size = DIRBLKSIZ;
+	dip->di_nlink = 3;
+	ip = &ifile[ROOTINO];
+	ip->if_version = 1;
+	ip->if_daddr = lfsp->lfs_idaddr;
+
+	/* Initialize the lost+found Directory */
+	sb_addr = make_dinode(LOSTFOUNDINO, ++dip, 1, sb_addr, lfsp);
+	dip->di_mode = IFDIR|IREAD|IWRITE|IEXEC;
+	dip->di_size = DIRBLKSIZ;
+	dip->di_nlink = 2;
+	ip = &ifile[LOSTFOUNDINO];
+	ip->if_version = 1;
+	ip->if_daddr = lfsp->lfs_idaddr;
+
+	/* Make all the other dinodes invalid */
+	for (i = INOPB(lfsp)-3, dip++; i; i--, dip++)
+		dip->di_inumber = LFS_UNUSED_INUM;
+	
+
+	/* Link remaining IFILE entries in free list */
+	for (ip = &ifile[LFS_FIRST_INUM], i = LFS_FIRST_INUM; 
+	    i < lfsp->lfs_ifpb; ++ip) {
+		ip->if_version = 1;
+		ip->if_daddr = LFS_UNUSED_DADDR;
+		ip->if_nextfree = ++i;
+	}
+	ifile[lfsp->lfs_ifpb - 1].if_nextfree = LFS_UNUSED_INUM;
+
+	/* Now, write the segment */
+
+	/* Compute a checksum across all the data you're writing */
+	dp = datasump = malloc (blocks_used * sizeof(u_long));
+	*dp++ = ((u_long *)dpagep)[0];		/* inode block */
+	for (i = 0; i < lfsp->lfs_cleansz; i++)
+		*dp++ = ((u_long *)cleaninfo)[(i << lfsp->lfs_bshift) / 
+		    sizeof(u_long)];		/* Cleaner info */
+	for (i = 0; i < lfsp->lfs_segtabsz; i++)
+		*dp++ = ((u_long *)segtable)[(i << lfsp->lfs_bshift) / 
+		    sizeof(u_long)];		/* Segusage table */
+	*dp++ = ((u_long *)ifile)[0];		/* Ifile */
+
+	/* Still need the root and l+f bytes; get them later */
+
+	/* Write out the inode block */
+	off = LFS_LABELPAD + LFS_SBPAD + LFS_SUMMARY_SIZE;
+	put(fd, off, dpagep, lfsp->lfs_bsize);
+	free(dpagep);
+	off += lfsp->lfs_bsize;
+
+	/* Write out the ifile */
+
+	put(fd, off, cleaninfo, lfsp->lfs_cleansz << lfsp->lfs_bshift);
+	off += (lfsp->lfs_cleansz << lfsp->lfs_bshift);
+	(void)free(cleaninfo);
+
+	put(fd, off, segtable, lfsp->lfs_segtabsz << lfsp->lfs_bshift);
+	off += (lfsp->lfs_segtabsz << lfsp->lfs_bshift);
+	(void)free(segtable);
+
+	put(fd, off, ifile, lfsp->lfs_bsize);
+	off += lfsp->lfs_bsize;
+
+	/*
+	 * use ipagep for space for writing out other stuff.  It used to 
+	 * contain the ifile, but we're done with it.
+	 */
+
+	/* Write out the root and lost and found directories */
+	bzero(ipagep, lfsp->lfs_bsize);
+	make_dir(ipagep, lfs_root_dir, 
+	    sizeof(lfs_root_dir) / sizeof(struct direct));
+	*dp++ = ((u_long *)ipagep)[0];
+	put(fd, off, ipagep, lfsp->lfs_bsize);
+	off += lfsp->lfs_bsize;
+
+	bzero(ipagep, lfsp->lfs_bsize);
+	make_dir(ipagep, lfs_lf_dir, 
+		sizeof(lfs_lf_dir) / sizeof(struct direct));
+	*dp++ = ((u_long *)ipagep)[0];
+	put(fd, off, ipagep, lfsp->lfs_bsize);
+
+	/* Write Supberblock */
+	lfsp->lfs_offset = (off + lfsp->lfs_bsize) / lp->d_secsize;
+	put(fd, LFS_LABELPAD, lfsp, sizeof(struct lfs));
+
+	/* 
+	 * Finally, calculate all the fields for the summary structure
+	 * and write it.
+	 */
+
+	summary.ss_next = lfsp->lfs_nextseg;
+	summary.ss_create = lfsp->lfs_tstamp;
+	summary.ss_nfinfo = 3;
+	summary.ss_ninos = 3;
+	summary.ss_datasum = cksum(datasump, sizeof(u_long) * blocks_used);
+
+	/*
+	 * Make sure that we don't overflow a summary block. We have to
+	 * record: FINFO structures for ifile, root, and l+f.  The number
+	 * of blocks recorded for the ifile is determined by the size of
+	 * the cleaner info and the segments usage table.  There is room
+	 * for one block included in sizeof(FINFO) so we don't need to add
+	 * any extra space for the ROOT and L+F, and one block of the ifile
+	 * is already counted.  Finally, we leave room for 1 inode block
+	 * address.
+	 */
+	sum_size = 3*sizeof(FINFO) + sizeof(SEGSUM) + sizeof(daddr_t) +
+	    (lfsp->lfs_cleansz + lfsp->lfs_segtabsz) * sizeof(u_long);
+#define	SUMERR \
+"Multiple summary blocks in segment 1 not yet implemented\nsummary is %d bytes."
+	if (sum_size > LFS_SUMMARY_SIZE)
+		fatal(SUMERR, sum_size);
+
+		block_array_size = lfsp->lfs_cleansz + lfsp->lfs_segtabsz + 1;
+
+	if (!(block_array = malloc(block_array_size *sizeof(int))))
+		fatal("%s: %s", special, strerror(errno));
+
+	/* fill in the array */
+	for (i = 0; i < block_array_size; i++)
+		block_array[i] = i;
+
+	/* copy into segment */
+	sump = ipagep;
+	bcopy(&summary, sump, sizeof(SEGSUM));
+	sump += sizeof(SEGSUM);
+
+	/* Now, add the ifile */
+	file_info.fi_nblocks = block_array_size;
+	file_info.fi_version = 1;
+	file_info.fi_ino = LFS_IFILE_INUM;
+
+	bcopy(&file_info, sump, sizeof(FINFO) - sizeof(u_long));
+	sump += sizeof(FINFO) - sizeof(u_long);
+	bcopy(block_array, sump, sizeof(u_long) * file_info.fi_nblocks);
+	sump += sizeof(u_long) * file_info.fi_nblocks;
+
+	/* Now, add the root directory */
+	file_info.fi_nblocks = 1;
+	file_info.fi_version = 1;
+	file_info.fi_ino = ROOTINO;
+	file_info.fi_blocks[0] = 0;
+	bcopy(&file_info, sump, sizeof(FINFO));
+	sump += sizeof(FINFO);
+
+	/* Now, add the lost and found */
+	file_info.fi_ino = LOSTFOUNDINO;
+	bcopy(&file_info, sump, sizeof(FINFO));
+
+	((daddr_t *)ipagep)[LFS_SUMMARY_SIZE / sizeof(daddr_t) - 1] = 
+	    lfsp->lfs_idaddr;
+	((SEGSUM *)ipagep)->ss_sumsum = cksum(ipagep+sizeof(summary.ss_sumsum), 
+	    LFS_SUMMARY_SIZE - sizeof(summary.ss_sumsum));
+	put(fd, LFS_LABELPAD + LFS_SBPAD, ipagep, LFS_SUMMARY_SIZE);
+
+	sp = (SEGSUM *)ipagep;
+	sp->ss_create = 0;
+	sp->ss_nfinfo = 0;
+	sp->ss_ninos = 0;
+	sp->ss_datasum = 0;
+
+	/* Now write the summary block for the next partial so it's invalid */
+	lfsp->lfs_tstamp = 0;
+	off += lfsp->lfs_bsize;
+	sp->ss_sumsum =
+	    cksum(&sp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum));
+	put(fd, off, sp, LFS_SUMMARY_SIZE);
+
+	/* Now, write rest of segments containing superblocks */
+	lfsp->lfs_cksum = 
+	    cksum(lfsp, sizeof(struct lfs) - sizeof(lfsp->lfs_cksum));
+	for (seg_addr = last_addr = lfsp->lfs_sboffs[0], j = 1, i = 1; 
+	    i < lfsp->lfs_nseg; i++) {
+
+		seg_addr += lfsp->lfs_ssize << lfsp->lfs_fsbtodb;
+		sp->ss_next = last_addr;
+		last_addr = seg_addr;
+		seg_seek = seg_addr * lp->d_secsize;
+
+		if (seg_addr == lfsp->lfs_sboffs[j]) {
+			if (j < (LFS_MAXNUMSB - 2))
+				j++;
+			put(fd, seg_seek, lfsp, sizeof(struct lfs));
+			seg_seek += LFS_SBPAD;
+		} 
+
+		/* Summary */
+		sp->ss_sumsum = cksum(&sp->ss_datasum, 
+		    LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum));
+		put(fd, seg_seek, sp, LFS_SUMMARY_SIZE);
+	}
+	free(ipagep);
+	close(fd);
+	return (0);
+}
+
+static void
+put(fd, off, p, len)
+	int fd;
+	off_t off;
+	void *p;
+	size_t len;
+{
+	int wbytes;
+
+	if (lseek(fd, off, SEEK_SET) < 0)
+		fatal("%s: %s", special, strerror(errno));
+	if ((wbytes = write(fd, p, len)) < 0)
+		fatal("%s: %s", special, strerror(errno));
+	if (wbytes != len)
+		fatal("%s: short write (%d, not %d)", special, wbytes, len);
+}
+
+/*
+ * Create the root directory for this file system and the lost+found
+ * directory.
+ */
+
+	u_long	d_ino;			/* inode number of entry */
+	u_short	d_reclen;		/* length of this record */
+	u_short	d_namlen;		/* length of string in d_name */
+	char	d_name[MAXNAMLEN + 1];	/* name with length <= MAXNAMLEN */
+void
+lfsinit()
+{}
+
+static daddr_t
+make_dinode(ino, dip, nblocks, saddr, lfsp)
+	ino_t ino;				/* inode we're creating */
+	struct dinode *dip;			/* disk inode */
+	int nblocks;				/* number of blocks in file */
+	daddr_t saddr;				/* starting block address */
+	struct lfs *lfsp;			/* superblock */
+{
+	int db_per_fb, i;
+
+	dip->di_nlink = 1;
+	dip->di_blocks = nblocks << lfsp->lfs_fsbtodb;
+
+	dip->di_size = (nblocks << lfsp->lfs_bshift);
+	dip->di_atime.ts_sec = dip->di_mtime.ts_sec =
+	    dip->di_ctime.ts_sec = lfsp->lfs_tstamp;
+	dip->di_atime.ts_nsec = dip->di_mtime.ts_nsec =
+	    dip->di_ctime.ts_nsec = 0;
+	dip->di_inumber = ino;
+
+#define	SEGERR \
+"File requires more than the number of direct blocks; increase block or segment size."
+	if (NDADDR < nblocks)
+		fatal("%s", SEGERR);
+
+	/* Assign the block addresses for the ifile */
+	db_per_fb = 1 << lfsp->lfs_fsbtodb;
+	for (i = 0; i < nblocks; i++, saddr += db_per_fb)
+		dip->di_db[i] = saddr;
+
+	return (saddr);
+}
+
+
+/*
+ * Construct a set of directory entries in "bufp".  We assume that all the
+ * entries in protodir fir in the first DIRBLKSIZ.  
+ */
+static void
+make_dir(bufp, protodir, entries)
+	void *bufp;
+	register struct direct *protodir;
+	int entries;
+{
+	char *cp;
+	int i, spcleft;
+
+	spcleft = DIRBLKSIZ;
+	for (cp = bufp, i = 0; i < entries - 1; i++) {
+		protodir[i].d_reclen = DIRSIZ(NEWDIRFMT, &protodir[i]);
+		bcopy(&protodir[i], cp, protodir[i].d_reclen);
+		cp += protodir[i].d_reclen;
+		if ((spcleft -= protodir[i].d_reclen) < 0)
+			fatal("%s: %s", special, "directory too big");
+	}
+	protodir[i].d_reclen = spcleft;
+	bcopy(&protodir[i], cp, DIRSIZ(NEWDIRFMT, &protodir[i]));
+}
diff --git a/sbin/newlfs/misc.c b/sbin/newlfs/misc.c
new file mode 100644
index 000000000000..074fb71e9246
--- /dev/null
+++ b/sbin/newlfs/misc.c
@@ -0,0 +1,83 @@
+/*-
+ * Copyright (c) 1991, 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[] = "@(#)misc.c	8.1 (Berkeley) 6/5/93";
+#endif /* not lint */
+
+#include <sys/types.h>
+#include <sys/types.h>
+#include <sys/disklabel.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "extern.h"
+
+u_int
+log2(num)
+        u_int num;
+{
+        register u_int i, limit;
+
+        limit = 1;
+        for (i = 0; limit < num; limit = limit << 1, i++);
+        return (i);
+}
+
+#if __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+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
+	(void)fprintf(stderr, "%s: ", progname);
+	(void)vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	(void)fprintf(stderr, "\n");
+	exit(1);
+	/* NOTREACHED */
+}
diff --git a/sbin/newlfs/newfs.c b/sbin/newlfs/newfs.c
new file mode 100644
index 000000000000..25ac7f05f176
--- /dev/null
+++ b/sbin/newlfs/newfs.c
@@ -0,0 +1,466 @@
+/*-
+ * Copyright (c) 1989, 1992, 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 copyright[] =
+"@(#) Copyright (c) 1989, 1992, 1993\n\
+	The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)newfs.c	8.3 (Berkeley) 4/22/94";
+#endif /* not lint */
+
+/*
+ * newfs: friendly front end to mkfs
+ */
+#include <sys/param.h>
+#include <sys/ucred.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/ufs/dinode.h>
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <paths.h>
+#include "config.h"
+#include "extern.h"
+
+#define	COMPAT			/* allow non-labeled disks */
+
+int	mfs;			/* run as the memory based filesystem */
+int	Nflag;			/* run without writing 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 = MAXCONTIG;	/* 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;		/* 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, *special;
+
+static struct disklabel *getdisklabel __P((char *, int));
+static struct disklabel *debug_readlabel __P((int));
+static void rewritelabel __P((char *, int, struct disklabel *));
+static void usage __P((void));
+
+int
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	register int ch;
+	register struct partition *pp;
+	register struct disklabel *lp;
+	struct partition oldpartition;
+	struct stat st;
+	int debug, lfs, fsi, fso, segsize;
+	char *cp, *opstring;
+
+	if (progname = rindex(*argv, '/'))
+		++progname;
+	else
+		progname = *argv;
+
+	if (strstr(progname, "mfs")) {
+		mfs = 1;
+		Nflag++;
+	}
+
+	/* -F is mfs only and MUST come first! */
+	opstring = "F:B:DLNS:T:a:b:c:d:e:f:i:k:l:m:n:o:p:r:s:t:u:x:";
+	if (!mfs)
+		opstring += 2;
+
+	debug = lfs = segsize = 0;
+	while ((ch = getopt(argc, argv, opstring)) != EOF)
+		switch(ch) {
+		case 'B':	/* LFS segment size */
+			if ((segsize = atoi(optarg)) < LFS_MINSEGSIZE)
+				fatal("%s: bad segment size", optarg);
+			break;
+		case 'D':
+			debug = 1;
+			break;
+		case 'F':
+			if ((mntflags = atoi(optarg)) == 0)
+				fatal("%s: bad mount flags", optarg);
+			break;
+		case 'L':	/* Create lfs */
+			lfs = 1;
+			break;
+		case 'N':
+			Nflag++;
+			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 max contiguous blocks\n",
+				    optarg);
+			break;
+		case 'b':	/* used for LFS */
+			if ((bsize = atoi(optarg)) < LFS_MINBLOCKSIZE)
+				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 cyl group\n",
+				    optarg);
+			break;
+		case 'f':
+			if ((fsize = atoi(optarg)) <= 0)
+				fatal("%s: bad frag 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':		/* used for LFS */
+			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 (strcmp(optarg, "space") == 0)
+				opt = FS_OPTSPACE;
+			else if (strcmp(optarg, "time") == 0)
+				opt = FS_OPTTIME;
+			else
+				fatal("%s: bad optimization preference %s",
+				    optarg, "(options are `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 revs/minute\n", optarg);
+			break;
+		case 's':	/* used for LFS */
+			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();
+
+	/*
+	 * If the -N flag isn't specified, open the output file.  If no path
+	 * prefix, try /dev/r%s and then /dev/%s.
+	 */
+	special = argv[0];
+	if (index(special, '/') == NULL) {
+		(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 = open(special,
+		    (debug ? O_CREAT : 0) | O_WRONLY, DEFFILEMODE);
+		if (fso < 0)
+			fatal("%s: %s", special, strerror(errno));
+	} else
+		fso = -1;
+
+	/* Open the input file. */
+	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 (!debug && !mfs && !S_ISCHR(st.st_mode))
+		(void)printf("%s: %s: not a character-special device\n",
+		    progname, special);
+	cp = index(argv[0], '\0') - 1;
+	if (!debug && (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
+	if (debug)
+		lp = debug_readlabel(fsi);
+	else
+		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 we're making a LFS, we break out here */
+	exit(make_lfs(fso, lp, pp, minfree, bsize, segsize));
+}
+
+#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
+
+static 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
+		(void)fprintf(stderr,
+		    "%s: ioctl (GDINFO): %s\n", progname, strerror(errno));
+		fatal(lmsg, s);
+	}
+	return (&lab);
+}
+
+
+static struct disklabel *
+debug_readlabel(fd)
+	int fd;
+{
+	static struct disklabel lab;
+	int n;
+
+	if ((n = read(fd, &lab, sizeof(struct disklabel))) < 0)
+		fatal("unable to read disk label: %s", strerror(errno));
+	else if (n < sizeof(struct disklabel))
+		fatal("short read of disklabel: %d of %d bytes", n,
+			sizeof(struct disklabel));
+	return(&lab);
+}
+
+static void
+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) {
+		(void)fprintf(stderr,
+		    "%s: ioctl (WDINFO): %s\n", progname, strerror(errno));
+		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)
+				fprintf(stderr,
+				    "%s: alternate label %d write: %s\n",
+				    progname, i/2, strerror(errno));
+		}
+		close(cfd);
+	}
+#endif
+}
+
+void
+usage()
+{
+	if (mfs) {
+		fprintf(stderr,
+		    "usage: mfs [ -fsoptions ] special-device mount-point\n");
+	} else
+		fprintf(stderr,
+		    "usage: newlfs [ -fsoptions ] special-device%s\n",
+#ifdef COMPAT
+		    " [device-type]");
+#else
+		    "");
+#endif
+	fprintf(stderr, "where fsoptions are:\n");
+	fprintf(stderr, "\t-B LFS segment size\n");
+	fprintf(stderr, "\t-D debug\n");
+	fprintf(stderr, "\t-F mount flags\n");
+	fprintf(stderr, "\t-L create LFS file system\n");
+	fprintf(stderr,
+	    "\t-N do not create file system, just print out parameters\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-r revolutions/minute\n");
+	fprintf(stderr, "\t-s file system size (sectors)\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);
+}
diff --git a/sbin/newlfs/newlfs.8 b/sbin/newlfs/newlfs.8
new file mode 100644
index 000000000000..92474e54609b
--- /dev/null
+++ b/sbin/newlfs/newlfs.8
@@ -0,0 +1,95 @@
+.\" Copyright (c) 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.
+.\"
+.\"     @(#)newlfs.8	8.1 (Berkeley) 6/19/93
+.\"
+.Dd June 19, 1993
+.Dt NEWLFS 8
+.Os BSD 4.4
+.Sh NAME
+.Nm newlfs
+.Nd construct a new LFS file system
+.Sh SYNOPSIS
+.Nm newlfs
+.Fl L
+.Op Ar newlfs-options
+.Ar special
+.Sh DESCRIPTION
+.Nm Newlfs
+builds a log-structured file system on the specified special
+device basing its defaults on the information in the disk label.
+(Before running 
+.Nm newlfs
+the disk must be labeled using 
+.Xr disklabel 8 .)
+.Pp
+The following options define the general layout policies.
+.Bl -tag -width Fl
+.It Fl B
+The logical segment size of the file system in bytes.
+.It Fl b Ar block-size
+The block size of the file system in bytes.
+.It Fl L
+Create a log-structured file system (LFS).
+This flag is currently required.
+.It Fl m Ar free space \&%
+The percentage of space reserved from normal users; the minimum
+free space threshold.  The default value used is 10%.
+See
+.Xr tunefs 8
+for more details on how to set this option.
+.It Fl s Ar size
+The size of the file system in sectors.
+.El
+.Sh SEE ALSO
+.Xr disktab 5 ,
+.Xr fs 5 ,
+.Xr dumplfs 8 ,
+.Xr disklabel 8 ,
+.Xr diskpart 8 ,
+.Xr tunefs 8
+.Rs
+.%A M. McKusick
+.%A W. Joy
+.%A S. Leffler
+.%A R. Fabry
+.%T A Fast File System for UNIX ,
+.%J ACM Transactions on Computer Systems 2
+.%V 3
+.%P pp 181-197
+.%D August 1984
+.%O (reprinted in the BSD System Manager's Manual)
+.Re
+.Sh HISTORY
+The
+.Nm
+command appeared in
+.Bx 4.4 .