- sync();
- exit(4);
- }
-}
-
-setup(dev)
- char *dev;
-{
- dev_t rootdev;
- struct stat statb;
- daddr_t super = bflag ? bflag : SBLOCK;
- int i, j, c, d, cgd;
- long size;
- BUFAREA asblk;
-# define altsblock asblk.b_un.b_fs
-
- if (stat("/", &statb) < 0)
- errexit("Can't stat root\n");
- rootdev = statb.st_dev;
- if (stat(dev, &statb) < 0) {
- error("Can't stat %s\n", dev);
- return (0);
- }
- rawflg = 0;
- if ((statb.st_mode & S_IFMT) == S_IFBLK)
- ;
- else if ((statb.st_mode & S_IFMT) == S_IFCHR)
- rawflg++;
- else {
- if (reply("file is not a block or character device; OK") == 0)
- return (0);
- }
- if (rootdev == statb.st_rdev)
- hotroot++;
- if ((dfile.rfdes = open(dev, 0)) < 0) {
- error("Can't open %s\n", dev);
- return (0);
- }
- if (preen == 0)
- printf("** %s", dev);
- if (nflag || (dfile.wfdes = open(dev, 1)) < 0) {
- dfile.wfdes = -1;
- if (preen)
- pfatal("NO WRITE ACCESS");
- printf(" (NO WRITE)");
- }
- if (preen == 0)
- printf("\n");
- fixcg = 0; inosumbad = 0; offsumbad = 0; frsumbad = 0; sbsumbad = 0;
- dfile.mod = 0;
- n_files = n_blks = n_ffree = n_bfree = 0;
- muldup = enddup = &duplist[0];
- badlnp = &badlncnt[0];
- lfdir = 0;
- rplyflag = 0;
- initbarea(&sblk);
- initbarea(&fileblk);
- initbarea(&inoblk);
- initbarea(&cgblk);
- initbarea(&asblk);
- /*
- * Read in the super block and its summary info.
- */
- if (bread(&dfile, (char *)&sblock, super, (long)SBSIZE) == 0)
- return (0);
- sblk.b_bno = super;
- sblk.b_size = SBSIZE;
- /*
- * run a few consistency checks of the super block
- */
- if (sblock.fs_magic != FS_MAGIC)
- { badsb("MAGIC NUMBER WRONG"); return (0); }
- if (sblock.fs_ncg < 1)
- { badsb("NCG OUT OF RANGE"); return (0); }
- if (sblock.fs_cpg < 1 || sblock.fs_cpg > MAXCPG)
- { badsb("CPG OUT OF RANGE"); return (0); }
- if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
- (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
- { badsb("NCYL DOES NOT JIVE WITH NCG*CPG"); return (0); }
- if (sblock.fs_sbsize > SBSIZE)
- { badsb("SIZE PREPOSTEROUSLY LARGE"); return (0); }
- /*
- * Set all possible fields that could differ, then do check
- * of whole super block against an alternate super block.
- * When an alternate super-block is specified this check is skipped.
- */
- if (bflag)
- goto sbok;
- if (getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1),
- sblock.fs_sbsize) == 0)
- return (0);
- altsblock.fs_link = sblock.fs_link;
- altsblock.fs_rlink = sblock.fs_rlink;
- altsblock.fs_time = sblock.fs_time;
- altsblock.fs_cstotal = sblock.fs_cstotal;
- altsblock.fs_cgrotor = sblock.fs_cgrotor;
- altsblock.fs_fmod = sblock.fs_fmod;
- altsblock.fs_clean = sblock.fs_clean;
- altsblock.fs_ronly = sblock.fs_ronly;
- altsblock.fs_flags = sblock.fs_flags;
- altsblock.fs_maxcontig = sblock.fs_maxcontig;
- altsblock.fs_minfree = sblock.fs_minfree;
- altsblock.fs_rotdelay = sblock.fs_rotdelay;
- altsblock.fs_maxbpg = sblock.fs_maxbpg;
- bcopy((char *)sblock.fs_csp, (char *)altsblock.fs_csp,
- sizeof sblock.fs_csp);
- bcopy((char *)sblock.fs_fsmnt, (char *)altsblock.fs_fsmnt,
- sizeof sblock.fs_fsmnt);
- if (bcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize))
- { badsb("TRASHED VALUES IN SUPER BLOCK"); return (0); }
-sbok:
- fmax = sblock.fs_size;
- imax = sblock.fs_ncg * sblock.fs_ipg;
- n_bad = cgsblock(&sblock, 0); /* boot block plus dedicated sblock */
- /*
- * read in the summary info.
- */
- for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
- size = sblock.fs_cssize - i < sblock.fs_bsize ?
- sblock.fs_cssize - i : sblock.fs_bsize;
- sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
- if (bread(&dfile, (char *)sblock.fs_csp[j],
- fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
- size) == 0)
- return (0);
- }
- /*
- * allocate and initialize the necessary maps
- */
- bmapsz = roundup(howmany(fmax, NBBY), sizeof(short));
- blockmap = calloc((unsigned)bmapsz, sizeof (char));
- if (blockmap == NULL) {
- printf("cannot alloc %d bytes for blockmap\n", bmapsz);
- goto badsb;
- }
- freemap = calloc((unsigned)bmapsz, sizeof (char));
- if (freemap == NULL) {
- printf("cannot alloc %d bytes for freemap\n", bmapsz);
- goto badsb;
- }
- statemap = calloc((unsigned)(imax + 1), sizeof(char));
- if (statemap == NULL) {
- printf("cannot alloc %d bytes for statemap\n", imax + 1);
- goto badsb;
- }
- lncntp = (short *)calloc((unsigned)(imax + 1), sizeof(short));
- if (lncntp == NULL) {
- printf("cannot alloc %d bytes for lncntp\n",
- (imax + 1) * sizeof(short));
- goto badsb;
- }
- for (c = 0; c < sblock.fs_ncg; c++) {
- cgd = cgdmin(&sblock, c);
- if (c == 0) {
- d = cgbase(&sblock, c);
- cgd += howmany(sblock.fs_cssize, sblock.fs_fsize);
- } else
- d = cgsblock(&sblock, c);
- for (; d < cgd; d++)
- setbmap(d);
- }
-
- return (1);
-
-badsb:
- ckfini();
- return (0);
-# undef altsblock
-}
-
-pass1()
-{
- register int c, i, n, j;
- register DINODE *dp;
- int ndb, partial;
- struct inodesc idesc;
- ino_t inumber;
-
- bzero((char *)&idesc, sizeof(struct inodesc));
- idesc.id_type = ADDR;
- idesc.id_func = pass1check;
- inumber = 0;
- n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
- for (c = 0; c < sblock.fs_ncg; c++) {
- if (getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize) == 0)
- continue;
- if (cgrp.cg_magic != CG_MAGIC) {
- pfatal("CG %d: BAD MAGIC NUMBER\n", c);
- bzero((char *)&cgrp, (int)sblock.fs_cgsize);
- }
- n = 0;
- for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
- dp = ginode(inumber);
- if (dp == NULL)
- continue;
- n++;
- if (ALLOC) {
- if (!isset(cgrp.cg_iused, i)) {
- if (debug)
- printf("%d bad, not used\n",
- inumber);
- inosumbad++;
- }
- n--;
- lastino = inumber;
- if (!preen && BADBLK &&
- reply("HOLD BAD BLOCK") == 1) {
- dp->di_size = sblock.fs_fsize;
- dp->di_mode = IFREG|0600;
- inodirty();
- } else if (ftypeok(dp) == 0)
- goto unknown;
- if (dp->di_size < 0) {
- if (debug)
- printf("bad size %d:",
- dp->di_size);
- goto unknown;
- }
- ndb = howmany(dp->di_size, sblock.fs_bsize);
- if (SPECIAL)
- 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;
- }
- n_files++;
- lncntp[inumber] = dp->di_nlink;
- if (dp->di_nlink <= 0) {
- if (badlnp < &badlncnt[MAXLNCNT])
- *badlnp++ = inumber;
- else {
- pfatal("LINK COUNT TABLE OVERFLOW");
- if (reply("CONTINUE") == 0)
- errexit("");
- }
- }
- statemap[inumber] = DIRCT ? DSTATE : FSTATE;
- badblk = dupblk = 0; maxblk = 0;
- idesc.id_number = inumber;
- idesc.id_filesize = 0;
- (void)ckinode(dp, &idesc);
- idesc.id_filesize *= btodb(sblock.fs_fsize);
- if (dp->di_blocks != idesc.id_filesize) {
- pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %ld)",
- inumber, dp->di_blocks,
- idesc.id_filesize);
- if (preen)
- printf(" (CORRECTED)\n");
- else if (reply("CORRECT") == 0)
- continue;
- dp->di_blocks = idesc.id_filesize;
- inodirty();
- }
- continue;
- unknown:
- pfatal("UNKNOWN FILE TYPE I=%u", inumber);
- if (reply("CLEAR") == 1) {
- zapino(dp);
- inodirty();
- inosumbad++;
- }
- } else {
- if (isset(cgrp.cg_iused, i)) {
- if (debug)
- printf("%d bad, marked used\n",
- inumber);
- inosumbad++;
- n--;
- }
- partial = 0;
- for (j = 0; j < NDADDR; j++)
- if (dp->di_db[j] != 0)
- partial++;
- for (j = 0; j < NIADDR; j++)
- if (dp->di_ib[j] != 0)
- partial++;
- if (partial || dp->di_mode != 0 ||
- dp->di_size != 0) {
- pfatal("PARTIALLY ALLOCATED INODE I=%u",
- inumber);
- if (reply("CLEAR") == 1) {
- zapino(dp);
- inodirty();
- inosumbad++;
- }
- }
- }
- }
- if (n != cgrp.cg_cs.cs_nifree) {
- if (debug)
- printf("cg[%d].cg_cs.cs_nifree is %d; calc %d\n",
- c, cgrp.cg_cs.cs_nifree, n);
- inosumbad++;
- }
- if (cgrp.cg_cs.cs_nbfree != sblock.fs_cs(&sblock, c).cs_nbfree
- || cgrp.cg_cs.cs_nffree != sblock.fs_cs(&sblock, c).cs_nffree
- || cgrp.cg_cs.cs_nifree != sblock.fs_cs(&sblock, c).cs_nifree
- || cgrp.cg_cs.cs_ndir != sblock.fs_cs(&sblock, c).cs_ndir)
- sbsumbad++;
- }
-}
-
-pass1check(idesc)
- register struct inodesc *idesc;
-{
- register daddr_t *dlp;
- int res = KEEPON;
- int anyout, nfrags;
- daddr_t blkno = idesc->id_blkno;
-
- anyout = outrange(blkno, idesc->id_numfrags);
- for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (anyout && outrange(blkno, 1)) {
- blkerr(idesc->id_number, "BAD", blkno);
- if (++badblk >= MAXBAD) {
- pwarn("EXCESSIVE BAD BLKS I=%u",
- idesc->id_number);
- if (preen)
- printf(" (SKIPPING)\n");
- else if (reply("CONTINUE") == 0)
- errexit("");
- return (STOP);
- }
- res = SKIP;
- } else if (getbmap(blkno)) {
- blkerr(idesc->id_number, "DUP", blkno);
- if (++dupblk >= MAXDUP) {
- pwarn("EXCESSIVE DUP BLKS I=%u",
- idesc->id_number);
- if (preen)
- printf(" (SKIPPING)\n");
- else if (reply("CONTINUE") == 0)
- errexit("");
- return (STOP);
- }
- if (enddup >= &duplist[DUPTBLSIZE]) {
- pfatal("DUP TABLE OVERFLOW.");
- if (reply("CONTINUE") == 0)
- errexit("");
- return (STOP);
- }
- for (dlp = duplist; dlp < muldup; dlp++)
- if (*dlp == blkno) {
- *enddup++ = blkno;
- break;
- }
- if (dlp >= muldup) {
- *enddup++ = *muldup;
- *muldup++ = blkno;
- }
- } else {
- n_blks++;
- setbmap(blkno);
- }
- idesc->id_filesize++;
- }
- return (res);
-}
-
-pass1b()
-{
- register int c, i;
- register DINODE *dp;
- struct inodesc idesc;
- ino_t inumber;
-
- bzero((char *)&idesc, sizeof(struct inodesc));
- idesc.id_type = ADDR;
- idesc.id_func = pass1bcheck;
- inumber = 0;
- for (c = 0; c < sblock.fs_ncg; c++) {
- for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
- dp = ginode(inumber);
- if (dp == NULL)
- continue;
- idesc.id_number = inumber;
- if (statemap[inumber] != USTATE &&
- (ckinode(dp, &idesc) & STOP))
- goto out1b;
- }
- }
-out1b:
- flush(&dfile, &inoblk);
-}
-
-pass1bcheck(idesc)
- register struct inodesc *idesc;
-{
- register daddr_t *dlp;
- int nfrags, res = KEEPON;
- daddr_t blkno = idesc->id_blkno;
-
- for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (outrange(blkno, 1))
- res = SKIP;
- for (dlp = duplist; dlp < muldup; dlp++)
- if (*dlp == blkno) {
- blkerr(idesc->id_number, "DUP", blkno);
- *dlp = *--muldup;
- *muldup = blkno;
- if (muldup == duplist)
- return (STOP);
- }
- }
- return (res);
-}
-
-pass2()
-{
- register DINODE *dp;
- struct inodesc rootdesc;
-
- bzero((char *)&rootdesc, sizeof(struct inodesc));
- rootdesc.id_type = ADDR;
- rootdesc.id_func = pass2check;
- rootdesc.id_number = ROOTINO;
- pathp = pathname;
- switch (statemap[ROOTINO]) {
-
- case USTATE:
- errexit("ROOT INODE UNALLOCATED. TERMINATING.\n");
-
- case FSTATE:
- pfatal("ROOT INODE NOT DIRECTORY");
- if (reply("FIX") == 0 || (dp = ginode(ROOTINO)) == NULL)
- errexit("");
- dp->di_mode &= ~IFMT;
- dp->di_mode |= IFDIR;
- inodirty();
- inosumbad++;
- statemap[ROOTINO] = DSTATE;
- /* fall into ... */
-
- case DSTATE:
- descend(&rootdesc, ROOTINO);
- break;
-
- case CLEAR:
- pfatal("DUPS/BAD IN ROOT INODE");
- printf("\n");
- if (reply("CONTINUE") == 0)
- errexit("");
- statemap[ROOTINO] = DSTATE;
- descend(&rootdesc, ROOTINO);
- }
-}
-
-pass2check(idesc)
- struct inodesc *idesc;
-{
- register DIRECT *dirp = idesc->id_dirp;
- char *curpathloc;
- int n, entrysize, ret = 0;
- DINODE *dp;
- DIRECT proto;
-
- /*
- * check for "."
- */
- if (idesc->id_entryno != 0)
- goto chk1;
- if (dirp->d_ino != 0 && dirp->d_namlen == 1 && dirp->d_name[0] == '.') {
- if (dirp->d_ino != idesc->id_number) {
- direrr(idesc->id_number, "BAD INODE NUMBER FOR '.'");
- dirp->d_ino = idesc->id_number;
- ret |= dofix(idesc);
- }
- goto chk1;
- }
- direrr(idesc->id_number, "MISSING '.'");
- proto.d_ino = idesc->id_number;
- proto.d_namlen = 1;
- (void)strcpy(proto.d_name, ".");
- entrysize = DIRSIZ(&proto);
- if (dirp->d_ino != 0) {
- pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
- dirp->d_name);
- } else if (dirp->d_reclen < entrysize) {
- pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
- } else if (dirp->d_reclen < 2 * entrysize) {
- proto.d_reclen = dirp->d_reclen;
- bcopy((char *)&proto, (char *)dirp, entrysize);
- ret |= dofix(idesc);
- } else {
- n = dirp->d_reclen - entrysize;
- proto.d_reclen = entrysize;
- bcopy((char *)&proto, (char *)dirp, entrysize);
- idesc->id_entryno++;
- lncntp[dirp->d_ino]--;
- dirp = (DIRECT *)((char *)(dirp) + entrysize);
- bzero((char *)dirp, n);
- dirp->d_reclen = n;
- ret |= dofix(idesc);
- }
-chk1:
- if (idesc->id_entryno > 1)
- goto chk2;
- proto.d_ino = idesc->id_parent;
- proto.d_namlen = 2;
- (void)strcpy(proto.d_name, "..");
- entrysize = DIRSIZ(&proto);
- if (idesc->id_entryno == 0) {
- n = DIRSIZ(dirp);
- if (dirp->d_reclen < n + entrysize)
- goto chk2;
- proto.d_reclen = dirp->d_reclen - n;
- dirp->d_reclen = n;
- idesc->id_entryno++;
- lncntp[dirp->d_ino]--;
- dirp = (DIRECT *)((char *)(dirp) + n);
- bzero((char *)dirp, n);
- dirp->d_reclen = n;
- }
- if (dirp->d_ino != 0 && dirp->d_namlen == 2 &&
- strcmp(dirp->d_name, "..") == 0) {
- if (dirp->d_ino != idesc->id_parent) {
- direrr(idesc->id_number, "BAD INODE NUMBER FOR '..'");
- dirp->d_ino = idesc->id_parent;
- ret |= dofix(idesc);
- }
- goto chk2;
- }
- direrr(idesc->id_number, "MISSING '..'");
- if (dirp->d_ino != 0) {
- pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
- dirp->d_name);
- } else if (dirp->d_reclen < entrysize) {
- pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
- } else {
- proto.d_reclen = dirp->d_reclen;
- bcopy((char *)&proto, (char *)dirp, entrysize);
- ret |= dofix(idesc);
- }
-chk2:
- if (dirp->d_ino == 0)
- return (ret|KEEPON);
- if (idesc->id_entryno >= 2 &&
- dirp->d_namlen <= 2 &&
- dirp->d_name[0] == '.') {
- if (dirp->d_namlen == 1) {
- direrr(idesc->id_number, "EXTRA '.' ENTRY");
- dirp->d_ino = 0;
- return (KEEPON | dofix(idesc));
- }
- if (dirp->d_name[1] == '.') {
- direrr(idesc->id_number, "EXTRA '..' ENTRY");
- dirp->d_ino = 0;
- return (KEEPON | dofix(idesc));
- }
- }
- curpathloc = pathp;
- *pathp++ = '/';
- if (pathp + dirp->d_namlen >= endpathname) {
- *pathp = '\0';
- errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
- }
- bcopy(dirp->d_name, pathp, dirp->d_namlen + 1);
- pathp += dirp->d_namlen;
- idesc->id_entryno++;
- n = 0;
- if (dirp->d_ino > imax || dirp->d_ino <= 0) {
- direrr(dirp->d_ino, "I OUT OF RANGE");
- n = reply("REMOVE");
- } else {
-again:
- switch (statemap[dirp->d_ino]) {
- case USTATE:
- direrr(dirp->d_ino, "UNALLOCATED");
- n = reply("REMOVE");
- break;
-
- case CLEAR:
- direrr(dirp->d_ino, "DUP/BAD");
- if ((n = reply("REMOVE")) == 1)
- break;
- if ((dp = ginode(dirp->d_ino)) == NULL)
- break;
- statemap[dirp->d_ino] = DIRCT ? DSTATE : FSTATE;
- goto again;
-
- case FSTATE:
- lncntp[dirp->d_ino]--;
- break;
-
- case DSTATE:
- descend(idesc, dirp->d_ino);
- if (statemap[dirp->d_ino] != CLEAR) {
- lncntp[dirp->d_ino]--;
- } else {
- dirp->d_ino = 0;
- ret |= ALTERED;
- }
- break;
- }
- }
- pathp = curpathloc;
- *pathp = '\0';
- if (n == 0)
- return (ret|KEEPON);
- dirp->d_ino = 0;
- return (ret|KEEPON|ALTERED);
-}
-
-pass3()
-{
- register DINODE *dp;
- struct inodesc idesc;
- ino_t inumber, orphan;
- int len;
-
- bzero((char *)&idesc, sizeof(struct inodesc));
- idesc.id_type = DATA;
- for (inumber = ROOTINO; inumber <= lastino; inumber++) {
- if (statemap[inumber] == DSTATE) {
- idesc.id_func = findino;
- srchname = "..";
- idesc.id_parent = inumber;
- do {
- orphan = idesc.id_parent;
- if ((dp = ginode(orphan)) == NULL)
- break;
- idesc.id_parent = 0;
- idesc.id_filesize = dp->di_size;
- idesc.id_number = orphan;
- (void)ckinode(dp, &idesc);
- if (idesc.id_parent == 0)
- break;
- } while (statemap[idesc.id_parent] == DSTATE);
- if (linkup(orphan, idesc.id_parent) == 1) {
- pathp = pathname;
- *pathp++ = '/';
- len = strlen(lfname);
- bcopy(lfname, pathp, len + 1);
- pathp += len;
- *pathp++ = '/';
- pathp += lftempname(pathp, orphan);
- idesc.id_func = pass2check;
- idesc.id_number = lfdir;
- descend(&idesc, orphan);
- }
- }
- }
-}
-
-pass4()
-{
- register ino_t inumber, *blp;
- int n;
- struct inodesc idesc;
-
- bzero((char *)&idesc, sizeof(struct inodesc));
- idesc.id_type = ADDR;
- idesc.id_func = pass4check;
- for (inumber = ROOTINO; inumber <= lastino; inumber++) {
- idesc.id_number = inumber;
- switch (statemap[inumber]) {
-
- case FSTATE:
- n = lncntp[inumber];
- if (n)
- adjust(&idesc, (short)n);
- else {
- for (blp = badlncnt;blp < badlnp; blp++)
- if (*blp == inumber) {
- clri(&idesc, "UNREF", 1);
- break;
- }
- }
- break;
-
- case DSTATE:
- clri(&idesc, "UNREF", 1);
- break;
-
- case CLEAR:
- clri(&idesc, "BAD/DUP", 1);
- break;
- }
- }
- if (imax - ROOTINO - n_files != sblock.fs_cstotal.cs_nifree) {
- pwarn("FREE INODE COUNT WRONG IN SUPERBLK");
- if (preen)
- printf(" (FIXED)\n");
- if (preen || reply("FIX") == 1) {
- sblock.fs_cstotal.cs_nifree = imax - ROOTINO - n_files;
- sbdirty();
- }
- }
- flush(&dfile, &fileblk);
-}
-
-pass4check(idesc)
- register struct inodesc *idesc;
-{
- register daddr_t *dlp;
- int nfrags, res = KEEPON;
- daddr_t blkno = idesc->id_blkno;
-
- for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (outrange(blkno, 1))
- res = SKIP;
- else if (getbmap(blkno)) {
- for (dlp = duplist; dlp < enddup; dlp++)
- if (*dlp == blkno) {
- *dlp = *--enddup;
- return (KEEPON);
- }
- clrbmap(blkno);
- n_blks--;
- }
- }
- return (res);
-}
-
-pass5()
-{
- register int c, n, i, b, d;
- short bo[MAXCPG][NRPOS];
- long botot[MAXCPG];
- long frsum[MAXFRAG];
- int blk;
- daddr_t cbase;
- int blockbits = (1<<sblock.fs_frag)-1;
-
- bcopy(blockmap, freemap, (unsigned)bmapsz);
- dupblk = 0;
- n_index = sblock.fs_ncg * (cgdmin(&sblock, 0) - cgtod(&sblock, 0));
- for (c = 0; c < sblock.fs_ncg; c++) {
- cbase = cgbase(&sblock, c);
- bzero((char *)botot, sizeof (botot));
- bzero((char *)bo, sizeof (bo));
- bzero((char *)frsum, sizeof (frsum));