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); } }
/* * make an entry in a directory */ int makeentry(ino_t parent, ino_t ino, const char *name) { union lfs_dinode *dp; struct inodesc idesc; char pathbuf[MAXPATHLEN + 1]; struct uvnode *vp; uint64_t size; if (parent < ULFS_ROOTINO || parent >= maxino || ino < ULFS_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; vp = vget(fs, parent); dp = VTOD(vp); size = lfs_dino_getsize(fs, dp); if (size % LFS_DIRBLKSIZ) { size = roundup(size, LFS_DIRBLKSIZ); lfs_dino_setsize(fs, dp, size); inodirty(VTOI(vp)); } if ((ckinode(dp, &idesc) & ALTERED) != 0) return (1); getpathname(pathbuf, sizeof(pathbuf), parent, parent); vp = vget(fs, parent); dp = VTOD(vp); if (expanddir(vp, dp, pathbuf) == 0) return (0); return (ckinode(dp, &idesc) & ALTERED); }
/* * deallocate an inode */ void freeino(ino_t ino) { struct inodesc idesc; struct uvnode *vp; memset(&idesc, 0, sizeof(struct inodesc)); idesc.id_type = ADDR; idesc.id_func = pass4check; idesc.id_number = ino; vp = vget(fs, ino); (void) ckinode(VTOD(vp), &idesc); clearinode(ino); statemap[ino] = USTATE; vnode_destroy(vp); n_files--; }
void clri(struct inodesc * idesc, const char *type, int flag) { struct uvnode *vp; vp = vget(fs, idesc->id_number); if (flag & 0x1) { pwarn("%s %s", type, (VTOI(vp)->i_ffs1_mode & IFMT) == IFDIR ? "DIR" : "FILE"); pinode(idesc->id_number); } if ((flag & 0x2) || preen || reply("CLEAR") == 1) { if (preen && flag != 2) printf(" (CLEARED)\n"); n_files--; (void) ckinode(VTOD(vp), idesc); clearinode(idesc->id_number); statemap[idesc->id_number] = USTATE; vnode_destroy(vp); return; } return; }
void adjust(struct inodesc *idesc, short lcnt) { struct uvnode *vp; union lfs_dinode *dp; /* * XXX: (1) since lcnt is apparently a delta, rename it; (2) * why is it a value to *subtract*? that is unnecessarily * confusing. */ vp = vget(fs, idesc->id_number); dp = VTOD(vp); if (lfs_dino_getnlink(fs, dp) == lcnt) { if (linkup(idesc->id_number, (ino_t) 0) == 0) clri(idesc, "UNREF", 0); } else { pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname : ((lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR ? "DIR" : "FILE")); pinode(idesc->id_number); printf(" COUNT %d SHOULD BE %d", lfs_dino_getnlink(fs, dp), lfs_dino_getnlink(fs, dp) - lcnt); if (preen) { if (lcnt < 0) { printf("\n"); pfatal("LINK COUNT INCREASING"); } printf(" (ADJUSTED)\n"); } if (preen || reply("ADJUST") == 1) { lfs_dino_setnlink(fs, dp, lfs_dino_getnlink(fs, dp) - lcnt); inodirty(VTOI(vp)); } } }
/* * Check validity of held blocks in an inode, recursing through all blocks. */ int ckinode(struct ufs1_dinode *dp, struct inodesc *idesc) { ufs_daddr_t *ap, lbn; long ret, n, ndb, offset; struct ufs1_dinode dino; u_int64_t remsize, sizepb; mode_t mode; char pathbuf[MAXPATHLEN + 1]; struct uvnode *vp, *thisvp; if (idesc->id_fix != IGNORE) idesc->id_fix = DONTKNOW; idesc->id_entryno = 0; idesc->id_filesize = dp->di_size; mode = dp->di_mode & IFMT; if (mode == IFBLK || mode == IFCHR || (mode == IFLNK && (dp->di_size < fs->lfs_maxsymlinklen || (fs->lfs_maxsymlinklen == 0 && dp->di_blocks == 0)))) return (KEEPON); dino = *dp; ndb = howmany(dino.di_size, fs->lfs_bsize); thisvp = vget(fs, idesc->id_number); for (lbn = 0; lbn < NDADDR; lbn++) { ap = dino.di_db + lbn; if (thisvp) idesc->id_numfrags = numfrags(fs, VTOI(thisvp)->i_lfs_fragsize[lbn]); else { if (--ndb == 0 && (offset = blkoff(fs, dino.di_size)) != 0) { idesc->id_numfrags = numfrags(fs, fragroundup(fs, offset)); } else idesc->id_numfrags = fs->lfs_frag; } if (*ap == 0) { if (idesc->id_type == DATA && ndb >= 0) { /* An empty block in a directory XXX */ getpathname(pathbuf, sizeof(pathbuf), idesc->id_number, idesc->id_number); pfatal("DIRECTORY %s INO %lld: CONTAINS EMPTY BLOCKS [1]", pathbuf, (long long)idesc->id_number); if (reply("ADJUST LENGTH") == 1) { vp = vget(fs, idesc->id_number); dp = VTOD(vp); dp->di_size = (ap - &dino.di_db[0]) * fs->lfs_bsize; printf( "YOU MUST RERUN FSCK AFTERWARDS\n"); rerun = 1; inodirty(VTOI(vp)); } else break; } continue; } idesc->id_blkno = *ap; idesc->id_lblkno = ap - &dino.di_db[0]; if (idesc->id_type == ADDR) { ret = (*idesc->id_func) (idesc); } else ret = dirscan(idesc); if (ret & STOP) return (ret); } idesc->id_numfrags = fs->lfs_frag; remsize = dino.di_size - fs->lfs_bsize * NDADDR; sizepb = fs->lfs_bsize; for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) { if (*ap) { idesc->id_blkno = *ap; ret = iblock(idesc, n, remsize); if (ret & STOP) return (ret); } else { if (idesc->id_type == DATA && remsize > 0) { /* An empty block in a directory XXX */ getpathname(pathbuf, sizeof(pathbuf), idesc->id_number, idesc->id_number); pfatal("DIRECTORY %s INO %lld: CONTAINS EMPTY BLOCKS [2]", pathbuf, (long long)idesc->id_number); if (reply("ADJUST LENGTH") == 1) { vp = vget(fs, idesc->id_number); dp = VTOD(vp); dp->di_size -= remsize; remsize = 0; printf( "YOU MUST RERUN FSCK AFTERWARDS\n"); rerun = 1; inodirty(VTOI(vp)); break; } else break; } } sizepb *= NINDIR(fs); remsize -= sizepb; } return (KEEPON); }
/* * allocate a new directory */ int allocdir(ino_t parent, ino_t request, int mode) { ino_t ino; char *cp; union lfs_dinode *dp; struct ubuf *bp; LFS_DIRHEADER *dirp; struct uvnode *vp; ino = allocino(request, LFS_IFDIR | mode); vp = vget(fs, ino); dp = VTOD(vp); bread(vp, lfs_dino_getdb(fs, dp, 0), lfs_sb_getfsize(fs), 0, &bp); if (bp->b_flags & B_ERROR) { brelse(bp, 0); freeino(ino); return (0); } dirp = (LFS_DIRHEADER *)bp->b_data; /* . */ lfs_dir_setino(fs, dirp, ino); lfs_dir_setreclen(fs, dirp, LFS_DIRECTSIZ(fs, 1)); lfs_dir_settype(fs, dirp, LFS_DT_DIR); lfs_dir_setnamlen(fs, dirp, 1); lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1, LFS_DIRECTSIZ(fs, 1)); /* .. */ dirp = LFS_NEXTDIR(fs, dirp); lfs_dir_setino(fs, dirp, parent); lfs_dir_setreclen(fs, dirp, LFS_DIRBLKSIZ - LFS_DIRECTSIZ(fs, 1)); lfs_dir_settype(fs, dirp, LFS_DT_DIR); lfs_dir_setnamlen(fs, dirp, 2); lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "..", 2, LFS_DIRBLKSIZ - LFS_DIRECTSIZ(fs, 1)); for (cp = &bp->b_data[LFS_DIRBLKSIZ]; cp < &bp->b_data[lfs_sb_getfsize(fs)]; cp += LFS_DIRBLKSIZ) { zerodirblk(cp); } VOP_BWRITE(bp); lfs_dino_setnlink(fs, dp, 2); inodirty(VTOI(vp)); if (ino == ULFS_ROOTINO) { lncntp[ino] = lfs_dino_getnlink(fs, dp); cacheino(dp, ino); return (ino); } if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) { freeino(ino); return (0); } cacheino(dp, ino); statemap[ino] = statemap[parent]; if (statemap[ino] == DSTATE) { lncntp[ino] = lfs_dino_getnlink(fs, dp); lncntp[parent]++; } vp = vget(fs, parent); dp = VTOD(vp); lfs_dino_setnlink(fs, dp, lfs_dino_getnlink(fs, dp) + 1); inodirty(VTOI(vp)); return (ino); }
int linkup(ino_t orphan, ino_t parentdir) { union lfs_dinode *dp; int lostdir; ino_t oldlfdir; struct inodesc idesc; char tempname[BUFSIZ]; struct uvnode *vp; memset(&idesc, 0, sizeof(struct inodesc)); vp = vget(fs, orphan); dp = VTOD(vp); lostdir = (lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR; pwarn("UNREF %s ", lostdir ? "DIR" : "FILE"); pinode(orphan); if (preen && lfs_dino_getsize(fs, dp) == 0) return (0); if (preen) printf(" (RECONNECTED)\n"); else if (reply("RECONNECT") == 0) return (0); if (lfdir == 0) { dp = ginode(ULFS_ROOTINO); idesc.id_name = lfname; idesc.id_type = DATA; idesc.id_func = findino; idesc.id_number = ULFS_ROOTINO; if ((ckinode(dp, &idesc) & FOUND) != 0) { lfdir = idesc.id_parent; } else { pwarn("NO lost+found DIRECTORY"); if (preen || reply("CREATE")) { lfdir = allocdir(ULFS_ROOTINO, (ino_t) 0, lfmode); if (lfdir != 0) { if (makeentry(ULFS_ROOTINO, lfdir, lfname) != 0) { if (preen) printf(" (CREATED)\n"); } else { freedir(lfdir, ULFS_ROOTINO); lfdir = 0; if (preen) printf("\n"); } } } } if (lfdir == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY"); printf("\n\n"); return (0); } } vp = vget(fs, lfdir); dp = VTOD(vp); if ((lfs_dino_getmode(fs, dp) & LFS_IFMT) != LFS_IFDIR) { pfatal("lost+found IS NOT A DIRECTORY"); if (reply("REALLOCATE") == 0) return (0); oldlfdir = lfdir; if ((lfdir = allocdir(ULFS_ROOTINO, (ino_t) 0, lfmode)) == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); return (0); } if ((changeino(ULFS_ROOTINO, lfname, lfdir) & ALTERED) == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); return (0); } inodirty(VTOI(vp)); idesc.id_type = ADDR; idesc.id_func = pass4check; idesc.id_number = oldlfdir; adjust(&idesc, lncntp[oldlfdir] + 1); lncntp[oldlfdir] = 0; vp = vget(fs, lfdir); dp = VTOD(vp); } if (statemap[lfdir] != DFOUND) { pfatal("SORRY. NO lost+found DIRECTORY\n\n"); return (0); } (void) lftempname(tempname, orphan); if (makeentry(lfdir, orphan, tempname) == 0) { pfatal("SORRY. NO SPACE IN lost+found DIRECTORY"); printf("\n\n"); return (0); } lncntp[orphan]--; if (lostdir) { if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 && parentdir != (ino_t) - 1) (void) makeentry(orphan, lfdir, ".."); vp = vget(fs, lfdir); lfs_dino_setnlink(fs, VTOI(vp)->i_din, lfs_dino_getnlink(fs, VTOI(vp)->i_din) + 1); inodirty(VTOI(vp)); lncntp[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); }