]> git.wh0rd.org - dump.git/blobdiff - dump/traverse.c
Be sure the di_size in a map header has the correct value.
[dump.git] / dump / traverse.c
index 3da18d39a628eaa47e4abf9223fd010a9be2bea3..147df5b60e11486f3ce80a0f72fbe2aea274ec96 100644 (file)
@@ -2,8 +2,8 @@
  *     Ported to Linux's Second Extended File System as part of the
  *     dump and restore backup suit
  *     Remy Card <card@Linux.EU.Org>, 1994-1997
- *     Stelian Pop <pop@noos.fr>, 1999-2000
- *     Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
+ *     Stelian Pop <stelian@popies.net>, 1999-2000
+ *     Stelian Pop <stelian@popies.net> - Alcôve <www.alcove.com>, 2000-2002
  */
 
 /*-
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
 
 #ifndef lint
 static const char rcsid[] =
-       "$Id: traverse.c,v 1.27 2001/03/20 09:14:58 stelian Exp $";
+       "$Id: traverse.c,v 1.64 2004/12/15 09:31:49 stelian Exp $";
 #endif /* not lint */
 
 #include <config.h>
 #include <ctype.h>
 #include <stdio.h>
+#include <sys/types.h>
 #ifdef __STDC__
 #include <string.h>
 #include <unistd.h>
 #endif
+#include <errno.h>
 
 #include <sys/param.h>
 #include <sys/stat.h>
 #ifdef __linux__
+#ifdef HAVE_EXT2FS_EXT2_FS_H
+#include <ext2fs/ext2_fs.h>
+#else
 #include <linux/ext2_fs.h>
+#endif
 #include <ext2fs/ext2fs.h>
 #include <bsdcompat.h>
 #include <compaterr.h>
@@ -93,21 +95,19 @@ typedef     long fsizeT;
 static int searchdir __P((struct ext2_dir_entry *dp, int offset,
                           int blocksize, char *buf, void *private));
 #else
-static int dirindir __P((ino_t ino, daddr_t blkno, int level, long *size));
-static void dmpindir __P((ino_t ino, daddr_t blk, int level, fsizeT *size));
-static int searchdir __P((ino_t ino, daddr_t blkno, long size, long filesize));
+static int dirindir __P((dump_ino_t ino, daddr_t blkno, int level, long *size));
+static void dmpindir __P((dump_ino_t ino, daddr_t blk, int level, fsizeT *size));
+static int searchdir __P((dump_ino_t ino, daddr_t blkno, long size, long filesize));
 #endif
-static void mapfileino __P((ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped));
-static int exclude_ino __P((ino_t ino));
-extern ino_t iexclude_list[IEXCLUDE_MAXNUM];   /* the inode exclude list */
-extern int iexclude_num;                       /* number of elements in list */
+static void mapfileino __P((dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped));
 
-/* Temporary fix waiting for Andreas fixes... */
-#ifdef HAS_EXT2FS_EXT2_FS
+#ifdef HAVE_EXT2_JOURNAL_INUM
 #define ext2_journal_ino(sb) (sb->s_journal_inum)
 #else
-#define ext2_ino_t __u32
-#define ext2_journal_ino(sb) (*((__u32 *)sb + 0x38))
+#define ext2_journal_ino(sb) (*((u_int32_t *)sb + 0x38))
+#endif
+#ifndef HAVE_EXT2_INO_T
+typedef ino_t ext2_ino_t;
 #endif
 
 #ifndef EXT3_FEATURE_COMPAT_HAS_JOURNAL
@@ -127,6 +127,20 @@ extern int iexclude_num;                   /* number of elements in list */
 #define EXT2_LIB_FEATURE_INCOMPAT_SUPP (EXT3_FEATURE_INCOMPAT_RECOVER | \
                                        EXT2_FEATURE_INCOMPAT_FILETYPE)
 #endif
