* 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.54 2003/01/10 14:46:55 stelian Exp $";
+ "$Id: traverse.c,v 1.67 2009/06/18 10:00:38 stelian Exp $";
#endif /* not lint */
#include <config.h>
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 dump_xattr __P((dump_ino_t ino, struct dinode *dp));
#ifdef HAVE_EXT2_JOURNAL_INUM
#define ext2_journal_ino(sb) (sb->s_journal_inum)
* dump blocks (sizeest vs. blkest in the indirect block
* calculation).
*/
- blkest = howmany((u_quad_t)dp->di_blocks * 512, 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) {
*/
SETINO(ino, usedinomap);
+ if (NODUMP_FLAG(dp))
+ do_exclude_ino(ino, "nodump attribute");
+
if (mode == IFDIR)
SETINO(ino, dumpdirmap);
if (WANTTODUMP(dp, ino)) {
return;
}
if (mode == IFDIR) {
- if ( NODUMP_FLAG(dp) || exclude_ino(ino) )
+ if (exclude_ino(ino))
CLRINO(ino, usedinomap);
*dirskipped = 1;
}
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;
}
#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);
+ 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.
*
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)
- 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;
spcl.c_count = 0;
writeheader(ino);
spcl.c_flags &= ~DR_METAONLY;
+ dump_xattr(ino, dp);
return;
}
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__ */
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));
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;
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)
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);
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)
- 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;
}
(void)free(cdc.buf);
+ dump_xattr(ino, dp);
}
#endif /* __linux__ */
* 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);
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
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);
/*
* 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))
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))
git.wh0rd.org / dump.git / blobdiff