lint; bug fix for missing indirection on parameter; timeval => timespec

SCCS-vsn: sbin/dump/traverse.c 5.18

diff --git a/usr/src/sbin/dump/traverse.c b/usr/src/sbin/dump/traverse.c
index f62292c..6db71b1 100644 (file)
--- a/usr/src/sbin/dump/traverse.c
+++ b/usr/src/sbin/dump/traverse.c
@@ -6,26 +6,22 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)traverse.c 5.17 (Berkeley) %G%";
+static char sccsid[] = "@(#)traverse.c 5.18 (Berkeley) %G%";

 #endif /* not lint */
 
 #ifdef sunos
 #include <stdio.h>
 #include <ctype.h>
 #include <sys/param.h>
 #endif /* not lint */
 
 #ifdef sunos
 #include <stdio.h>
 #include <ctype.h>
 #include <sys/param.h>

-#include <sys/time.h>
-#include <sys/dir.h>
-#include <sys/vnode.h>
-#include <ufs/inode.h>

 #include <ufs/fs.h>
 #else
 #include <sys/param.h>
 #include <ufs/fs.h>
 #else
 #include <sys/param.h>

-#include <sys/time.h>
-#include <ufs/ufs/dir.h>
-#include <ufs/ufs/dinode.h>

 #include <ufs/ffs/fs.h>
 #endif
 #include <ufs/ffs/fs.h>
 #endif

+#include <sys/time.h>

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

+#include <ufs/ufs/dir.h>
+#include <ufs/ufs/dinode.h>

 #include <protocols/dumprestore.h>
 #ifdef __STDC__
 #include <unistd.h>
 #include <protocols/dumprestore.h>
 #ifdef __STDC__
 #include <unistd.h>


@@ -100,9 +96,12 @@ mapfiles(maxino, tapesize)
                SETINO(ino, usedinomap);
                if (mode == IFDIR)
                        SETINO(ino, dumpdirmap);
                SETINO(ino, usedinomap);
                if (mode == IFDIR)
                        SETINO(ino, dumpdirmap);

-               if ((dp->di_mtime.tv_sec >= spcl.c_ddate ||
-                   dp->di_ctime.tv_sec >= spcl.c_ddate) &&
-                   (dp->di_flags & NODUMP) != NODUMP) {
+               if ((dp->di_mtime.ts_sec >= spcl.c_ddate ||
+                   dp->di_ctime.ts_sec >= spcl.c_ddate)
+#ifndef sunos
+                   && (dp->di_flags & NODUMP) != NODUMP
+#endif
+                   ) {

                        SETINO(ino, dumpinomap);
                        if (mode != IFREG && mode != IFDIR && mode != IFLNK) {
                                *tapesize += 1;
                        SETINO(ino, dumpinomap);
                        if (mode != IFREG && mode != IFDIR && mode != IFLNK) {
                                *tapesize += 1;


@@ -142,7 +141,7 @@ mapdirs(maxino, tapesize)
        register int i, dirty;
        register char *map;
        register ino_t ino;
        register int i, dirty;
        register char *map;
        register ino_t ino;

-       long filesize, blkcnt = 0;
+       long filesize;

        int ret, change = 0;
 
        for (map = dumpdirmap, ino = 0; ino < maxino; ) {
        int ret, change = 0;
 
        for (map = dumpdirmap, ino = 0; ino < maxino; ) {


@@ -192,22 +191,23 @@ mapdirs(maxino, tapesize)
  * as directories. Quit as soon as any entry is found that will
  * require the directory to be dumped.
  */
  * as directories. Quit as soon as any entry is found that will
  * require the directory to be dumped.
  */

-dirindir(ino, blkno, level, filesize)
+dirindir(ino, blkno, ind_level, filesize)

        ino_t ino;
        daddr_t blkno;
        ino_t ino;
        daddr_t blkno;

-       int level, *filesize;
+       int ind_level;
+       long *filesize;

 {
        int ret = 0;
        register int i;
        daddr_t idblk[MAXNINDIR];
 
 {
        int ret = 0;
        register int i;
        daddr_t idblk[MAXNINDIR];
 

-       bread(fsbtodb(sblock, blkno), (char *)idblk, sblock->fs_bsize);
-       if (level <= 0) {
+       bread(fsbtodb(sblock, blkno), (char *)idblk, (int)sblock->fs_bsize);
+       if (ind_level <= 0) {

                for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {
                        blkno = idblk[i];
                        if (blkno != 0)
                                ret |= searchdir(ino, blkno, sblock->fs_bsize,
                for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {
                        blkno = idblk[i];
                        if (blkno != 0)
                                ret |= searchdir(ino, blkno, sblock->fs_bsize,

-                                       filesize);
+                                       *filesize);

                        if (ret & HASDUMPEDFILE)
                                *filesize = 0;
                        else
                        if (ret & HASDUMPEDFILE)
                                *filesize = 0;
                        else


@@ -215,11 +215,11 @@ dirindir(ino, blkno, level, filesize)
                }
                return (ret);
        }
                }
                return (ret);
        }

-       level--;
+       ind_level--;

        for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {
                blkno = idblk[i];
                if (blkno != 0)
        for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {
                blkno = idblk[i];
                if (blkno != 0)

-                       ret |= dirindir(ino, blkno, level, filesize);
+                       ret |= dirindir(ino, blkno, ind_level, filesize);

        }
        return (ret);
 }
        }
        return (ret);
 }


@@ -232,14 +232,14 @@ dirindir(ino, blkno, level, filesize)
 searchdir(ino, blkno, size, filesize)
        ino_t ino;
        daddr_t blkno;
 searchdir(ino, blkno, size, filesize)
        ino_t ino;
        daddr_t blkno;

-       register int size;
-       int filesize;
+       register long size;
+       long filesize;

 {
        register struct direct *dp;
        register long loc;
        char dblk[MAXBSIZE];
 
 {
        register struct direct *dp;
        register long loc;
        char dblk[MAXBSIZE];
 

-       bread(fsbtodb(sblock, blkno), dblk, size);
+       bread(fsbtodb(sblock, blkno), dblk, (int)size);

        if (filesize < size)
                size = filesize;
        for (loc = 0; loc < size; ) {
        if (filesize < size)
                size = filesize;
        for (loc = 0; loc < size; ) {


@@ -275,7 +275,7 @@ dumpino(dp, ino)
        register struct dinode *dp;
        ino_t ino;
 {
        register struct dinode *dp;
        ino_t ino;
 {

-       int mode, level, cnt;
+       int mode, ind_level, cnt;

        long size;
 
        if (newtape) {
        long size;
 
        if (newtape) {


@@ -303,8 +303,8 @@ dumpino(dp, ino)
        blksout(&dp->di_db[0], cnt, ino);
        if ((size = dp->di_size - NDADDR * sblock->fs_bsize) <= 0)
                return;
        blksout(&dp->di_db[0], cnt, ino);
        if ((size = dp->di_size - NDADDR * sblock->fs_bsize) <= 0)
                return;

-       for (level = 0; level < NIADDR; level++) {
-               dmpindir(ino, dp->di_ib[level], level, &size);
+       for (ind_level = 0; ind_level < NIADDR; ind_level++) {
+               dmpindir(ino, dp->di_ib[ind_level], ind_level, &size);

                if (size <= 0)
                        return;
        }
                if (size <= 0)
                        return;
        }


@@ -314,20 +314,20 @@ dumpino(dp, ino)
  * Read indirect blocks, and pass the data blocks to be dumped.
  */
 void
  * Read indirect blocks, and pass the data blocks to be dumped.
  */
 void

-dmpindir(ino, blk, level, size)
+dmpindir(ino, blk, ind_level, size)

        ino_t ino;
        daddr_t blk;
        ino_t ino;
        daddr_t blk;

-       int level;
+       int ind_level;

        long *size;
 {
        int i, cnt;
        daddr_t idblk[MAXNINDIR];
 
        if (blk != 0)
        long *size;
 {
        int i, cnt;
        daddr_t idblk[MAXNINDIR];
 
        if (blk != 0)

-               bread(fsbtodb(sblock, blk), (char *)idblk, sblock->fs_bsize);
+               bread(fsbtodb(sblock, blk), (char *)idblk, (int) sblock->fs_bsize);

        else
        else

-               bzero((char *)idblk, sblock->fs_bsize);
-       if (level <= 0) {
+               bzero((char *)idblk, (int)sblock->fs_bsize);
+       if (ind_level <= 0) {

                if (*size < NINDIR(sblock) * sblock->fs_bsize)
                        cnt = howmany(*size, sblock->fs_fsize);
                else
                if (*size < NINDIR(sblock) * sblock->fs_bsize)
                        cnt = howmany(*size, sblock->fs_fsize);
                else


@@ -336,9 +336,9 @@ dmpindir(ino, blk, level, size)
                blksout(&idblk[0], cnt, ino);
                return;
        }
                blksout(&idblk[0], cnt, ino);
                return;
        }

-       level--;
+       ind_level--;

        for (i = 0; i < NINDIR(sblock); i++) {
        for (i = 0; i < NINDIR(sblock); i++) {

-               dmpindir(ino, idblk[i], level, size);
+               dmpindir(ino, idblk[i], ind_level, size);

                if (*size <= 0)
                        return;
        }
                if (*size <= 0)
                        return;
        }


@@ -374,7 +374,7 @@ blksout(blkp, frags, ino)
                for (j = i; j < count; j += tbperdb, bp++)
                        if (*bp != 0)
                                if (j + tbperdb <= count)
                for (j = i; j < count; j += tbperdb, bp++)
                        if (*bp != 0)
                                if (j + tbperdb <= count)

-                                       dumpblock(*bp, sblock->fs_bsize);
+                                       dumpblock(*bp, (int)sblock->fs_bsize);

                                else
                                        dumpblock(*bp, (count - j) * TP_BSIZE);
                spcl.c_type = TS_ADDR;
                                else
                                        dumpblock(*bp, (count - j) * TP_BSIZE);
                spcl.c_type = TS_ADDR;


@@ -435,7 +435,8 @@ getino(inum)
        curino = inum;
        if (inum >= minino && inum < maxino)
                return (&inoblock[inum - minino]);
        curino = inum;
        if (inum >= minino && inum < maxino)
                return (&inoblock[inum - minino]);

-       bread(fsbtodb(sblock, itod(sblock, inum)), inoblock, sblock->fs_bsize);
+       bread(fsbtodb(sblock, itod(sblock, inum)), (char *)inoblock,
+           (int)sblock->fs_bsize);

        minino = inum - (inum % INOPB(sblock));
        maxino = minino + INOPB(sblock);
        return (&inoblock[inum - minino]);
        minino = inum - (inum % INOPB(sblock));
        maxino = minino + INOPB(sblock);
        return (&inoblock[inum - minino]);


@@ -460,7 +461,7 @@ bread(blkno, buf, size)
        extern int errno;
 
 loop:
        extern int errno;
 
 loop:

-       if (lseek(diskfd, (long)(blkno << dev_bshift), 0) < 0)
+       if ((int)lseek(diskfd, ((off_t)blkno << dev_bshift), 0) < 0)

                msg("bread: lseek fails\n");
        if ((cnt = read(diskfd, buf, size)) == size)
                return;
                msg("bread: lseek fails\n");
        if ((cnt = read(diskfd, buf, size)) == size)
                return;


@@ -500,9 +501,9 @@ loop:
         */
        bzero(buf, size);
        for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) {
         */
        bzero(buf, size);
        for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) {

-               if (lseek(diskfd, (long)(blkno << dev_bshift), 0) < 0)
+               if ((int)lseek(diskfd, ((off_t)blkno << dev_bshift), 0) < 0)

                        msg("bread: lseek2 fails!\n");
                        msg("bread: lseek2 fails!\n");

-               if ((cnt = read(diskfd, buf, dev_bsize)) == dev_bsize)
+               if ((cnt = read(diskfd, buf, (int)dev_bsize)) == dev_bsize)

                        continue;
                if (cnt == -1) {
                        msg("read error from %s: %s: [sector %d]: count=%d\n",
                        continue;
                if (cnt == -1) {
                        msg("read error from %s: %s: [sector %d]: count=%d\n",