 @@ -1,14 +1,14 @@
-/*	$NetBSD: mke2fs.c,v 1.24 2016/08/04 17:43:47 jdolecek Exp $	*/
+/*	$NetBSD: mke2fs.c,v 1.25 2016/09/05 10:44:36 martin 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,27 +90,27 @@
  *	- 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.24 2016/08/04 17:43:47 jdolecek Exp $");
+__RCSID("$NetBSD: mke2fs.c,v 1.25 2016/09/05 10:44:36 martin 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>
 @@ -485,44 +485,47 @@ mke2fs(const char *fsys, int fi, int fo)
 		uint boffset;
 		boffset = cgbase(&sblock, cylno);
 		if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||
 		    (sblock.e2fs.e2fs_features_rocompat &
 		     EXT2F_ROCOMPAT_SPARSESUPER) == 0 ||
 		    cg_has_sb(cylno)) {
 			boffset += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;
 			if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
 			    (sblock.e2fs.e2fs_features_compat &
 			     EXT2F_COMPAT_RESIZE) != 0)
 				boffset += sblock.e2fs.e2fs_reserved_ngdb;
+		}
-		gd[cylno].ext2bgd_b_bitmap = boffset;
+		gd[cylno].ext2bgd_b_bitmap = h2fs32(boffset);
 		boffset += NBLOCK_BLOCK_BITMAP;
-		gd[cylno].ext2bgd_i_bitmap = boffset;
+		gd[cylno].ext2bgd_i_bitmap = h2fs32(boffset);
 		boffset += NBLOCK_INODE_BITMAP;
-		gd[cylno].ext2bgd_i_tables = boffset;
+		gd[cylno].ext2bgd_i_tables = h2fs32(boffset);
 		if (cylno == (ncg - 1))
-			gd[cylno].ext2bgd_nbfree =
+			gd[cylno].ext2bgd_nbfree = h2fs16(
-			    blocks_lastcg - cgoverhead(cylno);
+			    blocks_lastcg - cgoverhead(cylno));
 		else
-			gd[cylno].ext2bgd_nbfree =
+			gd[cylno].ext2bgd_nbfree = h2fs16(
-			    sblock.e2fs.e2fs_bpg - cgoverhead(cylno);
+			    sblock.e2fs.e2fs_bpg - cgoverhead(cylno));
-		fbcount += gd[cylno].ext2bgd_nbfree;
+		fbcount += fs2h16(gd[cylno].ext2bgd_nbfree);
 		gd[cylno].ext2bgd_nifree = sblock.e2fs.e2fs_ipg;
 		if (cylno == 0) {
 			/* take reserved inodes off nifree */
-			gd[cylno].ext2bgd_nifree -= EXT2_RESERVED_INODES;
+			gd[cylno].ext2bgd_nifree = h2fs16(
 			    sblock.e2fs.e2fs_ipg-EXT2_RESERVED_INODES);
 		} else {
 			gd[cylno].ext2bgd_nifree =
 			    h2fs16(sblock.e2fs.e2fs_ipg);
+		}
-		ficount += gd[cylno].ext2bgd_nifree;
+		ficount += fs2h16(gd[cylno].ext2bgd_nifree);
 		gd[cylno].ext2bgd_ndirs = 0;
