 @@ -1,14 +1,14 @@
-/* $NetBSD: dir.c,v 1.28 2013/06/08 02:11:11 dholland Exp $	 */
+/* $NetBSD: dir.c,v 1.29 2013/06/08 02:12:56 dholland Exp $	 */
 /*
  * Copyright (c) 1980, 1986, 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.
 @@ -45,56 +45,56 @@
 #include <stdlib.h>
 #include <string.h>
 #include "bufcache.h"
 #include "vnode.h"
 #include "lfs_user.h"
 #include "fsck.h"
 #include "fsutil.h"
 #include "extern.h"
 const char *lfname = "lost+found";
 int lfmode = 01700;
-struct dirtemplate emptydir = {
+struct lfs_dirtemplate emptydir = {
 	.dot_ino = 0,
 	.dot_reclen = DIRBLKSIZ,
 };
-struct dirtemplate dirhead = {
+struct lfs_dirtemplate dirhead = {
 	.dot_ino = 0,
 	.dot_reclen = 12,
-	.dot_type = DT_DIR,
+	.dot_type = LFS_DT_DIR,
 	.dot_namlen = 1,
 	.dot_name = ".",
 	.dotdot_ino = 0,
 	.dotdot_reclen = DIRBLKSIZ - 12,
-	.dotdot_type = DT_DIR,
+	.dotdot_type = LFS_DT_DIR,
 	.dotdot_namlen = 2,
 	.dotdot_name = ".."
 };
-struct odirtemplate odirhead = {
+struct lfs_odirtemplate odirhead = {
 	.dot_ino = 0,
 	.dot_reclen = 12,
 	.dot_namlen = 1,
 	.dot_name = ".",
 	.dotdot_ino = 0,
 	.dotdot_reclen = DIRBLKSIZ - 12,
 	.dotdot_namlen = 2,
 	.dotdot_name = ".."
 };
 static int expanddir(struct uvnode *, struct ulfs1_dinode *, char *);
 static void freedir(ino_t, ino_t);
-static struct direct *fsck_readdir(struct uvnode *, struct inodesc *);
+static struct lfs_direct *fsck_readdir(struct uvnode *, struct inodesc *);
 static int lftempname(char *, ino_t);
 static int mkentry(struct inodesc *);
 static int chgino(struct inodesc *);
 /*
  * Propagate connected state through the tree.
  */
 void
 propagate(void)
+{
 	struct inoinfo **inpp, *inp, *pinp;
 	struct inoinfo **inpend;
 @@ -121,142 +121,142 @@ propagate(void)
 		else if (inp->i_sibling)
 			inp = inp->i_sibling;
 		else
 			inp = inp->i_parentp;
+	}
+}
 /*
  * Scan each entry in a directory block.
  */
 int
 dirscan(struct inodesc *idesc)
+{
-	struct direct *dp;
+	struct lfs_direct *dp;
 	struct ubuf *bp;
 	int dsize, n;
 	long blksiz;
 	char dbuf[DIRBLKSIZ];
 	struct uvnode *vp;
 	if (idesc->id_type != DATA)
 		errexit("wrong type to dirscan %d", idesc->id_type);
 	if (idesc->id_entryno == 0 &&
 	    (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
 		idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
 	blksiz = idesc->id_numfrags * fs->lfs_fsize;
 	if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
 		idesc->id_filesize -= blksiz;
 		return (SKIP);
+	}
 	idesc->id_loc = 0;
 	vp = vget(fs, idesc->id_number);
 	for (dp = fsck_readdir(vp, idesc); dp != NULL;
 	    dp = fsck_readdir(vp, idesc)) {
 		dsize = dp->d_reclen;
 		memcpy(dbuf, dp, (size_t) dsize);
-		idesc->id_dirp = (struct direct *) dbuf;
+		idesc->id_dirp = (struct lfs_direct *) dbuf;
 		if ((n = (*idesc->id_func) (idesc)) & ALTERED) {
 			bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
 			memcpy(bp->b_data + idesc->id_loc - dsize, dbuf,
 			    (size_t) dsize);
 			VOP_BWRITE(bp);
 			sbdirty();
+		}
 		if (n & STOP)
 			return (n);
+	}
 	return (idesc->id_filesize > 0 ? KEEPON : STOP);
+}
 /*
  * get next entry in a directory.
  */
-static struct direct *
+static struct lfs_direct *
 fsck_readdir(struct uvnode *vp, struct inodesc *idesc)
+{
-	struct direct *dp, *ndp;
+	struct lfs_direct *dp, *ndp;
 	struct ubuf *bp;
 	long size, blksiz, fix, dploc;
 	blksiz = idesc->id_numfrags * fs->lfs_fsize;
 	bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
 	if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
 	    idesc->id_loc < blksiz) {
-		dp = (struct direct *) (bp->b_data + idesc->id_loc);
+		dp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 		if (dircheck(idesc, dp))
 			goto dpok;
 		brelse(bp, 0);
 		if (idesc->id_fix == IGNORE)
 			return (0);
 		fix = dofix(idesc, "DIRECTORY CORRUPTED");
 		bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
-		dp = (struct direct *) (bp->b_data + idesc->id_loc);
+		dp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 		dp->d_reclen = DIRBLKSIZ;
 		dp->d_ino = 0;
 		dp->d_type = 0;
 		dp->d_namlen = 0;
 		dp->d_name[0] = '\0';
 		if (fix)
 			VOP_BWRITE(bp);
 		else
 			brelse(bp, 0);
 		idesc->id_loc += DIRBLKSIZ;
 		idesc->id_filesize -= DIRBLKSIZ;
 		return (dp);
+	}
 dpok:
 	if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz) {
 		brelse(bp, 0);
 		return NULL;
+	}
 	dploc = idesc->id_loc;
-	dp = (struct direct *) (bp->b_data + dploc);
+	dp = (struct lfs_direct *) (bp->b_data + dploc);
 	idesc->id_loc += dp->d_reclen;
 	idesc->id_filesize -= dp->d_reclen;
 	if ((idesc->id_loc % DIRBLKSIZ) == 0) {
 		brelse(bp, 0);
 		return dp;
+	}
-	ndp = (struct direct *) (bp->b_data + idesc->id_loc);
+	ndp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 	if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
 	    dircheck(idesc, ndp) == 0) {
 		brelse(bp, 0);
 		size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
 		idesc->id_loc += size;
 		idesc->id_filesize -= size;
 		if (idesc->id_fix == IGNORE)
 			return 0;
 		fix = dofix(idesc, "DIRECTORY CORRUPTED");
 		bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
-		dp = (struct direct *) (bp->b_data + dploc);
+		dp = (struct lfs_direct *) (bp->b_data + dploc);
 		dp->d_reclen += size;
 		if (fix)
 			VOP_BWRITE(bp);
 		else
 			brelse(bp, 0);
 	} else
 		brelse(bp, 0);
 	return (dp);
+}
 /*
  * Verify that a directory entry is valid.
  * This is a superset of the checks made in the kernel.
  */
 int
-dircheck(struct inodesc *idesc, struct direct *dp)
+dircheck(struct inodesc *idesc, struct lfs_direct *dp)
+{
 	int size;
 	char *cp;
 	u_char namlen, type;
 	int spaceleft;
 	spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
 	if (dp->d_ino >= maxino ||
 	    dp->d_reclen == 0 ||
 	    dp->d_reclen > spaceleft ||
 	    (dp->d_reclen & 0x3) != 0) {
 		pwarn("ino too large, reclen=0, reclen>space, or reclen&3!=0\n");
 		pwarn("dp->d_ino = 0x%x\tdp->d_reclen = 0x%x\n",
 @@ -348,53 +348,53 @@ adjust(struct inodesc *idesc, short lcnt
+			}
 			printf(" (ADJUSTED)\n");
+		}
 		if (preen || reply("ADJUST") == 1) {
 			dp->di_nlink -= lcnt;
 			inodirty(VTOI(vp));
+		}
+	}
+}
 static int
 mkentry(struct inodesc *idesc)
+{
-	struct direct *dirp = idesc->id_dirp;
+	struct lfs_direct *dirp = idesc->id_dirp;
-	struct direct newent;
+	struct lfs_direct newent;
 	int newlen, oldlen;
 	newent.d_namlen = strlen(idesc->id_name);
 	newlen = DIRSIZ(0, &newent, 0);
 	if (dirp->d_ino != 0)
 		oldlen = DIRSIZ(0, dirp, 0);
 	else
 		oldlen = 0;
 	if (dirp->d_reclen - oldlen < newlen)
 		return (KEEPON);
 	newent.d_reclen = dirp->d_reclen - oldlen;
 	dirp->d_reclen = oldlen;
-	dirp = (struct direct *) (((char *) dirp) + oldlen);
+	dirp = (struct lfs_direct *) (((char *) dirp) + oldlen);
 	dirp->d_ino = idesc->id_parent;	/* ino to be entered is in id_parent */
 	dirp->d_reclen = newent.d_reclen;
 	dirp->d_type = typemap[idesc->id_parent];
 	dirp->d_namlen = newent.d_namlen;
 	memcpy(dirp->d_name, idesc->id_name, (size_t) dirp->d_namlen + 1);
 	return (ALTERED | STOP);
+}
 static int
 chgino(struct inodesc *idesc)
+{
-	struct direct *dirp = idesc->id_dirp;
+	struct lfs_direct *dirp = idesc->id_dirp;
 	if (memcmp(dirp->d_name, idesc->id_name, (int) dirp->d_namlen + 1))
 		return (KEEPON);
 	dirp->d_ino = idesc->id_parent;
 	dirp->d_type = typemap[idesc->id_parent];
 	return (ALTERED | STOP);
+}
 int
 linkup(ino_t orphan, ino_t parentdir)
+{
 	struct ulfs1_dinode *dp;
 	int lostdir;
 @@ -609,42 +609,42 @@ bad:
 	return (0);
+}
 /*
  * allocate a new directory
  */
 int
 allocdir(ino_t parent, ino_t request, int mode)
+{
 	ino_t ino;
 	char *cp;
 	struct ulfs1_dinode *dp;
 	struct ubuf *bp;
-	struct dirtemplate *dirp;
+	struct lfs_dirtemplate *dirp;
 	struct uvnode *vp;
 	ino = allocino(request, LFS_IFDIR | mode);
 	dirp = &dirhead;
 	dirp->dot_ino = ino;
 	dirp->dotdot_ino = parent;
 	vp = vget(fs, ino);
 	dp = VTOD(vp);
 	bread(vp, dp->di_db[0], fs->lfs_fsize, NOCRED, 0, &bp);
 	if (bp->b_flags & B_ERROR) {
 		brelse(bp, 0);
 		freeino(ino);
 		return (0);
+	}
-	memcpy(bp->b_data, dirp, sizeof(struct dirtemplate));
+	memcpy(bp->b_data, dirp, sizeof(struct lfs_dirtemplate));
 	for (cp = &bp->b_data[DIRBLKSIZ];
 	    cp < &bp->b_data[fs->lfs_fsize];
 	    cp += DIRBLKSIZ)
 		memcpy(cp, &emptydir, sizeof emptydir);
 	VOP_BWRITE(bp);
 	dp->di_nlink = 2;
 	inodirty(VTOI(vp));
 	if (ino == ULFS_ROOTINO) {
 		lncntp[ino] = dp->di_nlink;
 		cacheino(dp, ino);
 		return (ino);
+	}
 	if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) {

 @@ -1,14 +1,14 @@
-/* $NetBSD: pass2.c,v 1.20 2013/06/08 02:11:11 dholland Exp $	 */
+/* $NetBSD: pass2.c,v 1.21 2013/06/08 02:12:56 dholland Exp $	 */
 /*
  * Copyright (c) 1980, 1986, 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.
 @@ -42,27 +42,27 @@
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "bufcache.h"
 #include "vnode.h"
 #include "lfs_user.h"
 #include "fsck.h"
 #include "fsutil.h"
 #include "extern.h"
-#define MINDIRSIZE	(sizeof (struct dirtemplate))
+#define MINDIRSIZE	(sizeof (struct lfs_dirtemplate))
 static int pass2check(struct inodesc *);
 static int blksort(const void *, const void *);
 void
 pass2(void)
+{
 	struct ulfs1_dinode *dp;
 	struct uvnode *vp;
 	struct inoinfo **inpp, *inp;
 	struct inoinfo **inpend;
 	struct inodesc curino;
 	struct ulfs1_dinode dino;
 @@ -105,27 +105,27 @@ pass2(void)
 		dp = VTOD(vp);
 		dp->di_mode &= ~LFS_IFMT;
 		dp->di_mode |= LFS_IFDIR;
 		inodirty(VTOI(vp));
 		break;
 	case DSTATE:
 		break;
 	default:
 		errx(EEXIT, "BAD STATE %d FOR ROOT INODE\n", statemap[ULFS_ROOTINO]);
+	}
 	statemap[ULFS_WINO] = FSTATE;
-	typemap[ULFS_WINO] = DT_WHT;
+	typemap[ULFS_WINO] = LFS_DT_WHT;
 	/*
 	 * Sort the directory list into disk block order.
 	 */
 	qsort((char *) inpsort, (size_t) inplast, sizeof *inpsort, blksort);
 	/*
 	 * Check the integrity of each directory.
 	 */
 	memset(&curino, 0, sizeof(struct inodesc));
 	curino.id_type = DATA;
 	curino.id_func = pass2check;
 	inpend = &inpsort[inplast];
 	for (inpp = inpsort; inpp < inpend; inpp++) {
 		inp = *inpp;
 @@ -191,109 +191,109 @@ pass2(void)
 		lncntp[inp->i_parent]--;
 		inp->i_dotdot = inp->i_parent;
 		(void) changeino(inp->i_number, "..", inp->i_parent);
+	}
 	/*
 	 * Mark all the directories that can be found from the root.
 	 */
 	propagate();
+}
 static int
 pass2check(struct inodesc * idesc)
