From owner-svn-src-stable-10@freebsd.org  Wed Jan  4 02:43:35 2017
Return-Path: <owner-svn-src-stable-10@freebsd.org>
Delivered-To: svn-src-stable-10@mailman.ysv.freebsd.org
Received: from mx1.freebsd.org (mx1.freebsd.org
 [IPv6:2001:1900:2254:206a::19:1])
 by mailman.ysv.freebsd.org (Postfix) with ESMTP id CAA5FC9DC25;
 Wed,  4 Jan 2017 02:43:35 +0000 (UTC) (envelope-from pfg@FreeBSD.org)
Received: from repo.freebsd.org (repo.freebsd.org
 [IPv6:2610:1c1:1:6068::e6a:0])
 (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
 (Client did not present a certificate)
 by mx1.freebsd.org (Postfix) with ESMTPS id 66B7714C0;
 Wed,  4 Jan 2017 02:43:35 +0000 (UTC) (envelope-from pfg@FreeBSD.org)
Received: from repo.freebsd.org ([127.0.1.37])
 by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id v042hY9S038873;
 Wed, 4 Jan 2017 02:43:34 GMT (envelope-from pfg@FreeBSD.org)
Received: (from pfg@localhost)
 by repo.freebsd.org (8.15.2/8.15.2/Submit) id v042hXjX038861;
 Wed, 4 Jan 2017 02:43:33 GMT (envelope-from pfg@FreeBSD.org)
Message-Id: <201701040243.v042hXjX038861@repo.freebsd.org>
X-Authentication-Warning: repo.freebsd.org: pfg set sender to pfg@FreeBSD.org
 using -f
From: "Pedro F. Giffuni" <pfg@FreeBSD.org>
Date: Wed, 4 Jan 2017 02:43:33 +0000 (UTC)
To: src-committers@freebsd.org, svn-src-all@freebsd.org,
 svn-src-stable@freebsd.org, svn-src-stable-10@freebsd.org
Subject: svn commit: r311232 - stable/10/sys/fs/ext2fs
X-SVN-Group: stable-10
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-BeenThere: svn-src-stable-10@freebsd.org
X-Mailman-Version: 2.1.23
Precedence: list
List-Id: SVN commit messages for only the 10-stable src tree
 <svn-src-stable-10.freebsd.org>
List-Unsubscribe: <https://lists.freebsd.org/mailman/options/svn-src-stable-10>, 
 <mailto:svn-src-stable-10-request@freebsd.org?subject=unsubscribe>
List-Archive: <http://lists.freebsd.org/pipermail/svn-src-stable-10/>
List-Post: <mailto:svn-src-stable-10@freebsd.org>
List-Help: <mailto:svn-src-stable-10-request@freebsd.org?subject=help>
List-Subscribe: <https://lists.freebsd.org/mailman/listinfo/svn-src-stable-10>, 
 <mailto:svn-src-stable-10-request@freebsd.org?subject=subscribe>
X-List-Received-Date: Wed, 04 Jan 2017 02:43:35 -0000

Author: pfg
Date: Wed Jan  4 02:43:33 2017
New Revision: 311232
URL: https://svnweb.freebsd.org/changeset/base/311232

Log:
  MFC r310705, r310706:
  style(9) cleanups.
  
  Just to reduce some of the issues found with indent(1).

Modified:
  stable/10/sys/fs/ext2fs/ext2_alloc.c
  stable/10/sys/fs/ext2fs/ext2_balloc.c
  stable/10/sys/fs/ext2fs/ext2_bmap.c
  stable/10/sys/fs/ext2fs/ext2_dir.h
  stable/10/sys/fs/ext2fs/ext2_extents.c
  stable/10/sys/fs/ext2fs/ext2_extents.h
  stable/10/sys/fs/ext2fs/ext2_extern.h
  stable/10/sys/fs/ext2fs/ext2_hash.c
  stable/10/sys/fs/ext2fs/ext2_htree.c
  stable/10/sys/fs/ext2fs/ext2_inode.c
  stable/10/sys/fs/ext2fs/ext2_inode_cnv.c
  stable/10/sys/fs/ext2fs/ext2_lookup.c
  stable/10/sys/fs/ext2fs/ext2_mount.h
  stable/10/sys/fs/ext2fs/ext2_subr.c
  stable/10/sys/fs/ext2fs/ext2_vfsops.c
  stable/10/sys/fs/ext2fs/ext2_vnops.c
  stable/10/sys/fs/ext2fs/ext2fs.h
  stable/10/sys/fs/ext2fs/fs.h
  stable/10/sys/fs/ext2fs/htree.h
  stable/10/sys/fs/ext2fs/inode.h
Directory Properties:
  stable/10/   (props changed)

Modified: stable/10/sys/fs/ext2fs/ext2_alloc.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_alloc.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_alloc.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -86,7 +86,8 @@ ext2_alloc(struct inode *ip, daddr_t lbn
 	struct m_ext2fs *fs;
 	struct ext2mount *ump;
 	int32_t bno;
-	int cg;	
+	int cg;
+
 	*bnp = 0;
 	fs = ip->i_e2fs;
 	ump = ip->i_ump;
@@ -99,11 +100,11 @@ ext2_alloc(struct inode *ip, daddr_t lbn
 	}
 	if (cred == NOCRED)
 		panic("ext2_alloc: missing credential");
-#endif /* INVARIANTS */
+#endif		/* INVARIANTS */
 	if (size == fs->e2fs_bsize && fs->e2fs->e2fs_fbcount == 0)
 		goto nospace;
-	if (cred->cr_uid != 0 && 
-		fs->e2fs->e2fs_fbcount < fs->e2fs->e2fs_rbcount)
+	if (cred->cr_uid != 0 &&
+	    fs->e2fs->e2fs_fbcount < fs->e2fs->e2fs_rbcount)
 		goto nospace;
 	if (bpref >= fs->e2fs->e2fs_bcount)
 		bpref = 0;
@@ -112,7 +113,7 @@ ext2_alloc(struct inode *ip, daddr_t lbn
 	else
 		cg = dtog(fs, bpref);
 	bno = (daddr_t)ext2_hashalloc(ip, cg, bpref, fs->e2fs_bsize,
-				      ext2_alloccg);
+	    ext2_alloccg);
 	if (bno > 0) {
 		/* set next_alloc fields as done in block_getblk */
 		ip->i_next_alloc_block = lbn;
@@ -148,10 +149,12 @@ nospace:
 static SYSCTL_NODE(_vfs, OID_AUTO, ext2fs, CTLFLAG_RW, 0, "EXT2FS filesystem");
 
 static int doasyncfree = 1;
+
 SYSCTL_INT(_vfs_ext2fs, OID_AUTO, doasyncfree, CTLFLAG_RW, &doasyncfree, 0,
     "Use asychronous writes to update block pointers when freeing blocks");
 
 static int doreallocblks = 1;
+
 SYSCTL_INT(_vfs_ext2fs, OID_AUTO, doreallocblks, CTLFLAG_RW, &doreallocblks, 0, "");
 
 int
@@ -171,7 +174,7 @@ ext2_reallocblks(struct vop_reallocblks_
 	int i, len, start_lvl, end_lvl, pref, ssize;
 
 	if (doreallocblks == 0)
-		  return (ENOSPC);
+		return (ENOSPC);
 
 	vp = ap->a_vp;
 	ip = VTOI(vp);
@@ -236,7 +239,7 @@ ext2_reallocblks(struct vop_reallocblks_
 		ssize = len;
 	} else {
 #ifdef INVARIANTS
-		if (start_ap[start_lvl-1].in_lbn == idp->in_lbn)
+		if (start_ap[start_lvl - 1].in_lbn == idp->in_lbn)
 			panic("ext2_reallocblks: start == end");
 #endif
 		ssize = len - (idp->in_off + 1);
@@ -253,10 +256,10 @@ ext2_reallocblks(struct vop_reallocblks_
 	 * Search the block map looking for an allocation of the desired size.
 	 */
 	if ((newblk = (e2fs_daddr_t)ext2_hashalloc(ip, dtog(fs, pref), pref,
-	    len, ext2_clusteralloc)) == 0){
+	    len, ext2_clusteralloc)) == 0) {
 		EXT2_UNLOCK(ump);
 		goto fail;
-	}	
+	}
 	/*
 	 * We have found a new contiguous block.
 	 *
@@ -267,7 +270,7 @@ ext2_reallocblks(struct vop_reallocblks_
 #ifdef DEBUG
 	printf("realloc: ino %d, lbns %jd-%jd\n\told:", ip->i_number,
 	    (intmax_t)start_lbn, (intmax_t)end_lbn);
-#endif /* DEBUG */
+#endif	/* DEBUG */
 	blkno = newblk;
 	for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->e2fs_fpb) {
 		if (i == ssize) {
@@ -279,15 +282,15 @@ ext2_reallocblks(struct vop_reallocblks_
 			panic("ext2_reallocblks: alloc mismatch");
 #endif
 #ifdef DEBUG
-	printf(" %d,", *bap);
-#endif /* DEBUG */
+		printf(" %d,", *bap);
+#endif	/* DEBUG */
 		*bap++ = blkno;
 	}
 	/*
 	 * Next we must write out the modified inode and indirect blocks.
 	 * For strict correctness, the writes should be synchronous since
 	 * the old block values may have been written to disk. In practise
-	 * they are almost never written, but if we are concerned about 
+	 * they are almost never written, but if we are concerned about
 	 * strict correctness, the `doasyncfree' flag should be set to zero.
 	 *
 	 * The test on `doasyncfree' should be changed to test a flag
@@ -318,18 +321,18 @@ ext2_reallocblks(struct vop_reallocblks_
 	 */
 #ifdef DEBUG
 	printf("\n\tnew:");
-#endif /* DEBUG */
+#endif	/* DEBUG */
 	for (blkno = newblk, i = 0; i < len; i++, blkno += fs->e2fs_fpb) {
 		ext2_blkfree(ip, dbtofsb(fs, buflist->bs_children[i]->b_blkno),
 		    fs->e2fs_bsize);
 		buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
 #ifdef DEBUG
 		printf(" %d,", blkno);
-#endif /* DEBUG */
+#endif	/* DEBUG */
 	}
 #ifdef DEBUG
 	printf("\n");
-#endif /* DEBUG */
+#endif	/* DEBUG */
 	return (0);
 
 fail:
@@ -342,7 +345,7 @@ fail:
 
 /*
  * Allocate an inode in the filesystem.
- * 
+ *
  */
 int
 ext2_valloc(struct vnode *pvp, int mode, struct ucred *cred, struct vnode **vpp)
@@ -354,7 +357,7 @@ ext2_valloc(struct vnode *pvp, int mode,
 	struct ext2mount *ump;
 	ino_t ino, ipref;
 	int i, error, cg;
-	
+
 	*vpp = NULL;
 	pip = VTOI(pvp);
 	fs = pip->i_e2fs;
@@ -380,7 +383,7 @@ ext2_valloc(struct vnode *pvp, int mode,
 	ipref = cg * fs->e2fs->e2fs_ipg + 1;
 	ino = (ino_t)ext2_hashalloc(pip, cg, (long)ipref, mode, ext2_nodealloccg);
 
-	if (ino == 0) 
+	if (ino == 0)
 		goto noinodes;
 	error = VFS_VGET(pvp->v_mount, ino, LK_EXCLUSIVE, vpp);
 	if (error) {
@@ -454,7 +457,7 @@ ext2_dirpref(struct inode *pip)
 
 	avgifree = fs->e2fs->e2fs_ficount / fs->e2fs_gcount;
 	avgbfree = fs->e2fs->e2fs_fbcount / fs->e2fs_gcount;
-	avgndir  = fs->e2fs_total_dir / fs->e2fs_gcount;
+	avgndir = fs->e2fs_total_dir / fs->e2fs_gcount;
 
 	/*
 	 * Force allocation in another cg if creating a first level dir.
@@ -478,10 +481,8 @@ ext2_dirpref(struct inode *pip)
 				mincg = cg;
 				minndir = fs->e2fs_gd[cg].ext2bgd_ndirs;
 			}
-
 		return (mincg);
 	}
-
 	/*
 	 * Count various limits which used for
 	 * optimal allocation of a directory inode.
@@ -504,7 +505,7 @@ ext2_dirpref(struct inode *pip)
 		maxcontigdirs = 1;
 
 	/*
-	 * Limit number of dirs in one cg and reserve space for 
+	 * Limit number of dirs in one cg and reserve space for
 	 * regular files, but only if we have no deficit in
 	 * inodes or space.
 	 */
@@ -536,7 +537,7 @@ ext2_dirpref(struct inode *pip)
 }
 
 /*
- * Select the desired position for the next block in a file.  
+ * Select the desired position for the next block in a file.
  *
  * we try to mimic what Remy does in inode_getblk/block_getblk
  *
@@ -552,30 +553,34 @@ e4fs_daddr_t
 ext2_blkpref(struct inode *ip, e2fs_lbn_t lbn, int indx, e2fs_daddr_t *bap,
     e2fs_daddr_t blocknr)
 {
-	int	tmp;
+	int tmp;
+
 	mtx_assert(EXT2_MTX(ip->i_ump), MA_OWNED);
 
-	/* if the next block is actually what we thought it is,
-	   then set the goal to what we thought it should be
-	*/
+	/*
+	 * If the next block is actually what we thought it is, then set the
+	 * goal to what we thought it should be.
+	 */
 	if (ip->i_next_alloc_block == lbn && ip->i_next_alloc_goal != 0)
 		return ip->i_next_alloc_goal;
 
-	/* now check whether we were provided with an array that basically
-	   tells us previous blocks to which we want to stay closeby
-	*/
+	/*
+	 * Now check whether we were provided with an array that basically
+	 * tells us previous blocks to which we want to stay close.
+	 */
 	if (bap)
-		for (tmp = indx - 1; tmp >= 0; tmp--) 
-			if (bap[tmp]) 
+		for (tmp = indx - 1; tmp >= 0; tmp--)
+			if (bap[tmp])
 				return bap[tmp];
 
-	/* else let's fall back to the blocknr, or, if there is none,
-	   follow the rule that a block should be allocated near its inode
-	*/
+	/*
+	 * Else lets fall back to the blocknr or, if there is none, follow
+	 * the rule that a block should be allocated near its inode.
+	 */
 	return blocknr ? blocknr :
-			(e2fs_daddr_t)(ip->i_block_group * 
-			EXT2_BLOCKS_PER_GROUP(ip->i_e2fs)) + 
-			ip->i_e2fs->e2fs->e2fs_first_dblock;
+	    (e2fs_daddr_t)(ip->i_block_group *
+	    EXT2_BLOCKS_PER_GROUP(ip->i_e2fs)) +
+	    ip->i_e2fs->e2fs->e2fs_first_dblock;
 }
 
 /*
@@ -588,7 +593,7 @@ ext2_blkpref(struct inode *ip, e2fs_lbn_
  */
 static u_long
 ext2_hashalloc(struct inode *ip, int cg, long pref, int size,
-                daddr_t (*allocator)(struct inode *, int, daddr_t, int))
+    daddr_t (*allocator) (struct inode *, int, daddr_t, int))
 {
 	struct m_ext2fs *fs;
 	ino_t result;
@@ -652,8 +657,8 @@ ext2_alloccg(struct inode *ip, int cg, d
 		return (0);
 	EXT2_UNLOCK(ump);
 	error = bread(ip->i_devvp, fsbtodb(fs,
-		fs->e2fs_gd[cg].ext2bgd_b_bitmap),
-		(int)fs->e2fs_bsize, NOCRED, &bp);
+	    fs->e2fs_gd[cg].ext2bgd_b_bitmap),
+	    (int)fs->e2fs_bsize, NOCRED, &bp);
 	if (error) {
 		brelse(bp);
 		EXT2_LOCK(ump);
@@ -739,9 +744,8 @@ retry:
 		start = 0;
 		goto retry;
 	}
-
 	bno = ext2_mapsearch(fs, bbp, bpref);
-	if (bno < 0){
+	if (bno < 0) {
 		brelse(bp);
 		EXT2_LOCK(ump);
 		return (0);
@@ -750,7 +754,7 @@ gotit:
 #ifdef INVARIANTS
 	if (isset(bbp, bno)) {
 		printf("ext2fs_alloccgblk: cg=%d bno=%jd fs=%s\n",
-			cg, (intmax_t)bno, fs->e2fs_fsmnt);
+		    cg, (intmax_t)bno, fs->e2fs_fsmnt);
 		panic("ext2fs_alloccg: dup alloc");
 	}
 #endif
@@ -810,9 +814,9 @@ ext2_clusteralloc(struct inode *ip, int 
 		 * to find no cluster.
 		 */
 		lp = &fs->e2fs_clustersum[cg].cs_sum[len - 1];
-			for (i = len - 1; i > 0; i--)
-				if (*lp-- > 0)
-					break;
+		for (i = len - 1; i > 0; i--)
+			if (*lp-- > 0)
+				break;
 		fs->e2fs_maxcluster[cg] = i;
 		goto fail;
 	}
@@ -887,17 +891,18 @@ ext2_nodealloccg(struct inode *ip, int c
 	struct ext2mount *ump;
 	int error, start, len;
 	char *ibp, *loc;
-	ipref--; /* to avoid a lot of (ipref -1) */
+
+	ipref--;	/* to avoid a lot of (ipref -1) */
 	if (ipref == -1)
 		ipref = 0;
 	fs = ip->i_e2fs;
 	ump = ip->i_ump;
 	if (fs->e2fs_gd[cg].ext2bgd_nifree == 0)
 		return (0);
-	EXT2_UNLOCK(ump);	
+	EXT2_UNLOCK(ump);
 	error = bread(ip->i_devvp, fsbtodb(fs,
-		fs->e2fs_gd[cg].ext2bgd_i_bitmap),
-		(int)fs->e2fs_bsize, NOCRED, &bp);
+	    fs->e2fs_gd[cg].ext2bgd_i_bitmap),
+	    (int)fs->e2fs_bsize, NOCRED, &bp);
 	if (error) {
 		brelse(bp);
 		EXT2_LOCK(ump);
@@ -927,7 +932,7 @@ ext2_nodealloccg(struct inode *ip, int c
 		loc = memcchr(&ibp[start], 0xff, len);
 		if (loc == NULL) {
 			printf("cg = %d, ipref = %lld, fs = %s\n",
-				cg, (long long)ipref, fs->e2fs_fsmnt);
+			    cg, (long long)ipref, fs->e2fs_fsmnt);
 			panic("ext2fs_nodealloccg: map corrupted");
 			/* NOTREACHED */
 		}
@@ -945,7 +950,7 @@ gotit:
 	}
 	EXT2_UNLOCK(ump);
 	bdwrite(bp);
-	return (cg * fs->e2fs->e2fs_ipg + ipref +1);
+	return (cg * fs->e2fs->e2fs_ipg + ipref + 1);
 }
 
 /*
@@ -971,8 +976,8 @@ ext2_blkfree(struct inode *ip, e4fs_dadd
 		return;
 	}
 	error = bread(ip->i_devvp,
-		fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_b_bitmap),
-		(int)fs->e2fs_bsize, NOCRED, &bp);
+	    fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_b_bitmap),
+	    (int)fs->e2fs_bsize, NOCRED, &bp);
 	if (error) {
 		brelse(bp);
 		return;
@@ -981,7 +986,7 @@ ext2_blkfree(struct inode *ip, e4fs_dadd
 	bno = dtogd(fs, bno);
 	if (isclr(bbp, bno)) {
 		printf("block = %lld, fs = %s\n",
-		     (long long)bno, fs->e2fs_fsmnt);
+		    (long long)bno, fs->e2fs_fsmnt);
 		panic("ext2_blkfree: freeing free block");
 	}
 	clrbit(bbp, bno);
@@ -1006,7 +1011,7 @@ ext2_vfree(struct vnode *pvp, ino_t ino,
 	struct buf *bp;
 	struct ext2mount *ump;
 	int error, cg;
-	char * ibp;
+	char *ibp;
 
 	pip = VTOI(pvp);
 	fs = pip->i_e2fs;
@@ -1017,8 +1022,8 @@ ext2_vfree(struct vnode *pvp, ino_t ino,
 
 	cg = ino_to_cg(fs, ino);
 	error = bread(pip->i_devvp,
-		fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_i_bitmap),
-		(int)fs->e2fs_bsize, NOCRED, &bp);
+	    fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_i_bitmap),
+	    (int)fs->e2fs_bsize, NOCRED, &bp);
 	if (error) {
 		brelse(bp);
 		return (0);
@@ -1027,7 +1032,7 @@ ext2_vfree(struct vnode *pvp, ino_t ino,
 	ino = (ino - 1) % fs->e2fs->e2fs_ipg;
 	if (isclr(ibp, ino)) {
 		printf("ino = %llu, fs = %s\n",
-			 (unsigned long long)ino, fs->e2fs_fsmnt);
+		    (unsigned long long)ino, fs->e2fs_fsmnt);
 		if (fs->e2fs_ronly == 0)
 			panic("ext2_vfree: freeing free inode");
 	}
@@ -1073,7 +1078,7 @@ ext2_mapsearch(struct m_ext2fs *fs, char
 		loc = memcchr(&bbp[start], 0xff, len);
 		if (loc == NULL) {
 			printf("start = %d, len = %d, fs = %s\n",
-				start, len, fs->e2fs_fsmnt);
+			    start, len, fs->e2fs_fsmnt);
 			panic("ext2_mapsearch: map corrupted");
 			/* NOTREACHED */
 		}
@@ -1083,7 +1088,7 @@ ext2_mapsearch(struct m_ext2fs *fs, char
 
 /*
  * Fserr prints the name of a filesystem with an error diagnostic.
- * 
+ *
  * The form of the error message is:
  *	fs: error message
  */

Modified: stable/10/sys/fs/ext2fs/ext2_balloc.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_balloc.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_balloc.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -76,22 +76,23 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 	ump = ip->i_ump;
 
 	/*
-	 * check if this is a sequential block allocation. 
-	 * If so, increment next_alloc fields to allow ext2_blkpref 
+	 * check if this is a sequential block allocation.
+	 * If so, increment next_alloc fields to allow ext2_blkpref
 	 * to make a good guess
 	 */
 	if (lbn == ip->i_next_alloc_block + 1) {
 		ip->i_next_alloc_block++;
 		ip->i_next_alloc_goal++;
 	}
-
 	/*
 	 * The first NDADDR blocks are direct blocks
 	 */
 	if (lbn < NDADDR) {
 		nb = ip->i_db[lbn];
-		/* no new block is to be allocated, and no need to expand
-		   the file */
+		/*
+		 * no new block is to be allocated, and no need to expand
+		 * the file
+		 */
 		if (nb != 0 && ip->i_size >= (lbn + 1) * fs->e2fs_bsize) {
 			error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp);
 			if (error) {
@@ -116,10 +117,13 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 				}
 				bp->b_blkno = fsbtodb(fs, nb);
 			} else {
-			/* Godmar thinks: this shouldn't happen w/o fragments */
-				printf("nsize %d(%d) > osize %d(%d) nb %d\n", 
-					(int)nsize, (int)size, (int)osize, 
-					(int)ip->i_size, (int)nb);
+				/*
+				 * Godmar thinks: this shouldn't happen w/o
+				 * fragments
+				 */
+				printf("nsize %d(%d) > osize %d(%d) nb %d\n",
+				    (int)nsize, (int)size, (int)osize,
+				    (int)ip->i_size, (int)nb);
 				panic(
 				    "ext2_balloc: Something is terribly wrong");
 /*
@@ -156,7 +160,7 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 		return (error);
 #ifdef INVARIANTS
 	if (num < 1)
-		panic ("ext2_balloc: ext2_getlbns returned indirect block");
+		panic("ext2_balloc: ext2_getlbns returned indirect block");
 #endif
 	/*
 	 * Fetch the first indirect block allocating if necessary.
@@ -165,10 +169,10 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 	nb = ip->i_ib[indirs[0].in_off];
 	if (nb == 0) {
 		EXT2_LOCK(ump);
-		pref = ext2_blkpref(ip, lbn, indirs[0].in_off + 
-					     EXT2_NDIR_BLOCKS, &ip->i_db[0], 0);
+		pref = ext2_blkpref(ip, lbn, indirs[0].in_off +
+		    EXT2_NDIR_BLOCKS, &ip->i_db[0], 0);
 		if ((error = ext2_alloc(ip, lbn, pref, fs->e2fs_bsize, cred,
-			&newb)))
+		    &newb)))
 			return (error);
 		nb = newb;
 		bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0, 0);
@@ -207,8 +211,8 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 		EXT2_LOCK(ump);
 		if (pref == 0)
 			pref = ext2_blkpref(ip, lbn, indirs[i].in_off, bap,
-						bp->b_lblkno);
-		error =  ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newb);
+			    bp->b_lblkno);
+		error = ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newb);
 		if (error) {
 			brelse(bp);
 			return (error);
@@ -245,8 +249,8 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 	 */
 	if (nb == 0) {
 		EXT2_LOCK(ump);
-		pref = ext2_blkpref(ip, lbn, indirs[i].in_off, &bap[0], 
-				bp->b_lblkno);
+		pref = ext2_blkpref(ip, lbn, indirs[i].in_off, &bap[0],
+		    bp->b_lblkno);
 		if ((error = ext2_alloc(ip,
 		    lbn, pref, (int)fs->e2fs_bsize, cred, &newb)) != 0) {
 			brelse(bp);
@@ -265,7 +269,7 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 		if (flags & IO_SYNC) {
 			bwrite(bp);
 		} else {
-		if (bp->b_bufsize == fs->e2fs_bsize)
+			if (bp->b_bufsize == fs->e2fs_bsize)
 				bp->b_flags |= B_CLUSTEROK;
 			bdwrite(bp);
 		}
@@ -275,6 +279,7 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 	brelse(bp);
 	if (flags & BA_CLRBUF) {
 		int seqcount = (flags & BA_SEQMASK) >> BA_SEQSHIFT;
+
 		if (seqcount && (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
 			error = cluster_read(vp, ip->i_size, lbn,
 			    (int)fs->e2fs_bsize, NOCRED,
@@ -293,4 +298,3 @@ ext2_balloc(struct inode *ip, e2fs_lbn_t
 	*bpp = nbp;
 	return (0);
 }
-

Modified: stable/10/sys/fs/ext2fs/ext2_bmap.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_bmap.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_bmap.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -94,7 +94,7 @@ ext4_bmapext(struct vnode *vp, int32_t b
 	struct inode *ip;
 	struct m_ext2fs *fs;
 	struct ext4_extent *ep;
-	struct ext4_extent_path path = { .ep_bp = NULL };
+	struct ext4_extent_path path = {.ep_bp = NULL};
 	daddr_t lbn;
 	int ret = 0;
 
@@ -152,7 +152,7 @@ ext2_bmaparray(struct vnode *vp, daddr_t
 	struct buf *bp;
 	struct ext2mount *ump;
 	struct mount *mp;
-	struct indir a[NIADDR+1], *ap;
+	struct indir a[NIADDR + 1], *ap;
 	daddr_t daddr;
 	e2fs_lbn_t metalbn;
 	int error, num, maxrun = 0, bsize;
@@ -169,10 +169,8 @@ ext2_bmaparray(struct vnode *vp, daddr_t
 		maxrun = mp->mnt_iosize_max / bsize - 1;
 		*runp = 0;
 	}
-
-	if (runb) {
+	if (runb)
 		*runb = 0;
-	}
 
 
 	ap = a;
@@ -188,6 +186,7 @@ ext2_bmaparray(struct vnode *vp, daddr_t
 			*bnp = -1;
 		} else if (runp) {
 			daddr_t bnb = bn;
+
 			for (++bn; bn < NDADDR && *runp < maxrun &&
 			    is_sequential(ump, ip->i_db[bn - 1], ip->i_db[bn]);
 			    ++bn, ++*runp);
@@ -202,7 +201,6 @@ ext2_bmaparray(struct vnode *vp, daddr_t
 		return (0);
 	}
 
-
 	/* Get disk address out of indirect block array */
 	daddr = ip->i_ib[ap->in_off];
 
@@ -272,7 +270,7 @@ ext2_bmaparray(struct vnode *vp, daddr_t
 	 * return a request for a zeroed out buffer if attempts are made
 	 * to read a BLK_NOCOPY or BLK_SNAP block.
 	 */
-	if ((ip->i_flags & SF_SNAPSHOT) && daddr > 0 && daddr < ump->um_seqinc){
+	if ((ip->i_flags & SF_SNAPSHOT) && daddr > 0 && daddr < ump->um_seqinc) {
 		*bnp = -1;
 		return (0);
 	}

Modified: stable/10/sys/fs/ext2fs/ext2_dir.h
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_dir.h	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_dir.h	Wed Jan  4 02:43:33 2017	(r311232)
@@ -34,7 +34,7 @@
  */
 #define	EXT2FS_MAXNAMLEN	255
 
-struct	ext2fs_direct {
+struct ext2fs_direct {
 	uint32_t e2d_ino;		/* inode number of entry */
 	uint16_t e2d_reclen;		/* length of this record */
 	uint16_t e2d_namlen;		/* length of string in e2d_name */
@@ -49,10 +49,10 @@ enum slotstatus {
 
 struct ext2fs_searchslot {
 	enum slotstatus slotstatus;
-	doff_t slotoffset;	/* offset of area with free space */
-	int slotsize;		/* size of area at slotoffset */
-	int slotfreespace;	/* amount of space free in slot */
-	int slotneeded;		/* sizeof the entry we are seeking */
+	doff_t	slotoffset;		/* offset of area with free space */
+	int	slotsize;		/* size of area at slotoffset */
+	int	slotfreespace;		/* amount of space free in slot */
+	int	slotneeded;		/* sizeof the entry we are seeking */
 };
 
 /*
@@ -61,12 +61,13 @@ struct ext2fs_searchslot {
  * bigger than 255 chars, it's safe to reclaim the extra byte for the
  * file_type field.
  */
-struct	ext2fs_direct_2 {
+struct ext2fs_direct_2 {
 	uint32_t e2d_ino;		/* inode number of entry */
 	uint16_t e2d_reclen;		/* length of this record */
-	uint8_t e2d_namlen;		/* length of string in e2d_name */
-	uint8_t e2d_type;		/* file type */
-	char e2d_name[EXT2FS_MAXNAMLEN];/* name with length<=EXT2FS_MAXNAMLEN */
+	uint8_t	e2d_namlen;		/* length of string in e2d_name */
+	uint8_t	e2d_type;		/* file type */
+	char	e2d_name[EXT2FS_MAXNAMLEN];	/* name with
+						 * length<=EXT2FS_MAXNAMLEN */
 };
 
 /*
@@ -97,5 +98,4 @@ struct	ext2fs_direct_2 {
 #define	EXT2_DIR_ROUND			(EXT2_DIR_PAD - 1)
 #define	EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
 					 ~EXT2_DIR_ROUND)
-#endif /* !_FS_EXT2FS_EXT2_DIR_H_ */
-
+#endif	/* !_FS_EXT2FS_EXT2_DIR_H_ */

Modified: stable/10/sys/fs/ext2fs/ext2_extents.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_extents.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_extents.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -129,7 +129,7 @@ ext4_ext_put_cache(struct inode *ip, str
  */
 struct ext4_extent_path *
 ext4_ext_find_extent(struct m_ext2fs *fs, struct inode *ip,
-		     daddr_t lbn, struct ext4_extent_path *path)
+    daddr_t lbn, struct ext4_extent_path *path)
 {
 	struct ext4_extent_header *ehp;
 	uint16_t i;
@@ -156,7 +156,7 @@ ext4_ext_find_extent(struct m_ext2fs *fs
 			path->ep_bp = NULL;
 		}
 		error = bread(ip->i_devvp, fsbtodb(fs, nblk), size, NOCRED,
-			    &path->ep_bp);
+		    &path->ep_bp);
 		if (error) {
 			brelse(path->ep_bp);
 			path->ep_bp = NULL;

Modified: stable/10/sys/fs/ext2fs/ext2_extents.h
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_extents.h	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_extents.h	Wed Jan  4 02:43:33 2017	(r311232)
@@ -61,19 +61,19 @@ struct ext4_extent_index {
  * Extent tree header.
  */
 struct ext4_extent_header {
-	uint16_t eh_magic;	/* magic number: 0xf30a */
-	uint16_t eh_ecount;	/* number of valid entries */
-	uint16_t eh_max;	/* capacity of store in entries */
-	uint16_t eh_depth;	/* the depth of extent tree */
-	uint32_t eh_gen;	/* generation of extent tree */
+	uint16_t eh_magic;		/* magic number: 0xf30a */
+	uint16_t eh_ecount;		/* number of valid entries */
+	uint16_t eh_max;		/* capacity of store in entries */
+	uint16_t eh_depth;		/* the depth of extent tree */
+	uint32_t eh_gen;		/* generation of extent tree */
 };
 
 /*
  * Save cached extent.
  */
 struct ext4_extent_cache {
-	daddr_t	ec_start;	/* extent start */
-	uint32_t ec_blk;	/* logical block */
+	daddr_t	ec_start;		/* extent start */
+	uint32_t ec_blk;		/* logical block */
 	uint32_t ec_len;
 	uint32_t ec_type;
 };
@@ -93,7 +93,8 @@ struct inode;
 struct m_ext2fs;
 int	ext4_ext_in_cache(struct inode *, daddr_t, struct ext4_extent *);
 void	ext4_ext_put_cache(struct inode *, struct ext4_extent *, int);
-struct ext4_extent_path *ext4_ext_find_extent(struct m_ext2fs *fs,
+struct ext4_extent_path *
+ext4_ext_find_extent(struct m_ext2fs *fs,
     struct inode *, daddr_t, struct ext4_extent_path *);
 
-#endif /* !_FS_EXT2FS_EXT2_EXTENTS_H_ */
+#endif	/* !_FS_EXT2FS_EXT2_EXTENTS_H_ */

Modified: stable/10/sys/fs/ext2fs/ext2_extern.h
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_extern.h	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_extern.h	Wed Jan  4 02:43:33 2017	(r311232)
@@ -110,4 +110,4 @@ int	ext2_search_dirblock(struct inode *,
 extern struct vop_vector ext2_vnodeops;
 extern struct vop_vector ext2_fifoops;
 
-#endif /* !_FS_EXT2FS_EXT2_EXTERN_H_ */
+#endif	/* !_FS_EXT2FS_EXT2_EXTERN_H_ */

Modified: stable/10/sys/fs/ext2fs/ext2_hash.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_hash.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_hash.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -192,7 +192,7 @@ ext2_legacy_hash(const char *name, int l
 
 static void
 ext2_prep_hashbuf(const char *src, int slen, uint32_t *dst, int dlen,
-	     int unsigned_char)
+    int unsigned_char)
 {
 	uint32_t padding = slen | (slen << 8) | (slen << 16) | (slen << 24);
 	uint32_t buf_val;
@@ -240,8 +240,8 @@ ext2_prep_hashbuf(const char *src, int s
 
 int
 ext2_htree_hash(const char *name, int len,
-		uint32_t *hash_seed, int hash_version,
-		uint32_t *hash_major, uint32_t *hash_minor)
+    uint32_t *hash_seed, int hash_version,
+    uint32_t *hash_major, uint32_t *hash_minor)
 {
 	uint32_t hash[4];
 	uint32_t data[8];

Modified: stable/10/sys/fs/ext2fs/ext2_htree.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_htree.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_htree.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -98,7 +98,7 @@ ext2_htree_has_idx(struct inode *ip)
 
 static int
 ext2_htree_check_next(struct inode *ip, uint32_t hash, const char *name,
-		struct ext2fs_htree_lookup_info *info)
+    struct ext2fs_htree_lookup_info *info)
 {
 	struct vnode *vp = ITOV(ip);
 	struct ext2fs_htree_lookup_level *level;
@@ -195,6 +195,7 @@ ext2_htree_release(struct ext2fs_htree_l
 
 	for (i = 0; i < info->h_levels_num; i++) {
 		struct buf *bp = info->h_levels[i].h_bp;
+
 		if (bp != NULL)
 			brelse(bp);
 	}
@@ -224,8 +225,8 @@ ext2_htree_node_limit(struct inode *ip)
 
 static int
 ext2_htree_find_leaf(struct inode *ip, const char *name, int namelen,
-		     uint32_t *hash, uint8_t *hash_ver,
-		     struct ext2fs_htree_lookup_info *info)
+    uint32_t *hash, uint8_t *hash_ver,
+    struct ext2fs_htree_lookup_info *info)
 {
 	struct vnode *vp;
 	struct ext2fs *fs;
@@ -317,9 +318,9 @@ error:
  */
 int
 ext2_htree_lookup(struct inode *ip, const char *name, int namelen,
-		  struct buf **bpp, int *entryoffp, doff_t *offp,
-		  doff_t *prevoffp, doff_t *endusefulp,
-		  struct ext2fs_searchslot *ss)
+    struct buf **bpp, int *entryoffp, doff_t *offp,
+    doff_t *prevoffp, doff_t *endusefulp,
+    struct ext2fs_searchslot *ss)
 {
 	struct vnode *vp;
 	struct ext2fs_htree_lookup_info info;
@@ -386,7 +387,7 @@ ext2_htree_lookup(struct inode *ip, cons
 
 static int
 ext2_htree_append_block(struct vnode *vp, char *data,
-			struct componentname *cnp, uint32_t blksize)
+    struct componentname *cnp, uint32_t blksize)
 {
 	struct iovec aiov;
 	struct uio auio;
@@ -419,6 +420,7 @@ ext2_htree_writebuf(struct ext2fs_htree_
 
 	for (i = 0; i < info->h_levels_num; i++) {
 		struct buf *bp = info->h_levels[i].h_bp;
+
 		error = bwrite(bp);
 		if (error)
 			return (error);
@@ -429,7 +431,7 @@ ext2_htree_writebuf(struct ext2fs_htree_
 
 static void
 ext2_htree_insert_entry_to_level(struct ext2fs_htree_lookup_level *level,
-				 uint32_t hash, uint32_t blk)
+    uint32_t hash, uint32_t blk)
 {
 	struct ext2fs_htree_entry *target;
 	int entries_num;
@@ -449,7 +451,7 @@ ext2_htree_insert_entry_to_level(struct 
  */
 static void
 ext2_htree_insert_entry(struct ext2fs_htree_lookup_info *info,
-			uint32_t hash, uint32_t blk)
+    uint32_t hash, uint32_t blk)
 {
 	struct ext2fs_htree_lookup_level *level;
 
@@ -481,8 +483,8 @@ ext2_htree_cmp_sort_entry(const void *e1
  */
 static void
 ext2_append_entry(char *block, uint32_t blksize,
-		  struct ext2fs_direct_2 *last_entry,
-		  struct ext2fs_direct_2 *new_entry)
+    struct ext2fs_direct_2 *last_entry,
+    struct ext2fs_direct_2 *new_entry)
 {
 	uint16_t entry_len;
 
@@ -498,8 +500,8 @@ ext2_append_entry(char *block, uint32_t 
  */
 static int
 ext2_htree_split_dirblock(char *block1, char *block2, uint32_t blksize,
-			  uint32_t *hash_seed, uint8_t hash_version,
-			  uint32_t *split_hash, struct ext2fs_direct_2 *entry)
+    uint32_t *hash_seed, uint8_t hash_version,
+    uint32_t *split_hash, struct ext2fs_direct_2 *entry)
 {
 	int entry_cnt = 0;
 	int size = 0;
@@ -585,7 +587,7 @@ ext2_htree_split_dirblock(char *block1, 
 		offset += ep->e2d_reclen;
 		if (ep->e2d_ino) {
 			last = (struct ext2fs_direct_2 *)
-			   ((char *)last + entry_len);
+			    ((char *)last + entry_len);
 			entry_len = EXT2_DIR_REC_LEN(ep->e2d_namlen);
 			memcpy((void *)last, (void *)ep, entry_len);
 			last->e2d_reclen = entry_len;
@@ -616,7 +618,7 @@ ext2_htree_split_dirblock(char *block1, 
  */
 int
 ext2_htree_create_index(struct vnode *vp, struct componentname *cnp,
-			struct ext2fs_direct_2 *new_entry)
+    struct ext2fs_direct_2 *new_entry)
 {
 	struct buf *bp = NULL;
 	struct inode *dp;
@@ -721,7 +723,7 @@ out1:
  */
 int
 ext2_htree_add_entry(struct vnode *dvp, struct ext2fs_direct_2 *entry,
-		     struct componentname *cnp)
+    struct componentname *cnp)
 {
 	struct ext2fs_htree_entry *entries, *leaf_node;
 	struct ext2fs_htree_lookup_info info;
@@ -747,7 +749,7 @@ ext2_htree_add_entry(struct vnode *dvp, 
 	fs = m_fs->e2fs;
 	blksize = m_fs->e2fs_bsize;
 
-	if (ip->i_count != 0) 
+	if (ip->i_count != 0)
 		return ext2_add_entry(dvp, entry);
 
 	/* Target directory block is full, split it */
@@ -807,6 +809,7 @@ ext2_htree_add_entry(struct vnode *dvp, 
 
 			if (info.h_levels[1].h_entry >= entries + src_ent_num) {
 				struct buf *tmp = info.h_levels[1].h_bp;
+
 				info.h_levels[1].h_bp = dst_bp;
 				dst_bp = tmp;
 

Modified: stable/10/sys/fs/ext2fs/ext2_inode.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_inode.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_inode.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -81,11 +81,11 @@ ext2_update(struct vnode *vp, int waitfo
 		return (0);
 	ip->i_flag &= ~(IN_LAZYACCESS | IN_LAZYMOD | IN_MODIFIED);
 	fs = ip->i_e2fs;
-	if(fs->e2fs_ronly)
+	if (fs->e2fs_ronly)
 		return (0);
 	if ((error = bread(ip->i_devvp,
 	    fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
-		(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
+	    (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
 		brelse(bp);
 		return (error);
 	}
@@ -130,10 +130,10 @@ ext2_truncate(struct vnode *vp, off_t le
 	bo = &ovp->v_bufobj;
 #endif
 
-	ASSERT_VOP_LOCKED(vp, "ext2_truncate");	
+	ASSERT_VOP_LOCKED(vp, "ext2_truncate");
 
 	if (length < 0)
-	    return (EINVAL);
+		return (EINVAL);
 
 	if (ovp->v_type == VLNK &&
 	    oip->i_size < ovp->v_mount->mnt_maxsymlinklen) {
@@ -345,7 +345,7 @@ done:
 	    bo->bo_clean.bv_cnt != 0))
 		panic("itrunc3");
 	BO_UNLOCK(bo);
-#endif /* INVARIANTS */
+#endif	/* INVARIANTS */
 	/*
 	 * Put back the real size.
 	 */
@@ -418,12 +418,11 @@ ext2_indirtrunc(struct inode *ip, daddr_
 		*countp = 0;
 		return (error);
 	}
-
 	bap = (e2fs_daddr_t *)bp->b_data;
 	copy = malloc(fs->e2fs_bsize, M_TEMP, M_WAITOK);
 	bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->e2fs_bsize);
 	bzero((caddr_t)&bap[last + 1],
-	  (NINDIR(fs) - (last + 1)) * sizeof(e2fs_daddr_t));
+	    (NINDIR(fs) - (last + 1)) * sizeof(e2fs_daddr_t));
 	if (last == -1)
 		bp->b_flags |= B_INVAL;
 	if (DOINGASYNC(vp)) {

Modified: stable/10/sys/fs/ext2fs/ext2_inode_cnv.c
==============================================================================
--- stable/10/sys/fs/ext2fs/ext2_inode_cnv.c	Wed Jan  4 02:42:17 2017	(r311231)
+++ stable/10/sys/fs/ext2fs/ext2_inode_cnv.c	Wed Jan  4 02:43:33 2017	(r311232)
@@ -49,17 +49,17 @@ ext2_print_inode(struct inode *in)
 	struct ext4_extent_header *ehp;
 	struct ext4_extent *ep;
 
-	printf( "Inode: %5ju", (uintmax_t)in->i_number);
-	printf( /* "Inode: %5d" */
-		" Type: %10s Mode: 0x%o Flags: 0x%x  Version: %d\n",
-		"n/a", in->i_mode, in->i_flags, in->i_gen);
+	printf("Inode: %5ju", (uintmax_t)in->i_number);
+	printf(	/* "Inode: %5d" */
+	    " Type: %10s Mode: 0x%o Flags: 0x%x  Version: %d\n",
+	    "n/a", in->i_mode, in->i_flags, in->i_gen);
 	printf("User: %5u Group: %5u  Size: %ju\n",
 	    in->i_uid, in->i_gid, (uintmax_t)in->i_size);
 	printf("Links: %3d Blockcount: %ju\n",
 	    in->i_nlink, (uintmax_t)in->i_blocks);
-	printf( "ctime: 0x%x", in->i_ctime);
-	printf( "atime: 0x%x", in->i_atime);
-	printf( "mtime: 0x%x", in->i_mtime);
+	printf("ctime: 0x%x", in->i_ctime);
+	printf("atime: 0x%x", in->i_atime);
+	printf("mtime: 0x%x", in->i_mtime);
 	if (E2DI_HAS_XTIME(in))
 		printf("crtime %#x ", in->i_birthtime);
 	printf("BLOCKS:");
@@ -87,11 +87,12 @@ ext2_ei2i(struct ext2fs_dinode *ei, stru
 	int i;
 
 	ip->i_nlink = ei->e2di_nlink;
-	/* Godmar thinks - if the link count is zero, then the inode is
-	   unused - according to ext2 standards. Ufs marks this fact
-	   by setting i_mode to zero - why ?
-	   I can see that this might lead to problems in an undelete.
-	*/
+	/*
+	 * Godmar thinks - if the link count is zero, then the inode is
+	 * unused - according to ext2 standards. Ufs marks this fact by
+	 * setting i_mode to zero - why ? I can see that this might lead to
+	 * problems in an undelete.
+	 */
 	ip->i_mode = ei->e2di_nlink ? ei->e2di_mode : 0;
 	ip->i_size = ei->e2di_size;
 	if (S_ISREG(ip->i_mode))
@@ -116,15 +117,15 @@ ext2_ei2i(struct ext2fs_dinode *ei, stru
 	if (E2DI_HAS_HUGE_FILE(ip)) {
 		ip->i_blocks |= (uint64_t)ei->e2di_nblock_high << 32;
 		if (ei->e2di_flags & EXT4_HUGE_FILE)
-		      ip->i_blocks = fsbtodb(ip->i_e2fs, ip->i_blocks);
+			ip->i_blocks = fsbtodb(ip->i_e2fs, ip->i_blocks);
 	}
 	ip->i_gen = ei->e2di_gen;
 	ip->i_uid = ei->e2di_uid;
 	ip->i_gid = ei->e2di_gid;
 	/* XXX use memcpy */
-	for(i = 0; i < NDADDR; i++)
+	for (i = 0; i < NDADDR; i++)
 		ip->i_db[i] = ei->e2di_blocks[i];
-	for(i = 0; i < NIADDR; i++)
+	for (i = 0; i < NIADDR; i++)
 		ip->i_ib[i] = ei->e2di_blocks[EXT2_NDIR_BLOCKS + i];
 }
 
@@ -138,9 +139,9 @@ ext2_i2ei(struct inode *ip, struct ext2f
 
 	ei->e2di_mode = ip->i_mode;
 	ei->e2di_nlink = ip->i_nlink;
-	/* 
-	   Godmar thinks: if dtime is nonzero, ext2 says this inode
-	   has been deleted, this would correspond to a zero link count
+	/*
+	 * Godmar thinks: if dtime is nonzero, ext2 says this inode has been
+	 * deleted, this would correspond to a zero link count
 	 */
 	ei->e2di_dtime = ei->e2di_nlink ? 0 : ip->i_mtime;
 	ei->e2di_size = ip->i_size;
@@ -157,19 +158,19 @@ ext2_i2ei(struct inode *ip, struct ext2f
 		ei->e2di_crtime_extra = NSEC_TO_XTIME(ip->i_birthnsec);
 	}
 	ei->e2di_flags = 0;
-	ei->e2di_flags |= (ip->i_flags & SF_APPEND) ? EXT2_APPEND: 0;
-	ei->e2di_flags |= (ip->i_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE: 0;
-	ei->e2di_flags |= (ip->i_flags & UF_NODUMP) ? EXT2_NODUMP: 0;

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***