static void usage(void)
{
- fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"),
+ fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"),
program_name);
exit (1);
}
exit(1);
}
memset(header_buf, 0, blocksize);
-
+
if (hdr)
memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr));
-
+
actual = write(fd, header_buf, blocksize);
if (actual < 0) {
perror("write header");
com_err(program_name, retval, _("while writing superblock"));
exit(1);
}
-
+
hdr.offset_inode = lseek(fd, 0, SEEK_CUR);
retval = ext2fs_image_inode_write(fs, fd,
(fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
com_err(program_name, retval, _("while writing inode table"));
exit(1);
}
-
+
hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR);
retval = ext2fs_image_bitmap_write(fs, fd, 0);
if (retval) {
hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
- strncat(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name));
+ strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
hdr.fs_blocksize = fs->blocksize;
-
+
if (stat(device_name, &st) == 0)
hdr.fs_device = st.st_rdev;
static ino_t stashed_ino = 0;
static struct ext2_inode *stashed_inode;
-static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
+static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
ext2_ino_t ino,
blk_t *blocks)
{
int i;
-
+
if ((ino != stashed_ino) || !stashed_inode)
return EXT2_ET_CALLBACK_NOTHANDLED;
return 0;
}
-static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
+static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
ext2_ino_t ino)
{
if ((ino != stashed_ino) || !stashed_inode)
return 0;
}
-static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
+static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
ext2_ino_t ino,
struct ext2_inode *inode)
{
}
}
-static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
+static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
blk_t *block_nr,
- e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
+ e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
blk_t ref_block EXT2FS_ATTR((unused)),
- int ref_offset EXT2FS_ATTR((unused)),
+ int ref_offset EXT2FS_ATTR((unused)),
void *priv_data EXT2FS_ATTR((unused)))
{
struct process_block_struct *p;
p = (struct process_block_struct *) priv_data;
ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
- if (scramble_block_map && p->is_dir && blockcnt >= 0)
+ if (scramble_block_map && p->is_dir && blockcnt >= 0)
ext2fs_mark_block_bitmap(scramble_block_map, *block_nr);
return 0;
}
-static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
+static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
blk_t *block_nr,
- e2_blkcnt_t blockcnt,
+ e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
- int ref_offset EXT2FS_ATTR((unused)),
+ int ref_offset EXT2FS_ATTR((unused)),
void *priv_data EXT2FS_ATTR((unused)))
{
if (blockcnt < 0) {
{
blk_t first_block, b;
unsigned int i,j;
-
+
first_block = fs->super->s_first_data_block;
/*
* Mark primary superblock
*/
ext2fs_mark_block_bitmap(meta_block_map, first_block);
-
+
/*
* Mark the primary superblock descriptors
*/
j++, b++)
ext2fs_mark_block_bitmap(meta_block_map, b);
}
-
+
/*
- * Mark block used for the block bitmap
+ * Mark block used for the block bitmap
*/
if (fs->group_desc[i].bg_block_bitmap) {
ext2fs_mark_block_bitmap(meta_block_map,
fs->group_desc[i].bg_block_bitmap);
}
-
+
/*
- * Mark block used for the inode bitmap
+ * Mark block used for the inode bitmap
*/
if (fs->group_desc[i].bg_inode_bitmap) {
ext2fs_mark_block_bitmap(meta_block_map,
err = 0;
com_err(program_name, err, "error writing block %u",
block);
+ exit(1);
}
}
}
for (p = buf; p < end-8; p += rec_len) {
dirent = (struct ext2_dir_entry_2 *) p;
rec_len = dirent->rec_len;
-#ifdef EXT2FS_ENABLE_SWAPFS
- if (fs->flags & EXT2_FLAG_SWAP_BYTES)
- rec_len = ext2fs_swab16(rec_len);
+#ifdef WORDS_BIGENDIAN
+ rec_len = ext2fs_swab16(rec_len);
#endif
+ rec_len = (rec_len || fs->blocksize < 65536) ?
+ rec_len : 65536;
#if 0
printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len);
#endif
if (rec_len < 8 || (rec_len % 4) ||
(p+rec_len > end)) {
printf("Corrupt directory block %lu: "
- "bad rec_len (%d)\n", (unsigned long) blk,
+ "bad rec_len (%d)\n", (unsigned long) blk,
rec_len);
rec_len = end - p;
-#ifdef EXT2FS_ENABLE_SWAPFS
- if (fs->flags & EXT2_FLAG_SWAP_BYTES)
+#ifdef WORDS_BIGENDIAN
dirent->rec_len = ext2fs_swab16(rec_len);
#endif
continue;
}
if (dirent->name_len + 8 > rec_len) {
printf("Corrupt directory block %lu: "
- "bad name_len (%d)\n", (unsigned long) blk,
+ "bad name_len (%d)\n", (unsigned long) blk,
dirent->name_len);
dirent->name_len = rec_len - 8;
continue;
retval = io_channel_read_blk(fs->io, blk, 1, buf);
if (retval) {
com_err(program_name, retval,
- "error reading block %d", blk);
+ "error reading block %u", blk);
}
- if (scramble_block_map &&
+ if (scramble_block_map &&
ext2fs_test_block_bitmap(scramble_block_map, blk))
scramble_dir_block(fs, blk, buf);
if ((fd != 1) && check_zero_block(buf, fs->blocksize))
}
}
}
- write_block(fd, zero_buf, sparse, 1, -1);
+ if (sparse)
+ write_block(fd, zero_buf, sparse-1, 1, -1);
+ free(zero_buf);
+ free(buf);
}
static void write_raw_image_file(ext2_filsys fs, int fd, int scramble_flag)
ext2_ino_t ino;
errcode_t retval;
char * block_buf;
-
+
retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
&meta_block_map);
if (retval) {
retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
&scramble_block_map);
if (retval) {
- com_err(program_name, retval,
+ com_err(program_name, retval,
"while allocating scramble block bitmap");
exit(1);
}
}
-
+
mark_table_blocks(fs);
retval = ext2fs_open_inode_scan(fs, 0, &scan);
com_err(program_name, 0, "Can't allocate block buffer");
exit(1);
}
-
+
use_inode_shortcuts(fs, 1);
stashed_inode = &inode;
while (1) {
}
if (!ext2fs_inode_has_valid_blocks(&inode))
continue;
-
+
stashed_ino = ino;
pb.ino = ino;
pb.is_dir = LINUX_S_ISDIR(inode.i_mode);
(LINUX_S_ISLNK(inode.i_mode) &&
ext2fs_inode_has_valid_blocks(&inode)) ||
ino == fs->super->s_journal_inum) {
- retval = ext2fs_block_iterate2(fs, ino, 0,
- block_buf, process_dir_block, &pb);
+ retval = ext2fs_block_iterate2(fs, ino,
+ BLOCK_FLAG_READ_ONLY, block_buf,
+ process_dir_block, &pb);
if (retval) {
com_err(program_name, retval,
- "while iterating over inode %d",
+ "while iterating over inode %u",
ino);
exit(1);
}
} else {
- if (inode.i_block[EXT2_IND_BLOCK] ||
+ if ((inode.i_flags & EXT4_EXTENTS_FL) ||
+ inode.i_block[EXT2_IND_BLOCK] ||
inode.i_block[EXT2_DIND_BLOCK] ||
inode.i_block[EXT2_TIND_BLOCK]) {
retval = ext2fs_block_iterate2(fs,
- ino, 0, block_buf,
+ ino, BLOCK_FLAG_READ_ONLY, block_buf,
process_file_block, &pb);
if (retval) {
com_err(program_name, retval,
- "while iterating over %d", ino);
+ "while iterating over inode %u", ino);
exit(1);
}
}
}
use_inode_shortcuts(fs, 0);
output_meta_data_blocks(fs, fd);
+ free(block_buf);
}
static void install_image(char *device, char *image_fn, int raw_flag)
com_err(program_name, 0, "Raw images cannot be installed");
exit(1);
}
-
+
#ifdef CONFIG_TESTIO_DEBUG
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
exit(1);
}
-
+#ifdef HAVE_OPEN64
+ fd = open64(image_fn, O_RDONLY);
+#else
fd = open(image_fn, O_RDONLY);
+#endif
if (fd < 0) {
perror(image_fn);
exit(1);
}
- retval = io_ptr->open(device, IO_FLAG_RW, &io);
+ retval = io_ptr->open(device, IO_FLAG_RW, &io);
if (retval) {
com_err(device, 0, "while opening device file");
exit(1);
E2FSPROGS_DATE);
if (argc && *argv)
program_name = *argv;
- initialize_ext2_error_table();
+ add_error_table(&et_ext2_error_table);
while ((c = getopt (argc, argv, "rsI")) != EOF)
switch (c) {
case 'r':
write_image_file(fs, fd);
ext2fs_close (fs);
+ remove_error_table(&et_ext2_error_table);
exit (0);
}
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff