Module Name: src
Committed By: dholland
Date: Tue Sep 15 14:58:06 UTC 2015
Modified Files:
src/sbin/fsck_lfs: dir.c inode.c pass2.c
src/sbin/newfs_lfs: make_lfs.c
src/sys/ufs/lfs: lfs.h lfs_accessors.h lfs_rename.c ulfs_dirhash.c
ulfs_lookup.c ulfs_vnops.c
Log Message:
Add and use accessor functions for more of the directory entry fields.
To generate a diff of this commit:
cvs rdiff -u -r1.38 -r1.39 src/sbin/fsck_lfs/dir.c
cvs rdiff -u -r1.63 -r1.64 src/sbin/fsck_lfs/inode.c
cvs rdiff -u -r1.27 -r1.28 src/sbin/fsck_lfs/pass2.c
cvs rdiff -u -r1.49 -r1.50 src/sbin/newfs_lfs/make_lfs.c
cvs rdiff -u -r1.185 -r1.186 src/sys/ufs/lfs/lfs.h
cvs rdiff -u -r1.22 -r1.23 src/sys/ufs/lfs/lfs_accessors.h
cvs rdiff -u -r1.9 -r1.10 src/sys/ufs/lfs/lfs_rename.c \
src/sys/ufs/lfs/ulfs_dirhash.c
cvs rdiff -u -r1.26 -r1.27 src/sys/ufs/lfs/ulfs_lookup.c
cvs rdiff -u -r1.28 -r1.29 src/sys/ufs/lfs/ulfs_vnops.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sbin/fsck_lfs/dir.c
diff -u src/sbin/fsck_lfs/dir.c:1.38 src/sbin/fsck_lfs/dir.c:1.39
--- src/sbin/fsck_lfs/dir.c:1.38 Tue Sep 1 06:16:58 2015
+++ src/sbin/fsck_lfs/dir.c Tue Sep 15 14:58:05 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: dir.c,v 1.38 2015/09/01 06:16:58 dholland Exp $ */
+/* $NetBSD: dir.c,v 1.39 2015/09/15 14:58:05 dholland Exp $ */
/*
* Copyright (c) 1980, 1986, 1993
@@ -154,7 +154,7 @@ dirscan(struct inodesc *idesc)
vp = vget(fs, idesc->id_number);
for (dp = fsck_readdir(vp, idesc); dp != NULL;
dp = fsck_readdir(vp, idesc)) {
- dsize = dp->d_reclen;
+ dsize = lfs_dir_getreclen(fs, dp);
memcpy(dbuf, dp, (size_t) dsize);
idesc->id_dirp = (struct lfs_direct *) dbuf;
if ((n = (*idesc->id_func) (idesc)) & ALTERED) {
@@ -193,8 +193,8 @@ fsck_readdir(struct uvnode *vp, struct i
fix = dofix(idesc, "DIRECTORY CORRUPTED");
bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
dp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
- dp->d_reclen = LFS_DIRBLKSIZ;
- dp->d_ino = 0;
+ lfs_dir_setreclen(fs, dp, LFS_DIRBLKSIZ);
+ lfs_dir_setino(fs, dp, 0);
lfs_dir_settype(fs, dp, LFS_DT_UNKNOWN);
lfs_dir_setnamlen(fs, dp, 0);
dp->d_name[0] = '\0';
@@ -213,8 +213,8 @@ dpok:
}
dploc = idesc->id_loc;
dp = (struct lfs_direct *) (bp->b_data + dploc);
- idesc->id_loc += dp->d_reclen;
- idesc->id_filesize -= dp->d_reclen;
+ idesc->id_loc += lfs_dir_getreclen(fs, dp);
+ idesc->id_filesize -= lfs_dir_getreclen(fs, dp);
if ((idesc->id_loc % LFS_DIRBLKSIZ) == 0) {
brelse(bp, 0);
return dp;
@@ -231,7 +231,7 @@ dpok:
fix = dofix(idesc, "DIRECTORY CORRUPTED");
bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
dp = (struct lfs_direct *) (bp->b_data + dploc);
- dp->d_reclen += size;
+ lfs_dir_setreclen(fs, dp, lfs_dir_getreclen(fs, dp) + size);
if (fix)
VOP_BWRITE(bp);
else
@@ -255,23 +255,24 @@ dircheck(struct inodesc *idesc, struct l
int spaceleft;
spaceleft = LFS_DIRBLKSIZ - (idesc->id_loc % LFS_DIRBLKSIZ);
- if (dp->d_ino >= maxino ||
- dp->d_reclen == 0 ||
- dp->d_reclen > spaceleft ||
- (dp->d_reclen & 0x3) != 0) {
+ if (lfs_dir_getino(fs, dp) >= maxino ||
+ lfs_dir_getreclen(fs, dp) == 0 ||
+ lfs_dir_getreclen(fs, dp) > spaceleft ||
+ (lfs_dir_getreclen(fs, dp) & 0x3) != 0) {
pwarn("ino too large, reclen=0, reclen>space, or reclen&3!=0\n");
- pwarn("dp->d_ino = 0x%x\tdp->d_reclen = 0x%x\n",
- dp->d_ino, dp->d_reclen);
- pwarn("maxino = %llu\tspaceleft = 0x%x\n",
- (unsigned long long)maxino, spaceleft);
+ pwarn("dp->d_ino = 0x%jx\tdp->d_reclen = 0x%x\n",
+ (uintmax_t)lfs_dir_getino(fs, dp),
+ lfs_dir_getreclen(fs, dp));
+ pwarn("maxino = %ju\tspaceleft = 0x%x\n",
+ (uintmax_t)maxino, spaceleft);
return (0);
}
- if (dp->d_ino == 0)
+ if (lfs_dir_getino(fs, dp) == 0)
return (1);
size = LFS_DIRSIZ(fs, dp);
namlen = lfs_dir_getnamlen(fs, dp);
type = lfs_dir_gettype(fs, dp);
- if (dp->d_reclen < size ||
+ if (lfs_dir_getreclen(fs, dp) < size ||
idesc->id_filesize < size ||
/* namlen > MAXNAMLEN || */
type > 15) {
@@ -374,17 +375,18 @@ mkentry(struct inodesc *idesc)
namlen = strlen(idesc->id_name);
lfs_dir_setnamlen(fs, &newent, namlen);
newlen = LFS_DIRSIZ(fs, &newent);
- if (dirp->d_ino != 0)
+ if (lfs_dir_getino(fs, dirp) != 0)
oldlen = LFS_DIRSIZ(fs, dirp);
else
oldlen = 0;
- if (dirp->d_reclen - oldlen < newlen)
+ if (lfs_dir_getreclen(fs, dirp) - oldlen < newlen)
return (KEEPON);
- newent.d_reclen = dirp->d_reclen - oldlen;
- dirp->d_reclen = oldlen;
+ lfs_dir_setreclen(fs, &newent, lfs_dir_getreclen(fs, dirp) - oldlen);
+ lfs_dir_setreclen(fs, dirp, oldlen);
dirp = (struct lfs_direct *) (((char *) dirp) + oldlen);
- dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
- dirp->d_reclen = newent.d_reclen;
+ /* ino to be entered is in id_parent */
+ lfs_dir_setino(fs, dirp, idesc->id_parent);
+ lfs_dir_setreclen(fs, dirp, lfs_dir_getreclen(fs, &newent));
lfs_dir_settype(fs, dirp, typemap[idesc->id_parent]);
lfs_dir_setnamlen(fs, dirp, namlen);
memcpy(dirp->d_name, idesc->id_name, (size_t)namlen + 1);
@@ -400,7 +402,7 @@ chgino(struct inodesc *idesc)
namlen = lfs_dir_getnamlen(fs, dirp);
if (memcmp(dirp->d_name, idesc->id_name, namlen + 1))
return (KEEPON);
- dirp->d_ino = idesc->id_parent;
+ lfs_dir_setino(fs, dirp, idesc->id_parent);
lfs_dir_settype(fs, dirp, typemap[idesc->id_parent]);
return (ALTERED | STOP);
}
Index: src/sbin/fsck_lfs/inode.c
diff -u src/sbin/fsck_lfs/inode.c:1.63 src/sbin/fsck_lfs/inode.c:1.64
--- src/sbin/fsck_lfs/inode.c:1.63 Tue Sep 1 06:16:58 2015
+++ src/sbin/fsck_lfs/inode.c Tue Sep 15 14:58:05 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: inode.c,v 1.63 2015/09/01 06:16:58 dholland Exp $ */
+/* $NetBSD: inode.c,v 1.64 2015/09/15 14:58:05 dholland Exp $ */
/*-
* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
@@ -505,7 +505,7 @@ findname(struct inodesc * idesc)
size_t len;
char *buf;
- if (dirp->d_ino != idesc->id_parent)
+ if (lfs_dir_getino(fs, dirp) != idesc->id_parent)
return (KEEPON);
len = lfs_dir_getnamlen(fs, dirp) + 1;
/* XXX this is wrong: namlen+1 can be up to MAXPATHLEN+1 */
@@ -524,12 +524,14 @@ int
findino(struct inodesc * idesc)
{
struct lfs_direct *dirp = idesc->id_dirp;
+ ino_t ino;
- if (dirp->d_ino == 0)
+ ino = lfs_dir_getino(fs, dirp);
+ if (ino == 0)
return (KEEPON);
if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
- dirp->d_ino >= ULFS_ROOTINO && dirp->d_ino < maxino) {
- idesc->id_parent = dirp->d_ino;
+ ino >= ULFS_ROOTINO && ino < maxino) {
+ idesc->id_parent = ino;
return (STOP | FOUND);
}
return (KEEPON);
Index: src/sbin/fsck_lfs/pass2.c
diff -u src/sbin/fsck_lfs/pass2.c:1.27 src/sbin/fsck_lfs/pass2.c:1.28
--- src/sbin/fsck_lfs/pass2.c:1.27 Tue Sep 1 06:16:58 2015
+++ src/sbin/fsck_lfs/pass2.c Tue Sep 15 14:58:05 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: pass2.c,v 1.27 2015/09/01 06:16:58 dholland Exp $ */
+/* $NetBSD: pass2.c,v 1.28 2015/09/15 14:58:05 dholland Exp $ */
/*
* Copyright (c) 1980, 1986, 1993
@@ -226,11 +226,11 @@ pass2check(struct inodesc * idesc)
*/
if (idesc->id_entryno != 0)
goto chk1;
- if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
- if (dirp->d_ino != idesc->id_number) {
+ if (lfs_dir_getino(fs, dirp) != 0 && strcmp(dirp->d_name, ".") == 0) {
+ if (lfs_dir_getino(fs, dirp) != idesc->id_number) {
direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
if (reply("FIX") == 1) {
- dirp->d_ino = idesc->id_number;
+ lfs_dir_setino(fs, dirp, idesc->id_number);
ret |= ALTERED;
}
}
@@ -244,30 +244,30 @@ pass2check(struct inodesc * idesc)
goto chk1;
}
direrror(idesc->id_number, "MISSING '.'");
- proto.d_ino = idesc->id_number;
+ lfs_dir_setino(fs, &proto, idesc->id_number);
lfs_dir_settype(fs, &proto, LFS_DT_DIR);
lfs_dir_setnamlen(fs, &proto, 1);
(void) strlcpy(proto.d_name, ".", sizeof(proto.d_name));
entrysize = LFS_DIRSIZ(fs, &proto);
- if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
+ if (lfs_dir_getino(fs, dirp) != 0 && strcmp(dirp->d_name, "..") != 0) {
pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
dirp->d_name);
- } else if (dirp->d_reclen < entrysize) {
+ } else if (lfs_dir_getreclen(fs, dirp) < entrysize) {
pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
- } else if (dirp->d_reclen < 2 * entrysize) {
- proto.d_reclen = dirp->d_reclen;
+ } else if (lfs_dir_getreclen(fs, dirp) < 2 * entrysize) {
+ lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp));
memcpy(dirp, &proto, (size_t) entrysize);
if (reply("FIX") == 1)
ret |= ALTERED;
} else {
- n = dirp->d_reclen - entrysize;
- proto.d_reclen = entrysize;
+ n = lfs_dir_getreclen(fs, dirp) - entrysize;
+ lfs_dir_setreclen(fs, &proto, entrysize);
memcpy(dirp, &proto, (size_t) entrysize);
idesc->id_entryno++;
- lncntp[dirp->d_ino]--;
+ lncntp[lfs_dir_getino(fs, dirp)]--;
dirp = (struct lfs_direct *) ((char *) (dirp) + entrysize);
memset(dirp, 0, (size_t) n);
- dirp->d_reclen = n;
+ lfs_dir_setreclen(fs, dirp, n);
if (reply("FIX") == 1)
ret |= ALTERED;
}
@@ -275,25 +275,25 @@ chk1:
if (idesc->id_entryno > 1)
goto chk2;
inp = getinoinfo(idesc->id_number);
- proto.d_ino = inp->i_parent;
+ lfs_dir_setino(fs, &proto, inp->i_parent);
lfs_dir_settype(fs, &proto, LFS_DT_DIR);
lfs_dir_setnamlen(fs, &proto, 2);
(void) strlcpy(proto.d_name, "..", sizeof(proto.d_name));
entrysize = LFS_DIRSIZ(fs, &proto);
if (idesc->id_entryno == 0) {
n = LFS_DIRSIZ(fs, dirp);
- if (dirp->d_reclen < n + entrysize)
+ if (lfs_dir_getreclen(fs, dirp) < n + entrysize)
goto chk2;
- proto.d_reclen = dirp->d_reclen - n;
- dirp->d_reclen = n;
+ lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp) - n);
+ lfs_dir_setreclen(fs, dirp, n);
idesc->id_entryno++;
- lncntp[dirp->d_ino]--;
+ lncntp[lfs_dir_getino(fs, dirp)]--;
dirp = (struct lfs_direct *) ((char *) (dirp) + n);
- memset(dirp, 0, (size_t) proto.d_reclen);
- dirp->d_reclen = proto.d_reclen;
+ memset(dirp, 0, lfs_dir_getreclen(fs, &proto));
+ lfs_dir_setreclen(fs, dirp, lfs_dir_getreclen(fs, &proto));
}
- if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
- inp->i_dotdot = dirp->d_ino;
+ if (lfs_dir_getino(fs, dirp) != 0 && strcmp(dirp->d_name, "..") == 0) {
+ inp->i_dotdot = lfs_dir_getino(fs, dirp);
if (lfs_dir_gettype(fs, dirp) != LFS_DT_DIR) {
direrror(idesc->id_number, "BAD TYPE VALUE FOR '..'");
lfs_dir_settype(fs, dirp, LFS_DT_DIR);
@@ -302,12 +302,12 @@ chk1:
}
goto chk2;
}
- if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
+ if (lfs_dir_getino(fs, dirp) != 0 && strcmp(dirp->d_name, ".") != 0) {
fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
dirp->d_name);
inp->i_dotdot = (ino_t) - 1;
- } else if (dirp->d_reclen < entrysize) {
+ } else if (lfs_dir_getreclen(fs, dirp) < entrysize) {
fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
inp->i_dotdot = (ino_t) - 1;
@@ -317,17 +317,17 @@ chk1:
*/
inp->i_dotdot = inp->i_parent;
fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
- proto.d_reclen = dirp->d_reclen;
+ lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp));
memcpy(dirp, &proto, (size_t) entrysize);
if (reply("FIX") == 1)
ret |= ALTERED;
}
idesc->id_entryno++;
- if (dirp->d_ino != 0)
- lncntp[dirp->d_ino]--;
+ if (lfs_dir_getino(fs, dirp) != 0)
+ lncntp[lfs_dir_getino(fs, dirp)]--;
return (ret | KEEPON);
chk2:
- if (dirp->d_ino == 0)
+ if (lfs_dir_getino(fs, dirp) == 0)
return (ret | KEEPON);
if (lfs_dir_getnamlen(fs, dirp) <= 2 &&
dirp->d_name[0] == '.' &&
@@ -335,7 +335,7 @@ chk2:
if (lfs_dir_getnamlen(fs, dirp) == 1) {
direrror(idesc->id_number, "EXTRA '.' ENTRY");
if (reply("FIX") == 1) {
- dirp->d_ino = 0;
+ lfs_dir_setino(fs, dirp, 0);
ret |= ALTERED;
}
return (KEEPON | ret);
@@ -343,7 +343,7 @@ chk2:
if (dirp->d_name[1] == '.') {
direrror(idesc->id_number, "EXTRA '..' ENTRY");
if (reply("FIX") == 1) {
- dirp->d_ino = 0;
+ lfs_dir_setino(fs, dirp, 0);
ret |= ALTERED;
}
return (KEEPON | ret);
@@ -351,34 +351,35 @@ chk2:
}
idesc->id_entryno++;
n = 0;
- if (dirp->d_ino >= maxino) {
- fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE");
+ if (lfs_dir_getino(fs, dirp) >= maxino) {
+ fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), "I OUT OF RANGE");
n = reply("REMOVE");
- } else if (dirp->d_ino == LFS_IFILE_INUM &&
+ } else if (lfs_dir_getino(fs, dirp) == LFS_IFILE_INUM &&
idesc->id_number == ULFS_ROOTINO) {
if (lfs_dir_gettype(fs, dirp) != LFS_DT_REG) {
- fileerror(idesc->id_number, dirp->d_ino,
+ fileerror(idesc->id_number, lfs_dir_getino(fs, dirp),
"BAD TYPE FOR IFILE");
if (reply("FIX") == 1) {
lfs_dir_settype(fs, dirp, LFS_DT_REG);
ret |= ALTERED;
}
}
- } else if (((dirp->d_ino == ULFS_WINO && lfs_dir_gettype(fs, dirp) != LFS_DT_WHT) ||
- (dirp->d_ino != ULFS_WINO && lfs_dir_gettype(fs, dirp) == LFS_DT_WHT))) {
- fileerror(idesc->id_number, dirp->d_ino, "BAD WHITEOUT ENTRY");
- dirp->d_ino = ULFS_WINO;
+ } else if (((lfs_dir_getino(fs, dirp) == ULFS_WINO && lfs_dir_gettype(fs, dirp) != LFS_DT_WHT) ||
+ (lfs_dir_getino(fs, dirp) != ULFS_WINO && lfs_dir_gettype(fs, dirp) == LFS_DT_WHT))) {
+ fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), "BAD WHITEOUT ENTRY");
if (reply("FIX") == 1) {
+ lfs_dir_setino(fs, dirp, ULFS_WINO);
lfs_dir_settype(fs, dirp, LFS_DT_WHT);
ret |= ALTERED;
}
} else {
again:
- switch (statemap[dirp->d_ino]) {
+ switch (statemap[lfs_dir_getino(fs, dirp)]) {
case USTATE:
if (idesc->id_entryno <= 2)
break;
- fileerror(idesc->id_number, dirp->d_ino, "UNALLOCATED");
+ fileerror(idesc->id_number, lfs_dir_getino(fs, dirp),
+ "UNALLOCATED");
n = reply("REMOVE");
break;
@@ -386,7 +387,7 @@ again:
case FCLEAR:
if (idesc->id_entryno <= 2)
break;
- if (statemap[dirp->d_ino] == FCLEAR)
+ if (statemap[lfs_dir_getino(fs, dirp)] == FCLEAR)
errmsg = "DUP/BAD";
else if (!preen)
errmsg = "ZERO LENGTH DIRECTORY";
@@ -394,23 +395,24 @@ again:
n = 1;
break;
}
- fileerror(idesc->id_number, dirp->d_ino, errmsg);
+ fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), errmsg);
if ((n = reply("REMOVE")) == 1)
break;
- dp = ginode(dirp->d_ino);
- statemap[dirp->d_ino] =
+ dp = ginode(lfs_dir_getino(fs, dirp));
+ statemap[lfs_dir_getino(fs, dirp)] =
(lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR ? DSTATE : FSTATE;
- lncntp[dirp->d_ino] = lfs_dino_getnlink(fs, dp);
+ lncntp[lfs_dir_getino(fs, dirp)] = lfs_dino_getnlink(fs, dp);
goto again;
case DSTATE:
case DFOUND:
- inp = getinoinfo(dirp->d_ino);
+ inp = getinoinfo(lfs_dir_getino(fs, dirp));
if (inp->i_parent != 0 && idesc->id_entryno > 2) {
getpathname(pathbuf, sizeof(pathbuf),
idesc->id_number, idesc->id_number);
getpathname(namebuf, sizeof(namebuf),
- dirp->d_ino, dirp->d_ino);
+ lfs_dir_getino(fs, dirp),
+ lfs_dir_getino(fs, dirp));
pwarn("%s %s %s\n", pathbuf,
"IS AN EXTRANEOUS HARD LINK TO DIRECTORY",
namebuf);
@@ -424,27 +426,29 @@ again:
/* fall through */
case FSTATE:
- if (lfs_dir_gettype(fs, dirp) != typemap[dirp->d_ino]) {
- fileerror(idesc->id_number, dirp->d_ino,
+ if (lfs_dir_gettype(fs, dirp) != typemap[lfs_dir_getino(fs, dirp)]) {
+ fileerror(idesc->id_number,
+ lfs_dir_getino(fs, dirp),
"BAD TYPE VALUE");
if (debug)
pwarn("dir has %d, typemap has %d\n",
- lfs_dir_gettype(fs, dirp), typemap[dirp->d_ino]);
- lfs_dir_settype(fs, dirp, typemap[dirp->d_ino]);
+ lfs_dir_gettype(fs, dirp), typemap[lfs_dir_getino(fs, dirp)]);
+ lfs_dir_settype(fs, dirp, typemap[lfs_dir_getino(fs, dirp)]);
if (reply("FIX") == 1)
ret |= ALTERED;
}
- lncntp[dirp->d_ino]--;
+ lncntp[lfs_dir_getino(fs, dirp)]--;
break;
default:
- errx(EEXIT, "BAD STATE %d FOR INODE I=%d",
- statemap[dirp->d_ino], dirp->d_ino);
+ errx(EEXIT, "BAD STATE %d FOR INODE I=%ju",
+ statemap[lfs_dir_getino(fs, dirp)],
+ (uintmax_t)lfs_dir_getino(fs, dirp));
}
}
if (n == 0)
return (ret | KEEPON);
- dirp->d_ino = 0;
+ lfs_dir_setino(fs, dirp, 0);
return (ret | KEEPON | ALTERED);
}
/*
Index: src/sbin/newfs_lfs/make_lfs.c
diff -u src/sbin/newfs_lfs/make_lfs.c:1.49 src/sbin/newfs_lfs/make_lfs.c:1.50
--- src/sbin/newfs_lfs/make_lfs.c:1.49 Tue Sep 1 06:16:58 2015
+++ src/sbin/newfs_lfs/make_lfs.c Tue Sep 15 14:58:05 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: make_lfs.c,v 1.49 2015/09/01 06:16:58 dholland Exp $ */
+/* $NetBSD: make_lfs.c,v 1.50 2015/09/15 14:58:05 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -62,7 +62,7 @@
#if 0
static char sccsid[] = "@(#)lfs.c 8.5 (Berkeley) 5/24/95";
#else
-__RCSID("$NetBSD: make_lfs.c,v 1.49 2015/09/01 06:16:58 dholland Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.50 2015/09/15 14:58:05 dholland Exp $");
#endif
#endif /* not lint */
@@ -389,16 +389,18 @@ make_dir(struct lfs *fs, void *bufp, str
{
char *cp;
int i, spcleft;
+ unsigned reclen;
spcleft = LFS_DIRBLKSIZ;
for (cp = bufp, i = 0; i < entries - 1; i++) {
- protodir[i].d_reclen = LFS_DIRSIZ(fs, &protodir[i]);
- memmove(cp, &protodir[i], protodir[i].d_reclen);
- cp += protodir[i].d_reclen;
- if ((spcleft -= protodir[i].d_reclen) < 0)
+ reclen = LFS_DIRSIZ(fs, &protodir[i]);
+ lfs_dir_setreclen(fs, &protodir[i], reclen);
+ memmove(cp, &protodir[i], lfs_dir_getreclen(fs, &protodir[i]));
+ cp += reclen;
+ if ((spcleft -= reclen) < 0)
fatal("%s: %s", special, "directory too big");
}
- protodir[i].d_reclen = spcleft;
+ lfs_dir_setreclen(fs, &protodir[i], spcleft);
memmove(cp, &protodir[i], LFS_DIRSIZ(fs, &protodir[i]));
}
Index: src/sys/ufs/lfs/lfs.h
diff -u src/sys/ufs/lfs/lfs.h:1.185 src/sys/ufs/lfs/lfs.h:1.186
--- src/sys/ufs/lfs/lfs.h:1.185 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/lfs.h Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.h,v 1.185 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: lfs.h,v 1.186 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp */
/* from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp */
@@ -365,15 +365,24 @@
/*
* (See notes above)
*/
-#define d_ino d_fileno
struct lfs_direct {
- u_int32_t d_fileno; /* inode number of entry */
+ u_int32_t d_ino; /* inode number of entry */
u_int16_t d_reclen; /* length of this record */
u_int8_t d_type; /* file type, see below */
u_int8_t d_namlen; /* length of string in d_name */
char d_name[LFS_MAXNAMLEN + 1];/* name with length <= LFS_MAXNAMLEN */
};
+/* Note that this does *not* byteswap and should probably be phased out */
+#define LFS_DIRECT_INITIALIZER(ino, type, namlen, name) \
+ { \
+ .d_ino = (ino), \
+ .d_reclen = LFS_DIRECTSIZE(namlen), \
+ .d_type = (type), \
+ .d_namlen = (namlen), \
+ .d_name = (name) \
+ }
+
/*
* Template for manipulating directories. Should use struct lfs_direct's,
* but the name field is LFS_MAXNAMLEN - 1, and this just won't do.
Index: src/sys/ufs/lfs/lfs_accessors.h
diff -u src/sys/ufs/lfs/lfs_accessors.h:1.22 src/sys/ufs/lfs/lfs_accessors.h:1.23
--- src/sys/ufs/lfs/lfs_accessors.h:1.22 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/lfs_accessors.h Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_accessors.h,v 1.22 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: lfs_accessors.h,v 1.23 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp */
/* from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp */
@@ -241,6 +241,21 @@
#define LFS_OLDDIRFMT 1
#define LFS_NEWDIRFMT 0
+#define LFS_NEXTDIR(fs, dp) \
+ ((struct lfs_direct *)((char *)(dp) + lfs_dir_getreclen(fs, dp)))
+
+static __unused inline uint32_t
+lfs_dir_getino(const STRUCT_LFS *fs, const struct lfs_direct *dp)
+{
+ return LFS_SWAP_uint32_t(fs, dp->d_ino);
+}
+
+static __unused inline uint16_t
+lfs_dir_getreclen(const STRUCT_LFS *fs, const struct lfs_direct *dp)
+{
+ return LFS_SWAP_uint16_t(fs, dp->d_reclen);
+}
+
static __unused inline uint8_t
lfs_dir_gettype(const STRUCT_LFS *fs, const struct lfs_direct *dp)
{
@@ -261,6 +276,18 @@ lfs_dir_getnamlen(const STRUCT_LFS *fs,
}
static __unused inline void
+lfs_dir_setino(STRUCT_LFS *fs, struct lfs_direct *dp, uint32_t ino)
+{
+ dp->d_ino = LFS_SWAP_uint32_t(fs, ino);
+}
+
+static __unused inline void
+lfs_dir_setreclen(STRUCT_LFS *fs, struct lfs_direct *dp, uint16_t reclen)
+{
+ dp->d_reclen = LFS_SWAP_uint16_t(fs, reclen);
+}
+
+static __unused inline void
lfs_dir_settype(const STRUCT_LFS *fs, struct lfs_direct *dp, uint8_t type)
{
if (fs->lfs_hasolddirfmt) {
Index: src/sys/ufs/lfs/lfs_rename.c
diff -u src/sys/ufs/lfs/lfs_rename.c:1.9 src/sys/ufs/lfs/lfs_rename.c:1.10
--- src/sys/ufs/lfs/lfs_rename.c:1.9 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/lfs_rename.c Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_rename.c,v 1.9 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: lfs_rename.c,v 1.10 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: ufs_rename.c,v 1.6 2013/01/22 09:39:18 dholland Exp */
/*-
@@ -89,7 +89,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_rename.c,v 1.9 2015/09/01 06:16:59 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_rename.c,v 1.10 2015/09/15 14:58:06 dholland Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@@ -355,7 +355,6 @@ ulfs_rename_recalculate_fulr(struct vnod
struct mount *mp;
struct lfs *fs;
struct ulfsmount *ump;
- int needswap;
/* XXX int is a silly type for this; blame ulfsmount::um_dirblksiz. */
int dirblksiz;
doff_t search_start, search_end;
@@ -384,8 +383,6 @@ ulfs_rename_recalculate_fulr(struct vnod
KASSERT(ump == VTOI(dvp)->i_ump);
KASSERT(fs == VTOI(dvp)->i_lfs);
- needswap = ULFS_MPNEEDSWAP(fs);
-
dirblksiz = fs->um_dirblksiz;
KASSERT(0 < dirblksiz);
KASSERT((dirblksiz & (dirblksiz - 1)) == 0);
@@ -434,12 +431,12 @@ ulfs_rename_recalculate_fulr(struct vnod
* Examine the directory entry at offset.
*/
ep = (struct lfs_direct *)(dirbuf + (offset - search_start));
- reclen = ulfs_rw16(ep->d_reclen, needswap);
+ reclen = lfs_dir_getreclen(fs, ep);
- if (ep->d_ino == 0)
+ if (lfs_dir_getino(fs, ep) == 0)
goto next; /* Entry is unused. */
- if (ulfs_rw32(ep->d_ino, needswap) == ULFS_WINO)
+ if (lfs_dir_getino(fs, ep) == ULFS_WINO)
goto next; /* Entry is whiteout. */
if (fcnp->cn_namelen != ulfs_direct_namlen(ep, dvp))
Index: src/sys/ufs/lfs/ulfs_dirhash.c
diff -u src/sys/ufs/lfs/ulfs_dirhash.c:1.9 src/sys/ufs/lfs/ulfs_dirhash.c:1.10
--- src/sys/ufs/lfs/ulfs_dirhash.c:1.9 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/ulfs_dirhash.c Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_dirhash.c,v 1.9 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: ulfs_dirhash.c,v 1.10 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: ufs_dirhash.c,v 1.34 2009/10/05 23:48:08 rmind Exp */
/*
@@ -29,7 +29,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_dirhash.c,v 1.9 2015/09/01 06:16:59 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_dirhash.c,v 1.10 2015/09/15 14:58:06 dholland Exp $");
/*
* This implements a hash-based lookup scheme for ULFS directories.
@@ -73,8 +73,8 @@ static void ulfsdirhash_adjfree(struct d
static void ulfsdirhash_delslot(struct dirhash *dh, int slot);
static int ulfsdirhash_findslot(struct dirhash *dh, const char *name,
int namelen, doff_t offset);
-static doff_t ulfsdirhash_getprev(struct lfs_direct *dp, doff_t offset,
- int dirblksiz);
+static doff_t ulfsdirhash_getprev(struct lfs *fs, struct lfs_direct *dp,
+ doff_t offset, int dirblksiz);
static int ulfsdirhash_recycle(int wanted);
static pool_cache_t ulfsdirhashblk_cache;
@@ -228,13 +228,13 @@ ulfsdirhash_build(struct inode *ip)
/* Add this entry to the hash. */
ep = (struct lfs_direct *)((char *)bp->b_data + (pos & bmask));
- if (ep->d_reclen == 0 || ep->d_reclen >
+ if (lfs_dir_getreclen(fs, ep) == 0 || lfs_dir_getreclen(fs, ep) >
dirblksiz - (pos & (dirblksiz - 1))) {
/* Corrupted directory. */
brelse(bp, 0);
goto fail;
}
- if (ep->d_ino != 0) {
+ if (lfs_dir_getino(fs, ep) != 0) {
/* Add the entry (simplified ulfsdirhash_add). */
slot = ulfsdirhash_hash(dh, ep->d_name,
lfs_dir_getnamlen(fs, ep));
@@ -245,7 +245,7 @@ ulfsdirhash_build(struct inode *ip)
ulfsdirhash_adjfree(dh, pos, -LFS_DIRSIZ(fs, ep),
dirblksiz);
}
- pos += ep->d_reclen;
+ pos += lfs_dir_getreclen(fs, ep);
}
if (bp != NULL)
@@ -425,7 +425,7 @@ restart:
}
}
dp = (struct lfs_direct *)((char *)bp->b_data + (offset & bmask));
- if (dp->d_reclen == 0 || dp->d_reclen >
+ if (lfs_dir_getreclen(fs, dp) == 0 || lfs_dir_getreclen(fs, dp) >
dirblksiz - (offset & (dirblksiz - 1))) {
/* Corrupted directory. */
DIRHASH_UNLOCK(dh);
@@ -437,7 +437,7 @@ restart:
/* Found. Get the prev offset if needed. */
if (prevoffp != NULL) {
if (offset & (dirblksiz - 1)) {
- prevoff = ulfsdirhash_getprev(dp,
+ prevoff = ulfsdirhash_getprev(fs, dp,
offset, dirblksiz);
if (prevoff == -1) {
brelse(bp, 0);
@@ -538,15 +538,15 @@ ulfsdirhash_findfree(struct inode *ip, i
}
/* Find the first entry with free space. */
for (i = 0; i < dirblksiz; ) {
- if (dp->d_reclen == 0) {
+ if (lfs_dir_getreclen(fs, dp) == 0) {
DIRHASH_UNLOCK(dh);
brelse(bp, 0);
return (-1);
}
- if (dp->d_ino == 0 || dp->d_reclen > LFS_DIRSIZ(fs, dp))
+ if (lfs_dir_getino(fs, dp) == 0 || lfs_dir_getreclen(fs, dp) > LFS_DIRSIZ(fs, dp))
break;
- i += dp->d_reclen;
- dp = (struct lfs_direct *)((char *)dp + dp->d_reclen);
+ i += lfs_dir_getreclen(fs, dp);
+ dp = LFS_NEXTDIR(fs, dp);
}
if (i > dirblksiz) {
DIRHASH_UNLOCK(dh);
@@ -558,16 +558,16 @@ ulfsdirhash_findfree(struct inode *ip, i
/* Find the range of entries needed to get enough space */
freebytes = 0;
while (i < dirblksiz && freebytes < slotneeded) {
- freebytes += dp->d_reclen;
- if (dp->d_ino != 0)
+ freebytes += lfs_dir_getreclen(fs, dp);
+ if (lfs_dir_getino(fs, dp) != 0)
freebytes -= LFS_DIRSIZ(fs, dp);
- if (dp->d_reclen == 0) {
+ if (lfs_dir_getreclen(fs, dp) == 0) {
DIRHASH_UNLOCK(dh);
brelse(bp, 0);
return (-1);
}
- i += dp->d_reclen;
- dp = (struct lfs_direct *)((char *)dp + dp->d_reclen);
+ i += lfs_dir_getreclen(fs, dp);
+ dp = LFS_NEXTDIR(fs, dp);
}
if (i > dirblksiz) {
DIRHASH_UNLOCK(dh);
@@ -851,12 +851,12 @@ ulfsdirhash_checkblock(struct inode *ip,
panic("ulfsdirhash_checkblock: bad offset");
nfree = 0;
- for (i = 0; i < dirblksiz; i += dp->d_reclen) {
+ for (i = 0; i < dirblksiz; i += lfs_dir_getreclen(fs, dp)) {
dp = (struct lfs_direct *)(sbuf + i);
- if (dp->d_reclen == 0 || i + dp->d_reclen > dirblksiz)
+ if (lfs_dir_getreclen(fs, dp) == 0 || i + lfs_dir_getreclen(fs, dp) > dirblksiz)
panic("ulfsdirhash_checkblock: bad dir");
- if (dp->d_ino == 0) {
+ if (lfs_dir_getino(fs, dp) == 0) {
#if 0
/*
* XXX entries with d_ino == 0 should only occur
@@ -867,7 +867,7 @@ ulfsdirhash_checkblock(struct inode *ip,
if (i != 0)
panic("ulfsdirhash_checkblock: bad dir inode");
#endif
- nfree += dp->d_reclen;
+ nfree += lfs_dir_getreclen(fs, dp);
continue;
}
@@ -875,7 +875,7 @@ ulfsdirhash_checkblock(struct inode *ip,
ulfsdirhash_findslot(dh, dp->d_name, lfs_dir_getnamlen(fs, dp),
offset + i);
- nfree += dp->d_reclen - LFS_DIRSIZ(fs, dp);
+ nfree += lfs_dir_getreclen(fs, dp) - LFS_DIRSIZ(fs, dp);
}
if (i != dirblksiz)
panic("ulfsdirhash_checkblock: bad dir end");
@@ -1012,12 +1012,14 @@ ulfsdirhash_delslot(struct dirhash *dh,
* other problem occurred.
*/
static doff_t
-ulfsdirhash_getprev(struct lfs_direct *dirp, doff_t offset, int dirblksiz)
+ulfsdirhash_getprev(struct lfs *fs, struct lfs_direct *dirp,
+ doff_t offset, int dirblksiz)
{
struct lfs_direct *dp;
char *blkbuf;
doff_t blkoff, prevoff;
int entrypos, i;
+ unsigned reclen;
blkoff = offset & ~(dirblksiz - 1); /* offset of start of block */
entrypos = offset & (dirblksiz - 1); /* entry relative to block */
@@ -1029,9 +1031,10 @@ ulfsdirhash_getprev(struct lfs_direct *d
return (-1);
/* Scan from the start of the block until we get to the entry. */
- for (i = 0; i < entrypos; i += dp->d_reclen) {
+ for (i = 0; i < entrypos; i += reclen) {
dp = (struct lfs_direct *)(blkbuf + i);
- if (dp->d_reclen == 0 || i + dp->d_reclen > entrypos)
+ reclen = lfs_dir_getreclen(fs, dp);
+ if (reclen == 0 || i + reclen > entrypos)
return (-1); /* Corrupted directory. */
prevoff = blkoff + i;
}
Index: src/sys/ufs/lfs/ulfs_lookup.c
diff -u src/sys/ufs/lfs/ulfs_lookup.c:1.26 src/sys/ufs/lfs/ulfs_lookup.c:1.27
--- src/sys/ufs/lfs/ulfs_lookup.c:1.26 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/ulfs_lookup.c Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_lookup.c,v 1.26 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: ulfs_lookup.c,v 1.27 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: ufs_lookup.c,v 1.122 2013/01/22 09:39:18 dholland Exp */
/*
@@ -38,7 +38,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_lookup.c,v 1.26 2015/09/01 06:16:59 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_lookup.c,v 1.27 2015/09/15 14:58:06 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_lfs.h"
@@ -151,7 +151,6 @@ ulfs_lookup(void *v)
int flags;
int nameiop = cnp->cn_nameiop;
struct lfs *fs = dp->i_lfs;
- const int needswap = ULFS_MPNEEDSWAP(fs);
int dirblksiz = fs->um_dirblksiz;
ino_t foundino;
struct ulfs_lookup_results *results;
@@ -329,7 +328,7 @@ searchloop:
*/
KASSERT(bp != NULL);
ep = (struct lfs_direct *)((char *)bp->b_data + entryoffsetinblock);
- if (ep->d_reclen == 0 ||
+ if (lfs_dir_getreclen(fs, ep) == 0 ||
(lfs_dirchk && ulfs_dirbadentry(vdp, ep, entryoffsetinblock))) {
int i;
@@ -347,16 +346,15 @@ searchloop:
* compaction is viable.
*/
if (slotstatus != FOUND) {
- int size = ulfs_rw16(ep->d_reclen, needswap);
+ int size = lfs_dir_getreclen(fs, ep);
- if (ep->d_ino != 0)
+ if (lfs_dir_getino(fs, ep) != 0)
size -= LFS_DIRSIZ(fs, ep);
if (size > 0) {
if (size >= slotneeded) {
slotstatus = FOUND;
slotoffset = results->ulr_offset;
- slotsize = ulfs_rw16(ep->d_reclen,
- needswap);
+ slotsize = lfs_dir_getreclen(fs, ep);
} else if (slotstatus == NONE) {
slotfreespace += size;
if (slotoffset == -1)
@@ -364,8 +362,7 @@ searchloop:
if (slotfreespace >= slotneeded) {
slotstatus = COMPACT;
slotsize = results->ulr_offset +
- ulfs_rw16(ep->d_reclen,
- needswap) -
+ lfs_dir_getreclen(fs, ep) -
slotoffset;
}
}
@@ -375,7 +372,7 @@ searchloop:
/*
* Check for a name match.
*/
- if (ep->d_ino) {
+ if (lfs_dir_getino(fs, ep)) {
int namlen;
namlen = lfs_dir_getnamlen(fs, ep);
@@ -392,8 +389,7 @@ foundentry:
if (!FSFMT(vdp) && lfs_dir_gettype(fs, ep) == LFS_DT_WHT) {
slotstatus = FOUND;
slotoffset = results->ulr_offset;
- slotsize = ulfs_rw16(ep->d_reclen,
- needswap);
+ slotsize = lfs_dir_getreclen(fs, ep);
results->ulr_reclen = slotsize;
/*
* This is used to set
@@ -417,16 +413,15 @@ foundentry:
numdirpasses--;
goto notfound;
}
- foundino = ulfs_rw32(ep->d_ino, needswap);
- results->ulr_reclen =
- ulfs_rw16(ep->d_reclen, needswap);
+ foundino = lfs_dir_getino(fs, ep);
+ results->ulr_reclen = lfs_dir_getreclen(fs, ep);
goto found;
}
}
prevoff = results->ulr_offset;
- results->ulr_offset += ulfs_rw16(ep->d_reclen, needswap);
- entryoffsetinblock += ulfs_rw16(ep->d_reclen, needswap);
- if (ep->d_ino)
+ results->ulr_offset += lfs_dir_getreclen(fs, ep);
+ entryoffsetinblock += lfs_dir_getreclen(fs, ep);
+ if (lfs_dir_getino(fs, ep))
enduseful = results->ulr_offset;
}
notfound:
@@ -666,27 +661,26 @@ ulfs_dirbadentry(struct vnode *dp, struc
{
int i;
int namlen;
+ unsigned reclen;
struct ulfsmount *ump = VFSTOULFS(dp->v_mount);
struct lfs *fs = ump->um_lfs;
- const int needswap = ULFS_MPNEEDSWAP(fs);
int dirblksiz = fs->um_dirblksiz;
namlen = lfs_dir_getnamlen(fs, ep);
- if ((ulfs_rw16(ep->d_reclen, needswap) & 0x3) != 0 ||
- ulfs_rw16(ep->d_reclen, needswap) >
- dirblksiz - (entryoffsetinblock & (dirblksiz - 1)) ||
- ulfs_rw16(ep->d_reclen, needswap) < LFS_DIRSIZ(fs, ep) ||
- namlen > LFS_MAXNAMLEN) {
+ reclen = lfs_dir_getreclen(fs, ep);
+ if ((reclen & 0x3) != 0 ||
+ reclen > dirblksiz - (entryoffsetinblock & (dirblksiz - 1)) ||
+ reclen < LFS_DIRSIZ(fs, ep) || namlen > LFS_MAXNAMLEN) {
/*return (1); */
printf("First bad, reclen=%#x, DIRSIZ=%lu, namlen=%d, "
"flags=%#x, entryoffsetinblock=%d, dirblksiz = %d\n",
- ulfs_rw16(ep->d_reclen, needswap),
+ lfs_dir_getreclen(fs, ep),
(u_long)LFS_DIRSIZ(fs, ep),
namlen, dp->v_mount->mnt_flag, entryoffsetinblock,
dirblksiz);
goto bad;
}
- if (ep->d_ino == 0)
+ if (lfs_dir_getino(fs, ep) == 0)
return (0);
for (i = 0; i < namlen; i++)
if (ep->d_name[i] == '\0') {
@@ -714,7 +708,7 @@ ulfs_makedirentry(struct inode *ip, stru
{
struct lfs *fs = ip->i_lfs;
- newdirp->d_ino = ip->i_number;
+ lfs_dir_setino(fs, newdirp, ip->i_number);
memcpy(newdirp->d_name, cnp->cn_nameptr, (size_t)cnp->cn_namelen);
newdirp->d_name[cnp->cn_namelen] = '\0';
lfs_dir_setnamlen(fs, newdirp, cnp->cn_namelen);
@@ -728,7 +722,7 @@ void
ulfs_makedirentry_bytype(struct lfs *fs, struct componentname *cnp,
ino_t inum, unsigned dtype, struct lfs_direct *newdirp)
{
- newdirp->d_ino = inum;
+ lfs_dir_setino(fs, newdirp, inum);
memcpy(newdirp->d_name, cnp->cn_nameptr, (size_t)cnp->cn_namelen);
newdirp->d_name[cnp->cn_namelen] = '\0';
lfs_dir_setnamlen(fs, newdirp, cnp->cn_namelen);
@@ -786,7 +780,6 @@ ulfs_direnter(struct vnode *dvp, const s
struct timespec ts;
struct ulfsmount *ump = VFSTOULFS(dvp->v_mount);
struct lfs *fs = ump->um_lfs;
- const int needswap = ULFS_MPNEEDSWAP(fs);
int dirblksiz = fs->um_dirblksiz;
error = 0;
@@ -812,9 +805,6 @@ ulfs_direnter(struct vnode *dvp, const s
DIP_ASSIGN(dp, size, dp->i_size);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
uvm_vnp_setsize(dvp, dp->i_size);
- dirp->d_reclen = ulfs_rw16(dirblksiz, needswap);
- dirp->d_ino = ulfs_rw32(dirp->d_ino, needswap);
- /* d_type/d_namlen are handled in ulfs_makedirentry */
lfs_blkoff = ulr->ulr_offset & (ump->um_mountp->mnt_stat.f_iosize - 1);
memcpy((char *)bp->b_data + lfs_blkoff, dirp, newentrysize);
#ifdef LFS_DIRHASH
@@ -872,20 +862,20 @@ ulfs_direnter(struct vnode *dvp, const s
* ulr_offset + ulr_count would yield the space.
*/
ep = (struct lfs_direct *)dirbuf;
- dsize = (ep->d_ino != 0) ? LFS_DIRSIZ(fs, ep) : 0;
- spacefree = ulfs_rw16(ep->d_reclen, needswap) - dsize;
- for (loc = ulfs_rw16(ep->d_reclen, needswap); loc < ulr->ulr_count; ) {
+ dsize = (lfs_dir_getino(fs, ep) != 0) ? LFS_DIRSIZ(fs, ep) : 0;
+ spacefree = lfs_dir_getreclen(fs, ep) - dsize;
+ for (loc = lfs_dir_getreclen(fs, ep); loc < ulr->ulr_count; ) {
uint16_t reclen;
nep = (struct lfs_direct *)(dirbuf + loc);
/* Trim the existing slot (NB: dsize may be zero). */
- ep->d_reclen = ulfs_rw16(dsize, needswap);
- ep = (struct lfs_direct *)((char *)ep + dsize);
+ lfs_dir_setreclen(fs, ep, dsize);
+ ep = LFS_NEXTDIR(fs, ep);
- reclen = ulfs_rw16(nep->d_reclen, needswap);
+ reclen = lfs_dir_getreclen(fs, nep);
loc += reclen;
- if (nep->d_ino == 0) {
+ if (lfs_dir_getino(fs, nep) == 0) {
/*
* A mid-block unused entry. Such entries are
* never created by the kernel, but fsck_ffs
@@ -895,7 +885,7 @@ ulfs_direnter(struct vnode *dvp, const s
* relocated entry since we don't memcpy it.
*/
spacefree += reclen;
- ep->d_ino = 0;
+ lfs_dir_setino(fs, ep, 0);
dsize = 0;
continue;
}
@@ -918,25 +908,23 @@ ulfs_direnter(struct vnode *dvp, const s
* Update the pointer fields in the previous entry (if any),
* copy in the new entry, and write out the block.
*/
- if (ep->d_ino == 0 ||
- (ulfs_rw32(ep->d_ino, needswap) == ULFS_WINO &&
+ if (lfs_dir_getino(fs, ep) == 0 ||
+ (lfs_dir_getino(fs, ep) == ULFS_WINO &&
memcmp(ep->d_name, dirp->d_name, lfs_dir_getnamlen(fs, dirp)) == 0)) {
if (spacefree + dsize < newentrysize)
panic("ulfs_direnter: compact1");
- dirp->d_reclen = spacefree + dsize;
+ lfs_dir_setreclen(fs, dirp, spacefree + dsize);
} else {
if (spacefree < newentrysize)
panic("ulfs_direnter: compact2");
- dirp->d_reclen = spacefree;
- ep->d_reclen = ulfs_rw16(dsize, needswap);
- ep = (struct lfs_direct *)((char *)ep + dsize);
- }
- dirp->d_reclen = ulfs_rw16(dirp->d_reclen, needswap);
- dirp->d_ino = ulfs_rw32(dirp->d_ino, needswap);
- /* d_type/d_namlen are handled in ulfs_makedirentry */
+ lfs_dir_setreclen(fs, dirp, spacefree);
+ lfs_dir_setreclen(fs, ep, dsize);
+ ep = LFS_NEXTDIR(fs, ep);
+ }
+
#ifdef LFS_DIRHASH
- if (dp->i_dirhash != NULL && (ep->d_ino == 0 ||
- dirp->d_reclen == spacefree))
+ if (dp->i_dirhash != NULL && (lfs_dir_getino(fs, ep) == 0 ||
+ lfs_dir_getreclen(fs, dirp) == spacefree))
ulfsdirhash_add(dp, dirp, ulr->ulr_offset + ((char *)ep - dirbuf));
#endif
memcpy((void *)ep, (void *)dirp, (u_int)newentrysize);
@@ -1009,7 +997,6 @@ ulfs_dirremove(struct vnode *dvp, const
struct lfs_direct *ep;
struct buf *bp;
int error;
- const int needswap = ULFS_MPNEEDSWAP(dp->i_lfs);
if (flags & DOWHITEOUT) {
/*
@@ -1019,7 +1006,7 @@ ulfs_dirremove(struct vnode *dvp, const
&bp, true);
if (error)
return (error);
- ep->d_ino = ulfs_rw32(ULFS_WINO, needswap);
+ lfs_dir_setino(fs, ep, ULFS_WINO);
lfs_dir_settype(fs, ep, LFS_DT_WHT);
goto out;
}
@@ -1035,22 +1022,20 @@ ulfs_dirremove(struct vnode *dvp, const
*/
if (dp->i_dirhash != NULL)
ulfsdirhash_remove(dp, (ulr->ulr_count == 0) ? ep :
- (struct lfs_direct *)((char *)ep +
- ulfs_rw16(ep->d_reclen, needswap)), ulr->ulr_offset);
+ LFS_NEXTDIR(fs, ep), ulr->ulr_offset);
#endif
if (ulr->ulr_count == 0) {
/*
* First entry in block: set d_ino to zero.
*/
- ep->d_ino = 0;
+ lfs_dir_setino(fs, ep, 0);
} else {
/*
* Collapse new free space into previous entry.
*/
- ep->d_reclen =
- ulfs_rw16(ulfs_rw16(ep->d_reclen, needswap) + ulr->ulr_reclen,
- needswap);
+ lfs_dir_setreclen(fs, ep,
+ lfs_dir_getreclen(fs, ep) + ulr->ulr_reclen);
}
#ifdef LFS_DIRHASH
@@ -1118,7 +1103,7 @@ ulfs_dirrewrite(struct inode *dp, off_t
error = ulfs_blkatoff(vdp, offset, (void *)&ep, &bp, true);
if (error)
return (error);
- ep->d_ino = ulfs_rw32(newinum, ULFS_IPNEEDSWAP(dp));
+ lfs_dir_setino(fs, ep, newinum);
lfs_dir_settype(fs, ep, newtype);
oip->i_nlink--;
DIP_ASSIGN(oip, nlink, oip->i_nlink);
@@ -1153,11 +1138,9 @@ ulfs_dirempty(struct inode *ip, ino_t pa
struct lfs_direct *dp = (struct lfs_direct *)&dbuf;
int error, namlen;
size_t count;
- const int needswap = ULFS_IPNEEDSWAP(ip);
#define MINDIRSIZ (sizeof (struct lfs_dirtemplate) / 2)
- for (off = 0; off < ip->i_size;
- off += ulfs_rw16(dp->d_reclen, needswap)) {
+ for (off = 0; off < ip->i_size; off += lfs_dir_getreclen(fs, dp)) {
error = ulfs_bufio(UIO_READ, ITOV(ip), (void *)dp, MINDIRSIZ,
off, IO_NODELOCKED, cred, &count, NULL);
/*
@@ -1167,10 +1150,11 @@ ulfs_dirempty(struct inode *ip, ino_t pa
if (error || count != 0)
return (0);
/* avoid infinite loops */
- if (dp->d_reclen == 0)
+ if (lfs_dir_getreclen(fs, dp) == 0)
return (0);
/* skip empty entries */
- if (dp->d_ino == 0 || ulfs_rw32(dp->d_ino, needswap) == ULFS_WINO)
+ if (lfs_dir_getino(fs, dp) == 0 ||
+ lfs_dir_getino(fs, dp) == ULFS_WINO)
continue;
/* accept only "." and ".." */
namlen = lfs_dir_getnamlen(fs, dp);
@@ -1183,11 +1167,9 @@ ulfs_dirempty(struct inode *ip, ino_t pa
* 1 implies ".", 2 implies ".." if second
* char is also "."
*/
- if (namlen == 1 &&
- ulfs_rw32(dp->d_ino, needswap) == ip->i_number)
+ if (namlen == 1 && lfs_dir_getino(fs, dp) == ip->i_number)
continue;
- if (dp->d_name[1] == '.' &&
- ulfs_rw32(dp->d_ino, needswap) == parentino)
+ if (dp->d_name[1] == '.' && lfs_dir_getino(fs, dp) == parentino)
continue;
return (0);
}
Index: src/sys/ufs/lfs/ulfs_vnops.c
diff -u src/sys/ufs/lfs/ulfs_vnops.c:1.28 src/sys/ufs/lfs/ulfs_vnops.c:1.29
--- src/sys/ufs/lfs/ulfs_vnops.c:1.28 Tue Sep 1 06:16:59 2015
+++ src/sys/ufs/lfs/ulfs_vnops.c Tue Sep 15 14:58:06 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_vnops.c,v 1.28 2015/09/01 06:16:59 dholland Exp $ */
+/* $NetBSD: ulfs_vnops.c,v 1.29 2015/09/15 14:58:06 dholland Exp $ */
/* from NetBSD: ufs_vnops.c,v 1.213 2013/06/08 05:47:02 kardel Exp */
/*-
@@ -67,7 +67,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_vnops.c,v 1.28 2015/09/01 06:16:59 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_vnops.c,v 1.29 2015/09/15 14:58:06 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_lfs.h"
@@ -794,12 +794,11 @@ ulfs_readdir(void *v)
size_t skipbytes;
struct ulfsmount *ump = VFSTOULFS(vp->v_mount);
struct lfs *fs = ump->um_lfs;
- int nswap = ULFS_MPNEEDSWAP(fs);
uio = ap->a_uio;
count = uio->uio_resid;
rcount = count - ((uio->uio_offset + count) & (fs->um_dirblksiz - 1));
- if (rcount < _DIRENT_MINSIZE(cdp) || count < _DIRENT_MINSIZE(ndp))
+ if (rcount < LFS_DIRECTSIZ(0) || count < _DIRENT_MINSIZE(ndp))
return EINVAL;
startoff = uio->uio_offset & ~(fs->um_dirblksiz - 1);
@@ -834,7 +833,7 @@ ulfs_readdir(void *v)
off = uio->uio_offset;
if (ap->a_cookies) {
- ccount = rcount / _DIRENT_RECLEN(cdp, 1);
+ ccount = rcount / _DIRENT_RECLEN(ndp, 1);
ccp = *(ap->a_cookies) = malloc(ccount * sizeof(*ccp),
M_TEMP, M_WAITOK);
} else {
@@ -844,11 +843,10 @@ ulfs_readdir(void *v)
}
while (cdp < ecdp) {
- cdp->d_reclen = ulfs_rw16(cdp->d_reclen, nswap);
if (skipbytes > 0) {
- if (cdp->d_reclen <= skipbytes) {
- skipbytes -= cdp->d_reclen;
- cdp = _DIRENT_NEXT(cdp);
+ if (lfs_dir_getreclen(fs, cdp) <= skipbytes) {
+ skipbytes -= lfs_dir_getreclen(fs, cdp);
+ cdp = LFS_NEXTDIR(fs, cdp);
continue;
}
/*
@@ -857,7 +855,7 @@ ulfs_readdir(void *v)
error = EINVAL;
goto out;
}
- if (cdp->d_reclen == 0) {
+ if (lfs_dir_getreclen(fs, cdp) == 0) {
struct dirent *ondp = ndp;
ndp->d_reclen = _DIRENT_MINSIZE(ndp);
ndp = _DIRENT_NEXT(ndp);
@@ -871,17 +869,17 @@ ulfs_readdir(void *v)
if ((char *)(void *)ndp + ndp->d_reclen +
_DIRENT_MINSIZE(ndp) > endp)
break;
- ndp->d_fileno = ulfs_rw32(cdp->d_ino, nswap);
+ ndp->d_fileno = lfs_dir_getino(fs, cdp);
(void)memcpy(ndp->d_name, cdp->d_name, ndp->d_namlen);
memset(&ndp->d_name[ndp->d_namlen], 0,
ndp->d_reclen - _DIRENT_NAMEOFF(ndp) - ndp->d_namlen);
- off += cdp->d_reclen;
+ off += lfs_dir_getreclen(fs, cdp);
if (ap->a_cookies) {
KASSERT(ccp - *(ap->a_cookies) < ccount);
*(ccp++) = off;
}
ndp = _DIRENT_NEXT(ndp);
- cdp = _DIRENT_NEXT(cdp);
+ cdp = LFS_NEXTDIR(fs, cdp);
}
count = ((char *)(void *)ndp - ndbuf);
