D9536.id24996.diff
No OneTemporary
Actions

Size

129 KB

Referenced Files

None

Subscribers

None

D9536.id24996.diff
View Options

	Index: lib/libstand/ext2fs.c
	===================================================================
	--- lib/libstand/ext2fs.c
	+++ lib/libstand/ext2fs.c
	@@ -130,8 +130,8 @@
	#define EXT2_MINBSHIFT 10 /* mininum block shift */
	#define EXT2_MINFSHIFT 10 /* mininum frag shift */

	-#define NDADDR 12 /* # of direct blocks */
	-#define NIADDR 3 /* # of indirect blocks */
	+#define EXT2_NDADDR 12 /* # of direct blocks */
	+#define EXT2_NIADDR 3 /* # of indirect blocks */

	/*
	* file system block to disk address
	@@ -162,7 +162,7 @@
	#define fragroundup(fs, size) /* roundup(size, fsize) */ \
	(((size) + (fs)->fs_fmask) & ~(fs)->fs_fmask)
	#define dblksize(fs, dip, lbn) \
	- (((lbn) >= NDADDR \|\| (dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \
	+ (((lbn) >= EXT2_NDADDR \|\| (dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \
	? (fs)->fs_bsize \
	: (fragroundup(fs, blkoff(fs, (dip)->di_size))))

	@@ -275,8 +275,8 @@

	u_int32_t di_osdep1; /* os dependent stuff */

	- u_int32_t di_db[NDADDR]; /* direct blocks */
	- u_int32_t di_ib[NIADDR]; /* indirect blocks */
	+ u_int32_t di_db[EXT2_NDADDR]; /* direct blocks */
	+ u_int32_t di_ib[EXT2_NIADDR]; /* indirect blocks */
	u_int32_t di_version; /* version */
	u_int32_t di_facl; /* file acl */
	u_int32_t di_dacl; /* dir acl */
	@@ -305,12 +305,12 @@
	struct ext2fs f_fs; / pointer to super-block */
	struct ext2blkgrp f_bg; / pointer to blkgrp map */
	struct ext2dinode f_di; /* copy of on-disk inode */
	- int f_nindir[NIADDR]; /* number of blocks mapped by
	+ int f_nindir[EXT2_NIADDR]; /* number of blocks mapped by
	indirect block at level i */
	- char f_blk[NIADDR]; / buffer for indirect block
	+ char f_blk[EXT2_NIADDR]; / buffer for indirect block
	at level i */
	- size_t f_blksize[NIADDR]; /* size of buffer */
	- daddr_t f_blkno[NIADDR]; /* disk address of block in
	+ size_t f_blksize[EXT2_NIADDR]; /* size of buffer */
	+ daddr_t f_blkno[EXT2_NIADDR]; /* disk address of block in
	buffer */
	char f_buf; / buffer for data block */
	size_t f_buf_size; /* size of data block */
	@@ -411,7 +411,7 @@
	* Calculate indirect block levels.
	*/
	mult = 1;
	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < EXT2_NIADDR; i++) {
	mult *= nindir(fs);
	fp->f_nindir[i] = mult;
	}
	@@ -582,7 +582,7 @@
	fp->f_di = dp[ino_to_bo(fs, inumber)];

	/* clear out old buffers */
	- for (level = 0; level < NIADDR; level++)
	+ for (level = 0; level < EXT2_NIADDR; level++)
	fp->f_blkno[level] = -1;
	fp->f_buf_blkno = -1;
	fp->f_seekp = 0;
	@@ -609,33 +609,33 @@
	/*
	* Index structure of an inode:
	*
	- * di_db[0..NDADDR-1] hold block numbers for blocks
	- * 0..NDADDR-1
	+ * di_db[0..EXT2_NDADDR-1] hold block numbers for blocks
	+ * 0..EXT2_NDADDR-1
	*
	* di_ib[0] index block 0 is the single indirect block
	* holds block numbers for blocks
	- * NDADDR .. NDADDR + NINDIR(fs)-1
	+ * EXT2_NDADDR .. EXT2_NDADDR + NINDIR(fs)-1
	*
	* di_ib[1] index block 1 is the double indirect block
	* holds block numbers for INDEX blocks for blocks
	- * NDADDR + NINDIR(fs) ..
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
	+ * EXT2_NDADDR + NINDIR(fs) ..
	+ * EXT2_NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
	*
	* di_ib[2] index block 2 is the triple indirect block
	* holds block numbers for double-indirect
	* blocks for blocks
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2
	+ * EXT2_NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
	+ * EXT2_NDADDR + NINDIR(fs) + NINDIR(fs)**2
	* + NINDIR(fs)**3 - 1
	*/

	- if (file_block < NDADDR) {
	+ if (file_block < EXT2_NDADDR) {
	/* Direct block. */
	*disk_block_p = fp->f_di.di_db[file_block];
	return (0);
	}

	- file_block -= NDADDR;
	+ file_block -= EXT2_NDADDR;

	/*
	* nindir[0] = NINDIR
	@@ -643,12 +643,12 @@
	* nindir[2] = NINDIR**3
	* etc
	*/
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < EXT2_NIADDR; level++) {
	if (file_block < fp->f_nindir[level])
	break;
	file_block -= fp->f_nindir[level];
	}
	- if (level == NIADDR) {
	+ if (level == EXT2_NIADDR) {
	/* Block number too high */
	return (EFBIG);
	}
	@@ -800,7 +800,7 @@
	if (fp == (struct file *)0)
	return (0);

	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < EXT2_NIADDR; level++) {
	if (fp->f_blk[level])
	free(fp->f_blk[level]);
	}
	Index: lib/libstand/nandfs.c
	===================================================================
	--- lib/libstand/nandfs.c
	+++ lib/libstand/nandfs.c
	@@ -85,7 +85,7 @@
	struct nandfs_mdt nf_datfile_mdt;
	struct nandfs_mdt nf_ifile_mdt;

	- int nf_nindir[NIADDR];
	+ int nf_nindir[NANDFS_NIADDR];
	};

	static int nandfs_open(const char , struct open_file );
	@@ -313,7 +313,7 @@
	nandfs_daddr_t mult;

	mult = 1;
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < NANDFS_NIADDR; level++) {
	mult *= NINDIR(fs);
	fs->nf_nindir[level] = mult;
	}
	@@ -392,7 +392,7 @@
	nandfs_daddr_t mult;

	mult = 1;
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < NANDFS_NIADDR; level++) {
	mult *= NINDIR(fs);
	fs->nf_nindir[level] = mult;
	}
	@@ -887,12 +887,12 @@

	ino = node->inode;

	- if (lblknr < NDADDR) {
	+ if (lblknr < UFS_NDADDR) {
	*vblknr = ino->i_db[lblknr];
	return (0);
	}

	- lblknr -= NDADDR;
	+ lblknr -= UFS_NDADDR;

	/*
	* nindir[0] = NINDIR
	@@ -900,14 +900,14 @@
	* nindir[2] = NINDIR**3
	* etc
	*/
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < NANDFS_NIADDR; level++) {
	NANDFS_DEBUG("lblknr=%jx fs->nf_nindir[%d]=%d\n", lblknr, level, fs->nf_nindir[level]);
	if (lblknr < fs->nf_nindir[level])
	break;
	lblknr -= fs->nf_nindir[level];
	}

	- if (level == NIADDR) {
	+ if (level == NANDFS_NIADDR) {
	/* Block number too high */
	NANDFS_DEBUG("lblknr %jx too high\n", lblknr);
	return (EFBIG);
	Index: lib/libstand/ufs.c
	===================================================================
	--- lib/libstand/ufs.c
	+++ lib/libstand/ufs.c
	@@ -112,14 +112,14 @@
	struct ufs1_dinode di1;
	struct ufs2_dinode di2;
	} f_di; /* copy of on-disk inode */
	- int f_nindir[NIADDR];
	+ int f_nindir[UFS_NIADDR];
	/* number of blocks mapped by
	indirect block at level i */
	- char f_blk[NIADDR]; / buffer for indirect block at
	+ char f_blk[UFS_NIADDR]; / buffer for indirect block at
	level i */
	- size_t f_blksize[NIADDR];
	+ size_t f_blksize[UFS_NIADDR];
	/* size of buffer */
	- ufs2_daddr_t f_blkno[NIADDR];/* disk address of block in buffer */
	+ ufs2_daddr_t f_blkno[UFS_NIADDR];/* disk address of block in buffer */
	ufs2_daddr_t f_buf_blkno; /* block number of data block */
	char f_buf; / buffer for data block */
	size_t f_buf_size; /* size of data block */
	@@ -179,7 +179,7 @@
	{
	int level;

	- for (level = 0; level < NIADDR; level++)
	+ for (level = 0; level < UFS_NIADDR; level++)
	fp->f_blkno[level] = -1;
	fp->f_buf_blkno = -1;
	}
	@@ -209,33 +209,33 @@
	/*
	* Index structure of an inode:
	*
	- * di_db[0..NDADDR-1] hold block numbers for blocks
	- * 0..NDADDR-1
	+ * di_db[0..UFS_NDADDR-1] hold block numbers for blocks
	+ * 0..UFS_NDADDR-1
	*
	* di_ib[0] index block 0 is the single indirect block
	* holds block numbers for blocks
	- * NDADDR .. NDADDR + NINDIR(fs)-1
	+ * UFS_NDADDR .. UFS_NDADDR + NINDIR(fs)-1
	*
	* di_ib[1] index block 1 is the double indirect block
	* holds block numbers for INDEX blocks for blocks
	- * NDADDR + NINDIR(fs) ..
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
	+ * UFS_NDADDR + NINDIR(fs) ..
	+ * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
	*
	* di_ib[2] index block 2 is the triple indirect block
	* holds block numbers for double-indirect
	* blocks for blocks
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
	- * NDADDR + NINDIR(fs) + NINDIR(fs)**2
	+ * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
	+ * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2
	* + NINDIR(fs)**3 - 1
	*/

	- if (file_block < NDADDR) {
	+ if (file_block < UFS_NDADDR) {
	/* Direct block. */
	*disk_block_p = DIP(fp, di_db[file_block]);
	return (0);
	}

	- file_block -= NDADDR;
	+ file_block -= UFS_NDADDR;

	/*
	* nindir[0] = NINDIR
	@@ -243,12 +243,12 @@
	* nindir[2] = NINDIR**3
	* etc
	*/
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < UFS_NIADDR; level++) {
	if (file_block < fp->f_nindir[level])
	break;
	file_block -= fp->f_nindir[level];
	}
	- if (level == NIADDR) {
	+ if (level == UFS_NIADDR) {
	/* Block number too high */
	return (EFBIG);
	}
	@@ -545,13 +545,13 @@
	int level;

	mult = 1;
	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < UFS_NIADDR; level++) {
	mult *= NINDIR(fs);
	fp->f_nindir[level] = mult;
	}
	}

	- inumber = ROOTINO;
	+ inumber = UFS_ROOTINO;
	if ((rc = read_inode(inumber, f)) != 0)
	goto out;

	@@ -667,7 +667,7 @@
	if (*cp != '/')
	inumber = parent_inumber;
	else
	- inumber = (ino_t)ROOTINO;
	+ inumber = (ino_t)UFS_ROOTINO;

	if ((rc = read_inode(inumber, f)) != 0)
	goto out;
	@@ -704,7 +704,7 @@
	if (fp == (struct file *)0)
	return (0);

	- for (level = 0; level < NIADDR; level++) {
	+ for (level = 0; level < UFS_NIADDR; level++) {
	if (fp->f_blk[level])
	free(fp->f_blk[level]);
	}
	Index: sbin/dump/traverse.c
	===================================================================
	--- sbin/dump/traverse.c
	+++ sbin/dump/traverse.c
	@@ -118,11 +118,10 @@
	sizeest = howmany(DIP(dp, di_size), TP_BSIZE);
	if (blkest > sizeest)
	blkest = sizeest;
	- if (DIP(dp, di_size) > sblock->fs_bsize * NDADDR) {
	+ if (DIP(dp, di_size) > sblock->fs_bsize * UFS_NDADDR) {
	/* calculate the number of indirect blocks on the dump tape */
	- blkest +=
	- howmany(sizeest - NDADDR * sblock->fs_bsize / TP_BSIZE,
	- TP_NINDIR);
	+ blkest += howmany(sizeest -
	+ UFS_NDADDR * sblock->fs_bsize / TP_BSIZE, TP_NINDIR);
	}
	return (blkest + 1);
	}
	@@ -192,7 +191,7 @@
	continue;
	}
	for (i = 0; i < inosused; i++, ino++) {
	- if (ino < ROOTINO \|\|
	+ if (ino < UFS_ROOTINO \|\|
	(dp = getino(ino, &mode)) == NULL \|\|
	(mode & IFMT) == 0)
	continue;
	@@ -232,7 +231,7 @@
	* Restore gets very upset if the root is not dumped,
	* so ensure that it always is dumped.
	*/
	- SETINO(ROOTINO, dumpinomap);
	+ SETINO(UFS_ROOTINO, dumpinomap);
	return (anydirskipped);
	}

	@@ -284,7 +283,7 @@
	else
	di.dp2 = dp->dp2;
	filesize = DIP(&di, di_size);
	- for (ret = 0, i = 0; filesize > 0 && i < NDADDR; i++) {
	+ for (ret = 0, i = 0; filesize > 0 && i < UFS_NDADDR; i++) {
	if (DIP(&di, di_db[i]) != 0)
	ret \|= searchdir(ino, DIP(&di, di_db[i]),
	(long)sblksize(sblock, DIP(&di, di_size),
	@@ -294,7 +293,7 @@
	else
	filesize -= sblock->fs_bsize;
	}
	- for (i = 0; filesize > 0 && i < NIADDR; i++) {
	+ for (i = 0; filesize > 0 && i < UFS_NIADDR; i++) {
	if (DIP(&di, di_ib[i]) == 0)
	continue;
	ret \|= dirindir(ino, DIP(&di, di_ib[i]), i, &filesize,
	@@ -556,8 +555,8 @@
	DIP(dp, di_mode) & IFMT);
	return;
	}
	- if (DIP(dp, di_size) > NDADDR * sblock->fs_bsize) {
	- cnt = NDADDR * sblock->fs_frag;
	+ if (DIP(dp, di_size) > UFS_NDADDR * sblock->fs_bsize) {
	+ cnt = UFS_NDADDR * sblock->fs_frag;
	last = 0;
	} else {
	cnt = howmany(DIP(dp, di_size), sblock->fs_fsize);
	@@ -567,9 +566,9 @@
	ufs1_blksout(&dp->dp1.di_db[0], cnt, ino);
	else
	ufs2_blksout(dp, &dp->dp2.di_db[0], cnt, ino, last);
	- if ((size = DIP(dp, di_size) - NDADDR * sblock->fs_bsize) <= 0)
	+ if ((size = DIP(dp, di_size) - UFS_NDADDR * sblock->fs_bsize) <= 0)
	return;
	- for (ind_level = 0; ind_level < NIADDR; ind_level++) {
	+ for (ind_level = 0; ind_level < UFS_NIADDR; ind_level++) {
	dmpindir(dp, ino, DIP(dp, di_ib[ind_level]), ind_level, &size);
	if (size <= 0)
	return;
	@@ -740,8 +739,8 @@
	* part of them here, we simply push them entirely into a
	* new block rather than putting some here and some later.
	*/
	- if (spcl.c_extsize > NXADDR * sblock->fs_bsize)
	- blks = howmany(NXADDR * sblock->fs_bsize, TP_BSIZE);
	+ if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize)
	+ blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);
	else
	blks = howmany(spcl.c_extsize, TP_BSIZE);
	if (spcl.c_count + blks > TP_NINDIR)
	@@ -784,8 +783,8 @@
	* dump them out in a new block, otherwise just dump the data.
	*/
	if (added == 0) {
	- if (spcl.c_extsize > NXADDR * sblock->fs_bsize) {
	- frags = NXADDR * sblock->fs_frag;
	+ if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize) {
	+ frags = UFS_NXADDR * sblock->fs_frag;
	last = 0;
	} else {
	frags = howmany(spcl.c_extsize, sblock->fs_fsize);
	@@ -793,8 +792,8 @@
	}
	ufs2_blksout(dp, &dp->dp2.di_extb[0], frags, ino, last);
	} else {
	- if (spcl.c_extsize > NXADDR * sblock->fs_bsize)
	- blks = howmany(NXADDR * sblock->fs_bsize, TP_BSIZE);
	+ if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize)
	+ blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);
	else
	blks = howmany(spcl.c_extsize, TP_BSIZE);
	tbperdb = sblock->fs_bsize >> tp_bshift;
	@@ -820,7 +819,7 @@
	* If the extended attributes fall into an indirect block,
	* dump it as well.
	*/
	- if ((size = spcl.c_extsize - NXADDR * sblock->fs_bsize) > 0)
	+ if ((size = spcl.c_extsize - UFS_UFS_NXADDR * sblock->fs_bsize) > 0)
	dmpindir(dp, ino, dp->dp2.di_exti, 0, &size);
	}

	Index: sbin/ffsinfo/ffsinfo.c
	===================================================================
	--- sbin/ffsinfo/ffsinfo.c
	+++ sbin/ffsinfo/ffsinfo.c
	@@ -377,7 +377,7 @@
	/*
	* Ok, now prepare for dumping all direct and indirect pointers.
	*/
	- rb=howmany(ino->di_size, sblock.fs_bsize)-NDADDR;
	+ rb = howmany(ino->di_size, sblock.fs_bsize) - UFS_NDADDR;
	if(rb>0) {
	/*
	* Dump single indirect block.
	@@ -529,7 +529,7 @@
	/*
	* Ok, now prepare for dumping all direct and indirect pointers.
	*/
	- rb = howmany(ino->di_size, sblock.fs_bsize) - NDADDR;
	+ rb = howmany(ino->di_size, sblock.fs_bsize) - UFS_NDADDR;
	if (rb > 0) {
	/*
	* Dump single indirect block.
	Index: sbin/fsck_ffs/dir.c
	===================================================================
	--- sbin/fsck_ffs/dir.c
	+++ sbin/fsck_ffs/dir.c
	@@ -255,7 +255,7 @@
	pinode(ino);
	printf("\n");
	getpathname(pathbuf, cwd, ino);
	- if (ino < ROOTINO \|\| ino > maxino) {
	+ if (ino < UFS_ROOTINO \|\| ino > maxino) {
	pfatal("NAME=%s\n", pathbuf);
	return;
	}
	@@ -401,24 +401,25 @@
	if (reply("RECONNECT") == 0)
	return (0);
	if (lfdir == 0) {
	- dp = ginode(ROOTINO);
	+ dp = ginode(UFS_ROOTINO);
	idesc.id_name = strdup(lfname);
	idesc.id_type = DATA;
	idesc.id_func = findino;
	- idesc.id_number = ROOTINO;
	+ idesc.id_number = UFS_ROOTINO;
	if ((ckinode(dp, &idesc) & FOUND) != 0) {
	lfdir = idesc.id_parent;
	} else {
	pwarn("NO lost+found DIRECTORY");
	if (preen \|\| reply("CREATE")) {
	- lfdir = allocdir(ROOTINO, (ino_t)0, lfmode);
	+ lfdir = allocdir(UFS_ROOTINO, (ino_t)0, lfmode);
	if (lfdir != 0) {
	- if (makeentry(ROOTINO, lfdir, lfname) != 0) {
	+ if (makeentry(UFS_ROOTINO, lfdir,
	+ lfname) != 0) {
	numdirs++;
	if (preen)
	printf(" (CREATED)\n");
	} else {
	- freedir(lfdir, ROOTINO);
	+ freedir(lfdir, UFS_ROOTINO);
	lfdir = 0;
	if (preen)
	printf("\n");
	@@ -438,11 +439,11 @@
	if (reply("REALLOCATE") == 0)
	return (0);
	oldlfdir = lfdir;
	- if ((lfdir = allocdir(ROOTINO, (ino_t)0, lfmode)) == 0) {
	+ if ((lfdir = allocdir(UFS_ROOTINO, (ino_t)0, lfmode)) == 0) {
	pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
	return (0);
	}
	- if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) {
	+ if ((changeino(UFS_ROOTINO, lfname, lfdir) & ALTERED) == 0) {
	pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
	return (0);
	}
	@@ -519,8 +520,8 @@
	struct inodesc idesc;
	char pathbuf[MAXPATHLEN + 1];

	- if (parent < ROOTINO \|\| parent >= maxino \|\|
	- ino < ROOTINO \|\| ino >= maxino)
	+ if (parent < UFS_ROOTINO \|\| parent >= maxino \|\|
	+ ino < UFS_ROOTINO \|\| ino >= maxino)
	return (0);
	memset(&idesc, 0, sizeof(struct inodesc));
	idesc.id_type = DATA;
	@@ -554,7 +555,7 @@
	char *cp, firstblk[DIRBLKSIZ];

	lastbn = lblkno(&sblock, DIP(dp, di_size));
	- if (lastbn >= NDADDR - 1 \|\| DIP(dp, di_db[lastbn]) == 0 \|\|
	+ if (lastbn >= UFS_NDADDR - 1 \|\| DIP(dp, di_db[lastbn]) == 0 \|\|
	DIP(dp, di_size) == 0)
	return (0);
	if ((newblk = allocblk(sblock.fs_frag)) == 0)
	@@ -630,7 +631,7 @@
	dirty(bp);
	DIP_SET(dp, di_nlink, 2);
	inodirty();
	- if (ino == ROOTINO) {
	+ if (ino == UFS_ROOTINO) {
	inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
	cacheino(dp, ino);
	return(ino);
	Index: sbin/fsck_ffs/fsutil.c
	===================================================================
	--- sbin/fsck_ffs/fsutil.c
	+++ sbin/fsck_ffs/fsutil.c
	@@ -854,7 +854,7 @@
	struct inodesc idesc;
	static int busy = 0;

	- if (curdir == ino && ino == ROOTINO) {
	+ if (curdir == ino && ino == UFS_ROOTINO) {
	(void)strcpy(namebuf, "/");
	return;
	}
	@@ -872,7 +872,7 @@
	idesc.id_parent = curdir;
	goto namelookup;
	}
	- while (ino != ROOTINO) {
	+ while (ino != UFS_ROOTINO) {
	idesc.id_number = ino;
	idesc.id_func = findino;
	idesc.id_name = strdup("..");
	@@ -894,7 +894,7 @@
	ino = idesc.id_number;
	}
	busy = 0;
	- if (ino != ROOTINO)
	+ if (ino != UFS_ROOTINO)
	*--cp = '?';
	memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
	}
	Index: sbin/fsck_ffs/gjournal.c
	===================================================================
	--- sbin/fsck_ffs/gjournal.c
	+++ sbin/fsck_ffs/gjournal.c
	@@ -367,7 +367,7 @@
	osize = dino->di_extsize;
	dino->di_blocks -= extblocks;
	dino->di_extsize = 0;
	- for (i = 0; i < NXADDR; i++) {
	+ for (i = 0; i < UFS_NXADDR; i++) {
	if (dino->di_extb[i] == 0)
	continue;
	blkfree(dino->di_extb[i], sblksize(fs, osize, i));
	@@ -383,7 +383,7 @@
	freeindir(dino->di_ib[level], level);
	}
	/* deallocate direct blocks and fragments */
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	bn = dino->di_db[i];
	if (bn == 0)
	continue;
	Index: sbin/fsck_ffs/inode.c
	===================================================================
	--- sbin/fsck_ffs/inode.c
	+++ sbin/fsck_ffs/inode.c
	@@ -78,7 +78,7 @@
	else
	dino.dp2 = dp->dp2;
	ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	idesc->id_lbn++;
	if (--ndb == 0 &&
	(offset = blkoff(&sblock, DIP(&dino, di_size))) != 0)
	@@ -115,9 +115,9 @@
	return (ret);
	}
	idesc->id_numfrags = sblock.fs_frag;
	- remsize = DIP(&dino, di_size) - sblock.fs_bsize * NDADDR;
	+ remsize = DIP(&dino, di_size) - sblock.fs_bsize * UFS_NDADDR;
	sizepb = sblock.fs_bsize;
	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < UFS_NIADDR; i++) {
	sizepb *= NINDIR(&sblock);
	if (DIP(&dino, di_ib[i])) {
	idesc->id_blkno = DIP(&dino, di_ib[i]);
	@@ -284,7 +284,7 @@
	{
	ufs2_daddr_t iblk;

	- if (inumber < ROOTINO \|\| inumber > maxino)
	+ if (inumber < UFS_ROOTINO \|\| inumber > maxino)
	errx(EEXIT, "bad inode number %ju to ginode",
	(uintmax_t)inumber);
	if (startinum == 0 \|\|
	@@ -348,9 +348,9 @@
	mode = DIP(dp, di_mode) & IFMT;
	if (mode == 0) {
	if (memcmp(dp->dp2.di_db, ufs2_zino.di_db,
	- NDADDR * sizeof(ufs2_daddr_t)) \|\|
	+ UFS_NDADDR * sizeof(ufs2_daddr_t)) \|\|
	memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
	- NIADDR * sizeof(ufs2_daddr_t)) \|\|
	+ UFS_NIADDR * sizeof(ufs2_daddr_t)) \|\|
	dp->dp2.di_mode \|\| dp->dp2.di_size)
	return (NULL);
	goto inodegood;
	@@ -370,20 +370,20 @@
	if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {
	ndb = howmany(DIP(dp, di_size),
	sizeof(ufs2_daddr_t));
	- if (ndb > NDADDR) {
	- j = ndb - NDADDR;
	+ if (ndb > UFS_NDADDR) {
	+ j = ndb - UFS_NDADDR;
	for (ndb = 1; j > 1; j--)
	ndb *= NINDIR(&sblock);
	- ndb += NDADDR;
	+ ndb += UFS_NDADDR;
	}
	}
	}
	- for (j = ndb; ndb < NDADDR && j < NDADDR; j++)
	+ for (j = ndb; ndb < UFS_NDADDR && j < UFS_NDADDR; j++)
	if (DIP(dp, di_db[j]) != 0)
	return (NULL);
	- for (j = 0, ndb -= NDADDR; ndb > 0; j++)
	+ for (j = 0, ndb -= UFS_NDADDR; ndb > 0; j++)
	ndb /= NINDIR(&sblock);
	- for (; j < NIADDR; j++)
	+ for (; j < UFS_NIADDR; j++)
	if (DIP(dp, di_ib[j]) != 0)
	return (NULL);
	}
	@@ -449,8 +449,8 @@
	struct inoinfo inp, *inpp;
	int i, blks;

	- if (howmany(DIP(dp, di_size), sblock.fs_bsize) > NDADDR)
	- blks = NDADDR + NIADDR;
	+ if (howmany(DIP(dp, di_size), sblock.fs_bsize) > UFS_NDADDR)
	+ blks = UFS_NDADDR + UFS_NIADDR;
	else
	blks = howmany(DIP(dp, di_size), sblock.fs_bsize);
	inp = (struct inoinfo *)
	@@ -460,16 +460,16 @@
	inpp = &inphead[inumber % dirhash];
	inp->i_nexthash = *inpp;
	*inpp = inp;
	- inp->i_parent = inumber == ROOTINO ? ROOTINO : (ino_t)0;
	+ inp->i_parent = inumber == UFS_ROOTINO ? UFS_ROOTINO : (ino_t)0;
	inp->i_dotdot = (ino_t)0;
	inp->i_number = inumber;
	inp->i_isize = DIP(dp, di_size);
	inp->i_numblks = blks;
	- for (i = 0; i < MIN(blks, NDADDR); i++)
	+ for (i = 0; i < MIN(blks, UFS_NDADDR); i++)
	inp->i_blks[i] = DIP(dp, di_db[i]);
	- if (blks > NDADDR)
	- for (i = 0; i < NIADDR; i++)
	- inp->i_blks[NDADDR + i] = DIP(dp, di_ib[i]);
	+ if (blks > UFS_NDADDR)
	+ for (i = 0; i < UFS_NIADDR; i++)
	+ inp->i_blks[UFS_NDADDR + i] = DIP(dp, di_ib[i]);
	if (inplast == listmax) {
	listmax += 100;
	inpsort = (struct inoinfo *)realloc((char )inpsort,
	@@ -575,7 +575,7 @@
	if (dirp->d_ino == 0)
	return (KEEPON);
	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
	- dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
	+ dirp->d_ino >= UFS_ROOTINO && dirp->d_ino <= maxino) {
	idesc->id_parent = dirp->d_ino;
	return (STOP\|FOUND);
	}
	@@ -604,7 +604,7 @@
	time_t t;

	printf(" I=%lu ", (u_long)ino);
	- if (ino < ROOTINO \|\| ino > maxino)
	+ if (ino < UFS_ROOTINO \|\| ino > maxino)
	return;
	dp = ginode(ino);
	printf(" OWNER=");
	@@ -662,7 +662,7 @@
	int cg;

	if (request == 0)
	- request = ROOTINO;
	+ request = UFS_ROOTINO;
	else if (inoinfo(request)->ino_state != USTATE)
	return (0);
	for (ino = request; ino < maxino; ino++)
	Index: sbin/fsck_ffs/main.c
	===================================================================
	--- sbin/fsck_ffs/main.c
	+++ sbin/fsck_ffs/main.c
	@@ -500,7 +500,7 @@
	*/
	n_ffree = sblock.fs_cstotal.cs_nffree;
	n_bfree = sblock.fs_cstotal.cs_nbfree;
	- files = maxino - ROOTINO - sblock.fs_cstotal.cs_nifree - n_files;
	+ files = maxino - UFS_ROOTINO - sblock.fs_cstotal.cs_nifree - n_files;
	blks = n_blks +
	sblock.fs_ncg * (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
	blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
	Index: sbin/fsck_ffs/pass1.c
	===================================================================
	--- sbin/fsck_ffs/pass1.c
	+++ sbin/fsck_ffs/pass1.c
	@@ -163,7 +163,7 @@
	* Scan the allocated inodes.
	*/
	for (i = 0; i < inosused; i++, inumber++) {
	- if (inumber < ROOTINO) {
	+ if (inumber < UFS_ROOTINO) {
	(void)getnextinode(inumber, rebuildcg);
	continue;
	}
	@@ -250,15 +250,15 @@
	if (mode == 0) {
	if ((sblock.fs_magic == FS_UFS1_MAGIC &&
	(memcmp(dp->dp1.di_db, ufs1_zino.di_db,
	- NDADDR * sizeof(ufs1_daddr_t)) \|\|
	+ UFS_NDADDR * sizeof(ufs1_daddr_t)) \|\|
	memcmp(dp->dp1.di_ib, ufs1_zino.di_ib,
	- NIADDR * sizeof(ufs1_daddr_t)) \|\|
	+ UFS_NIADDR * sizeof(ufs1_daddr_t)) \|\|
	dp->dp1.di_mode \|\| dp->dp1.di_size)) \|\|
	(sblock.fs_magic == FS_UFS2_MAGIC &&
	(memcmp(dp->dp2.di_db, ufs2_zino.di_db,
	- NDADDR * sizeof(ufs2_daddr_t)) \|\|
	+ UFS_NDADDR * sizeof(ufs2_daddr_t)) \|\|
	memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
	- NIADDR * sizeof(ufs2_daddr_t)) \|\|
	+ UFS_NIADDR * sizeof(ufs2_daddr_t)) \|\|
	dp->dp2.di_mode \|\| dp->dp2.di_size))) {
	pfatal("PARTIALLY ALLOCATED INODE I=%lu",
	(u_long)inumber);
	@@ -324,24 +324,24 @@
	else
	ndb = howmany(DIP(dp, di_size),
	sizeof(ufs2_daddr_t));
	- if (ndb > NDADDR) {
	- j = ndb - NDADDR;
	+ if (ndb > UFS_NDADDR) {
	+ j = ndb - UFS_NDADDR;
	for (ndb = 1; j > 1; j--)
	ndb *= NINDIR(&sblock);
	- ndb += NDADDR;
	+ ndb += UFS_NDADDR;
	}
	}
	}
	- for (j = ndb; ndb < NDADDR && j < NDADDR; j++)
	+ for (j = ndb; ndb < UFS_NDADDR && j < UFS_NDADDR; j++)
	if (DIP(dp, di_db[j]) != 0) {
	if (debug)
	printf("bad direct addr[%d]: %ju\n", j,
	(uintmax_t)DIP(dp, di_db[j]));
	goto unknown;
	}
	- for (j = 0, ndb -= NDADDR; ndb > 0; j++)
	+ for (j = 0, ndb -= UFS_NDADDR; ndb > 0; j++)
	ndb /= NINDIR(&sblock);
	- for (; j < NIADDR; j++)
	+ for (; j < UFS_NIADDR; j++)
	if (DIP(dp, di_ib[j]) != 0) {
	if (debug)
	printf("bad indirect addr: %ju\n",
	@@ -376,7 +376,7 @@
	if (sblock.fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize > 0) {
	idesc->id_type = ADDR;
	ndb = howmany(dp->dp2.di_extsize, sblock.fs_bsize);
	- for (j = 0; j < NXADDR; j++) {
	+ for (j = 0; j < UFS_NXADDR; j++) {
	if (--ndb == 0 &&
	(offset = blkoff(&sblock, dp->dp2.di_extsize)) != 0)
	idesc->id_numfrags = numfrags(&sblock,
	Index: sbin/fsck_ffs/pass1b.c
	===================================================================
	--- sbin/fsck_ffs/pass1b.c
	+++ sbin/fsck_ffs/pass1b.c
	@@ -73,7 +73,7 @@
	got_sigalarm = 0;
	}
	for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
	- if (inumber < ROOTINO)
	+ if (inumber < UFS_ROOTINO)
	continue;
	dp = ginode(inumber);
	if (dp == NULL)
	Index: sbin/fsck_ffs/pass2.c
	===================================================================
	--- sbin/fsck_ffs/pass2.c
	+++ sbin/fsck_ffs/pass2.c
	@@ -67,7 +67,7 @@
	int i;
	char pathbuf[MAXPATHLEN + 1];

	- switch (inoinfo(ROOTINO)->ino_state) {
	+ switch (inoinfo(UFS_ROOTINO)->ino_state) {

	case USTATE:
	pfatal("ROOT INODE UNALLOCATED");
	@@ -75,15 +75,16 @@
	ckfini(0);
	exit(EEXIT);
	}
	- if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
	+ if (allocdir(UFS_ROOTINO, UFS_ROOTINO, 0755) != UFS_ROOTINO)
	errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
	break;

	case DCLEAR:
	pfatal("DUPS/BAD IN ROOT INODE");
	if (reply("REALLOCATE")) {
	- freeino(ROOTINO);
	- if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
	+ freeino(UFS_ROOTINO);
	+ if (allocdir(UFS_ROOTINO, UFS_ROOTINO, 0755) !=
	+ UFS_ROOTINO)
	errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
	break;
	}
	@@ -98,8 +99,9 @@
	case FZLINK:
	pfatal("ROOT INODE NOT DIRECTORY");
	if (reply("REALLOCATE")) {
	- freeino(ROOTINO);
	- if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
	+ freeino(UFS_ROOTINO);
	+ if (allocdir(UFS_ROOTINO, UFS_ROOTINO, 0755) !=
	+ UFS_ROOTINO)
	errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
	break;
	}
	@@ -107,7 +109,7 @@
	ckfini(0);
	exit(EEXIT);
	}
	- dp = ginode(ROOTINO);
	+ dp = ginode(UFS_ROOTINO);
	DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
	DIP_SET(dp, di_mode, DIP(dp, di_mode) \| IFDIR);
	inodirty();
	@@ -119,11 +121,11 @@

	default:
	errx(EEXIT, "BAD STATE %d FOR ROOT INODE",
	- inoinfo(ROOTINO)->ino_state);
	+ inoinfo(UFS_ROOTINO)->ino_state);
	}
	- inoinfo(ROOTINO)->ino_state = DFOUND;
	- inoinfo(WINO)->ino_state = FSTATE;
	- inoinfo(WINO)->ino_type = DT_WHT;
	+ inoinfo(UFS_ROOTINO)->ino_state = DFOUND;
	+ inoinfo(UFS_WINO)->ino_state = FSTATE;
	+ inoinfo(UFS_WINO)->ino_type = DT_WHT;
	/*
	* Sort the directory list into disk block order.
	*/
	@@ -182,11 +184,12 @@
	memset(dp, 0, sizeof(struct ufs2_dinode));
	DIP_SET(dp, di_mode, IFDIR);
	DIP_SET(dp, di_size, inp->i_isize);
	- for (i = 0; i < MIN(inp->i_numblks, NDADDR); i++)
	+ for (i = 0; i < MIN(inp->i_numblks, UFS_NDADDR); i++)
	DIP_SET(dp, di_db[i], inp->i_blks[i]);
	- if (inp->i_numblks > NDADDR)
	- for (i = 0; i < NIADDR; i++)
	- DIP_SET(dp, di_ib[i], inp->i_blks[NDADDR + i]);
	+ if (inp->i_numblks > UFS_NDADDR)
	+ for (i = 0; i < UFS_NIADDR; i++)
	+ DIP_SET(dp, di_ib[i],
	+ inp->i_blks[UFS_NDADDR + i]);
	curino.id_number = inp->i_number;
	curino.id_parent = inp->i_parent;
	(void)ckinode(dp, &curino);
	@@ -411,10 +414,10 @@
	if (dirp->d_ino > maxino) {
	fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE");
	n = reply("REMOVE");
	- } else if (((dirp->d_ino == WINO && dirp->d_type != DT_WHT) \|\|
	- (dirp->d_ino != WINO && dirp->d_type == DT_WHT))) {
	+ } else if (((dirp->d_ino == UFS_WINO && dirp->d_type != DT_WHT) \|\|
	+ (dirp->d_ino != UFS_WINO && dirp->d_type == DT_WHT))) {
	fileerror(idesc->id_number, dirp->d_ino, "BAD WHITEOUT ENTRY");
	- dirp->d_ino = WINO;
	+ dirp->d_ino = UFS_WINO;
	dirp->d_type = DT_WHT;
	if (reply("FIX") == 1)
	ret \|= ALTERED;
	Index: sbin/fsck_ffs/pass3.c
	===================================================================
	--- sbin/fsck_ffs/pass3.c
	+++ sbin/fsck_ffs/pass3.c
	@@ -68,7 +68,7 @@
	}
	inp = inpsort[inpindex];
	state = inoinfo(inp->i_number)->ino_state;
	- if (inp->i_number == ROOTINO \|\|
	+ if (inp->i_number == UFS_ROOTINO \|\|
	(inp->i_parent != 0 && !S_IS_DUNFOUND(state)))
	continue;
	if (state == DCLEAR)
	@@ -81,7 +81,7 @@
	*/
	if ((preen \|\| bkgrdflag) &&
	resolved && usedsoftdep && S_IS_DUNFOUND(state)) {
	- if (inp->i_dotdot >= ROOTINO)
	+ if (inp->i_dotdot >= UFS_ROOTINO)
	inoinfo(inp->i_dotdot)->ino_linkcnt++;
	continue;
	}
	Index: sbin/fsck_ffs/pass4.c
	===================================================================
	--- sbin/fsck_ffs/pass4.c
	+++ sbin/fsck_ffs/pass4.c
	@@ -71,7 +71,7 @@
	}
	inumber = cg * sblock.fs_ipg;
	for (i = 0; i < inostathead[cg].il_numalloced; i++, inumber++) {
	- if (inumber < ROOTINO)
	+ if (inumber < UFS_ROOTINO)
	continue;
	idesc.id_number = inumber;
	switch (inoinfo(inumber)->ino_state) {
	Index: sbin/fsck_ffs/pass5.c
	===================================================================
	--- sbin/fsck_ffs/pass5.c
	+++ sbin/fsck_ffs/pass5.c
	@@ -68,7 +68,7 @@
	struct cg cg, newcg = (struct cg *)buf;
	struct bufarea *cgbp;

	- inoinfo(WINO)->ino_state = USTATE;
	+ inoinfo(UFS_WINO)->ino_state = USTATE;
	memset(newcg, 0, (size_t)fs->fs_cgsize);
	newcg->cg_niblk = fs->fs_ipg;
	if (cvtlevel >= 3) {
	@@ -234,14 +234,14 @@
	break;

	default:
	- if (j < (int)ROOTINO)
	+ if (j < (int)UFS_ROOTINO)
	break;
	errx(EEXIT, "BAD STATE %d FOR INODE I=%d",
	inoinfo(j)->ino_state, j);
	}
	}
	if (c == 0)
	- for (i = 0; i < (int)ROOTINO; i++) {
	+ for (i = 0; i < (int)UFS_ROOTINO; i++) {
	setbit(cg_inosused(newcg), i);
	newcg->cg_cs.cs_nifree--;
	}
	Index: sbin/fsck_ffs/suj.c
	===================================================================
	--- sbin/fsck_ffs/suj.c
	+++ sbin/fsck_ffs/suj.c
	@@ -758,7 +758,7 @@
	/*
	* Handle extattr blocks first.
	*/
	- if (lbn < 0 && lbn >= -NXADDR) {
	+ if (lbn < 0 && lbn >= -UFS_NXADDR) {
	lbn = -1 - lbn;
	if (lbn > lblkno(fs, ip->dp2.di_extsize - 1))
	return (0);
	@@ -771,13 +771,13 @@
	if (DIP(ip, di_mode) == IFLNK &&
	DIP(ip, di_size) < fs->fs_maxsymlinklen)
	return (0);
	- if (lbn >= 0 && lbn < NDADDR) {
	+ if (lbn >= 0 && lbn < UFS_NDADDR) {
	*frags = numfrags(fs, sblksize(fs, DIP(ip, di_size), lbn));
	return (DIP(ip, di_db[lbn]));
	}
	*frags = fs->fs_frag;

	- for (i = 0, tmpval = NINDIR(fs), cur = NDADDR; i < NIADDR; i++,
	+ for (i = 0, tmpval = NINDIR(fs), cur = UFS_NDADDR; i < UFS_NIADDR; i++,
	tmpval *= NINDIR(fs), cur = next) {
	next = cur + tmpval;
	if (lbn == -cur - i)
	@@ -1037,7 +1037,7 @@
	fragcnt = 0;
	if ((flags & VISIT_EXT) &&
	fs->fs_magic == FS_UFS2_MAGIC && ip->dp2.di_extsize) {
	- for (i = 0; i < NXADDR; i++) {
	+ for (i = 0; i < UFS_NXADDR; i++) {
	if (ip->dp2.di_extb[i] == 0)
	continue;
	frags = sblksize(fs, ip->dp2.di_extsize, i);
	@@ -1050,7 +1050,7 @@
	if (mode == IFBLK \|\| mode == IFCHR \|\|
	(mode == IFLNK && size < fs->fs_maxsymlinklen))
	return (fragcnt);
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	if (DIP(ip, di_db[i]) == 0)
	continue;
	frags = sblksize(fs, size, i);
	@@ -1063,7 +1063,7 @@
	* real pointers to them.
	*/
	flags \|= VISIT_ROOT;
	- for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR; i++,
	+ for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,
	lbn = nextlbn) {
	nextlbn = lbn + tmpval;
	tmpval *= NINDIR(fs);
	@@ -1123,7 +1123,7 @@
	* to the size in the inode or the maximum size permitted by
	* populated indirects.
	*/
	- if (visitlbn >= NDADDR) {
	+ if (visitlbn >= UFS_NDADDR) {
	isize = DIP(ip, di_size);
	size = lblktosize(fs, visitlbn + 1);
	if (isize > size)
	@@ -1161,7 +1161,7 @@

	mask = blk_freemask(blk, ino, lbn, frags);
	resid = 0;
	- if (lbn <= -NDADDR && follow && mask == 0)
	+ if (lbn <= -UFS_NDADDR && follow && mask == 0)
	indir_visit(ino, lbn, blk, &resid, blk_free_visit, VISIT_INDIR);
	else
	blk_free(blk, mask, frags);
	@@ -1253,7 +1253,7 @@
	dp = (struct direct *)&block[0];
	for (dpoff = 0; dpoff < size && dp->d_reclen; dpoff += dp->d_reclen) {
	dp = (struct direct *)&block[dpoff];
	- if (dp->d_ino == 0 \|\| dp->d_ino == WINO)
	+ if (dp->d_ino == 0 \|\| dp->d_ino == UFS_WINO)
	continue;
	if (dp->d_namlen == 1 && dp->d_name[0] == '.')
	continue;
	@@ -1278,8 +1278,8 @@
	{
	uint32_t gen;

	- if (ino == ROOTINO)
	- err_suj("Attempting to free ROOTINO\n");
	+ if (ino == UFS_ROOTINO)
	+ err_suj("Attempting to free UFS_ROOTINO\n");
	if (debug)
	printf("Truncating and freeing ino %ju, nlink %d, mode %o\n",
	(uintmax_t)ino, DIP(ip, di_nlink), DIP(ip, di_mode));
	@@ -1540,7 +1540,7 @@
	if (size > cursize)
	size = cursize;
	lastlbn = lblkno(fs, blkroundup(fs, size));
	- for (i = lastlbn; i < NDADDR; i++) {
	+ for (i = lastlbn; i < UFS_NDADDR; i++) {
	if (DIP(ip, di_db[i]) == 0)
	continue;
	frags = sblksize(fs, cursize, i);
	@@ -1551,7 +1551,7 @@
	/*
	* Follow indirect blocks, freeing anything required.
	*/
	- for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR; i++,
	+ for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,
	lbn = nextlbn) {
	nextlbn = lbn + tmpval;
	tmpval *= NINDIR(fs);
	@@ -1583,7 +1583,7 @@
	* If we're truncating direct blocks we have to adjust frags
	* accordingly.
	*/
	- if (visitlbn < NDADDR && totalfrags) {
	+ if (visitlbn < UFS_NDADDR && totalfrags) {
	long oldspace, newspace;

	bn = DIP(ip, di_db[visitlbn]);
	@@ -2655,7 +2655,8 @@
	return;
	bytes = lfragtosize(fs, frags);
	if (bread(disk, fsbtodb(fs, blk), block, bytes) <= 0)
	- err_suj("Failed to read ROOTINO directory block %jd\n", blk);
	+ err_suj("Failed to read UFS_ROOTINO directory block %jd\n",
	+ blk);
	for (off = 0; off < bytes; off += dp->d_reclen) {
	dp = (struct direct *)&block[off];
	if (dp->d_reclen == 0)
	@@ -2708,9 +2709,9 @@
	/*
	* Find the journal inode.
	*/
	- ip = ino_read(ROOTINO);
	+ ip = ino_read(UFS_ROOTINO);
	sujino = 0;
	- ino_visit(ip, ROOTINO, suj_find, 0);
	+ ino_visit(ip, UFS_ROOTINO, suj_find, 0);
	if (sujino == 0) {
	printf("Journal inode removed. Use tunefs to re-create.\n");
	sblock.fs_flags &= ~FS_SUJ;
	Index: sbin/fsdb/fsdb.c
	===================================================================
	--- sbin/fsdb/fsdb.c
	+++ sbin/fsdb/fsdb.c
	@@ -231,8 +231,8 @@
	EditLine *elptr;
	HistEvent he;

	- curinode = ginode(ROOTINO);
	- curinum = ROOTINO;
	+ curinode = ginode(UFS_ROOTINO);
	+ curinum = UFS_ROOTINO;
	printactive(0);

	hist = history_init();
	@@ -299,9 +299,10 @@
	ino_t curinum, ocurrent;

	#define GETINUM(ac,inum) inum = strtoul(argv[ac], &cp, 0); \
	- if (inum < ROOTINO \|\| inum > maxino \|\| cp == argv[ac] \|\| *cp != '\0' ) { \
	+ if (inum < UFS_ROOTINO \|\| inum > maxino \|\| cp == argv[ac] \|\| \
	+ *cp != '\0' ) { \
	printf("inode %ju out of range; range is [%ju,%ju]\n", \
	- (uintmax_t)inum, (uintmax_t)ROOTINO, (uintmax_t)maxino); \
	+ (uintmax_t)inum, (uintmax_t)UFS_ROOTINO, (uintmax_t)maxino);\
	return 1; \
	}

	@@ -486,8 +487,8 @@
	inosused = sblock.fs_ipg;

	for (; inosused > 0; inum++, inosused--) {
	- /* Skip magic inodes: 0, WINO, ROOTINO. */
	- if (inum < ROOTINO)
	+ /* Skip magic inodes: 0, UFS_WINO, UFS_ROOTINO. */
	+ if (inum < UFS_ROOTINO)
	continue;
	/*
	* Check if the block we are looking for is just an inode block.
	@@ -531,10 +532,10 @@
	}
	/* Look through direct data blocks. */
	if (is_ufs2 ?
	- find_blks64(curinode->dp2.di_db, NDADDR, wantedblk64) :
	- find_blks32(curinode->dp1.di_db, NDADDR, wantedblk32))
	+ find_blks64(curinode->dp2.di_db, UFS_NDADDR, wantedblk64) :
	+ find_blks32(curinode->dp1.di_db, UFS_NDADDR, wantedblk32))
	goto end;
	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < UFS_NIADDR; i++) {
	/*
	* Does the block we are looking for belongs to the
	* indirect blocks?
	@@ -726,8 +727,8 @@
	ocurrent = curinum;

	if (argv[1][0] == '/') {
	- curinum = ROOTINO;
	- curinode = ginode(ROOTINO);
	+ curinum = UFS_ROOTINO;
	+ curinode = ginode(UFS_ROOTINO);
	} else {
	if (!checkactivedir())
	return 1;
	Index: sbin/fsdb/fsdbutil.c
	===================================================================
	--- sbin/fsdb/fsdbutil.c
	+++ sbin/fsdb/fsdbutil.c
	@@ -292,13 +292,13 @@
	printf("Blocks for inode %ju:\n", (uintmax_t)inum);
	printf("Direct blocks:\n");
	ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);
	- for (i = 0; i < NDADDR && i < ndb; i++) {
	+ for (i = 0; i < UFS_NDADDR && i < ndb; i++) {
	if (i > 0)
	printf(", ");
	blkno = DIP(dp, di_db[i]);
	printf("%jd", (intmax_t)blkno);
	}
	- if (ndb <= NDADDR) {
	+ if (ndb <= UFS_NDADDR) {
	offset = blkoff(&sblock, DIP(dp, di_size));
	if (offset != 0) {
	nfrags = numfrags(&sblock, fragroundup(&sblock, offset));
	@@ -306,14 +306,14 @@
	}
	}
	putchar('\n');
	- if (ndb <= NDADDR)
	+ if (ndb <= UFS_NDADDR)
	return;

	bufp = malloc((unsigned int)sblock.fs_bsize);
	if (bufp == NULL)
	errx(EEXIT, "cannot allocate indirect block buffer");
	printf("Indirect blocks:\n");
	- for (i = 0; i < NIADDR; i++)
	+ for (i = 0; i < UFS_NIADDR; i++)
	printindir(DIP(dp, di_ib[i]), i, bufp);
	free(bufp);
	}
	Index: sbin/fsirand/fsirand.c
	===================================================================
	--- sbin/fsirand/fsirand.c
	+++ sbin/fsirand/fsirand.c
	@@ -261,7 +261,7 @@
	dp1 = &((struct ufs1_dinode *)inodebuf)[n];
	else
	dp2 = &((struct ufs2_dinode *)inodebuf)[n];
	- if (inumber >= ROOTINO) {
	+ if (inumber >= UFS_ROOTINO) {
	if (printonly)
	(void)printf("ino %ju gen %08x\n",
	(uintmax_t)inumber,
	Index: sbin/growfs/debug.c
	===================================================================
	--- sbin/growfs/debug.c
	+++ sbin/growfs/debug.c
	@@ -694,11 +694,11 @@
	ino->di_ctimensec);

	remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
	- for (ictr = 0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
	+ for (ictr = 0; ictr < MIN(UFS_NDADDR, remaining_blocks); ictr++) {
	fprintf(dbg_log, "db ufs_daddr_t[%x] 0x%08x\n", ictr,
	ino->di_db[ictr]);
	}
	- remaining_blocks -= NDADDR;
	+ remaining_blocks -= UFS_NDADDR;
	if (remaining_blocks > 0) {
	fprintf(dbg_log, "ib ufs_daddr_t[0] 0x%08x\n",
	ino->di_ib[0]);
	@@ -768,14 +768,14 @@
	fprintf(dbg_log, "flags u_int32_t 0x%08x\n", ino->di_flags);
	fprintf(dbg_log, "extsize u_int32_t 0x%08x\n", ino->di_extsize);

	- /* XXX: What do we do with di_extb[NXADDR]? */
	+ /* XXX: What do we do with di_extb[UFS_NXADDR]? */

	remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
	- for (ictr = 0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
	+ for (ictr = 0; ictr < MIN(UFS_NDADDR, remaining_blocks); ictr++) {
	fprintf(dbg_log, "db ufs2_daddr_t[%x] 0x%16jx\n", ictr,
	ino->di_db[ictr]);
	}
	- remaining_blocks -= NDADDR;
	+ remaining_blocks -= UFS_NDADDR;
	if (remaining_blocks > 0) {
	fprintf(dbg_log, "ib ufs2_daddr_t[0] 0x%16jx\n",
	ino->di_ib[0]);
	Index: sbin/growfs/growfs.c
	===================================================================
	--- sbin/growfs/growfs.c
	+++ sbin/growfs/growfs.c
	@@ -388,7 +388,7 @@
	}
	acg.cg_cs.cs_nifree += sblock.fs_ipg;
	if (cylno == 0)
	- for (ino = 0; ino < ROOTINO; ino++) {
	+ for (ino = 0; ino < UFS_ROOTINO; ino++) {
	setbit(cg_inosused(&acg), ino);
	acg.cg_cs.cs_nifree--;
	}
	Index: sbin/newfs/mkfs.c
	===================================================================
	--- sbin/newfs/mkfs.c
	+++ sbin/newfs/mkfs.c
	@@ -273,7 +273,7 @@
	sblock.fs_sblockloc = SBLOCK_UFS1;
	sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);
	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
	- sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
	+ sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
	sizeof(ufs1_daddr_t));
	sblock.fs_old_inodefmt = FS_44INODEFMT;
	sblock.fs_old_cgoffset = 0;
	@@ -292,7 +292,7 @@
	sblock.fs_sblockloc = SBLOCK_UFS2;
	sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);
	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);
	- sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
	+ sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
	sizeof(ufs2_daddr_t));
	}
	sblock.fs_sblkno =
	@@ -301,8 +301,8 @@
	sblock.fs_cblkno = sblock.fs_sblkno +
	roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag);
	sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
	- sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
	- for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
	+ sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1;
	+ for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) {
	sizepb *= NINDIR(&sblock);
	sblock.fs_maxfilesize += sizepb;
	}
	@@ -473,7 +473,8 @@
	fragnum(&sblock, sblock.fs_size) +
	(fragnum(&sblock, csfrags) > 0 ?
	sblock.fs_frag - fragnum(&sblock, csfrags) : 0);
	- sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;
	+ sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg -
	+ UFS_ROOTINO;
	sblock.fs_cstotal.cs_ndir = 0;
	sblock.fs_dsize -= csfrags;
	sblock.fs_time = utime;
	@@ -696,7 +697,7 @@
	}
	acg.cg_cs.cs_nifree += sblock.fs_ipg;
	if (cylno == 0)
	- for (i = 0; i < (long)ROOTINO; i++) {
	+ for (i = 0; i < (long)UFS_ROOTINO; i++) {
	setbit(cg_inosused(&acg), i);
	acg.cg_cs.cs_nifree--;
	}
	@@ -808,16 +809,16 @@
	#define ROOTLINKCNT 3

	static struct direct root_dir[] = {
	- { ROOTINO, sizeof(struct direct), DT_DIR, 1, "." },
	- { ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
	- { ROOTINO + 1, sizeof(struct direct), DT_DIR, 5, ".snap" },
	+ { UFS_ROOTINO, sizeof(struct direct), DT_DIR, 1, "." },
	+ { UFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
	+ { UFS_ROOTINO + 1, sizeof(struct direct), DT_DIR, 5, ".snap" },
	};

	#define SNAPLINKCNT 2

	static struct direct snap_dir[] = {
	- { ROOTINO + 1, sizeof(struct direct), DT_DIR, 1, "." },
	- { ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
	+ { UFS_ROOTINO + 1, sizeof(struct direct), DT_DIR, 1, "." },
	+ { UFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
	};

	void
	@@ -854,7 +855,7 @@
	btodb(fragroundup(&sblock, node.dp1.di_size));
	wtfs(fsbtodb(&sblock, node.dp1.di_db[0]), sblock.fs_fsize,
	iobuf);
	- iput(&node, ROOTINO);
	+ iput(&node, UFS_ROOTINO);
	if (!nflag) {
	/*
	* create the .snap directory
	@@ -869,7 +870,7 @@
	btodb(fragroundup(&sblock, node.dp1.di_size));
	wtfs(fsbtodb(&sblock, node.dp1.di_db[0]),
	sblock.fs_fsize, iobuf);
	- iput(&node, ROOTINO + 1);
	+ iput(&node, UFS_ROOTINO + 1);
	}
	} else {
	/*
	@@ -890,7 +891,7 @@
	btodb(fragroundup(&sblock, node.dp2.di_size));
	wtfs(fsbtodb(&sblock, node.dp2.di_db[0]), sblock.fs_fsize,
	iobuf);
	- iput(&node, ROOTINO);
	+ iput(&node, UFS_ROOTINO);
	if (!nflag) {
	/*
	* create the .snap directory
	@@ -905,7 +906,7 @@
	btodb(fragroundup(&sblock, node.dp2.di_size));
	wtfs(fsbtodb(&sblock, node.dp2.di_db[0]),
	sblock.fs_fsize, iobuf);
	- iput(&node, ROOTINO + 1);
	+ iput(&node, UFS_ROOTINO + 1);
	}
	}
	}
	Index: sbin/newfs_nandfs/newfs_nandfs.c
	===================================================================
	--- sbin/newfs_nandfs/newfs_nandfs.c
	+++ sbin/newfs_nandfs/newfs_nandfs.c
	@@ -314,8 +314,8 @@
	}

	debug("bad segment needs %#jx", blk);
	- if (blk >= NDADDR) {
	- printf("nandfs: file too big (%jd > %d)\n", blk, NDADDR);
	+ if (blk >= UFS_NDADDR) {
	+ printf("nandfs: file too big (%jd > %d)\n", blk, UFS_NDADDR);
	exit(2);
	}

	Index: sbin/quotacheck/quotacheck.c
	===================================================================
	--- sbin/quotacheck/quotacheck.c
	+++ sbin/quotacheck/quotacheck.c
	@@ -371,7 +371,8 @@
	continue;
	}
	for (i = 0; i < inosused; i++, ino++) {
	- if ((dp = getnextinode(ino)) == NULL \|\| ino < ROOTINO \|\|
	+ if ((dp = getnextinode(ino)) == NULL \|\|
	+ ino < UFS_ROOTINO \|\|
	(mode = DIP(dp, di_mode) & IFMT) == 0)
	continue;
	/*
	Index: sbin/restore/dirs.c
	===================================================================
	--- sbin/restore/dirs.c
	+++ sbin/restore/dirs.c
	@@ -272,7 +272,7 @@
	}

	/*
	- * Lookup a pathname which is always assumed to start from the ROOTINO.
	+ * Lookup a pathname which is always assumed to start from the UFS_ROOTINO.
	*/
	struct direct *
	pathsearch(const char *pathname)
	@@ -283,7 +283,7 @@

	strcpy(buffer, pathname);
	path = buffer;
	- ino = ROOTINO;
	+ ino = UFS_ROOTINO;
	while (*path == '/')
	path++;
	dp = NULL;
	@@ -632,7 +632,7 @@
	ep->e_flags &= ~NEW;
	continue;
	}
	- if (node.ino == ROOTINO &&
	+ if (node.ino == UFS_ROOTINO &&
	reply("set owner/mode for '.'") == FAIL)
	continue;
	}
	Index: sbin/restore/interactive.c
	===================================================================
	--- sbin/restore/interactive.c
	+++ sbin/restore/interactive.c
	@@ -505,7 +505,7 @@

	dp = pathsearch(name);
	if (dp == NULL \|\| (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) \|\|
	- (!vflag && dp->d_ino == WINO))
	+ (!vflag && dp->d_ino == UFS_WINO))
	return;
	if ((dirp = rst_opendir(name)) == NULL) {
	entries = 1;
	@@ -540,7 +540,7 @@
	break;
	if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0)
	continue;
	- if (!vflag && (dp->d_ino == WINO \|\|
	+ if (!vflag && (dp->d_ino == UFS_WINO \|\|
	strcmp(dp->d_name, ".") == 0 \|\|
	strcmp(dp->d_name, "..") == 0))
	continue;
	@@ -644,7 +644,7 @@
	width = 0;
	haveprefix = 0;
	havepostfix = 0;
	- bigino = ROOTINO;
	+ bigino = UFS_ROOTINO;
	endlist = &list[nentry];
	for (fp = &list[0]; fp < endlist; fp++) {
	if (bigino < fp->fnum)
	@@ -713,7 +713,7 @@
	static struct dirent adirent;

	while ((dp = rst_readdir(dirp)) != NULL) {
	- if (!vflag && dp->d_ino == WINO)
	+ if (!vflag && dp->d_ino == UFS_WINO)
	continue;
	if (dflag \|\| TSTINO(dp->d_ino, dumpmap))
	break;
	@@ -736,7 +736,7 @@

	dp = pathsearch(name);
	if (dp == NULL \|\| (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) \|\|
	- (!vflag && dp->d_ino == WINO))
	+ (!vflag && dp->d_ino == UFS_WINO))
	return (-1);
	if (inodetype(dp->d_ino) == NODE)
	stp->st_mode = IFDIR;
	Index: sbin/restore/main.c
	===================================================================
	--- sbin/restore/main.c
	+++ sbin/restore/main.c
	@@ -212,7 +212,7 @@
	extractdirs(1);
	removeoldleaves();
	vprintf(stdout, "Calculate node updates.\n");
	- treescan(".", ROOTINO, nodeupdates);
	+ treescan(".", UFS_ROOTINO, nodeupdates);
	findunreflinks();
	removeoldnodes();
	} else {
	@@ -223,7 +223,7 @@
	initsymtable((char *)0);
	extractdirs(1);
	vprintf(stdout, "Calculate extraction list.\n");
	- treescan(".", ROOTINO, nodeupdates);
	+ treescan(".", UFS_ROOTINO, nodeupdates);
	}
	createleaves(symtbl);
	createlinks();
	@@ -231,7 +231,7 @@
	checkrestore();
	if (dflag) {
	vprintf(stdout, "Verify the directory structure\n");
	- treescan(".", ROOTINO, verifyfile);
	+ treescan(".", UFS_ROOTINO, verifyfile);
	}
	dumpsymtable(symtbl, (long)1);
	break;
	Index: sbin/restore/restore.c
	===================================================================
	--- sbin/restore/restore.c
	+++ sbin/restore/restore.c
	@@ -81,7 +81,7 @@
	dprintf(stdout, "%s: not on the tape\n", name);
	return (descend);
	}
	- if (ino == WINO && command == 'i' && !vflag)
	+ if (ino == UFS_WINO && command == 'i' && !vflag)
	return (descend);
	if (!mflag) {
	(void) sprintf(buf, "./%ju", (uintmax_t)ino);
	@@ -156,7 +156,7 @@
	ino_t i, mydirino;

	vprintf(stdout, "Mark entries to be removed.\n");
	- if ((ep = lookupino(WINO))) {
	+ if ((ep = lookupino(UFS_WINO))) {
	vprintf(stdout, "Delete whiteouts\n");
	for ( ; ep != NULL; ep = nextep) {
	nextep = ep->e_links;
	@@ -172,7 +172,7 @@
	freeentry(ep);
	}
	}
	- for (i = ROOTINO + 1; i < maxino; i++) {
	+ for (i = UFS_ROOTINO + 1; i < maxino; i++) {
	ep = lookupino(i);
	if (ep == NULL)
	continue;
	@@ -516,7 +516,7 @@
	ino_t i;

	vprintf(stdout, "Find unreferenced names.\n");
	- for (i = ROOTINO; i < maxino; i++) {
	+ for (i = UFS_ROOTINO; i < maxino; i++) {
	ep = lookupino(i);
	if (ep == NULL \|\| ep->e_type == LEAF \|\| TSTINO(i, dumpmap) == 0)
	continue;
	@@ -599,7 +599,7 @@
	vprintf(stdout, "Extract new leaves.\n");
	dumpsymtable(symtabfile, volno);
	}
	- first = lowerbnd(ROOTINO);
	+ first = lowerbnd(UFS_ROOTINO);
	curvol = volno;
	while (curfile.ino < maxino) {
	first = lowerbnd(first);
	@@ -677,7 +677,7 @@
	getvol((long)1);
	skipmaps();
	skipdirs();
	- first = lowerbnd(ROOTINO);
	+ first = lowerbnd(UFS_ROOTINO);
	last = upperbnd(maxino - 1);
	for (;;) {
	curvol = volno;
	@@ -780,7 +780,7 @@
	ino_t i;
	char name[BUFSIZ];

	- if ((ep = lookupino(WINO))) {
	+ if ((ep = lookupino(UFS_WINO))) {
	vprintf(stdout, "Add whiteouts\n");
	for ( ; ep != NULL; ep = ep->e_links) {
	if ((ep->e_flags & NEW) == 0)
	@@ -790,7 +790,7 @@
	}
	}
	vprintf(stdout, "Add links\n");
	- for (i = ROOTINO; i < maxino; i++) {
	+ for (i = UFS_ROOTINO; i < maxino; i++) {
	ep = lookupino(i);
	if (ep == NULL)
	continue;
	@@ -820,7 +820,7 @@
	ino_t i;

	vprintf(stdout, "Check the symbol table.\n");
	- for (i = WINO; i < maxino; i++) {
	+ for (i = UFS_WINO; i < maxino; i++) {
	for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
	ep->e_flags &= ~KEEP;
	if (ep->e_type == NODE)
	Index: sbin/restore/symtab.c
	===================================================================
	--- sbin/restore/symtab.c
	+++ sbin/restore/symtab.c
	@@ -84,7 +84,7 @@
	{
	struct entry *ep;

	- if (inum < WINO \|\| inum >= maxino)
	+ if (inum < UFS_WINO \|\| inum >= maxino)
	return (NULL);
	for (ep = entry[inum % entrytblsize]; ep != NULL; ep = ep->e_next)
	if (ep->e_ino == inum)
	@@ -100,7 +100,7 @@
	{
	struct entry **epp;

	- if (inum < WINO \|\| inum >= maxino)
	+ if (inum < UFS_WINO \|\| inum >= maxino)
	panic("addino: out of range %ju\n", (uintmax_t)inum);
	epp = &entry[inum % entrytblsize];
	np->e_ino = inum;
	@@ -121,7 +121,7 @@
	struct entry *next;
	struct entry **prev;

	- if (inum < WINO \|\| inum >= maxino)
	+ if (inum < UFS_WINO \|\| inum >= maxino)
	panic("deleteino: out of range %ju\n", (uintmax_t)inum);
	prev = &entry[inum % entrytblsize];
	for (next = *prev; next != NULL; next = next->e_next) {
	@@ -146,7 +146,7 @@
	char buf[MAXPATHLEN];

	cp = name;
	- for (ep = lookupino(ROOTINO); ep != NULL; ep = ep->e_entries) {
	+ for (ep = lookupino(UFS_ROOTINO); ep != NULL; ep = ep->e_entries) {
	for (np = buf; cp != '/' && cp != '\0' &&
	np < &buf[sizeof(buf)]; )
	np++ = cp++;
	@@ -198,7 +198,7 @@
	for (cp = &namebuf[MAXPATHLEN - 2]; cp > &namebuf[ep->e_namlen]; ) {
	cp -= ep->e_namlen;
	memmove(cp, ep->e_name, (long)ep->e_namlen);
	- if (ep == lookupino(ROOTINO))
	+ if (ep == lookupino(UFS_ROOTINO))
	return (cp);
	*(--cp) = '/';
	ep = ep->e_parent;
	@@ -233,12 +233,12 @@
	np->e_type = type & ~LINK;
	ep = lookupparent(name);
	if (ep == NULL) {
	- if (inum != ROOTINO \|\| lookupino(ROOTINO) != NULL)
	+ if (inum != UFS_ROOTINO \|\| lookupino(UFS_ROOTINO) != NULL)
	panic("bad name to addentry %s\n", name);
	np->e_name = savename(name);
	np->e_namlen = strlen(name);
	np->e_parent = np;
	- addino(ROOTINO, np);
	+ addino(UFS_ROOTINO, np);
	return (np);
	}
	np->e_name = savename(strrchr(name, '/') + 1);
	@@ -458,7 +458,7 @@
	* Assign indices to each entry
	* Write out the string entries
	*/
	- for (i = WINO; i <= maxino; i++) {
	+ for (i = UFS_WINO; i <= maxino; i++) {
	for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
	ep->e_index = mynum++;
	(void) fwrite(ep->e_name, sizeof(char),
	@@ -470,7 +470,7 @@
	*/
	tep = &temp;
	stroff = 0;
	- for (i = WINO; i <= maxino; i++) {
	+ for (i = UFS_WINO; i <= maxino; i++) {
	for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
	memmove(tep, ep, (long)sizeof(struct entry));
	tep->e_name = (char *)stroff;
	@@ -538,7 +538,7 @@
	entry = calloc((unsigned)entrytblsize, sizeof(struct entry *));
	if (entry == NULL)
	panic("no memory for entry table\n");
	- ep = addentry(".", ROOTINO, NODE);
	+ ep = addentry(".", UFS_ROOTINO, NODE);
	ep->e_flags \|= NEW;
	return;
	}
	Index: sbin/restore/tape.c
	===================================================================
	--- sbin/restore/tape.c
	+++ sbin/restore/tape.c
	@@ -301,7 +301,7 @@
	* whiteout inode exists, so that the whiteout entries can be
	* extracted.
	*/
	- SETINO(WINO, dumpmap);
	+ SETINO(UFS_WINO, dumpmap);
	/* 'r' restores don't call getvol() for tape 1, so mark it as read. */
	if (command == 'r')
	tapesread = 1;
	Index: sbin/restore/utilities.c
	===================================================================
	--- sbin/restore/utilities.c
	+++ sbin/restore/utilities.c
	@@ -303,7 +303,7 @@
	{
	struct entry *ep;

	- for ( ; start > ROOTINO; start--) {
	+ for ( ; start > UFS_ROOTINO; start--) {
	ep = lookupino(start);
	if (ep == NULL \|\| ep->e_type == NODE)
	continue;
	Index: sbin/tunefs/tunefs.c
	===================================================================
	--- sbin/tunefs/tunefs.c
	+++ sbin/tunefs/tunefs.c
	@@ -671,7 +671,7 @@
	}

	/*
	- * Search in the ROOTINO for the SUJ_FILE. If it exists we can not enable
	+ * Search in the UFS_ROOTINO for the SUJ_FILE. If it exists we can not enable
	* journaling.
	*/
	static ino_t
	@@ -684,18 +684,18 @@
	void *ip;
	int i;

	- if (getino(&disk, &ip, ROOTINO, &mode) != 0) {
	+ if (getino(&disk, &ip, UFS_ROOTINO, &mode) != 0) {
	warn("Failed to get root inode");
	return (-1);
	}
	dp2 = ip;
	dp1 = ip;
	if (sblock.fs_magic == FS_UFS1_MAGIC) {
	- if ((off_t)dp1->di_size >= lblktosize(&sblock, NDADDR)) {
	- warnx("ROOTINO extends beyond direct blocks.");
	+ if ((off_t)dp1->di_size >= lblktosize(&sblock, UFS_NDADDR)) {
	+ warnx("UFS_ROOTINO extends beyond direct blocks.");
	return (-1);
	}
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	if (dp1->di_db[i] == 0)
	break;
	if ((ino = dir_search(dp1->di_db[i],
	@@ -703,11 +703,11 @@
	return (ino);
	}
	} else {
	- if ((off_t)dp2->di_size >= lblktosize(&sblock, NDADDR)) {
	- warnx("ROOTINO extends beyond direct blocks.");
	+ if ((off_t)dp2->di_size >= lblktosize(&sblock, UFS_NDADDR)) {
	+ warnx("UFS_ROOTINO extends beyond direct blocks.");
	return (-1);
	}
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	if (dp2->di_db[i] == 0)
	break;
	if ((ino = dir_search(dp2->di_db[i],
	@@ -787,7 +787,7 @@
	}

	/*
	- * Insert the journal file into the ROOTINO directory. We always extend the
	+ * Insert the journal file into the UFS_ROOTINO directory. We always extend the
	* last frag
	*/
	static int
	@@ -803,7 +803,7 @@
	int mode;
	int off;

	- if (getino(&disk, &ip, ROOTINO, &mode) != 0) {
	+ if (getino(&disk, &ip, UFS_ROOTINO, &mode) != 0) {
	warn("Failed to get root inode");
	sbdirty();
	return (-1);
	@@ -816,7 +816,7 @@
	if (nblk <= 0)
	return (-1);
	/*
	- * For simplicity sake we aways extend the ROOTINO into a new
	+ * For simplicity sake we aways extend the UFS_ROOTINO into a new
	* directory block rather than searching for space and inserting
	* into an existing block. However, if the rootino has frags
	* have to free them and extend the block.
	@@ -1036,7 +1036,7 @@
	dp2->di_ctime = utime;
	dp2->di_birthtime = utime;
	}
	- for (i = 0; i < NDADDR && resid; i++, resid--) {
	+ for (i = 0; i < UFS_NDADDR && resid; i++, resid--) {
	blk = journal_balloc();
	if (blk <= 0)
	goto out;
	@@ -1048,7 +1048,7 @@
	dp2->di_blocks++;
	}
	}
	- for (i = 0; i < NIADDR && resid; i++) {
	+ for (i = 0; i < UFS_NIADDR && resid; i++) {
	blk = journal_balloc();
	if (blk <= 0)
	goto out;
	Index: sys/boot/common/ufsread.c
	===================================================================
	--- sys/boot/common/ufsread.c
	+++ sys/boot/common/ufsread.c
	@@ -127,7 +127,7 @@
	ssize_t n;
	uint8_t dt;

	- ino = ROOTINO;
	+ ino = UFS_ROOTINO;
	dt = DT_DIR;
	for (;;) {
	if (*path == '/')
	@@ -261,19 +261,19 @@
	while (nb) {
	lbn = lblkno(&fs, fs_off);
	off = blkoff(&fs, fs_off);
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	addr2 = DIP(di_db[lbn]);
	- } else if (lbn < NDADDR + NINDIR(&fs)) {
	+ } else if (lbn < UFS_NDADDR + NINDIR(&fs)) {
	n = INDIRPERVBLK(&fs);
	addr2 = DIP(di_ib[0]);
	- u = (u_int)(lbn - NDADDR) / n * DBPERVBLK;
	+ u = (u_int)(lbn - UFS_NDADDR) / n * DBPERVBLK;
	vbaddr = fsbtodb(&fs, addr2) + u;
	if (indmap != vbaddr) {
	if (dskread(indbuf, vbaddr, DBPERVBLK))
	return -1;
	indmap = vbaddr;
	}
	- n = (lbn - NDADDR) & (n - 1);
	+ n = (lbn - UFS_NDADDR) & (n - 1);
	#if defined(UFS1_ONLY)
	memcpy(&addr1, (ufs1_daddr_t *)indbuf + n,
	sizeof(ufs1_daddr_t));
	Index: sys/fs/ext2fs/ext2_alloc.c
	===================================================================
	--- sys/fs/ext2fs/ext2_alloc.c
	+++ sys/fs/ext2fs/ext2_alloc.c
	@@ -167,7 +167,7 @@
	uint32_t bap, sbap, *ebap;
	struct ext2mount *ump;
	struct cluster_save *buflist;
	- struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
	+ struct indir start_ap[EXT2_NIADDR + 1], end_ap[EXT2_NIADDR + 1], *idp;
	e2fs_lbn_t start_lbn, end_lbn;
	int soff;
	e2fs_daddr_t newblk, blkno;
	@@ -203,7 +203,7 @@
	* this for other indirect block boundaries, but it is only
	* important for the first one.
	*/
	- if (start_lbn < NDADDR && end_lbn >= NDADDR)
	+ if (start_lbn < EXT2_NDADDR && end_lbn >= EXT2_NDADDR)
	return (ENOSPC);
	/*
	* If the latest allocation is in a new cylinder group, assume that
	@@ -403,9 +403,9 @@
	ip->i_mode = 0;
	ip->i_flags = 0;
	/* now we want to make sure that the block pointers are zeroed out */
	- for (i = 0; i < NDADDR; i++)
	+ for (i = 0; i < EXT2_NDADDR; i++)
	ip->i_db[i] = 0;
	- for (i = 0; i < NIADDR; i++)
	+ for (i = 0; i < EXT2_NIADDR; i++)
	ip->i_ib[i] = 0;

	/*
	Index: sys/fs/ext2fs/ext2_balloc.c
	===================================================================
	--- sys/fs/ext2fs/ext2_balloc.c
	+++ sys/fs/ext2fs/ext2_balloc.c
	@@ -64,7 +64,7 @@
	struct ext2mount *ump;
	struct buf bp, nbp;
	struct vnode *vp = ITOV(ip);
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[EXT2_NIADDR + 2];
	e4fs_daddr_t nb, newb;
	e2fs_daddr_t *bap, pref;
	int osize, nsize, num, i, error;
	@@ -85,9 +85,9 @@
	ip->i_next_alloc_goal++;
	}
	/*
	- * The first NDADDR blocks are direct blocks
	+ * The first EXT2_NDADDR blocks are direct blocks
	*/
	- if (lbn < NDADDR) {
	+ if (lbn < EXT2_NDADDR) {
	nb = ip->i_db[lbn];
	/*
	* no new block is to be allocated, and no need to expand
	Index: sys/fs/ext2fs/ext2_bmap.c
	===================================================================
	--- sys/fs/ext2fs/ext2_bmap.c
	+++ sys/fs/ext2fs/ext2_bmap.c
	@@ -163,7 +163,7 @@
	struct buf *bp;
	struct ext2mount *ump;
	struct mount *mp;
	- struct indir a[NIADDR + 1], *ap;
	+ struct indir a[EXT2_NIADDR + 1], *ap;
	daddr_t daddr;
	e2fs_lbn_t metalbn;
	int error, num, maxrun = 0, bsize;
	@@ -198,7 +198,7 @@
	} else if (runp) {
	daddr_t bnb = bn;

	- for (++bn; bn < NDADDR && *runp < maxrun &&
	+ for (++bn; bn < EXT2_NDADDR && *runp < maxrun &&
	is_sequential(ump, ip->i_db[bn - 1], ip->i_db[bn]);
	++bn, ++*runp);
	bn = bnb;
	@@ -325,17 +325,18 @@
	if ((long)bn < 0)
	bn = -(long)bn;

	- /* The first NDADDR blocks are direct blocks. */
	- if (bn < NDADDR)
	+ /* The first EXT2_NDADDR blocks are direct blocks. */
	+ if (bn < EXT2_NDADDR)
	return (0);

	/*
	* Determine the number of levels of indirection. After this loop
	* is done, blockcnt indicates the number of data blocks possible
	- * at the previous level of indirection, and NIADDR - i is the number
	- * of levels of indirection needed to locate the requested block.
	+ * at the previous level of indirection, and EXT2_NIADDR - i is the
	+ * number of levels of indirection needed to locate the requested block.
	*/
	- for (blockcnt = 1, i = NIADDR, bn -= NDADDR;; i--, bn -= blockcnt) {
	+ for (blockcnt = 1, i = EXT2_NIADDR, bn -= EXT2_NDADDR; ;
	+ i--, bn -= blockcnt) {
	if (i == 0)
	return (EFBIG);
	/*
	@@ -351,9 +352,9 @@

	/* Calculate the address of the first meta-block. */
	if (realbn >= 0)
	- metalbn = -(realbn - bn + NIADDR - i);
	+ metalbn = -(realbn - bn + EXT2_NIADDR - i);
	else
	- metalbn = -(-realbn - bn + NIADDR - i);
	+ metalbn = -(-realbn - bn + EXT2_NIADDR - i);

	/*
	* At each iteration, off is the offset into the bap array which is
	@@ -362,9 +363,9 @@
	* into the argument array.
	*/
	ap->in_lbn = metalbn;
	- ap->in_off = off = NIADDR - i;
	+ ap->in_off = off = EXT2_NIADDR - i;
	ap++;
	- for (++numlevels; i <= NIADDR; i++) {
	+ for (++numlevels; i <= EXT2_NIADDR; i++) {
	/* If searching for a meta-data block, quit when found. */
	if (metalbn == realbn)
	break;
	Index: sys/fs/ext2fs/ext2_inode.c
	===================================================================
	--- sys/fs/ext2fs/ext2_inode.c
	+++ sys/fs/ext2fs/ext2_inode.c
	@@ -113,8 +113,9 @@
	struct vnode *ovp = vp;
	int32_t lastblock;
	struct inode *oip;
	- int32_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
	- uint32_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
	+ int32_t bn, lbn, lastiblock[EXT2_NIADDR], indir_lbn[EXT2_NIADDR];
	+ uint32_t oldblks[EXT2_NDADDR + EXT2_NIADDR];
	+ uint32_t newblks[EXT2_NDADDR + EXT2_NIADDR];
	struct m_ext2fs *fs;
	struct buf *bp;
	int offset, size, level;
	@@ -218,7 +219,7 @@
	* the file is truncated to 0.
	*/
	lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;
	- lastiblock[SINGLE] = lastblock - NDADDR;
	+ lastiblock[SINGLE] = lastblock - EXT2_NDADDR;
	lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
	lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
	nblocks = btodb(fs->e2fs_bsize);
	@@ -229,13 +230,13 @@
	* normalized to -1 for calls to ext2_indirtrunc below.
	*/
	for (level = TRIPLE; level >= SINGLE; level--) {
	- oldblks[NDADDR + level] = oip->i_ib[level];
	+ oldblks[EXT2_NDADDR + level] = oip->i_ib[level];
	if (lastiblock[level] < 0) {
	oip->i_ib[level] = 0;
	lastiblock[level] = -1;
	}
	}
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < EXT2_NDADDR; i++) {
	oldblks[i] = oip->i_db[i];
	if (i > lastblock)
	oip->i_db[i] = 0;
	@@ -249,13 +250,13 @@
	* Note that we save the new block configuration so we can check it
	* when we are done.
	*/
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < EXT2_NDADDR; i++) {
	newblks[i] = oip->i_db[i];
	oip->i_db[i] = oldblks[i];
	}
	- for (i = 0; i < NIADDR; i++) {
	- newblks[NDADDR + i] = oip->i_ib[i];
	- oip->i_ib[i] = oldblks[NDADDR + i];
	+ for (i = 0; i < EXT2_NIADDR; i++) {
	+ newblks[EXT2_NDADDR + i] = oip->i_ib[i];
	+ oip->i_ib[i] = oldblks[EXT2_NDADDR + i];
	}
	oip->i_size = osize;
	error = vtruncbuf(ovp, cred, length, (int)fs->e2fs_bsize);
	@@ -266,7 +267,7 @@
	/*
	* Indirect blocks first.
	*/
	- indir_lbn[SINGLE] = -NDADDR;
	+ indir_lbn[SINGLE] = -EXT2_NDADDR;
	indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
	indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
	for (level = TRIPLE; level >= SINGLE; level--) {
	@@ -290,7 +291,7 @@
	/*
	* All whole direct blocks or frags.
	*/
	- for (i = NDADDR - 1; i > lastblock; i--) {
	+ for (i = EXT2_NDADDR - 1; i > lastblock; i--) {
	long bsize;

	bn = oip->i_db[i];
	@@ -335,9 +336,9 @@
	done:
	#ifdef INVARIANTS
	for (level = SINGLE; level <= TRIPLE; level++)
	- if (newblks[NDADDR + level] != oip->i_ib[level])
	+ if (newblks[EXT2_NDADDR + level] != oip->i_ib[level])
	panic("itrunc1");
	- for (i = 0; i < NDADDR; i++)
	+ for (i = 0; i < EXT2_NDADDR; i++)
	if (newblks[i] != oip->i_db[i])
	panic("itrunc2");
	BO_LOCK(bo);
	Index: sys/fs/ext2fs/ext2_inode_cnv.c
	===================================================================
	--- sys/fs/ext2fs/ext2_inode_cnv.c
	+++ sys/fs/ext2fs/ext2_inode_cnv.c
	@@ -123,9 +123,9 @@
	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 < EXT2_NDADDR; i++)
	ip->i_db[i] = ei->e2di_blocks[i];
	- for (i = 0; i < NIADDR; i++)
	+ for (i = 0; i < EXT2_NIADDR; i++)
	ip->i_ib[i] = ei->e2di_blocks[EXT2_NDIR_BLOCKS + i];
	}

	@@ -169,8 +169,8 @@
	ei->e2di_uid = ip->i_uid;
	ei->e2di_gid = ip->i_gid;
	/* XXX use memcpy */
	- for (i = 0; i < NDADDR; i++)
	+ for (i = 0; i < EXT2_NDADDR; i++)
	ei->e2di_blocks[i] = ip->i_db[i];
	- for (i = 0; i < NIADDR; i++)
	+ for (i = 0; i < EXT2_NIADDR; i++)
	ei->e2di_blocks[EXT2_NDIR_BLOCKS + i] = ip->i_ib[i];
	}
	Index: sys/fs/ext2fs/inode.h
	===================================================================
	--- sys/fs/ext2fs/inode.h
	+++ sys/fs/ext2fs/inode.h
	@@ -50,8 +50,8 @@
	*/
	#define doff_t int32_t

	-#define NDADDR 12 /* Direct addresses in inode. */
	-#define NIADDR 3 /* Indirect addresses in inode. */
	+#define EXT2_NDADDR 12 /* Direct addresses in inode. */
	+#define EXT2_NIADDR 3 /* Indirect addresses in inode. */

	/*
	* The size of physical and logical block numbers in EXT2FS.
	@@ -106,8 +106,8 @@
	int32_t i_birthnsec; /* Inode creation time. */
	uint32_t i_gen; /* Generation number. */
	uint32_t i_flags; /* Status flags (chflags). */
	- uint32_t i_db[NDADDR]; /* Direct disk blocks. */
	- uint32_t i_ib[NIADDR]; /* Indirect disk blocks. */
	+ uint32_t i_db[EXT2_NDADDR]; /* Direct disk blocks. */
	+ uint32_t i_ib[EXT2_NIADDR]; /* Indirect disk blocks. */

	struct ext4_extent_cache i_ext_cache; /* cache for ext4 extent */
	};
	Index: sys/fs/nandfs/bmap.c
	===================================================================
	--- sys/fs/nandfs/bmap.c
	+++ sys/fs/nandfs/bmap.c
	@@ -67,7 +67,7 @@
	bmap_lookup(struct nandfs_node node, nandfs_lbn_t lblk, nandfs_daddr_t vblk)
	{
	struct nandfs_inode *ip;
	- struct nandfs_indir a[NIADDR + 1], *ap;
	+ struct nandfs_indir a[NANDFS_NIADDR + 1], *ap;
	nandfs_daddr_t daddr;
	struct buf *bp;
	int error;
	@@ -129,7 +129,7 @@
	int
	bmap_dirty_meta(struct nandfs_node *node, nandfs_lbn_t lblk, int force)
	{
	- struct nandfs_indir a[NIADDR+1], *ap;
	+ struct nandfs_indir a[NANDFS_NIADDR+1], *ap;
	#ifdef DEBUG
	nandfs_daddr_t daddr;
	#endif
	@@ -179,7 +179,7 @@
	nandfs_daddr_t vblk)
	{
	struct nandfs_inode *ip;
	- struct nandfs_indir a[NIADDR+1], *ap;
	+ struct nandfs_indir a[NANDFS_NIADDR+1], *ap;
	struct buf *bp;
	nandfs_daddr_t daddr;
	int error;
	@@ -267,7 +267,7 @@
	return (error);
	}

	-CTASSERT(NIADDR <= 3);
	+CTASSERT(NANDFS_NIADDR <= 3);
	#define SINGLE 0 /* index of single indirect block */
	#define DOUBLE 1 /* index of double indirect block */
	#define TRIPLE 2 /* index of triple indirect block */
	@@ -399,8 +399,8 @@
	nandfs_lbn_t todo)
	{
	struct nandfs_inode *ip;
	- struct nandfs_indir a[NIADDR + 1], f[NIADDR], *ap;
	- nandfs_daddr_t indir_lbn[NIADDR];
	+ struct nandfs_indir a[NANDFS_NIADDR + 1], f[NANDFS_NIADDR], *ap;
	+ nandfs_daddr_t indir_lbn[NANDFS_NIADDR];
	nandfs_daddr_t *copy;
	int error, level;
	nandfs_lbn_t left, tosub;
	@@ -421,12 +421,12 @@
	if (error)
	return (error);

	- indir_lbn[SINGLE] = -NDADDR;
	+ indir_lbn[SINGLE] = -NANDFS_NDADDR;
	indir_lbn[DOUBLE] = indir_lbn[SINGLE] - MNINDIR(fsdev) - 1;
	indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - MNINDIR(fsdev)
	* MNINDIR(fsdev) - 1;

	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < NANDFS_NIADDR; i++) {
	f[i].in_off = MNINDIR(fsdev) - 1;
	f[i].in_lbn = 0xdeadbeef;
	}
	@@ -482,7 +482,7 @@
	if (num < 0)
	i = lastblk;
	else
	- i = NDADDR - 1;
	+ i = NANDFS_NDADDR - 1;

	for (; i >= 0 && left > 0; i--) {
	if (ip->i_db[i] != 0) {
	@@ -508,13 +508,13 @@
	nandfs_lbn_t
	get_maxfilesize(struct nandfs_device *fsdev)
	{
	- struct nandfs_indir f[NIADDR];
	+ struct nandfs_indir f[NANDFS_NIADDR];
	nandfs_lbn_t max;
	int i;

	- max = NDADDR;
	+ max = NANDFS_NDADDR;

	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < NANDFS_NIADDR; i++) {
	f[i].in_off = MNINDIR(fsdev) - 1;
	max += blocks_inside(fsdev, i, f);
	}
	@@ -557,17 +557,17 @@
	if (bn < 0)
	bn = -bn;

	- /* The first NDADDR blocks are direct blocks. */
	- if (bn < NDADDR)
	+ /* The first NANDFS_NDADDR blocks are direct blocks. */
	+ if (bn < NANDFS_NDADDR)
	return (0);

	/*
	* Determine the number of levels of indirection. After this loop
	* is done, blockcnt indicates the number of data blocks possible
	- * at the previous level of indirection, and NIADDR - i is the number
	- * of levels of indirection needed to locate the requested block.
	+ * at the previous level of indirection, and NANDFS_NIADDR - i is the
	+ * number of levels of indirection needed to locate the requested block.
	*/
	- for (blockcnt = 1, i = NIADDR, bn -= NDADDR;; i--, bn -= blockcnt) {
	+ for (blockcnt = 1, i = NANDFS_NIADDR, bn -= NANDFS_NDADDR;; i--, bn -= blockcnt) {
	DPRINTF(BMAP, ("%s: blockcnt=%jd i=%d bn=%jd\n", __func__,
	blockcnt, i, bn));
	if (i == 0)
	@@ -579,9 +579,9 @@

	/* Calculate the address of the first meta-block. */
	if (realbn >= 0)
	- metalbn = -(realbn - bn + NIADDR - i);
	+ metalbn = -(realbn - bn + NANDFS_NIADDR - i);
	else
	- metalbn = -(-realbn - bn + NIADDR - i);
	+ metalbn = -(-realbn - bn + NANDFS_NIADDR - i);

	/*
	* At each iteration, off is the offset into the bap array which is
	@@ -590,13 +590,13 @@
	* into the argument array.
	*/
	ap->in_lbn = metalbn;
	- ap->in_off = off = NIADDR - i;
	+ ap->in_off = off = NANDFS_NIADDR - i;

	DPRINTF(BMAP, ("%s: initial: ap->in_lbn=%jx ap->in_off=%d\n", __func__,
	metalbn, off));

	ap++;
	- for (++numlevels; i <= NIADDR; i++) {
	+ for (++numlevels; i <= NANDFS_NIADDR; i++) {
	/* If searching for a meta-data block, quit when found. */
	if (metalbn == realbn)
	break;
	Index: sys/fs/nandfs/nandfs_fs.h
	===================================================================
	--- sys/fs/nandfs/nandfs_fs.h
	+++ sys/fs/nandfs/nandfs_fs.h
	@@ -56,8 +56,8 @@
	#define NANDFS_SYS_NODE(ino) \
	(((ino) >= NANDFS_DAT_INO) && ((ino) <= NANDFS_GC_INO))

	-#define NDADDR 12 /* Direct addresses in inode. */
	-#define NIADDR 3 /* Indirect addresses in inode. */
	+#define NANDFS_NDADDR 12 /* Direct addresses in inode. */
	+#define NANDFS_NIADDR 3 /* Indirect addresses in inode. */

	typedef int64_t nandfs_daddr_t;
	typedef int64_t nandfs_lbn_t;
	@@ -75,8 +75,8 @@
	uint16_t i_links_count; /* 50: number of references to the inode*/
	uint32_t i_flags; /* 52: NANDFS__FL flags /
	nandfs_daddr_t i_special; /* 56: special */
	- nandfs_daddr_t i_db[NDADDR]; /* 64: Direct disk blocks. */
	- nandfs_daddr_t i_ib[NIADDR]; /* 160: Indirect disk blocks. */
	+ nandfs_daddr_t i_db[NANDFS_NDADDR]; /* 64: Direct disk blocks. */
	+ nandfs_daddr_t i_ib[NANDFS_NIADDR]; /* 160: Indirect disk blocks. */
	uint64_t i_xattr; /* 184: reserved for extended attributes*/
	uint32_t i_generation; /* 192: file generation for NFS */
	uint32_t i_pad[15]; /* 196: make it 64 bits aligned */
	Index: sys/fs/nfsclient/nfs_clvfsops.c
	===================================================================
	--- sys/fs/nfsclient/nfs_clvfsops.c
	+++ sys/fs/nfsclient/nfs_clvfsops.c
	@@ -1541,7 +1541,7 @@
	* traversals of the mount point (i.e. "..") will not work if
	* the nfsnode gets flushed out of the cache. Ufs does not have
	* this problem, because one can identify root inodes by their
	- * number == ROOTINO (2).
	+ * number == UFS_ROOTINO (2).
	*/
	if (nmp->nm_fhsize > 0) {
	/*
	Index: sys/ufs/ffs/ffs_alloc.c
	===================================================================
	--- sys/ufs/ffs/ffs_alloc.c
	+++ sys/ufs/ffs/ffs_alloc.c
	@@ -303,7 +303,7 @@
	}

	if (bp->b_blkno == bp->b_lblkno) {
	- if (lbprev >= NDADDR)
	+ if (lbprev >= UFS_NDADDR)
	panic("ffs_realloccg: lbprev out of range");
	bp->b_blkno = fsbtodb(fs, bprev);
	}
	@@ -524,7 +524,7 @@
	ufs_lbn_t start_lbn, end_lbn;
	ufs1_daddr_t soff, newblk, blkno;
	ufs2_daddr_t pref;
	- struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
	+ struct indir start_ap[UFS_NIADDR + 1], end_ap[UFS_NIADDR + 1], *idp;
	int i, cg, len, start_lvl, end_lvl, ssize;

	vp = ap->a_vp;
	@@ -567,7 +567,7 @@
	* this for other indirect block boundaries, but it is only
	* important for the first one.
	*/
	- if (start_lbn < NDADDR && end_lbn >= NDADDR)
	+ if (start_lbn < UFS_NDADDR && end_lbn >= UFS_NDADDR)
	return (ENOSPC);
	/*
	* If the latest allocation is in a new cylinder group, assume that
	@@ -773,7 +773,7 @@
	struct ufsmount *ump;
	ufs_lbn_t start_lbn, end_lbn;
	ufs2_daddr_t soff, newblk, blkno, pref;
	- struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
	+ struct indir start_ap[UFS_NIADDR + 1], end_ap[UFS_NIADDR + 1], *idp;
	int i, cg, len, start_lvl, end_lvl, ssize;

	vp = ap->a_vp;
	@@ -816,7 +816,7 @@
	* this for other indirect block boundaries, but it is only
	* important for the first one.
	*/
	- if (start_lbn < NDADDR && end_lbn >= NDADDR)
	+ if (start_lbn < UFS_NDADDR && end_lbn >= UFS_NDADDR)
	return (ENOSPC);
	/*
	* If the latest allocation is in a new cylinder group, assume that
	@@ -1334,9 +1334,9 @@
	* If we are allocating the first indirect block, try to
	* place it immediately following the last direct block.
	*/
	- if (indx == -1 && lbn < NDADDR + NINDIR(fs) &&
	- ip->i_din1->di_db[NDADDR - 1] != 0)
	- pref = ip->i_din1->di_db[NDADDR - 1] + fs->fs_frag;
	+ if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&
	+ ip->i_din1->di_db[UFS_NDADDR - 1] != 0)
	+ pref = ip->i_din1->di_db[UFS_NDADDR - 1] + fs->fs_frag;
	return (pref);
	}
	/*
	@@ -1344,7 +1344,7 @@
	* block and the indirect has been allocated in the data block area,
	* try to place it immediately following the indirect block.
	*/
	- if (lbn == NDADDR) {
	+ if (lbn == UFS_NDADDR) {
	pref = ip->i_din1->di_ib[0];
	if (pref != 0 && pref >= cgdata(fs, inocg) &&
	pref < cgbase(fs, inocg + 1))
	@@ -1368,7 +1368,7 @@
	* blocks, we try to allocate in the data area of the inode's
	* cylinder group.
	*/
	- if (lbn < NDADDR + NINDIR(fs))
	+ if (lbn < UFS_NDADDR + NINDIR(fs))
	return (cgdata(fs, inocg));
	/*
	* Find a cylinder with greater than average number of
	@@ -1439,9 +1439,9 @@
	* If we are allocating the first indirect block, try to
	* place it immediately following the last direct block.
	*/
	- if (indx == -1 && lbn < NDADDR + NINDIR(fs) &&
	- ip->i_din2->di_db[NDADDR - 1] != 0)
	- pref = ip->i_din2->di_db[NDADDR - 1] + fs->fs_frag;
	+ if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&
	+ ip->i_din2->di_db[UFS_NDADDR - 1] != 0)
	+ pref = ip->i_din2->di_db[UFS_NDADDR - 1] + fs->fs_frag;
	return (pref);
	}
	/*
	@@ -1449,7 +1449,7 @@
	* block and the indirect has been allocated in the data block area,
	* try to place it immediately following the indirect block.
	*/
	- if (lbn == NDADDR) {
	+ if (lbn == UFS_NDADDR) {
	pref = ip->i_din2->di_ib[0];
	if (pref != 0 && pref >= cgdata(fs, inocg) &&
	pref < cgbase(fs, inocg + 1))
	@@ -1473,7 +1473,7 @@
	* blocks, we try to allocate in the data area of the inode's
	* cylinder group.
	*/
	- if (lbn < NDADDR + NINDIR(fs))
	+ if (lbn < UFS_NDADDR + NINDIR(fs))
	return (cgdata(fs, inocg));
	/*
	* Find a cylinder with greater than average number of
	@@ -2916,7 +2916,7 @@
	if (blksize > blkcnt)
	blksize = blkcnt;
	ffs_blkfree(ump, fs, ump->um_devvp, blkno,
	- blksize * fs->fs_fsize, ROOTINO, VDIR, NULL);
	+ blksize * fs->fs_fsize, UFS_ROOTINO, VDIR, NULL);
	blkno += blksize;
	blkcnt -= blksize;
	blksize = fs->fs_frag;
	Index: sys/ufs/ffs/ffs_balloc.c
	===================================================================
	--- sys/ufs/ffs/ffs_balloc.c
	+++ sys/ufs/ffs/ffs_balloc.c
	@@ -97,12 +97,12 @@
	ufs1_daddr_t nb;
	struct buf bp, nbp;
	struct ufsmount *ump;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	int deallocated, osize, nsize, num, i, error;
	ufs2_daddr_t newb;
	ufs1_daddr_t *bap, pref;
	- ufs1_daddr_t allocib, blkp, *allocblk, allociblk[NIADDR + 1];
	- ufs2_daddr_t *lbns_remfree, lbns[NIADDR + 1];
	+ ufs1_daddr_t allocib, blkp, *allocblk, allociblk[UFS_NIADDR + 1];
	+ ufs2_daddr_t *lbns_remfree, lbns[UFS_NIADDR + 1];
	int unwindidx = -1;
	int saved_inbdflush;
	static struct timeval lastfail;
	@@ -133,7 +133,7 @@
	* this fragment has to be extended to be a full block.
	*/
	lastlbn = lblkno(fs, ip->i_size);
	- if (lastlbn < NDADDR && lastlbn < lbn) {
	+ if (lastlbn < UFS_NDADDR && lastlbn < lbn) {
	nb = lastlbn;
	osize = blksize(fs, ip, nb);
	if (osize < fs->fs_bsize && osize > 0) {
	@@ -161,9 +161,9 @@
	}
	}
	/*
	- * The first NDADDR blocks are direct blocks
	+ * The first UFS_NDADDR blocks are direct blocks
	*/
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	if (flags & BA_METAONLY)
	panic("ffs_balloc_ufs1: BA_METAONLY for direct block");
	nb = dp->di_db[lbn];
	@@ -265,8 +265,8 @@
	bp->b_blkno = fsbtodb(fs, nb);
	vfs_bio_clrbuf(bp);
	if (DOINGSOFTDEP(vp)) {
	- softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
	- newb, 0, fs->fs_bsize, 0, bp);
	+ softdep_setup_allocdirect(ip, UFS_NDADDR +
	+ indirs[0].in_off, newb, 0, fs->fs_bsize, 0, bp);
	bdwrite(bp);
	} else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) {
	if (bp->b_bufsize == fs->fs_bsize)
	@@ -383,7 +383,7 @@
	* the file. Otherwise it has been allocated in the metadata
	* area, so we want to find our own place out in the data area.
	*/
	- if (pref == 0 \|\| (lbn > NDADDR && fs->fs_metaspace != 0))
	+ if (pref == 0 \|\| (lbn > UFS_NDADDR && fs->fs_metaspace != 0))
	pref = ffs_blkpref_ufs1(ip, lbn, indirs[i].in_off,
	&bap[0]);
	error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
	@@ -571,10 +571,10 @@
	struct fs *fs;
	struct buf bp, nbp;
	struct ufsmount *ump;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	ufs2_daddr_t nb, newb, *bap, pref;
	- ufs2_daddr_t allocib, blkp, *allocblk, allociblk[NIADDR + 1];
	- ufs2_daddr_t *lbns_remfree, lbns[NIADDR + 1];
	+ ufs2_daddr_t allocib, blkp, *allocblk, allociblk[UFS_NIADDR + 1];
	+ ufs2_daddr_t *lbns_remfree, lbns[UFS_NIADDR + 1];
	int deallocated, osize, nsize, num, i, error;
	int unwindidx = -1;
	int saved_inbdflush;
	@@ -603,7 +603,7 @@
	* Check for allocating external data.
	*/
	if (flags & IO_EXT) {
	- if (lbn >= NXADDR)
	+ if (lbn >= UFS_NXADDR)
	return (EFBIG);
	/*
	* If the next write will extend the data into a new block,
	@@ -717,7 +717,7 @@
	* this fragment has to be extended to be a full block.
	*/
	lastlbn = lblkno(fs, ip->i_size);
	- if (lastlbn < NDADDR && lastlbn < lbn) {
	+ if (lastlbn < UFS_NDADDR && lastlbn < lbn) {
	nb = lastlbn;
	osize = blksize(fs, ip, nb);
	if (osize < fs->fs_bsize && osize > 0) {
	@@ -744,9 +744,9 @@
	}
	}
	/*
	- * The first NDADDR blocks are direct blocks
	+ * The first UFS_NDADDR blocks are direct blocks
	*/
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	if (flags & BA_METAONLY)
	panic("ffs_balloc_ufs2: BA_METAONLY for direct block");
	nb = dp->di_db[lbn];
	@@ -851,8 +851,8 @@
	bp->b_blkno = fsbtodb(fs, nb);
	vfs_bio_clrbuf(bp);
	if (DOINGSOFTDEP(vp)) {
	- softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
	- newb, 0, fs->fs_bsize, 0, bp);
	+ softdep_setup_allocdirect(ip, UFS_NDADDR +
	+ indirs[0].in_off, newb, 0, fs->fs_bsize, 0, bp);
	bdwrite(bp);
	} else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) {
	if (bp->b_bufsize == fs->fs_bsize)
	@@ -970,7 +970,7 @@
	* the file. Otherwise it has been allocated in the metadata
	* area, so we want to find our own place out in the data area.
	*/
	- if (pref == 0 \|\| (lbn > NDADDR && fs->fs_metaspace != 0))
	+ if (pref == 0 \|\| (lbn > UFS_NDADDR && fs->fs_metaspace != 0))
	pref = ffs_blkpref_ufs2(ip, lbn, indirs[i].in_off,
	&bap[0]);
	error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
	Index: sys/ufs/ffs/ffs_inode.c
	===================================================================
	--- sys/ufs/ffs/ffs_inode.c
	+++ sys/ufs/ffs/ffs_inode.c
	@@ -183,8 +183,9 @@
	struct ucred *cred;
	{
	struct inode *ip;
	- ufs2_daddr_t bn, lbn, lastblock, lastiblock[NIADDR], indir_lbn[NIADDR];
	- ufs2_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
	+ ufs2_daddr_t bn, lbn, lastblock, lastiblock[UFS_NIADDR];
	+ ufsw_daddr_t indir_lbn[UFS_NIADDR], oldblks[UFS_NDADDR + UFS_NIADDR];
	+ ufs2_daddr_t newblks[UFS_NDADDR + UFS_NIADDR];
	ufs2_daddr_t count, blocksreleased = 0, datablocks, blkno;
	struct bufobj *bo;
	struct fs *fs;
	@@ -260,14 +261,14 @@
	osize = ip->i_din2->di_extsize;
	ip->i_din2->di_blocks -= extblocks;
	ip->i_din2->di_extsize = 0;
	- for (i = 0; i < NXADDR; i++) {
	+ for (i = 0; i < UFS_NXADDR; i++) {
	oldblks[i] = ip->i_din2->di_extb[i];
	ip->i_din2->di_extb[i] = 0;
	}
	ip->i_flag \|= IN_CHANGE;
	if ((error = ffs_update(vp, waitforupdate)))
	return (error);
	- for (i = 0; i < NXADDR; i++) {
	+ for (i = 0; i < UFS_NXADDR; i++) {
	if (oldblks[i] == 0)
	continue;
	ffs_blkfree(ump, fs, ITODEVVP(ip), oldblks[i],
	@@ -338,14 +339,14 @@
	lbn = lblkno(fs, length - 1);
	if (length == 0) {
	blkno = -1;
	- } else if (lbn < NDADDR) {
	+ } else if (lbn < UFS_NDADDR) {
	blkno = DIP(ip, i_db[lbn]);
	} else {
	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize,
	cred, BA_METAONLY, &bp);
	if (error)
	return (error);
	- indiroff = (lbn - NDADDR) % NINDIR(fs);
	+ indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
	if (I_IS_UFS1(ip))
	blkno = ((ufs1_daddr_t *)(bp->b_data))[indiroff];
	else
	@@ -428,7 +429,7 @@
	* so that we do not get a soft updates inconsistency
	* when we create the fragment below.
	*/
	- if (DOINGSOFTDEP(vp) && lbn < NDADDR &&
	+ if (DOINGSOFTDEP(vp) && lbn < UFS_NDADDR &&
	fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize &&
	(error = ffs_syncvnode(vp, MNT_WAIT, 0)) != 0)
	return (error);
	@@ -456,7 +457,7 @@
	* the file is truncated to 0.
	*/
	lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
	- lastiblock[SINGLE] = lastblock - NDADDR;
	+ lastiblock[SINGLE] = lastblock - UFS_NDADDR;
	lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
	lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
	nblocks = btodb(fs->fs_bsize);
	@@ -467,13 +468,13 @@
	* normalized to -1 for calls to ffs_indirtrunc below.
	*/
	for (level = TRIPLE; level >= SINGLE; level--) {
	- oldblks[NDADDR + level] = DIP(ip, i_ib[level]);
	+ oldblks[UFS_NDADDR + level] = DIP(ip, i_ib[level]);
	if (lastiblock[level] < 0) {
	DIP_SET(ip, i_ib[level], 0);
	lastiblock[level] = -1;
	}
	}
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	oldblks[i] = DIP(ip, i_db[i]);
	if (i > lastblock)
	DIP_SET(ip, i_db[i], 0);
	@@ -487,13 +488,13 @@
	* Note that we save the new block configuration so we can check it
	* when we are done.
	*/
	- for (i = 0; i < NDADDR; i++) {
	+ for (i = 0; i < UFS_NDADDR; i++) {
	newblks[i] = DIP(ip, i_db[i]);
	DIP_SET(ip, i_db[i], oldblks[i]);
	}
	- for (i = 0; i < NIADDR; i++) {
	- newblks[NDADDR + i] = DIP(ip, i_ib[i]);
	- DIP_SET(ip, i_ib[i], oldblks[NDADDR + i]);
	+ for (i = 0; i < UFS_NIADDR; i++) {
	+ newblks[UFS_NDADDR + i] = DIP(ip, i_ib[i]);
	+ DIP_SET(ip, i_ib[i], oldblks[UFS_NDADDR + i]);
	}
	ip->i_size = osize;
	DIP_SET(ip, i_size, osize);
	@@ -505,7 +506,7 @@
	/*
	* Indirect blocks first.
	*/
	- indir_lbn[SINGLE] = -NDADDR;
	+ indir_lbn[SINGLE] = -UFS_NDADDR;
	indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
	indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
	for (level = TRIPLE; level >= SINGLE; level--) {
	@@ -531,7 +532,7 @@
	/*
	* All whole direct blocks or frags.
	*/
	- for (i = NDADDR - 1; i > lastblock; i--) {
	+ for (i = UFS_NDADDR - 1; i > lastblock; i--) {
	long bsize;

	bn = DIP(ip, i_db[i]);
	@@ -579,9 +580,9 @@
	done:
	#ifdef INVARIANTS
	for (level = SINGLE; level <= TRIPLE; level++)
	- if (newblks[NDADDR + level] != DIP(ip, i_ib[level]))
	+ if (newblks[UFS_NDADDR + level] != DIP(ip, i_ib[level]))
	panic("ffs_truncate1");
	- for (i = 0; i < NDADDR; i++)
	+ for (i = 0; i < UFS_NDADDR; i++)
	if (newblks[i] != DIP(ip, i_db[i]))
	panic("ffs_truncate2");
	BO_LOCK(bo);
	Index: sys/ufs/ffs/ffs_snapshot.c
	===================================================================
	--- sys/ufs/ffs/ffs_snapshot.c
	+++ sys/ufs/ffs/ffs_snapshot.c
	@@ -330,7 +330,7 @@
	* Allocate all indirect blocks and mark all of them as not
	* needing to be copied.
	*/
	- for (blkno = NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
	+ for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
	fs->fs_bsize, td->td_ucred, BA_METAONLY, &ibp);
	if (error)
	@@ -576,7 +576,7 @@
	*/
	blkno = 0;
	loc = howmany(xp->i_size, fs->fs_bsize) - 1;
	- if (loc < NDADDR) {
	+ if (loc < UFS_NDADDR) {
	len = fragroundup(fs, blkoff(fs, xp->i_size));
	if (len != 0 && len < fs->fs_bsize) {
	ffs_blkfree(ump, copy_fs, vp,
	@@ -816,7 +816,7 @@
	* update the non-integrity-critical time fields and
	* allocated-block count.
	*/
	- for (blockno = 0; blockno < NDADDR; blockno++) {
	+ for (blockno = 0; blockno < UFS_NDADDR; blockno++) {
	if (DIP(ip, i_db[blockno]) != 0)
	continue;
	error = UFS_BALLOC(vp, lblktosize(fs, blockno),
	@@ -923,8 +923,8 @@
	if (base + len >= numblks)
	len = numblks - base - 1;
	loc = 0;
	- if (base < NDADDR) {
	- for ( ; loc < NDADDR; loc++) {
	+ if (base < UFS_NDADDR) {
	+ for ( ; loc < UFS_NDADDR; loc++) {
	if (ffs_isblock(fs, cg_blksfree(cgp), loc))
	DIP_SET(ip, i_db[loc], BLK_NOCOPY);
	else if (passno == 2 && DIP(ip, i_db[loc])== BLK_NOCOPY)
	@@ -938,7 +938,7 @@
	if (error) {
	return (error);
	}
	- indiroff = (base + loc - NDADDR) % NINDIR(fs);
	+ indiroff = (base + loc - UFS_NDADDR) % NINDIR(fs);
	for ( ; loc < len; loc++, indiroff++) {
	if (indiroff >= NINDIR(fs)) {
	if (passno == 2)
	@@ -1010,7 +1010,7 @@
	*/
	lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
	blkno = 0;
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkno = VTOI(snapvp)->i_din1->di_db[lbn];
	} else {
	if (DOINGSOFTDEP(snapvp))
	@@ -1021,7 +1021,7 @@
	td->td_pflags &= ~TDP_COWINPROGRESS;
	if (error)
	return (error);
	- indiroff = (lbn - NDADDR) % NINDIR(fs);
	+ indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
	blkno = ((ufs1_daddr_t *)(bp->b_data))[indiroff];
	bqrelse(bp);
	}
	@@ -1047,7 +1047,7 @@
	dip->di_size = 0;
	dip->di_blocks = 0;
	dip->di_flags &= ~SF_SNAPSHOT;
	- bzero(&dip->di_db[0], (NDADDR + NIADDR) * sizeof(ufs1_daddr_t));
	+ bzero(&dip->di_db[0], (UFS_NDADDR + UFS_NIADDR) * sizeof(ufs1_daddr_t));
	bdwrite(bp);
	/*
	* Now go through and expunge all the blocks in the file
	@@ -1055,16 +1055,16 @@
	*/
	numblks = howmany(cancelip->i_size, fs->fs_bsize);
	if ((error = (*acctfunc)(snapvp, &cancelip->i_din1->di_db[0],
	- &cancelip->i_din1->di_db[NDADDR], fs, 0, expungetype)))
	+ &cancelip->i_din1->di_db[UFS_NDADDR], fs, 0, expungetype)))
	return (error);
	if ((error = (*acctfunc)(snapvp, &cancelip->i_din1->di_ib[0],
	- &cancelip->i_din1->di_ib[NIADDR], fs, -1, expungetype)))
	+ &cancelip->i_din1->di_ib[UFS_NIADDR], fs, -1, expungetype)))
	return (error);
	blksperindir = 1;
	- lbn = -NDADDR;
	- len = numblks - NDADDR;
	- rlbn = NDADDR;
	- for (i = 0; len > 0 && i < NIADDR; i++) {
	+ lbn = -UFS_NDADDR;
	+ len = numblks - UFS_NDADDR;
	+ rlbn = UFS_NDADDR;
	+ for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
	error = indiracct_ufs1(snapvp, ITOV(cancelip), i,
	cancelip->i_din1->di_ib[i], lbn, rlbn, len,
	blksperindir, fs, acctfunc, expungetype);
	@@ -1100,7 +1100,7 @@
	{
	int error, num, i;
	ufs_lbn_t subblksperindir;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	ufs1_daddr_t last, *bap;
	struct buf *bp;

	@@ -1196,7 +1196,7 @@
	if (blkno == 0 \|\| blkno == BLK_NOCOPY \|\| blkno == BLK_SNAP)
	continue;
	lbn = fragstoblks(fs, blkno);
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkp = &ip->i_din1->di_db[lbn];
	ip->i_flag \|= IN_CHANGE \| IN_UPDATE;
	} else {
	@@ -1205,7 +1205,7 @@
	if (error)
	return (error);
	blkp = &((ufs1_daddr_t *)(ibp->b_data))
	- [(lbn - NDADDR) % NINDIR(fs)];
	+ [(lbn - UFS_NDADDR) % NINDIR(fs)];
	}
	/*
	* If we are expunging a snapshot vnode and we
	@@ -1214,13 +1214,13 @@
	* we took our current snapshot and can be ignored.
	*/
	if (expungetype == BLK_SNAP && *blkp == BLK_NOCOPY) {
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	brelse(ibp);
	} else {
	if (*blkp != 0)
	panic("snapacct_ufs1: bad block");
	*blkp = expungetype;
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	bdwrite(ibp);
	}
	}
	@@ -1294,7 +1294,7 @@
	*/
	lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
	blkno = 0;
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkno = VTOI(snapvp)->i_din2->di_db[lbn];
	} else {
	if (DOINGSOFTDEP(snapvp))
	@@ -1305,7 +1305,7 @@
	td->td_pflags &= ~TDP_COWINPROGRESS;
	if (error)
	return (error);
	- indiroff = (lbn - NDADDR) % NINDIR(fs);
	+ indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
	blkno = ((ufs2_daddr_t *)(bp->b_data))[indiroff];
	bqrelse(bp);
	}
	@@ -1331,7 +1331,7 @@
	dip->di_size = 0;
	dip->di_blocks = 0;
	dip->di_flags &= ~SF_SNAPSHOT;
	- bzero(&dip->di_db[0], (NDADDR + NIADDR) * sizeof(ufs2_daddr_t));
	+ bzero(&dip->di_db[0], (UFS_NDADDR + UFS_NIADDR) * sizeof(ufs2_daddr_t));
	bdwrite(bp);
	/*
	* Now go through and expunge all the blocks in the file
	@@ -1339,16 +1339,16 @@
	*/
	numblks = howmany(cancelip->i_size, fs->fs_bsize);
	if ((error = (*acctfunc)(snapvp, &cancelip->i_din2->di_db[0],
	- &cancelip->i_din2->di_db[NDADDR], fs, 0, expungetype)))
	+ &cancelip->i_din2->di_db[UFS_NDADDR], fs, 0, expungetype)))
	return (error);
	if ((error = (*acctfunc)(snapvp, &cancelip->i_din2->di_ib[0],
	- &cancelip->i_din2->di_ib[NIADDR], fs, -1, expungetype)))
	+ &cancelip->i_din2->di_ib[UFS_NIADDR], fs, -1, expungetype)))
	return (error);
	blksperindir = 1;
	- lbn = -NDADDR;
	- len = numblks - NDADDR;
	- rlbn = NDADDR;
	- for (i = 0; len > 0 && i < NIADDR; i++) {
	+ lbn = -UFS_NDADDR;
	+ len = numblks - UFS_NDADDR;
	+ rlbn = UFS_NDADDR;
	+ for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
	error = indiracct_ufs2(snapvp, ITOV(cancelip), i,
	cancelip->i_din2->di_ib[i], lbn, rlbn, len,
	blksperindir, fs, acctfunc, expungetype);
	@@ -1384,7 +1384,7 @@
	{
	int error, num, i;
	ufs_lbn_t subblksperindir;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	ufs2_daddr_t last, *bap;
	struct buf *bp;

	@@ -1480,7 +1480,7 @@
	if (blkno == 0 \|\| blkno == BLK_NOCOPY \|\| blkno == BLK_SNAP)
	continue;
	lbn = fragstoblks(fs, blkno);
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkp = &ip->i_din2->di_db[lbn];
	ip->i_flag \|= IN_CHANGE \| IN_UPDATE;
	} else {
	@@ -1489,7 +1489,7 @@
	if (error)
	return (error);
	blkp = &((ufs2_daddr_t *)(ibp->b_data))
	- [(lbn - NDADDR) % NINDIR(fs)];
	+ [(lbn - UFS_NDADDR) % NINDIR(fs)];
	}
	/*
	* If we are expunging a snapshot vnode and we
	@@ -1498,13 +1498,13 @@
	* we took our current snapshot and can be ignored.
	*/
	if (expungetype == BLK_SNAP && *blkp == BLK_NOCOPY) {
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	brelse(ibp);
	} else {
	if (*blkp != 0)
	panic("snapacct_ufs2: bad block");
	*blkp = expungetype;
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	bdwrite(ibp);
	}
	}
	@@ -1639,7 +1639,7 @@
	* Clear all BLK_NOCOPY fields. Pass any block claims to other
	* snapshots that want them (see ffs_snapblkfree below).
	*/
	- for (blkno = 1; blkno < NDADDR; blkno++) {
	+ for (blkno = 1; blkno < UFS_NDADDR; blkno++) {
	dblk = DIP(ip, i_db[blkno]);
	if (dblk == 0)
	continue;
	@@ -1654,7 +1654,7 @@
	}
	}
	numblks = howmany(ip->i_size, fs->fs_bsize);
	- for (blkno = NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
	+ for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
	fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
	if (error)
	@@ -1771,7 +1771,7 @@
	/*
	* Lookup block being written.
	*/
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkno = DIP(ip, i_db[lbn]);
	} else {
	td->td_pflags \|= TDP_COWINPROGRESS;
	@@ -1780,7 +1780,7 @@
	td->td_pflags &= ~TDP_COWINPROGRESS;
	if (error)
	break;
	- indiroff = (lbn - NDADDR) % NINDIR(fs);
	+ indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
	if (I_IS_UFS1(ip))
	blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
	else
	@@ -1803,7 +1803,7 @@
	*/
	if (claimedblk)
	panic("snapblkfree: inconsistent block type");
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	DIP_SET(ip, i_db[lbn], BLK_NOCOPY);
	ip->i_flag \|= IN_CHANGE \| IN_UPDATE;
	} else if (I_IS_UFS1(ip)) {
	@@ -1822,7 +1822,7 @@
	* (default), or does not care about the block,
	* it is not needed.
	*/
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	bqrelse(ibp);
	continue;
	}
	@@ -1846,13 +1846,13 @@
	* the work to the inode or indirect being written.
	*/
	if (wkhd != NULL) {
	- if (lbn < NDADDR)
	+ if (lbn < UFS_NDADDR)
	softdep_inode_append(ip,
	curthread->td_ucred, wkhd);
	else
	softdep_buf_append(ibp, wkhd);
	}
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	DIP_SET(ip, i_db[lbn], bno);
	} else if (I_IS_UFS1(ip)) {
	((ufs1_daddr_t *)(ibp->b_data))[indiroff] = bno;
	@@ -1866,7 +1866,7 @@
	lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
	return (1);
	}
	- if (lbn >= NDADDR)
	+ if (lbn >= UFS_NDADDR)
	bqrelse(ibp);
	/*
	* Allocate the block into which to do the copy. Note that this
	@@ -2327,7 +2327,7 @@
	* will never require any additional allocations for the
	* snapshot inode.
	*/
	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	blkno = DIP(ip, i_db[lbn]);
	} else {
	td->td_pflags \|= TDP_COWINPROGRESS \| TDP_NORUNNINGBUF;
	@@ -2336,7 +2336,7 @@
	td->td_pflags &= ~TDP_COWINPROGRESS;
	if (error)
	break;
	- indiroff = (lbn - NDADDR) % NINDIR(fs);
	+ indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
	if (I_IS_UFS1(ip))
	blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
	else
	Index: sys/ufs/ffs/ffs_softdep.c
	===================================================================
	--- sys/ufs/ffs/ffs_softdep.c
	+++ sys/ufs/ffs/ffs_softdep.c
	@@ -2732,7 +2732,7 @@
	ino_t sujournal;
	int error;

	- error = VFS_VGET(mp, ROOTINO, LK_EXCLUSIVE, &dvp);
	+ error = VFS_VGET(mp, UFS_ROOTINO, LK_EXCLUSIVE, &dvp);
	if (error)
	return (error);
	bzero(&cnp, sizeof(cnp));
	@@ -4133,8 +4133,8 @@
	freework->fw_blkno = nb;
	freework->fw_frags = frags;
	freework->fw_indir = NULL;
	- freework->fw_ref = (MOUNTEDSUJ(UFSTOVFS(ump)) == 0 \|\| lbn >= -NXADDR)
	- ? 0 : NINDIR(ump->um_fs) + 1;
	+ freework->fw_ref = (MOUNTEDSUJ(UFSTOVFS(ump)) == 0 \|\|
	+ lbn >= -UFS_NXADDR) ? 0 : NINDIR(ump->um_fs) + 1;
	freework->fw_start = freework->fw_off = off;
	if (journal)
	newjfreeblk(freeblks, lbn, nb, frags);
	@@ -5296,7 +5296,7 @@
	"off %jd newsize %ld oldsize %d",
	ip->i_number, newblkno, oldblkno, off, newsize, oldsize);
	ACQUIRE_LOCK(ITOUMP(ip));
	- if (off >= NDADDR) {
	+ if (off >= UFS_NDADDR) {
	if (lbn > 0)
	panic("softdep_setup_allocdirect: bad lbn %jd, off %jd",
	lbn, off);
	@@ -5464,7 +5464,7 @@
	LOCK_OWNED(VFSTOUFS(newadp->ad_list.wk_mp));
	if (newadp->ad_oldblkno != oldadp->ad_newblkno \|\|
	newadp->ad_oldsize != oldadp->ad_newsize \|\|
	- newadp->ad_offset >= NDADDR)
	+ newadp->ad_offset >= UFS_NDADDR)
	panic("%s %jd != new %jd \|\| old size %ld != new %ld",
	"allocdirect_merge: old blkno",
	(intmax_t)newadp->ad_oldblkno,
	@@ -5669,8 +5669,8 @@
	ump = VFSTOUFS(mp);
	KASSERT(MOUNTEDSOFTDEP(mp) != 0,
	("softdep_setup_allocext called on non-softdep filesystem"));
	- KASSERT(off < NXADDR, ("softdep_setup_allocext: lbn %lld > NXADDR",
	- (long long)off));
	+ KASSERT(off < UFS_NXADDR,
	+ ("softdep_setup_allocext: lbn %lld > UFS_NXADDR", (long long)off));

	lbn = bp->b_lblkno;
	if (oldblkno && oldblkno != newblkno)
	@@ -6430,12 +6430,12 @@

	totblks = 0;
	numblks = howmany(length, fs->fs_bsize);
	- if (numblks <= NDADDR) {
	+ if (numblks <= UFS_NDADDR) {
	totblks = howmany(length, fs->fs_fsize);
	goto out;
	}
	totblks = blkstofrags(fs, numblks);
	- numblks -= NDADDR;
	+ numblks -= UFS_NDADDR;
	/*
	* Count all single, then double, then triple indirects required.
	* Subtracting one indirects worth of blocks for each pass
	@@ -6553,12 +6553,12 @@
	/*
	* Compute frags we are keeping in lastlbn. 0 means all.
	*/
	- if (lastlbn >= 0 && lastlbn < NDADDR) {
	+ if (lastlbn >= 0 && lastlbn < UFS_NDADDR) {
	frags = fragroundup(fs, lastoff);
	/* adp offset of last valid allocdirect. */
	iboff = lastlbn;
	} else if (lastlbn > 0)
	- iboff = NDADDR;
	+ iboff = UFS_NDADDR;
	if (fs->fs_magic == FS_UFS2_MAGIC)
	extblocks = btodb(fragroundup(fs, ip->i_din2->di_extsize));
	/*
	@@ -6570,9 +6570,10 @@
	/*
	* Handle truncation of whole direct and indirect blocks.
	*/
	- for (i = iboff + 1; i < NDADDR; i++)
	+ for (i = iboff + 1; i < UFS_NDADDR; i++)
	setup_freedirect(freeblks, ip, i, needj);
	- for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR;
	+ for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR;
	+ i < UFS_NIADDR;
	i++, lbn += tmpval, tmpval *= NINDIR(fs)) {
	/* Release a whole indirect tree. */
	if (lbn > lastlbn) {
	@@ -6580,7 +6581,7 @@
	needj);
	continue;
	}
	- iboff = i + NDADDR;
	+ iboff = i + UFS_NDADDR;
	/*
	* Traverse partially truncated indirect tree.
	*/
	@@ -6614,7 +6615,7 @@
	* handling indirect blocks. Non-indirects need no extra
	* journaling.
	*/
	- if (length != 0 && lastlbn >= NDADDR) {
	+ if (length != 0 && lastlbn >= UFS_NDADDR) {
	ip->i_flag \|= IN_TRUNCATED;
	newjtrunc(freeblks, length, 0);
	}
	@@ -6626,7 +6627,7 @@
	freeblks->fb_len = length;
	}
	if ((flags & IO_EXT) != 0) {
	- for (i = 0; i < NXADDR; i++)
	+ for (i = 0; i < UFS_NXADDR; i++)
	setup_freeext(freeblks, ip, i, needj);
	ip->i_din2->di_extsize = 0;
	datablocks += extblocks;
	@@ -6877,9 +6878,10 @@
	if (fs->fs_magic == FS_UFS2_MAGIC)
	extblocks = btodb(fragroundup(fs, ip->i_din2->di_extsize));
	if ((flags & IO_NORMAL) != 0) {
	- for (i = 0; i < NDADDR; i++)
	+ for (i = 0; i < UFS_NDADDR; i++)
	setup_freedirect(freeblks, ip, i, 0);
	- for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR;
	+ for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR;
	+ i < UFS_NIADDR;
	i++, lbn += tmpval, tmpval *= NINDIR(fs))
	setup_freeindir(freeblks, ip, i, -lbn -i, 0);
	ip->i_size = 0;
	@@ -6887,7 +6889,7 @@
	datablocks = DIP(ip, i_blocks) - extblocks;
	}
	if ((flags & IO_EXT) != 0) {
	- for (i = 0; i < NXADDR; i++)
	+ for (i = 0; i < UFS_NXADDR; i++)
	setup_freeext(freeblks, ip, i, 0);
	ip->i_din2->di_extsize = 0;
	datablocks += extblocks;
	@@ -7022,9 +7024,9 @@
	* to verify how many levels are required.
	*/
	lbn = lblkno(fs, length);
	- if (lbn >= NDADDR) {
	+ if (lbn >= UFS_NDADDR) {
	/* Calculate the virtual lbn of the triple indirect. */
	- lbn = -lbn - (NIADDR - 1);
	+ lbn = -lbn - (UFS_NIADDR - 1);
	end = OFF_TO_IDX(lblktosize(fs, lbn));
	} else
	end = extend;
	@@ -7753,7 +7755,7 @@
	* blocks to expire so that we know the checker will not confuse
	* a re-allocated indirect block with its old contents.
	*/
	- if (needj && freework->fw_lbn <= -NDADDR)
	+ if (needj && freework->fw_lbn <= -UFS_NDADDR)
	indirblk_insert(freework);
	/*
	* If we are canceling an existing jnewblk pass it to the free
	@@ -7926,7 +7928,7 @@

	case D_FREEWORK:
	freework = WK_FREEWORK(wk);
	- if (freework->fw_lbn <= -NDADDR)
	+ if (freework->fw_lbn <= -UFS_NDADDR)
	handle_workitem_indirblk(freework);
	else
	freework_freeblock(freework);
	@@ -8476,7 +8478,7 @@
	/*
	* Whiteouts have no dependencies.
	*/
	- if (newinum == WINO) {
	+ if (newinum == UFS_WINO) {
	if (newdirbp != NULL)
	bdwrite(newdirbp);
	return (0);
	@@ -8493,7 +8495,7 @@
	dap->da_newinum = newinum;
	dap->da_state = ATTACHED;
	LIST_INIT(&dap->da_jwork);
	- isindir = bp->b_lblkno >= NDADDR;
	+ isindir = bp->b_lblkno >= UFS_NDADDR;
	newdirblk = NULL;
	if (isnewblk &&
	(isindir ? blkoff(fs, diroffset) : fragoff(fs, diroffset)) == 0) {
	@@ -9306,7 +9308,7 @@
	/*
	* Whiteouts do not need diradd dependencies.
	*/
	- if (newinum != WINO) {
	+ if (newinum != UFS_WINO) {
	dap = malloc(sizeof(struct diradd),
	M_DIRADD, M_SOFTDEP_FLAGS\|M_ZERO);
	workitem_alloc(&dap->da_list, D_DIRADD, mp);
	@@ -9340,7 +9342,7 @@
	* Whiteouts have no additional dependencies,
	* so just put the dirrem on the correct list.
	*/
	- if (newinum == WINO) {
	+ if (newinum == UFS_WINO) {
	if ((dirrem->dm_state & COMPLETE) == 0) {
	LIST_INSERT_HEAD(&pagedep->pd_dirremhd, dirrem,
	dm_next);
	@@ -10217,19 +10219,19 @@
	if (deplist != 0 && prevlbn >= adp->ad_offset)
	panic("softdep_write_inodeblock: lbn order");
	prevlbn = adp->ad_offset;
	- if (adp->ad_offset < NDADDR &&
	+ if (adp->ad_offset < UFS_NDADDR &&
	dp->di_db[adp->ad_offset] != adp->ad_newblkno)
	panic("%s: direct pointer #%jd mismatch %d != %jd",
	"softdep_write_inodeblock",
	(intmax_t)adp->ad_offset,
	dp->di_db[adp->ad_offset],
	(intmax_t)adp->ad_newblkno);
	- if (adp->ad_offset >= NDADDR &&
	- dp->di_ib[adp->ad_offset - NDADDR] != adp->ad_newblkno)
	+ if (adp->ad_offset >= UFS_NDADDR &&
	+ dp->di_ib[adp->ad_offset - UFS_NDADDR] != adp->ad_newblkno)
	panic("%s: indirect pointer #%jd mismatch %d != %jd",
	"softdep_write_inodeblock",
	- (intmax_t)adp->ad_offset - NDADDR,
	- dp->di_ib[adp->ad_offset - NDADDR],
	+ (intmax_t)adp->ad_offset - UFS_NDADDR,
	+ dp->di_ib[adp->ad_offset - UFS_NDADDR],
	(intmax_t)adp->ad_newblkno);
	deplist \|= 1 << adp->ad_offset;
	if ((adp->ad_state & ATTACHED) == 0)
	@@ -10247,24 +10249,24 @@
	*/
	for (lastadp = NULL, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
	lastadp = adp, adp = TAILQ_NEXT(adp, ad_next)) {
	- if (adp->ad_offset >= NDADDR)
	+ if (adp->ad_offset >= UFS_NDADDR)
	break;
	dp->di_db[adp->ad_offset] = adp->ad_oldblkno;
	/* keep going until hitting a rollback to a frag */
	if (adp->ad_oldsize == 0 \|\| adp->ad_oldsize == fs->fs_bsize)
	continue;
	dp->di_size = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;
	- for (i = adp->ad_offset + 1; i < NDADDR; i++) {
	+ for (i = adp->ad_offset + 1; i < UFS_NDADDR; i++) {
	#ifdef INVARIANTS
	if (dp->di_db[i] != 0 && (deplist & (1 << i)) == 0)
	panic("softdep_write_inodeblock: lost dep1");
	#endif /* INVARIANTS */
	dp->di_db[i] = 0;
	}
	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < UFS_NIADDR; i++) {
	#ifdef INVARIANTS
	if (dp->di_ib[i] != 0 &&
	- (deplist & ((1 << NDADDR) << i)) == 0)
	+ (deplist & ((1 << UFS_NDADDR) << i)) == 0)
	panic("softdep_write_inodeblock: lost dep2");
	#endif /* INVARIANTS */
	dp->di_ib[i] = 0;
	@@ -10296,7 +10298,7 @@
	* postpone fsck, we are stuck with this argument.
	*/
	for (; adp; adp = TAILQ_NEXT(adp, ad_next))
	- dp->di_ib[adp->ad_offset - NDADDR] = 0;
	+ dp->di_ib[adp->ad_offset - UFS_NDADDR] = 0;
	}

	/*
	@@ -10416,7 +10418,7 @@
	if (adp->ad_oldsize == 0 \|\| adp->ad_oldsize == fs->fs_bsize)
	continue;
	dp->di_extsize = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;
	- for (i = adp->ad_offset + 1; i < NXADDR; i++) {
	+ for (i = adp->ad_offset + 1; i < UFS_NXADDR; i++) {
	#ifdef INVARIANTS
	if (dp->di_extb[i] != 0 && (deplist & (1 << i)) == 0)
	panic("softdep_write_inodeblock: lost dep1");
	@@ -10450,19 +10452,19 @@
	if ((adp->ad_state & ATTACHED) == 0)
	panic("inodedep %p and adp %p not attached", inodedep, adp);
	prevlbn = adp->ad_offset;
	- if (adp->ad_offset < NDADDR &&
	+ if (adp->ad_offset < UFS_NDADDR &&
	dp->di_db[adp->ad_offset] != adp->ad_newblkno)
	panic("%s: direct pointer #%jd mismatch %jd != %jd",
	"softdep_write_inodeblock",
	(intmax_t)adp->ad_offset,
	(intmax_t)dp->di_db[adp->ad_offset],
	(intmax_t)adp->ad_newblkno);
	- if (adp->ad_offset >= NDADDR &&
	- dp->di_ib[adp->ad_offset - NDADDR] != adp->ad_newblkno)
	+ if (adp->ad_offset >= UFS_NDADDR &&
	+ dp->di_ib[adp->ad_offset - UFS_NDADDR] != adp->ad_newblkno)
	panic("%s indirect pointer #%jd mismatch %jd != %jd",
	"softdep_write_inodeblock:",
	- (intmax_t)adp->ad_offset - NDADDR,
	- (intmax_t)dp->di_ib[adp->ad_offset - NDADDR],
	+ (intmax_t)adp->ad_offset - UFS_NDADDR,
	+ (intmax_t)dp->di_ib[adp->ad_offset - UFS_NDADDR],
	(intmax_t)adp->ad_newblkno);
	deplist \|= 1 << adp->ad_offset;
	if ((adp->ad_state & ATTACHED) == 0)
	@@ -10480,24 +10482,24 @@
	*/
	for (lastadp = NULL, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
	lastadp = adp, adp = TAILQ_NEXT(adp, ad_next)) {
	- if (adp->ad_offset >= NDADDR)
	+ if (adp->ad_offset >= UFS_NDADDR)
	break;
	dp->di_db[adp->ad_offset] = adp->ad_oldblkno;
	/* keep going until hitting a rollback to a frag */
	if (adp->ad_oldsize == 0 \|\| adp->ad_oldsize == fs->fs_bsize)
	continue;
	dp->di_size = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;
	- for (i = adp->ad_offset + 1; i < NDADDR; i++) {
	+ for (i = adp->ad_offset + 1; i < UFS_NDADDR; i++) {
	#ifdef INVARIANTS
	if (dp->di_db[i] != 0 && (deplist & (1 << i)) == 0)
	panic("softdep_write_inodeblock: lost dep2");
	#endif /* INVARIANTS */
	dp->di_db[i] = 0;
	}
	- for (i = 0; i < NIADDR; i++) {
	+ for (i = 0; i < UFS_NIADDR; i++) {
	#ifdef INVARIANTS
	if (dp->di_ib[i] != 0 &&
	- (deplist & ((1 << NDADDR) << i)) == 0)
	+ (deplist & ((1 << UFS_NDADDR) << i)) == 0)
	panic("softdep_write_inodeblock: lost dep3");
	#endif /* INVARIANTS */
	dp->di_ib[i] = 0;
	@@ -10529,7 +10531,7 @@
	* postpone fsck, we are stuck with this argument.
	*/
	for (; adp; adp = TAILQ_NEXT(adp, ad_next))
	- dp->di_ib[adp->ad_offset - NDADDR] = 0;
	+ dp->di_ib[adp->ad_offset - UFS_NDADDR] = 0;
	}

	/*
	@@ -11456,7 +11458,7 @@
	if (adp->ad_state & ATTACHED)
	panic("handle_written_inodeblock: new entry");
	if (fstype == UFS1) {
	- if (adp->ad_offset < NDADDR) {
	+ if (adp->ad_offset < UFS_NDADDR) {
	if (dp1->di_db[adp->ad_offset]!=adp->ad_oldblkno)
	panic("%s %s #%jd mismatch %d != %jd",
	"handle_written_inodeblock:",
	@@ -11466,17 +11468,20 @@
	(intmax_t)adp->ad_oldblkno);
	dp1->di_db[adp->ad_offset] = adp->ad_newblkno;
	} else {
	- if (dp1->di_ib[adp->ad_offset - NDADDR] != 0)
	+ if (dp1->di_ib[adp->ad_offset - UFS_NDADDR] !=
	+ 0)
	panic("%s: %s #%jd allocated as %d",
	"handle_written_inodeblock",
	"indirect pointer",
	- (intmax_t)adp->ad_offset - NDADDR,
	- dp1->di_ib[adp->ad_offset - NDADDR]);
	- dp1->di_ib[adp->ad_offset - NDADDR] =
	+ (intmax_t)adp->ad_offset -
	+ UFS_NDADDR,
	+ dp1->di_ib[adp->ad_offset -
	+ UFS_NDADDR]);
	+ dp1->di_ib[adp->ad_offset - UFS_NDADDR] =
	adp->ad_newblkno;
	}
	} else {
	- if (adp->ad_offset < NDADDR) {
	+ if (adp->ad_offset < UFS_NDADDR) {
	if (dp2->di_db[adp->ad_offset]!=adp->ad_oldblkno)
	panic("%s: %s #%jd %s %jd != %jd",
	"handle_written_inodeblock",
	@@ -11486,14 +11491,17 @@
	(intmax_t)adp->ad_oldblkno);
	dp2->di_db[adp->ad_offset] = adp->ad_newblkno;
	} else {
	- if (dp2->di_ib[adp->ad_offset - NDADDR] != 0)
	+ if (dp2->di_ib[adp->ad_offset - UFS_NDADDR] !=
	+ 0)
	panic("%s: %s #%jd allocated as %jd",
	"handle_written_inodeblock",
	"indirect pointer",
	- (intmax_t)adp->ad_offset - NDADDR,
	+ (intmax_t)adp->ad_offset -
	+ UFS_NDADDR,
	(intmax_t)
	- dp2->di_ib[adp->ad_offset - NDADDR]);
	- dp2->di_ib[adp->ad_offset - NDADDR] =
	+ dp2->di_ib[adp->ad_offset -
	+ UFS_NDADDR]);
	+ dp2->di_ib[adp->ad_offset - UFS_NDADDR] =
	adp->ad_newblkno;
	}
	}
	Index: sys/ufs/ffs/ffs_vfsops.c
	===================================================================
	--- sys/ufs/ffs/ffs_vfsops.c
	+++ sys/ufs/ffs/ffs_vfsops.c
	@@ -1431,7 +1431,7 @@
	fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
	sbp->f_bavail = freespace(fs, fs->fs_minfree) +
	dbtofsb(fs, fs->fs_pendingblocks);
	- sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
	+ sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;
	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
	UFS_UNLOCK(ump);
	sbp->f_namemax = NAME_MAX;
	@@ -1848,7 +1848,7 @@
	ino = ufhp->ufid_ino;
	ump = VFSTOUFS(mp);
	fs = ump->um_fs;
	- if (ino < ROOTINO \|\| ino >= fs->fs_ncg * fs->fs_ipg)
	+ if (ino < UFS_ROOTINO \|\| ino >= fs->fs_ncg * fs->fs_ipg)
	return (ESTALE);
	/*
	* Need to check if inode is initialized because UFS2 does lazy
	Index: sys/ufs/ffs/ffs_vnops.c
	===================================================================
	--- sys/ufs/ffs/ffs_vnops.c
	+++ sys/ufs/ffs/ffs_vnops.c
	@@ -271,7 +271,7 @@
	* active. Otherwise we must flush them with data,
	* since dependencies prevent data block writes.
	*/
	- if (waitfor == MNT_WAIT && bp->b_lblkno <= -NDADDR &&
	+ if (waitfor == MNT_WAIT && bp->b_lblkno <= -UFS_NDADDR &&
	(lbn_level(bp->b_lblkno) >= passes \|\|
	((flags & DATA_ONLY) != 0 && !DOINGSOFTDEP(vp))))
	continue;
	@@ -356,7 +356,7 @@
	*/
	still_dirty = false;
	TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
	- if (bp->b_lblkno > -NDADDR) {
	+ if (bp->b_lblkno > -UFS_NDADDR) {
	still_dirty = true;
	break;
	}
	@@ -373,7 +373,7 @@
	}
	/* switch between sync/async. */
	wait = !wait;
	- if (wait \|\| ++passes < NIADDR + 2)
	+ if (wait \|\| ++passes < UFS_NIADDR + 2)
	goto loop;
	#ifdef INVARIANTS
	if (!vn_isdisk(vp, NULL))
	@@ -1002,7 +1002,8 @@
	uio->uio_offset = dp->di_extsize;
	KASSERT(uio->uio_offset >= 0, ("ffs_extwrite: uio->uio_offset < 0"));
	KASSERT(uio->uio_resid >= 0, ("ffs_extwrite: uio->uio_resid < 0"));
	- if ((uoff_t)uio->uio_offset + uio->uio_resid > NXADDR * fs->fs_bsize)
	+ if ((uoff_t)uio->uio_offset + uio->uio_resid >
	+ UFS_NXADDR * fs->fs_bsize)
	return (EFBIG);

	resid = uio->uio_resid;
	@@ -1145,7 +1146,7 @@
	fs = ITOFS(ip);
	dp = ip->i_din2;
	easize = dp->di_extsize;
	- if ((uoff_t)easize + extra > NXADDR * fs->fs_bsize)
	+ if ((uoff_t)easize + extra > UFS_NXADDR * fs->fs_bsize)
	return (EFBIG);

	eae = malloc(easize + extra, M_TEMP, M_WAITOK);
	@@ -1296,7 +1297,7 @@

	vp = ap->a_vp;
	lbn = ap->a_bp->b_lblkno;
	- if (I_IS_UFS2(VTOI(vp)) && lbn < 0 && lbn >= -NXADDR)
	+ if (I_IS_UFS2(VTOI(vp)) && lbn < 0 && lbn >= -UFS_NXADDR)
	return (VOP_STRATEGY_APV(&ufs_vnodeops, ap));
	if (vp->v_type == VFIFO)
	return (VOP_STRATEGY_APV(&ufs_fifoops, ap));
	@@ -1584,7 +1585,7 @@
	return (EROFS);

	ealen = ap->a_uio->uio_resid;
	- if (ealen < 0 \|\| ealen > lblktosize(fs, NXADDR))
	+ if (ealen < 0 \|\| ealen > lblktosize(fs, UFS_NXADDR))
	return (EINVAL);

	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
	@@ -1635,7 +1636,7 @@
	easize += (ealength - ul);
	}
	}
	- if (easize > lblktosize(fs, NXADDR)) {
	+ if (easize > lblktosize(fs, UFS_NXADDR)) {
	free(eae, M_TEMP);
	ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
	if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
	Index: sys/ufs/ffs/fs.h
	===================================================================
	--- sys/ufs/ffs/fs.h
	+++ sys/ufs/ffs/fs.h
	@@ -575,7 +575,7 @@
	(((off_t)(frag)) << (fs)->fs_fshift)
	#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \
	(((off_t)(blk)) << (fs)->fs_bshift)
	-/* Use this only when `blk' is known to be small, e.g., < NDADDR. */
	+/* Use this only when `blk' is known to be small, e.g., < UFS_NDADDR. */
	#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \
	((blk) << (fs)->fs_bshift)
	#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \
	@@ -608,11 +608,11 @@
	* Determining the size of a file block in the filesystem.
	*/
	#define blksize(fs, ip, lbn) \
	- (((lbn) >= NDADDR \|\| (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \
	+ (((lbn) >= UFS_NDADDR \|\| (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \
	? (fs)->fs_bsize \
	: (fragroundup(fs, blkoff(fs, (ip)->i_size))))
	#define sblksize(fs, size, lbn) \
	- (((lbn) >= NDADDR \|\| (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
	+ (((lbn) >= UFS_NDADDR \|\| (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
	? (fs)->fs_bsize \
	: (fragroundup(fs, blkoff(fs, (size)))))

	@@ -622,7 +622,7 @@
	#define NINDIR(fs) ((fs)->fs_nindir)

	/*
	- * Indirect lbns are aligned on NDADDR addresses where single indirects
	+ * Indirect lbns are aligned on UFS_NDADDR addresses where single indirects
	* are the negated address of the lowest lbn reachable, double indirects
	* are this lbn - 1 and triple indirects are this lbn - 2. This yields
	* an unusual bit order to determine level.
	Index: sys/ufs/ufs/dinode.h
	===================================================================
	--- sys/ufs/ufs/dinode.h
	+++ sys/ufs/ufs/dinode.h
	@@ -74,15 +74,15 @@
	* 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 ROOTINO ((ino_t)2)
	+#define UFS_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_WHT entry.
	- * See the comments about ROOTINO above.
	+ * See the comments about UFS_ROOTINO above.
	*/
	-#define WINO ((ino_t)1)
	+#define UFS_WINO ((ino_t)1)

	/*
	* The size of physical and logical block numbers and time fields in UFS.
	@@ -118,9 +118,9 @@
	* are defined by types with precise widths.
	*/

	-#define NXADDR 2 /* External addresses in inode. */
	-#define NDADDR 12 /* Direct addresses in inode. */
	-#define NIADDR 3 /* Indirect addresses in inode. */
	+#define UFS_NXADDR 2 /* External addresses in inode. */
	+#define UFS_NDADDR 12 /* Direct addresses in inode. */
	+#define UFS_NIADDR 3 /* Indirect addresses in inode. */

	struct ufs2_dinode {
	u_int16_t di_mode; /* 0: IFMT, permissions; see below. */
	@@ -142,9 +142,9 @@
	u_int32_t di_kernflags; /* 84: Kernel flags. */
	u_int32_t di_flags; /* 88: Status flags (chflags). */
	u_int32_t di_extsize; /* 92: External attributes size. */
	- ufs2_daddr_t di_extb[NXADDR];/* 96: External attributes block. */
	- ufs2_daddr_t di_db[NDADDR]; /* 112: Direct disk blocks. */
	- ufs2_daddr_t di_ib[NIADDR]; /* 208: Indirect disk blocks. */
	+ ufs2_daddr_t di_extb[UFS_NXADDR];/* 96: External attributes block. */
	+ ufs2_daddr_t di_db[UFS_NDADDR]; /* 112: Direct disk blocks. */
	+ ufs2_daddr_t di_ib[UFS_NIADDR]; /* 208: Indirect disk blocks. */
	u_int64_t di_modrev; /* 232: i_modrev for NFSv4 */
	uint32_t di_freelink; /* 240: SUJ: Next unlinked inode. */
	uint32_t di_spare[3]; /* 244: Reserved; currently unused */
	@@ -176,8 +176,8 @@
	int32_t di_mtimensec; /* 28: Last modified time. */
	int32_t di_ctime; /* 32: Last inode change time. */
	int32_t di_ctimensec; /* 36: Last inode change time. */
	- ufs1_daddr_t di_db[NDADDR]; /* 40: Direct disk blocks. */
	- ufs1_daddr_t di_ib[NIADDR]; /* 88: Indirect disk blocks. */
	+ ufs1_daddr_t di_db[UFS_NDADDR]; /* 40: Direct disk blocks. */
	+ ufs1_daddr_t di_ib[UFS_NIADDR]; /* 88: Indirect disk blocks. */
	u_int32_t di_flags; /* 100: Status flags (chflags). */
	u_int32_t di_blocks; /* 104: Blocks actually held. */
	u_int32_t di_gen; /* 108: Generation number. */
	Index: sys/ufs/ufs/ufs_bmap.c
	===================================================================
	--- sys/ufs/ufs/ufs_bmap.c
	+++ sys/ufs/ufs/ufs_bmap.c
	@@ -115,7 +115,7 @@
	struct buf *bp;
	struct ufsmount *ump;
	struct mount *mp;
	- struct indir a[NIADDR+1], *ap;
	+ struct indir a[UFS_NIADDR+1], *ap;
	ufs2_daddr_t daddr;
	ufs_lbn_t metalbn;
	int error, num, maxrun = 0;
	@@ -144,9 +144,9 @@

	num = *nump;
	if (num == 0) {
	- if (bn >= 0 && bn < NDADDR) {
	+ if (bn >= 0 && bn < UFS_NDADDR) {
	*bnp = blkptrtodb(ump, DIP(ip, i_db[bn]));
	- } else if (bn < 0 && bn >= -NXADDR) {
	+ } else if (bn < 0 && bn >= -UFS_NXADDR) {
	*bnp = blkptrtodb(ump, ip->i_din2->di_extb[-1 - bn]);
	if (*bnp == 0)
	*bnp = -1;
	@@ -175,7 +175,7 @@
	*bnp = -1;
	} else if (runp) {
	ufs2_daddr_t bnb = bn;
	- for (++bn; bn < NDADDR && *runp < maxrun &&
	+ for (++bn; bn < UFS_NDADDR && *runp < maxrun &&
	is_sequential(ump, DIP(ip, i_db[bn - 1]),
	DIP(ip, i_db[bn]));
	++bn, ++*runp);
	@@ -330,17 +330,18 @@
	if (bn < 0)
	bn = -bn;

	- /* The first NDADDR blocks are direct blocks. */
	- if (bn < NDADDR)
	+ /* The first UFS_NDADDR blocks are direct blocks. */
	+ if (bn < UFS_NDADDR)
	return (0);

	/*
	* Determine the number of levels of indirection. After this loop
	* is done, blockcnt indicates the number of data blocks possible
	- * at the previous level of indirection, and NIADDR - i is the number
	- * of levels of indirection needed to locate the requested block.
	+ * at the previous level of indirection, and UFS_NIADDR - i is the
	+ * number of levels of indirection needed to locate the requested block.
	*/
	- for (blockcnt = 1, i = NIADDR, bn -= NDADDR;; i--, bn -= blockcnt) {
	+ for (blockcnt = 1, i = UFS_NIADDR, bn -= UFS_NDADDR; ;
	+ i--, bn -= blockcnt) {
	if (i == 0)
	return (EFBIG);
	blockcnt *= MNINDIR(ump);
	@@ -350,9 +351,9 @@

	/* Calculate the address of the first meta-block. */
	if (realbn >= 0)
	- metalbn = -(realbn - bn + NIADDR - i);
	+ metalbn = -(realbn - bn + UFS_NIADDR - i);
	else
	- metalbn = -(-realbn - bn + NIADDR - i);
	+ metalbn = -(-realbn - bn + UFS_NIADDR - i);

	/*
	* At each iteration, off is the offset into the bap array which is
	@@ -361,9 +362,9 @@
	* into the argument array.
	*/
	ap->in_lbn = metalbn;
	- ap->in_off = off = NIADDR - i;
	+ ap->in_off = off = UFS_NIADDR - i;
	ap++;
	- for (++numlevels; i <= NIADDR; i++) {
	+ for (++numlevels; i <= UFS_NIADDR; i++) {
	/* If searching for a meta-data block, quit when found. */
	if (metalbn == realbn)
	break;
	Index: sys/ufs/ufs/ufs_lookup.c
	===================================================================
	--- sys/ufs/ufs/ufs_lookup.c
	+++ sys/ufs/ufs/ufs_lookup.c
	@@ -1069,7 +1069,7 @@
	namlen = ep->d_namlen;
	# endif
	if (ep->d_ino == 0 \|\|
	- (ep->d_ino == WINO && namlen == dirp->d_namlen &&
	+ (ep->d_ino == UFS_WINO && namlen == dirp->d_namlen &&
	bcmp(ep->d_name, dirp->d_name, dirp->d_namlen) == 0)) {
	if (spacefree + dsize < newentrysize)
	panic("ufs_direnter: compact1");
	@@ -1178,12 +1178,12 @@
	}
	if (flags & DOWHITEOUT) {
	/*
	- * Whiteout entry: set d_ino to WINO.
	+ * Whiteout entry: set d_ino to UFS_WINO.
	*/
	if ((error =
	UFS_BLKATOFF(dvp, (off_t)dp->i_offset, (char **)&ep, &bp)) != 0)
	return (error);
	- ep->d_ino = WINO;
	+ ep->d_ino = UFS_WINO;
	ep->d_type = DT_WHT;
	goto out;
	}
	@@ -1353,7 +1353,7 @@
	if (dp->d_reclen == 0)
	return (0);
	/* skip empty entries */
	- if (dp->d_ino == 0 \|\| dp->d_ino == WINO)
	+ if (dp->d_ino == 0 \|\| dp->d_ino == UFS_WINO)
	continue;
	/* accept only "." and ".." */
	# if (BYTE_ORDER == LITTLE_ENDIAN)
	@@ -1445,7 +1445,7 @@
	return (EEXIST);
	if (target->i_number == parent_ino)
	return (0);
	- if (target->i_number == ROOTINO)
	+ if (target->i_number == UFS_ROOTINO)
	return (0);
	for (;;) {
	error = ufs_dir_dd_ino(vp, cred, &dd_ino, &vp1);
	@@ -1455,7 +1455,7 @@
	error = EINVAL;
	break;
	}
	- if (dd_ino == ROOTINO)
	+ if (dd_ino == UFS_ROOTINO)
	break;
	if (dd_ino == parent_ino)
	break;
	Index: sys/ufs/ufs/ufs_vfsops.c
	===================================================================
	--- sys/ufs/ufs/ufs_vfsops.c
	+++ sys/ufs/ufs/ufs_vfsops.c
	@@ -74,7 +74,7 @@
	struct vnode *nvp;
	int error;

	- error = VFS_VGET(mp, (ino_t)ROOTINO, flags, &nvp);
	+ error = VFS_VGET(mp, (ino_t)UFS_ROOTINO, flags, &nvp);
	if (error)
	return (error);
	*vpp = nvp;
	Index: sys/ufs/ufs/ufs_vnops.c
	===================================================================
	--- sys/ufs/ufs/ufs_vnops.c
	+++ sys/ufs/ufs/ufs_vnops.c
	@@ -1053,7 +1053,7 @@
	panic("ufs_whiteout: old format filesystem");
	#endif

	- newdir.d_ino = WINO;
	+ newdir.d_ino = UFS_WINO;
	newdir.d_namlen = cnp->cn_namelen;
	bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1);
	newdir.d_type = DT_WHT;
	@@ -2564,7 +2564,7 @@
	if (vp->v_type == VFIFO)
	vp->v_op = fifoops;
	ASSERT_VOP_LOCKED(vp, "ufs_vinit");
	- if (ip->i_number == ROOTINO)
	+ if (ip->i_number == UFS_ROOTINO)
	vp->v_vflag \|= VV_ROOT;
	*vpp = vp;
	return (0);
	Index: usr.sbin/makefs/ffs.c
	===================================================================
	--- usr.sbin/makefs/ffs.c
	+++ usr.sbin/makefs/ffs.c
	@@ -278,7 +278,7 @@
	errx(1, "Image file `%s' not created.", image);
	TIMER_RESULTS(start, "ffs_create_image");

	- fsopts->curinode = ROOTINO;
	+ fsopts->curinode = UFS_ROOTINO;

	if (debug & DEBUG_FS_MAKEFS)
	putchar('\n');
	@@ -371,7 +371,7 @@

	/* calculate size of tree */
	ffs_size_dir(root, fsopts);
	- fsopts->inodes += ROOTINO; /* include first two inodes */
	+ fsopts->inodes += UFS_ROOTINO; /* include first two inodes */

	if (debug & DEBUG_FS_VALIDATE)
	printf("ffs_validate: size of tree: %lld bytes, %lld inodes\n",
	@@ -565,11 +565,11 @@
	(long long)fs->fs_cstotal.cs_ndir);
	}

	- if (fs->fs_cstotal.cs_nifree + ROOTINO < fsopts->inodes) {
	+ if (fs->fs_cstotal.cs_nifree + UFS_ROOTINO < fsopts->inodes) {
	warnx(
	"Image file `%s' has %lld free inodes; %lld are required.",
	image,
	- (long long)(fs->fs_cstotal.cs_nifree + ROOTINO),
	+ (long long)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO),
	(long long)fsopts->inodes);
	return (-1);
	}
	@@ -636,8 +636,8 @@

	slen = strlen(node->symlink) + 1;
	if (slen >= (ffs_opts->version == 1 ?
	- MAXSYMLINKLEN_UFS1 :
	- MAXSYMLINKLEN_UFS2))
	+ UFS1_MAXSYMLINKLEN :
	+ UFS2_MAXSYMLINKLEN))
	ADDSIZE(slen);
	}
	}
	@@ -690,7 +690,7 @@
	ufs_rw32(cur->inode->st.st_rdev, fsopts->needswap);
	} else if (S_ISLNK(cur->type)) { /* symlink */
	slen = strlen(cur->symlink);
	- if (slen < MAXSYMLINKLEN_UFS1) { /* short link */
	+ if (slen < UFS1_MAXSYMLINKLEN) { /* short link */
	memcpy(dinp->di_db, cur->symlink, slen);
	} else
	membuf = cur->symlink;
	@@ -742,7 +742,7 @@
	ufs_rw64(cur->inode->st.st_rdev, fsopts->needswap);
	} else if (S_ISLNK(cur->type)) { /* symlink */
	slen = strlen(cur->symlink);
	- if (slen < MAXSYMLINKLEN_UFS2) { /* short link */
	+ if (slen < UFS2_MAXSYMLINKLEN) { /* short link */
	memcpy(dinp->di_db, cur->symlink, slen);
	} else
	membuf = cur->symlink;
	Index: usr.sbin/makefs/ffs/ffs_alloc.c
	===================================================================
	--- usr.sbin/makefs/ffs/ffs_alloc.c
	+++ usr.sbin/makefs/ffs/ffs_alloc.c
	@@ -157,7 +157,7 @@

	fs = ip->i_fs;
	if (indx % fs->fs_maxbpg == 0 \|\| bap[indx - 1] == 0) {
	- if (lbn < NDADDR + NINDIR(fs)) {
	+ if (lbn < UFS_NDADDR + NINDIR(fs)) {
	cg = ino_to_cg(fs, ip->i_number);
	return (fs->fs_fpg * cg + fs->fs_frag);
	}
	@@ -196,7 +196,7 @@

	fs = ip->i_fs;
	if (indx % fs->fs_maxbpg == 0 \|\| bap[indx - 1] == 0) {
	- if (lbn < NDADDR + NINDIR(fs)) {
	+ if (lbn < UFS_NDADDR + NINDIR(fs)) {
	cg = ino_to_cg(fs, ip->i_number);
	return (fs->fs_fpg * cg + fs->fs_frag);
	}
	Index: usr.sbin/makefs/ffs/ffs_balloc.c
	===================================================================
	--- usr.sbin/makefs/ffs/ffs_balloc.c
	+++ usr.sbin/makefs/ffs/ffs_balloc.c
	@@ -82,11 +82,11 @@
	int32_t nb;
	struct buf bp, nbp;
	struct fs *fs = ip->i_fs;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	daddr_t newb, pref;
	int32_t *bap;
	int osize, nsize, num, i, error;
	- int32_t *allocblk, allociblk[NIADDR + 1];
	+ int32_t *allocblk, allociblk[UFS_NIADDR + 1];
	int32_t *allocib;
	const int needswap = UFS_FSNEEDSWAP(fs);

	@@ -107,7 +107,7 @@
	*/

	lastlbn = lblkno(fs, ip->i_ffs1_size);
	- if (lastlbn < NDADDR && lastlbn < lbn) {
	+ if (lastlbn < UFS_NDADDR && lastlbn < lbn) {
	nb = lastlbn;
	osize = blksize(fs, ip, nb);
	if (osize < fs->fs_bsize && osize > 0) {
	@@ -117,10 +117,10 @@
	}

	/*
	- * The first NDADDR blocks are direct blocks
	+ * The first UFS_NDADDR blocks are direct blocks
	*/

	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	nb = ufs_rw32(ip->i_ffs1_db[lbn], needswap);
	if (nb != 0 && ip->i_ffs1_size >= lblktosize(fs, lbn + 1)) {

	@@ -333,11 +333,11 @@
	int size;
	struct buf bp, nbp;
	struct fs *fs = ip->i_fs;
	- struct indir indirs[NIADDR + 2];
	+ struct indir indirs[UFS_NIADDR + 2];
	daddr_t newb, pref, nb;
	int64_t *bap;
	int osize, nsize, num, i, error;
	- int64_t *allocblk, allociblk[NIADDR + 1];
	+ int64_t *allocblk, allociblk[UFS_NIADDR + 1];
	int64_t *allocib;
	const int needswap = UFS_FSNEEDSWAP(fs);

	@@ -358,7 +358,7 @@
	*/

	lastlbn = lblkno(fs, ip->i_ffs2_size);
	- if (lastlbn < NDADDR && lastlbn < lbn) {
	+ if (lastlbn < UFS_NDADDR && lastlbn < lbn) {
	nb = lastlbn;
	osize = blksize(fs, ip, nb);
	if (osize < fs->fs_bsize && osize > 0) {
	@@ -368,10 +368,10 @@
	}

	/*
	- * The first NDADDR blocks are direct blocks
	+ * The first UFS_NDADDR blocks are direct blocks
	*/

	- if (lbn < NDADDR) {
	+ if (lbn < UFS_NDADDR) {
	nb = ufs_rw64(ip->i_ffs2_db[lbn], needswap);
	if (nb != 0 && ip->i_ffs2_size >= lblktosize(fs, lbn + 1)) {

	Index: usr.sbin/makefs/ffs/mkfs.c
	===================================================================
	--- usr.sbin/makefs/ffs/mkfs.c
	+++ usr.sbin/makefs/ffs/mkfs.c
	@@ -148,8 +148,8 @@
	sblock.fs_old_flags = 0;
	} else {
	sblock.fs_old_inodefmt = FS_44INODEFMT;
	- sblock.fs_maxsymlinklen = (Oflag == 1 ? MAXSYMLINKLEN_UFS1 :
	- MAXSYMLINKLEN_UFS2);
	+ sblock.fs_maxsymlinklen = (Oflag == 1 ? UFS1_MAXSYMLINKLEN :
	+ UFS2_MAXSYMLINKLEN);
	sblock.fs_old_flags = FS_FLAGS_UPDATED;
	sblock.fs_flags = 0;
	}
	@@ -256,7 +256,7 @@
	sblock.fs_sblockloc = SBLOCK_UFS1;
	sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);
	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
	- sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
	+ sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
	sizeof (ufs1_daddr_t));
	sblock.fs_old_inodefmt = FS_44INODEFMT;
	sblock.fs_old_cgoffset = 0;
	@@ -276,7 +276,7 @@
	sblock.fs_sblockloc = SBLOCK_UFS2;
	sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);
	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);
	- sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
	+ sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
	sizeof (ufs2_daddr_t));
	}

	@@ -286,8 +286,8 @@
	sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
	roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag));
	sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
	- sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
	- for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
	+ sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1;
	+ for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) {
	sizepb *= NINDIR(&sblock);
	sblock.fs_maxfilesize += sizepb;
	}
	@@ -447,7 +447,8 @@
	fragnum(&sblock, sblock.fs_size) +
	(fragnum(&sblock, csfrags) > 0 ?
	sblock.fs_frag - fragnum(&sblock, csfrags) : 0);
	- sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;
	+ sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg -
	+ UFS_ROOTINO;
	sblock.fs_cstotal.cs_ndir = 0;
	sblock.fs_dsize -= csfrags;
	sblock.fs_time = tstamp;
	@@ -654,7 +655,7 @@
	}
	acg.cg_cs.cs_nifree += sblock.fs_ipg;
	if (cylno == 0)
	- for (i = 0; i < ROOTINO; i++) {
	+ for (i = 0; i < UFS_ROOTINO; i++) {
	setbit(cg_inosused_swap(&acg, 0), i);
	acg.cg_cs.cs_nifree--;
	}
	Index: usr.sbin/makefs/ffs/ufs_bmap.c
	===================================================================
	--- usr.sbin/makefs/ffs/ufs_bmap.c
	+++ usr.sbin/makefs/ffs/ufs_bmap.c
	@@ -82,17 +82,17 @@
	if ((long)bn < 0)
	bn = -(long)bn;

	- assert (bn >= NDADDR);
	+ assert (bn >= UFS_NDADDR);

	/*
	* Determine the number of levels of indirection. After this loop
	* is done, blockcnt indicates the number of data blocks possible
	- * at the given level of indirection, and NIADDR - i is the number
	+ * at the given level of indirection, and UFS_NIADDR - i is the number
	* of levels of indirection needed to locate the requested block.
	*/

	- bn -= NDADDR;
	- for (lbc = 0, i = NIADDR;; i--, bn -= blockcnt) {
	+ bn -= UFS_NDADDR;
	+ for (lbc = 0, i = UFS_NIADDR;; i--, bn -= blockcnt) {
	if (i == 0)
	return (EFBIG);

	@@ -105,9 +105,9 @@

	/* Calculate the address of the first meta-block. */
	if (realbn >= 0)
	- metalbn = -(realbn - bn + NIADDR - i);
	+ metalbn = -(realbn - bn + UFS_NIADDR - i);
	else
	- metalbn = -(-realbn - bn + NIADDR - i);
	+ metalbn = -(-realbn - bn + UFS_NIADDR - i);

	/*
	* At each iteration, off is the offset into the bap array which is
	@@ -116,9 +116,9 @@
	* into the argument array.
	*/
	ap->in_lbn = metalbn;
	- ap->in_off = off = NIADDR - i;
	+ ap->in_off = off = UFS_NIADDR - i;
	ap++;
	- for (++numlevels; i <= NIADDR; i++) {
	+ for (++numlevels; i <= UFS_NIADDR; i++) {
	/* If searching for a meta-data block, quit when found. */
	if (metalbn == realbn)
	break;
	Index: usr.sbin/makefs/makefs.h
	===================================================================
	--- usr.sbin/makefs/makefs.h
	+++ usr.sbin/makefs/makefs.h
	@@ -255,8 +255,8 @@
	#define DINODE1_SIZE (sizeof(struct ufs1_dinode))
	#define DINODE2_SIZE (sizeof(struct ufs2_dinode))

	-#define MAXSYMLINKLEN_UFS1 ((NDADDR + NIADDR) * sizeof(ufs1_daddr_t))
	-#define MAXSYMLINKLEN_UFS2 ((NDADDR + NIADDR) * sizeof(ufs2_daddr_t))
	+#define UFS1_MAXSYMLINKLEN ((UFS_NDADDR + UFS_NIADDR) * sizeof(ufs1_daddr_t))
	+#define UFS2_MAXSYMLINKLEN ((UFS_NDADDR + UFS_NIADDR) * sizeof(ufs2_daddr_t))

	#if (BYTE_ORDER == LITTLE_ENDIAN)
	#define DIRSIZ_SWAP(oldfmt, dp, needswap) \
	Index: usr.sbin/quot/quot.c
	===================================================================
	--- usr.sbin/quot/quot.c
	+++ usr.sbin/quot/quot.c
	@@ -170,7 +170,7 @@

	sz = DIP(super, dp, di_size);
	#ifdef COMPAT
	- if (lblkno(super,sz) >= NDADDR) {
	+ if (lblkno(super,sz) >= UFS_NDADDR) {
	nblk = blkroundup(super,sz);
	if (sz == nblk)
	nblk += super->fs_bsize;
	@@ -180,10 +180,10 @@

	#else /* COMPAT */

	- if (lblkno(super,sz) >= NDADDR) {
	+ if (lblkno(super,sz) >= UFS_NDADDR) {
	nblk = blkroundup(super,sz);
	sz = lblkno(super,nblk);
	- sz = (sz - NDADDR + NINDIR(super) - 1) / NINDIR(super);
	+ sz = (sz - UFS_NDADDR + NINDIR(super) - 1) / NINDIR(super);
	while (sz > 0) {
	nblk += sz * super->fs_bsize;
	/* sz - 1 rounded up */

File Metadata

Mime Type: text/plain
Expires: Sun, Dec 21, 9:19 PM (13 m, 51 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 27121997
Default Alt Text: D9536.id24996.diff (129 KB)

D9536.id24996.diffNo OneTemporaryActions

D9536.id24996.diffView Options

File Metadata

Event Timeline

D9536.id24996.diff
No OneTemporary
Actions

D9536.id24996.diff
View Options