2 * e2image.c --- Program which writes an image file backing up
3 * critical metadata for the filesystem.
5 * Copyright 2000, 2001 by Theodore Ts'o.
8 * This file may be redistributed under the terms of the GNU Public
13 #define _LARGEFILE_SOURCE
14 #define _LARGEFILE64_SOURCE
35 #include <sys/types.h>
37 #include "ext2fs/ext2_fs.h"
38 #include "ext2fs/ext2fs.h"
39 #include "et/com_err.h"
40 #include "uuid/uuid.h"
42 #include "ext2fs/e2image.h"
44 #include "../version.h"
45 #include "nls-enable.h"
47 const char * program_name = "e2image";
48 char * device_name = NULL;
50 static void usage(void)
52 fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"),
57 static void write_header(int fd, struct ext2_image_hdr *hdr, int blocksize)
62 header_buf = malloc(blocksize);
64 fputs(_("Couldn't allocate header buffer\n"), stderr);
68 if (lseek(fd, 0, SEEK_SET) < 0) {
69 perror("lseek while writing header");
72 memset(header_buf, 0, blocksize);
75 memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr));
77 actual = write(fd, header_buf, blocksize);
79 perror("write header");
82 if (actual != blocksize) {
83 fprintf(stderr, _("short write (only %d bytes) for "
84 "writing image header"), actual);
90 static void write_image_file(ext2_filsys fs, int fd)
92 struct ext2_image_hdr hdr;
96 write_header(fd, NULL, fs->blocksize);
97 memset(&hdr, 0, sizeof(struct ext2_image_hdr));
99 hdr.offset_super = lseek(fd, 0, SEEK_CUR);
100 retval = ext2fs_image_super_write(fs, fd, 0);
102 com_err(program_name, retval, _("while writing superblock"));
106 hdr.offset_inode = lseek(fd, 0, SEEK_CUR);
107 retval = ext2fs_image_inode_write(fs, fd,
108 (fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
110 com_err(program_name, retval, _("while writing inode table"));
114 hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR);
115 retval = ext2fs_image_bitmap_write(fs, fd, 0);
117 com_err(program_name, retval, _("while writing block bitmap"));
121 hdr.offset_inodemap = lseek(fd, 0, SEEK_CUR);
122 retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
124 com_err(program_name, retval, _("while writing inode bitmap"));
128 hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
129 strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
130 gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
131 strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
132 hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
133 hdr.fs_blocksize = fs->blocksize;
135 if (stat(device_name, &st) == 0)
136 hdr.fs_device = st.st_rdev;
138 if (fstat(fd, &st) == 0) {
139 hdr.image_device = st.st_dev;
140 hdr.image_inode = st.st_ino;
142 memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
144 hdr.image_time = time(0);
145 write_header(fd, &hdr, fs->blocksize);
149 * These set of functions are used to write a RAW image file.
151 ext2fs_block_bitmap meta_block_map;
152 ext2fs_block_bitmap scramble_block_map; /* Directory blocks to be scrambled */
154 struct process_block_struct {
160 * These subroutines short circuits ext2fs_get_blocks and
161 * ext2fs_check_directory; we use them since we already have the inode
162 * structure, so there's no point in letting the ext2fs library read
165 static ino_t stashed_ino = 0;
166 static struct ext2_inode *stashed_inode;
168 static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
174 if ((ino != stashed_ino) || !stashed_inode)
175 return EXT2_ET_CALLBACK_NOTHANDLED;
177 for (i=0; i < EXT2_N_BLOCKS; i++)
178 blocks[i] = stashed_inode->i_block[i];
182 static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
185 if ((ino != stashed_ino) || !stashed_inode)
186 return EXT2_ET_CALLBACK_NOTHANDLED;
188 if (!LINUX_S_ISDIR(stashed_inode->i_mode))
189 return EXT2_ET_NO_DIRECTORY;
193 static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
195 struct ext2_inode *inode)
197 if ((ino != stashed_ino) || !stashed_inode)
198 return EXT2_ET_CALLBACK_NOTHANDLED;
199 *inode = *stashed_inode;
203 static void use_inode_shortcuts(ext2_filsys fs, int bool)
206 fs->get_blocks = meta_get_blocks;
207 fs->check_directory = meta_check_directory;
208 fs->read_inode = meta_read_inode;
212 fs->check_directory = 0;
217 static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
219 e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
220 blk_t ref_block EXT2FS_ATTR((unused)),
221 int ref_offset EXT2FS_ATTR((unused)),
222 void *priv_data EXT2FS_ATTR((unused)))
224 struct process_block_struct *p;
226 p = (struct process_block_struct *) priv_data;
228 ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
229 if (scramble_block_map && p->is_dir && blockcnt >= 0)
230 ext2fs_mark_block_bitmap(scramble_block_map, *block_nr);
234 static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
236 e2_blkcnt_t blockcnt,
237 blk_t ref_block EXT2FS_ATTR((unused)),
238 int ref_offset EXT2FS_ATTR((unused)),
239 void *priv_data EXT2FS_ATTR((unused)))
242 ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
247 static void mark_table_blocks(ext2_filsys fs)
249 blk_t first_block, b;
252 first_block = fs->super->s_first_data_block;
254 * Mark primary superblock
256 ext2fs_mark_block_bitmap(meta_block_map, first_block);
259 * Mark the primary superblock descriptors
261 for (j = 0; j < fs->desc_blocks; j++) {
262 ext2fs_mark_block_bitmap(meta_block_map,
263 ext2fs_descriptor_block_loc(fs, first_block, j));
266 for (i = 0; i < fs->group_desc_count; i++) {
268 * Mark the blocks used for the inode table
270 if (fs->group_desc[i].bg_inode_table) {
271 for (j = 0, b = fs->group_desc[i].bg_inode_table;
272 j < (unsigned) fs->inode_blocks_per_group;
274 ext2fs_mark_block_bitmap(meta_block_map, b);
278 * Mark block used for the block bitmap
280 if (fs->group_desc[i].bg_block_bitmap) {
281 ext2fs_mark_block_bitmap(meta_block_map,
282 fs->group_desc[i].bg_block_bitmap);
286 * Mark block used for the inode bitmap
288 if (fs->group_desc[i].bg_inode_bitmap) {
289 ext2fs_mark_block_bitmap(meta_block_map,
290 fs->group_desc[i].bg_inode_bitmap);
296 * This function returns 1 if the specified block is all zeros
298 static int check_zero_block(char *buf, int blocksize)
301 int left = blocksize;
311 static void write_block(int fd, char *buf, int sparse_offset,
312 int blocksize, blk_t block)
319 if (lseek64(fd, sparse_offset, SEEK_CUR) < 0)
322 if (lseek(fd, sparse_offset, SEEK_CUR) < 0)
327 count = write(fd, buf, blocksize);
328 if (count != blocksize) {
333 com_err(program_name, err, "error writing block %u",
342 #define EXT4_MAX_REC_LEN ((1<<16)-1)
344 static void scramble_dir_block(ext2_filsys fs, blk_t blk, char *buf)
347 struct ext2_dir_entry_2 *dirent;
348 unsigned int rec_len;
351 end = buf + fs->blocksize;
352 for (p = buf; p < end-8; p += rec_len) {
353 dirent = (struct ext2_dir_entry_2 *) p;
354 rec_len = dirent->rec_len;
355 #ifdef WORDS_BIGENDIAN
356 rec_len = ext2fs_swab16(rec_len);
358 if (rec_len == EXT4_MAX_REC_LEN || rec_len == 0)
359 rec_len = fs->blocksize;
361 rec_len = (rec_len & 65532) | ((rec_len & 3) << 16);
363 printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len);
365 if (rec_len < 8 || (rec_len % 4) ||
367 printf("Corrupt directory block %lu: "
368 "bad rec_len (%d)\n", (unsigned long) blk,
371 (void) ext2fs_set_rec_len(fs, rec_len,
372 (struct ext2_dir_entry *) dirent);
373 #ifdef WORDS_BIGENDIAN
374 dirent->rec_len = ext2fs_swab16(dirent->rec_len);
378 if (dirent->name_len + 8 > rec_len) {
379 printf("Corrupt directory block %lu: "
380 "bad name_len (%d)\n", (unsigned long) blk,
382 dirent->name_len = rec_len - 8;
386 len = rec_len - dirent->name_len - 8;
388 memset(cp+dirent->name_len, 0, len);
389 if (dirent->name_len==1 && cp[0] == '.')
391 if (dirent->name_len==2 && cp[0] == '.' && cp[1] == '.')
394 memset(cp, 'A', dirent->name_len);
395 len = dirent->name_len;
397 while ((len > 0) && (id > 0)) {
406 static void output_meta_data_blocks(ext2_filsys fs, int fd)
410 char *buf, *zero_buf;
413 buf = malloc(fs->blocksize);
415 com_err(program_name, ENOMEM, "while allocating buffer");
418 zero_buf = malloc(fs->blocksize);
420 com_err(program_name, ENOMEM, "while allocating buffer");
423 memset(zero_buf, 0, fs->blocksize);
424 for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
425 if ((blk >= fs->super->s_first_data_block) &&
426 ext2fs_test_block_bitmap(meta_block_map, blk)) {
427 retval = io_channel_read_blk(fs->io, blk, 1, buf);
429 com_err(program_name, retval,
430 "error reading block %u", blk);
432 if (scramble_block_map &&
433 ext2fs_test_block_bitmap(scramble_block_map, blk))
434 scramble_dir_block(fs, blk, buf);
435 if ((fd != 1) && check_zero_block(buf, fs->blocksize))
437 write_block(fd, buf, sparse, fs->blocksize, blk);
442 write_block(fd, zero_buf, 0,
446 sparse += fs->blocksize;
447 if (sparse >= 1024*1024) {
448 write_block(fd, 0, sparse, 0, 0);
454 write_block(fd, zero_buf, sparse-1, 1, -1);
459 static void write_raw_image_file(ext2_filsys fs, int fd, int scramble_flag)
461 struct process_block_struct pb;
462 struct ext2_inode inode;
463 ext2_inode_scan scan;
468 retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
471 com_err(program_name, retval, "while allocating block bitmap");
476 retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
477 &scramble_block_map);
479 com_err(program_name, retval,
480 "while allocating scramble block bitmap");
485 mark_table_blocks(fs);
487 retval = ext2fs_open_inode_scan(fs, 0, &scan);
489 com_err(program_name, retval, _("while opening inode scan"));
493 block_buf = malloc(fs->blocksize * 3);
495 com_err(program_name, 0, "Can't allocate block buffer");
499 use_inode_shortcuts(fs, 1);
500 stashed_inode = &inode;
502 retval = ext2fs_get_next_inode(scan, &ino, &inode);
503 if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
506 com_err(program_name, retval,
507 _("while getting next inode"));
512 if (!inode.i_links_count)
514 if (inode.i_file_acl) {
515 ext2fs_mark_block_bitmap(meta_block_map,
518 if (!ext2fs_inode_has_valid_blocks(&inode))
523 pb.is_dir = LINUX_S_ISDIR(inode.i_mode);
524 if (LINUX_S_ISDIR(inode.i_mode) ||
525 (LINUX_S_ISLNK(inode.i_mode) &&
526 ext2fs_inode_has_valid_blocks(&inode)) ||
527 ino == fs->super->s_journal_inum) {
528 retval = ext2fs_block_iterate2(fs, ino,
529 BLOCK_FLAG_READ_ONLY, block_buf,
530 process_dir_block, &pb);
532 com_err(program_name, retval,
533 "while iterating over inode %u",
538 if ((inode.i_flags & EXT4_EXTENTS_FL) ||
539 inode.i_block[EXT2_IND_BLOCK] ||
540 inode.i_block[EXT2_DIND_BLOCK] ||
541 inode.i_block[EXT2_TIND_BLOCK]) {
542 retval = ext2fs_block_iterate2(fs,
543 ino, BLOCK_FLAG_READ_ONLY, block_buf,
544 process_file_block, &pb);
546 com_err(program_name, retval,
547 "while iterating over inode %u", ino);
553 use_inode_shortcuts(fs, 0);
554 output_meta_data_blocks(fs, fd);
558 static void install_image(char *device, char *image_fn, int raw_flag)
562 int open_flag = EXT2_FLAG_IMAGE_FILE;
565 io_channel io, image_io;
568 com_err(program_name, 0, "Raw images cannot be installed");
572 #ifdef CONFIG_TESTIO_DEBUG
573 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
574 io_ptr = test_io_manager;
575 test_io_backing_manager = unix_io_manager;
578 io_ptr = unix_io_manager;
580 retval = ext2fs_open (image_fn, open_flag, 0, 0,
583 com_err (program_name, retval, _("while trying to open %s"),
588 retval = ext2fs_read_bitmaps (fs);
590 com_err(program_name, retval, "error reading bitmaps");
595 fd = open64(image_fn, O_RDONLY);
597 fd = open(image_fn, O_RDONLY);
604 retval = io_ptr->open(device, IO_FLAG_RW, &io);
606 com_err(device, 0, "while opening device file");
612 ext2fs_rewrite_to_io(fs, io);
614 if (lseek(fd, fs->image_header->offset_inode, SEEK_SET) < 0) {
619 retval = ext2fs_image_inode_read(fs, fd, 0);
621 com_err(image_fn, 0, "while restoring the image table");
629 int main (int argc, char ** argv)
637 int install_flag = 0;
638 int scramble_flag = 0;
642 setlocale(LC_MESSAGES, "");
643 setlocale(LC_CTYPE, "");
644 bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
645 textdomain(NLS_CAT_NAME);
647 fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION,
650 program_name = *argv;
651 add_error_table(&et_ext2_error_table);
652 while ((c = getopt (argc, argv, "rsI")) != EOF)
666 if (optind != argc - 2 )
668 device_name = argv[optind];
669 image_fn = argv[optind+1];
672 install_image(device_name, image_fn, raw_flag);
676 retval = ext2fs_open (device_name, open_flag, 0, 0,
677 unix_io_manager, &fs);
679 com_err (program_name, retval, _("while trying to open %s"),
681 fputs(_("Couldn't find valid filesystem superblock.\n"), stdout);
685 if (strcmp(image_fn, "-") == 0)
689 fd = open64(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
691 fd = open(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
694 com_err(program_name, errno,
695 _("while trying to open %s"), argv[optind+1]);
701 write_raw_image_file(fs, fd, scramble_flag);
703 write_image_file(fs, fd);
706 remove_error_table(&et_ext2_error_table);