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