+#ifndef EXT2_RESIZE_INO
+#define EXT2_RESIZE_INO                        7
+#endif
+#ifndef EXT2_FT_UNKNOWN
+#define EXT2_FT_UNKNOWN                0
+#define EXT2_FT_REG_FILE       1
+#define EXT2_FT_DIR            2
+#define EXT2_FT_CHRDEV         3
+#define EXT2_FT_BLKDEV         4
+#define EXT2_FT_FIFO           5
+#define EXT2_FT_SOCK           6
+#define EXT2_FT_SYMLINK                7
+#define EXT2_FT_MAX            8
+#endif
 
 int dump_fs_open(const char *disk, ext2_filsys *fs)
 {
@@ -135,28 +149,27 @@ int dump_fs_open(const char *disk, ext2_filsys *fs)
        retval = ext2fs_open(disk, EXT2_FLAG_FORCE, 0, 0, unix_io_manager, fs);
        if (!retval) {
                struct ext2_super_block *es = (*fs)->super;
-               ext2_ino_t journal_ino = ext2_journal_ino(es);
+               dump_ino_t journal_ino = ext2_journal_ino(es);
 
                if (es->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV){
-                       fprintf(stderr, "This an journal, not a filesystem!\n");
+                       msg("This is a journal, not a filesystem!\n");
                        retval = EXT2_ET_UNSUPP_FEATURE;
                        ext2fs_close(*fs);
                }
                else if ((retval = es->s_feature_incompat &
                                        ~(EXT2_LIB_FEATURE_INCOMPAT_SUPP |
                                          EXT3_FEATURE_INCOMPAT_RECOVER))) {
-                       fprintf(stderr,
-                               "Unsupported feature(s) 0x%x in filesystem\n",
+                       msg("Unsupported feature(s) 0x%x in filesystem\n",
                                retval);
                        retval = EXT2_ET_UNSUPP_FEATURE;
                        ext2fs_close(*fs);
                }
-               else if (es->s_feature_compat &
+               else {
+                       if (es->s_feature_compat &
                                EXT3_FEATURE_COMPAT_HAS_JOURNAL && 
-                               journal_ino && !exclude_ino(journal_ino)) {
-                       iexclude_list[iexclude_num++] = journal_ino;
-                       msg("Added ext3 journal inode %d to exclude list\n",
-                           journal_ino);
+                               journal_ino)
+                               do_exclude_ino(journal_ino, "journal inode");
+                       do_exclude_ino(EXT2_RESIZE_INO, "resize inode");
                }
        }
        return retval;
@@ -189,17 +202,25 @@ blockest(struct dinode const *dp)
         *      dump blocks (sizeest vs. blkest in the indirect block
         *      calculation).
         */
-       blkest = howmany((u_quad_t)dp->di_blocks*fs->blocksize, TP_BSIZE);
+       blkest = howmany((u_quad_t)dp->di_blocks * 512, fs->blocksize) * (fs->blocksize / TP_BSIZE);
        i_size = dp->di_size + ((u_quad_t) dp->di_size_high << 32);
-       sizeest = howmany(i_size, TP_BSIZE);
+       sizeest = howmany(i_size, fs->blocksize) * (fs->blocksize / TP_BSIZE);
        if (blkest > sizeest)
                blkest = sizeest;
 #ifdef __linux__
-       if (i_size > fs->blocksize * NDADDR) {
+       if ((dp->di_mode & IFMT) == IFDIR) {
+               /*
+                * for directories, assume only half of space is filled
+                * with entries.  
+                */
+                blkest = blkest / 2;
+                sizeest = sizeest / 2;
+       }
+       if (i_size > (u_quad_t)fs->blocksize * NDADDR) {
                /* calculate the number of indirect blocks on the dump tape */
                blkest +=
                        howmany(sizeest - NDADDR * fs->blocksize / TP_BSIZE,
-                       NINDIR(sblock) * EXT2_FRAGS_PER_BLOCK(fs->super));
+                       TP_NINDIR);
        }
 #else
        if (i_size > sblock->fs_bsize * NDADDR) {
@@ -212,25 +233,13 @@ blockest(struct dinode const *dp)
        return (blkest + 1);
 }
 
-/*
- * This tests whether an inode is in the exclude list 
- */
-int
-exclude_ino(ino_t ino)
-{
-       /* 04-Feb-00 ILC */
-       if (iexclude_num) {     /* if there are inodes in the exclude list */
-               int idx;        /* then check this inode against it */
-               for (idx = 0; idx < iexclude_num; idx++)
-                       if (ino == iexclude_list[idx])
-                               return 1;
-       }
-       return 0;
-}
-
 /* Auxiliary macro to pick up files changed since previous dump. */
+#define CSINCE(dp, t) \
+       ((dp)->di_ctime >= (t))
+#define MSINCE(dp, t) \
+       ((dp)->di_mtime >= (t))
 #define        CHANGEDSINCE(dp, t) \
-       ((dp)->di_mtime >= (t) || (dp)->di_ctime >= (t))
+       (CSINCE(dp, t) || MSINCE(dp, t))
 
 /* The NODUMP_FLAG macro tests if a file has the nodump flag. */
 #ifdef UF_NODUMP
@@ -241,7 +250,7 @@ exclude_ino(ino_t ino)
 
 /* The WANTTODUMP macro decides whether a file should be dumped. */
 #define        WANTTODUMP(dp, ino) \
-       (CHANGEDSINCE(dp, spcl.c_ddate) && \
+       (CHANGEDSINCE(dp, ((u_int32_t)spcl.c_ddate)) && \
         (!NODUMP_FLAG(dp)) && \
         (!exclude_ino(ino)))
 
@@ -250,9 +259,9 @@ exclude_ino(ino_t ino)
  * copy of the given inode, or be NULL (in which case it is fetched.)
  */
 static void
-mapfileino(ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)
+mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)
 {
-       register int mode;
+       int mode;
 
        /*
         * Skip inode if we've already marked it for dumping
@@ -278,6 +287,8 @@ mapfileino(ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)
                SETINO(ino, dumpdirmap);
        if (WANTTODUMP(dp, ino)) {
                SETINO(ino, dumpinomap);
+               if (!MSINCE(dp, (u_int32_t)spcl.c_ddate))
+                       SETINO(ino, metainomap);
                if (mode != IFREG && mode != IFDIR && mode != IFLNK)
                        *tapesize += 1;
                else
@@ -300,7 +311,7 @@ mapfileino(ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)
  */
 #ifdef __linux__
 int
-mapfiles(ino_t maxino, long *tapesize)
+mapfiles(UNUSED(dump_ino_t maxino), long *tapesize)
 {
        ext2_ino_t ino;
        int anydirskipped = 0;
@@ -344,9 +355,9 @@ mapfiles(ino_t maxino, long *tapesize)
 }
 #else
 int
-mapfiles(ino_t maxino, long *tapesize)
+mapfiles(dump_ino_t maxino, long *tapesize)
 {
-       register ino_t ino;
+       dump_ino_t ino;
        int anydirskipped = 0;
 
        for (ino = ROOTINO; ino < maxino; ino++)
@@ -361,6 +372,54 @@ mapfiles(ino_t maxino, long *tapesize)
 }
 #endif /* __linux__ */
 
+#ifdef __linux__
+int
+maponefile(UNUSED(dump_ino_t maxino), long *tapesize, char *directory)
+{
+       errcode_t retval;
+       ext2_ino_t dir_ino;
+       char dir_name [MAXPATHLEN];
+       int i, anydirskipped = 0;
+
+       /*
+        * Mark every directory in the path as being dumped
+        */
+       for (i = 0; i < (int)strlen (directory); i++) {
+               if (directory[i] == '/') {
+                       strncpy (dir_name, directory, i);
+                       dir_name[i] = '\0';
+                       retval = ext2fs_namei(fs, ROOTINO, ROOTINO, 
+                                             dir_name, &dir_ino);
+                       if (retval) {
+                               com_err(disk, retval, 
+                                       "while translating %s", dir_name);
+                               exit(X_ABORT);
+                       }
+                       mapfileino((dump_ino_t) dir_ino, 0,
+                                  tapesize, &anydirskipped);
+               }
+       }
+       /*
+        * Mark the final directory
+        */
+       retval = ext2fs_namei(fs, ROOTINO, ROOTINO, directory, &dir_ino);
+       if (retval) {
+               com_err(disk, retval, "while translating %s", directory);
+               exit(X_ABORT);
+       }
+       mapfileino((dump_ino_t)dir_ino, 0, tapesize, &anydirskipped);
+
+       mapfileino(ROOTINO, 0, tapesize, &anydirskipped);
+
+       /*
+        * Restore gets very upset if the root is not dumped,
+        * so ensure that it always is dumped.
+        */
+       SETINO(ROOTINO, dumpdirmap);
+       return anydirskipped;
+}
+#endif /* __linux__ */
+
 #ifdef __linux__
 struct mapfile_context {
        long *tapesize;
@@ -368,10 +427,11 @@ struct mapfile_context {
 };
 
 static int
-mapfilesindir(struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf, void *private)
+mapfilesindir(struct ext2_dir_entry *dirent, UNUSED(int offset), 
+             UNUSED(int blocksize), UNUSED(char *buf), void *private)
 {
-       register struct dinode const *dp;
-       register int mode;
+       struct dinode const *dp;
+       int mode;
        errcode_t retval;
        struct mapfile_context *mfc;
        ext2_ino_t ino;
@@ -404,7 +464,7 @@ mapfilesindir(struct ext2_dir_entry *dirent, int offset, int blocksize, char *bu
  * the directories in the filesystem.
  */
 int
-mapfilesfromdir(ino_t maxino, long *tapesize, char *directory)
+mapfilesfromdir(UNUSED(dump_ino_t maxino), long *tapesize, char *directory)
 {
        errcode_t retval;
        struct mapfile_context mfc;
@@ -415,7 +475,7 @@ mapfilesfromdir(ino_t maxino, long *tapesize, char *directory)
        /*
         * Mark every directory in the path as being dumped
         */
-       for (i = 0; i < strlen (directory); i++) {
+       for (i = 0; i < (int)strlen (directory); i++) {
                if (directory[i] == '/') {
                        strncpy (dir_name, directory, i);
                        dir_name[i] = '\0';
@@ -483,14 +543,14 @@ struct mapdirs_context {
  * pass using this algorithm.
  */
 int
-mapdirs(ino_t maxino, long *tapesize)
+mapdirs(dump_ino_t maxino, long *tapesize)
 {
-       register struct dinode *dp;
-       register int isdir;
-       register char *map;
-       register ino_t ino;
+       struct  dinode *dp;
+       int isdir;
+       char *map;
+       dump_ino_t ino;
 #ifndef __linux__
-       register int i;
+       int i;
        long filesize;
 #else
        struct mapdirs_context mdc;
@@ -566,10 +626,10 @@ mapdirs(ino_t maxino, long *tapesize)
  * require the directory to be dumped.
  */
 static int
-dirindir(ino_t ino, daddr_t blkno, int ind_level, long *filesize)
+dirindir(dump_ino_t ino, daddr_t blkno, int ind_level, long *filesize)
 {
        int ret = 0;
-       register int i;
+       int i;
        daddr_t idblk[MAXNINDIR];
 
        bread(fsbtodb(sblock, blkno), (char *)idblk, (int)sblock->fs_bsize);
@@ -603,7 +663,8 @@ dirindir(ino_t ino, daddr_t blkno, int ind_level, long *filesize)
  */
 #ifdef __linux__
 static int
-searchdir(struct ext2_dir_entry *dp, int offset, int blocksize, char *buf, void *private)
+searchdir(struct ext2_dir_entry *dp, UNUSED(int offset), 
+         UNUSED(int blocksize), UNUSED(char *buf), void *private)
 {
        struct mapdirs_context *mdc;
        int *ret;
@@ -626,12 +687,13 @@ searchdir(struct ext2_dir_entry *dp, int offset, int blocksize, char *buf, void
                ip = getino(dp->inode);
                if (TSTINO(dp->inode, dumpinomap)) {
                        CLRINO(dp->inode, dumpinomap);
-                       CLRINO(dp->inode, usedinomap);
                        *tapesize -= blockest(ip);
                }
-               /* Add dir back to the dir map, to propagate nodump */
+               /* Add dir back to the dir map and remove from
+                * usedinomap to propagate nodump */
                if ((ip->di_mode & IFMT) == IFDIR) {
                        SETINO(dp->inode, dumpdirmap);
+                       CLRINO(dp->inode, usedinomap);
                        *ret |= HASSUBDIRS;
                }
        } else {
@@ -652,10 +714,10 @@ searchdir(struct ext2_dir_entry *dp, int offset, int blocksize, char *buf, void
 #else  /* __linux__ */
 
 static int
-searchdir(ino_t ino, daddr_t blkno, long size, long filesize)
+searchdir(dump_ino_t ino, daddr_t blkno, long size, long filesize)
 {
-       register struct direct *dp;
-       register long loc, ret = 0;
+       struct direct *dp;
+       long loc, ret = 0;
        char dblk[MAXBSIZE];
 
        bread(fsbtodb(sblock, blkno), dblk, (int)size);
@@ -694,7 +756,7 @@ searchdir(ino_t ino, daddr_t blkno, long size, long filesize)
 #ifdef __linux__
 
 struct block_context {
-       ino_t   ino;
+       ext2_ino_t ino;
        int     *buf;
        int     cnt;
        int     max;
@@ -705,11 +767,11 @@ struct block_context {
  * Dump a block to the tape
  */
 static int
-dumponeblock(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt,
-            blk_t ref_block, int ref_offset, void * private)
+dumponeblock(UNUSED(ext2_filsys fs), blk_t *blocknr, e2_blkcnt_t blockcnt,
+            UNUSED(blk_t ref_block), UNUSED(int ref_offset), void * private)
 {
        struct block_context *p;
-       int i;
+       e2_blkcnt_t i;
 
        if (blockcnt < NDADDR)
                return 0;
@@ -737,18 +799,24 @@ dumponeblock(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt,
  * Dump the contents of an inode to tape.
  */
 void
-dumpino(struct dinode *dp, ino_t ino)
+dumpino(struct dinode *dp, dump_ino_t ino, int metaonly)
 {
        unsigned long cnt;
-       fsizeT size;
+       fsizeT size, remaining;
        char buf[TP_BSIZE];
-       struct old_bsd_inode obi;
+       struct new_bsd_inode nbi;
+       int i;
 #ifdef __linux__
        struct block_context bc;
 #else
        int ind_level;
 #endif
-       u_quad_t i_size = dp->di_size + ((u_quad_t) dp->di_size_high << 32);
+       u_quad_t i_size;
+       
+       if (metaonly)
+               i_size = 0;
+       else 
+               i_size = dp->di_size + ((u_quad_t) dp->di_size_high << 32);
 
        if (newtape) {
                newtape = 0;
@@ -756,27 +824,38 @@ dumpino(struct dinode *dp, ino_t ino)
        }
        CLRINO(ino, dumpinomap);
 #ifdef __linux__
-       memset(&obi, 0, sizeof(obi));
-       obi.di_mode = dp->di_mode;
-       obi.di_uid = dp->di_uid;
-       obi.di_gid = dp->di_gid;
-       obi.di_qsize.v = i_size;
-       obi.di_atime = dp->di_atime;
-       obi.di_mtime = dp->di_mtime;
-       obi.di_ctime = dp->di_ctime;
-       obi.di_nlink = dp->di_nlink;
-       obi.di_blocks = dp->di_blocks;
-       obi.di_flags = dp->di_flags;
-       obi.di_gen = dp->di_gen;
-       memmove(&obi.di_db, &dp->di_db, (NDADDR + NIADDR) * sizeof(daddr_t));
+       memset(&nbi, 0, sizeof(nbi));
+       nbi.di_mode = dp->di_mode;
+       nbi.di_nlink = dp->di_nlink;
+       nbi.di_ouid = dp->di_uid;
+       nbi.di_ogid = dp->di_gid;
+       nbi.di_size = i_size;
+       nbi.di_atime.tv_sec = dp->di_atime;
+       nbi.di_mtime.tv_sec = dp->di_mtime;
+       nbi.di_ctime.tv_sec = dp->di_ctime;
+       memmove(&nbi.di_db, &dp->di_db, (NDADDR + NIADDR) * sizeof(daddr_t));
+       nbi.di_flags = dp->di_flags;
+       nbi.di_blocks = dp->di_blocks;
+       nbi.di_gen = dp->di_gen;
+       nbi.di_uid = (((int32_t)dp->di_uidhigh) << 16) | dp->di_uid;
+       nbi.di_gid = (((int32_t)dp->di_gidhigh) << 16) | dp->di_gid;
        if (dp->di_file_acl)
-               warn("ACLs in inode #%ld won't be dumped", (long)ino);
-       memmove(&spcl.c_dinode, &obi, sizeof(obi));
+               msg("ACLs in inode #%ld won't be dumped\n", (long)ino);
+       memmove(&spcl.c_dinode, &nbi, sizeof(nbi));
 #else  /* __linux__ */
        spcl.c_dinode = *dp;
 #endif /* __linux__ */
        spcl.c_type = TS_INODE;
        spcl.c_count = 0;
+
+       if (metaonly && (dp->di_mode & S_IFMT)) {
+               spcl.c_flags |= DR_METAONLY;
+               spcl.c_count = 0;
+               writeheader(ino);
+               spcl.c_flags &= ~DR_METAONLY;
+               return;
+       }
+
        switch (dp->di_mode & S_IFMT) {
 
        case 0:
@@ -840,7 +919,7 @@ dumpino(struct dinode *dp, ino_t ino)
                msg("Warning: undefined file type 0%o\n", dp->di_mode & IFMT);
                return;
        }
-       if (i_size > NDADDR * sblock->fs_bsize)
+       if (i_size > (u_quad_t)NDADDR * sblock->fs_bsize)
 #ifdef __linux__
                cnt = NDADDR * EXT2_FRAGS_PER_BLOCK(fs->super);
 #else
@@ -858,7 +937,18 @@ dumpino(struct dinode *dp, ino_t ino)
        bc.ino = ino;
        bc.next_block = NDADDR;
 
-       ext2fs_block_iterate2(fs, ino, 0, NULL, dumponeblock, (void *)&bc);
+       ext2fs_block_iterate2(fs, (ext2_ino_t)ino, 0, NULL, dumponeblock, (void *)&bc);
+       /* deal with holes at the end of the inode */
+       if (i_size > ((u_quad_t)bc.next_block) * sblock->fs_fsize) {
+               remaining = i_size - ((u_quad_t)bc.next_block) * sblock->fs_fsize;
+               for (i = 0; i < (int)howmany(remaining, sblock->fs_fsize); i++) {
+                       bc.buf[bc.cnt++] = 0;
+                       if (bc.cnt == bc.max) {
+                               blksout (bc.buf, bc.cnt, bc.ino);
+                               bc.cnt = 0;
+                       }
+               }
+       }
        if (bc.cnt > 0) {
                blksout (bc.buf, bc.cnt, bc.ino);
        }
@@ -888,25 +978,58 @@ struct convert_dir_context {
  * size of the entry, and creates it in a temporary buffer
  */
 static int
-convert_dir(struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf, void *private)
+convert_dir(struct ext2_dir_entry *dirent, UNUSED(int offset), 
+           UNUSED(int blocksize), UNUSED(char *buf), void *private)
 {
        struct convert_dir_context *p;
-       struct olddirect *dp;
+       struct direct *dp;
        int reclen;
 
+       /* do not save entries to excluded inodes */
+       if (TSTINO(dirent->inode, dumpinomap) == 0 &&
+           TSTINO(dirent->inode, dumpdirmap) == 0 &&
+           TSTINO(dirent->inode, usedinomap) == 0)
+               return 0;
+
        p = (struct convert_dir_context *)private;
 
        reclen = EXT2_DIR_REC_LEN((dirent->name_len & 0xFF) + 1);
        if (((p->offset + reclen - 1) / p->bs) != (p->offset / p->bs)) {
-               dp = (struct olddirect *)(p->buf + p->prev_offset);
+               dp = (struct direct *)(p->buf + p->prev_offset);
                dp->d_reclen += p->bs - (p->offset % p->bs);
                p->offset += p->bs - (p->offset % p->bs);
        }
 
-       dp = (struct olddirect *)(p->buf + p->offset);
+       dp = (struct direct *)(p->buf + p->offset);
        dp->d_ino = dirent->inode;
        dp->d_reclen = reclen;
        dp->d_namlen = dirent->name_len & 0xFF;
+       switch ((dirent->name_len & 0xFF00) >> 8) {
+       default:
+               dp->d_type = DT_UNKNOWN;
+               break;
+       case EXT2_FT_REG_FILE:
+               dp->d_type = DT_REG;
+               break;
+       case EXT2_FT_DIR:
+               dp->d_type = DT_DIR;
+               break;
+       case EXT2_FT_CHRDEV:
+               dp->d_type = DT_CHR;
+               break;
+       case EXT2_FT_BLKDEV:
+               dp->d_type = DT_BLK;
+               break;
+       case EXT2_FT_FIFO:
+               dp->d_type = DT_FIFO;
+               break;
+       case EXT2_FT_SOCK:
+               dp->d_type = DT_SOCK;
+               break;
+       case EXT2_FT_SYMLINK:
+               dp->d_type = DT_LNK;
+               break;
+       }
        strncpy(dp->d_name, dirent->name, dp->d_namlen);
        dp->d_name[dp->d_namlen] = '\0';
        p->prev_offset = p->offset;
@@ -921,11 +1044,11 @@ convert_dir(struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf,
  * Dumps a directory to tape after converting it to the BSD format
  */
 void
-dumpdirino(struct dinode *dp, ino_t ino)
+dumpdirino(struct dinode *dp, dump_ino_t ino)
 {
        fsizeT size;
        char buf[TP_BSIZE];
-       struct old_bsd_inode obi;
+       struct new_bsd_inode nbi;
        struct convert_dir_context cdc;
        errcode_t retval;
        struct ext2_dir_entry *de;
@@ -950,7 +1073,7 @@ dumpdirino(struct dinode *dp, ino_t ino)
        cdc.prev_offset = 0;
        cdc.bs = MIN(DIRBLKSIZ, TP_BSIZE);
        /* Do the conversion */
-       retval = ext2fs_dir_iterate(fs, ino, 0, NULL, convert_dir, (void *)&cdc);
+       retval = ext2fs_dir_iterate(fs, (ext2_ino_t)ino, 0, NULL, convert_dir, (void *)&cdc);
        if (retval) {
                com_err(disk, retval, "while converting directory #%ld\n", (long)ino);
                exit(X_ABORT);
@@ -965,22 +1088,24 @@ dumpdirino(struct dinode *dp, ino_t ino)
        dir_size = cdc.offset;
 
 #ifdef __linux__
-       memset(&obi, 0, sizeof(obi));
-       obi.di_mode = dp->di_mode;
-       obi.di_uid = dp->di_uid;
-       obi.di_gid = dp->di_gid;
-       obi.di_qsize.v = dir_size; /* (u_quad_t)dp->di_size; */
-       obi.di_atime = dp->di_atime;
-       obi.di_mtime = dp->di_mtime;
-       obi.di_ctime = dp->di_ctime;
-       obi.di_nlink = dp->di_nlink;
-       obi.di_blocks = dp->di_blocks;
-       obi.di_flags = dp->di_flags;
-       obi.di_gen = dp->di_gen;
-       memmove(&obi.di_db, &dp->di_db, (NDADDR + NIADDR) * sizeof(daddr_t));
+       memset(&nbi, 0, sizeof(nbi));
+       nbi.di_mode = dp->di_mode;
+       nbi.di_nlink = dp->di_nlink;
+       nbi.di_ouid = dp->di_uid;
+       nbi.di_ogid = dp->di_gid;
+       nbi.di_size = dir_size; /* (u_quad_t)dp->di_size; */
+       nbi.di_atime.tv_sec = dp->di_atime;
+       nbi.di_mtime.tv_sec = dp->di_mtime;
+       nbi.di_ctime.tv_sec = dp->di_ctime;
+       memmove(&nbi.di_db, &dp->di_db, (NDADDR + NIADDR) * sizeof(daddr_t));
+       nbi.di_flags = dp->di_flags;
+       nbi.di_blocks = dp->di_blocks;
+       nbi.di_gen = dp->di_gen;
+       nbi.di_uid = (((int32_t)dp->di_uidhigh) << 16) | dp->di_uid;
+       nbi.di_gid = (((int32_t)dp->di_gidhigh) << 16) | dp->di_gid;
        if (dp->di_file_acl)
-               warn("ACLs in inode #%ld won't be dumped", (long)ino);
-       memmove(&spcl.c_dinode, &obi, sizeof(obi));
+               msg("ACLs in inode #%ld won't be dumped\n", (long)ino);
+       memmove(&spcl.c_dinode, &nbi, sizeof(nbi));
 #else  /* __linux__ */
        spcl.c_dinode = *dp;
 #endif /* __linux__ */
@@ -1024,7 +1149,7 @@ dumpdirino(struct dinode *dp, ino_t ino)
  * Read indirect blocks, and pass the data blocks to be dumped.
  */
 static void
-dmpindir(ino_t ino, daddr_t blk, int ind_level, fsizeT *size)
+dmpindir(dump_ino_t ino, daddr_t blk, int ind_level, fsizeT *size)
 {
        int i, cnt;
 #ifdef __linux__
@@ -1079,9 +1204,9 @@ dmpindir(ino_t ino, daddr_t blk, int ind_level, fsizeT *size)
  * Collect up the data into tape record sized buffers and output them.
  */
 void
-blksout(daddr_t *blkp, int frags, ino_t ino)
+blksout(blk_t *blkp, int frags, dump_ino_t ino)
 {
-       register daddr_t *bp;
+       blk_t *bp;
        int i, j, count, blks, tbperdb;
 
        blks = howmany(frags * sblock->fs_fsize, TP_BSIZE);
@@ -1115,33 +1240,33 @@ blksout(daddr_t *blkp, int frags, ino_t ino)
  * Dump a map to the tape.
  */
 void
-dumpmap(char *map, int type, ino_t ino)
+dumpmap(char *map, int type, dump_ino_t ino)
 {
-       register int i;
+       int i;
        char *cp;
 
        spcl.c_type = type;
        spcl.c_count = howmany(mapsize * sizeof(char), TP_BSIZE);
+       spcl.c_dinode.di_size = mapsize;
        writeheader(ino);
        for (i = 0, cp = map; i < spcl.c_count; i++, cp += TP_BSIZE)
                writerec(cp, 0);
 }
 
-/*
- * Write a header record to the dump tape.
- */
-#if defined __linux__ && !defined(int32_t)
+#if defined(__linux__) && !defined(int32_t)
 #define int32_t __s32
 #endif
+
+/* 
+ * Compute and fill in checksum information.
+ */
 void
-writeheader(ino_t ino)
+mkchecksum(union u_spcl *tmpspcl) 
 {
-       register int32_t sum, cnt, *lp;
+       int32_t sum, cnt, *lp;
 
-       spcl.c_inumber = ino;
-       spcl.c_magic = NFS_MAGIC;
-       spcl.c_checksum = 0;
-       lp = (int32_t *)&spcl;
+       tmpspcl->s_spcl.c_checksum = 0;
+       lp = (int32_t *)&tmpspcl->s_spcl;
        sum = 0;
        cnt = sizeof(union u_spcl) / (4 * sizeof(int32_t));
        while (--cnt >= 0) {
@@ -1150,19 +1275,30 @@ writeheader(ino_t ino)
                sum += *lp++;
                sum += *lp++;
        }
-       spcl.c_checksum = CHECKSUM - sum;
+       tmpspcl->s_spcl.c_checksum = CHECKSUM - sum;
+}
+
+/*
+ * Write a header record to the dump tape.
+ */
+void
+writeheader(dump_ino_t ino)
+{
+       spcl.c_inumber = ino;
+       spcl.c_magic = NFS_MAGIC;
+       mkchecksum((union u_spcl *)&spcl);
        writerec((char *)&spcl, 1);
 }
 
 #ifdef __linux__
 struct dinode *
-getino(ino_t inum)
+getino(dump_ino_t inum)
 {
        static struct dinode dinode;
        errcode_t err;
 
        curino = inum;
-       err = ext2fs_read_inode(fs, inum, (struct ext2_inode *) &dinode);
+       err = ext2fs_read_inode(fs, (ext2_ino_t)inum, (struct ext2_inode *) &dinode);
        if (err) {
                com_err(disk, err, "while reading inode #%ld\n", (long)inum);
                exit(X_ABORT);
@@ -1171,7 +1307,7 @@ getino(ino_t inum)
 }
 #else  /* __linux__ */
 struct dinode *
-getino(ino_t inum)
+getino(dump_ino_t inum)
 {
        static daddr_t minino, maxino;
        static struct dinode inoblock[MAXINOPB];
@@ -1194,18 +1330,16 @@ getino(ino_t inum)
  * consent from the operator to continue.
  */
 int    breaderrors = 0;
-#define        BREADEMAX 32
 
 void
-bread(daddr_t blkno, char *buf, int size)
+bread(ext2_loff_t blkno, char *buf, int size)
 {
        int cnt, i;
-       extern int errno;
 
 loop:
 #ifdef __linux__
-       if (ext2fs_llseek(diskfd, (((ext2_loff_t)blkno) << dev_bshift), 0) !=
-                       (((ext2_loff_t)blkno) << dev_bshift))
+       if (ext2fs_llseek(diskfd, (blkno << dev_bshift), 0) !=
+                       (blkno << dev_bshift))
 #else
        if (lseek(diskfd, ((off_t)blkno << dev_bshift), 0) !=
                                                ((off_t)blkno << dev_bshift))
@@ -1228,14 +1362,15 @@ loop:
                goto loop;
        }
        if (cnt == -1)
-               msg("read error from %s: %s: [block %d]: count=%d\n",
-                       disk, strerror(errno), blkno, size);
+               msg("read error from %s: %s: [block %d, ext2blk %d]: count=%d\n",
+                       disk, strerror(errno), blkno, 
+                       dbtofsb(sblock, blkno), size);
        else
-               msg("short read error from %s: [block %d]: count=%d, got=%d\n",
-                       disk, blkno, size, cnt);
-       if (++breaderrors > BREADEMAX) {
+               msg("short read error from %s: [block %d, ext2blk %d]: count=%d, got=%d\n",
+                       disk, blkno, dbtofsb(sblock, blkno), size, cnt);
+       if (breademax && ++breaderrors > breademax) {
                msg("More than %d block read errors from %d\n",
-                       BREADEMAX, disk);
+                       breademax, disk);
                broadcast("DUMP IS AILING!\n");
                msg("This is an unrecoverable error.\n");
                if (!query("Do you want to attempt to continue?")){
@@ -1250,8 +1385,8 @@ loop:
        memset(buf, 0, size);
        for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) {
 #ifdef __linux__
-               if (ext2fs_llseek(diskfd, (((ext2_loff_t)blkno) << dev_bshift), 0) !=
-                               (((ext2_loff_t)blkno) << dev_bshift))
+               if (ext2fs_llseek(diskfd, (blkno << dev_bshift), 0) !=
+                               (blkno << dev_bshift))
 #else
                if (lseek(diskfd, ((off_t)blkno << dev_bshift), 0) !=
                                                ((off_t)blkno << dev_bshift))
@@ -1260,11 +1395,12 @@ loop:
                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",
-                               disk, strerror(errno), blkno, dev_bsize);
+                       msg("read error from %s: %s: [sector %d, ext2blk %d]: count=%d\n",
+                               disk, strerror(errno), blkno, 
+                               dbtofsb(sblock, blkno), dev_bsize);
                        continue;
                }
-               msg("short read error from %s: [sector %d]: count=%d, got=%d\n",
-                       disk, blkno, dev_bsize, cnt);
+               msg("short read error from %s: [sector %d, ext2blk %d]: count=%d, got=%d\n",
+                       disk, blkno, dbtofsb(sblock, blkno), dev_bsize, cnt);
        }
 }