e2image.c revision df200fffd5276d3c8ba201fd61858ba906b77cf6 
1/*
2 * e2image.c --- Program which writes an image file backing up
3 * critical metadata for the filesystem.
4 *
5 * Copyright 2000, 2001 by Theodore Ts'o.
6 *
7 * %Begin-Header%
8 * This file may be redistributed under the terms of the GNU Public
9 * License.
10 * %End-Header%
11 */
12
13#define _LARGEFILE_SOURCE
14#define _LARGEFILE64_SOURCE
15
16#include <fcntl.h>
17#include <grp.h>
18#ifdef HAVE_GETOPT_H
19#include <getopt.h>
20#else
21extern char *optarg;
22extern int optind;
23#endif
24#include <pwd.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <time.h>
29#include <unistd.h>
30#include <fcntl.h>
31#include <errno.h>
32#include <sys/stat.h>
33#include <sys/types.h>
34
35#include "ext2fs/ext2_fs.h"
36#include "ext2fs/ext2fs.h"
37#include "et/com_err.h"
38#include "uuid/uuid.h"
39#include "e2p/e2p.h"
40#include "ext2fs/e2image.h"
41
42#include "../version.h"
43#include "nls-enable.h"
44
45const char * program_name = "e2image";
46char * device_name = NULL;
47
48static void usage(void)
49{
50	fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"),
51		program_name);
52	exit (1);
53}
54
55static void write_header(int fd, struct ext2_image_hdr *hdr, int blocksize)
56{
57	char *header_buf;
58	int actual;
59
60	header_buf = malloc(blocksize);
61	if (!header_buf) {
62		fputs(_("Couldn't allocate header buffer\n"), stderr);
63		exit(1);
64	}
65
66	if (lseek(fd, 0, SEEK_SET) < 0) {
67		perror("lseek while writing header");
68		exit(1);
69	}
70	memset(header_buf, 0, blocksize);
71
72	if (hdr)
73		memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr));
74
75	actual = write(fd, header_buf, blocksize);
76	if (actual < 0) {
77		perror("write header");
78		exit(1);
79	}
80	if (actual != blocksize) {
81		fprintf(stderr, _("short write (only %d bytes) for "
82				  "writing image header"), actual);
83		exit(1);
84	}
85	free(header_buf);
86}
87
88static void write_image_file(ext2_filsys fs, int fd)
89{
90	struct ext2_image_hdr	hdr;
91	struct stat		st;
92	errcode_t		retval;
93
94	write_header(fd, NULL, fs->blocksize);
95	memset(&hdr, 0, sizeof(struct ext2_image_hdr));
96
97	hdr.offset_super = lseek(fd, 0, SEEK_CUR);
98	retval = ext2fs_image_super_write(fs, fd, 0);
99	if (retval) {
100		com_err(program_name, retval, _("while writing superblock"));
101		exit(1);
102	}
103
104	hdr.offset_inode = lseek(fd, 0, SEEK_CUR);
105	retval = ext2fs_image_inode_write(fs, fd,
106				  (fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
107	if (retval) {
108		com_err(program_name, retval, _("while writing inode table"));
109		exit(1);
110	}
111
112	hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR);
113	retval = ext2fs_image_bitmap_write(fs, fd, 0);
114	if (retval) {
115		com_err(program_name, retval, _("while writing block bitmap"));
116		exit(1);
117	}
118
119	hdr.offset_inodemap = lseek(fd, 0, SEEK_CUR);
120	retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
121	if (retval) {
122		com_err(program_name, retval, _("while writing inode bitmap"));
123		exit(1);
124	}
125
126	hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
127	strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
128	gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
129	strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
130	hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
131	hdr.fs_blocksize = fs->blocksize;
132
133	if (stat(device_name, &st) == 0)
134		hdr.fs_device = st.st_rdev;
135
136	if (fstat(fd, &st) == 0) {
137		hdr.image_device = st.st_dev;
138		hdr.image_inode = st.st_ino;
139	}
140	memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
141
142	hdr.image_time = time(0);
143	write_header(fd, &hdr, fs->blocksize);
144}
145
146/*
147 * These set of functions are used to write a RAW image file.
148 */
149ext2fs_block_bitmap meta_block_map;
150ext2fs_block_bitmap scramble_block_map;	/* Directory blocks to be scrambled */
151
152struct process_block_struct {
153	ext2_ino_t	ino;
154	int		is_dir;
155};
156
157/*
158 * These subroutines short circuits ext2fs_get_blocks and
159 * ext2fs_check_directory; we use them since we already have the inode
160 * structure, so there's no point in letting the ext2fs library read
161 * the inode again.
162 */
163static ino_t stashed_ino = 0;
164static struct ext2_inode *stashed_inode;
165
166static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
167				 ext2_ino_t ino,
168				 blk_t *blocks)
169{
170	int	i;
171
172	if ((ino != stashed_ino) || !stashed_inode)
173		return EXT2_ET_CALLBACK_NOTHANDLED;
174
175	for (i=0; i < EXT2_N_BLOCKS; i++)
176		blocks[i] = stashed_inode->i_block[i];
177	return 0;
178}
179
180static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
181				      ext2_ino_t ino)
182{
183	if ((ino != stashed_ino) || !stashed_inode)
184		return EXT2_ET_CALLBACK_NOTHANDLED;
185
186	if (!LINUX_S_ISDIR(stashed_inode->i_mode))
187		return EXT2_ET_NO_DIRECTORY;
188	return 0;
189}
190
191static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
192				 ext2_ino_t ino,
193				 struct ext2_inode *inode)
194{
195	if ((ino != stashed_ino) || !stashed_inode)
196		return EXT2_ET_CALLBACK_NOTHANDLED;
197	*inode = *stashed_inode;
198	return 0;
199}
200
201static void use_inode_shortcuts(ext2_filsys fs, int bool)
202{
203	if (bool) {
204		fs->get_blocks = meta_get_blocks;
205		fs->check_directory = meta_check_directory;
206		fs->read_inode = meta_read_inode;
207		stashed_ino = 0;
208	} else {
209		fs->get_blocks = 0;
210		fs->check_directory = 0;
211		fs->read_inode = 0;
212	}
213}
214
215static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
216			     blk_t *block_nr,
217			     e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
218			     blk_t ref_block EXT2FS_ATTR((unused)),
219			     int ref_offset EXT2FS_ATTR((unused)),
220			     void *priv_data EXT2FS_ATTR((unused)))
221{
222	struct process_block_struct *p;
223
224	p = (struct process_block_struct *) priv_data;
225
226	ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
227	if (scramble_block_map && p->is_dir && blockcnt >= 0)
228		ext2fs_mark_block_bitmap(scramble_block_map, *block_nr);
229	return 0;
230}
231
232static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
233			      blk_t *block_nr,
234			      e2_blkcnt_t blockcnt,
235			      blk_t ref_block EXT2FS_ATTR((unused)),
236			      int ref_offset EXT2FS_ATTR((unused)),
237			      void *priv_data EXT2FS_ATTR((unused)))
238{
239	if (blockcnt < 0) {
240		ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
241	}
242	return 0;
243}
244
245static void mark_table_blocks(ext2_filsys fs)
246{
247	blk_t	first_block, b;
248	unsigned int	i,j;
249
250	first_block = fs->super->s_first_data_block;
251	/*
252	 * Mark primary superblock
253	 */
254	ext2fs_mark_block_bitmap(meta_block_map, first_block);
255
256	/*
257	 * Mark the primary superblock descriptors
258	 */
259	for (j = 0; j < fs->desc_blocks; j++) {
260		ext2fs_mark_block_bitmap(meta_block_map,
261			 ext2fs_descriptor_block_loc(fs, first_block, j));
262	}
263
264	for (i = 0; i < fs->group_desc_count; i++) {
265		/*
266		 * Mark the blocks used for the inode table
267		 */
268		if (fs->group_desc[i].bg_inode_table) {
269			for (j = 0, b = fs->group_desc[i].bg_inode_table;
270			     j < (unsigned) fs->inode_blocks_per_group;
271			     j++, b++)
272				ext2fs_mark_block_bitmap(meta_block_map, b);
273		}
274
275		/*
276		 * Mark block used for the block bitmap
277		 */
278		if (fs->group_desc[i].bg_block_bitmap) {
279			ext2fs_mark_block_bitmap(meta_block_map,
280				     fs->group_desc[i].bg_block_bitmap);
281		}
282
283		/*
284		 * Mark block used for the inode bitmap
285		 */
286		if (fs->group_desc[i].bg_inode_bitmap) {
287			ext2fs_mark_block_bitmap(meta_block_map,
288				 fs->group_desc[i].bg_inode_bitmap);
289		}
290	}
291}
292
293/*
294 * This function returns 1 if the specified block is all zeros
295 */
296static int check_zero_block(char *buf, int blocksize)
297{
298	char	*cp = buf;
299	int	left = blocksize;
300
301	while (left > 0) {
302		if (*cp++)
303			return 0;
304		left--;
305	}
306	return 1;
307}
308
309static void write_block(int fd, char *buf, int sparse_offset,
310			int blocksize, blk_t block)
311{
312	int		count;
313	errcode_t	err;
314
315	if (sparse_offset) {
316#ifdef HAVE_LSEEK64
317		if (lseek64(fd, sparse_offset, SEEK_CUR) < 0)
318			perror("lseek");
319#else
320		if (lseek(fd, sparse_offset, SEEK_CUR) < 0)
321			perror("lseek");
322#endif
323	}
324	if (blocksize) {
325		count = write(fd, buf, blocksize);
326		if (count != blocksize) {
327			if (count == -1)
328				err = errno;
329			else
330				err = 0;
331			com_err(program_name, err, "error writing block %u",
332				block);
333			exit(1);
334		}
335	}
336}
337
338int name_id[256];
339
340static void scramble_dir_block(ext2_filsys fs, blk_t blk, char *buf)
341{
342	char *p, *end, *cp;
343	struct ext2_dir_entry_2 *dirent;
344	int rec_len, id, len;
345
346	end = buf + fs->blocksize;
347	for (p = buf; p < end-8; p += rec_len) {
348		dirent = (struct ext2_dir_entry_2 *) p;
349		rec_len = dirent->rec_len;
350#ifdef EXT2FS_ENABLE_SWAPFS
351		if (fs->flags & EXT2_FLAG_SWAP_BYTES)
352			rec_len = ext2fs_swab16(rec_len);
353#endif
354#if 0
355		printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len);
356#endif
357		if (rec_len < 8 || (rec_len % 4) ||
358		    (p+rec_len > end)) {
359			printf("Corrupt directory block %lu: "
360			       "bad rec_len (%d)\n", (unsigned long) blk,
361			       rec_len);
362			rec_len = end - p;
363#ifdef EXT2FS_ENABLE_SWAPFS
364			if (fs->flags & EXT2_FLAG_SWAP_BYTES)
365				dirent->rec_len = ext2fs_swab16(rec_len);
366#endif
367			continue;
368		}
369		if (dirent->name_len + 8 > rec_len) {
370			printf("Corrupt directory block %lu: "
371			       "bad name_len (%d)\n", (unsigned long) blk,
372			       dirent->name_len);
373			dirent->name_len = rec_len - 8;
374			continue;
375		}
376		cp = p+8;
377		len = rec_len - dirent->name_len - 8;
378		if (len > 0)
379			memset(cp+dirent->name_len, 0, len);
380		if (dirent->name_len==1 && cp[0] == '.')
381			continue;
382		if (dirent->name_len==2 && cp[0] == '.' && cp[1] == '.')
383			continue;
384
385		memset(cp, 'A', dirent->name_len);
386		len = dirent->name_len;
387		id = name_id[len]++;
388		while ((len > 0) && (id > 0)) {
389			*cp += id % 26;
390			id = id / 26;
391			cp++;
392			len--;
393		}
394	}
395}
396
397static void output_meta_data_blocks(ext2_filsys fs, int fd)
398{
399	errcode_t	retval;
400	blk_t		blk;
401	char		*buf, *zero_buf;
402	int		sparse = 0;
403
404	buf = malloc(fs->blocksize);
405	if (!buf) {
406		com_err(program_name, ENOMEM, "while allocating buffer");
407		exit(1);
408	}
409	zero_buf = malloc(fs->blocksize);
410	if (!zero_buf) {
411		com_err(program_name, ENOMEM, "while allocating buffer");
412		exit(1);
413	}
414	memset(zero_buf, 0, fs->blocksize);
415	for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
416		if ((blk >= fs->super->s_first_data_block) &&
417		    ext2fs_test_block_bitmap(meta_block_map, blk)) {
418			retval = io_channel_read_blk(fs->io, blk, 1, buf);
419			if (retval) {
420				com_err(program_name, retval,
421					"error reading block %u", blk);
422			}
423			if (scramble_block_map &&
424			    ext2fs_test_block_bitmap(scramble_block_map, blk))
425				scramble_dir_block(fs, blk, buf);
426			if ((fd != 1) && check_zero_block(buf, fs->blocksize))
427				goto sparse_write;
428			write_block(fd, buf, sparse, fs->blocksize, blk);
429			sparse = 0;
430		} else {
431		sparse_write:
432			if (fd == 1) {
433				write_block(fd, zero_buf, 0,
434					    fs->blocksize, blk);
435				continue;
436			}
437			sparse += fs->blocksize;
438			if (sparse >= 1024*1024) {
439				write_block(fd, 0, sparse, 0, 0);
440				sparse = 0;
441			}
442		}
443	}
444	if (sparse)
445		write_block(fd, zero_buf, sparse-1, 1, -1);
446	free(zero_buf);
447	free(buf);
448}
449
450static void write_raw_image_file(ext2_filsys fs, int fd, int scramble_flag)
451{
452	struct process_block_struct	pb;
453	struct ext2_inode		inode;
454	ext2_inode_scan			scan;
455	ext2_ino_t			ino;
456	errcode_t			retval;
457	char *				block_buf;
458
459	retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
460					      &meta_block_map);
461	if (retval) {
462		com_err(program_name, retval, "while allocating block bitmap");
463		exit(1);
464	}
465
466	if (scramble_flag) {
467		retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
468						      &scramble_block_map);
469		if (retval) {
470			com_err(program_name, retval,
471				"while allocating scramble block bitmap");
472			exit(1);
473		}
474	}
475
476	mark_table_blocks(fs);
477
478	retval = ext2fs_open_inode_scan(fs, 0, &scan);
479	if (retval) {
480		com_err(program_name, retval, _("while opening inode scan"));
481		exit(1);
482	}
483
484	block_buf = malloc(fs->blocksize * 3);
485	if (!block_buf) {
486		com_err(program_name, 0, "Can't allocate block buffer");
487		exit(1);
488	}
489
490	use_inode_shortcuts(fs, 1);
491	stashed_inode = &inode;
492	while (1) {
493		retval = ext2fs_get_next_inode(scan, &ino, &inode);
494		if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
495			continue;
496		if (retval) {
497			com_err(program_name, retval,
498				_("while getting next inode"));
499			exit(1);
500		}
501		if (ino == 0)
502			break;
503		if (!inode.i_links_count)
504			continue;
505		if (inode.i_file_acl) {
506			ext2fs_mark_block_bitmap(meta_block_map,
507						 inode.i_file_acl);
508		}
509		if (!ext2fs_inode_has_valid_blocks(&inode))
510			continue;
511
512		stashed_ino = ino;
513		pb.ino = ino;
514		pb.is_dir = LINUX_S_ISDIR(inode.i_mode);
515		if (LINUX_S_ISDIR(inode.i_mode) ||
516		    (LINUX_S_ISLNK(inode.i_mode) &&
517		     ext2fs_inode_has_valid_blocks(&inode)) ||
518		    ino == fs->super->s_journal_inum) {
519			retval = ext2fs_block_iterate2(fs, ino, 0,
520				       block_buf, process_dir_block, &pb);
521			if (retval) {
522				com_err(program_name, retval,
523					"while iterating over inode %u",
524					ino);
525				exit(1);
526			}
527		} else {
528			if (inode.i_block[EXT2_IND_BLOCK] ||
529			    inode.i_block[EXT2_DIND_BLOCK] ||
530			    inode.i_block[EXT2_TIND_BLOCK]) {
531				retval = ext2fs_block_iterate2(fs,
532				       ino, 0, block_buf,
533				       process_file_block, &pb);
534				if (retval) {
535					com_err(program_name, retval,
536					"while iterating over inode %u", ino);
537					exit(1);
538				}
539			}
540		}
541	}
542	use_inode_shortcuts(fs, 0);
543	output_meta_data_blocks(fs, fd);
544	free(block_buf);
545}
546
547static void install_image(char *device, char *image_fn, int raw_flag)
548{
549	errcode_t retval;
550	ext2_filsys fs;
551	int open_flag = EXT2_FLAG_IMAGE_FILE;
552	int fd = 0;
553	io_manager	io_ptr;
554	io_channel	io, image_io;
555
556	if (raw_flag) {
557		com_err(program_name, 0, "Raw images cannot be installed");
558		exit(1);
559	}
560
561#ifdef CONFIG_TESTIO_DEBUG
562	io_ptr = test_io_manager;
563	test_io_backing_manager = unix_io_manager;
564#else
565	io_ptr = unix_io_manager;
566#endif
567
568	retval = ext2fs_open (image_fn, open_flag, 0, 0,
569			      io_ptr, &fs);
570        if (retval) {
571		com_err (program_name, retval, _("while trying to open %s"),
572			 image_fn);
573		exit(1);
574	}
575
576	retval = ext2fs_read_bitmaps (fs);
577	if (retval) {
578		com_err(program_name, retval, "error reading bitmaps");
579		exit(1);
580	}
581
582
583	fd = open(image_fn, O_RDONLY);
584	if (fd < 0) {
585		perror(image_fn);
586		exit(1);
587	}
588
589	retval = io_ptr->open(device, IO_FLAG_RW, &io);
590	if (retval) {
591		com_err(device, 0, "while opening device file");
592		exit(1);
593	}
594
595	image_io = fs->io;
596
597	ext2fs_rewrite_to_io(fs, io);
598
599	if (lseek(fd, fs->image_header->offset_inode, SEEK_SET) < 0) {
600		perror("lseek");
601		exit(1);
602	}
603
604	retval = ext2fs_image_inode_read(fs, fd, 0);
605	if (retval) {
606		com_err(image_fn, 0, "while restoring the image table");
607		exit(1);
608	}
609
610	ext2fs_close (fs);
611	exit (0);
612}
613
614int main (int argc, char ** argv)
615{
616	int c;
617	errcode_t retval;
618	ext2_filsys fs;
619	char *image_fn;
620	int open_flag = 0;
621	int raw_flag = 0;
622	int install_flag = 0;
623	int scramble_flag = 0;
624	int fd = 0;
625
626#ifdef ENABLE_NLS
627	setlocale(LC_MESSAGES, "");
628	setlocale(LC_CTYPE, "");
629	bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
630	textdomain(NLS_CAT_NAME);
631#endif
632	fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION,
633		 E2FSPROGS_DATE);
634	if (argc && *argv)
635		program_name = *argv;
636	add_error_table(&et_ext2_error_table);
637	while ((c = getopt (argc, argv, "rsI")) != EOF)
638		switch (c) {
639		case 'r':
640			raw_flag++;
641			break;
642		case 's':
643			scramble_flag++;
644			break;
645		case 'I':
646			install_flag++;
647			break;
648		default:
649			usage();
650		}
651	if (optind != argc - 2 )
652		usage();
653	device_name = argv[optind];
654	image_fn = argv[optind+1];
655
656	if (install_flag) {
657		install_image(device_name, image_fn, raw_flag);
658		exit (0);
659	}
660
661	retval = ext2fs_open (device_name, open_flag, 0, 0,
662			      unix_io_manager, &fs);
663        if (retval) {
664		com_err (program_name, retval, _("while trying to open %s"),
665			 device_name);
666		fputs(_("Couldn't find valid filesystem superblock.\n"), stdout);
667		exit(1);
668	}
669
670	if (strcmp(image_fn, "-") == 0)
671		fd = 1;
672	else {
673#ifdef HAVE_OPEN64
674		fd = open64(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
675#else
676		fd = open(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
677#endif
678		if (fd < 0) {
679			com_err(program_name, errno,
680				_("while trying to open %s"), argv[optind+1]);
681			exit(1);
682		}
683	}
684
685	if (raw_flag)
686		write_raw_image_file(fs, fd, scramble_flag);
687	else
688		write_image_file(fs, fd);
689
690	ext2fs_close (fs);
691	remove_error_table(&et_ext2_error_table);
692	exit (0);
693}
694