salvage the correct part of the directory

[unix-history] / usr / src / sbin / fsck / pass5.c

diff --git a/usr/src/sbin/fsck/pass5.c b/usr/src/sbin/fsck/pass5.c
index c44acc6..7d41ed6 100644 (file)
--- a/usr/src/sbin/fsck/pass5.c
+++ b/usr/src/sbin/fsck/pass5.c
@@ -1,57 +1,61 @@
 /*
 /*

- * Copyright (c) 1980 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1980, 1986 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%

  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)pass5.c    5.4 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)pass5.c    5.18 (Berkeley) %G%";
+#endif /* not lint */

 
 #include <sys/param.h>
 
 #include <sys/param.h>

-#include <sys/inode.h>
-#include <sys/fs.h>
+#include <sys/time.h>
+#include <ufs/ufs/dinode.h>
+#include <ufs/ffs/fs.h>
+#include <string.h>

 #include "fsck.h"
 
 pass5()
 {
        int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
 #include "fsck.h"
 
 pass5()
 {
        int c, blk, frags, basesize, sumsize, mapsize, savednrpos;

+       register struct fs *fs = &sblock;
+       register struct cg *cg = &cgrp;

        daddr_t dbase, dmax;
        register daddr_t d;
        register long i, j;
        struct csum *cs;
        daddr_t dbase, dmax;
        register daddr_t d;
        register long i, j;
        struct csum *cs;

-       time_t now;

        struct csum cstotal;
        struct csum cstotal;

-       struct inodesc idesc;
+       struct inodesc idesc[3];

        char buf[MAXBSIZE];
        register struct cg *newcg = (struct cg *)buf;
        struct ocg *ocg = (struct ocg *)buf;
 
        char buf[MAXBSIZE];
        register struct cg *newcg = (struct cg *)buf;
        struct ocg *ocg = (struct ocg *)buf;
 

-       bzero((char *)newcg, sblock.fs_cgsize);
-       newcg->cg_niblk = sblock.fs_ipg;
-       switch (sblock.fs_postblformat) {
+       bzero((char *)newcg, (size_t)fs->fs_cgsize);
+       newcg->cg_niblk = fs->fs_ipg;
+       switch ((int)fs->fs_postblformat) {

 
        case FS_42POSTBLFMT:
                basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
                sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);
 
        case FS_42POSTBLFMT:
                basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
                sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);

-               mapsize = &ocg->cg_free[howmany(sblock.fs_fpg, NBBY)] -
+               mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -

                        (u_char *)&ocg->cg_iused[0];
                ocg->cg_magic = CG_MAGIC;
                        (u_char *)&ocg->cg_iused[0];
                ocg->cg_magic = CG_MAGIC;

-               savednrpos = sblock.fs_nrpos;
-               sblock.fs_nrpos = 8;
+               savednrpos = fs->fs_nrpos;
+               fs->fs_nrpos = 8;

                break;
 
        case FS_DYNAMICPOSTBLFMT:
                newcg->cg_btotoff =
                        &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
                newcg->cg_boff =
                break;
 
        case FS_DYNAMICPOSTBLFMT:
                newcg->cg_btotoff =
                        &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
                newcg->cg_boff =

-                       newcg->cg_btotoff + sblock.fs_cpg * sizeof(long);
+                       newcg->cg_btotoff + fs->fs_cpg * sizeof(long);

                newcg->cg_iusedoff = newcg->cg_boff + 
                newcg->cg_iusedoff = newcg->cg_boff + 

-                       sblock.fs_cpg * sblock.fs_nrpos * sizeof(short);
+                       fs->fs_cpg * fs->fs_nrpos * sizeof(short);

                newcg->cg_freeoff =
                newcg->cg_freeoff =

-                       newcg->cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
+                       newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);

                newcg->cg_nextfreeoff = newcg->cg_freeoff +
                newcg->cg_nextfreeoff = newcg->cg_freeoff +

-                       howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock),
+                       howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs),

                                NBBY);
                newcg->cg_magic = CG_MAGIC;
                basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
                                NBBY);
                newcg->cg_magic = CG_MAGIC;
                basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);


@@ -61,54 +65,56 @@ pass5()
 
        default:
                errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
 
        default:
                errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",

-                       sblock.fs_postblformat);
+                       fs->fs_postblformat);
+       }
+       bzero((char *)&idesc[0], sizeof idesc);
+       for (i = 0; i < 3; i++) {
+               idesc[i].id_type = ADDR;
+               if (doinglevel2)
+                       idesc[i].id_fix = FIX;

        }
        }

-       bzero((char *)&idesc, sizeof(struct inodesc));
-       idesc.id_type = ADDR;

        bzero((char *)&cstotal, sizeof(struct csum));
        bzero((char *)&cstotal, sizeof(struct csum));

-       (void)time(&now);
-       for (i = sblock.fs_size; i < fragroundup(&sblock, sblock.fs_size); i++)
+       j = blknum(fs, fs->fs_size + fs->fs_frag - 1);
+       for (i = fs->fs_size; i < j; i++)

                setbmap(i);
                setbmap(i);

-       for (c = 0; c < sblock.fs_ncg; c++) {
-               getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize);
-               if (!cg_chkmagic(&cgrp))
+       for (c = 0; c < fs->fs_ncg; c++) {
+               getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
+               if (!cg_chkmagic(cg))

                        pfatal("CG %d: BAD MAGIC NUMBER\n", c);
                        pfatal("CG %d: BAD MAGIC NUMBER\n", c);

-               dbase = cgbase(&sblock, c);
-               dmax = dbase + sblock.fs_fpg;
-               if (dmax > sblock.fs_size)
-                       dmax = sblock.fs_size;
-               if (now > cgrp.cg_time)
-                       newcg->cg_time = cgrp.cg_time;
-               else
-                       newcg->cg_time = now;
+               dbase = cgbase(fs, c);
+               dmax = dbase + fs->fs_fpg;
+               if (dmax > fs->fs_size)
+                       dmax = fs->fs_size;
+               newcg->cg_time = cg->cg_time;

                newcg->cg_cgx = c;
                newcg->cg_cgx = c;

-               if (c == sblock.fs_ncg - 1)
-                       newcg->cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
+               if (c == fs->fs_ncg - 1)
+                       newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;

                else
                else

-                       newcg->cg_ncyl = sblock.fs_cpg;
+                       newcg->cg_ncyl = fs->fs_cpg;

                newcg->cg_ndblk = dmax - dbase;
                newcg->cg_cs.cs_ndir = 0;
                newcg->cg_cs.cs_nffree = 0;
                newcg->cg_cs.cs_nbfree = 0;
                newcg->cg_ndblk = dmax - dbase;
                newcg->cg_cs.cs_ndir = 0;
                newcg->cg_cs.cs_nffree = 0;
                newcg->cg_cs.cs_nbfree = 0;

-               newcg->cg_cs.cs_nifree = sblock.fs_ipg;
-               if (cgrp.cg_rotor < newcg->cg_ndblk)
-                       newcg->cg_rotor = cgrp.cg_rotor;
+               newcg->cg_cs.cs_nifree = fs->fs_ipg;
+               if (cg->cg_rotor < newcg->cg_ndblk)
+                       newcg->cg_rotor = cg->cg_rotor;

                else
                        newcg->cg_rotor = 0;
                else
                        newcg->cg_rotor = 0;

-               if (cgrp.cg_frotor < newcg->cg_ndblk)
-                       newcg->cg_frotor = cgrp.cg_frotor;
+               if (cg->cg_frotor < newcg->cg_ndblk)
+                       newcg->cg_frotor = cg->cg_frotor;

                else
                        newcg->cg_frotor = 0;
                else
                        newcg->cg_frotor = 0;

-               if (cgrp.cg_irotor < newcg->cg_niblk)
-                       newcg->cg_irotor = cgrp.cg_irotor;
+               if (cg->cg_irotor < newcg->cg_niblk)
+                       newcg->cg_irotor = cg->cg_irotor;

                else
                        newcg->cg_irotor = 0;
                bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
                else
                        newcg->cg_irotor = 0;
                bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);

-               bzero((char *)&cg_blktot(newcg)[0], sumsize + mapsize);
-               if (sblock.fs_postblformat == FS_42POSTBLFMT)
+               bzero((char *)&cg_blktot(newcg)[0],
+                     (size_t)(sumsize + mapsize));
+               if (fs->fs_postblformat == FS_42POSTBLFMT)

                        ocg->cg_magic = CG_MAGIC;
                        ocg->cg_magic = CG_MAGIC;

-               j = sblock.fs_ipg * c;
-               for (i = 0; i < sblock.fs_ipg; j++, i++) {
+               j = fs->fs_ipg * c;
+               for (i = 0; i < fs->fs_ipg; j++, i++) {

                        switch (statemap[j]) {
 
                        case USTATE:
                        switch (statemap[j]) {
 
                        case USTATE:


@@ -140,64 +146,64 @@ pass5()
                        }
                for (i = 0, d = dbase;
                     d < dmax;
                        }
                for (i = 0, d = dbase;
                     d < dmax;

-                    d += sblock.fs_frag, i += sblock.fs_frag) {
+                    d += fs->fs_frag, i += fs->fs_frag) {

                        frags = 0;
                        frags = 0;

-                       for (j = 0; j < sblock.fs_frag; j++) {
-                               if (getbmap(d + j))
+                       for (j = 0; j < fs->fs_frag; j++) {
+                               if (testbmap(d + j))

                                        continue;
                                setbit(cg_blksfree(newcg), i + j);
                                frags++;
                        }
                                        continue;
                                setbit(cg_blksfree(newcg), i + j);
                                frags++;
                        }

-                       if (frags == sblock.fs_frag) {
+                       if (frags == fs->fs_frag) {

                                newcg->cg_cs.cs_nbfree++;
                                newcg->cg_cs.cs_nbfree++;

-                               j = cbtocylno(&sblock, i);
+                               j = cbtocylno(fs, i);

                                cg_blktot(newcg)[j]++;
                                cg_blktot(newcg)[j]++;

-                               cg_blks(&sblock, newcg, j)
-                                   [cbtorpos(&sblock, i)]++;
+                               cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;

                        } else if (frags > 0) {
                                newcg->cg_cs.cs_nffree += frags;
                        } else if (frags > 0) {
                                newcg->cg_cs.cs_nffree += frags;

-                               blk = blkmap(&sblock, cg_blksfree(newcg), i);
-                               fragacct(&sblock, blk, newcg->cg_frsum, 1);
+                               blk = blkmap(fs, cg_blksfree(newcg), i);
+                               ffs_fragacct(fs, blk, newcg->cg_frsum, 1);

                        }
                }
                cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
                cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
                cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
                cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
                        }
                }
                cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
                cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
                cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
                cstotal.cs_ndir += newcg->cg_cs.cs_ndir;

-               cs = &sblock.fs_cs(&sblock, c);
+               cs = &fs->fs_cs(fs, c);

                if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
                if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&

-                   dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
+                   dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {

                        bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
                        sbdirty();
                }
                        bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
                        sbdirty();
                }

-               if (cvtflag) {
-                       bcopy((char *)newcg, (char *)&cgrp, sblock.fs_cgsize);
+               if (doinglevel1) {
+                       bcopy((char *)newcg, (char *)cg, (size_t)fs->fs_cgsize);

                        cgdirty();
                        continue;
                }
                if (bcmp(cg_inosused(newcg),
                        cgdirty();
                        continue;
                }
                if (bcmp(cg_inosused(newcg),

-                        cg_inosused(&cgrp), mapsize) != 0 &&
-                   dofix(&idesc, "BLK(S) MISSING IN BIT MAPS")) {
-                       bcopy(cg_inosused(newcg), cg_inosused(&cgrp), mapsize);
+                        cg_inosused(cg), mapsize) != 0 &&
+                   dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
+                       bcopy(cg_inosused(newcg), cg_inosused(cg),
+                             (size_t)mapsize);

                        cgdirty();
                }
                        cgdirty();
                }

-               if ((bcmp((char *)newcg, (char *)&cgrp, basesize) != 0 ||
+               if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||

                     bcmp((char *)&cg_blktot(newcg)[0],
                     bcmp((char *)&cg_blktot(newcg)[0],

-                         (char *)&cg_blktot(&cgrp)[0], sumsize) != 0) &&
-                   dofix(&idesc, "SUMMARY INFORMATION BAD")) {
-                       bcopy((char *)newcg, (char *)&cgrp, basesize);
+                         (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
+                   dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
+                       bcopy((char *)newcg, (char *)cg, (size_t)basesize);

                        bcopy((char *)&cg_blktot(newcg)[0],
                        bcopy((char *)&cg_blktot(newcg)[0],

-                             (char *)&cg_blktot(&cgrp)[0], sumsize);
+                             (char *)&cg_blktot(cg)[0], (size_t)sumsize);

                        cgdirty();
                }
        }
                        cgdirty();
                }
        }

-       if (sblock.fs_postblformat == FS_42POSTBLFMT)
-               sblock.fs_nrpos = savednrpos;
-       if (bcmp((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs) != 0
-           && dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
-               bcopy((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs);
-               sblock.fs_ronly = 0;
-               sblock.fs_fmod = 0;
+       if (fs->fs_postblformat == FS_42POSTBLFMT)
+               fs->fs_nrpos = savednrpos;
+       if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
+           && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
+               bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
+               fs->fs_ronly = 0;
+               fs->fs_fmod = 0;

                sbdirty();
        }
 }
                sbdirty();
        }
 }