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
33
#include <sys/types.h>
35
#include "ext2fs/ext2_fs.h"
36
#include "ext2fs/ext2fs.h"
37
#include "et/com_err.h"
38
#include "uuid/uuid.h"
40
#include "ext2fs/e2image.h"
42
#include "../version.h"
43
#include "nls-enable.h"
45
const char * program_name = "e2image";
46
char * device_name = NULL;
48
static void usage(void)
50
fprintf(stderr, _("Usage: %s [-r] device file\n"), program_name);
54
static void write_header(int fd, struct ext2_image_hdr *hdr, int blocksize)
59
header_buf = malloc(blocksize);
61
fprintf(stderr, _("Couldn't allocate header buffer\n"));
65
if (lseek(fd, 0, SEEK_SET) < 0) {
66
perror("lseek while writing header");
69
memset(header_buf, 0, blocksize);
72
memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr));
74
actual = write(fd, header_buf, blocksize);
76
perror("write header");
79
if (actual != blocksize) {
80
fprintf(stderr, _("short write (only %d bytes) for"
81
"writing image header"), actual);
87
static void write_image_file(ext2_filsys fs, int fd)
89
struct ext2_image_hdr hdr;
93
write_header(fd, NULL, fs->blocksize);
94
memset(&hdr, 0, sizeof(struct ext2_image_hdr));
96
hdr.offset_super = lseek(fd, 0, SEEK_CUR);
97
retval = ext2fs_image_super_write(fs, fd, 0);
99
com_err(program_name, retval, _("while writing superblock"));
103
hdr.offset_inode = lseek(fd, 0, SEEK_CUR);
104
retval = ext2fs_image_inode_write(fs, fd,
105
(fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
107
com_err(program_name, retval, _("while writing inode table"));
111
hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR);
112
retval = ext2fs_image_bitmap_write(fs, fd, 0);
114
com_err(program_name, retval, _("while writing block bitmap"));
118
hdr.offset_inodemap = lseek(fd, 0, SEEK_CUR);
119
retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
121
com_err(program_name, retval, _("while writing inode bitmap"));
125
hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
126
strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
127
gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
128
strncat(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name));
129
hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
130
hdr.fs_blocksize = fs->blocksize;
132
if (stat(device_name, &st) == 0)
133
hdr.fs_device = st.st_rdev;
135
if (fstat(fd, &st) == 0) {
136
hdr.image_device = st.st_dev;
137
hdr.image_inode = st.st_ino;
139
memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
141
hdr.image_time = time(0);
142
write_header(fd, &hdr, fs->blocksize);
146
* These set of functions are used to write a RAW image file.
148
ext2fs_block_bitmap meta_block_map;
150
struct process_block_struct {
155
* These subroutines short circuits ext2fs_get_blocks and
156
* ext2fs_check_directory; we use them since we already have the inode
157
* structure, so there's no point in letting the ext2fs library read
160
static ino_t stashed_ino = 0;
161
static struct ext2_inode *stashed_inode;
163
static errcode_t meta_get_blocks(ext2_filsys fs, ext2_ino_t ino,
168
if ((ino != stashed_ino) || !stashed_inode)
169
return EXT2_ET_CALLBACK_NOTHANDLED;
171
for (i=0; i < EXT2_N_BLOCKS; i++)
172
blocks[i] = stashed_inode->i_block[i];
176
static errcode_t meta_check_directory(ext2_filsys fs, ext2_ino_t ino)
178
if ((ino != stashed_ino) || !stashed_inode)
179
return EXT2_ET_CALLBACK_NOTHANDLED;
181
if (!LINUX_S_ISDIR(stashed_inode->i_mode))
182
return EXT2_ET_NO_DIRECTORY;
186
static errcode_t meta_read_inode(ext2_filsys fs, ext2_ino_t ino,
187
struct ext2_inode *inode)
189
if ((ino != stashed_ino) || !stashed_inode)
190
return EXT2_ET_CALLBACK_NOTHANDLED;
191
*inode = *stashed_inode;
195
static void use_inode_shortcuts(ext2_filsys fs, int bool)
198
fs->get_blocks = meta_get_blocks;
199
fs->check_directory = meta_check_directory;
200
fs->read_inode = meta_read_inode;
204
fs->check_directory = 0;
209
static int process_dir_block(ext2_filsys fs, blk_t *block_nr,
210
e2_blkcnt_t blockcnt, blk_t ref_block,
211
int ref_offset, void *priv_data)
213
ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
217
static int process_file_block(ext2_filsys fs, blk_t *block_nr,
218
e2_blkcnt_t blockcnt, blk_t ref_block,
219
int ref_offset, void *priv_data)
222
ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
227
static void mark_table_blocks(ext2_filsys fs)
232
block = fs->super->s_first_data_block;
234
* Mark primary superblock
236
ext2fs_mark_block_bitmap(meta_block_map, block);
239
* Mark the primary superblock descriptors
241
for (j = 0; j < fs->desc_blocks; j++) {
242
ext2fs_mark_block_bitmap(meta_block_map,
246
for (i = 0; i < fs->group_desc_count; i++) {
248
* Mark the blocks used for the inode table
250
if (fs->group_desc[i].bg_inode_table) {
251
for (j = 0, b = fs->group_desc[i].bg_inode_table;
252
j < fs->inode_blocks_per_group;
254
ext2fs_mark_block_bitmap(meta_block_map, b);
258
* Mark block used for the block bitmap
260
if (fs->group_desc[i].bg_block_bitmap) {
261
ext2fs_mark_block_bitmap(meta_block_map,
262
fs->group_desc[i].bg_block_bitmap);
266
* Mark block used for the inode bitmap
268
if (fs->group_desc[i].bg_inode_bitmap) {
269
ext2fs_mark_block_bitmap(meta_block_map,
270
fs->group_desc[i].bg_inode_bitmap);
272
block += fs->super->s_blocks_per_group;
277
* This function returns 1 if the specified block is all zeros
279
static int check_zero_block(char *buf, int blocksize)
282
int left = blocksize;
292
static void write_block(int fd, char *buf, int sparse_offset,
293
int blocksize, blk_t block)
300
if (lseek64(fd, sparse_offset, SEEK_CUR) < 0)
303
if (lseek(fd, sparse_offset, SEEK_CUR) < 0)
308
count = write(fd, buf, blocksize);
309
if (count != blocksize) {
314
com_err(program_name, err, "error writing block %d",
320
static void output_meta_data_blocks(ext2_filsys fs, int fd)
324
char buf[8192], zero_buf[8192];
327
memset(zero_buf, 0, sizeof(zero_buf));
328
for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
329
if ((blk >= fs->super->s_first_data_block) &&
330
ext2fs_test_block_bitmap(meta_block_map, blk)) {
331
retval = io_channel_read_blk(fs->io, blk, 1, buf);
333
com_err(program_name, retval,
334
"error reading block %d", blk);
336
if ((fd != 1) && check_zero_block(buf, fs->blocksize))
338
write_block(fd, buf, sparse, fs->blocksize, blk);
343
write_block(fd, zero_buf, 0,
347
sparse += fs->blocksize;
348
if (sparse >= 1024*1024) {
349
write_block(fd, 0, sparse, 0, 0);
354
write_block(fd, zero_buf, sparse, 1, -1);
357
static void write_raw_image_file(ext2_filsys fs, int fd)
359
struct process_block_struct pb;
360
struct ext2_inode inode;
361
ext2_inode_scan scan;
366
retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
369
com_err(program_name, retval, "while allocating block bitmap");
373
mark_table_blocks(fs);
375
retval = ext2fs_open_inode_scan(fs, 0, &scan);
377
com_err(program_name, retval, _("while opening inode scan"));
381
block_buf = malloc(fs->blocksize * 3);
383
com_err(program_name, 0, "Can't allocate block buffer");
387
use_inode_shortcuts(fs, 1);
388
stashed_inode = &inode;
390
retval = ext2fs_get_next_inode(scan, &ino, &inode);
392
com_err(program_name, retval,
393
_("while getting next inode"));
398
if (!inode.i_links_count ||
399
!ext2fs_inode_has_valid_blocks(&inode))
403
if (LINUX_S_ISDIR(inode.i_mode) ||
404
ino == fs->super->s_journal_inum) {
405
retval = ext2fs_block_iterate2(fs, ino, 0,
406
block_buf, process_dir_block, &pb);
408
com_err(program_name, retval,
409
"while iterating over inode %d",
414
if (inode.i_block[EXT2_IND_BLOCK] ||
415
inode.i_block[EXT2_DIND_BLOCK] ||
416
inode.i_block[EXT2_TIND_BLOCK]) {
417
retval = ext2fs_block_iterate2(fs,
419
process_file_block, &pb);
421
com_err(program_name, retval,
422
"while iterating over %d", ino);
426
if (inode.i_file_acl) {
427
ext2fs_mark_block_bitmap(meta_block_map,
432
use_inode_shortcuts(fs, 0);
433
output_meta_data_blocks(fs, fd);
436
int main (int argc, char ** argv)
447
setlocale(LC_MESSAGES, "");
448
setlocale(LC_CTYPE, "");
449
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
450
textdomain(NLS_CAT_NAME);
452
fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION,
455
program_name = *argv;
456
initialize_ext2_error_table();
457
while ((c = getopt (argc, argv, "r")) != EOF)
465
if (optind != argc - 2 )
467
device_name = argv[optind];
468
outfn = argv[optind+1];
469
retval = ext2fs_open (device_name, open_flag, 0, 0,
470
unix_io_manager, &fs);
472
com_err (program_name, retval, _("while trying to open %s"),
474
printf(_("Couldn't find valid filesystem superblock.\n"));
478
if (strcmp(outfn, "-") == 0)
482
fd = open64(outfn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
484
fd = open(outfn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
487
com_err(program_name, errno,
488
_("while trying to open %s"), argv[optind+1]);
494
write_raw_image_file(fs, fd);
496
write_image_file(fs, fd);