+{
-	struct direct *dirp = idesc->id_dirp;
+	struct lfs_direct *dirp = idesc->id_dirp;
 	struct inoinfo *inp;
 	int n, entrysize, ret = 0;
 	struct ulfs1_dinode *dp;
 	const char *errmsg;
-	struct direct proto;
+	struct lfs_direct proto;
 	char namebuf[MAXPATHLEN + 1];
 	char pathbuf[MAXPATHLEN + 1];
 	/*
 	 * check for "."
 	 */
 	if (idesc->id_entryno != 0)
 		goto chk1;
 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
 		if (dirp->d_ino != idesc->id_number) {
 			direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
 			dirp->d_ino = idesc->id_number;
 			if (reply("FIX") == 1)
 				ret |= ALTERED;
+		}
-		if (dirp->d_type != DT_DIR) {
+		if (dirp->d_type != LFS_DT_DIR) {
 			direrror(idesc->id_number, "BAD TYPE VALUE FOR '.'");
-			dirp->d_type = DT_DIR;
+			dirp->d_type = LFS_DT_DIR;
 			if (reply("FIX") == 1)
 				ret |= ALTERED;
+		}
 		goto chk1;
+	}
 	direrror(idesc->id_number, "MISSING '.'");
 	proto.d_ino = idesc->id_number;
-	proto.d_type = DT_DIR;
+	proto.d_type = LFS_DT_DIR;
 	proto.d_namlen = 1;
 	(void) strlcpy(proto.d_name, ".", sizeof(proto.d_name));
 	entrysize = DIRSIZ(0, &proto, 0);
 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
 		pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
 		    dirp->d_name);
 	} else if (dirp->d_reclen < entrysize) {
 		pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
 	} else if (dirp->d_reclen < 2 * entrysize) {
 		proto.d_reclen = dirp->d_reclen;
 		memcpy(dirp, &proto, (size_t) entrysize);
 		if (reply("FIX") == 1)
 			ret |= ALTERED;
 	} else {
 		n = dirp->d_reclen - entrysize;
 		proto.d_reclen = entrysize;
 		memcpy(dirp, &proto, (size_t) entrysize);
 		idesc->id_entryno++;
 		lncntp[dirp->d_ino]--;
-		dirp = (struct direct *) ((char *) (dirp) + entrysize);
+		dirp = (struct lfs_direct *) ((char *) (dirp) + entrysize);
 		memset(dirp, 0, (size_t) n);
 		dirp->d_reclen = n;
 		if (reply("FIX") == 1)
 			ret |= ALTERED;
+	}
 chk1:
 	if (idesc->id_entryno > 1)
 		goto chk2;
 	inp = getinoinfo(idesc->id_number);
 	proto.d_ino = inp->i_parent;
-	proto.d_type = DT_DIR;
+	proto.d_type = LFS_DT_DIR;
 	proto.d_namlen = 2;
 	(void) strlcpy(proto.d_name, "..", sizeof(proto.d_name));
 	entrysize = DIRSIZ(0, &proto, 0);
 	if (idesc->id_entryno == 0) {
 		n = DIRSIZ(0, dirp, 0);
 		if (dirp->d_reclen < n + entrysize)
 			goto chk2;
 		proto.d_reclen = dirp->d_reclen - n;
 		dirp->d_reclen = n;
 		idesc->id_entryno++;
 		lncntp[dirp->d_ino]--;
-		dirp = (struct direct *) ((char *) (dirp) + n);
+		dirp = (struct lfs_direct *) ((char *) (dirp) + n);
 		memset(dirp, 0, (size_t) proto.d_reclen);
 		dirp->d_reclen = proto.d_reclen;
+	}
 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
 		inp->i_dotdot = dirp->d_ino;
