X-Git-Url: https://git.wh0rd.org/?p=dump.git;a=blobdiff_plain;f=dump%2Ftraverse.c;h=0a394aea1c304c3ab4ee66125639fb87ee2341b2;hp=a49434bdd50943ab9ee95353933132c4308fe9de;hb=7af2fada292acbfb50d441c4be192690dff40283;hpb=109e9e1d1a904627eeae4d519a0f694795b2892c diff --git a/dump/traverse.c b/dump/traverse.c index a49434b..0a394ae 100644 --- a/dump/traverse.c +++ b/dump/traverse.c @@ -2,8 +2,8 @@ * Ported to Linux's Second Extended File System as part of the * dump and restore backup suit * Remy Card , 1994-1997 - * Stelian Pop , 1999-2000 - * Stelian Pop - Alcôve , 2000 + * Stelian Pop , 1999-2000 + * Stelian Pop - Alcôve , 2000-2002 */ /*- @@ -18,11 +18,7 @@ * 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. * @@ -41,20 +37,32 @@ #ifndef lint static const char rcsid[] = - "$Id: traverse.c,v 1.23 2000/12/04 15:43:16 stelian Exp $"; + "$Id: traverse.c,v 1.70 2010/06/10 12:01:30 stelian Exp $"; #endif /* not lint */ +#include +#include +#include +#include +#ifdef __STDC__ +#include +#include +#endif +#include + #include #include #ifdef __linux__ +#ifdef HAVE_EXT2FS_EXT2_FS_H +#include +#else #include +#endif +#include #include #include #include -#define swab32(x) ext2fs_swab32(x) -#else /* __linux__ */ -#define swab32(x) x -#ifdef sunos +#elif defined sunos #include #include @@ -64,22 +72,10 @@ static const char rcsid[] = #include #include #include -#endif #endif /* __linux__ */ #include -#include -#include -#ifdef __STDC__ -#include -#include -#endif - -#ifdef __linux__ -#include -#endif - #include "dump.h" #define HASDUMPEDFILE 0x1 @@ -99,42 +95,84 @@ 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, long *tapesize, int *dirskipped)); -static int exclude_ino __P((ino_t ino)); +static void mapfileino __P((dump_ino_t ino, struct dinode const *dp, long long *tapesize, int *dirskipped)); +static void dump_xattr __P((dump_ino_t ino, struct dinode *dp)); -/* #define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 */ -#ifdef EXT3_FEATURE_INCOMPAT_RECOVER -#define FORCE_OPEN EXT2_FLAG_FORCE +#ifdef HAVE_EXT2_JOURNAL_INUM +#define ext2_journal_ino(sb) (sb->s_journal_inum) #else -#define FORCE_OPEN 0 +#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 +#define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004 +#endif +#ifndef EXT2_FEATURE_INCOMPAT_FILETYPE +#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002 +#endif +#ifndef EXT3_FEATURE_INCOMPAT_RECOVER +#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 +#endif +#ifndef EXT3_FEATURE_INCOMPAT_JOURNAL_DEV +#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 +#endif + +#ifndef EXT2_LIB_FEATURE_INCOMPAT_SUPP +#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) { int retval; - struct ext2fs_sb *s; - retval = ext2fs_open(disk, FORCE_OPEN, 0, 0, unix_io_manager, fs); -#if defined(EXT2_LIB_FEATURE_COMPAT_SUPP) && defined(EXT2_LIB_FEATURE_INCOMPAT_SUPP) && defined(EXT2_LIB_FEATURE_RO_COMPAT_SUPP) && defined(EXT2_ET_UNSUPP_FEATURE) && defined(EXT2_ET_RO_UNSUPP_FEATURE) + retval = ext2fs_open(disk, EXT2_FLAG_FORCE, 0, 0, unix_io_manager, fs); if (!retval) { - s = (struct ext2fs_sb *) (*fs)->super; - if ((s->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) || -#ifdef EXT3_FEATURE_INCOMPAT_RECOVER - (s->s_feature_incompat & ~(EXT3_FEATURE_INCOMPAT_RECOVER | EXT2_LIB_FEATURE_INCOMPAT_SUPP))) { -#else - (s->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) { -#endif + struct ext2_super_block *es = (*fs)->super; + dump_ino_t journal_ino = ext2_journal_ino(es); + + if (es->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV){ + 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))) { + msg("Unsupported feature(s) 0x%x in filesystem\n", + retval); retval = EXT2_ET_UNSUPP_FEATURE; + ext2fs_close(*fs); } - else if (s->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) { - retval = EXT2_ET_RO_UNSUPP_FEATURE; + else { + if (es->s_feature_compat & + EXT3_FEATURE_COMPAT_HAS_JOURNAL && + journal_ino) + do_exclude_ino(journal_ino, "journal inode"); + do_exclude_ino(EXT2_RESIZE_INO, "resize inode"); } } -#endif /* defined && defined && defined... */ return retval; } @@ -146,9 +184,10 @@ int dump_fs_open(const char *disk, ext2_filsys *fs) * hence the estimate may be high. */ long -blockest(struct dinode *dp) +blockest(struct dinode const *dp) { long blkest, sizeest; + u_quad_t i_size; /* * dp->di_size is the size of the file in bytes. @@ -164,19 +203,28 @@ blockest(struct dinode *dp) * dump blocks (sizeest vs. blkest in the indirect block * calculation). */ - blkest = howmany(dbtob(dp->di_blocks), TP_BSIZE); - sizeest = howmany(dp->di_size, 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, fs->blocksize) * (fs->blocksize / TP_BSIZE); if (blkest > sizeest) blkest = sizeest; #ifdef __linux__ - if (dp->di_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 (dp->di_size > sblock->fs_bsize * NDADDR) { + if (i_size > sblock->fs_bsize * NDADDR) { /* calculate the number of indirect blocks on the dump tape */ blkest += howmany(sizeest - NDADDR * sblock->fs_bsize / TP_BSIZE, @@ -186,28 +234,13 @@ blockest(struct dinode *dp) return (blkest + 1); } -extern ino_t iexclude_list[IEXCLUDE_MAXNUM]; /* the inode exclude list */ -extern int iexclude_num; /* number of elements in the list */ - -/* - * 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 @@ -218,25 +251,26 @@ 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))) /* - * Determine if given inode should be dumped + * Determine if given inode should be dumped. "dp" must either point to a + * copy of the given inode, or be NULL (in which case it is fetched.) */ -void -mapfileino(ino_t ino, long *tapesize, int *dirskipped) +static void +mapfileino(dump_ino_t ino, struct dinode const *dp, long long *tapesize, int *dirskipped) { - register int mode; - register struct dinode *dp; + int mode; /* * Skip inode if we've already marked it for dumping */ if (TSTINO(ino, usedinomap)) return; - dp = getino(ino); + if (!dp) + dp = getino(ino); if ((mode = (dp->di_mode & IFMT)) == 0) return; #ifdef __linux__ @@ -250,10 +284,15 @@ mapfileino(ino_t ino, long *tapesize, int *dirskipped) */ SETINO(ino, usedinomap); + if (NODUMP_FLAG(dp)) + do_exclude_ino(ino, "nodump attribute"); + if (mode == IFDIR) 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 @@ -261,7 +300,7 @@ mapfileino(ino_t ino, long *tapesize, int *dirskipped) return; } if (mode == IFDIR) { - if ( NODUMP_FLAG(dp) || exclude_ino(ino) ) + if (exclude_ino(ino)) CLRINO(ino, usedinomap); *dirskipped = 1; } @@ -274,10 +313,55 @@ mapfileino(ino_t ino, long *tapesize, int *dirskipped) * that have been modified since the previous dump time. Also, find all * the directories in the filesystem. */ +#ifdef __linux__ +int +mapfiles(UNUSED(dump_ino_t maxino), long long *tapesize) +{ + ext2_ino_t ino; + int anydirskipped = 0; + ext2_inode_scan scan; + errcode_t err; + struct ext2_inode inode; + + /* + * We use libext2fs's inode scanning routines, which are particularly + * robust. (Note that getino cannot return an error.) + */ + err = ext2fs_open_inode_scan(fs, 0, &scan); + if (err) { + com_err(disk, err, "while opening inodes\n"); + exit(X_ABORT); + } + for (;;) { + err = ext2fs_get_next_inode(scan, &ino, &inode); + if (err == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) + continue; + if (err) { + com_err(disk, err, "while scanning inode #%ld\n", + (long)ino); + exit(X_ABORT); + } + if (ino == 0) + break; + + curino = ino; + mapfileino(ino, (struct dinode const *)&inode, tapesize, + &anydirskipped); + } + ext2fs_close_inode_scan(scan); + + /* + * Restore gets very upset if the root is not dumped, + * so ensure that it always is dumped. + */ + SETINO(ROOTINO, dumpinomap); + return (anydirskipped); +} +#else int -mapfiles(ino_t maxino, long *tapesize) +mapfiles(dump_ino_t maxino, long long *tapesize) { - register ino_t ino; + dump_ino_t ino; int anydirskipped = 0; for (ino = ROOTINO; ino < maxino; ino++) @@ -290,28 +374,78 @@ mapfiles(ino_t maxino, long *tapesize) SETINO(ROOTINO, dumpinomap); return (anydirskipped); } +#endif /* __linux__ */ + +#ifdef __linux__ +int +maponefile(UNUSED(dump_ino_t maxino), long 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; + long long *tapesize; int *anydirskipped; }; 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 *dp; - register int mode; + struct dinode const *dp; + int mode; errcode_t retval; struct mapfile_context *mfc; - ino_t ino; + ext2_ino_t ino; ino = dirent->inode; mfc = (struct mapfile_context *)private; + dp = getino(dirent->inode); - mapfileino(dirent->inode, mfc->tapesize, mfc->anydirskipped); + mapfileino(dirent->inode, dp, mfc->tapesize, mfc->anydirskipped); - dp = getino(dirent->inode); mode = dp->di_mode & IFMT; if (mode == IFDIR && dp->di_nlink != 0 && dp->di_dtime == 0) { if ((dirent->name[0] != '.' || ( dirent->name_len & 0xFF ) != 1) && @@ -334,18 +468,18 @@ 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 long *tapesize, char *directory) { errcode_t retval; struct mapfile_context mfc; - ino_t dir_ino; + 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 < strlen (directory); i++) { + for (i = 0; i < (int)strlen (directory); i++) { if (directory[i] == '/') { strncpy (dir_name, directory, i); dir_name[i] = '\0'; @@ -356,7 +490,7 @@ mapfilesfromdir(ino_t maxino, long *tapesize, char *directory) dir_name); exit(X_ABORT); } - mapfileino(dir_ino, tapesize, &anydirskipped); + mapfileino(dir_ino, 0, tapesize, &anydirskipped); } } /* @@ -367,7 +501,7 @@ mapfilesfromdir(ino_t maxino, long *tapesize, char *directory) com_err(disk, retval, "while translating %s", directory); exit(X_ABORT); } - mapfileino(dir_ino, tapesize, &anydirskipped); + mapfileino(dir_ino, 0, tapesize, &anydirskipped); mfc.tapesize = tapesize; mfc.anydirskipped = &anydirskipped; @@ -382,7 +516,7 @@ mapfilesfromdir(ino_t maxino, long *tapesize, char *directory) * Ensure that the root inode actually appears in the file list * for a subdir */ - mapfileino(ROOTINO, tapesize, &anydirskipped); + mapfileino(ROOTINO, 0, tapesize, &anydirskipped); /* * Restore gets very upset if the root is not dumped, * so ensure that it always is dumped. @@ -396,7 +530,7 @@ mapfilesfromdir(ino_t maxino, long *tapesize, char *directory) struct mapdirs_context { int *ret; int nodump; - long *tapesize; + long long *tapesize; }; #endif @@ -413,14 +547,14 @@ struct mapdirs_context { * pass using this algorithm. */ int -mapdirs(ino_t maxino, long *tapesize) +mapdirs(dump_ino_t maxino, long 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; @@ -440,9 +574,10 @@ mapdirs(ino_t maxino, long *tapesize) * in usedinomap, but we have to go through it anyway * to propagate the nodump attribute. */ + if ((isdir & 1) == 0) + continue; nodump = (TSTINO(ino, usedinomap) == 0); - if ((isdir & 1) == 0 || - (TSTINO(ino, dumpinomap) && nodump == 0)) + if (TSTINO(ino, dumpinomap) && nodump == 0) continue; dp = getino(ino); #ifdef __linux__ @@ -496,10 +631,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); @@ -533,11 +668,12 @@ 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; - long *tapesize; + long long *tapesize; struct dinode *ip; mdc = (struct mapdirs_context *)private; @@ -556,12 +692,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 { @@ -582,10 +719,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); @@ -624,7 +761,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; @@ -635,13 +772,12 @@ struct block_context { * Dump a block to the tape */ static int -dumponeblock(ext2_filsys fs, blk_t *blocknr, int blockcnt, 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; p = (struct block_context *)private; for (i = p->next_block; i < blockcnt; i++) { p->buf[p->cnt++] = 0; @@ -660,23 +796,94 @@ dumponeblock(ext2_filsys fs, blk_t *blocknr, int blockcnt, void *private) } #endif +static void +dump_xattr(dump_ino_t ino, struct dinode *dp) { + + if (dp->di_extraisize != 0) { +#ifdef HAVE_EXT2FS_READ_INODE_FULL + char inode[EXT2_INODE_SIZE(fs->super)]; + errcode_t err; + u_int32_t *magic; + + memset(inode, 0, EXT2_INODE_SIZE(fs->super)); + err = ext2fs_read_inode_full(fs, (ext2_ino_t)ino, + (struct ext2_inode *) inode, + EXT2_INODE_SIZE(fs->super)); + if (err) { + com_err(disk, err, "while reading inode #%ld\n", (long)ino); + exit(X_ABORT); + } + + magic = (void *)inode + EXT2_GOOD_OLD_INODE_SIZE + dp->di_extraisize; + if (*magic == EXT2_XATTR_MAGIC) { + char xattr[EXT2_INODE_SIZE(fs->super)]; + int i; + char *cp; + + if (vflag) + msg("dumping EA (inode) in inode #%ld\n", (long)ino); + memset(xattr, 0, EXT2_INODE_SIZE(fs->super)); + memcpy(xattr, (void *)magic, + EXT2_INODE_SIZE(fs->super) - + (EXT2_GOOD_OLD_INODE_SIZE + dp->di_extraisize)); + magic = (u_int32_t *)xattr; + *magic = EXT2_XATTR_MAGIC2; + + spcl.c_type = TS_INODE; + spcl.c_dinode.di_size = EXT2_INODE_SIZE(fs->super); + spcl.c_flags |= DR_EXTATTRIBUTES; + spcl.c_extattributes = EXT_XATTR; + spcl.c_count = howmany(EXT2_INODE_SIZE(fs->super), TP_BSIZE); + for (i = 0; i < spcl.c_count; i++) + spcl.c_addr[i] = 1; + writeheader(ino); + for (i = 0, cp = xattr; i < spcl.c_count; i++, cp += TP_BSIZE) + writerec(cp, 0); + spcl.c_flags &= ~DR_EXTATTRIBUTES; + spcl.c_extattributes = 0; + } +#endif + } + + if (dp->di_file_acl) { + + if (vflag) + msg("dumping EA (block) in inode #%ld\n", (long)ino); + + spcl.c_type = TS_INODE; + spcl.c_dinode.di_size = sblock->fs_bsize; + spcl.c_flags |= DR_EXTATTRIBUTES; + spcl.c_extattributes = EXT_XATTR; + blksout(&dp->di_file_acl, EXT2_FRAGS_PER_BLOCK(fs->super), ino); + spcl.c_flags &= ~DR_EXTATTRIBUTES; + spcl.c_extattributes = 0; + } +} + /* * Dump passes 3 and 4. * * 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) { - int cnt; - fsizeT size; + unsigned long cnt; + 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; + + if (metaonly) + i_size = 0; + else + i_size = dp->di_size + ((u_quad_t) dp->di_size_high << 32); if (newtape) { newtape = 0; @@ -684,27 +891,37 @@ 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 = (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)); - if (dp->di_file_acl || dp->di_dir_acl) - warn("ACLs in inode #%ld won't be dumped", (long)ino); - memmove(&spcl.c_dinode, &obi, sizeof(obi)); + 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; + 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; + dump_xattr(ino, dp); + return; + } + switch (dp->di_mode & S_IFMT) { case 0: @@ -724,14 +941,15 @@ dumpino(struct dinode *dp, ino_t ino) * Check for short symbolic link. */ #ifdef __linux__ - if (dp->di_size > 0 && - dp->di_size < EXT2_N_BLOCKS * sizeof (daddr_t)) { + if (i_size > 0 && + i_size < EXT2_N_BLOCKS * sizeof (daddr_t)) { spcl.c_addr[0] = 1; spcl.c_count = 1; writeheader(ino); memmove(buf, dp->di_db, (u_long)dp->di_size); buf[dp->di_size] = '\0'; writerec(buf, 0); + dump_xattr(ino, dp); return; } #endif /* __linux__ */ @@ -753,7 +971,7 @@ dumpino(struct dinode *dp, ino_t ino) case S_IFDIR: #endif case S_IFREG: - if (dp->di_size > 0) + if (i_size) break; /* fall through */ @@ -762,23 +980,13 @@ dumpino(struct dinode *dp, ino_t ino) case S_IFCHR: case S_IFBLK: writeheader(ino); + dump_xattr(ino, dp); return; default: msg("Warning: undefined file type 0%o\n", dp->di_mode & IFMT); return; } - if (dp->di_size > NDADDR * sblock->fs_bsize) -#ifdef __linux__ - cnt = NDADDR * EXT2_FRAGS_PER_BLOCK(fs->super); -#else - cnt = NDADDR * sblock->fs_frag; -#endif - else - cnt = howmany(dp->di_size, sblock->fs_fsize); - blksout(&dp->di_db[0], cnt, ino); - if ((size = dp->di_size - NDADDR * sblock->fs_bsize) <= 0) - return; #ifdef __linux__ bc.max = NINDIR(sblock) * EXT2_FRAGS_PER_BLOCK(fs->super); bc.buf = (int *)malloc (bc.max * sizeof (int)); @@ -786,12 +994,33 @@ dumpino(struct dinode *dp, ino_t ino) bc.ino = ino; bc.next_block = NDADDR; - ext2fs_block_iterate (fs, ino, 0, NULL, dumponeblock, (void *)&bc); + ext2fs_block_iterate2(fs, (ext2_ino_t)ino, BLOCK_FLAG_DATA_ONLY, 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); } free(bc.buf); + dump_xattr(ino, dp); #else + if (i_size > (u_quad_t)NDADDR * sblock->fs_bsize) + cnt = NDADDR * sblock->fs_frag; + else + cnt = howmany(i_size, sblock->fs_fsize); + blksout(&dp->di_db[0], cnt, ino); + if ((quad_t) (size = i_size - NDADDR * sblock->fs_bsize) <= 0) { + dump_xattr(ino, dp); + return; + } for (ind_level = 0; ind_level < NIADDR; ind_level++) { dmpindir(ino, dp->di_ib[ind_level], ind_level, &size); if (size <= 0) @@ -816,25 +1045,56 @@ 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 (exclude_ino(dirent->inode)) + 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; @@ -849,11 +1109,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; @@ -878,7 +1138,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); @@ -893,22 +1153,22 @@ 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)); - if (dp->di_file_acl || dp->di_dir_acl) - warn("ACLs in inode #%ld won't be dumped", (long)ino); - memmove(&spcl.c_dinode, &obi, sizeof(obi)); + 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; + memmove(&spcl.c_dinode, &nbi, sizeof(nbi)); #else /* __linux__ */ spcl.c_dinode = *dp; #endif /* __linux__ */ @@ -944,6 +1204,7 @@ dumpdirino(struct dinode *dp, ino_t ino) } (void)free(cdc.buf); + dump_xattr(ino, dp); } #endif /* __linux__ */ @@ -952,7 +1213,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__ @@ -970,16 +1231,15 @@ dmpindir(ino_t ino, daddr_t blk, int ind_level, fsizeT *size) */ #if defined(EXT2_FLAG_SWAP_BYTES) if ((fs->flags & EXT2_FLAG_SWAP_BYTES) || - (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)) { + (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)) #endif + { max = sblock->fs_bsize >> 2; swapme = (blk_t *) idblk; for (i = 0; i < max; i++, swapme++) - *swapme = swab32(*swapme); -#if defined(EXT2_FLAG_SWAP_BYTES) + *swapme = ext2fs_swab32(*swapme); } -#endif -#endif +#endif /* __linux__ */ else memset(idblk, 0, (int)sblock->fs_bsize); if (ind_level <= 0) { @@ -1008,9 +1268,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); @@ -1044,67 +1304,78 @@ 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) +#define int32_t __s32 +#endif + +/* + * Compute and fill in checksum information. */ void -writeheader(ino_t ino) +mkchecksum(union u_spcl *tmpspcl) { -#ifdef __linux__ - register __s32 sum, cnt, *lp; -#else - register int32_t sum, cnt, *lp; -#endif + int32_t sum, cnt, *lp; - spcl.c_inumber = ino; - spcl.c_magic = NFS_MAGIC; - spcl.c_checksum = 0; -#ifdef __linux__ - lp = (__s32 *)&spcl; -#else - lp = (int32_t *)&spcl; -#endif + tmpspcl->s_spcl.c_checksum = 0; + lp = (int32_t *)&tmpspcl->s_spcl; sum = 0; -#ifdef __linux__ - cnt = sizeof(union u_spcl) / (4 * sizeof(__s32)); -#else cnt = sizeof(union u_spcl) / (4 * sizeof(int32_t)); -#endif while (--cnt >= 0) { sum += *lp++; sum += *lp++; 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; - ext2fs_read_inode(fs, inum, (struct ext2_inode *) &dinode); +#ifdef HAVE_EXT2FS_READ_INODE_FULL + err = ext2fs_read_inode_full(fs, (ext2_ino_t)inum, (struct ext2_inode *) &dinode, sizeof(struct dinode)); +#else + err = ext2fs_read_inode(fs, (ext2_ino_t)inum, (struct ext2_inode *) &dinode); +#endif + if (err) { + com_err(disk, err, "while reading inode #%ld\n", (long)inum); + exit(X_ABORT); + } return &dinode; } #else /* __linux__ */ struct dinode * -getino(ino_t inum) +getino(dump_ino_t inum) { static daddr_t minino, maxino; static struct dinode inoblock[MAXINOPB]; @@ -1127,18 +1398,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)) @@ -1161,14 +1430,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?")){ @@ -1183,8 +1453,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)) @@ -1193,11 +1463,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); } }