convert to BSD only copyright

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

diff --git a/usr/src/sbin/fsck/pass2.c b/usr/src/sbin/fsck/pass2.c
index cab8b72..4da68e5 100644 (file)
--- a/usr/src/sbin/fsck/pass2.c
+++ b/usr/src/sbin/fsck/pass2.c
@@ -1,17 +1,28 @@
 /*
 /*

- * 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.
+ *
+ * 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 sccsid[] = "@(#)pass2.c    5.2 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)pass2.c    5.8 (Berkeley) %G%";
+#endif /* not lint */

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

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

 #include <strings.h>
 #include "fsck.h"
 
 #include <strings.h>
 #include "fsck.h"
 


@@ -19,7 +30,7 @@ int   pass2check();
 
 pass2()
 {
 
 pass2()
 {

-       register DINODE *dp;
+       register struct dinode *dp;

        struct inodesc rootdesc;
 
        bzero((char *)&rootdesc, sizeof(struct inodesc));
        struct inodesc rootdesc;
 
        bzero((char *)&rootdesc, sizeof(struct inodesc));


@@ -33,7 +44,7 @@ pass2()
                pfatal("ROOT INODE UNALLOCATED");
                if (reply("ALLOCATE") == 0)
                        errexit("");
                pfatal("ROOT INODE UNALLOCATED");
                if (reply("ALLOCATE") == 0)
                        errexit("");

-               if (allocdir(ROOTINO, ROOTINO) != ROOTINO)
+               if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)

                        errexit("CANNOT ALLOCATE ROOT INODE\n");
                descend(&rootdesc, ROOTINO);
                break;
                        errexit("CANNOT ALLOCATE ROOT INODE\n");
                descend(&rootdesc, ROOTINO);
                break;


@@ -42,7 +53,7 @@ pass2()
                pfatal("DUPS/BAD IN ROOT INODE");
                if (reply("REALLOCATE")) {
                        freeino(ROOTINO);
                pfatal("DUPS/BAD IN ROOT INODE");
                if (reply("REALLOCATE")) {
                        freeino(ROOTINO);

-                       if (allocdir(ROOTINO, ROOTINO) != ROOTINO)
+                       if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)

                                errexit("CANNOT ALLOCATE ROOT INODE\n");
                        descend(&rootdesc, ROOTINO);
                        break;
                                errexit("CANNOT ALLOCATE ROOT INODE\n");
                        descend(&rootdesc, ROOTINO);
                        break;


@@ -58,7 +69,7 @@ pass2()
                pfatal("ROOT INODE NOT DIRECTORY");
                if (reply("REALLOCATE")) {
                        freeino(ROOTINO);
                pfatal("ROOT INODE NOT DIRECTORY");
                if (reply("REALLOCATE")) {
                        freeino(ROOTINO);

-                       if (allocdir(ROOTINO, ROOTINO) != ROOTINO)
+                       if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)

                                errexit("CANNOT ALLOCATE ROOT INODE\n");
                        descend(&rootdesc, ROOTINO);
                        break;
                                errexit("CANNOT ALLOCATE ROOT INODE\n");
                        descend(&rootdesc, ROOTINO);
                        break;


@@ -84,11 +95,11 @@ pass2()
 pass2check(idesc)
        struct inodesc *idesc;
 {
 pass2check(idesc)
        struct inodesc *idesc;
 {

-       register DIRECT *dirp = idesc->id_dirp;
+       register struct direct *dirp = idesc->id_dirp;

        char *curpathloc;
        int n, entrysize, ret = 0;
        char *curpathloc;
        int n, entrysize, ret = 0;

-       DINODE *dp;
-       DIRECT proto;
+       struct dinode *dp;
+       struct direct proto;

        char namebuf[BUFSIZ];
 
        /* 
        char namebuf[BUFSIZ];
 
        /* 


@@ -98,14 +109,14 @@ pass2check(idesc)
                goto chk1;
        if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
                if (dirp->d_ino != idesc->id_number) {
                goto chk1;
        if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
                if (dirp->d_ino != idesc->id_number) {

-                       direrr(idesc->id_number, "BAD INODE NUMBER FOR '.'");
+                       direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");

                        dirp->d_ino = idesc->id_number;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                }
                goto chk1;
        }
                        dirp->d_ino = idesc->id_number;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                }
                goto chk1;
        }

-       direrr(idesc->id_number, "MISSING '.'");
+       direrror(idesc->id_number, "MISSING '.'");

        proto.d_ino = idesc->id_number;
        proto.d_namlen = 1;
        (void)strcpy(proto.d_name, ".");
        proto.d_ino = idesc->id_number;
        proto.d_namlen = 1;
        (void)strcpy(proto.d_name, ".");


@@ -126,7 +137,7 @@ pass2check(idesc)
                bcopy((char *)&proto, (char *)dirp, entrysize);
                idesc->id_entryno++;
                lncntp[dirp->d_ino]--;
                bcopy((char *)&proto, (char *)dirp, entrysize);
                idesc->id_entryno++;
                lncntp[dirp->d_ino]--;

-               dirp = (DIRECT *)((char *)(dirp) + entrysize);
+               dirp = (struct direct *)((char *)(dirp) + entrysize);

                bzero((char *)dirp, n);
                dirp->d_reclen = n;
                if (reply("FIX") == 1)
                bzero((char *)dirp, n);
                dirp->d_reclen = n;
                if (reply("FIX") == 1)


@@ -147,20 +158,20 @@ chk1:
                dirp->d_reclen = n;
                idesc->id_entryno++;
                lncntp[dirp->d_ino]--;
                dirp->d_reclen = n;
                idesc->id_entryno++;
                lncntp[dirp->d_ino]--;

-               dirp = (DIRECT *)((char *)(dirp) + n);
+               dirp = (struct direct *)((char *)(dirp) + n);

                bzero((char *)dirp, n);
                dirp->d_reclen = n;
        }
        if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
                if (dirp->d_ino != idesc->id_parent) {
                bzero((char *)dirp, n);
                dirp->d_reclen = n;
        }
        if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
                if (dirp->d_ino != idesc->id_parent) {

-                       direrr(idesc->id_number, "BAD INODE NUMBER FOR '..'");
+                       direrror(idesc->id_number, "BAD INODE NUMBER FOR '..'");

                        dirp->d_ino = idesc->id_parent;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                }
                goto chk2;
        }
                        dirp->d_ino = idesc->id_parent;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                }
                goto chk2;
        }

-       direrr(idesc->id_number, "MISSING '..'");
+       direrror(idesc->id_number, "MISSING '..'");

        if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
                pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
                        dirp->d_name);
        if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
                pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
                        dirp->d_name);


@@ -179,14 +190,14 @@ chk2:
            dirp->d_name[0] == '.' &&
            idesc->id_entryno >= 2) {
                if (dirp->d_namlen == 1) {
            dirp->d_name[0] == '.' &&
            idesc->id_entryno >= 2) {
                if (dirp->d_namlen == 1) {

-                       direrr(idesc->id_number, "EXTRA '.' ENTRY");
+                       direrror(idesc->id_number, "EXTRA '.' ENTRY");

                        dirp->d_ino = 0;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                        return (KEEPON | ret);
                }
                if (dirp->d_name[1] == '.') {
                        dirp->d_ino = 0;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                        return (KEEPON | ret);
                }
                if (dirp->d_name[1] == '.') {

-                       direrr(idesc->id_number, "EXTRA '..' ENTRY");
+                       direrror(idesc->id_number, "EXTRA '..' ENTRY");

                        dirp->d_ino = 0;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;
                        dirp->d_ino = 0;
                        if (reply("FIX") == 1)
                                ret |= ALTERED;


@@ -199,28 +210,30 @@ chk2:
                *pathp = '\0';
                errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
        }
                *pathp = '\0';
                errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
        }

-       bcopy(dirp->d_name, pathp, dirp->d_namlen + 1);
+       bcopy(dirp->d_name, pathp, (int)dirp->d_namlen + 1);

        pathp += dirp->d_namlen;
        idesc->id_entryno++;
        n = 0;
        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");
+       if (dirp->d_ino > maxino || dirp->d_ino <= 0) {
+               direrror(dirp->d_ino, "I OUT OF RANGE");

                n = reply("REMOVE");
        } else {
 again:
                switch (statemap[dirp->d_ino]) {
                case USTATE:
                n = reply("REMOVE");
        } else {
 again:
                switch (statemap[dirp->d_ino]) {
                case USTATE:

-                       direrr(dirp->d_ino, "UNALLOCATED");
+                       direrror(dirp->d_ino, "UNALLOCATED");

                        n = reply("REMOVE");
                        break;
 
                case DCLEAR:
                case FCLEAR:
                        n = reply("REMOVE");
                        break;
 
                case DCLEAR:
                case FCLEAR:

-                       direrr(dirp->d_ino, "DUP/BAD");
+                       direrror(dirp->d_ino, "DUP/BAD");

                        if ((n = reply("REMOVE")) == 1)
                                break;
                        dp = ginode(dirp->d_ino);
                        if ((n = reply("REMOVE")) == 1)
                                break;
                        dp = ginode(dirp->d_ino);

-                       statemap[dirp->d_ino] = DIRCT(dp) ? DSTATE : FSTATE;
+                       statemap[dirp->d_ino] =
+                           (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
+                       lncntp[dirp->d_ino] = dp->di_nlink;

                        goto again;
 
                case DFOUND:
                        goto again;
 
                case DFOUND: