projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
4.4BSD snapshot (revision 8.1)
[unix-history] / usr / src / sbin / fsck / pass1.c
diff --git a/usr/src/sbin/fsck/pass1.c b/usr/src/sbin/fsck/pass1.c
index 3ecc82a..920c744 100644 (file)
--- a/usr/src/sbin/fsck/pass1.c
+++ b/usr/src/sbin/fsck/pass1.c
@@ -1,30 +1,33 @@
 /*
 /*
- * 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, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * %sccs.include.redist.c%
  */
 
 #ifndef lint
  */
 
 #ifndef lint
-static char sccsid[] = "@(#)pass1.c    5.4 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)pass1.c    8.1 (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/ufs/dir.h>
+#include <ufs/ffs/fs.h>
+#include <stdlib.h>
+#include <string.h>
 #include "fsck.h"
 
 static daddr_t badblk;
 static daddr_t dupblk;
 int pass1check();
 #include "fsck.h"
 
 static daddr_t badblk;
 static daddr_t dupblk;
 int pass1check();
+struct dinode *getnextinode();
 
 pass1()
 {
 
 pass1()
 {
-       register int c, i, j;
-       register DINODE *dp;
-       struct zlncnt *zlnp;
-       int ndb, partial, cgd;
-       struct inodesc idesc;
        ino_t inumber;
        ino_t inumber;
+       int c, i, cgd;
+       struct inodesc idesc;
 
        /*
         * Set file system reserved blocks in used block map.
 
        /*
         * Set file system reserved blocks in used block map.
@@ -47,101 +50,174 @@ pass1()
        idesc.id_func = pass1check;
        inumber = 0;
        n_files = n_blks = 0;
        idesc.id_func = pass1check;
        inumber = 0;
        n_files = n_blks = 0;
+       resetinodebuf();
        for (c = 0; c < sblock.fs_ncg; c++) {
                for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
                        if (inumber < ROOTINO)
                                continue;
        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;
+                       checkinode(inumber, &idesc);
+               }
+       }
+       freeinodebuf();
+}
+
+checkinode(inumber, idesc)
+       ino_t inumber;
+       register struct inodesc *idesc;
+{
+       register struct dinode *dp;
+       struct zlncnt *zlnp;
+       int ndb, j;
+       mode_t mode;
+       char symbuf[MAXSYMLINKLEN];
+
+       dp = getnextinode(inumber);
+       mode = dp->di_mode & IFMT;
+       if (mode == 0) {
+               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=%lu", inumber);
+                       if (reply("CLEAR") == 1) {
+                               dp = ginode(inumber);
+                               clearinode(dp);
                                inodirty();
                        }
                                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();
+               }
+               statemap[inumber] = USTATE;
+               return;
+       }
+       lastino = inumber;
+       if (/* dp->di_size < 0 || */
+           dp->di_size + sblock.fs_bsize - 1 < dp->di_size) {
+               if (debug)
+                       printf("bad size %qu:", dp->di_size);
+               goto unknown;
+       }
+       if (!preen && mode == IFMT && reply("HOLD BAD BLOCK") == 1) {
+               dp = ginode(inumber);
+               dp->di_size = sblock.fs_fsize;
+               dp->di_mode = IFREG|0600;
+               inodirty();
+       }
+       ndb = howmany(dp->di_size, sblock.fs_bsize);
+       if (ndb < 0) {
+               if (debug)
+                       printf("bad size %qu ndb %d:",
+                               dp->di_size, ndb);
+               goto unknown;
+       }
+       if (mode == IFBLK || mode == IFCHR)
+               ndb++;
+       if (mode == IFLNK) {
+               if (doinglevel2 &&
+                   dp->di_size > 0 && dp->di_size < MAXSYMLINKLEN &&
+                   dp->di_blocks != 0) {
+                       if (bread(fsreadfd, symbuf,
+                           fsbtodb(&sblock, dp->di_db[0]),
+                           (long)dp->di_size) != 0)
+                               errexit("cannot read symlink");
+                       if (debug) {
+                               symbuf[dp->di_size] = 0;
+                               printf("convert symlink %d(%s) of size %d\n",
+                                       inumber, symbuf, (long)dp->di_size);
                        }
                        }
-                       continue;
-       unknown:
-                       pfatal("UNKNOWN FILE TYPE I=%u", inumber);
-                       statemap[inumber] = FCLEAR;
-                       if (reply("CLEAR") == 1) {
-                               statemap[inumber] = USTATE;
-                               zapino(dp);
-                               inodirty();
+                       dp = ginode(inumber);
+                       bcopy(symbuf, (caddr_t)dp->di_shortlink,
+                           (long)dp->di_size);
+                       dp->di_blocks = 0;
+                       inodirty();
+               }
+               /*
+                * Fake ndb value so direct/indirect block checks below
+                * will detect any garbage after symlink string.
+                */
+               if (dp->di_size < sblock.fs_maxsymlinklen) {
+                       ndb = howmany(dp->di_size, sizeof(daddr_t));
+                       if (ndb > NDADDR) {
+                               j = ndb - NDADDR;
+                               for (ndb = 1; j > 1; j--)
+                                       ndb *= NINDIR(&sblock);
+                               ndb += NDADDR;
                        }
                }
        }
                        }
                }
        }
