void
pass2(void)
{
union dinode *dp;
struct inoinfo **inpp, *inp;
struct inoinfo **inpend;
struct inodesc curino;
union dinode dino;
int i;
char pathbuf[MAXPATHLEN + 1];
switch (inoinfo(ROOTINO)->ino_state) {
case USTATE:
pfatal("ROOT INODE UNALLOCATED");
if (reply("ALLOCATE") == 0) {
ckfini(0);
exit(EEXIT);
}
if (allocdir(ROOTINO, ROOTINO, 0755) != 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)
errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
break;
}
if (reply("CONTINUE") == 0) {
ckfini(0);
exit(EEXIT);
}
break;
case FSTATE:
case FCLEAR:
case FZLINK:
pfatal("ROOT INODE NOT DIRECTORY");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
break;
}
if (reply("FIX") == 0) {
ckfini(0);
exit(EEXIT);
}
dp = ginode(ROOTINO);
DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR);
inodirty();
break;
case DSTATE:
case DZLINK:
break;
default:
errx(EEXIT, "BAD STATE %d FOR ROOT INODE",
inoinfo(ROOTINO)->ino_state);
}
inoinfo(ROOTINO)->ino_state = DFOUND;
inoinfo(WINO)->ino_state = FSTATE;
inoinfo(WINO)->ino_type = DT_WHT;
/*
* Sort the directory list into disk block order.
*/
qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
/*
* Check the integrity of each directory.
*/
memset(&curino, 0, sizeof(struct inodesc));
curino.id_type = DATA;
curino.id_func = pass2check;
inpend = &inpsort[inplast];
for (inpp = inpsort; inpp < inpend; inpp++) {
if (got_siginfo) {
printf("%s: phase 2: dir %td of %d (%d%%)\n", cdevname,
inpp - inpsort, (int)inplast,
(int)((inpp - inpsort) * 100 / inplast));
got_siginfo = 0;
}
if (got_sigalarm) {
setproctitle("%s p2 %d%%", cdevname,
(int)((inpp - inpsort) * 100 / inplast));
got_sigalarm = 0;
}
inp = *inpp;
if (inp->i_isize == 0)
continue;
if (inp->i_isize < MINDIRSIZE) {
direrror(inp->i_number, "DIRECTORY TOO SHORT");
inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
if (reply("FIX") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, di_size, inp->i_isize);
inodirty();
}
} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
getpathname(pathbuf, inp->i_number, inp->i_number);
if (usedsoftdep)
pfatal("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf,
(intmax_t)inp->i_isize, DIRBLKSIZ);
else
pwarn("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf,
(intmax_t)inp->i_isize, DIRBLKSIZ);
if (preen)
printf(" (ADJUSTED)\n");
inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
if (preen || reply("ADJUST") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, di_size,
roundup(inp->i_isize, DIRBLKSIZ));
inodirty();
}
}
dp = &dino;
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 < (inp->i_numblks<NDADDR ? inp->i_numblks : 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]);
curino.id_number = inp->i_number;
curino.id_parent = inp->i_parent;
(void)ckinode(dp, &curino);
}
/*
* Now that the parents of all directories have been found,
* make another pass to verify the value of `..'
*/
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_parent == 0 || inp->i_isize == 0)
continue;
if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
INO_IS_DUNFOUND(inp->i_number))
inoinfo(inp->i_number)->ino_state = DFOUND;
if (inp->i_dotdot == inp->i_parent ||
inp->i_dotdot == (ino_t)-1)
continue;
if (inp->i_dotdot == 0) {
inp->i_dotdot = inp->i_parent;
fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
if (reply("FIX") == 0)
continue;
(void)makeentry(inp->i_number, inp->i_parent, "..");
inoinfo(inp->i_parent)->ino_linkcnt--;
continue;
}
/*
* Here we have:
* inp->i_number is directory with bad ".." in it.
* inp->i_dotdot is current value of "..".
* inp->i_parent is directory to which ".." should point.
*/
getpathname(pathbuf, inp->i_parent, inp->i_number);
printf("BAD INODE NUMBER FOR '..' in DIR I=%d (%s)\n",
inp->i_number, pathbuf);
getpathname(pathbuf, inp->i_dotdot, inp->i_dotdot);
printf("CURRENTLY POINTS TO I=%d (%s), ", inp->i_dotdot,
pathbuf);
getpathname(pathbuf, inp->i_parent, inp->i_parent);
printf("SHOULD POINT TO I=%d (%s)", inp->i_parent, pathbuf);
if (cursnapshot != 0) {
/*
* We need to:
* setcwd(inp->i_number);
* setdotdot(inp->i_dotdot, inp->i_parent);
*/
cmd.value = inp->i_number;
if (sysctlbyname("vfs.ffs.setcwd", 0, 0,
&cmd, sizeof cmd) == -1) {
/* kernel lacks support for these functions */
printf(" (IGNORED)\n");
continue;
}
cmd.value = inp->i_dotdot; /* verify same value */
cmd.size = inp->i_parent; /* new parent */
if (sysctlbyname("vfs.ffs.setdotdot", 0, 0,
&cmd, sizeof cmd) == -1) {
printf(" (FIX FAILED: %s)\n", strerror(errno));
continue;
}
printf(" (FIXED)\n");
inoinfo(inp->i_parent)->ino_linkcnt--;
inp->i_dotdot = inp->i_parent;
continue;
}
if (preen)
printf(" (FIXED)\n");
else if (reply("FIX") == 0)
continue;
inoinfo(inp->i_dotdot)->ino_linkcnt++;
inoinfo(inp->i_parent)->ino_linkcnt--;
inp->i_dotdot = inp->i_parent;
(void)changeino(inp->i_number, "..", inp->i_parent);
}
/*
* Mark all the directories that can be found from the root.
*/
propagate();
}
void
pass2(void)
{
union dinode *dp;
struct inoinfo **inpp, *inp, *pinp;
struct inoinfo **inpend;
struct inodesc curino;
union dinode dino;
char pathbuf[MAXPATHLEN + 1];
int i;
switch (GET_ISTATE(ROOTINO)) {
case USTATE:
pfatal("ROOT INODE UNALLOCATED");
if (reply("ALLOCATE") == 0) {
ckfini(0);
errexit("%s", "");
}
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE\n");
break;
case DCLEAR:
pfatal("DUPS/BAD IN ROOT INODE");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE\n");
break;
}
if (reply("CONTINUE") == 0) {
ckfini(0);
errexit("%s", "");
}
break;
case FSTATE:
case FCLEAR:
pfatal("ROOT INODE NOT DIRECTORY");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE\n");
break;
}
if (reply("FIX") == 0) {
ckfini(0);
errexit("%s", "");
}
dp = ginode(ROOTINO);
DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR);
inodirty();
break;
case DSTATE:
break;
default:
errexit("BAD STATE %d FOR ROOT INODE\n", GET_ISTATE(ROOTINO));
}
SET_ISTATE(ROOTINO, DFOUND);
/*
* Sort the directory list into disk block order.
*/
qsort(inpsort, (size_t)inplast, sizeof *inpsort, blksort);
/*
* Check the integrity of each directory.
*/
memset(&curino, 0, sizeof(struct inodesc));
curino.id_type = DATA;
curino.id_func = pass2check;
inpend = &inpsort[inplast];
info_pos = 0;
info_max = inpend - inpsort;
info_fn = pass2_info1;
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
info_pos ++;
if (inp->i_isize == 0)
continue;
if (inp->i_isize < MINDIRSIZE) {
direrror(inp->i_number, "DIRECTORY TOO SHORT");
inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
if (reply("FIX") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, di_size, inp->i_isize);
inodirty();
}
} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
getpathname(pathbuf, sizeof pathbuf,
inp->i_number, inp->i_number);
if (usedsoftdep)
pfatal("%s %s: LENGTH %ld NOT MULTIPLE of %d",
"DIRECTORY", pathbuf, (long)inp->i_isize,
DIRBLKSIZ);
else
pwarn("%s %s: LENGTH %ld NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf, (long)inp->i_isize,
DIRBLKSIZ);
if (preen)
printf(" (ADJUSTED)\n");
inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
if (preen || reply("ADJUST") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, di_size, inp->i_isize);
inodirty();
}
}
memset(&dino, 0, sizeof(union dinode));
dp = &dino;
DIP_SET(dp, di_mode, IFDIR);
DIP_SET(dp, di_size, inp->i_isize);
for (i = 0;
i < (inp->i_numblks<NDADDR ? inp->i_numblks : 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]);
curino.id_number = inp->i_number;
curino.id_parent = inp->i_parent;
(void)ckinode(dp, &curino);
}
/*
* Now that the parents of all directories have been found,
* make another pass to verify the value of `..'
*/
info_pos = 0;
info_fn = pass2_info2;
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
info_pos++;
if (inp->i_parent == 0 || inp->i_isize == 0)
continue;
if (inp->i_dotdot == inp->i_parent ||
inp->i_dotdot == (ino_t)-1)
continue;
if (inp->i_dotdot == 0) {
inp->i_dotdot = inp->i_parent;
fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
if (reply("FIX") == 0)
continue;
(void)makeentry(inp->i_number, inp->i_parent, "..");
lncntp[inp->i_parent]--;
continue;
}
fileerror(inp->i_parent, inp->i_number,
"BAD INODE NUMBER FOR '..'");
if (reply("FIX") == 0)
continue;
lncntp[inp->i_dotdot]++;
lncntp[inp->i_parent]--;
inp->i_dotdot = inp->i_parent;
(void)changeino(inp->i_number, "..", inp->i_parent);
}
info_fn = NULL;
/*
* Create a list of children for each directory.
*/
inpend = &inpsort[inplast];
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_parent == 0 ||
inp->i_number == ROOTINO)
continue;
pinp = getinoinfo(inp->i_parent);
inp->i_parentp = pinp;
inp->i_sibling = pinp->i_child;
pinp->i_child = inp;
}
/*
* Mark all the directories that can be found from the root.
*/
propagate(ROOTINO);
}
/*
* Read in a superblock finding an alternate if necessary.
* Return 1 if successful, 0 if unsuccessful, -1 if file system
* is already clean (ckclean and preen mode only).
*/
int
setup(char *dev)
{
long cg, asked, i, j;
long bmapsize;
struct stat statb;
struct fs proto;
size_t size;
havesb = 0;
fswritefd = -1;
cursnapshot = 0;
if (stat(dev, &statb) < 0) {
printf("Can't stat %s: %s\n", dev, strerror(errno));
if (bkgrdflag) {
unlink(snapname);
bkgrdflag = 0;
}
return (0);
}
if ((statb.st_mode & S_IFMT) != S_IFCHR &&
(statb.st_mode & S_IFMT) != S_IFBLK) {
if (bkgrdflag != 0 && (statb.st_flags & SF_SNAPSHOT) == 0) {
unlink(snapname);
printf("background fsck lacks a snapshot\n");
exit(EEXIT);
}
if ((statb.st_flags & SF_SNAPSHOT) != 0 && cvtlevel == 0) {
cursnapshot = statb.st_ino;
} else {
if (cvtlevel == 0 ||
(statb.st_flags & SF_SNAPSHOT) == 0) {
if (preen && bkgrdflag) {
unlink(snapname);
bkgrdflag = 0;
}
pfatal("%s is not a disk device", dev);
if (reply("CONTINUE") == 0) {
if (bkgrdflag) {
unlink(snapname);
bkgrdflag = 0;
}
return (0);
}
} else {
if (bkgrdflag) {
unlink(snapname);
bkgrdflag = 0;
}
pfatal("cannot convert a snapshot");
exit(EEXIT);
}
}
}
if ((fsreadfd = open(dev, O_RDONLY)) < 0 ||
ufs_disk_fillout(&disk, dev) < 0) {
if (bkgrdflag) {
unlink(snapname);
bkgrdflag = 0;
}
printf("Can't open %s: %s\n", dev, strerror(errno));
return (0);
}
if (bkgrdflag) {
unlink(snapname);
size = MIBSIZE;
if (sysctlnametomib("vfs.ffs.adjrefcnt", adjrefcnt, &size) < 0||
sysctlnametomib("vfs.ffs.adjblkcnt", adjblkcnt, &size) < 0||
sysctlnametomib("vfs.ffs.freefiles", freefiles, &size) < 0||
sysctlnametomib("vfs.ffs.freedirs", freedirs, &size) < 0 ||
sysctlnametomib("vfs.ffs.freeblks", freeblks, &size) < 0) {
pfatal("kernel lacks background fsck support\n");
exit(EEXIT);
}
/*
* When kernel is lack of runtime bgfsck superblock summary
* adjustment functionality, it does not mean we can not
* continue, as old kernels will recompute the summary at
* mount time. However, it will be an unexpected softupdates
* inconsistency if it turns out that the summary is still
* incorrect. Set a flag so subsequent operation can know
* this.
*/
bkgrdsumadj = 1;
if (sysctlnametomib("vfs.ffs.adjndir", adjndir, &size) < 0 ||
sysctlnametomib("vfs.ffs.adjnbfree", adjnbfree, &size) < 0 ||
sysctlnametomib("vfs.ffs.adjnifree", adjnifree, &size) < 0 ||
sysctlnametomib("vfs.ffs.adjnffree", adjnffree, &size) < 0 ||
sysctlnametomib("vfs.ffs.adjnumclusters", adjnumclusters, &size) < 0) {
bkgrdsumadj = 0;
pwarn("kernel lacks runtime superblock summary adjustment support");
}
cmd.version = FFS_CMD_VERSION;
cmd.handle = fsreadfd;
fswritefd = -1;
}
if (preen == 0)
printf("** %s", dev);
if (bkgrdflag == 0 &&
(nflag || ufs_disk_write(&disk) < 0 ||
(fswritefd = dup(disk.d_fd)) < 0)) {
fswritefd = -1;
if (preen)
pfatal("NO WRITE ACCESS");
printf(" (NO WRITE)");
}
if (preen == 0)
printf("\n");
/*
* Read in the superblock, looking for alternates if necessary
*/
if (readsb(1) == 0) {
skipclean = 0;
if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
return(0);
if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
return (0);
for (cg = 0; cg < proto.fs_ncg; cg++) {
bflag = fsbtodb(&proto, cgsblock(&proto, cg));
if (readsb(0) != 0)
break;
}
if (cg >= proto.fs_ncg) {
printf("%s %s\n%s %s\n%s %s\n",
"SEARCH FOR ALTERNATE SUPER-BLOCK",
"FAILED. YOU MUST USE THE",
"-b OPTION TO FSCK TO SPECIFY THE",
"LOCATION OF AN ALTERNATE",
"SUPER-BLOCK TO SUPPLY NEEDED",
"INFORMATION; SEE fsck_ffs(8).");
bflag = 0;
return(0);
}
pwarn("USING ALTERNATE SUPERBLOCK AT %jd\n", bflag);
bflag = 0;
}
if (skipclean && ckclean && sblock.fs_clean) {
pwarn("FILE SYSTEM CLEAN; SKIPPING CHECKS\n");
return (-1);
}
maxfsblock = sblock.fs_size;
maxino = sblock.fs_ncg * sblock.fs_ipg;
/*
* Check and potentially fix certain fields in the super block.
*/
if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
if (reply("SET TO DEFAULT") == 1) {
sblock.fs_optim = FS_OPTTIME;
sbdirty();
}
}
if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
sblock.fs_minfree);
if (reply("SET TO DEFAULT") == 1) {
sblock.fs_minfree = 10;
sbdirty();
}
}
if (sblock.fs_magic == FS_UFS1_MAGIC &&
sblock.fs_old_inodefmt < FS_44INODEFMT) {
pwarn("Format of file system is too old.\n");
pwarn("Must update to modern format using a version of fsck\n");
pfatal("from before 2002 with the command ``fsck -c 2''\n");
exit(EEXIT);
}
if (asblk.b_dirty && !bflag) {
memmove(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
flush(fswritefd, &asblk);
}
if (preen == 0 && yflag == 0 && sblock.fs_magic == FS_UFS2_MAGIC &&
fswritefd != -1 && chkrecovery(fsreadfd) == 0 &&
reply("SAVE DATA TO FIND ALTERNATE SUPERBLOCKS") != 0)
saverecovery(fsreadfd, fswritefd);
/*
* read in the summary info.
*/
asked = 0;
sblock.fs_csp = Calloc(1, sblock.fs_cssize);
if (sblock.fs_csp == NULL) {
printf("cannot alloc %u bytes for cg summary info\n",
(unsigned)sblock.fs_cssize);
goto badsb;
}
for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
size = MIN(sblock.fs_cssize - i, sblock.fs_bsize);
readcnt[sblk.b_type]++;
if (blread(fsreadfd, (char *)sblock.fs_csp + i,
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
size) != 0 && !asked) {
pfatal("BAD SUMMARY INFORMATION");
if (reply("CONTINUE") == 0) {
ckfini(0);
exit(EEXIT);
}
asked++;
}
}
/*
* allocate and initialize the necessary maps
*/
bmapsize = roundup(howmany(maxfsblock, CHAR_BIT), sizeof(short));
blockmap = Calloc((unsigned)bmapsize, sizeof (char));
if (blockmap == NULL) {
printf("cannot alloc %u bytes for blockmap\n",
(unsigned)bmapsize);
goto badsb;
}
inostathead = Calloc(sblock.fs_ncg, sizeof(struct inostatlist));
if (inostathead == NULL) {
printf("cannot alloc %u bytes for inostathead\n",
(unsigned)(sizeof(struct inostatlist) * (sblock.fs_ncg)));
goto badsb;
}
numdirs = MAX(sblock.fs_cstotal.cs_ndir, 128);
dirhash = numdirs;
inplast = 0;
listmax = numdirs + 10;
inpsort = (struct inoinfo **)Calloc(listmax, sizeof(struct inoinfo *));
inphead = (struct inoinfo **)Calloc(numdirs, sizeof(struct inoinfo *));
if (inpsort == NULL || inphead == NULL) {
printf("cannot alloc %ju bytes for inphead\n",
(uintmax_t)numdirs * sizeof(struct inoinfo *));
goto badsb;
}
bufinit();
if (sblock.fs_flags & FS_DOSOFTDEP)
usedsoftdep = 1;
else
usedsoftdep = 0;
return (1);
badsb:
ckfini(0);
return (0);
}
int
setup(const char *dev)
{
long cg, asked, i;
long bmapsize;
struct disklabel *lp;
off_t sizepb;
struct stat statb;
struct m_ext2fs proto;
int doskipclean;
u_int64_t maxfilesize;
havesb = 0;
fswritefd = -1;
doskipclean = skipclean;
if (stat(dev, &statb) < 0) {
printf("Can't stat %s: %s\n", dev, strerror(errno));
return 0;
}
if (!S_ISCHR(statb.st_mode)) {
pfatal("%s is not a character device", dev);
if (reply("CONTINUE") == 0)
return 0;
}
if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
printf("Can't open %s: %s\n", dev, strerror(errno));
return 0;
}
if (preen == 0)
printf("** %s", dev);
if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
fswritefd = -1;
if (preen)
pfatal("NO WRITE ACCESS");
printf(" (NO WRITE)");
}
if (preen == 0)
printf("\n");
fsmodified = 0;
lfdir = 0;
initbarea(&sblk);
initbarea(&asblk);
sblk.b_un.b_buf = malloc(SBSIZE);
asblk.b_un.b_buf = malloc(SBSIZE);
if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
errexit("cannot allocate space for superblock");
if ((lp = getdisklabel(NULL, fsreadfd)) != NULL)
dev_bsize = secsize = lp->d_secsize;
else
dev_bsize = secsize = DEV_BSIZE;
/*
* Read in the superblock, looking for alternates if necessary
*/
if (readsb(1) == 0) {
if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
return 0;
if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
return 0;
for (cg = 1; cg < proto.e2fs_ncg; cg++) {
bflag = EXT2_FSBTODB(&proto,
cg * proto.e2fs.e2fs_bpg +
proto.e2fs.e2fs_first_dblock);
if (readsb(0) != 0)
break;
}
if (cg >= proto.e2fs_ncg) {
printf("%s %s\n%s %s\n%s %s\n",
"SEARCH FOR ALTERNATE SUPER-BLOCK",
"FAILED. YOU MUST USE THE",
"-b OPTION TO FSCK_FFS TO SPECIFY THE",
"LOCATION OF AN ALTERNATE",
"SUPER-BLOCK TO SUPPLY NEEDED",
"INFORMATION; SEE fsck_ext2fs(8).");
return 0;
}
doskipclean = 0;
pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
}
if (debug)
printf("state = %d\n", sblock.e2fs.e2fs_state);
if (sblock.e2fs.e2fs_state == E2FS_ISCLEAN) {
if (doskipclean) {
pwarn("%sile system is clean; not checking\n",
preen ? "f" : "** F");
return -1;
}
if (!preen)
pwarn("** File system is already clean\n");
}
maxfsblock = sblock.e2fs.e2fs_bcount;
maxino = sblock.e2fs_ncg * sblock.e2fs.e2fs_ipg;
sizepb = sblock.e2fs_bsize;
maxfilesize = sblock.e2fs_bsize * EXT2FS_NDADDR - 1;
for (i = 0; i < EXT2FS_NIADDR; i++) {
sizepb *= EXT2_NINDIR(&sblock);
maxfilesize += sizepb;
}
/*
* Check and potentially fix certain fields in the super block.
*/
if (/* (sblock.e2fs.e2fs_rbcount < 0) || */
(sblock.e2fs.e2fs_rbcount > sblock.e2fs.e2fs_bcount)) {
pfatal("IMPOSSIBLE RESERVED BLOCK COUNT=%d IN SUPERBLOCK",
sblock.e2fs.e2fs_rbcount);
if (reply("SET TO DEFAULT") == 1) {
sblock.e2fs.e2fs_rbcount =
sblock.e2fs.e2fs_bcount * MINFREE / 100;
sbdirty();
dirty(&asblk);
}
}
if (sblock.e2fs.e2fs_bpg != sblock.e2fs.e2fs_fpg) {
pfatal("WRONG FPG=%d (BPG=%d) IN SUPERBLOCK",
sblock.e2fs.e2fs_fpg, sblock.e2fs.e2fs_bpg);
return 0;
}
if (asblk.b_dirty && !bflag) {
copyback_sb(&asblk);
flush(fswritefd, &asblk);
}
/*
* read in the summary info.
*/
sblock.e2fs_gd = malloc(sblock.e2fs_ngdb * sblock.e2fs_bsize);
if (sblock.e2fs_gd == NULL)
errexit("out of memory");
asked = 0;
for (i = 0; i < sblock.e2fs_ngdb; i++) {
if (bread(fsreadfd,
(char *)&sblock.e2fs_gd[i * sblock.e2fs_bsize /
sizeof(struct ext2_gd)],
EXT2_FSBTODB(&sblock, ((sblock.e2fs_bsize > 1024) ? 0 : 1) +
i + 1),
sblock.e2fs_bsize) != 0 && !asked) {
pfatal("BAD SUMMARY INFORMATION");
if (reply("CONTINUE") == 0)
exit(FSCK_EXIT_CHECK_FAILED);
asked++;
}
}
/*
* allocate and initialize the necessary maps
*/
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
blockmap = calloc((unsigned int)bmapsize, sizeof(char));
if (blockmap == NULL) {
printf("cannot alloc %u bytes for blockmap\n",
(unsigned int)bmapsize);
goto badsblabel;
}
statemap = calloc((unsigned int)(maxino + 2), sizeof(char));
if (statemap == NULL) {
printf("cannot alloc %u bytes for statemap\n",
(unsigned int)(maxino + 1));
goto badsblabel;
}
typemap = calloc((unsigned int)(maxino + 1), sizeof(char));
if (typemap == NULL) {
printf("cannot alloc %u bytes for typemap\n",
(unsigned int)(maxino + 1));
goto badsblabel;
}
lncntp = calloc((unsigned)(maxino + 1), sizeof(int16_t));
if (lncntp == NULL) {
printf("cannot alloc %u bytes for lncntp\n",
(unsigned int)((maxino + 1) * sizeof(int16_t)));
goto badsblabel;
}
for (numdirs = 0, cg = 0; cg < sblock.e2fs_ncg; cg++) {
numdirs += fs2h16(sblock.e2fs_gd[cg].ext2bgd_ndirs);
}
inplast = 0;
listmax = numdirs + 10;
inpsort = calloc((unsigned int)listmax, sizeof(struct inoinfo *));
inphead = calloc((unsigned int)numdirs, sizeof(struct inoinfo *));
if (inpsort == NULL || inphead == NULL) {
printf("cannot alloc %u bytes for inphead\n",
(unsigned int)(numdirs * sizeof(struct inoinfo *)));
goto badsblabel;
}
bufinit();
return 1;
badsblabel:
ckfini(0);
return 0;
}
void
pass2(void)
{
struct ufs1_dinode *dp;
struct inoinfo **inpp, *inp;
struct inoinfo **inpend;
struct inodesc curino;
struct ufs1_dinode dino;
char pathbuf[MAXPATHLEN + 1];
long i, n;
switch (inoinfo(ROOTINO)->ino_state) {
case USTATE:
pfatal("ROOT INODE UNALLOCATED");
if (reply("ALLOCATE") == 0) {
ckfini(0);
exit(EEXIT);
}
if (allocdir(ROOTINO, ROOTINO, 0755) != 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)
errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
break;
}
if (reply("CONTINUE") == 0) {
ckfini(0);
exit(EEXIT);
}
break;
case FSTATE:
case FCLEAR:
pfatal("ROOT INODE NOT DIRECTORY");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
break;
}
if (reply("FIX") == 0) {
ckfini(0);
exit(EEXIT);
}
dp = ginode(ROOTINO);
dp->di_mode &= ~IFMT;
dp->di_mode |= IFDIR;
inodirty();
break;
case DSTATE:
break;
default:
errx(EEXIT, "BAD STATE %d FOR ROOT INODE",
inoinfo(ROOTINO)->ino_state);
}
inoinfo(ROOTINO)->ino_state = DFOUND;
if (newinofmt) {
inoinfo(WINO)->ino_state = FSTATE;
inoinfo(WINO)->ino_type = DT_WHT;
}
/*
* Sort the directory list into disk block order. Do this in blocks
* of 1000 directories in order to maintain locality of reference
* in memory in case fsck is using swap space.
*/
for (i = 0; i < inplast; i += 1000) {
if ((n = inplast - i) > 1000)
n = 1000;
qsort(inpsort + i, (size_t)n, sizeof *inpsort, blksort);
}
/*
* Check the integrity of each directory.
*/
memset(&curino, 0, sizeof(struct inodesc));
curino.id_type = DATA;
curino.id_func = pass2check;
dp = &dino;
inpend = &inpsort[inplast];
for (inpp = inpsort; inpp < inpend; inpp++) {
if (got_siginfo) {
printf("%s: phase 2: dir %d of %ld (%d%%)\n", cdevname,
inpp - inpsort, inplast, (int)((inpp - inpsort) * 100 /
inplast));
got_siginfo = 0;
}
inp = *inpp;
if (inp->i_isize == 0)
continue;
if (inp->i_isize < MINDIRSIZE) {
direrror(inp->i_number, "DIRECTORY TOO SHORT");
inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
if (reply("FIX") == 1) {
dp = ginode(inp->i_number);
dp->di_size = inp->i_isize;
inodirty();
dp = &dino;
}
} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
getpathname(pathbuf, inp->i_number, inp->i_number);
if (usedsoftdep)
pfatal("%s %s: LENGTH %d NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf, inp->i_isize,
DIRBLKSIZ);
else
pwarn("%s %s: LENGTH %d NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf, inp->i_isize,
DIRBLKSIZ);
if (preen)
printf(" (ADJUSTED)\n");
inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
if (preen || reply("ADJUST") == 1) {
dp = ginode(inp->i_number);
dp->di_size = roundup(inp->i_isize, DIRBLKSIZ);
inodirty();
dp = &dino;
}
}
memset(&dino, 0, sizeof(struct ufs1_dinode));
dino.di_mode = IFDIR;
dp->di_size = inp->i_isize;
memmove(&dp->di_db[0], &inp->i_blks[0], (size_t)inp->i_numblks);
curino.id_number = inp->i_number;
curino.id_parent = inp->i_parent;
ckinode(dp, &curino);
}
/*
* Now that the parents of all directories have been found,
* make another pass to verify the value of `..'
*/
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_parent == 0 || inp->i_isize == 0)
continue;
if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
inoinfo(inp->i_number)->ino_state == DSTATE)
inoinfo(inp->i_number)->ino_state = DFOUND;
if (inp->i_dotdot == inp->i_parent ||
inp->i_dotdot == (ufs1_ino_t)-1)
continue;
if (inp->i_dotdot == 0) {
inp->i_dotdot = inp->i_parent;
fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
if (reply("FIX") == 0)
continue;
makeentry(inp->i_number, inp->i_parent, "..");
inoinfo(inp->i_parent)->ino_linkcnt--;
continue;
}
fileerror(inp->i_parent, inp->i_number,
"BAD INODE NUMBER FOR '..'");
if (reply("FIX") == 0)
continue;
inoinfo(inp->i_dotdot)->ino_linkcnt++;
inoinfo(inp->i_parent)->ino_linkcnt--;
inp->i_dotdot = inp->i_parent;
changeino(inp->i_number, "..", inp->i_parent);
}
/*
* Mark all the directories that can be found from the root.
*/
propagate();
}
void
pass2(void)
{
union dinode *dp;
struct inoinfo **inpp, *inp, *pinp;
struct inoinfo **inpend;
struct inostat *rinfo, *info;
struct inodesc curino;
union dinode dino;
int i, maxblk;
char pathbuf[MAXPATHLEN + 1];
rinfo = inoinfo(ROOTINO);
switch (rinfo->ino_state) {
case USTATE:
pfatal("ROOT INODE UNALLOCATED");
if (reply("ALLOCATE") == 0) {
markclean = 0;
ckfini();
exit(FSCK_EXIT_CHECK_FAILED);
}
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE");
break;
case DCLEAR:
pfatal("DUPS/BAD IN ROOT INODE");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE");
break;
}
markclean = 0;
if (reply("CONTINUE") == 0) {
ckfini();
exit(FSCK_EXIT_CHECK_FAILED);
}
break;
case FSTATE:
case FCLEAR:
pfatal("ROOT INODE NOT DIRECTORY");
if (reply("REALLOCATE")) {
freeino(ROOTINO);
if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
errexit("CANNOT ALLOCATE ROOT INODE");
break;
}
if (reply("FIX") == 0) {
markclean = 0;
ckfini();
exit(FSCK_EXIT_CHECK_FAILED);
}
dp = ginode(ROOTINO);
DIP_SET(dp, mode,
iswap16((iswap16(DIP(dp, mode)) & ~IFMT) | IFDIR));
inodirty();
break;
case DSTATE:
break;
default:
errexit("BAD STATE %d FOR ROOT INODE", rinfo->ino_state);
}
if (newinofmt) {
info = inoinfo(WINO);
info->ino_state = FSTATE;
info->ino_type = DT_WHT;
}
/*
* Sort the directory list into disk block order.
*/
qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
/*
* Check the integrity of each directory.
*/
memset(&curino, 0, sizeof(struct inodesc));
curino.id_type = DATA;
curino.id_func = pass2check;
inpend = &inpsort[inplast];
for (inpp = inpsort; inpp < inpend; inpp++) {
if (got_siginfo) {
fprintf(stderr,
"%s: phase 2: dir %ld of %d (%d%%)\n", cdevname(),
(long)(inpp - inpsort), (int)inplast,
(int)((inpp - inpsort) * 100 / inplast));
got_siginfo = 0;
}
#ifdef PROGRESS
progress_bar(cdevname(), preen ? NULL : "phase 2",
(inpp - inpsort), inplast);
#endif /* PROGRESS */
inp = *inpp;
if (inp->i_isize == 0)
continue;
if (inp->i_isize < MINDIRSIZE) {
direrror(inp->i_number, "DIRECTORY TOO SHORT");
inp->i_isize = roundup(MINDIRSIZE, dirblksiz);
if (reply("FIX") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, size, iswap64(inp->i_isize));
inodirty();
} else
markclean = 0;
} else if ((inp->i_isize & (dirblksiz - 1)) != 0) {
getpathname(pathbuf, sizeof(pathbuf), inp->i_number,
inp->i_number);
if (usedsoftdep)
pfatal("%s %s: LENGTH %lld NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf,
(long long)inp->i_isize, dirblksiz);
else
pwarn("%s %s: LENGTH %lld NOT MULTIPLE OF %d",
"DIRECTORY", pathbuf,
(long long)inp->i_isize, dirblksiz);
if (preen)
printf(" (ADJUSTED)\n");
inp->i_isize = roundup(inp->i_isize, dirblksiz);
if (preen || reply("ADJUST") == 1) {
dp = ginode(inp->i_number);
DIP_SET(dp, size, iswap64(inp->i_isize));
inodirty();
} else
markclean = 0;
}
memset(&dino, 0, sizeof dino);
dp = &dino;
if (!is_ufs2) {
dp->dp1.di_mode = iswap16(IFDIR);
dp->dp1.di_size = iswap64(inp->i_isize);
maxblk = inp->i_numblks < NDADDR ? inp->i_numblks :
NDADDR;
for (i = 0; i < maxblk; i++)
dp->dp1.di_db[i] = inp->i_blks[i];
if (inp->i_numblks > NDADDR) {
for (i = 0; i < NIADDR; i++)
dp->dp1.di_ib[i] =
inp->i_blks[NDADDR + i];
}
} else {
dp->dp2.di_mode = iswap16(IFDIR);
dp->dp2.di_size = iswap64(inp->i_isize);
maxblk = inp->i_numblks < NDADDR ? inp->i_numblks :
NDADDR;
for (i = 0; i < maxblk; i++)
dp->dp2.di_db[i] = inp->i_blks[i];
if (inp->i_numblks > NDADDR) {
for (i = 0; i < NIADDR; i++)
dp->dp2.di_ib[i] =
inp->i_blks[NDADDR + i];
}
}
curino.id_number = inp->i_number;
curino.id_parent = inp->i_parent;
(void)ckinode(&dino, &curino);
}
/*
* Byte swapping in directory entries, if needed, has been done.
* Now rescan dirs for pass2check()
*/
if (do_dirswap) {
do_dirswap = 0;
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_isize == 0)
continue;
memset(&dino, 0, sizeof dino);
if (!is_ufs2) {
dino.dp1.di_mode = iswap16(IFDIR);
dino.dp1.di_size = iswap64(inp->i_isize);
for (i = 0; i < inp->i_numblks; i++)
dino.dp1.di_db[i] = inp->i_blks[i];
} else {
dino.dp2.di_mode = iswap16(IFDIR);
dino.dp2.di_size = iswap64(inp->i_isize);
for (i = 0; i < inp->i_numblks; i++)
dino.dp2.di_db[i] = inp->i_blks[i];
}
curino.id_number = inp->i_number;
curino.id_parent = inp->i_parent;
(void)ckinode(&dino, &curino);
}
}
/*
* Now that the parents of all directories have been found,
* make another pass to verify the value of `..'
*/
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_parent == 0 || inp->i_isize == 0)
continue;
if (inp->i_dotdot == inp->i_parent ||
inp->i_dotdot == (ino_t)-1)
continue;
info = inoinfo(inp->i_parent);
if (inp->i_dotdot == 0) {
inp->i_dotdot = inp->i_parent;
fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
if (reply("FIX") == 0) {
markclean = 0;
continue;
}
(void)makeentry(inp->i_number, inp->i_parent, "..");
info->ino_linkcnt--;
continue;
}
fileerror(inp->i_parent, inp->i_number,
"BAD INODE NUMBER FOR '..'");
if (reply("FIX") == 0) {
markclean = 0;
continue;
}
inoinfo(inp->i_dotdot)->ino_linkcnt++;
info->ino_linkcnt--;
inp->i_dotdot = inp->i_parent;
(void)changeino(inp->i_number, "..", inp->i_parent);
}
/*
* Create a list of children for each directory.
*/
inpend = &inpsort[inplast];
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
info = inoinfo(inp->i_number);
inp->i_child = inp->i_sibling = 0;
if (info->ino_state == DFOUND)
info->ino_state = DSTATE;
}
for (inpp = inpsort; inpp < inpend; inpp++) {
inp = *inpp;
if (inp->i_parent == 0 ||
inp->i_number == ROOTINO)
continue;
pinp = getinoinfo(inp->i_parent);
inp->i_sibling = pinp->i_child;
pinp->i_child = inp;
}
/*
* Mark all the directories that can be found from the root.
*/
propagate(ROOTINO);
#ifdef PROGRESS
if (!preen)
progress_done();
#endif /* PROGRESS */
}
