Swing the axe and remove some archaic features from newfs which modern

diskdrives do neither need nor want:

	-O create a 4.3BSD format filesystem
	-d rotational delay between contiguous blocks
	-k sector 0 skew, per track
	-l hardware sector interleave
	-n number of distinguished rotational positions
	-p spare sectors per track
	-r revolutions/minute
	-t tracks/cylinder
	-x spare sectors per cylinder

No change in the produced filesystem image unless one or more of
these options were used.

Approved by:	mckusick

4 files changed, 52 insertions, 339 deletions

diff --git a/sbin/newfs/mkfs.c b/sbin/newfs/mkfs.c
index e50aef8..eefec83 100644
--- a/sbin/newfs/mkfs.c
+++ b/sbin/newfs/mkfs.c
@@ -95,7 +95,7 @@ static struct dinode zino[MAXBSIZE / sizeof(struct dinode)];
 static int fsi, fso;
 static int randinit;
 static daddr_t alloc(int size, int mode);
-static long calcipg(long cpg, long bpcg, off_t *usedbp);
+static long calcipg(long lcpg, long bpcg, off_t *usedbp);
 static int charsperline(void);
 static void clrblock (struct fs *, unsigned char *, int);
 static void fsinit (time_t);
@@ -113,11 +113,10 @@ void
 mkfs(struct partition *pp, char *fsys, int fi, int fo)
 {
 	long i, mincpc, mincpg, inospercg;
-	long cylno, rpos, blk, j, warn = 0;
+	long cylno, j, lwarn = 0;
 	long used, mincpgcnt, bpcg;
 	off_t usedb;
 	long mapcramped, inodecramped;
-	long postblsize, rotblsize, totalsbsize;
 	time_t utime;
 	quad_t sizepb;
 	int width;
@@ -133,13 +132,8 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 	}
 	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;
-	}
+	sblock.fs_inodefmt = FS_44INODEFMT;
+	sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
 	if (Uflag)
 		sblock.fs_flags |= FS_DOSOFTDEP;
 	/*
@@ -153,10 +147,8 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 	/*
 	 * 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);
+	sblock.fs_nsect = secpercyl;
+	sblock.fs_ntrak = 1;
 	if (sblock.fs_nsect <= 0)
 		printf("preposterous nsect %d\n", sblock.fs_nsect), exit(15);
 	/*
@@ -216,7 +208,7 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 		    sblock.fs_bsize / MAXFRAG);
 		exit(21);
 	}
-	sblock.fs_nrpos = nrpos;
+	sblock.fs_nrpos = 1;
 	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;
@@ -228,10 +220,7 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 	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_cgmask = 0xffffffff;
 	sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
 	for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
 		sizepb *= NINDIR(&sblock);
@@ -404,7 +393,7 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 	sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;
 	if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
 		sblock.fs_ncyl++;
-		warn = 1;
+		lwarn = 1;
 	}
 	if (sblock.fs_ncyl < 1) {
 		printf("file systems must have at least one cylinder\n");
@@ -421,65 +410,14 @@ mkfs(struct partition *pp, char *fsys, int fi, int fo)
 	 * 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_interleave = 1;
+	sblock.fs_trackskew = 0;
+	sblock.fs_npsect = secpercyl;
 	sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
 	sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));
 	if (sblock.fs_sbsize > SBSIZE)
 		sblock.fs_sbsize = SBSIZE;
-	if (sblock.fs_ntrak == 1) {
-		sblock.fs_cpc = 0;
-		goto next;
-	}
-	postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof(int16_t);
-	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_firstfield);
-		sblock.fs_rotbloff = &sblock.fs_space[0] -
-		    (u_char *)(&sblock.fs_firstfield);
-	} else {
-		/* use dynamic table space */
-		sblock.fs_postbloff = &sblock.fs_space[0] -
-		    (u_char *)(&sblock.fs_firstfield);
-		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);
-	if (sblock.fs_sbsize > SBSIZE)
-		sblock.fs_sbsize = SBSIZE;
-	/*
-	 * 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:
+	sblock.fs_cpc = 0;
 	/*
 	 * Compute/validate number of cylinder groups.
 	 */