-		if (dirp->d_type != DT_DIR) {
+		if (dirp->d_type != LFS_DT_DIR) {
 			direrror(idesc->id_number, "BAD TYPE VALUE FOR '..'");
-			dirp->d_type = DT_DIR;
+			dirp->d_type = LFS_DT_DIR;
 			if (reply("FIX") == 1)
 				ret |= ALTERED;
+		}
 		goto chk2;
+	}
 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
 		fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
 		pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
 		    dirp->d_name);
 		inp->i_dotdot = (ino_t) - 1;
 	} else if (dirp->d_reclen < entrysize) {
 		fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
 		pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
 @@ -331,38 +331,38 @@ chk2:
 			dirp->d_ino = 0;
 			if (reply("FIX") == 1)
 				ret |= ALTERED;
 			return (KEEPON | ret);
+		}
+	}
 	idesc->id_entryno++;
 	n = 0;
 	if (dirp->d_ino >= maxino) {
 		fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE");
 		n = reply("REMOVE");
 	} else if (dirp->d_ino == LFS_IFILE_INUM &&
 	    idesc->id_number == ULFS_ROOTINO) {
-		if (dirp->d_type != DT_REG) {
+		if (dirp->d_type != LFS_DT_REG) {
 			fileerror(idesc->id_number, dirp->d_ino,
 			    "BAD TYPE FOR IFILE");
-			dirp->d_type = DT_REG;
+			dirp->d_type = LFS_DT_REG;
 			if (reply("FIX") == 1)
 				ret |= ALTERED;
+		}
-	} else if (((dirp->d_ino == ULFS_WINO && (dirp->d_type != DT_WHT)) ||
+	} else if (((dirp->d_ino == ULFS_WINO && (dirp->d_type != LFS_DT_WHT)) ||
-		(dirp->d_ino != ULFS_WINO && dirp->d_type == DT_WHT))) {
+		(dirp->d_ino != ULFS_WINO && dirp->d_type == LFS_DT_WHT))) {
 		fileerror(idesc->id_number, dirp->d_ino, "BAD WHITEOUT ENTRY");
 		dirp->d_ino = ULFS_WINO;
-		dirp->d_type = DT_WHT;
+		dirp->d_type = LFS_DT_WHT;
 		if (reply("FIX") == 1)
 			ret |= ALTERED;
 	} else {
 again:
 		switch (statemap[dirp->d_ino]) {
 		case USTATE:
 			if (idesc->id_entryno <= 2)
 				break;
 			fileerror(idesc->id_number, dirp->d_ino, "UNALLOCATED");
 			n = reply("REMOVE");
 			break;
 		case DCLEAR:

 @@ -1,14 +1,14 @@
-/*	$NetBSD: make_lfs.c,v 1.24 2013/06/08 02:11:11 dholland Exp $	*/
+/*	$NetBSD: make_lfs.c,v 1.25 2013/06/08 02:12:56 dholland Exp $	*/
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * 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.
 @@ -52,27 +52,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)lfs.c	8.5 (Berkeley) 5/24/95";
 #else
-__RCSID("$NetBSD: make_lfs.c,v 1.24 2013/06/08 02:11:11 dholland Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.25 2013/06/08 02:12:56 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <sys/disk.h>
 #include <sys/time.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 /* Override certain things to make <ufs/lfs/lfs.h> work */
 #define _SYS_VNODE_H_ /* XXX */
 # undef simple_lock
 # define simple_lock(x)
 @@ -171,45 +171,45 @@ static struct lfs lfs_default =  {
 		/* dlfs_inodefmt */     LFS_44INODEFMT,
 		/* dlfs_interleave */   0,
 		/* dlfs_ident */        0,
 		/* dlfs_fsbtodb */      0,
 		/* dlfs_resvseg */      0,
 		/* dlfs_pad */ 		{ 0 },
 		/* dlfs_cksum */	0
 	},
 };
 #define	UMASK	0755
-struct direct lfs_root_dir[] = {
+struct lfs_direct lfs_root_dir[] = {
-	{ ULFS_ROOTINO, sizeof(struct direct), DT_DIR, 1, "."},
+	{ ULFS_ROOTINO, sizeof(struct lfs_direct), LFS_DT_DIR, 1, "."},
-	{ ULFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".."},
+	{ ULFS_ROOTINO, sizeof(struct lfs_direct), LFS_DT_DIR, 2, ".."},
-	/* { LFS_IFILE_INUM, sizeof(struct direct), DT_REG, 5, "ifile"}, */
+	/* { LFS_IFILE_INUM, sizeof(struct lfs_direct), LFS_DT_REG, 5, "ifile"}, */
 #ifdef MAKE_LF_DIR
-	{ LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 10, "lost+found"},
+	{ LOSTFOUNDINO, sizeof(struct lfs_direct), LFS_DT_DIR, 10, "lost+found"},
 #endif
 };
 #ifdef MAKE_LF_DIR
-struct direct lfs_lf_dir[] = {
+struct lfs_direct lfs_lf_dir[] = {
-        { LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 1, "." },
+        { LOSTFOUNDINO, sizeof(struct lfs_direct), LFS_DT_DIR, 1, "." },
-        { ULFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
+        { ULFS_ROOTINO, sizeof(struct lfs_direct), LFS_DT_DIR, 2, ".." },
 };
 #endif
 void pwarn(const char *, ...);
 static void make_dinode(ino_t, struct ulfs1_dinode *, int, struct lfs *);
-static void make_dir( void *, struct direct *, int);
+static void make_dir( void *, struct lfs_direct *, int);
 static uint64_t maxfilesize(int);
 /*
  * calculate the maximum file size allowed with the specified block shift.
  */
 static uint64_t
 maxfilesize(int bshift)
+{
 	uint64_t nptr; /* number of block pointers per block */
 	uint64_t maxblock;
 	nptr = (1 << bshift) / sizeof(uint32_t);
 	maxblock = ULFS_NDADDR + nptr + nptr * nptr + nptr * nptr * nptr;
 @@ -270,27 +270,27 @@ make_dinode(ino_t ino, struct ulfs1_dino
 			--bb;
 			factor *= NINDIR(fs);
 			base -= factor;
 			++lvl;
+		}
+	}
+}
 /*
  * 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(void *bufp, struct direct *protodir, int entries)
+make_dir(void *bufp, struct lfs_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], 0);
 		memmove(cp, &protodir[i], 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;
 @@ -686,47 +686,47 @@ make_lfs(int devfd, uint secsize, struct
 	VTOI(vp)->i_nlink = dip->di_nlink = 3;
 #else
 	VTOI(vp)->i_nlink = dip->di_nlink = 2;
 #endif
         VTOI(vp)->i_lfs_effnblks = dip->di_blocks =
 		btofsb(fs, roundup(DIRBLKSIZ,fs->lfs_fsize));
 	for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, fs->lfs_bsize); i++)
 		VTOI(vp)->i_lfs_fragsize[i] = fs->lfs_bsize;
 	if (DIRBLKSIZ < fs->lfs_bsize)
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
 			roundup(DIRBLKSIZ,fs->lfs_fsize);
 	bread(vp, 0, fs->lfs_fsize, NOCRED, 0, &bp);
 	make_dir(bp->b_data, lfs_root_dir,
-		 sizeof(lfs_root_dir) / sizeof(struct direct));
+		 sizeof(lfs_root_dir) / sizeof(struct lfs_direct));
 	VOP_BWRITE(bp);
 #ifdef MAKE_LF_DIR
 	/* Initialize lost+found directory */
 	vp = lfs_raw_vget(fs, LOSTFOUNDINO, devfd, 0x0);
 	dip = VTOI(vp)->i_din.ffs1_din;
 	make_dinode(LOSTFOUNDINO, dip, howmany(DIRBLKSIZ,fs->lfs_fsize), fs);
 	dip->di_mode = IFDIR | UMASK;
 	VTOI(vp)->i_lfs_osize = dip->di_size = DIRBLKSIZ;
         VTOI(vp)->i_nlink = dip->di_nlink = 2;
         VTOI(vp)->i_lfs_effnblks = dip->di_blocks =
 		btofsb(fs, roundup(DIRBLKSIZ,fs->lfs_fsize));
 	for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, fs->lfs_bsize); i++)
 		VTOI(vp)->i_lfs_fragsize[i] = fs->lfs_bsize;
 	if (DIRBLKSIZ < fs->lfs_bsize)
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
 			roundup(DIRBLKSIZ,fs->lfs_fsize);
 	bread(vp, 0, fs->lfs_fsize, NOCRED, 0, &bp);
 	make_dir(bp->b_data, lfs_lf_dir,
-		 sizeof(lfs_lf_dir) / sizeof(struct direct));
+		 sizeof(lfs_lf_dir) / sizeof(struct lfs_direct));
 	VOP_BWRITE(bp);
 #endif /* MAKE_LF_DIR */
 	/* Set their IFILE entry version numbers to 1 */
 	LFS_IENTRY(ip, fs, 1, bp);
 	if (version == 1) {
 		ip_v1 = (IFILE_V1 *)ip;
 		for (i = LFS_IFILE_INUM; i <= HIGHEST_USED_INO; i++) {
 			ip_v1->if_version = 1;
 			ip_v1->if_daddr = 0x0;
 			ip_v1->if_nextfree = 0;
 			++ip_v1;
+		}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_vnops.c,v 1.7 2013/06/08 02:11:11 dholland Exp $	*/
+/*	$NetBSD: ulfs_vnops.c,v 1.8 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: ufs_vnops.c,v 1.212 2013/03/18 19:35:48 plunky Exp  */
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Wasabi Systems, Inc.
+ *
  * 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
 @@ -57,27 +57,27 @@
  * 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.
+ *
  *	@(#)ufs_vnops.c	8.28 (Berkeley) 7/31/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_vnops.c,v 1.7 2013/06/08 02:11:11 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_vnops.c,v 1.8 2013/06/08 02:12:56 dholland Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_lfs.h"
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/resourcevar.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 @@ -108,29 +108,29 @@ __KERNEL_RCSID(0, "$NetBSD: ulfs_vnops.c
 #endif
 #include <ufs/lfs/lfs_extern.h>
 #include <ufs/lfs/lfs.h>
 #include <uvm/uvm.h>
 static int ulfs_chmod(struct vnode *, int, kauth_cred_t, struct lwp *);
 static int ulfs_chown(struct vnode *, uid_t, gid_t, kauth_cred_t,
     struct lwp *);
 /*
  * A virgin directory (no blushing please).
  */
-static const struct dirtemplate mastertemplate = {
+static const struct lfs_dirtemplate mastertemplate = {
-,	12,		DT_DIR,	1,	".",
+,	12,		LFS_DT_DIR,	1,	".",
-,	DIRBLKSIZ - 12,	DT_DIR,	2,	".."
+,	DIRBLKSIZ - 12,	LFS_DT_DIR,	2,	".."
 };
 /*
  * Create a regular file
  */
 int
 ulfs_create(void *v)
+{
 	struct vop_create_args /* {
 		struct vnode		*a_dvp;
 		struct vnode		**a_vpp;
 		struct componentname	*a_cnp;
 		struct vattr		*a_vap;
 @@ -816,27 +816,27 @@ ulfs_remove(void *v)
  */
 int
 ulfs_link(void *v)
+{
 	struct vop_link_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode *vp = ap->a_vp;
 	struct componentname *cnp = ap->a_cnp;
 	struct inode *ip;
-	struct direct *newdir;
+	struct lfs_direct *newdir;
 	int error;
 	struct ulfs_lookup_results *ulr;
 	KASSERT(dvp != vp);
 	KASSERT(vp->v_type != VDIR);
 	KASSERT(dvp->v_mount == vp->v_mount);
 	/* XXX should handle this material another way */
 	ulr = &VTOI(dvp)->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(VTOI(dvp));
 	fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 	error = vn_lock(vp, LK_EXCLUSIVE);
 @@ -890,27 +890,27 @@ ulfs_link(void *v)
 /*
  * whiteout vnode call
  */
 int
 ulfs_whiteout(void *v)
+{
 	struct vop_whiteout_args /* {
 		struct vnode		*a_dvp;
 		struct componentname	*a_cnp;
 		int			a_flags;
 	} */ *ap = v;
 	struct vnode		*dvp = ap->a_dvp;
 	struct componentname	*cnp = ap->a_cnp;
-	struct direct		*newdir;
+	struct lfs_direct		*newdir;
 	int			error;
 	struct ulfsmount	*ump = VFSTOULFS(dvp->v_mount);
 	struct ulfs_lookup_results *ulr;
 	/* XXX should handle this material another way */
 	ulr = &VTOI(dvp)->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(VTOI(dvp));
 	error = 0;
 	switch (ap->a_flags) {
 	case LOOKUP:
 		/* 4.4 format directories support whiteout operations */
 		if (ump->um_maxsymlinklen > 0)
 @@ -924,27 +924,27 @@ ulfs_whiteout(void *v)
 		if (error)
 			break;
 #ifdef DIAGNOSTIC
 		if (ump->um_maxsymlinklen <= 0)
 			panic("ulfs_whiteout: old format filesystem");
 #endif
 		newdir = pool_cache_get(ulfs_direct_cache, PR_WAITOK);
 		newdir->d_ino = ULFS_WINO;
 		newdir->d_namlen = cnp->cn_namelen;
 		memcpy(newdir->d_name, cnp->cn_nameptr,
 		    (size_t)cnp->cn_namelen);
 		newdir->d_name[cnp->cn_namelen] = '\0';
-		newdir->d_type = DT_WHT;
+		newdir->d_type = LFS_DT_WHT;
 		error = ulfs_direnter(dvp, ulr, NULL, newdir, cnp, NULL);
 		pool_cache_put(ulfs_direct_cache, newdir);
 		break;
 	case DELETE:
 		/* remove an existing directory whiteout */
 		fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 		error = ULFS_WAPBL_BEGIN(dvp->v_mount);
 		if (error)
 			break;
 #ifdef DIAGNOSTIC
 		if (ump->um_maxsymlinklen <= 0)
 			panic("ulfs_whiteout: old format filesystem");
 @@ -966,28 +966,28 @@ int
 ulfs_mkdir(void *v)
+{
 	struct vop_mkdir_args /* {
 		struct vnode		*a_dvp;
 		struct vnode		**a_vpp;
 		struct componentname	*a_cnp;
 		struct vattr		*a_vap;
 	} */ *ap = v;
 	struct vnode		*dvp = ap->a_dvp, *tvp;
 	struct vattr		*vap = ap->a_vap;
 	struct componentname	*cnp = ap->a_cnp;
 	struct inode		*ip, *dp = VTOI(dvp);
 	struct buf		*bp;
-	struct dirtemplate	dirtemplate;
+	struct lfs_dirtemplate	dirtemplate;
-	struct direct		*newdir;
+	struct lfs_direct		*newdir;
 	int			error, dmode;
 	struct ulfsmount	*ump = dp->i_ump;
 	int			dirblksiz = ump->um_dirblksiz;
 	struct ulfs_lookup_results *ulr;
 	fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 	/* XXX should handle this material another way */
 	ulr = &dp->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(dp);
 	if ((nlink_t)dp->i_nlink >= LINK_MAX) {
 		error = EMLINK;
 @@ -1276,42 +1276,42 @@ ulfs_symlink(void *v)
 		    ap->a_cnp->cn_cred, NULL, NULL);
 	ULFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
 	if (error)
 		vput(vp);
 out:
 	fstrans_done(ap->a_dvp->v_mount);
 	return (error);
+}
 /*
  * Vnode op for reading directories.
+ *
  * This routine handles converting from the on-disk directory format
- * "struct direct" to the in-memory format "struct dirent" as well as
+ * "struct lfs_direct" to the in-memory format "struct dirent" as well as
  * byte swapping the entries if necessary.
  */
 int
 ulfs_readdir(void *v)
+{
 	struct vop_readdir_args /* {
 		struct vnode	*a_vp;
 		struct uio	*a_uio;
 		kauth_cred_t	a_cred;
 		int		*a_eofflag;
 		off_t		**a_cookies;
 		int		*ncookies;
 	} */ *ap = v;
 	struct vnode	*vp = ap->a_vp;
-	struct direct	*cdp, *ecdp;
+	struct lfs_direct	*cdp, *ecdp;
 	struct dirent	*ndp;
 	char		*cdbuf, *ndbuf, *endp;
 	struct uio	auio, *uio;
 	struct iovec	aiov;
 	int		error;
 	size_t		count, ccount, rcount, cdbufsz, ndbufsz;
 	off_t		off, *ccp;
 	off_t		startoff;
 	size_t		skipbytes;
 	struct ulfsmount *ump = VFSTOULFS(vp->v_mount);
 	int nswap = ULFS_MPNEEDSWAP(ump);
 #if BYTE_ORDER == LITTLE_ENDIAN
 	int needswap = ump->um_maxsymlinklen <= 0 && nswap == 0;
 @@ -1337,28 +1337,28 @@ ulfs_readdir(void *v)
 	auio.uio_rw = UIO_READ;
 	cdbufsz = rcount;
 	cdbuf = kmem_alloc(cdbufsz, KM_SLEEP);
 	aiov.iov_base = cdbuf;
 	aiov.iov_len = rcount;
 	error = VOP_READ(vp, &auio, 0, ap->a_cred);
 	if (error != 0) {
 		kmem_free(cdbuf, cdbufsz);
 		return error;
+	}
 	rcount -= auio.uio_resid;
-	cdp = (struct direct *)(void *)cdbuf;
+	cdp = (struct lfs_direct *)(void *)cdbuf;
-	ecdp = (struct direct *)(void *)&cdbuf[rcount];
+	ecdp = (struct lfs_direct *)(void *)&cdbuf[rcount];
 	ndbufsz = count;
 	ndbuf = kmem_alloc(ndbufsz, KM_SLEEP);
 	ndp = (struct dirent *)(void *)ndbuf;
 	endp = &ndbuf[count];
 	off = uio->uio_offset;
 	if (ap->a_cookies) {
 		ccount = rcount / _DIRENT_RECLEN(cdp, 1);
 		ccp = *(ap->a_cookies) = malloc(ccount * sizeof(*ccp),
 		    M_TEMP, M_WAITOK);
 	} else {
 		/* XXX: GCC */
 @@ -1796,27 +1796,27 @@ ulfs_vinit(struct mount *mntp, int (**sp
 	ip->i_modrev = (uint64_t)(uint)tv.tv_sec << 32
 			| tv.tv_usec * 4294u;
 	*vpp = vp;
+}
 /*
  * Allocate a new inode.
  */
 int
 ulfs_makeinode(int mode, struct vnode *dvp, const struct ulfs_lookup_results *ulr,
 	struct vnode **vpp, struct componentname *cnp)
+{
 	struct inode	*ip, *pdir;
-	struct direct	*newdir;
+	struct lfs_direct	*newdir;
 	struct vnode	*tvp;
 	int		error;
 	ULFS_WAPBL_JUNLOCK_ASSERT(dvp->v_mount);
 	pdir = VTOI(dvp);
 	if ((mode & LFS_IFMT) == 0)
 		mode |= LFS_IFREG;
 	if ((error = ULFS_VALLOC(dvp, mode, cnp->cn_cred, vpp)) != 0) {
 		vput(dvp);
 		return (error);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_dir.h,v 1.4 2013/06/08 02:04:31 dholland Exp $	*/
+/*	$NetBSD: ulfs_dir.h,v 1.5 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp  */
 /*
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -37,116 +37,116 @@
  *	@(#)dir.h	8.5 (Berkeley) 4/27/95
  */
 #ifndef _UFS_LFS_ULFS_DIR_H_
 #define	_UFS_LFS_ULFS_DIR_H_
 /*
  * A directory consists of some number of blocks of DIRBLKSIZ
  * bytes, where DIRBLKSIZ is chosen such that it can be transferred
  * to disk in a single atomic operation (e.g. 512 bytes on most machines).
+ *
  * Each DIRBLKSIZ byte block contains some number of directory entry
  * structures, which are of variable length.  Each directory entry has
- * a struct direct at the front of it, containing its inode number,
+ * a struct lfs_direct at the front of it, containing its inode number,
  * the length of the entry, and the length of the name contained in
  * the entry.  These are followed by the name padded to a 4 byte boundary.
  * All names are guaranteed null terminated.
  * The maximum length of a name in a directory is FFS_MAXNAMLEN.
+ *
  * The macro DIRSIZ(fmt, dp) gives the amount of space required to represent
  * a directory entry.  Free space in a directory is represented by
  * entries which have dp->d_reclen > DIRSIZ(fmt, dp).  All DIRBLKSIZ bytes
  * in a directory block are claimed by the directory entries.  This
  * usually results in the last entry in a directory having a large
  * dp->d_reclen.  When entries are deleted from a directory, the
  * space is returned to the previous entry in the same directory
  * block by increasing its dp->d_reclen.  If the first entry of
  * a directory block is free, then its dp->d_ino is set to 0.
  * Entries other than the first in a directory do not normally have
  * dp->d_ino set to 0.
  */
 #undef	DIRBLKSIZ
 #define	DIRBLKSIZ	DEV_BSIZE
 #define	FFS_MAXNAMLEN	255
 #define d_ino d_fileno
-struct	direct {
+struct lfs_direct {
 	u_int32_t d_fileno;		/* inode number of entry */
 	u_int16_t d_reclen;		/* length of this record */
 	u_int8_t  d_type; 		/* file type, see below */
 	u_int8_t  d_namlen;		/* length of string in d_name */
 	char	  d_name[FFS_MAXNAMLEN + 1];/* name with length <= FFS_MAXNAMLEN */
 };
 /*
  * File types
  */
-#define	DT_UNKNOWN	 0
+#define	LFS_DT_UNKNOWN	 0
-#define	DT_FIFO		 1
+#define	LFS_DT_FIFO	 1
-#define	DT_CHR		 2
+#define	LFS_DT_CHR	 2
-#define	DT_DIR		 4
+#define	LFS_DT_DIR	 4
-#define	DT_BLK		 6
+#define	LFS_DT_BLK	 6
-#define	DT_REG		 8
+#define	LFS_DT_REG	 8
-#define	DT_LNK		10
+#define	LFS_DT_LNK	10
-#define	DT_SOCK		12
+#define	LFS_DT_SOCK	12
-#define	DT_WHT		14
+#define	LFS_DT_WHT	14
 /*
  * Convert between stat structure types and directory types.
  */
 #define	IFTODT(mode)	(((mode) & 0170000) >> 12)
 #define	DTTOIF(dirtype)	((dirtype) << 12)
 /*
  * The DIRSIZ macro gives the minimum record length which will hold
- * the directory entry.  This requires the amount of space in struct direct
+ * the directory entry.  This requires the amount of space in struct lfs_direct
  * without the d_name field, plus enough space for the name with a terminating
  * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary.
  */
 #define	DIRECTSIZ(namlen) \
-	((sizeof(struct direct) - (FFS_MAXNAMLEN+1)) + (((namlen)+1 + 3) &~ 3))
+	((sizeof(struct lfs_direct) - (FFS_MAXNAMLEN+1)) + (((namlen)+1 + 3) &~ 3))
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 #define DIRSIZ(oldfmt, dp, needswap)	\
     (((oldfmt) && !(needswap)) ?	\
     DIRECTSIZ((dp)->d_type) : DIRECTSIZ((dp)->d_namlen))
 #else
 #define DIRSIZ(oldfmt, dp, needswap)	\
     (((oldfmt) && (needswap)) ?		\
     DIRECTSIZ((dp)->d_type) : DIRECTSIZ((dp)->d_namlen))
 #endif
 #define OLDDIRFMT	1
 #define NEWDIRFMT	0
 /*
  * Template for manipulating directories.  Should use struct direct's,
  * but the name field is FFS_MAXNAMLEN - 1, and this just won't do.
  */
-struct dirtemplate {
+struct lfs_dirtemplate {
 	u_int32_t	dot_ino;
 	int16_t		dot_reclen;
 	u_int8_t	dot_type;
 	u_int8_t	dot_namlen;
 	char		dot_name[4];	/* must be multiple of 4 */
 	u_int32_t	dotdot_ino;
 	int16_t		dotdot_reclen;
 	u_int8_t	dotdot_type;
 	u_int8_t	dotdot_namlen;
 	char		dotdot_name[4];	/* ditto */
 };
 /*
  * This is the old format of directories, sanz type element.
  */
-struct odirtemplate {
+struct lfs_odirtemplate {
 	u_int32_t	dot_ino;
 	int16_t		dot_reclen;
 	u_int16_t	dot_namlen;
 	char		dot_name[4];	/* must be multiple of 4 */
 	u_int32_t	dotdot_ino;
 	int16_t		dotdot_reclen;
 	u_int16_t	dotdot_namlen;
 	char		dotdot_name[4];	/* ditto */
 };
 #endif /* !_UFS_LFS_ULFS_DIR_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_rename.c,v 1.4 2013/06/08 02:11:11 dholland Exp $	*/
+/*	$NetBSD: ulfs_rename.c,v 1.5 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: ufs_rename.c,v 1.6 2013/01/22 09:39:18 dholland Exp  */
 /*-
  * Copyright (c) 2012 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Taylor R Campbell.
+ *
  * 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
 @@ -25,27 +25,27 @@
  * 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.
  */
 /*
  * ULFS Rename
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_rename.c,v 1.4 2013/06/08 02:11:11 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_rename.c,v 1.5 2013/06/08 02:12:56 dholland Exp $");
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/errno.h>
 #include <sys/fstrans.h>
 #include <sys/kauth.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/pool.h>
 #include <sys/vnode.h>
 #include <sys/vnode_if.h>
 #include <sys/wapbl.h>
 @@ -60,29 +60,29 @@ __KERNEL_RCSID(0, "$NetBSD: ulfs_rename.
 /*
  * Forward declarations
  */
 static int ulfs_sane_rename(struct vnode *, struct componentname *,
     struct vnode *, struct componentname *,
     kauth_cred_t, bool);
 static bool ulfs_rename_ulr_overlap_p(const struct ulfs_lookup_results *,
     const struct ulfs_lookup_results *);
 static int ulfs_rename_recalculate_fulr(struct vnode *,
     struct ulfs_lookup_results *, const struct ulfs_lookup_results *,
     const struct componentname *);
-static int ulfs_direct_namlen(const struct direct *, const struct vnode *);
+static int ulfs_direct_namlen(const struct lfs_direct *, const struct vnode *);
 static int ulfs_read_dotdot(struct vnode *, kauth_cred_t, ino_t *);
-static int ulfs_dirbuf_dotdot_namlen(const struct dirtemplate *,
+static int ulfs_dirbuf_dotdot_namlen(const struct lfs_dirtemplate *,
     const struct vnode *);
 static const struct genfs_rename_ops ulfs_genfs_rename_ops;
 /*
  * ulfs_sane_rename: The hairiest vop, with the saner API.
+ *
  * Arguments:
+ *
  * . fdvp (from directory vnode),
  * . fcnp (from component name),
  * . tdvp (to directory vnode),
  * . tcnp (to component name),
 @@ -261,45 +261,45 @@ ulfs_gro_remove_check_permitted(struct m
 	KASSERT(vp->v_mount == mp);
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
 	return genfs_ufslike_remove_check_permitted(cred,
 	    dvp, VTOI(dvp)->i_mode, VTOI(dvp)->i_uid, vp, VTOI(vp)->i_uid);
+}
 /*
  * A virgin directory (no blushing please).
+ *
  * XXX Copypasta from ulfs_vnops.c.  Kill!
  */
-static const struct dirtemplate mastertemplate = {
+static const struct lfs_dirtemplate mastertemplate = {
-,	12,		DT_DIR,	1,	".",
+,	12,		LFS_DT_DIR,	1,	".",
-,	DIRBLKSIZ - 12,	DT_DIR,	2,	".."
+,	DIRBLKSIZ - 12,	LFS_DT_DIR,	2,	".."
 };
 /*
  * ulfs_gro_rename: Actually perform the rename operation.
  */
 int
 ulfs_gro_rename(struct mount *mp, kauth_cred_t cred,
     struct vnode *fdvp, struct componentname *fcnp,
     void *fde, struct vnode *fvp,
     struct vnode *tdvp, struct componentname *tcnp,
     void *tde, struct vnode *tvp)
+{
 	struct ulfs_lookup_results *fulr = fde;
 	struct ulfs_lookup_results *tulr = tde;
 	bool directory_p, reparent_p;
-	struct direct *newdir;
+	struct lfs_direct *newdir;
 	int error;
 	KASSERT(mp != NULL);
 	KASSERT(fdvp != NULL);
 	KASSERT(fcnp != NULL);
 	KASSERT(fulr != NULL);
 	KASSERT(fvp != NULL);
 	KASSERT(tdvp != NULL);
 	KASSERT(tcnp != NULL);
 	KASSERT(tulr != NULL);
 	KASSERT(fulr != tulr);
 	KASSERT(fdvp != fvp);
 	KASSERT(fdvp != tvp);
 @@ -478,27 +478,27 @@ ulfs_gro_rename(struct mount *mp, kauth_
+		}
+	}
 	/*
 	 * If the source is a directory with a new parent, the link
 	 * count of the old parent directory must be decremented and
 	 * ".." set to point to the new parent.
+	 *
 	 * XXX ulfs_dirrewrite updates the link count of fdvp, but not
 	 * the link count of fvp or the link count of tdvp.  Go figure.
 	 */
 	if (directory_p && reparent_p) {
 		error = ulfs_dirrewrite(VTOI(fvp), mastertemplate.dot_reclen,
-		    VTOI(fdvp), VTOI(tdvp)->i_number, DT_DIR, 0, IN_CHANGE);
+		    VTOI(fdvp), VTOI(tdvp)->i_number, LFS_DT_DIR, 0, IN_CHANGE);
 #if 0		/* XXX This branch was not in ulfs_rename! */
 		if (error)
 			goto whymustithurtsomuch;
 #endif
 		/* XXX WTF?  Why purge here?  Why not purge others?  */
 		cache_purge(fdvp);
+	}
 	/*
 	 * 3) Unlink the source.
 	 */
 @@ -604,27 +604,27 @@ static int
 ulfs_rename_recalculate_fulr(struct vnode *dvp,
     struct ulfs_lookup_results *fulr, const struct ulfs_lookup_results *tulr,
     const struct componentname *fcnp)
+{
 	struct mount *mp;
 	struct ulfsmount *ump;
 	int needswap;
 	/* XXX int is a silly type for this; blame ulfsmount::um_dirblksiz.  */
 	int dirblksiz;
 	doff_t search_start, search_end;
 	doff_t offset;		/* Offset of entry we're examining.  */
 	struct buf *bp;		/* I/O block we're examining.  */
 	char *dirbuf;		/* Pointer into directory at search_start.  */
-	struct direct *ep;	/* Pointer to the entry we're examining.  */
+	struct lfs_direct *ep;	/* Pointer to the entry we're examining.  */
 	/* XXX direct::d_reclen is 16-bit;
 	 * ulfs_lookup_results::ulr_reclen is 32-bit.  Blah.  */
 	uint32_t reclen;	/* Length of the entry we're examining.  */
 	uint32_t prev_reclen;	/* Length of the preceding entry.  */
 	int error;
 	KASSERT(dvp != NULL);
 	KASSERT(dvp->v_mount != NULL);
 	KASSERT(VTOI(dvp) != NULL);
 	KASSERT(fulr != NULL);
 	KASSERT(tulr != NULL);
 	KASSERT(fulr != tulr);
 	KASSERT(ulfs_rename_ulr_overlap_p(fulr, tulr));
 @@ -673,27 +673,27 @@ ulfs_rename_recalculate_fulr(struct vnod
 	/*
 	 * Search from search_start to search_end for the entry matching
 	 * fcnp, which must be there because we found it before and it
 	 * should only at most have moved earlier.
 	 */
 	for (;;) {
 		KASSERT(search_start <= offset);
 		KASSERT(offset < search_end);
 		/*
 		 * Examine the directory entry at offset.
 		 */
-		ep = (struct direct *)(dirbuf + (offset - search_start));
+		ep = (struct lfs_direct *)(dirbuf + (offset - search_start));
 		reclen = ulfs_rw16(ep->d_reclen, needswap);
 		if (ep->d_ino == 0)
 			goto next;	/* Entry is unused.  */
 		if (ulfs_rw32(ep->d_ino, needswap) == ULFS_WINO)
 			goto next;	/* Entry is whiteout.  */
 		if (fcnp->cn_namelen != ulfs_direct_namlen(ep, dvp))
 			goto next;	/* Wrong name length.  */
 		if (memcmp(ep->d_name, fcnp->cn_nameptr, fcnp->cn_namelen))
 			goto next;	/* Wrong name.  */
 @@ -734,27 +734,27 @@ next:
 	 * start of a directory block.
 	 */
 	fulr->ulr_count = ((offset & (dirblksiz - 1))? prev_reclen : 0);
 	brelse(bp, 0);
 	return 0;
+}
 /*
  * ulfs_direct_namlen: Return the namlen of the directory entry ep from
  * the directory vp.
  */
 static int			/* XXX int?  uint8_t?  */
-ulfs_direct_namlen(const struct direct *ep, const struct vnode *vp)
+ulfs_direct_namlen(const struct lfs_direct *ep, const struct vnode *vp)
+{
 	bool swap;
 	KASSERT(ep != NULL);
 	KASSERT(vp != NULL);
 	KASSERT(VTOI(vp) != NULL);
 	KASSERT(VTOI(vp)->i_ump != NULL);
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 	swap = (ULFS_MPNEEDSWAP(VTOI(vp)->i_ump) == 0);
 #else
 	swap = (ULFS_MPNEEDSWAP(VTOI(vp)->i_ump) != 0);
 #endif
 @@ -862,27 +862,27 @@ ulfs_rmdired_p(struct vnode *vp)
 	KASSERT(vp->v_type == VDIR);
 	/* XXX Is this correct?  */
 	return (VTOI(vp)->i_size == 0);
+}
 /*
  * ulfs_read_dotdot: Store in *ino_ret the inode number of the parent
  * of the directory vp.
  */
 static int
 ulfs_read_dotdot(struct vnode *vp, kauth_cred_t cred, ino_t *ino_ret)
+{
-	struct dirtemplate dirbuf;
+	struct lfs_dirtemplate dirbuf;
 	int error;
 	KASSERT(vp != NULL);
 	KASSERT(ino_ret != NULL);
 	KASSERT(vp->v_type == VDIR);
 	error = vn_rdwr(UIO_READ, vp, &dirbuf, sizeof dirbuf, (off_t)0,
 	    UIO_SYSSPACE, IO_NODELOCKED, cred, NULL, NULL);
 	if (error)
 		return error;
 	if (ulfs_dirbuf_dotdot_namlen(&dirbuf, vp) != 2 ||
 	    dirbuf.dotdot_name[0] != '.' ||
 @@ -891,27 +891,27 @@ ulfs_read_dotdot(struct vnode *vp, kauth
 		return ENOTDIR;
 	*ino_ret = ulfs_rw32(dirbuf.dotdot_ino,
 	    ULFS_MPNEEDSWAP(VTOI(vp)->i_ump));
 	return 0;
+}
 /*
  * ulfs_dirbuf_dotdot_namlen: Return the namlen of the directory buffer
  * dirbuf that came from the directory vp.  Swap byte order if
  * necessary.
  */
 static int			/* XXX int?  uint8_t?  */
-ulfs_dirbuf_dotdot_namlen(const struct dirtemplate *dirbuf,
+ulfs_dirbuf_dotdot_namlen(const struct lfs_dirtemplate *dirbuf,
     const struct vnode *vp)
+{
 	bool swap;
 	KASSERT(dirbuf != NULL);
 	KASSERT(vp != NULL);
 	KASSERT(VTOI(vp) != NULL);
 	KASSERT(VTOI(vp)->i_ump != NULL);
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 	swap = (ULFS_MPNEEDSWAP(VTOI(vp)->i_ump) == 0);
 #else
 	swap = (ULFS_MPNEEDSWAP(VTOI(vp)->i_ump) != 0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_dirhash.c,v 1.3 2013/06/06 00:48:04 dholland Exp $	*/
+/*	$NetBSD: ulfs_dirhash.c,v 1.4 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: ufs_dirhash.c,v 1.34 2009/10/05 23:48:08 rmind Exp  */
 /*
  * Copyright (c) 2001, 2002 Ian Dowse.  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.
 @@ -19,27 +19,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR 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.
+ *
  * $FreeBSD: src/sys/ufs/ufs/ufs_dirhash.c,v 1.3.2.8 2004/12/08 11:54:13 dwmalone Exp $
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_dirhash.c,v 1.3 2013/06/06 00:48:04 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_dirhash.c,v 1.4 2013/06/08 02:12:56 dholland Exp $");
 /*
  * This implements a hash-based lookup scheme for ULFS directories.
  */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/types.h>
 #include <sys/hash.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 @@ -62,27 +62,27 @@ __KERNEL_RCSID(0, "$NetBSD: ulfs_dirhash
 #define BLKFREE2IDX(n)		((n) > DH_NFSTATS ? DH_NFSTATS : (n))
 static u_int ulfs_dirhashminblks = 5;
 static u_int ulfs_dirhashmaxmem = 2 * 1024 * 1024;
 static u_int ulfs_dirhashmem;
 static u_int ulfs_dirhashcheck = 0;
 static int ulfsdirhash_hash(struct dirhash *dh, const char *name, int namelen);
 static void ulfsdirhash_adjfree(struct dirhash *dh, doff_t offset, int diff,
 	   int dirblksiz);
 static void ulfsdirhash_delslot(struct dirhash *dh, int slot);
 static int ulfsdirhash_findslot(struct dirhash *dh, const char *name,
 	   int namelen, doff_t offset);
-static doff_t ulfsdirhash_getprev(struct direct *dp, doff_t offset,
+static doff_t ulfsdirhash_getprev(struct lfs_direct *dp, doff_t offset,
 	   int dirblksiz);
 static int ulfsdirhash_recycle(int wanted);
 static pool_cache_t ulfsdirhashblk_cache;
 static pool_cache_t ulfsdirhash_cache;
 #define DIRHASHLIST_LOCK()		mutex_enter(&ulfsdirhash_lock)
 #define DIRHASHLIST_UNLOCK()		mutex_exit(&ulfsdirhash_lock)
 #define DIRHASH_LOCK(dh)		mutex_enter(&(dh)->dh_lock)
 #define DIRHASH_UNLOCK(dh)		mutex_exit(&(dh)->dh_lock)
 #define DIRHASH_BLKALLOC()		\
     pool_cache_get(ulfsdirhashblk_cache, PR_NOWAIT)
 #define DIRHASH_BLKFREE(ptr)		\
 @@ -105,27 +105,27 @@ static struct sysctllog *ulfsdirhash_sys
  * ulfsdirhash_lock. Only the owner of the inode may free the associated
  * dirhash, but anything can steal its memory and set dh_hash to NULL.
  */
 /*
  * Attempt to build up a hash table for the directory contents in
  * inode 'ip'. Returns 0 on success, or -1 of the operation failed.
  */
 int
 ulfsdirhash_build(struct inode *ip)
+{
 	struct dirhash *dh;
 	struct buf *bp = NULL;
-	struct direct *ep;
+	struct lfs_direct *ep;
 	struct vnode *vp;
 	doff_t bmask, pos;
 	int dirblocks, i, j, memreqd, nblocks, narrays, nslots, slot;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	/* Check if we can/should use dirhash. */
 	if (ip->i_dirhash == NULL) {
 		if (ip->i_size < (ulfs_dirhashminblks * dirblksiz) || OFSFMT(ip))
 			return (-1);
 	} else {
 		/* Hash exists, but sysctls could have changed. */
 		if (ip->i_size < (ulfs_dirhashminblks * dirblksiz) ||
 @@ -216,27 +216,27 @@ ulfsdirhash_build(struct inode *ip)
 		if ((curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD)
 		    != 0) {
 			preempt();
+		}
 		/* If necessary, get the next directory block. */
 		if ((pos & bmask) == 0) {
 			if (bp != NULL)
 				brelse(bp, 0);
 			if (ulfs_blkatoff(vp, (off_t)pos, NULL, &bp, false) != 0)
 				goto fail;
+		}
 		/* Add this entry to the hash. */
-		ep = (struct direct *)((char *)bp->b_data + (pos & bmask));
+		ep = (struct lfs_direct *)((char *)bp->b_data + (pos & bmask));
 		if (ep->d_reclen == 0 || ep->d_reclen >
 		    dirblksiz - (pos & (dirblksiz - 1))) {
 			/* Corrupted directory. */
 			brelse(bp, 0);
 			goto fail;
+		}
 		if (ep->d_ino != 0) {
 			/* Add the entry (simplified ulfsdirhash_add). */
 			slot = ulfsdirhash_hash(dh, ep->d_name, ep->d_namlen);
 			while (DH_ENTRY(dh, slot) != DIRHASH_EMPTY)
 				slot = WRAPINCR(slot, dh->dh_hlen);
 			dh->dh_hused++;
 			DH_ENTRY(dh, slot) = pos;
 @@ -315,27 +315,27 @@ ulfsdirhash_free(struct inode *ip)
  * EJUSTRETURN if the caller should revert to a linear search.
+ *
  * If successful, the directory offset is stored in *offp, and a
  * pointer to a struct buf containing the entry is stored in *bpp. If
  * prevoffp is non-NULL, the offset of the previous entry within
  * the DIRBLKSIZ-sized block is stored in *prevoffp (if the entry
  * is the first in a block, the start of the block is used).
  */
 int
 ulfsdirhash_lookup(struct inode *ip, const char *name, int namelen, doff_t *offp,
     struct buf **bpp, doff_t *prevoffp)
+{
 	struct dirhash *dh, *dh_next;
-	struct direct *dp;
+	struct lfs_direct *dp;
 	struct vnode *vp;
 	struct buf *bp;
 	doff_t blkoff, bmask, offset, prevoff;
 	int i, slot;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	if ((dh = ip->i_dirhash) == NULL)
 		return (EJUSTRETURN);
 	/*
 	 * Move this dirhash towards the end of the list if it has a
 	 * score higher than the next entry, and acquire the dh_lock.
 @@ -412,27 +412,27 @@ restart:
 		if (offset < 0 || offset >= ip->i_size)
 			panic("ulfsdirhash_lookup: bad offset in hash array");
 		if ((offset & ~bmask) != blkoff) {
 			if (bp != NULL)
 				brelse(bp, 0);
 			blkoff = offset & ~bmask;
 			if (ulfs_blkatoff(vp, (off_t)blkoff,
 			    NULL, &bp, false) != 0) {
 				DIRHASH_UNLOCK(dh);
 				return (EJUSTRETURN);
+			}
+		}
-		dp = (struct direct *)((char *)bp->b_data + (offset & bmask));
+		dp = (struct lfs_direct *)((char *)bp->b_data + (offset & bmask));
 		if (dp->d_reclen == 0 || dp->d_reclen >
 		    dirblksiz - (offset & (dirblksiz - 1))) {
 			/* Corrupted directory. */
 			DIRHASH_UNLOCK(dh);
 			brelse(bp, 0);
 			return (EJUSTRETURN);
+		}
 		if (dp->d_namlen == namelen &&
 		    memcmp(dp->d_name, name, namelen) == 0) {
 			/* Found. Get the prev offset if needed. */
 			if (prevoffp != NULL) {
 				if (offset & (dirblksiz - 1)) {
 					prevoff = ulfsdirhash_getprev(dp,
 @@ -488,27 +488,27 @@ restart:
+ *
  * To use the space, the caller may need to compact existing entries in
  * the directory. The total number of bytes in all of the entries involved
  * in the compaction is stored in *slotsize. In other words, all of
  * the entries that must be compacted are exactly contained in the
  * region beginning at the returned offset and spanning *slotsize bytes.
+ *
  * Returns -1 if no space was found, indicating that the directory
  * must be extended.
  */
 doff_t
 ulfsdirhash_findfree(struct inode *ip, int slotneeded, int *slotsize)
+{
-	struct direct *dp;
+	struct lfs_direct *dp;
 	struct dirhash *dh;
 	struct buf *bp;
 	doff_t pos, slotstart;
 	int dirblock, error, freebytes, i;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	if ((dh = ip->i_dirhash) == NULL)
 		return (-1);
 	DIRHASH_LOCK(dh);
 	if (dh->dh_hash == NULL) {
 		DIRHASH_UNLOCK(dh);
 @@ -534,48 +534,48 @@ ulfsdirhash_findfree(struct inode *ip, i
 		DIRHASH_UNLOCK(dh);
 		return (-1);
+	}
 	/* Find the first entry with free space. */
 	for (i = 0; i < dirblksiz; ) {
 		if (dp->d_reclen == 0) {
 			DIRHASH_UNLOCK(dh);
 			brelse(bp, 0);
 			return (-1);
+		}
 		if (dp->d_ino == 0 || dp->d_reclen > DIRSIZ(0, dp, needswap))
 			break;
 		i += dp->d_reclen;
-		dp = (struct direct *)((char *)dp + dp->d_reclen);
+		dp = (struct lfs_direct *)((char *)dp + dp->d_reclen);
+	}
 	if (i > dirblksiz) {
 		DIRHASH_UNLOCK(dh);
 		brelse(bp, 0);
 		return (-1);
+	}
 	slotstart = pos + i;
 	/* Find the range of entries needed to get enough space */
 	freebytes = 0;
 	while (i < dirblksiz && freebytes < slotneeded) {
 		freebytes += dp->d_reclen;
 		if (dp->d_ino != 0)
 			freebytes -= DIRSIZ(0, dp, needswap);
 		if (dp->d_reclen == 0) {
 			DIRHASH_UNLOCK(dh);
 			brelse(bp, 0);
 			return (-1);
+		}
 		i += dp->d_reclen;
-		dp = (struct direct *)((char *)dp + dp->d_reclen);
+		dp = (struct lfs_direct *)((char *)dp + dp->d_reclen);
+	}
 	if (i > dirblksiz) {
 		DIRHASH_UNLOCK(dh);
 		brelse(bp, 0);
 		return (-1);
+	}
 	if (freebytes < slotneeded)
 		panic("ulfsdirhash_findfree: free mismatch");
 	DIRHASH_UNLOCK(dh);
 	brelse(bp, 0);
 	*slotsize = pos + i - slotstart;
 	return (slotstart);
+}
 @@ -605,31 +605,31 @@ ulfsdirhash_enduseful(struct inode *ip)
 		DIRHASH_UNLOCK(dh);
 		return (-1);
+	}
 	for (i = dh->dh_dirblks - 1; i >= 0; i--)
 		if (dh->dh_blkfree[i] != dirblksiz / DIRALIGN)
 			break;
 	DIRHASH_UNLOCK(dh);
 	return ((doff_t)(i + 1) * dirblksiz);
+}
 /*
  * Insert information into the hash about a new directory entry. dirp
- * points to a struct direct containing the entry, and offset specifies
+ * points to a struct lfs_direct containing the entry, and offset specifies
  * the offset of this entry.
  */
 void
-ulfsdirhash_add(struct inode *ip, struct direct *dirp, doff_t offset)
+ulfsdirhash_add(struct inode *ip, struct lfs_direct *dirp, doff_t offset)
+{
 	struct dirhash *dh;
 	int slot;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	if ((dh = ip->i_dirhash) == NULL)
 		return;
 	DIRHASH_LOCK(dh);
 	if (dh->dh_hash == NULL) {
 		DIRHASH_UNLOCK(dh);
 		ulfsdirhash_free(ip);
 @@ -656,27 +656,27 @@ ulfsdirhash_add(struct inode *ip, struct
 	DH_ENTRY(dh, slot) = offset;
 	/* Update the per-block summary info. */
 	ulfsdirhash_adjfree(dh, offset, -DIRSIZ(0, dirp, needswap), dirblksiz);
 	DIRHASH_UNLOCK(dh);
+}
 /*
  * Remove the specified directory entry from the hash. The entry to remove
  * is defined by the name in `dirp', which must exist at the specified
  * `offset' within the directory.
  */
 void
-ulfsdirhash_remove(struct inode *ip, struct direct *dirp, doff_t offset)
+ulfsdirhash_remove(struct inode *ip, struct lfs_direct *dirp, doff_t offset)
+{
 	struct dirhash *dh;
 	int slot;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	if ((dh = ip->i_dirhash) == NULL)
 		return;
 	DIRHASH_LOCK(dh);
 	if (dh->dh_hash == NULL) {
 		DIRHASH_UNLOCK(dh);
 		ulfsdirhash_free(ip);
 @@ -690,27 +690,27 @@ ulfsdirhash_remove(struct inode *ip, str
 	/* Remove the hash entry. */
 	ulfsdirhash_delslot(dh, slot);
 	/* Update the per-block summary info. */
 	ulfsdirhash_adjfree(dh, offset, DIRSIZ(0, dirp, needswap), dirblksiz);
 	DIRHASH_UNLOCK(dh);
+}
 /*
  * Change the offset associated with a directory entry in the hash. Used
  * when compacting directory blocks.
  */
 void
-ulfsdirhash_move(struct inode *ip, struct direct *dirp, doff_t oldoff,
+ulfsdirhash_move(struct inode *ip, struct lfs_direct *dirp, doff_t oldoff,
     doff_t newoff)
+{
 	struct dirhash *dh;
 	int slot;
 	if ((dh = ip->i_dirhash) == NULL)
 		return;
 	DIRHASH_LOCK(dh);
 	if (dh->dh_hash == NULL) {
 		DIRHASH_UNLOCK(dh);
 		ulfsdirhash_free(ip);
 		return;
+	}
 @@ -814,50 +814,50 @@ ulfsdirhash_dirtrunc(struct inode *ip, d
 /*
  * Debugging function to check that the dirhash information about
  * a directory block matches its actual contents. Panics if a mismatch
  * is detected.
+ *
  * On entry, `sbuf' should point to the start of an in-core
  * DIRBLKSIZ-sized directory block, and `offset' should contain the
  * offset from the start of the directory of that block.
  */
 void
 ulfsdirhash_checkblock(struct inode *ip, char *sbuf, doff_t offset)
+{
 	struct dirhash *dh;
-	struct direct *dp;
+	struct lfs_direct *dp;
 	int block, ffslot, i, nfree;
 	const int needswap = ULFS_MPNEEDSWAP(ip->i_ump);
 	int dirblksiz = ip->i_ump->um_dirblksiz;
 	if (!ulfs_dirhashcheck)
 		return;
 	if ((dh = ip->i_dirhash) == NULL)
 		return;
 	DIRHASH_LOCK(dh);
 	if (dh->dh_hash == NULL) {
 		DIRHASH_UNLOCK(dh);
 		ulfsdirhash_free(ip);
 		return;
+	}
 	block = offset / dirblksiz;
 	if ((offset & (dirblksiz - 1)) != 0 || block >= dh->dh_dirblks)
 		panic("ulfsdirhash_checkblock: bad offset");
 	nfree = 0;
 	for (i = 0; i < dirblksiz; i += dp->d_reclen) {
-		dp = (struct direct *)(sbuf + i);
+		dp = (struct lfs_direct *)(sbuf + i);
 		if (dp->d_reclen == 0 || i + dp->d_reclen > dirblksiz)
 			panic("ulfsdirhash_checkblock: bad dir");
 		if (dp->d_ino == 0) {
 #if 0
 			/*
 			 * XXX entries with d_ino == 0 should only occur
 			 * at the start of a DIRBLKSIZ block. However the
 			 * ulfs code is tolerant of such entries at other
 			 * offsets, and fsck does not fix them.
 			 */
 			if (i != 0)
 				panic("ulfsdirhash_checkblock: bad dir inode");
 @@ -996,45 +996,45 @@ ulfsdirhash_delslot(struct dirhash *dh,
 			i = WRAPDECR(i, dh->dh_hlen);
+		}
 		KASSERT(dh->dh_hused >= 0);
+	}
+}
 /*
  * Given a directory entry and its offset, find the offset of the
  * previous entry in the same DIRBLKSIZ-sized block. Returns an
  * offset, or -1 if there is no previous entry in the block or some
  * other problem occurred.
  */
 static doff_t
-ulfsdirhash_getprev(struct direct *dirp, doff_t offset, int dirblksiz)
+ulfsdirhash_getprev(struct lfs_direct *dirp, doff_t offset, int dirblksiz)
+{
-	struct direct *dp;
+	struct lfs_direct *dp;
 	char *blkbuf;
 	doff_t blkoff, prevoff;
 	int entrypos, i;
 	blkoff = offset & ~(dirblksiz - 1);	/* offset of start of block */
 	entrypos = offset & (dirblksiz - 1);	/* entry relative to block */
 	blkbuf = (char *)dirp - entrypos;
 	prevoff = blkoff;
 	/* If `offset' is the start of a block, there is no previous entry. */
 	if (entrypos == 0)
 		return (-1);
 	/* Scan from the start of the block until we get to the entry. */
 	for (i = 0; i < entrypos; i += dp->d_reclen) {
-		dp = (struct direct *)(blkbuf + i);
+		dp = (struct lfs_direct *)(blkbuf + i);
 		if (dp->d_reclen == 0 || i + dp->d_reclen > entrypos)
 			return (-1);	/* Corrupted directory. */
 		prevoff = blkoff + i;
+	}
 	return (prevoff);
+}
 /*
  * Try to free up `wanted' bytes by stealing memory from existing
  * dirhashes. Returns zero with list locked if successful.
  */
 static int
 ulfsdirhash_recycle(int wanted)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_lookup.c,v 1.6 2013/06/06 00:50:51 dholland Exp $	*/
+/*	$NetBSD: ulfs_lookup.c,v 1.7 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: ufs_lookup.c,v 1.122 2013/01/22 09:39:18 dholland Exp  */
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -28,27 +28,27 @@
  * 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.
+ *
  *	@(#)ufs_lookup.c	8.9 (Berkeley) 8/11/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_lookup.c,v 1.6 2013/06/06 00:50:51 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_lookup.c,v 1.7 2013/06/08 02:12:56 dholland Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_lfs.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/buf.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 @@ -111,27 +111,27 @@ int	lfs_dirchk = 0;
  *	  nor deleting, add name to cache
  */
 int
 ulfs_lookup(void *v)
+{
 	struct vop_lookup_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *vdp = ap->a_dvp;	/* vnode for directory being searched */
 	struct inode *dp = VTOI(vdp);	/* inode for directory being searched */
 	struct buf *bp;			/* a buffer of directory entries */
-	struct direct *ep;		/* the current directory entry */
+	struct lfs_direct *ep;		/* the current directory entry */
 	int entryoffsetinblock;		/* offset of ep in bp's buffer */
 	enum {
 		NONE,		/* need to search a slot for our new entry */
 		COMPACT,	/* a compaction can make a slot in the current
 				   DIRBLKSIZ block */
 		FOUND,		/* found a slot (or no need to search) */
 	} slotstatus;
 	doff_t slotoffset;		/* offset of area with free space.
 					   a special value -1 for invalid */
 	int slotsize;			/* size of area at slotoffset */
 	int slotfreespace;		/* accumulated amount of space free in
 					   the current DIRBLKSIZ block */
 	int slotneeded;			/* size of the entry we're seeking */
 @@ -253,27 +253,27 @@ ulfs_lookup(void *v)
 			if (slotoffset >= 0) {
 				slotstatus = COMPACT;
 				enduseful = ulfsdirhash_enduseful(dp);
 				if (enduseful < 0)
 					enduseful = dp->i_size;
+			}
+		}
 		/* Look up the component. */
 		numdirpasses = 1;
 		entryoffsetinblock = 0; /* silence compiler warning */
 		switch (ulfsdirhash_lookup(dp, cnp->cn_nameptr, cnp->cn_namelen,
 		    &results->ulr_offset, &bp, nameiop == DELETE ? &prevoff : NULL)) {
 		case 0:
-			ep = (struct direct *)((char *)bp->b_data +
+			ep = (struct lfs_direct *)((char *)bp->b_data +
 			    (results->ulr_offset & bmask));
 			goto foundentry;
 		case ENOENT:
 			results->ulr_offset = roundup(dp->i_size, dirblksiz);
 			goto notfound;
 		default:
 			/* Something failed; just do a linear search. */
 			break;
+		}
+	}
 #endif /* LFS_DIRHASH */
 	if (nameiop != LOOKUP || results->ulr_diroff == 0 ||
 @@ -317,27 +317,27 @@ searchloop:
 		if (slotstatus == NONE &&
 		    (entryoffsetinblock & (dirblksiz - 1)) == 0) {
 			slotoffset = -1;
 			slotfreespace = 0;
+		}
 		/*
 		 * Get pointer to next entry.
 		 * Full validation checks are slow, so we only check
 		 * enough to insure forward progress through the
 		 * directory. Complete checks can be run by patching
 		 * "lfs_dirchk" to be true.
 		 */
 		KASSERT(bp != NULL);
-		ep = (struct direct *)((char *)bp->b_data + entryoffsetinblock);
+		ep = (struct lfs_direct *)((char *)bp->b_data + entryoffsetinblock);
 		if (ep->d_reclen == 0 ||
 		    (lfs_dirchk && ulfs_dirbadentry(vdp, ep, entryoffsetinblock))) {
 			int i;
 			ulfs_dirbad(dp, results->ulr_offset, "mangled entry");
 			i = dirblksiz - (entryoffsetinblock & (dirblksiz - 1));
 			results->ulr_offset += i;
 			entryoffsetinblock += i;
 			continue;
+		}
 		/*
 		 * If an appropriate sized slot has not yet been found,
 @@ -388,27 +388,27 @@ searchloop:
 			else
 				namlen = ep->d_namlen;
 #endif
 			if (namlen == cnp->cn_namelen &&
 			    !memcmp(cnp->cn_nameptr, ep->d_name,
 			    (unsigned)namlen)) {
 #ifdef LFS_DIRHASH
 foundentry:
 #endif
 				/*
 				 * Save directory entry's inode number and
 				 * reclen, and release directory buffer.
 				 */
-				if (!FSFMT(vdp) && ep->d_type == DT_WHT) {
+				if (!FSFMT(vdp) && ep->d_type == LFS_DT_WHT) {
 					slotstatus = FOUND;
 					slotoffset = results->ulr_offset;
 					slotsize = ulfs_rw16(ep->d_reclen,
 					    needswap);
 					results->ulr_reclen = slotsize;
 					/*
 					 * This is used to set
 					 * results->ulr_endoff,
 					 * which may be used by ulfs_direnter()
 					 * as a length to truncate the
 					 * directory to.  Therefore, it must
 					 * point past the end of the last
 					 * non-empty directory entry.  We don't
 @@ -701,27 +701,27 @@ ulfs_dirbad(struct inode *ip, doff_t off
 	if ((mp->mnt_stat.f_flag & MNT_RDONLY) == 0)
 		panic("bad dir");
+}
 /*
  * Do consistency checking on a directory entry:
  *	record length must be multiple of 4
  *	entry must fit in rest of its DIRBLKSIZ block
  *	record must be large enough to contain entry
  *	name is not longer than FFS_MAXNAMLEN
  *	name must be as long as advertised, and null terminated
  */
 int
-ulfs_dirbadentry(struct vnode *dp, struct direct *ep, int entryoffsetinblock)
+ulfs_dirbadentry(struct vnode *dp, struct lfs_direct *ep, int entryoffsetinblock)
+{
 	int i;
 	int namlen;
 	struct ulfsmount *ump = VFSTOULFS(dp->v_mount);
 	const int needswap = ULFS_MPNEEDSWAP(ump);
 	int dirblksiz = ump->um_dirblksiz;
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 	if (FSFMT(dp) && needswap == 0)
 		namlen = ep->d_type;
 	else
 		namlen = ep->d_namlen;
 #else
 @@ -757,27 +757,27 @@ ulfs_dirbadentry(struct vnode *dp, struc
 		goto bad;
 	return (0);
 bad:
 	return (1);
+}
 /*
  * Construct a new directory entry after a call to namei, using the
  * name in the componentname argument cnp. The argument ip is the
  * inode to which the new directory entry will refer.
  */
 void
 ulfs_makedirentry(struct inode *ip, struct componentname *cnp,
-    struct direct *newdirp)
+    struct lfs_direct *newdirp)
+{
 	newdirp->d_ino = ip->i_number;
 	newdirp->d_namlen = cnp->cn_namelen;
 	memcpy(newdirp->d_name, cnp->cn_nameptr, (size_t)cnp->cn_namelen);
 	newdirp->d_name[cnp->cn_namelen] = '\0';
 	if (FSFMT(ITOV(ip)))
 		newdirp->d_type = 0;
 	else
 		newdirp->d_type = IFTODT(ip->i_mode);
+}
 /*
  * Write a directory entry after a call to namei, using the parameters
 @@ -800,36 +800,36 @@ ulfs_makedirentry(struct inode *ip, stru
  * directory AFAIK) and a fresh block is allocated to put the new
  * directory entry in.
+ *
  * If ulr->ulr_count is not zero, ulfs_lookup found a slot to insert
  * the entry into. This slot ranges from ulr_offset to ulr_offset +
  * ulr_count. However, this slot may already be partially populated
  * requiring compaction. See notes below.
+ *
  * Furthermore, if ulr_count is not zero and ulr_endoff is not the
  * same as i_size, the directory is truncated to size ulr_endoff.
  */
 int
 ulfs_direnter(struct vnode *dvp, const struct ulfs_lookup_results *ulr,
-    struct vnode *tvp, struct direct *dirp,
+    struct vnode *tvp, struct lfs_direct *dirp,
     struct componentname *cnp, struct buf *newdirbp)
+{
 	kauth_cred_t cr;
 	struct lwp *l;
 	int newentrysize;
 	struct inode *dp;
 	struct buf *bp;
 	u_int dsize;
-	struct direct *ep, *nep;
+	struct lfs_direct *ep, *nep;
 	int error, ret, blkoff, loc, spacefree;
 	char *dirbuf;
 	struct timespec ts;
 	struct ulfsmount *ump = VFSTOULFS(dvp->v_mount);
 	const int needswap = ULFS_MPNEEDSWAP(ump);
 	int dirblksiz = ump->um_dirblksiz;
 	ULFS_WAPBL_JLOCK_ASSERT(dvp->v_mount);
 	error = 0;
 	cr = cnp->cn_cred;
 	l = curlwp;
 @@ -913,37 +913,37 @@ ulfs_direnter(struct vnode *dvp, const s
 	/*
 	 * Get the block containing the space for the new directory entry.
 	 */
 	error = ulfs_blkatoff(dvp, (off_t)ulr->ulr_offset, &dirbuf, &bp, true);
 	if (error) {
 		return (error);
+	}
 	/*
 	 * Find space for the new entry. In the simple case, the entry at
 	 * offset base will have the space. If it does not, then namei
 	 * arranged that compacting the region ulr_offset to
 	 * ulr_offset + ulr_count would yield the space.
 	 */
-	ep = (struct direct *)dirbuf;
+	ep = (struct lfs_direct *)dirbuf;
 	dsize = (ep->d_ino != 0) ? DIRSIZ(FSFMT(dvp), ep, needswap) : 0;
 	spacefree = ulfs_rw16(ep->d_reclen, needswap) - dsize;
 	for (loc = ulfs_rw16(ep->d_reclen, needswap); loc < ulr->ulr_count; ) {
 		uint16_t reclen;
-		nep = (struct direct *)(dirbuf + loc);
+		nep = (struct lfs_direct *)(dirbuf + loc);
 		/* Trim the existing slot (NB: dsize may be zero). */
 		ep->d_reclen = ulfs_rw16(dsize, needswap);
-		ep = (struct direct *)((char *)ep + dsize);
+		ep = (struct lfs_direct *)((char *)ep + dsize);
 		reclen = ulfs_rw16(nep->d_reclen, needswap);
 		loc += reclen;
 		if (nep->d_ino == 0) {
 			/*
 			 * A mid-block unused entry. Such entries are
 			 * never created by the kernel, but fsck_ffs
 			 * can create them (and it doesn't fix them).
+			 *
 			 * Add up the free space, and initialise the
 			 * relocated entry since we don't memcpy it.
 			 */
 			spacefree += reclen;
 @@ -971,27 +971,27 @@ ulfs_direnter(struct vnode *dvp, const s
 	 * copy in the new entry, and write out the block.
 	 */
 	if (ep->d_ino == 0 ||
 	    (ulfs_rw32(ep->d_ino, needswap) == ULFS_WINO &&
 	     memcmp(ep->d_name, dirp->d_name, dirp->d_namlen) == 0)) {
 		if (spacefree + dsize < newentrysize)
 			panic("ulfs_direnter: compact1");
 		dirp->d_reclen = spacefree + dsize;
 	} else {
 		if (spacefree < newentrysize)
 			panic("ulfs_direnter: compact2");
 		dirp->d_reclen = spacefree;
 		ep->d_reclen = ulfs_rw16(dsize, needswap);
-		ep = (struct direct *)((char *)ep + dsize);
+		ep = (struct lfs_direct *)((char *)ep + dsize);
+	}
 	dirp->d_reclen = ulfs_rw16(dirp->d_reclen, needswap);
 	dirp->d_ino = ulfs_rw32(dirp->d_ino, needswap);
 	if (FSFMT(dvp)) {
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 		if (needswap == 0) {
 #else
 		if (needswap != 0) {
 #endif
 			u_char tmp = dirp->d_namlen;
 			dirp->d_namlen = dirp->d_type;
 			dirp->d_type = tmp;
+		}
 @@ -1058,60 +1058,60 @@ ulfs_direnter(struct vnode *dvp, const s
  * The space is marked free by adding it to the record length (not
  * name length) of the preceding entry. If the first entry becomes
  * free, it is marked free by setting the inode number to 0.
+ *
  * The link count of IP is decremented. Note that this is not the
  * inverse behavior of ulfs_direnter, which does not adjust link
  * counts. Sigh.
  */
 int
 ulfs_dirremove(struct vnode *dvp, const struct ulfs_lookup_results *ulr,
 	      struct inode *ip, int flags, int isrmdir)
+{
 	struct inode *dp = VTOI(dvp);
-	struct direct *ep;
+	struct lfs_direct *ep;
 	struct buf *bp;
 	int error;
 #ifdef LFS_EI
 	const int needswap = ULFS_MPNEEDSWAP(dp->i_ump);
 #endif
 	ULFS_WAPBL_JLOCK_ASSERT(dvp->v_mount);
 	if (flags & DOWHITEOUT) {
 		/*
 		 * Whiteout entry: set d_ino to ULFS_WINO.
 		 */
 		error = ulfs_blkatoff(dvp, (off_t)ulr->ulr_offset, (void *)&ep,
 				     &bp, true);
 		if (error)
 			return (error);
 		ep->d_ino = ulfs_rw32(ULFS_WINO, needswap);
-		ep->d_type = DT_WHT;
+		ep->d_type = LFS_DT_WHT;
 		goto out;
+	}
 	if ((error = ulfs_blkatoff(dvp,
 	    (off_t)(ulr->ulr_offset - ulr->ulr_count), (void *)&ep, &bp, true)) != 0)
 		return (error);
 #ifdef LFS_DIRHASH
 	/*
 	 * Remove the dirhash entry. This is complicated by the fact
 	 * that `ep' is the previous entry when ulr_count != 0.
 	 */
 	if (dp->i_dirhash != NULL)
 		ulfsdirhash_remove(dp, (ulr->ulr_count == 0) ? ep :
-		   (struct direct *)((char *)ep +
+		   (struct lfs_direct *)((char *)ep +
 		   ulfs_rw16(ep->d_reclen, needswap)), ulr->ulr_offset);
 #endif
 	if (ulr->ulr_count == 0) {
 		/*
 		 * First entry in block: set d_ino to zero.
 		 */
 		ep->d_ino = 0;
 	} else {
 		/*
 		 * Collapse new free space into previous entry.
 		 */
 		ep->d_reclen =
 @@ -1168,27 +1168,27 @@ out:
  * (This is ignored if the fs doesn't support that.)
  * ISRMDIR is not used and (XXX) should be removed.
  * IFLAGS are added to DP's inode flags.
+ *
  * The link count of OIP is decremented. Note that the link count of
  * the new inode is *not* incremented. Yay for symmetry.
  */
 int
 ulfs_dirrewrite(struct inode *dp, off_t offset,
     struct inode *oip, ino_t newinum, int newtype,
     int isrmdir, int iflags)
+{
 	struct buf *bp;
-	struct direct *ep;
+	struct lfs_direct *ep;
 	struct vnode *vdp = ITOV(dp);
 	int error;
 	error = ulfs_blkatoff(vdp, offset, (void *)&ep, &bp, true);
 	if (error)
 		return (error);
 	ep->d_ino = ulfs_rw32(newinum, ULFS_MPNEEDSWAP(dp->i_ump));
 	if (!FSFMT(vdp))
 		ep->d_type = newtype;
 	oip->i_nlink--;
 	DIP_ASSIGN(oip, nlink, oip->i_nlink);
 	oip->i_flag |= IN_CHANGE;
 	ULFS_WAPBL_UPDATE(ITOV(oip), NULL, NULL, UPDATE_DIROP);
 @@ -1199,41 +1199,41 @@ ulfs_dirrewrite(struct inode *dp, off_t
 	 * drop its snapshot reference so that it will be reclaimed
 	 * when last open reference goes away.
 	 */
 	if ((oip->i_flags & SF_SNAPSHOT) != 0 && oip->i_nlink == 0)
 		ulfs_snapgone(oip);
 	ULFS_WAPBL_UPDATE(vdp, NULL, NULL, UPDATE_DIROP);
 	return (error);
+}
 /*
  * Check if a directory is empty or not.
  * Inode supplied must be locked.
+ *
- * Using a struct dirtemplate here is not precisely
+ * Using a struct lfs_dirtemplate here is not precisely
- * what we want, but better than using a struct direct.
+ * what we want, but better than using a struct lfs_direct.
+ *
  * NB: does not handle corrupted directories.
  */
 int
 ulfs_dirempty(struct inode *ip, ino_t parentino, kauth_cred_t cred)
+{
 	doff_t off;
-	struct dirtemplate dbuf;
+	struct lfs_dirtemplate dbuf;
-	struct direct *dp = (struct direct *)&dbuf;
+	struct lfs_direct *dp = (struct lfs_direct *)&dbuf;
 	int error, namlen;
 	size_t count;
 	const int needswap = ULFS_IPNEEDSWAP(ip);
-#define	MINDIRSIZ (sizeof (struct dirtemplate) / 2)
+#define	MINDIRSIZ (sizeof (struct lfs_dirtemplate) / 2)
 	for (off = 0; off < ip->i_size;
 	    off += ulfs_rw16(dp->d_reclen, needswap)) {
 		error = vn_rdwr(UIO_READ, ITOV(ip), (void *)dp, MINDIRSIZ, off,
 		   UIO_SYSSPACE, IO_NODELOCKED, cred, &count, NULL);
 		/*
 		 * Since we read MINDIRSIZ, residual must
 		 * be 0 unless we're at end of file.
 		 */
 		if (error || count != 0)
 			return (0);
 		/* avoid infinite loops */
 		if (dp->d_reclen == 0)
 @@ -1273,46 +1273,46 @@ ulfs_dirempty(struct inode *ip, ino_t pa
 	return (1);
+}
 /*
  * Check if source directory is in the path of the target directory.
  * Target is supplied locked, source is unlocked.
  * The target is always vput before returning.
  */
 int
 ulfs_checkpath(struct inode *source, struct inode *target, kauth_cred_t cred)
+{
 	struct vnode *nextvp, *vp;
 	int error, rootino, namlen;
-	struct dirtemplate dirbuf;
+	struct lfs_dirtemplate dirbuf;
 	const int needswap = ULFS_MPNEEDSWAP(target->i_ump);
 	vp = ITOV(target);
 	if (target->i_number == source->i_number) {
 		error = EEXIST;
 		goto out;
+	}
 	rootino = ULFS_ROOTINO;
 	error = 0;
 	if (target->i_number == rootino)
 		goto out;
 	for (;;) {
 		if (vp->v_type != VDIR) {
 			error = ENOTDIR;
 			break;
+		}
 		error = vn_rdwr(UIO_READ, vp, (void *)&dirbuf,
-		    sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE,
+		    sizeof (struct lfs_dirtemplate), (off_t)0, UIO_SYSSPACE,
 		    IO_NODELOCKED, cred, NULL, NULL);
 		if (error != 0)
 			break;
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 		if (FSFMT(vp) && needswap == 0)
 			namlen = dirbuf.dotdot_type;
 		else
 			namlen = dirbuf.dotdot_namlen;
 #else
 		if (FSFMT(vp) && needswap != 0)
 			namlen = dirbuf.dotdot_type;
 		else
 			namlen = dirbuf.dotdot_namlen;
 @@ -1345,31 +1345,31 @@ out:
 		printf("checkpath: .. not a directory\n");
 	if (vp != NULL)
 		vput(vp);
 	return (error);
+}
 /*
  * Extract the inode number of ".." from a directory.
  * Helper for ulfs_parentcheck.
  */
 static int
 ulfs_readdotdot(struct vnode *vp, int needswap, kauth_cred_t cred, ino_t *result)
+{
-	struct dirtemplate dirbuf;
+	struct lfs_dirtemplate dirbuf;
 	int namlen, error;
 	error = vn_rdwr(UIO_READ, vp, &dirbuf,
-		    sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE,
+		    sizeof (struct lfs_dirtemplate), (off_t)0, UIO_SYSSPACE,
 		    IO_NODELOCKED, cred, NULL, NULL);
 	if (error) {
 		return error;
+	}
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 	if (FSFMT(vp) && needswap == 0)
 		namlen = dirbuf.dotdot_type;
 	else
 		namlen = dirbuf.dotdot_namlen;
 #else
 	if (FSFMT(vp) && needswap != 0)
 		namlen = dirbuf.dotdot_type;

 @@ -1,14 +1,14 @@
-/* $NetBSD: fsck.h,v 1.19 2013/06/06 00:52:50 dholland Exp $	 */
+/* $NetBSD: fsck.h,v 1.20 2013/06/08 02:12:56 dholland Exp $	 */
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * 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.
 @@ -121,27 +121,27 @@ enum fixstate {
 struct inodesc {
 	enum fixstate id_fix;	/* policy on fixing errors */
 	int (*id_func) (struct inodesc *);	/* function to be applied to
 						 * blocks of inode */
 	ino_t id_number;	/* inode number described */
 	ino_t id_parent;	/* for DATA nodes, their parent */
 	daddr_t id_blkno;	/* current block number being examined */
 	daddr_t id_lblkno;	/* current logical block number */
 	int id_numfrags;	/* number of frags contained in block */
 	quad_t id_filesize;	/* for DATA nodes, the size of the directory */
 	int id_loc;		/* for DATA nodes, current location in dir */
 	int id_entryno;		/* for DATA nodes, current entry number */
-	struct direct *id_dirp;	/* for DATA nodes, ptr to current entry */
+	struct lfs_direct *id_dirp;	/* for DATA nodes, ptr to current entry */
 	const char *id_name;	/* for DATA nodes, name to find or enter */
 	char id_type;		/* type of descriptor, DATA or ADDR */
 };
 /* file types */
 #define	DATA	1
 #define	ADDR	2
 /*
  * Linked list of duplicate blocks.
+ *
  * The list is composed of two parts. The first part of the
  * list (from duplist through the node pointed to by muldup)
  * contains a single copy of each duplicate block that has been

 @@ -1,14 +1,14 @@
-/* $NetBSD: inode.c,v 1.47 2013/06/08 02:11:11 dholland Exp $	 */
+/* $NetBSD: inode.c,v 1.48 2013/06/08 02:12:56 dholland Exp $	 */
 /*-
  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * 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.
 @@ -476,46 +476,46 @@ clearinode(ino_t inumber)
 		SEGUSE *sup;
 		u_int32_t oldsn = dtosn(fs, daddr);
 		seg_table[oldsn].su_nbytes -= LFS_DINODE1_SIZE;
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 		sup->su_nbytes -= LFS_DINODE1_SIZE;
 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp);	/* Ifile */
+	}
+}
 int
 findname(struct inodesc * idesc)
+{
-	struct direct *dirp = idesc->id_dirp;
+	struct lfs_direct *dirp = idesc->id_dirp;
 	size_t len;
 	char *buf;
 	if (dirp->d_ino != idesc->id_parent)
 		return (KEEPON);
 	if ((len = dirp->d_namlen + 1) > MAXPATHLEN) {
 		/* Truncate it but don't overflow the buffer */
 		len = MAXPATHLEN;
+	}
 	/* this is namebuf with utils.h */
 	buf = __UNCONST(idesc->id_name);
 	(void)memcpy(buf, dirp->d_name, len);
 	return (STOP | FOUND);
+}
 int
 findino(struct inodesc * idesc)
+{
-	struct direct *dirp = idesc->id_dirp;
+	struct lfs_direct *dirp = idesc->id_dirp;
 	if (dirp->d_ino == 0)
 		return (KEEPON);
 	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
 	    dirp->d_ino >= ULFS_ROOTINO && dirp->d_ino < maxino) {
 		idesc->id_parent = dirp->d_ino;
 		return (STOP | FOUND);
+	}
 	return (KEEPON);
+}
 void
 pinode(ino_t ino)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_dirhash.h,v 1.2 2013/06/06 00:48:04 dholland Exp $	*/
+/*	$NetBSD: ulfs_dirhash.h,v 1.3 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: dirhash.h,v 1.6 2008/06/04 11:33:19 ad Exp  */
 /*
  * Copyright (c) 2001 Ian Dowse.  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.
 @@ -108,23 +108,23 @@ struct dirhash {
 	TAILQ_ENTRY(dirhash) dh_list;	/* chain of all dirhashes */
 };
 /*
  * Dirhash functions.
  */
 int	ulfsdirhash_build(struct inode *);
 doff_t	ulfsdirhash_findfree(struct inode *, int, int *);
 doff_t	ulfsdirhash_enduseful(struct inode *);
 int	ulfsdirhash_lookup(struct inode *, const char *, int, doff_t *,
 	    struct buf **, doff_t *);
 void	ulfsdirhash_newblk(struct inode *, doff_t);
-void	ulfsdirhash_add(struct inode *, struct direct *, doff_t);
+void	ulfsdirhash_add(struct inode *, struct lfs_direct *, doff_t);
-void	ulfsdirhash_remove(struct inode *, struct direct *, doff_t);
+void	ulfsdirhash_remove(struct inode *, struct lfs_direct *, doff_t);
-void	ulfsdirhash_move(struct inode *, struct direct *, doff_t, doff_t);
+void	ulfsdirhash_move(struct inode *, struct lfs_direct *, doff_t, doff_t);
 void	ulfsdirhash_dirtrunc(struct inode *, doff_t);
 void	ulfsdirhash_free(struct inode *);
 void	ulfsdirhash_checkblock(struct inode *, char *, doff_t);
 void	ulfsdirhash_init(void);
 void	ulfsdirhash_done(void);
 #endif /* !_UFS_LFS_ULFS_DIRHASH_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_extern.h,v 1.5 2013/06/06 00:52:14 dholland Exp $	*/
+/*	$NetBSD: ulfs_extern.h,v 1.6 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: ufs_extern.h,v 1.72 2012/05/09 00:21:18 riastradh Exp  */
 /*-
  * Copyright (c) 1991, 1993, 1994
  *	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
 @@ -29,46 +29,46 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)ufs_extern.h	8.10 (Berkeley) 5/14/95
  */
 #ifndef _UFS_LFS_ULFS_EXTERN_H_
 #define _UFS_LFS_ULFS_EXTERN_H_
 #include <sys/mutex.h>
 struct buf;
 struct componentname;
 struct direct;
 struct disklabel;
 struct dquot;
 struct fid;
 struct flock;
 struct indir;
 struct inode;
 struct mbuf;
 struct mount;
 struct nameidata;
 struct lfs_direct;
 struct lwp;
 struct ulfs_ufid;
 struct ulfs_args;
 struct ulfs_lookup_results;
 struct ulfs_ufid;
 struct ulfsmount;
 struct uio;
 struct vattr;
 struct vnode;
-extern pool_cache_t ulfs_direct_cache;	/* memory pool for directs */
+extern pool_cache_t ulfs_direct_cache;	/* memory pool for lfs_directs */
 __BEGIN_DECLS
 #define	ulfs_abortop	genfs_abortop
 int	ulfs_access(void *);
 int	ulfs_advlock(void *);
 int	ulfs_bmap(void *);
 int	ulfs_close(void *);
 int	ulfs_create(void *);
 int	ulfs_getattr(void *);
 int	ulfs_inactive(void *);
 #define	ulfs_fcntl	genfs_fcntl
 #define	ulfs_ioctl	genfs_enoioctl
 #define	ulfs_islocked	genfs_islocked
 @@ -114,31 +114,31 @@ void	ulfs_ihashinit(void);
 void	ulfs_ihashreinit(void);
 void	ulfs_ihashdone(void);
 struct vnode *ulfs_ihashlookup(dev_t, ino_t);
 struct vnode *ulfs_ihashget(dev_t, ino_t, int);
 void	ulfs_ihashins(struct inode *);
 void	ulfs_ihashrem(struct inode *);
 /* ulfs_inode.c */
 int	ulfs_reclaim(struct vnode *);
 int	ulfs_balloc_range(struct vnode *, off_t, off_t, kauth_cred_t, int);
 /* ulfs_lookup.c */
 void	ulfs_dirbad(struct inode *, doff_t, const char *);
-int	ulfs_dirbadentry(struct vnode *, struct direct *, int);
+int	ulfs_dirbadentry(struct vnode *, struct lfs_direct *, int);
 void	ulfs_makedirentry(struct inode *, struct componentname *,
-			 struct direct *);
+			 struct lfs_direct *);
 int	ulfs_direnter(struct vnode *, const struct ulfs_lookup_results *,
-		     struct vnode *, struct direct *,
+		     struct vnode *, struct lfs_direct *,
 		     struct componentname *, struct buf *);
 int	ulfs_dirremove(struct vnode *, const struct ulfs_lookup_results *,
 		      struct inode *, int, int);
 int	ulfs_dirrewrite(struct inode *, off_t,
 		       struct inode *, ino_t, int, int, int);
 int	ulfs_dirempty(struct inode *, ino_t, kauth_cred_t);
 int	ulfs_checkpath(struct inode *, struct inode *, kauth_cred_t);
 int	ulfs_parentcheck(struct vnode *, struct vnode *, kauth_cred_t,
 			int *, struct vnode **);
 int	ulfs_blkatoff(struct vnode *, off_t, char **, struct buf **, bool);
 /* ulfs_rename.c -- for lfs */
 bool	ulfs_gro_directory_empty_p(struct mount *, kauth_cred_t,

 @@ -1,14 +1,14 @@
-/* $NetBSD: extern.h,v 1.10 2013/06/06 00:52:50 dholland Exp $	 */
+/* $NetBSD: extern.h,v 1.11 2013/06/08 02:12:56 dholland Exp $	 */
 /*
  * Copyright (c) 1994 James A. Jegers
  * 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. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
 @@ -26,27 +26,27 @@
 void adjust(struct inodesc *, short);
 int allocblk(long);
 int allocdir(ino_t, ino_t, int);
 void blkerror(ino_t, const char *, daddr_t);
 void cacheino(struct ulfs1_dinode *, ino_t);
 int changeino(ino_t, const char *, ino_t);
 struct fstab;
 void checkinode(ino_t, struct inodesc *);
 int chkrange(daddr_t, int);
 void ckfini(int);
 int ckinode(struct ulfs1_dinode *, struct inodesc *);
 void clri(struct inodesc *, const char *, int);
-int dircheck(struct inodesc *, struct direct *);
+int dircheck(struct inodesc *, struct lfs_direct *);
 void direrror(ino_t, const char *);
 int dirscan(struct inodesc *);
 int dofix(struct inodesc *, const char *);
 void fileerror(ino_t, ino_t, const char *);
 int findino(struct inodesc *);
 int findname(struct inodesc *);
 void flush(int, struct ubufarea *);
 void freeblk(daddr_t, long);
 void freeino(ino_t);
 void freeinodebuf(void);
 int ftypeok(struct ulfs1_dinode *);
 void getpathname(char *, size_t, ino_t, ino_t);
 void inocleanup(void);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_dinode.h,v 1.7 2013/06/08 02:11:49 dholland Exp $	*/
+/*	$NetBSD: ulfs_dinode.h,v 1.8 2013/06/08 02:12:56 dholland Exp $	*/
 /*  from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp  */
 /*
  * Copyright (c) 2002 Networks Associates Technology, Inc.
  * All rights reserved.
+ *
  * This software was developed for the FreeBSD Project by Marshall
  * Kirk McKusick and Network Associates Laboratories, the Security
  * Research Division of Network Associates, Inc. under DARPA/SPAWAR
  * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
  * research program
+ *
  * Copyright (c) 1982, 1989, 1993
 @@ -56,27 +56,27 @@
 #include <ufs/lfs/lfs.h>
 /*
  * The root inode is the root of the file system.  Inode 0 can't be used for
  * normal purposes and historically bad blocks were linked to inode 1, thus
  * the root inode is 2.  (Inode 1 is no longer used for this purpose, however
  * numerous dump tapes make this assumption, so we are stuck with it).
  */
 #define	ULFS_ROOTINO	((ino_t)2)
 /*
  * The Whiteout inode# is a dummy non-zero inode number which will
  * never be allocated to a real file.  It is used as a place holder
- * in the directory entry which has been tagged as a DT_W entry.
+ * in the directory entry which has been tagged as a LFS_DT_WHT entry.
  * See the comments about ULFS_ROOTINO above.
  */
 #define	ULFS_WINO	((ino_t)1)
 /*
  * Maximum length of a symlink that can be stored within the inode.
  */
 #define ULFS1_MAXSYMLINKLEN	((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int32_t))
 #define ULFS2_MAXSYMLINKLEN	((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int64_t))
 #define ULFS_MAXSYMLINKLEN(ip) \
 	((ip)->i_ump->um_fstype == ULFS1) ? \
 	ULFS1_MAXSYMLINKLEN : ULFS2_MAXSYMLINKLEN