void
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
{
char pathbuf[MAXPATHLEN + 1];
struct uvnode *vp;
pwarn("%s ", errmesg);
pinode(ino);
printf("\n");
pwarn("PARENT=%lld\n", (long long)cwd);
getpathname(pathbuf, sizeof(pathbuf), cwd, ino);
if (ino < ULFS_ROOTINO || ino >= maxino) {
pfatal("NAME=%s\n", pathbuf);
return;
}
vp = vget(fs, ino);
if (vp == NULL)
pfatal("INO is NULL\n");
else {
if (ftypeok(VTOD(vp)))
pfatal("%s=%s\n",
(lfs_dino_getmode(fs, VTOI(vp)->i_din) & LFS_IFMT) == LFS_IFDIR ?
"DIR" : "FILE", pathbuf);
else
pfatal("NAME=%s\n", pathbuf);
}
}
void
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
{
struct ext2fs_dinode *dp;
char pathbuf[MAXPATHLEN + 1];
pwarn("%s ", errmesg);
pinode(ino);
printf("\n");
getpathname(pathbuf, sizeof(pathbuf), cwd, ino);
if ((ino < EXT2_FIRSTINO && ino != EXT2_ROOTINO) || ino > maxino) {
pfatal("NAME=%s\n", pathbuf);
return;
}
dp = ginode(ino);
if (ftypeok(dp))
pfatal("%s=%s\n",
(fs2h16(dp->e2di_mode) & IFMT) == IFDIR ? "DIR" : "FILE", pathbuf);
else
pfatal("NAME=%s\n", pathbuf);
}
void
fileerror(ufs1_ino_t cwd, ufs1_ino_t ino, char *errmesg)
{
struct ufs1_dinode *dp;
char pathbuf[MAXPATHLEN + 1];
pwarn("%s ", errmesg);
pinode(ino);
printf("\n");
getpathname(pathbuf, cwd, ino);
if (ino < ROOTINO || ino > maxino) {
pfatal("NAME=%s\n", pathbuf);
return;
}
dp = ginode(ino);
if (ftypeok(dp))
pfatal("%s=%s\n",
(dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE", pathbuf);
else
pfatal("NAME=%s\n", pathbuf);
}
void
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
{
union dinode *dp;
char pathbuf[MAXPATHLEN + 1];
pwarn("%s ", errmesg);
pinode(ino);
printf("\n");
getpathname(pathbuf, cwd, ino);
if (ino < UFS_ROOTINO || ino > maxino) {
pfatal("NAME=%s\n", pathbuf);
return;
}
dp = ginode(ino);
if (ftypeok(dp))
pfatal("%s=%s\n",
(DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE",
pathbuf);
else
pfatal("NAME=%s\n", pathbuf);
}
/*
* Scan each entry in a directory block.
*/
int
dirscan(struct inodesc *idesc)
{
struct direct *dp;
struct bufarea *bp;
int dsize, n;
long blksiz;
#if DIRBLKSIZ > APPLEUFS_DIRBLKSIZ
char dbuf[DIRBLKSIZ];
#else
char dbuf[APPLEUFS_DIRBLKSIZ];
#endif
if (idesc->id_type != DATA)
errexit("wrong type to dirscan %d", idesc->id_type);
if (idesc->id_entryno == 0 &&
(idesc->id_filesize & (dirblksiz - 1)) != 0)
idesc->id_filesize = roundup(idesc->id_filesize, dirblksiz);
blksiz = idesc->id_numfrags * sblock->fs_fsize;
if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
idesc->id_filesize -= blksiz;
return (SKIP);
}
/*
* If we are are swapping byte order in directory entries, just swap
* this block and return.
*/
if (do_dirswap) {
int off;
bp = getdirblk(idesc->id_blkno, blksiz);
for (off = 0; off < blksiz; off += iswap16(dp->d_reclen)) {
dp = (struct direct *)(bp->b_un.b_buf + off);
dp->d_ino = bswap32(dp->d_ino);
dp->d_reclen = bswap16(dp->d_reclen);
if (!newinofmt) {
u_int8_t tmp = dp->d_namlen;
dp->d_namlen = dp->d_type;
dp->d_type = tmp;
}
if (dp->d_reclen == 0)
break;
}
dirty(bp);
idesc->id_filesize -= blksiz;
return (idesc->id_filesize > 0 ? KEEPON : STOP);
}
idesc->id_loc = 0;
for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
dsize = iswap16(dp->d_reclen);
if (dsize > sizeof dbuf)
dsize = sizeof dbuf;
memmove(dbuf, dp, (size_t)dsize);
# if (BYTE_ORDER == LITTLE_ENDIAN)
if (!newinofmt && !needswap) {
# else
if (!newinofmt && needswap) {
# endif
struct direct *tdp = (struct direct *)dbuf;
u_char tmp;
tmp = tdp->d_namlen;
tdp->d_namlen = tdp->d_type;
tdp->d_type = tmp;
}
idesc->id_dirp = (struct direct *)dbuf;
if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
# if (BYTE_ORDER == LITTLE_ENDIAN)
if (!newinofmt && !doinglevel2 && !needswap) {
# else
if (!newinofmt && !doinglevel2 && needswap) {
# endif
struct direct *tdp;
u_char tmp;
tdp = (struct direct *)dbuf;
tmp = tdp->d_namlen;
tdp->d_namlen = tdp->d_type;
tdp->d_type = tmp;
}
bp = getdirblk(idesc->id_blkno, blksiz);
memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf,
(size_t)dsize);
dirty(bp);
sbdirty();
}
if (n & STOP)
return (n);
}
return (idesc->id_filesize > 0 ? KEEPON : STOP);
}
/*
* get next entry in a directory.
*/
static struct direct *
fsck_readdir(struct inodesc *idesc)
{
struct direct *dp, *ndp;
struct bufarea *bp;
long size, blksiz, fix, dploc;
blksiz = idesc->id_numfrags * sblock->fs_fsize;
bp = getdirblk(idesc->id_blkno, blksiz);
if (idesc->id_loc % dirblksiz == 0 && idesc->id_filesize > 0 &&
idesc->id_loc < blksiz) {
dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
if (dircheck(idesc, dp))
goto dpok;
if (idesc->id_fix == IGNORE)
return (0);
fix = dofix(idesc, "DIRECTORY CORRUPTED");
bp = getdirblk(idesc->id_blkno, blksiz);
dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
dp->d_reclen = iswap16(dirblksiz);
dp->d_ino = 0;
dp->d_type = 0;
dp->d_namlen = 0;
dp->d_name[0] = '\0';
if (fix)
dirty(bp);
else
markclean = 0;
idesc->id_loc += dirblksiz;
idesc->id_filesize -= dirblksiz;
return (dp);
}
dpok:
if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
return NULL;
dploc = idesc->id_loc;
dp = (struct direct *)(bp->b_un.b_buf + dploc);
idesc->id_loc += iswap16(dp->d_reclen);
idesc->id_filesize -= iswap16(dp->d_reclen);
if ((idesc->id_loc % dirblksiz) == 0)
return (dp);
ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
dircheck(idesc, ndp) == 0) {
size = dirblksiz - (idesc->id_loc % dirblksiz);
idesc->id_loc += size;
idesc->id_filesize -= size;
if (idesc->id_fix == IGNORE)
return (0);
fix = dofix(idesc, "DIRECTORY CORRUPTED");
bp = getdirblk(idesc->id_blkno, blksiz);
dp = (struct direct *)(bp->b_un.b_buf + dploc);
dp->d_reclen = iswap16(iswap16(dp->d_reclen) + size);
if (fix)
dirty(bp);
else
markclean = 0;
}
return (dp);
}
/*
* Verify that a directory entry is valid.
* This is a superset of the checks made in the kernel.
*/
static int
dircheck(struct inodesc *idesc, struct direct *dp)
{
int size;
char *cp;
u_char namlen, type;
int spaceleft;
spaceleft = dirblksiz - (idesc->id_loc % dirblksiz);
if (iswap32(dp->d_ino) >= maxino ||
dp->d_reclen == 0 ||
iswap16(dp->d_reclen) > spaceleft ||
(iswap16(dp->d_reclen) & 0x3) != 0)
return (0);
if (dp->d_ino == 0)
return (1);
size = DIRSIZ(!newinofmt, dp, needswap);
# if (BYTE_ORDER == LITTLE_ENDIAN)
if (!newinofmt && !needswap) {
# else
if (!newinofmt && needswap) {
# endif
type = dp->d_namlen;
namlen = dp->d_type;
} else {
namlen = dp->d_namlen;
type = dp->d_type;
}
if (iswap16(dp->d_reclen) < size ||
idesc->id_filesize < size ||
/* namlen > MAXNAMLEN || */
type > 15)
return (0);
for (cp = dp->d_name, size = 0; size < namlen; size++)
if (*cp == '\0' || (*cp++ == '/'))
return (0);
if (*cp != '\0')
return (0);
return (1);
}
void
direrror(ino_t ino, const char *errmesg)
{
fileerror(ino, ino, errmesg);
}
void
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
{
union dinode *dp;
char pathbuf[MAXPATHLEN + 1];
uint16_t mode;
pwarn("%s ", errmesg);
pinode(ino);
printf("\n");
getpathname(pathbuf, sizeof(pathbuf), cwd, ino);
if (ino < ROOTINO || ino > maxino) {
pfatal("NAME=%s\n", pathbuf);
return;
}
dp = ginode(ino);
if (ftypeok(dp)) {
mode = DIP(dp, mode);
pfatal("%s=%s\n",
(iswap16(mode) & IFMT) == IFDIR ? "DIR" : "FILE", pathbuf);
}
else
pfatal("NAME=%s\n", pathbuf);
}
void
adjust(struct inodesc *idesc, int lcnt)
{
union dinode *dp;
int16_t nlink;
int saveresolved;
dp = ginode(idesc->id_number);
nlink = iswap16(DIP(dp, nlink));
if (nlink == lcnt) {
/*
* If we have not hit any unresolved problems, are running
* in preen mode, and are on a file system using soft updates,
* then just toss any partially allocated files.
*/
if (resolved && preen && usedsoftdep) {
clri(idesc, "UNREF", 1);
return;
} else {
/*
* The file system can be marked clean even if
* a file is not linked up, but is cleared.
* Hence, resolved should not be cleared when
* linkup is answered no, but clri is answered yes.
*/
saveresolved = resolved;
if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) {
resolved = saveresolved;
clri(idesc, "UNREF", 0);
return;
}
/*
* Account for the new reference created by linkup().
*/
dp = ginode(idesc->id_number);
lcnt--;
}
}
if (lcnt != 0) {
pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
((iswap16(DIP(dp, mode)) & IFMT) == IFDIR ?
"DIR" : "FILE"));
pinode(idesc->id_number);
printf(" COUNT %d SHOULD BE %d",
nlink, nlink - lcnt);
if (preen || usedsoftdep) {
if (lcnt < 0) {
printf("\n");
pfatal("LINK COUNT INCREASING");
}
if (preen)
printf(" (ADJUSTED)\n");
}
if (preen || reply("ADJUST") == 1) {
DIP_SET(dp, nlink, iswap16(nlink - lcnt));
inodirty();
} else
markclean = 0;
}
}
static int
mkentry(struct inodesc *idesc)
{
struct direct *dirp = idesc->id_dirp;
struct direct newent;
int newlen, oldlen;
newent.d_namlen = strlen(idesc->id_name);
newlen = DIRSIZ(0, &newent, 0);
if (dirp->d_ino != 0)
oldlen = DIRSIZ(0, dirp, 0);
else
oldlen = 0;
if (iswap16(dirp->d_reclen) - oldlen < newlen)
return (KEEPON);
newent.d_reclen = iswap16(iswap16(dirp->d_reclen) - oldlen);
dirp->d_reclen = iswap16(oldlen);
dirp = (struct direct *)(((char *)dirp) + oldlen);
/* ino to be entered is in id_parent */
dirp->d_ino = iswap32(idesc->id_parent);
dirp->d_reclen = newent.d_reclen;
if (newinofmt)
dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
else
dirp->d_type = 0;
dirp->d_namlen = newent.d_namlen;
memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1);
# if (BYTE_ORDER == LITTLE_ENDIAN)
/*
* If the entry was split, dirscan() will only reverse the byte
* order of the original entry, and not the new one, before
* writing it back out. So, we reverse the byte order here if
* necessary.
*/
if (oldlen != 0 && !newinofmt && !doinglevel2 && !needswap) {
# else
if (oldlen != 0 && !newinofmt && !doinglevel2 && needswap) {
# endif
u_char tmp;
tmp = dirp->d_namlen;
dirp->d_namlen = dirp->d_type;
dirp->d_type = tmp;
}
return (ALTERED|STOP);
}
static int
chgino(struct inodesc *idesc)
{
struct direct *dirp = idesc->id_dirp;
if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
return (KEEPON);
dirp->d_ino = iswap32(idesc->id_parent);
if (newinofmt)
dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
else
dirp->d_type = 0;
return (ALTERED|STOP);
}
int
linkup(ino_t orphan, ino_t parentdir, char *name)
{
union dinode *dp;
int lostdir;
ino_t oldlfdir;
struct inodesc idesc;
char tempname[BUFSIZ];
int16_t nlink;
uint16_t mode;
memset(&idesc, 0, sizeof(struct inodesc));
dp = ginode(orphan);
mode = iswap16(DIP(dp, mode));
nlink = iswap16(DIP(dp, nlink));
lostdir = (mode & IFMT) == IFDIR;
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
pinode(orphan);
if (preen && DIP(dp, size) == 0)
return (0);
if (preen)
printf(" (RECONNECTED)\n");
else
if (reply("RECONNECT") == 0) {
markclean = 0;
return (0);
}
if (parentdir != 0)
inoinfo(parentdir)->ino_linkcnt++;
if (lfdir == 0) {
dp = ginode(ROOTINO);
idesc.id_name = lfname;
idesc.id_type = DATA;
idesc.id_func = findino;
idesc.id_number = 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);
if (lfdir != 0) {
if (makeentry(ROOTINO, lfdir, lfname) != 0) {
numdirs++;
if (preen)
printf(" (CREATED)\n");
} else {
freedir(lfdir, ROOTINO);
lfdir = 0;
if (preen)
printf("\n");
}
}
if (lfdir != 0) {
reparent(lfdir, ROOTINO);
}
}
}
if (lfdir == 0) {
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
markclean = 0;
return (0);
}
}
dp = ginode(lfdir);
mode = DIP(dp, mode);
mode = iswap16(mode);
if ((mode & IFMT) != IFDIR) {
pfatal("lost+found IS NOT A DIRECTORY");
if (reply("REALLOCATE") == 0) {
markclean = 0;
return (0);
}
oldlfdir = lfdir;
lfdir = allocdir(ROOTINO, (ino_t)0, lfmode);
if (lfdir == 0) {
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
markclean = 0;
return (0);
}
if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) {
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
markclean = 0;
return (0);
}
inodirty();
reparent(lfdir, ROOTINO);
idesc.id_type = ADDR;
idesc.id_func = pass4check;
idesc.id_number = oldlfdir;
adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1);
inoinfo(oldlfdir)->ino_linkcnt = 0;
dp = ginode(lfdir);
}
if (inoinfo(lfdir)->ino_state != DFOUND) {
pfatal("SORRY. NO lost+found DIRECTORY\n\n");
markclean = 0;
return (0);
}
(void)lftempname(tempname, orphan);
if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) {
pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
printf("\n\n");
markclean = 0;
return (0);
}
inoinfo(orphan)->ino_linkcnt--;
if (lostdir) {
if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 &&
parentdir != (ino_t)-1)
(void)makeentry(orphan, lfdir, "..");
dp = ginode(lfdir);
nlink = DIP(dp, nlink);
DIP_SET(dp, nlink, iswap16(iswap16(nlink) + 1));
inodirty();
inoinfo(lfdir)->ino_linkcnt++;
reparent(orphan, lfdir);
pwarn("DIR I=%llu CONNECTED. ", (unsigned long long)orphan);
if (parentdir != (ino_t)-1)
printf("PARENT WAS I=%llu\n",
(unsigned long long)parentdir);
if (preen == 0)
printf("\n");
}
return (1);
}
/*
* fix an entry in a directory.
*/
int
changeino(ino_t dir, const char *name, ino_t newnum)
{
struct inodesc idesc;
memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
idesc.id_func = chgino;
idesc.id_number = dir;
idesc.id_fix = DONTKNOW;
idesc.id_name = name;
idesc.id_parent = newnum; /* new value for name */
return (ckinode(ginode(dir), &idesc));
}
/*
* make an entry in a directory
*/
int
makeentry(ino_t parent, ino_t ino, const char *name)
{
union dinode *dp;
struct inodesc idesc;
char pathbuf[MAXPATHLEN + 1];
if (parent < ROOTINO || parent >= maxino ||
ino < ROOTINO || ino >= maxino)
return (0);
memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
idesc.id_func = mkentry;
idesc.id_number = parent;
idesc.id_parent = ino; /* this is the inode to enter */
idesc.id_fix = DONTKNOW;
idesc.id_name = name;
dp = ginode(parent);
if (iswap64(DIP(dp, size)) % dirblksiz) {
DIP_SET(dp, size,
iswap64(roundup(iswap64(DIP(dp, size)), dirblksiz)));
inodirty();
}
if ((ckinode(dp, &idesc) & ALTERED) != 0)
return (1);
getpathname(pathbuf, sizeof(pathbuf), parent, parent);
dp = ginode(parent);
if (expanddir(dp, pathbuf) == 0)
return (0);
return (ckinode(dp, &idesc) & ALTERED);
}
/*
* Attempt to expand the size of a directory
*/
static int
expanddir(union dinode *dp, char *name)
{
daddr_t lastbn, newblk, dirblk;
struct bufarea *bp;
char *cp;
#if DIRBLKSIZ > APPLEUFS_DIRBLKSIZ
char firstblk[DIRBLKSIZ];
#else
char firstblk[APPLEUFS_DIRBLKSIZ];
#endif
struct ufs1_dinode *dp1 = NULL;
struct ufs2_dinode *dp2 = NULL;
if (is_ufs2)
dp2 = &dp->dp2;
else
dp1 = &dp->dp1;
lastbn = lblkno(sblock, iswap64(DIP(dp, size)));
if (lastbn >= NDADDR - 1 || DIP(dp, db[lastbn]) == 0 ||
DIP(dp, size) == 0)
return (0);
if ((newblk = allocblk(sblock->fs_frag)) == 0)
return (0);
if (is_ufs2) {
dp2->di_db[lastbn + 1] = dp2->di_db[lastbn];
dp2->di_db[lastbn] = iswap64(newblk);
dp2->di_size = iswap64(iswap64(dp2->di_size)+sblock->fs_bsize);
dp2->di_blocks = iswap64(iswap64(dp2->di_blocks) +
btodb(sblock->fs_bsize));
dirblk = iswap64(dp2->di_db[lastbn + 1]);
} else {
dp1->di_db[lastbn + 1] = dp1->di_db[lastbn];
dp1->di_db[lastbn] = iswap32((int32_t)newblk);
dp1->di_size = iswap64(iswap64(dp1->di_size)+sblock->fs_bsize);
dp1->di_blocks = iswap32(iswap32(dp1->di_blocks) +
btodb(sblock->fs_bsize));
dirblk = iswap32(dp1->di_db[lastbn + 1]);
}
bp = getdirblk(dirblk, sblksize(sblock, DIP(dp, size), lastbn + 1));
if (bp->b_errs)
goto bad;
memmove(firstblk, bp->b_un.b_buf, dirblksiz);
bp = getdirblk(newblk, sblock->fs_bsize);
if (bp->b_errs)
goto bad;
memmove(bp->b_un.b_buf, firstblk, dirblksiz);
emptydir.dot_reclen = iswap16(dirblksiz);
for (cp = &bp->b_un.b_buf[dirblksiz];
cp < &bp->b_un.b_buf[sblock->fs_bsize];
cp += dirblksiz)
memmove(cp, &emptydir, sizeof emptydir);
dirty(bp);
bp = getdirblk(dirblk, sblksize(sblock, DIP(dp, size), lastbn + 1));
if (bp->b_errs)
goto bad;
memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir);
pwarn("NO SPACE LEFT IN %s", name);
if (preen)
printf(" (EXPANDED)\n");
else if (reply("EXPAND") == 0)
goto bad;
dirty(bp);
inodirty();
return (1);
bad:
if (is_ufs2) {
dp2->di_db[lastbn] = dp2->di_db[lastbn + 1];
dp2->di_db[lastbn + 1] = 0;
dp2->di_size = iswap64(iswap64(dp2->di_size)-sblock->fs_bsize);
dp2->di_blocks = iswap64(iswap64(dp2->di_blocks) -
btodb(sblock->fs_bsize));
} else {
dp1->di_db[lastbn] = dp1->di_db[lastbn + 1];
dp1->di_db[lastbn + 1] = 0;
dp1->di_size = iswap64(iswap64(dp1->di_size)-sblock->fs_bsize);
dp1->di_blocks = iswap32(iswap32(dp1->di_blocks) -
btodb(sblock->fs_bsize));
}
freeblk(newblk, sblock->fs_frag);
markclean = 0;
return (0);
}
/*
* allocate a new directory
*/
ino_t
allocdir(ino_t parent, ino_t request, int mode)
{
ino_t ino;
char *cp;
union dinode *dp;
struct bufarea *bp;
struct inoinfo *inp;
struct dirtemplate *dirp;
daddr_t dirblk;
ino = allocino(request, IFDIR|mode);
if (ino < ROOTINO)
return 0;
dirhead.dot_reclen = iswap16(12);
dirhead.dotdot_reclen = iswap16(dirblksiz - 12);
odirhead.dot_reclen = iswap16(12);
odirhead.dotdot_reclen = iswap16(dirblksiz - 12);
odirhead.dot_namlen = iswap16(1);
odirhead.dotdot_namlen = iswap16(2);
if (newinofmt)
dirp = &dirhead;
else
dirp = (struct dirtemplate *)&odirhead;
dirp->dot_ino = iswap32(ino);
dirp->dotdot_ino = iswap32(parent);
dp = ginode(ino);
dirblk = is_ufs2 ? iswap64(dp->dp2.di_db[0])
: iswap32(dp->dp1.di_db[0]);
bp = getdirblk(dirblk, sblock->fs_fsize);
if (bp->b_errs) {
freeino(ino);
return (0);
}
memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate));
emptydir.dot_reclen = iswap16(dirblksiz);
for (cp = &bp->b_un.b_buf[dirblksiz];
cp < &bp->b_un.b_buf[sblock->fs_fsize];
cp += dirblksiz)
memmove(cp, &emptydir, sizeof emptydir);
dirty(bp);
DIP_SET(dp, nlink, iswap16(2));
inodirty();
if (ino == ROOTINO) {
inoinfo(ino)->ino_linkcnt = iswap16(DIP(dp, nlink));
cacheino(dp, ino);
return(ino);
}
if (inoinfo(parent)->ino_state != DSTATE &&
inoinfo(parent)->ino_state != DFOUND) {
freeino(ino);
return (0);
}
cacheino(dp, ino);
inp = getinoinfo(ino);
inp->i_parent = parent;
inp->i_dotdot = parent;
inoinfo(ino)->ino_state = inoinfo(parent)->ino_state;
if (inoinfo(ino)->ino_state == DSTATE) {
inoinfo(ino)->ino_linkcnt = iswap16(DIP(dp, nlink));
inoinfo(parent)->ino_linkcnt++;
}
dp = ginode(parent);
DIP_SET(dp, nlink, iswap16(iswap16(DIP(dp, nlink)) + 1));
inodirty();
return (ino);
}
union dinode *
getnextinode(ino_t inumber, int rebuildcg)
{
int j;
long size;
mode_t mode;
ufs2_daddr_t ndb, blk;
union dinode *dp;
static caddr_t nextinop;
if (inumber != nextino++ || inumber > lastvalidinum)
errx(EEXIT, "bad inode number %ju to nextinode",
(uintmax_t)inumber);
if (inumber >= lastinum) {
readcount++;
blk = ino_to_fsba(&sblock, lastinum);
if (readcount % readpercg == 0) {
size = partialsize;
lastinum += partialcnt;
} else {
size = inobufsize;
lastinum += fullcnt;
}
/*
* If getblk encounters an error, it will already have zeroed
* out the buffer, so we do not need to do so here.
*/
getblk(&inobuf, blk, size);
nextinop = inobuf.b_un.b_buf;
}
dp = (union dinode *)nextinop;
if (rebuildcg && nextinop == inobuf.b_un.b_buf) {
/*
* Try to determine if we have reached the end of the
* allocated inodes.
*/
mode = DIP(dp, di_mode) & IFMT;
if (mode == 0) {
if (memcmp(dp->dp2.di_db, ufs2_zino.di_db,
NDADDR * sizeof(ufs2_daddr_t)) ||
memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
NIADDR * sizeof(ufs2_daddr_t)) ||
dp->dp2.di_mode || dp->dp2.di_size)
return (NULL);
goto inodegood;
}
if (!ftypeok(dp))
return (NULL);
ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);
if (ndb < 0)
return (NULL);
if (mode == IFBLK || mode == IFCHR)
ndb++;
if (mode == IFLNK) {
/*
* Fake ndb value so direct/indirect block checks below
* will detect any garbage after symlink string.
*/
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;
for (ndb = 1; j > 1; j--)
ndb *= NINDIR(&sblock);
ndb += NDADDR;
}
}
}
for (j = ndb; ndb < NDADDR && j < NDADDR; j++)
if (DIP(dp, di_db[j]) != 0)
return (NULL);
for (j = 0, ndb -= NDADDR; ndb > 0; j++)
ndb /= NINDIR(&sblock);
for (; j < NIADDR; j++)
if (DIP(dp, di_ib[j]) != 0)
return (NULL);
}
inodegood:
if (sblock.fs_magic == FS_UFS1_MAGIC)
nextinop += sizeof(struct ufs1_dinode);
else
nextinop += sizeof(struct ufs2_dinode);
return (dp);
}
pass1()
{
register int c, i, j;
register DINODE *dp;
struct zlncnt *zlnp;
int ndb, partial, cgd;
struct inodesc idesc;
ino_t inumber;
/*
* Set file system reserved blocks in used block map.
*/
for (c = 0; c < sblock.fs_ncg; c++) {
cgd = cgdmin(&sblock, c);
if (c == 0) {
i = cgbase(&sblock, c);
cgd += howmany(sblock.fs_cssize, sblock.fs_fsize);
} else
i = cgsblock(&sblock, c);
for (; i < cgd; i++)
setbmap(i);
}
/*
* Find all allocated blocks.
*/
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1check;
inumber = 0;
n_files = n_blks = 0;
for (c = 0; c < sblock.fs_ncg; c++) {
for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
if (inumber < ROOTINO)
continue;
dp = ginode(inumber);
if (!ALLOC(dp)) {
if (bcmp((char *)dp->di_db, (char *)zino.di_db,
NDADDR * sizeof(daddr_t)) ||
bcmp((char *)dp->di_ib, (char *)zino.di_ib,
NIADDR * sizeof(daddr_t)) ||
dp->di_mode || dp->di_size) {
pfatal("PARTIALLY ALLOCATED INODE I=%u",
inumber);
if (reply("CLEAR") == 1) {
zapino(dp);
inodirty();
}
}
statemap[inumber] = USTATE;
continue;
}
lastino = inumber;
if (dp->di_size < 0 ||
dp->di_size + sblock.fs_bsize - 1 < 0) {
if (debug)
printf("bad size %d:", dp->di_size);
goto unknown;
}
if (!preen && (dp->di_mode & IFMT) == IFMT &&
reply("HOLD BAD BLOCK") == 1) {
dp->di_size = sblock.fs_fsize;
dp->di_mode = IFREG|0600;
inodirty();
}
ndb = howmany(dp->di_size, sblock.fs_bsize);
if (SPECIAL(dp))
ndb++;
for (j = ndb; j < NDADDR; j++)
if (dp->di_db[j] != 0) {
if (debug)
printf("bad direct addr: %d\n",
dp->di_db[j]);
goto unknown;
}
for (j = 0, ndb -= NDADDR; ndb > 0; j++)
ndb /= NINDIR(&sblock);
for (; j < NIADDR; j++)
if (dp->di_ib[j] != 0) {
if (debug)
printf("bad indirect addr: %d\n",
dp->di_ib[j]);
goto unknown;
}
if (ftypeok(dp) == 0)
goto unknown;
n_files++;
lncntp[inumber] = dp->di_nlink;
if (dp->di_nlink <= 0) {
zlnp = (struct zlncnt *)malloc(sizeof *zlnp);
if (zlnp == NULL) {
pfatal("LINK COUNT TABLE OVERFLOW");
if (reply("CONTINUE") == 0)
errexit("");
} else {
zlnp->zlncnt = inumber;
zlnp->next = zlnhead;
zlnhead = zlnp;
}
}
statemap[inumber] = DIRCT(dp) ? DSTATE : FSTATE;
badblk = dupblk = 0; maxblk = 0;
idesc.id_number = inumber;
(void)ckinode(dp, &idesc);
idesc.id_entryno *= btodb(sblock.fs_fsize);
if (dp->di_blocks != idesc.id_entryno) {
pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %ld)",
inumber, dp->di_blocks, idesc.id_entryno);
if (preen)
printf(" (CORRECTED)\n");
else if (reply("CORRECT") == 0)
continue;
dp->di_blocks = idesc.id_entryno;
inodirty();
}
continue;
unknown:
pfatal("UNKNOWN FILE TYPE I=%u", inumber);
statemap[inumber] = FCLEAR;
if (reply("CLEAR") == 1) {
statemap[inumber] = USTATE;
zapino(dp);
inodirty();
}
}
}
}
/*
* Perform checks on an inode and setup/track the state of the inode
* in maps (statemap[], lncntp[]) for future reference and validation.
* Initiate the calls to ckinode and in turn pass1check() to handle
* further validation.
*/
static void
verify_inode(fsck_ino_t inumber, struct inodesc *idesc, fsck_ino_t maxinumber)
{
int j, clear, flags;
int isdir;
char *err;
fsck_ino_t shadow, attrinode;
daddr32_t ndb;
struct dinode *dp;
struct inoinfo *iip;
dp = getnextinode(inumber);
if ((dp->di_mode & IFMT) == 0) {
/* mode and type of file is not set */
if ((memcmp((void *)dp->di_db, (void *)zino.di_db,
NDADDR * sizeof (daddr32_t)) != 0) ||
(memcmp((void *)dp->di_ib, (void *)zino.di_ib,
NIADDR * sizeof (daddr32_t)) != 0) ||
(dp->di_mode != 0) || (dp->di_size != 0)) {
pfatal("PARTIALLY ALLOCATED INODE I=%u", inumber);
if (reply("CLEAR") == 1) {
dp = ginode(inumber);
clearinode(dp);
inodirty();
} else {
iscorrupt = 1;
}
}
statemap[inumber] = USTATE;
return;
}
isdir = ((dp->di_mode & IFMT) == IFDIR) ||
((dp->di_mode & IFMT) == IFATTRDIR);
lastino = inumber;
if (dp->di_size > (u_offset_t)UFS_MAXOFFSET_T) {
pfatal("NEGATIVE SIZE %lld I=%d",
(longlong_t)dp->di_size, inumber);
goto bogus;
}
/*
* A more precise test of the type is done later on. Just get
* rid of the blatantly-wrong ones before we do any
* significant work.
*/
if ((dp->di_mode & IFMT) == IFMT) {
pfatal("BAD MODE 0%o I=%d",
dp->di_mode & IFMT, inumber);
if (reply("BAD MODE: MAKE IT A FILE") == 1) {
statemap[inumber] = FSTATE;
dp = ginode(inumber);
dp->di_mode = IFREG | 0600;
inodirty();
truncino(inumber, sblock.fs_fsize, TI_NOPARENT);
dp = getnextrefresh();
} else {
iscorrupt = 1;
}
}
ndb = howmany(dp->di_size, (u_offset_t)sblock.fs_bsize);
if (ndb < 0) {
/* extra space to distinguish from previous pfatal() */
pfatal("NEGATIVE SIZE %lld I=%d",
(longlong_t)dp->di_size, inumber);
goto bogus;
}
if ((dp->di_mode & IFMT) == IFBLK ||
(dp->di_mode & IFMT) == IFCHR) {
if (dp->di_size != 0) {
pfatal("SPECIAL FILE WITH NON-ZERO LENGTH %lld I=%d",
(longlong_t)dp->di_size, inumber);
goto bogus;
}
for (j = 0; j < NDADDR; j++) {
/*
* It's a device, so all the block pointers
* should be zero except for di_ordev.
* di_ordev is overlayed on the block array,
* but where varies between big and little
* endian, so make sure that the only non-zero
* element is the correct one. There can be
* a device whose ordev is zero, so we can't
* check for the reverse.
*/
if (dp->di_db[j] != 0 &&
&dp->di_db[j] != &dp->di_ordev) {
if (debug) {
(void) printf(
"spec file di_db[%d] has %d\n",
j, dp->di_db[j]);
}
pfatal(
"SPECIAL FILE WITH NON-ZERO FRAGMENT LIST I=%d",
inumber);
goto bogus;
}
}
for (j = 0; j < NIADDR; j++) {
if (dp->di_ib[j] != 0) {
if (debug)
(void) printf(
"special has %d at ib[%d]\n",
dp->di_ib[j], j);
pfatal(
"SPECIAL FILE WITH NON-ZERO FRAGMENT LIST I=%d",
inumber);
goto bogus;
}
}
} else {
/*
* This assignment is mostly here to appease lint, but
* doesn't hurt.
*/
err = "Internal error: unexpected variant of having "
"blocks past end of file I=%d";
clear = 0;
/*
* If it's not a device, it has to follow the
* rules for files. In particular, no blocks after
* the last one that di_size says is in use.
*/
for (j = ndb; j < NDADDR; j++) {
if (dp->di_db[j] != 0) {
if (debug) {
(void) printf("bad file direct "
"addr[%d]: block 0x%x "
"format: 0%o\n",
j, dp->di_db[j],
dp->di_mode & IFMT);
}
err = "FILE WITH FRAGMENTS PAST END I=%d";
clear = 1;
break;
}
}
/*
* Find last indirect pointer that should be in use,
* and make sure any after it are clear.
*/
if (!clear) {
for (j = 0, ndb -= NDADDR; ndb > 0; j++) {
ndb /= NINDIR(&sblock);
}
for (; j < NIADDR; j++) {
if (dp->di_ib[j] != 0) {
if (debug) {
(void) printf("bad file "
"indirect addr: block %d\n",
dp->di_ib[j]);
}
err =
"FILE WITH FRAGMENTS PAST END I=%d";
clear = 2;
break;
}
}
}
if (clear) {
/*
* The discarded blocks will be garbage-
* collected in pass5. If we're told not to
* discard them, it's just lost blocks, which
* isn't worth setting iscorrupt for.
*/
pwarn(err, inumber);
if (preen || reply("DISCARD EXCESS FRAGMENTS") == 1) {
dp = ginode(inumber);
if (clear == 1) {
for (; j < NDADDR; j++)
dp->di_db[j] = 0;
j = 0;
}
for (; j < NIADDR; j++)
dp->di_ib[j] = 0;
inodirty();
dp = getnextrefresh();
if (preen)
(void) printf(" (TRUNCATED)");
}
}
}
if (ftypeok(dp) == 0) {
pfatal("UNKNOWN FILE TYPE 0%o I=%d", dp->di_mode, inumber);
goto bogus;
}
n_files++;
TRACK_LNCNTP(inumber, lncntp[inumber] = dp->di_nlink);
/*
* We can't do anything about it right now, so note that its
* processing is being delayed. Otherwise, we'd be changing
* the block allocations out from under ourselves, which causes
* no end of confusion.
*/
flags = statemap[inumber] & INDELAYD;
/*
* if errorlocked or logging, then open deleted files will
* manifest as di_nlink <= 0 and di_mode != 0
* so skip them; they're ok.
* Also skip anything already marked to be cleared.
*/
if (dp->di_nlink <= 0 &&
!((errorlocked || islog) && dp->di_mode == 0) &&
!(flags & INCLEAR)) {
flags |= INZLINK;
if (debug)
(void) printf(
"marking i=%d INZLINK; nlink %d, mode 0%o, islog %d\n",
inumber, dp->di_nlink, dp->di_mode, islog);
}
switch (dp->di_mode & IFMT) {
case IFDIR:
case IFATTRDIR:
if (dp->di_size == 0) {
/*
* INCLEAR means it will be ignored by passes 2 & 3.
*/
if ((dp->di_mode & IFMT) == IFDIR)
(void) printf("ZERO-LENGTH DIR I=%d\n",
inumber);
else
(void) printf("ZERO-LENGTH ATTRDIR I=%d\n",
inumber);
add_orphan_dir(inumber);
flags |= INCLEAR;
flags &= ~INZLINK; /* It will be cleared anyway */
}
statemap[inumber] = DSTATE | flags;
cacheino(dp, inumber);
countdirs++;
break;
case IFSHAD:
if (dp->di_size == 0) {
(void) printf("ZERO-LENGTH SHADOW I=%d\n", inumber);
flags |= INCLEAR;
flags &= ~INZLINK; /* It will be cleared anyway */
}
statemap[inumber] = SSTATE | flags;
cacheacl(dp, inumber);
break;
default:
statemap[inumber] = FSTATE | flags;
}
badblk = 0;
dupblk = 0;
idesc->id_number = inumber;
idesc->id_fix = DONTKNOW;
if (dp->di_size > (u_offset_t)MAXOFF_T) {
largefile_count++;
}
(void) ckinode(dp, idesc, CKI_TRAVERSE);
if (isdir && (idesc->id_firsthole >= 0))
check_dirholes(inumber, idesc);
if (dp->di_blocks != idesc->id_entryno) {
/*
* The kernel releases any blocks it finds in the lists,
* ignoring the block count itself. So, a bad count is
* not grounds for setting iscorrupt.
*/
pwarn("INCORRECT DISK BLOCK COUNT I=%u (%d should be %d)",
inumber, (uint32_t)dp->di_blocks, idesc->id_entryno);
if (!preen && (reply("CORRECT") == 0))
return;
dp = ginode(inumber);
dp->di_blocks = idesc->id_entryno;
iip = getinoinfo(inumber);
if (iip != NULL)
iip->i_isize = dp->di_size;
inodirty();
if (preen)
(void) printf(" (CORRECTED)\n");
}
if (isdir && (dp->di_blocks == 0)) {
/*
* INCLEAR will cause passes 2 and 3 to skip it.
*/
(void) printf("DIR WITH ZERO BLOCKS I=%d\n", inumber);
statemap[inumber] = DCLEAR;
add_orphan_dir(inumber);
}
/*
* Check that the ACL is on a valid file type
*/
shadow = dp->di_shadow;
if (shadow != 0) {
if (acltypeok(dp) == 0) {
clear_attr_acl(inumber, -1,
"NON-ZERO ACL REFERENCE, I=%d\n");
} else if ((shadow <= UFSROOTINO) ||
(shadow > maxinumber)) {
clear_attr_acl(inumber, -1,
"BAD ACL REFERENCE I=%d\n");
} else {
registershadowclient(shadow,
inumber, &shadowclientinfo);
}
}
attrinode = dp->di_oeftflag;
if (attrinode != 0) {
if ((attrinode <= UFSROOTINO) ||
(attrinode > maxinumber)) {
clear_attr_acl(attrinode, inumber,
"BAD ATTRIBUTE REFERENCE TO I=%d FROM I=%d\n");
} else {
dp = ginode(attrinode);
if ((dp->di_mode & IFMT) != IFATTRDIR) {
clear_attr_acl(attrinode, inumber,
"BAD ATTRIBUTE DIR REF TO I=%d FROM I=%d\n");
} else if (dp->di_size == 0) {
clear_attr_acl(attrinode, inumber,
"REFERENCE TO ZERO-LENGTH ATTRIBUTE DIR I=%d from I=%d\n");
} else {
registershadowclient(attrinode, inumber,
&attrclientinfo);
}
}
}
return;
/*
* If we got here, we've not had the chance to see if a
* directory has holes, but we know the directory's bad,
* so it's safe to always return false (no holes found).
*
* Also, a pfatal() is always done before jumping here, so
* we know we're not in preen mode.
*/
bogus:
if (isdir) {
/*
* INCLEAR makes passes 2 & 3 skip it.
*/
statemap[inumber] = DCLEAR;
add_orphan_dir(inumber);
cacheino(dp, inumber);
} else {
statemap[inumber] = FCLEAR;
}
if (reply("CLEAR") == 1) {
(void) tdelete((void *)inumber, &limbo_dirs, ino_t_cmp);
freeino(inumber, TI_PARENT);
inodirty();
} else {
iscorrupt = 1;
}
}
