 @@ -1,14 +1,14 @@
-/*	$NetBSD: mke2fs.c,v 1.14 2010/09/10 15:51:20 tsutsui Exp $	*/
+/*	$NetBSD: mke2fs.c,v 1.14.8.1 2012/03/09 16:51:04 sborrill Exp $	*/
 /*-
  * Copyright (c) 2007 Izumi Tsutsui.  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.
+ *
 @@ -90,51 +90,51 @@
  *	- Ext2fs Home Page
  *		http://e2fsprogs.sourceforge.net/ext2.html
  *	- Design and Implementation of the Second Extended Filesystem
  *		http://e2fsprogs.sourceforge.net/ext2intro.html
  *	- Linux Documentation "The Second Extended Filesystem"
  *		http://www.kernel.org/doc/Documentation/filesystems/ext2.txt
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)mkfs.c	8.11 (Berkeley) 5/3/95";
 #else
-__RCSID("$NetBSD: mke2fs.c,v 1.14 2010/09/10 15:51:20 tsutsui Exp $");
+__RCSID("$NetBSD: mke2fs.c,v 1.14.8.1 2012/03/09 16:51:04 sborrill Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <sys/mman.h>
 #include <sys/time.h>
 #include <ufs/ext2fs/ext2fs_dinode.h>
 #include <ufs/ext2fs/ext2fs_dir.h>
 #include <ufs/ext2fs/ext2fs.h>
 #include <sys/ioctl.h>
 #include <err.h>
 #include <errno.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <uuid.h>
 #include "extern.h"
 static void initcg(uint);
-static void zap_old_sblock(daddr_t);
+static void zap_old_sblock(int);
 static uint cgoverhead(uint);
 static int fsinit(const struct timeval *);
 static int makedir(struct ext2fs_direct *, int);
 static void copy_dir(struct ext2fs_direct *, struct ext2fs_direct *);
 static void init_resizeino(const struct timeval *);
 static uint32_t alloc(uint32_t, uint16_t);
 static void iput(struct ext2fs_dinode *, ino_t);
 static void rdfs(daddr_t, int, void *);
 static void wtfs(daddr_t, int, void *);
 static int ilog2(uint);
 static int skpc(int, size_t, uint8_t *);
 /* XXX: some of these macro should be into <ufs/ext2fs/ext2fs.h>? */
 @@ -542,53 +542,57 @@ mke2fs(const char *fsys, int fi, int fo)
 	iobufsize = (NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb) * sblock.e2fs_bsize;
 	iobuf = mmap(0, iobufsize, PROT_READ|PROT_WRITE,
 	    MAP_ANON|MAP_PRIVATE, -1, 0);
 	if (iobuf == NULL)
 		errx(EXIT_FAILURE, "Cannot allocate I/O buffer\n");
 	memset(iobuf, 0, iobufsize);
 	/*
 	 * We now start writing to the filesystem
 	 */
 	if (!Nflag) {
 		static const uint pbsize[] = { 1024, 2048, 4096, 0 };
-		uint pblock, epblock;
+		uint pblock;
 		/*
 		 * Validate the given file system size.
 		 * Verify that its last block can actually be accessed.
 		 * Convert to file system fragment sized units.
 		 */
 		if (fssize <= 0)
 			errx(EXIT_FAILURE, "Preposterous size %" PRId64 "\n",
 			    fssize);
 		wtfs(fssize - 1, sectorsize, iobuf);
 		/*
 		 * Ensure there is nothing that looks like a filesystem
 		 * superblock anywhere other than where ours will be.
 		 * If fsck_ext2fs finds the wrong one all hell breaks loose!
+		 *
-		 * XXX: needs to check how fsck_ext2fs programs even
+		 * Ext2fs superblock is always placed at the same SBOFF,
-		 *      on other OSes determine alternate superblocks
+		 * so we just zap possible first backups.
 		 */
 		for (i = 0; pbsize[i] != 0; i++) {
-			epblock = (uint64_t)bcount * bsize / pbsize[i];
+ 			pblock = (pbsize[i] > BBSIZE) ? 0 : 1;	/* 1st dblk */
-			for (pblock = ((pbsize[i] == SBSIZE) ? 1 : 0);
+			pblock += pbsize[i] * NBBY;		/* next bg */
-			    pblock < epblock;
+			/* zap first backup */
-			    pblock += pbsize[i] * NBBY /* bpg */)
+			zap_old_sblock(pblock * pbsize[i]);
 				zap_old_sblock((daddr_t)pblock *
 				    pbsize[i] / sectorsize);
+		}
 		/*
 		 * Also zap possbile FFS magic leftover to prevent
 		 * kernel vfs_mountroot() and bootloadres from mis-recognizing
 		 * this file system as FFS.
 		 */
 		zap_old_sblock(8192);	/* SBLOCK_UFS1 */
 		zap_old_sblock(65536);	/* SBLOCK_UFS2 */
+	}
 	if (verbosity >= 3)
 		printf("super-block backups (for fsck_ext2fs -b #) at:\n");
 	/* If we are printing more than one line of numbers, line up columns */
 	fld_width = verbosity < 4 ? 1 : snprintf(NULL, 0, "%" PRIu64,
 	    (uint64_t)cgbase(&sblock, ncg - 1));
 	/* Get terminal width */
 	if (ioctl(fileno(stdout), TIOCGWINSZ, &winsize) == 0)
 		max_cols = winsize.ws_col;
 	else
 		max_cols = 80;
 	if (Nflag && verbosity == 3)
 @@ -759,91 +763,92 @@ initcg(uint cylno)
 			dp = (struct ext2fs_dinode *)(buf + inodesize * j);
 			/* h2fs32() just for consistency */
 			dp->e2di_gen = h2fs32(arc4random());
