convert to BSD only copyright

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

diff --git a/usr/src/sbin/fsck/pass4.c b/usr/src/sbin/fsck/pass4.c
index 092170a..8e89c64 100644 (file)
--- a/usr/src/sbin/fsck/pass4.c
+++ b/usr/src/sbin/fsck/pass4.c
@@ -1,19 +1,37 @@
+/*
+ * Copyright (c) 1980, 1986 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+

 #ifndef lint
 #ifndef lint

-static char version[] = "@(#)pass4.c   3.1 (Berkeley) %G%";
-#endif
+static char sccsid[] = "@(#)pass4.c    5.7 (Berkeley) %G%";
+#endif /* not lint */

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

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

 #include "fsck.h"
 
 int    pass4check();
 
 pass4()
 {
 #include "fsck.h"
 
 int    pass4check();
 
 pass4()
 {

-       register ino_t inumber, *blp;
-       int n;
+       register ino_t inumber;
+       register struct zlncnt *zlnp;

        struct inodesc idesc;
        struct inodesc idesc;

+       int n;

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


@@ -23,12 +41,17 @@ pass4()
                switch (statemap[inumber]) {
 
                case FSTATE:
                switch (statemap[inumber]) {
 
                case FSTATE:

+               case DFOUND:

                        n = lncntp[inumber];
                        if (n)
                                adjust(&idesc, (short)n);
                        else {
                        n = lncntp[inumber];
                        if (n)
                                adjust(&idesc, (short)n);
                        else {

-                               for (blp = badlncnt;blp < badlnp; blp++)
-                                       if (*blp == inumber) {
+                               for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
+                                       if (zlnp->zlncnt == inumber) {
+                                               zlnp->zlncnt = zlnhead->zlncnt;
+                                               zlnp = zlnhead;
+                                               zlnhead = zlnhead->next;
+                                               free((char *)zlnp);

                                                clri(&idesc, "UNREF", 1);
                                                break;
                                        }
                                                clri(&idesc, "UNREF", 1);
                                                break;
                                        }


@@ -39,41 +62,45 @@ pass4()
                        clri(&idesc, "UNREF", 1);
                        break;
 
                        clri(&idesc, "UNREF", 1);
                        break;
 

-               case CLEAR:
+               case DCLEAR:
+               case FCLEAR:

                        clri(&idesc, "BAD/DUP", 1);
                        break;
                        clri(&idesc, "BAD/DUP", 1);
                        break;

+
+               case USTATE:
+                       break;
+
+               default:
+                       errexit("BAD STATE %d FOR INODE I=%d",
+                           statemap[inumber], inumber);

                }
        }
                }
        }

-       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;
 {
 }
 
 pass4check(idesc)
        register struct inodesc *idesc;
 {

-       register daddr_t *dlp;
+       register struct dups *dlp;

        int nfrags, res = KEEPON;
        daddr_t blkno = idesc->id_blkno;
 
        for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
        int nfrags, res = KEEPON;
        daddr_t blkno = idesc->id_blkno;
 
        for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {

-               if (outrange(blkno, 1))
+               if (chkrange(blkno, 1)) {

                        res = SKIP;
                        res = SKIP;

-               else if (getbmap(blkno)) {
-                       for (dlp = duplist; dlp < enddup; dlp++)
-                               if (*dlp == blkno) {
-                                       *dlp = *--enddup;
-                                       return (KEEPON);
-                               }
-                       clrbmap(blkno);
-                       n_blks--;
+               } else if (testbmap(blkno)) {
+                       for (dlp = duplist; dlp; dlp = dlp->next) {
+                               if (dlp->dup != blkno)
+                                       continue;
+                               dlp->dup = duplist->dup;
+                               dlp = duplist;
+                               duplist = duplist->next;
+                               free((char *)dlp);
+                               break;
+                       }
+                       if (dlp == 0) {
+                               clrbmap(blkno);
+                               n_blks--;
+                       }

                }
        }
        return (res);
                }
        }
        return (res);