+	}
 	sblock.e2fs.e2fs_fbcount = fbcount;
 	sblock.e2fs.e2fs_ficount = ficount;
 	/*
 	 * Dump out summary information about file system.
 	 */
 	if (verbosity > 0) {
 		printf("%s: %u.%1uMB (%" PRId64 " sectors) "
 		    "block size %u, fragment size %u\n",
 		    fsys,
 		    (uint)(((uint64_t)bcount * bsize) / (1024 * 1024)),
 @@ -719,62 +722,62 @@ initcg(uint cylno)
 		/* The last group could have less blocks than e2fs_bpg. */
 		nblcg = sblock.e2fs.e2fs_bcount -
 		    cgbase(&sblock, sblock.e2fs_ncg - 1);
 		for (i = nblcg; i < roundup(nblcg, NBBY); i++)
 			setbit(buf, i);
 		memset(&buf[i / NBBY], ~0U, sblock.e2fs.e2fs_bpg - i);
+	}
 	/* set overhead (superblock, group descriptor etc.) blocks used */
 	for (i = 0; i < cgoverhead(cylno) / NBBY; i++)
 		buf[i] = ~0;
 	i = i * NBBY;
 	for (; i < cgoverhead(cylno); i++)
 		setbit(buf, i);
-	wtfs(EXT2_FSBTODB(&sblock, gd[cylno].ext2bgd_b_bitmap),
+	wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[cylno].ext2bgd_b_bitmap)),
 	    sblock.e2fs_bsize, buf);
 	/*
 	 * Initialize inode bitmap.
+	 *
 	 *  Assume e2fs_ipg is a multiple of NBBY since
 	 *  it's a multiple of e2fs_ipb (as we did above).
 	 *  Note even (possibly smaller) the last group has the same e2fs_ipg.
 	 */
 	i = sblock.e2fs.e2fs_ipg / NBBY;
 	memset(buf, 0, i);
 	memset(buf + i, ~0U, sblock.e2fs_bsize - i);
 	if (cylno == 0) {
 		/* mark reserved inodes */
 		for (i = 1; i < EXT2_FIRSTINO; i++)
 			setbit(buf, EXT2_INO_INDEX(i));
+	}
-	wtfs(EXT2_FSBTODB(&sblock, gd[cylno].ext2bgd_i_bitmap),
+	wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[cylno].ext2bgd_i_bitmap)),
 	    sblock.e2fs_bsize, buf);
 	/*
 	 * Initialize inode tables.
+	 *
 	 *  Just initialize generation numbers for NFS security.
 	 *  XXX: sys/ufs/ext2fs/ext2fs_alloc.c:ext2fs_valloc() seems
 	 *       to override these generated numbers.
 	 */
 	memset(buf, 0, sblock.e2fs_bsize);
 	for (i = 0; i < sblock.e2fs_itpg; i++) {
 		for (j = 0; j < sblock.e2fs_ipb; j++) {
 			dp = (struct ext2fs_dinode *)(buf + inodesize * j);
 			/* h2fs32() just for consistency */
 			dp->e2di_gen = h2fs32(arc4random());
+		}
-		wtfs(EXT2_FSBTODB(&sblock, gd[cylno].ext2bgd_i_tables + i),
+		wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[cylno].ext2bgd_i_tables) + i),
 		    sblock.e2fs_bsize, buf);
+	}
+}
 /*
  * Zap possible lingering old superblock data
  */
 static void
 zap_old_sblock(int sblkoff)
+{
 	static int cg0_data;
 	uint32_t oldfs[SBSIZE / sizeof(uint32_t)];
 	static const struct fsm {
 @@ -1254,27 +1257,27 @@ alloc(uint32_t size, uint16_t mode)
 	uint32_t loc, bno;
 	uint8_t *bbp;
 	uint len, map, i;
 	if (gd[0].ext2bgd_nbfree == 0)
 		return 0;
 	if (size > sblock.e2fs_bsize)
 		return 0;
 	bbp = malloc(sblock.e2fs_bsize);
 	if (bbp == NULL)
 		return 0;
-	rdfs(EXT2_FSBTODB(&sblock, gd[0].ext2bgd_b_bitmap),
+	rdfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_b_bitmap)),
 	    sblock.e2fs_bsize, bbp);
 	/* XXX: kernel uses e2fs_fpg here */
 	len = sblock.e2fs.e2fs_bpg / NBBY;
 #if 0	/* no need block allocation for root or lost+found dir */
 	for (loc = 0; loc < len; loc++) {
 		if (bbp[loc] == 0) {
 			bno = loc * NBBY;
 			goto gotit;
+		}
+	}
 #endif
 @@ -1289,33 +1292,33 @@ alloc(uint32_t size, uint16_t mode)
 	bno = loc * NBBY;
 	for (i = 0; i < NBBY; i++, bno++) {
 		if ((map & (1 << i)) == 0)
 			goto gotit;
+	}
 	free(bbp);
 	return 0;
  gotit:
 	if (isset(bbp, bno))
 		errx(EXIT_FAILURE, "%s: inconsistent bitmap", __func__);
 	setbit(bbp, bno);