+		}
 		wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_i_tables + i),
 		    sblock.e2fs_bsize, buf);
+	}
+}
 /*
  * Zap possible lingering old superblock data
  */
 static void
-zap_old_sblock(daddr_t sec)
+zap_old_sblock(int sblkoff)
+{
-	static daddr_t cg0_data;
+	static int cg0_data;
 	uint32_t oldfs[SBSIZE / sizeof(uint32_t)];
 	static const struct fsm {
 		uint32_t offset;
 		uint32_t magic;
 		uint32_t mask;
 	} fs_magics[] = {
 		{offsetof(struct ext2fs, e2fs_magic) / 4, E2FS_MAGIC, 0xffff},
 		{offsetof(struct ext2fs, e2fs_magic) / 4,
 		    E2FS_MAGIC << 16, 0xffff0000},
 		{14, 0xef530000, 0xffff0000},	/* EXT2FS (big) */
 		{0x55c / 4, 0x00011954, ~0U},	/* FS_UFS1_MAGIC */
 		{0x55c / 4, 0x19540119, ~0U},	/* FS_UFS2_MAGIC */
 		{0, 0x70162, ~0U},		/* LFS_MAGIC */
 		{.offset = ~0U},
 	};
 	const struct fsm *fsm;
 	if (Nflag)
 		return;
 	/* don't override data before superblock */
-	if (sec < SBOFF / sectorsize)
+	if (sblkoff < SBOFF)
 		return;
 	if (cg0_data == 0) {
 		cg0_data =
 		    ((daddr_t)sblock.e2fs.e2fs_first_dblock + cgoverhead(0)) *
-		    sblock.e2fs_bsize / sectorsize;
+		    sblock.e2fs_bsize;
+	}
 	/* Ignore anything that is beyond our filesystem */
-	if (sec >= fssize)
+	if (sblkoff / sectorsize >= fssize)
 		return;
 	/* Zero anything inside our filesystem... */
-	if (sec >= sblock.e2fs.e2fs_first_dblock * bsize / sectorsize) {
+	if (sblkoff >= sblock.e2fs.e2fs_first_dblock * bsize) {
 		/* ...unless we will write that area anyway */
-		if (sec >= cg0_data)
+		if (sblkoff >= cg0_data)
 			/* assume iobuf is zero'ed here */
-			wtfs(sec, roundup(SBSIZE, sectorsize), iobuf);
+			wtfs(sblkoff / sectorsize,
 			    roundup(SBSIZE, sectorsize), iobuf);
 		return;
+	}
 	/*
 	 * The sector might contain boot code, so we must validate it
+	 *
 	 * XXX: ext2fs won't preserve data after SBOFF,
 	 *      but first_dblock could have a different value.
 	 */
-	rdfs(sec, sizeof(oldfs), &oldfs);
+	rdfs(sblkoff / sectorsize, sizeof(oldfs), &oldfs);
 	for (fsm = fs_magics;; fsm++) {
 		uint32_t v;
 		if (fsm->mask == 0)
 			return;
 		v = oldfs[fsm->offset];
 		if ((v & fsm->mask) == fsm->magic ||
 		    (bswap32(v) & fsm->mask) == fsm->magic)
 			break;
+	}
 	/* Just zap the magic number */
 	oldfs[fsm->offset] = 0;
-	wtfs(sec, sizeof(oldfs), &oldfs);
+	wtfs(sblkoff / sectorsize, sizeof(oldfs), &oldfs);
+}
 /*
  * uint cgoverhead(uint c)
+ *
  * 	Return a number of reserved blocks on the specified group.
  * 	XXX: should be shared with src/sbin/fsck_ext2fs/setup.c
  */
 uint
 cgoverhead(uint c)
+{
 	uint overh;