@@ -516,9 +454,9 @@ next:
 		sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
 		sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
 		    NSPF(&sblock);
-		warn = 0;
+		lwarn = 0;
 	}
-	if (warn) {
+	if (lwarn) {
 		printf("Warning: %d sector(s) in last cylinder unallocated\n",
 		    sblock.fs_spc -
 		    (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1) *
@@ -542,11 +480,11 @@ next:
 	if (fscs == NULL)
 		errx(31, "calloc failed");
 	sblock.fs_magic = FS_MAGIC;
-	sblock.fs_rotdelay = rotdelay;
+	sblock.fs_rotdelay = 0;
 	sblock.fs_minfree = minfree;
 	sblock.fs_maxcontig = maxcontig;
 	sblock.fs_maxbpg = maxbpg;
-	sblock.fs_rps = rpm / 60;
+	sblock.fs_rps = 60;
 	sblock.fs_optim = opt;
 	sblock.fs_cgrotor = 0;
 	sblock.fs_cstotal.cs_ndir = 0;
@@ -666,7 +604,7 @@ initcg(int cylno, time_t utime)
 	acg.cg_btotoff = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
 	acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);
 	acg.cg_iusedoff = acg.cg_boff +
-		sblock.fs_cpg * sblock.fs_nrpos * sizeof(u_int16_t);
+		sblock.fs_cpg * sizeof(u_int16_t);
 	acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
 	if (sblock.fs_contigsumsize <= 0) {
 		acg.cg_nextfreeoff = acg.cg_freeoff +
@@ -842,17 +780,10 @@ fsinit(time_t utime)
 	/*
 	 * create the lost+found directory
 	 */
-	if (Oflag) {
-		(void)makedir((struct direct *)olost_found_dir, 2);
-		for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
-			memmove(&buf[i], &olost_found_dir[2],
-			    DIRSIZ(0, &olost_found_dir[2]));
-	} else {
-		(void)makedir(lost_found_dir, 2);
-		for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
-			memmove(&buf[i], &lost_found_dir[2],
-			    DIRSIZ(0, &lost_found_dir[2]));
-	}
+	(void)makedir(lost_found_dir, 2);
+	for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
+		memmove(&buf[i], &lost_found_dir[2],
+		    DIRSIZ(0, &lost_found_dir[2]));
 	node.di_mode = IFDIR | UMASK;
 	node.di_nlink = 2;
 	node.di_size = sblock.fs_bsize;
@@ -866,10 +797,7 @@ fsinit(time_t utime)
 	 */
 	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_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);
@@ -955,7 +883,7 @@ goth:
  * Calculate number of inodes per group.
  */
 long
-calcipg(long cpg, long bpcg, off_t *usedbp)
+calcipg(long lcpg, long bpcg, off_t *usedbp)
 {
 	int i;
 	long ipg, new_ipg, ncg, ncyl;
@@ -966,7 +894,7 @@ calcipg(long cpg, long bpcg, off_t *usedbp)
 	 * Note that fssize is still in sectors, not filesystem blocks.
 	 */
 	ncyl = howmany(fssize, (u_int)secpercyl);
-	ncg = howmany(ncyl, cpg);
+	ncg = howmany(ncyl, lcpg);
 	/*
 	 * Iterate a few times to allow for ipg depending on itself.
 	 */
@@ -974,8 +902,8 @@ calcipg(long cpg, long bpcg, off_t *usedbp)
 	for (i = 0; i < 10; i++) {
 		usedb = (sblock.fs_iblkno + ipg / INOPF(&sblock)) *
 		    NSPF(&sblock) * (off_t)sectorsize;
-		new_ipg = (cpg * (quad_t)bpcg - usedb) / density *
-		    fssize / ncg / secpercyl / cpg;
+		new_ipg = (lcpg * (quad_t)bpcg - usedb) / density *
+		    fssize / ncg / secpercyl / lcpg;
 		new_ipg = roundup(new_ipg, INOPB(&sblock));
 		if (new_ipg == ipg)
 			break;
@@ -991,7 +919,7 @@ calcipg(long cpg, long bpcg, off_t *usedbp)
 void
 iput(struct dinode *ip, ino_t ino)
 {
-	struct dinode buf[MAXINOPB];
+	struct dinode lbuf[MAXINOPB];
 	daddr_t d;
 	int c;
 
@@ -1014,9 +942,9 @@ iput(struct dinode *ip, ino_t ino)
 		exit(32);
 	}
 	d = fsbtodb(&sblock, ino_to_fsba(&sblock, ino));
-	rdfs(d, sblock.fs_bsize, (char *)buf);
-	buf[ino_to_fsbo(&sblock, ino)] = *ip;
-	wtfs(d, sblock.fs_bsize, (char *)buf);
+	rdfs(d, sblock.fs_bsize, (char *)lbuf);
+	lbuf[ino_to_fsbo(&sblock, ino)] = *ip;
+	wtfs(d, sblock.fs_bsize, (char *)lbuf);
 }
 
 /*
@@ -1207,7 +1135,7 @@ charsperline(void)
 static int
 ilog2(int val)
 {
-	int n;
+	u_int n;
 
 	for (n = 0; n < sizeof(n) * NBBY; n++)
 		if (1 << n == val)
diff --git a/sbin/newfs/newfs.8 b/sbin/newfs/newfs.8
index aefc95d..dfcb9a1 100644
--- a/sbin/newfs/newfs.8
+++ b/sbin/newfs/newfs.8
@@ -46,24 +46,16 @@
 .Op Fl a Ar maxcontig
 .Op Fl b Ar block-size
 .Op Fl c Ar cylinders
-.Op Fl d Ar rotdelay
 .Op Fl e Ar maxbpg
 .Op Fl f Ar frag-size
 .Op Fl g Ar avgfilesize
 .Op Fl h Ar avfpdir
 .Op Fl i Ar bytes
-.Op Fl k Ar skew
-.Op Fl l Ar interleave
 .Op Fl m Ar free space
-.Op Fl n Ar rotational positions
 .Op Fl o Ar optimization
-.Op Fl p Ar sectors
-.Op Fl r Ar revolutions
 .Op Fl s Ar size
-.Op Fl t Ar tracks
 .Op Fl u Ar sectors
 .Op Fl v
-.Op Fl x Ar sectors
 .Ar special
 .Sh DESCRIPTION
 .Nm Newfs
@@ -91,19 +83,11 @@ For backward compatibility.
 .It Fl N
 Cause the file system parameters to be printed out
 without really creating the file system.
-.It Fl O
-Create a
-.Bx 4.3
-format filesystem.
-This options is primarily used to build root filesystems
-that can be understood by older boot ROMs.
 .It Fl U
 Enables soft updates on the new filesystem.
 .It Fl a Ar maxcontig
 Specify the maximum number of contiguous blocks that will be
-laid out before forcing a rotational delay (see the
-.Fl d
-option).
+laid out before forcing a rotational delay.
 The default value is 1.
 See
 .Xr tunefs 8
@@ -119,14 +103,6 @@ The number of cylinders per cylinder group in a file system.  The default
 is to compute the maximum allowed by the other parameters.  This value is
 dependent on a number of other parameters, in particular the block size
 and the number of bytes per inode.
-.It Fl d Ar rotdelay
-This parameter once specified the minimum time in milliseconds required to
-initiate another disk transfer on the same cylinder.  It was used in determining
-the rotationally optimal layout for disk blocks within a file.  Modern disks
-with read/write-behind achieve higher performance with this feature disabled, so
-this value should be left at the default value of 0 milliseconds.  See
-.Xr tunefs 8
-for more details on how to set this option.
 .It Fl e Ar maxbpg
 Indicate the maximum number of blocks any single file can
 allocate out of a cylinder group before it is forced to begin
@@ -167,15 +143,6 @@ currently 8%.
 See
 .Xr tunefs 8
 for more details on how to set this option.
-.It Fl n Ar number of distinguished rotational positions
-UFS has the ability to keep track of the availability of blocks at different
-rotational positions, so that it could lay out the data to be picked up with
-minimum rotational latency.  This parameter specifies the default number of
-rotational positions to distinguish.
-.Pp
-Nowadays this value should be set to 1 (which essentially disables the
-rotational position table) because modern drives with read-ahead and
-write-behind do better without the rotational position table.
 .It Fl o Ar optimization\ preference
 .Pq Ar space No or Ar time .
 The file system can either be instructed to try to minimize the time spent
@@ -218,57 +185,11 @@ to find the alternate superblocks if the standard superblock is lost.
 .Bl -tag -width indent
 .It Fl S Ar sector-size
 The size of a sector in bytes (almost never anything but 512).
-.It Fl k Ar sector \&0 skew , per track
-Used to describe perturbations in the media format to compensate for
-a slow controller.
-Track skew is the offset of sector 0 on track N relative to sector 0
-on track N-1 on the same cylinder.
-This option is of historical importance only; modern controllers are always fast
-enough to handle operations back-to-back.
-.It Fl l Ar hardware sector interleave
-Used to describe perturbations in the media format to compensate for
-a slow controller.
-Interleave is physical sector interleave on each track,
-specified as the denominator of the ratio:
-.Dl sectors read/sectors passed over
-Thus an interleave of 1/1 implies contiguous layout, while 1/2 implies
-logical sector 0 is separated by one sector from logical sector 1.
-This option is of historical importance only; the physical sector layout of
-modern disks is not visible from outside.
-.It Fl p Ar spare sectors per track
-Spare sectors (bad sector replacements) are physical sectors that occupy
-space at the end of each track.
-They are not counted as part of the sectors/track
-.Pq Fl u
-since they are not available to the file system for data allocation.
-This option is of historical importance only.  Modern disks perform their own
-bad sector allocation.
-.It Fl r Ar revolutions/minute
-The speed of the disk in revolutions per minute.  This value is no longer of
-interest, since all the parameters which depend on it are usually disabled.
-.It Fl t Ar #tracks/cylinder
-The number of tracks/cylinder available for data allocation by the file
-system.
-The default is 1.
-If zero is specified, the value from the disklabel will be used.
-.It Fl u Ar sectors/track
-The number of sectors per track available for data allocation by the file
+.It Fl u Ar sectors/cylinders
+The number of sectors per cylinder available for data allocation by the file
 system.
 The default is 4096.
 If zero is specified, the value from the disklabel will be used.
-This does not include sectors reserved at the end of each track for bad
-block replacement (see the
-.Fl p
-option).
-.It Fl x Ar spare sectors per cylinder
-Spare sectors (bad sector replacements) are physical sectors that occupy
-space at the end of the last track in the cylinder.
-They are deducted from the sectors/track
-.Pq Fl u
-of the last track of each cylinder since they are not available to the file
-system for data allocation.
-This option is of historical importance only.  Modern disks perform their own
-bad sector allocation.
 .El
 .Sh EXAMPLES
 .Dl newfs /dev/ad3s1a
diff --git a/sbin/newfs/newfs.c b/sbin/newfs/newfs.c
index 995b0ed..c749ad9 100644
--- a/sbin/newfs/newfs.c
+++ b/sbin/newfs/newfs.c
@@ -96,19 +96,6 @@ static struct disklabel *getdisklabel(char *s, int fd);
 #define	DESCPG		65536	/* desired fs_cpg ("infinity") */
 
 /*
- * Once upon a time...
- *    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.
- *
- * ...but now we make this 0 to disable the rotdelay delay because
- * modern drives with read/write-behind achieve higher performance
- * without the delay.
- */
-#define ROTDELAY	0
-
-/*
  * 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.
@@ -123,47 +110,21 @@ static struct disklabel *getdisklabel(char *s, int fd);
 #define	NFPI		4
 
 /*
- * Once upon a time...
- *    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.
- *
- * ...but now we make this 1 (which essentially disables the rotational
- * position table because modern drives with read-ahead and write-behind do
- * better without the rotational position table.
- */
-#define	NRPOS		1	/* number distinct rotational positions */
-
-/*
  * About the same time as the above, we knew what went where on the disks.
  * no longer so, so kill the code which finds the different platters too...
  * We do this by saying one head, with a lot of sectors on it.
  * The number of sectors are used to determine the size of a cyl-group.
  * Kirk suggested one or two meg per "cylinder" so we say two.
  */
-#define NTRACKS		1	/* number of heads */
 #define NSECTORS	4096	/* number of sectors */
 
 int	Nflag;			/* run without writing file system */
-int	Oflag;			/* format as an 4.3BSD file system */
 int	Rflag;			/* regression test */
 int	Uflag;			/* enable soft updates for file system */
-int	fssize;			/* file system size */
-int	ntracks = NTRACKS;	/* # tracks/cylinder */
-int	nsectors = 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 */
+u_int	fssize;			/* file system size */
+u_int	secpercyl = NSECTORS;	/* sectors per cylinder */
 int	sectorsize;		/* bytes/sector */
 int	realsectorsize;		/* bytes/sector in hardware */
-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 */
@@ -172,23 +133,20 @@ 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	avgfilesize = AVFILESIZ;/* expected average file size */
 int	avgfilesperdir = AFPDIR;/* expected number of files per directory */
 int	bbsize = BBSIZE;	/* boot block size */
 int	sbsize = SBSIZE;	/* superblock size */
-int	t_or_u_flag = 0;	/* user has specified -t or -u */
+static int	t_or_u_flag = 0;	/* user has specified -t or -u */
 #ifdef COMPAT
-char	*disktype;
-int	unlabeled;
+static char	*disktype;
+static int	unlabeled;
 #endif
 
-char	device[MAXPATHLEN];
-char	*progname;
+static char	device[MAXPATHLEN];
+static char	*progname;
 
-extern void mkfs (struct partition *, char *, int, int);
 static void rewritelabel (char *s, int fd, register struct disklabel *lp);
 static void usage (void);
 
@@ -210,14 +168,11 @@ main(int argc, char *argv[])
 		progname = *argv;
 
 	while ((ch = getopt(argc, argv,
-	    "NORS:T:Ua:b:c:d:e:f:g:h:i:k:l:m:n:o:p:r:s:t:u:vx:")) != -1)
+	    "NRS:T:Ua:b:c:e:f:g:h:i:m:o:s:u:v:")) != -1)
 		switch (ch) {
 		case 'N':
 			Nflag = 1;
 			break;
-		case 'O':
-			Oflag = 1;
-			break;
 		case 'R':
 			Rflag = 1;
 			break;
@@ -247,10 +202,6 @@ main(int argc, char *argv[])
 				fatal("%s: bad cylinders/group", optarg);
 			cpgflg++;
 			break;
-		case 'd':
-			if ((rotdelay = atoi(optarg)) < 0)
-				fatal("%s: bad rotational delay", optarg);
-			break;
 		case 'e':
 			if ((maxbpg = atoi(optarg)) <= 0)
 		fatal("%s: bad blocks per file in a cylinder group",
@@ -272,25 +223,10 @@ main(int argc, char *argv[])
 			if ((density = atoi(optarg)) <= 0)
 				fatal("%s: bad bytes per inode", 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 %%", optarg);
 			break;
-		case 'n':
-			if ((nrpos = atoi(optarg)) < 0)
-				fatal("%s: bad rotational layout count",
-				    optarg);
-			if (nrpos == 0)
-				nrpos = 1;
-			break;
 		case 'o':
 			if (strcmp(optarg, "space") == 0)
 				opt = FS_OPTSPACE;
@@ -301,37 +237,19 @@ main(int argc, char *argv[])
 		"%s: unknown optimization preference: use `space' or `time'",
 				    optarg);
 			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", optarg);
-			break;
 		case 's':
 			if ((fssize = atoi(optarg)) <= 0)
 				fatal("%s: bad file system size", optarg);
 			break;
-		case 't':
-			t_or_u_flag++;
-			if ((ntracks = atoi(optarg)) < 0)
-				fatal("%s: bad total tracks", optarg);
-			break;
 		case 'u':
 			t_or_u_flag++;
-			if ((nsectors = atoi(optarg)) < 0)
+			if ((n = atoi(optarg)) < 0)
 				fatal("%s: bad sectors/track", optarg);
+			secpercyl = n;
 			break;
 		case 'v':
 			vflag = 1;
 			break;
-		case 'x':
-			if ((cylspares = atoi(optarg)) < 0)
-				fatal("%s: bad spare sectors per cylinder",
-				    optarg);
-			break;
 		case '?':
 		default:
 			usage();
@@ -416,19 +334,9 @@ main(int argc, char *argv[])
 		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)
+	if (secpercyl == 0) {
+		secpercyl = lp->d_nsectors;
+		if (secpercyl <= 0)
 			fatal("%s: no default #sectors/track", argv[0]);
 	}
 	if (sectorsize == 0) {
@@ -436,16 +344,6 @@ main(int argc, char *argv[])
 		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)
@@ -471,18 +369,6 @@ main(int argc, char *argv[])
 		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;
 	/*
 	 * Only complain if -t or -u have been specified; the default
 	 * case (4096 sectors per cylinder) is intended to disagree
@@ -494,8 +380,6 @@ main(int argc, char *argv[])
 		    "disagrees with disk label", (u_long)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;
@@ -506,8 +390,6 @@ main(int argc, char *argv[])
 		int secperblk = sectorsize / DEV_BSIZE;
 
 		sectorsize = DEV_BSIZE;
-		nsectors *= secperblk;
-		nphyssectors *= secperblk;
 		secpercyl *= secperblk;
 		fssize *= secperblk;
 		pp->p_size *= secperblk;
@@ -599,7 +481,6 @@ usage()
 	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-R regression test, supress random factors\n");
 	fprintf(stderr, "\t-S sector size\n");
 #ifdef COMPAT
@@ -609,24 +490,16 @@ usage()
 	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-g average file size\n");
 	fprintf(stderr, "\t-h average files per directory\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-u sectors/cylinder\n");
 	fprintf(stderr,
         "\t-v do not attempt to determine partition name from device name\n");
-	fprintf(stderr, "\t-x spare sectors per cylinder\n");
 	exit(1);
 }
diff --git a/sbin/newfs/newfs.h b/sbin/newfs/newfs.h
index 96c4602..9bfe66f 100644
--- a/sbin/newfs/newfs.h
+++ b/sbin/newfs/newfs.h
@@ -38,19 +38,12 @@
  * variables set up by front end.
  */
 extern int	Nflag;		/* run mkfs without writing file system */
-extern int	Oflag;		/* format as an 4.3BSD file system */
 extern int	Rflag;		/* regression test */
 extern int	Uflag;		/* enable soft updates for 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 u_int	fssize;		/* file system size */
+extern u_int	secpercyl;	/* sectors per cylinder */
 extern int	sectorsize;	/* bytes/sector */
 extern int	realsectorsize;	/* bytes/sector in hardware*/
-extern int	rpm;		/* revolutions/minute of drive */
-extern int	interleave;	/* hardware sector interleave */
-extern int	trackskew;	/* sector 0 skew, per track */
 extern int	fsize;		/* fragment size */
 extern int	bsize;		/* block size */
 extern int	cpg;		/* cylinders/cylinder group */
@@ -59,11 +52,9 @@ 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 int	avgfilesize;	/* expected average file size */
 extern int	avgfilesperdir;	/* expected number of files per directory */
-
+void mkfs (struct partition *, char *, int, int);