-	wtfs(EXT2_FSBTODB(&sblock, gd[0].ext2bgd_b_bitmap),
+	wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_b_bitmap)),
 	    sblock.e2fs_bsize, bbp);
 	free(bbp);
 	/* XXX: modified group descriptors won't be written into backups */
-	gd[0].ext2bgd_nbfree--;
+	gd[0].ext2bgd_nbfree = h2fs16(fs2h16(gd[0].ext2bgd_nbfree)-1);
 	if ((mode & EXT2_IFDIR) != 0)
-		gd[0].ext2bgd_ndirs++;
+		gd[0].ext2bgd_ndirs = h2fs16(fs2h16(gd[0].ext2bgd_ndirs)+1);
 	sblock.e2fs.e2fs_fbcount--;
 	return sblock.e2fs.e2fs_first_dblock + bno;
+}
 /*
  * void iput(struct ext2fs_dinode *ip, ino_t ino)
+ *
  *	Put an inode entry into the corresponding table.
  */
 static void
 iput(struct ext2fs_dinode *ip, ino_t ino)
+{
 @@ -1333,37 +1336,37 @@ iput(struct ext2fs_dinode *ip, ino_t ino
 	 * Reserved inodes are allocated and accounted in initcg()
 	 * so skip checks of the bitmap and allocation for them.
 	 */
 	if (ino >= EXT2_FIRSTINO) {
 		c = ino_to_cg(&sblock, ino);
 		/* sanity check */
 		if (gd[c].ext2bgd_nifree == 0)
 			errx(EXIT_FAILURE,
 			    "%s: no free inode %" PRIu64 " in block group %u",
 			    __func__, (uint64_t)ino, c);
 		/* update inode bitmap */
-		rdfs(EXT2_FSBTODB(&sblock, gd[0].ext2bgd_i_bitmap),
+		rdfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_i_bitmap)),
 		    sblock.e2fs_bsize, bp);
 		/* more sanity */
 		if (isset(bp, EXT2_INO_INDEX(ino)))
 			errx(EXIT_FAILURE, "%s: inode %" PRIu64
 			    " already in use", __func__, (uint64_t)ino);
 		setbit(bp, EXT2_INO_INDEX(ino));
-		wtfs(EXT2_FSBTODB(&sblock, gd[0].ext2bgd_i_bitmap),
+		wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_i_bitmap)),
 		    sblock.e2fs_bsize, bp);
-		gd[c].ext2bgd_nifree--;
+		gd[c].ext2bgd_nifree = h2fs16(fs2h16(gd[c].ext2bgd_nifree)-1);
 		sblock.e2fs.e2fs_ficount--;
+	}
 	if (ino >= sblock.e2fs.e2fs_ipg * sblock.e2fs_ncg)
 		errx(EXIT_FAILURE, "%s: inode value out of range (%" PRIu64
 		    ")", __func__, (uint64_t)ino);
 	/* update an inode entry in the table */
 	d = EXT2_FSBTODB(&sblock, ino_to_fsba(&sblock, ino));
 	rdfs(d, sblock.e2fs_bsize, bp);
 	dp = (struct ext2fs_dinode *)(bp +
 	    inodesize * ino_to_fsbo(&sblock, ino));