+       for (j = ndb; j < NDADDR; j++)
+               if (dp->di_db[j] != 0) {
+                       if (debug)
+                               printf("bad direct addr: %ld\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: %ld\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;
+               }
+       }
+       if (mode == IFDIR) {
+               if (dp->di_size == 0)
+                       statemap[inumber] = DCLEAR;
+               else
+                       statemap[inumber] = DSTATE;
+               cacheino(dp, inumber);
+       } else
+               statemap[inumber] = FSTATE;
+       typemap[inumber] = IFTODT(mode);
+       if (doinglevel2 &&
+           (dp->di_ouid != (u_short)-1 || dp->di_ogid != (u_short)-1)) {
+               dp = ginode(inumber);
+               dp->di_uid = dp->di_ouid;
+               dp->di_ouid = -1;
+               dp->di_gid = dp->di_ogid;
+               dp->di_ogid = -1;
+               inodirty();
+       }
+       badblk = dupblk = 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=%lu (%ld should be %ld)",
+                   inumber, dp->di_blocks, idesc->id_entryno);
+               if (preen)
+                       printf(" (CORRECTED)\n");
+               else if (reply("CORRECT") == 0)
+                       return;
+               dp = ginode(inumber);
+               dp->di_blocks = idesc->id_entryno;
+               inodirty();
+       }
+       return;
+unknown:
+       pfatal("UNKNOWN FILE TYPE I=%lu", inumber);
+       statemap[inumber] = FCLEAR;
+       if (reply("CLEAR") == 1) {
+               statemap[inumber] = USTATE;
+               dp = ginode(inumber);
+               clearinode(dp);
+               inodirty();
+       }
 }
 
 pass1check(idesc)
 }
 
 pass1check(idesc)
@@ -153,10 +229,10 @@ pass1check(idesc)
        register struct dups *dlp;
        struct dups *new;
 
        register struct dups *dlp;
        struct dups *new;
 
-       if ((anyout = outrange(blkno, idesc->id_numfrags)) != 0) {
-               blkerr(idesc->id_number, "BAD", blkno);
-               if (++badblk >= MAXBAD) {
-                       pwarn("EXCESSIVE BAD BLKS I=%u",
+       if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) {
+               blkerror(idesc->id_number, "BAD", blkno);
+               if (badblk++ >= MAXBAD) {
+                       pwarn("EXCESSIVE BAD BLKS I=%lu",
                                idesc->id_number);
                        if (preen)
                                printf(" (SKIPPING)\n");
                                idesc->id_number);
                        if (preen)
                                printf(" (SKIPPING)\n");
@@ -166,15 +242,15 @@ pass1check(idesc)
                }
        }
        for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
                }
        }
        for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
-               if (anyout && outrange(blkno, 1)) {
+               if (anyout && chkrange(blkno, 1)) {
                        res = SKIP;
                        res = SKIP;
-               } else if (!getbmap(blkno)) {
+               } else if (!testbmap(blkno)) {
                        n_blks++;
                        setbmap(blkno);
                } else {
                        n_blks++;
                        setbmap(blkno);
                } else {
-                       blkerr(idesc->id_number, "DUP", blkno);
-                       if (++dupblk >= MAXDUP) {
-                               pwarn("EXCESSIVE DUP BLKS I=%u",
+                       blkerror(idesc->id_number, "DUP", blkno);
+                       if (dupblk++ >= MAXDUP) {
+                               pwarn("EXCESSIVE DUP BLKS I=%lu",
                                        idesc->id_number);
                                if (preen)
                                        printf(" (SKIPPING)\n");
                                        idesc->id_number);
                                if (preen)
                                        printf(" (SKIPPING)\n");
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.