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 */