X-Git-Url: https://git.wh0rd.org/?p=dump.git;a=blobdiff_plain;f=dump%2Ftraverse.c;h=6ed1d287f3d572cbb7ec7f08cc4538ba9f36bc9e;hp=6d4f00b3e910219257a3bd44ce6aff3b5997328c;hb=b0e0d7757fe7cdc08be0269f37a7193e07fb1bb3;hpb=a18d599791e977f3e3d26123031e6ed4e64d6d08 diff --git a/dump/traverse.c b/dump/traverse.c index 6d4f00b..6ed1d28 100644 --- a/dump/traverse.c +++ b/dump/traverse.c @@ -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,7 +37,7 @@ #ifndef lint static const char rcsid[] = - "$Id: traverse.c,v 1.49 2002/07/19 14:57:39 stelian Exp $"; + "$Id: traverse.c,v 1.71 2010/06/10 12:17:35 stelian Exp $"; #endif /* not lint */ #include @@ -103,7 +99,8 @@ 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((dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)); +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)); #ifdef HAVE_EXT2_JOURNAL_INUM #define ext2_journal_ino(sb) (sb->s_journal_inum) @@ -134,6 +131,17 @@ typedef ino_t ext2_ino_t; #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) { @@ -195,17 +203,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 ((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) { @@ -224,7 +240,7 @@ blockest(struct dinode const *dp) #define MSINCE(dp, t) \ ((dp)->di_mtime >= (t)) #define CHANGEDSINCE(dp, t) \ - (CSINCE(dp, t) || MSINCE(dp, t)) + CSINCE(dp, t) /* The NODUMP_FLAG macro tests if a file has the nodump flag. */ #ifdef UF_NODUMP @@ -244,7 +260,7 @@ blockest(struct dinode const *dp) * copy of the given inode, or be NULL (in which case it is fetched.) */ static void -mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped) +mapfileino(dump_ino_t ino, struct dinode const *dp, long long *tapesize, int *dirskipped) { int mode; @@ -268,6 +284,9 @@ mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskip */ SETINO(ino, usedinomap); + if (NODUMP_FLAG(dp)) + do_exclude_ino(ino, "nodump attribute"); + if (mode == IFDIR) SETINO(ino, dumpdirmap); if (WANTTODUMP(dp, ino)) { @@ -281,7 +300,7 @@ mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskip return; } if (mode == IFDIR) { - if ( NODUMP_FLAG(dp) || exclude_ino(ino) ) + if (exclude_ino(ino)) CLRINO(ino, usedinomap); *dirskipped = 1; } @@ -296,7 +315,7 @@ mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskip */ #ifdef __linux__ int -mapfiles(UNUSED(dump_ino_t maxino), long *tapesize) +mapfiles(UNUSED(dump_ino_t maxino), long long *tapesize) { ext2_ino_t ino; int anydirskipped = 0; @@ -340,7 +359,7 @@ mapfiles(UNUSED(dump_ino_t maxino), long *tapesize) } #else int -mapfiles(dump_ino_t maxino, long *tapesize) +mapfiles(dump_ino_t maxino, long long *tapesize) { dump_ino_t ino; int anydirskipped = 0; @@ -359,7 +378,7 @@ mapfiles(dump_ino_t maxino, long *tapesize) #ifdef __linux__ int -maponefile(UNUSED(dump_ino_t maxino), long *tapesize, char *directory) +maponefile(UNUSED(dump_ino_t maxino), long long *tapesize, char *directory) { errcode_t retval; ext2_ino_t dir_ino; @@ -407,7 +426,7 @@ maponefile(UNUSED(dump_ino_t maxino), long *tapesize, char *directory) #ifdef __linux__ struct mapfile_context { - long *tapesize; + long long *tapesize; int *anydirskipped; }; @@ -449,7 +468,7 @@ mapfilesindir(struct ext2_dir_entry *dirent, UNUSED(int offset), * the directories in the filesystem. */ int -mapfilesfromdir(UNUSED(dump_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; @@ -511,7 +530,7 @@ mapfilesfromdir(UNUSED(dump_ino_t maxino), long *tapesize, char *directory) struct mapdirs_context { int *ret; int nodump; - long *tapesize; + long long *tapesize; }; #endif @@ -528,7 +547,7 @@ struct mapdirs_context { * pass using this algorithm. */ int -mapdirs(dump_ino_t maxino, long *tapesize) +mapdirs(dump_ino_t maxino, long long *tapesize) { struct dinode *dp; int isdir; @@ -555,9 +574,10 @@ mapdirs(dump_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__ @@ -653,7 +673,7 @@ searchdir(struct ext2_dir_entry *dp, UNUSED(int offset), { struct mapdirs_context *mdc; int *ret; - long *tapesize; + long long *tapesize; struct dinode *ip; mdc = (struct mapdirs_context *)private; @@ -756,10 +776,8 @@ 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; @@ -778,6 +796,70 @@ dumponeblock(UNUSED(ext2_filsys fs), blk_t *blocknr, e2_blkcnt_t blockcnt, } #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. * @@ -824,8 +906,6 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) 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, &nbi, sizeof(nbi)); #else /* __linux__ */ spcl.c_dinode = *dp; @@ -838,6 +918,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) spcl.c_count = 0; writeheader(ino); spcl.c_flags &= ~DR_METAONLY; + dump_xattr(ino, dp); return; } @@ -868,6 +949,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) 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__ */ @@ -898,23 +980,13 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) 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 (i_size > (u_quad_t)NDADDR * sblock->fs_bsize) -#ifdef __linux__ - cnt = NDADDR * EXT2_FRAGS_PER_BLOCK(fs->super); -#else - cnt = NDADDR * sblock->fs_frag; -#endif - 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) - return; #ifdef __linux__ bc.max = NINDIR(sblock) * EXT2_FRAGS_PER_BLOCK(fs->super); bc.buf = (int *)malloc (bc.max * sizeof (int)); @@ -922,7 +994,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) bc.ino = ino; bc.next_block = NDADDR; - ext2fs_block_iterate2(fs, (ext2_ino_t)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; @@ -938,7 +1010,17 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) 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) @@ -970,6 +1052,10 @@ convert_dir(struct ext2_dir_entry *dirent, UNUSED(int offset), 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); @@ -983,6 +1069,32 @@ convert_dir(struct ext2_dir_entry *dirent, UNUSED(int 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; @@ -1056,8 +1168,6 @@ dumpdirino(struct dinode *dp, dump_ino_t ino) 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, &nbi, sizeof(nbi)); #else /* __linux__ */ spcl.c_dinode = *dp; @@ -1094,6 +1204,7 @@ dumpdirino(struct dinode *dp, dump_ino_t ino) } (void)free(cdc.buf); + dump_xattr(ino, dp); } #endif /* __linux__ */ @@ -1157,9 +1268,9 @@ dmpindir(dump_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, dump_ino_t ino) +blksout(blk_t *blkp, int frags, dump_ino_t ino) { - daddr_t *bp; + blk_t *bp; int i, j, count, blks, tbperdb; blks = howmany(frags * sblock->fs_fsize, TP_BSIZE); @@ -1200,12 +1311,13 @@ dumpmap(char *map, int type, dump_ino_t ino) 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); } -#if defined __linux__ && !defined(int32_t) +#if defined(__linux__) && !defined(int32_t) #define int32_t __s32 #endif @@ -1250,7 +1362,11 @@ getino(dump_ino_t inum) errcode_t err; curino = inum; +#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); @@ -1278,20 +1394,20 @@ getino(dump_ino_t inum) /* * Read a chunk of data from the disk. * Try to recover from hard errors by reading in sector sized pieces. - * Error recovery is attempted at most breademax times before seeking + * Error recovery is attempted at most BREADEMAX times before seeking * consent from the operator to continue. */ int breaderrors = 0; void -bread(daddr_t blkno, char *buf, int size) +bread(ext2_loff_t blkno, char *buf, int size) { int cnt, i; 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)) @@ -1320,7 +1436,7 @@ loop: else msg("short read error from %s: [block %d, ext2blk %d]: count=%d, got=%d\n", disk, blkno, dbtofsb(sblock, blkno), size, cnt); - if (++breaderrors > breademax) { + if (breademax && ++breaderrors > breademax) { msg("More than %d block read errors from %d\n", breademax, disk); broadcast("DUMP IS AILING!\n"); @@ -1337,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))