]> git.ipfire.org Git - thirdparty/e2fsprogs.git/blob - misc/e2image.c
projects / thirdparty / e2fsprogs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'maint' into next
[thirdparty/e2fsprogs.git] / misc / e2image.c
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 "config.h"
17 #include <fcntl.h>
18 #include <grp.h>
19 #ifdef HAVE_GETOPT_H
20 #include <getopt.h>
21 #else
22 extern char *optarg;
23 extern int optind;
24 #endif
25 #include <pwd.h>
26 #include <stdio.h>
27 #ifdef HAVE_STDLIB_H
28 #include <stdlib.h>
29 #endif
30 #include <string.h>
31 #include <time.h>
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <assert.h>
38 #include <signal.h>
39
40 #include "ext2fs/ext2_fs.h"
41 #include "ext2fs/ext2fs.h"
42 #include "et/com_err.h"
43 #include "uuid/uuid.h"
44 #include "e2p/e2p.h"
45 #include "ext2fs/e2image.h"
46 #include "ext2fs/qcow2.h"
47
48 #include "../version.h"
49 #include "nls-enable.h"
50 #include "plausible.h"
51
52 #define QCOW_OFLAG_COPIED (1LL << 63)
53 #define NO_BLK ((blk64_t) -1)
54
55 /* Image types */
56 #define E2IMAGE_RAW 1
57 #define E2IMAGE_QCOW2 2
58
59 /* Image flags */
60 #define E2IMAGE_INSTALL_FLAG 1
61 #define E2IMAGE_SCRAMBLE_FLAG 2
62 #define E2IMAGE_IS_QCOW2_FLAG 4
63 #define E2IMAGE_CHECK_ZERO_FLAG 8
64
65 static const char * program_name = "e2image";
66 static char * device_name = NULL;
67 static char all_data;
68 static char output_is_blk;
69 static char nop_flag;
70 /* writing to blk device: don't skip zeroed blocks */
71 static blk64_t source_offset, dest_offset;
72 static char move_mode;
73 static char show_progress;
74 static char *check_buf;
75 static int skipped_blocks;
76
77 static blk64_t align_offset(blk64_t offset, unsigned int n)
78 {
79 return (offset + n - 1) & ~((blk64_t) n - 1);
80 }
81
82 static int get_bits_from_size(size_t size)
83 {
84 int res = 0;
85
86 if (size == 0)
87 return -1;
88
89 while (size != 1) {
90 /* Not a power of two */
91 if (size & 1)
92 return -1;
93
94 size >>= 1;
95 res++;
96 }
97 return res;
98 }
99
100 static void usage(void)
101 {
102 fprintf(stderr, _("Usage: %s [ -r|Q ] [ -fr ] device image-file\n"),
103 program_name);
104 fprintf(stderr, _(" %s -I device image-file\n"), program_name);
105 fprintf(stderr, _(" %s -ra [ -cfnp ] [ -o src_offset ] "
106 "[ -O dest_offset ] src_fs [ dest_fs ]\n"),
107 program_name);
108 exit (1);
109 }
110
111 static ext2_loff_t seek_relative(int fd, int offset)
112 {
113 ext2_loff_t ret = ext2fs_llseek(fd, offset, SEEK_CUR);
114 if (ret < 0) {
115 perror("seek_relative");
116 exit(1);
117 }
118 return ret;
119 }
120
121 static ext2_loff_t seek_set(int fd, ext2_loff_t offset)
122 {
123 ext2_loff_t ret = ext2fs_llseek(fd, offset, SEEK_SET);
124 if (ret < 0) {
125 perror("seek_set");
126 exit(1);
127 }
128 return ret;
129 }
130
131 /*
132 * Returns true if the block we are about to write is identical to
133 * what is already on the disk.
134 */
135 static int check_block(int fd, void *buf, void *cbuf, int blocksize)
136 {
137 char *cp = cbuf;
138 int count = blocksize, ret;
139
140 if (cbuf == NULL)
141 return 0;
142
143 while (count > 0) {
144 ret = read(fd, cp, count);
145 if (ret < 0) {
146 perror("check_block");
147 exit(1);
148 }
149 count -= ret;
150 cp += ret;
151 }
152 ret = memcmp(buf, cbuf, blocksize);
153 seek_relative(fd, -blocksize);
154 return (ret == 0) ? 1 : 0;
155 }
156
157 static void generic_write(int fd, void *buf, int blocksize, blk64_t block)
158 {
159 int count, free_buf = 0;
160 errcode_t err;
161
162 if (!blocksize)
163 return;
164
165 if (!buf) {
166 free_buf = 1;
167 err = ext2fs_get_arrayzero(1, blocksize, &buf);
168 if (err) {
169 com_err(program_name, err, "%s",
170 _("while allocating buffer"));
171 exit(1);
172 }
173 }
174 if (nop_flag) {
175 printf(_("Writing block %llu\n"), (unsigned long long) block);
176 if (fd != 1)
177 seek_relative(fd, blocksize);
178 goto free_and_return;
179 }
180 count = write(fd, buf, blocksize);
181 if (count != blocksize) {
182 if (count == -1)
183 err = errno;
184 else
185 err = 0;
186
187 if (block)
188 com_err(program_name, err,
189 _("error writing block %llu"), block);
190 else
191 com_err(program_name, err, "%s",
192 _("error in generic_write()"));
193
194 exit(1);
195 }
196 free_and_return:
197 if (free_buf)
198 ext2fs_free_mem(&buf);
199 }
200
201 static void write_header(int fd, void *hdr, int hdr_size, int wrt_size)
202 {
203 char *header_buf;
204 int ret;
205
206 /* Sanity check */
207 if (hdr_size > wrt_size) {
208 fprintf(stderr, "%s",
209 _("Error: header size is bigger than wrt_size\n"));
210 }
211
212 ret = ext2fs_get_mem(wrt_size, &header_buf);
213 if (ret) {
214 fputs(_("Couldn't allocate header buffer\n"), stderr);
215 exit(1);
216 }
217
218 seek_set(fd, 0);
219 memset(header_buf, 0, wrt_size);
220
221 if (hdr)
222 memcpy(header_buf, hdr, hdr_size);
223
224 generic_write(fd, header_buf, wrt_size, NO_BLK);
225
226 ext2fs_free_mem(&header_buf);
227 }
228
229 static void write_image_file(ext2_filsys fs, int fd)
230 {
231 struct ext2_image_hdr hdr;
232 struct stat st;
233 errcode_t retval;
234
235 write_header(fd, NULL, sizeof(struct ext2_image_hdr), fs->blocksize);
236 memset(&hdr, 0, sizeof(struct ext2_image_hdr));
237
238 hdr.offset_super = seek_relative(fd, 0);
239 retval = ext2fs_image_super_write(fs, fd, 0);
240 if (retval) {
241 com_err(program_name, retval, "%s",
242 _("while writing superblock"));
243 exit(1);
244 }
245
246 hdr.offset_inode = seek_relative(fd, 0);
247 retval = ext2fs_image_inode_write(fs, fd,
248 (fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
249 if (retval) {
250 com_err(program_name, retval, "%s",
251 _("while writing inode table"));
252 exit(1);
253 }
254
255 hdr.offset_blockmap = seek_relative(fd, 0);
256 retval = ext2fs_image_bitmap_write(fs, fd, 0);
257 if (retval) {
258 com_err(program_name, retval, "%s",
259 _("while writing block bitmap"));
260 exit(1);
261 }
262
263 hdr.offset_inodemap = seek_relative(fd, 0);
264 retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
265 if (retval) {
266 com_err(program_name, retval, "%s",
267 _("while writing inode bitmap"));
268 exit(1);
269 }
270
271 hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
272 strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
273 gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
274 strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
275 hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
276 hdr.fs_blocksize = fs->blocksize;
277
278 if (stat(device_name, &st) == 0)
279 hdr.fs_device = st.st_rdev;
280
281 if (fstat(fd, &st) == 0) {
282 hdr.image_device = st.st_dev;
283 hdr.image_inode = st.st_ino;
284 }
285 memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
286
287 hdr.image_time = time(0);
288 write_header(fd, &hdr, sizeof(struct ext2_image_hdr), fs->blocksize);
289 }
290
291 /*
292 * These set of functions are used to write a RAW image file.
293 */
294 static ext2fs_block_bitmap meta_block_map;
295 static ext2fs_block_bitmap scramble_block_map; /* Directory blocks to be scrambled */
296 static blk64_t meta_blocks_count;
297
298 struct process_block_struct {
299 ext2_ino_t ino;
300 int is_dir;
301 };
302
303 /*
304 * These subroutines short circuits ext2fs_get_blocks and
305 * ext2fs_check_directory; we use them since we already have the inode
306 * structure, so there's no point in letting the ext2fs library read
307 * the inode again.
308 */
309 static ino_t stashed_ino = 0;
310 static struct ext2_inode *stashed_inode;
311
312 static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
313 ext2_ino_t ino,
314 blk_t *blocks)
315 {
316 int i;
317
318 if ((ino != stashed_ino) || !stashed_inode)
319 return EXT2_ET_CALLBACK_NOTHANDLED;
320
321 for (i=0; i < EXT2_N_BLOCKS; i++)
322 blocks[i] = stashed_inode->i_block[i];
323 return 0;
324 }
325
326 static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
327 ext2_ino_t ino)
328 {
329 if ((ino != stashed_ino) || !stashed_inode)
330 return EXT2_ET_CALLBACK_NOTHANDLED;
331
332 if (!LINUX_S_ISDIR(stashed_inode->i_mode))
333 return EXT2_ET_NO_DIRECTORY;
334 return 0;
335 }
336
337 static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
338 ext2_ino_t ino,
339 struct ext2_inode *inode)
340 {
341 if ((ino != stashed_ino) || !stashed_inode)
342 return EXT2_ET_CALLBACK_NOTHANDLED;
343 *inode = *stashed_inode;
344 return 0;
345 }
346
347 static void use_inode_shortcuts(ext2_filsys fs, int use_shortcuts)
348 {
349 if (use_shortcuts) {
350 fs->get_blocks = meta_get_blocks;
351 fs->check_directory = meta_check_directory;
352 fs->read_inode = meta_read_inode;
353 stashed_ino = 0;
354 } else {
355 fs->get_blocks = 0;
356 fs->check_directory = 0;
357 fs->read_inode = 0;
358 }
359 }
360
361 static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
362 blk64_t *block_nr,
363 e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
364 blk64_t ref_block EXT2FS_ATTR((unused)),
365 int ref_offset EXT2FS_ATTR((unused)),
366 void *priv_data EXT2FS_ATTR((unused)))
367 {
368 struct process_block_struct *p;
369
370 p = (struct process_block_struct *) priv_data;
371
372 ext2fs_mark_block_bitmap2(meta_block_map, *block_nr);
373 meta_blocks_count++;
374 if (scramble_block_map && p->is_dir && blockcnt >= 0)
375 ext2fs_mark_block_bitmap2(scramble_block_map, *block_nr);
376 return 0;
377 }
378
379 static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
380 blk64_t *block_nr,
381 e2_blkcnt_t blockcnt,
382 blk64_t ref_block EXT2FS_ATTR((unused)),
383 int ref_offset EXT2FS_ATTR((unused)),
384 void *priv_data EXT2FS_ATTR((unused)))
385 {
386 if (blockcnt < 0 || all_data) {
387 ext2fs_mark_block_bitmap2(meta_block_map, *block_nr);
388 meta_blocks_count++;
389 }
390 return 0;
391 }
392
393 static void mark_table_blocks(ext2_filsys fs)
394 {
395 blk64_t first_block, b;
396 unsigned int i,j;
397
398 first_block = fs->super->s_first_data_block;
399 /*
400 * Mark primary superblock
401 */
402 ext2fs_mark_block_bitmap2(meta_block_map, first_block);
403 meta_blocks_count++;
404
405 /*
406 * Mark the primary superblock descriptors
407 */
408 for (j = 0; j < fs->desc_blocks; j++) {
409 ext2fs_mark_block_bitmap2(meta_block_map,
410 ext2fs_descriptor_block_loc2(fs, first_block, j));
411 }
412 meta_blocks_count += fs->desc_blocks;
413
414 for (i = 0; i < fs->group_desc_count; i++) {
415 /*
416 * Mark the blocks used for the inode table
417 */
418 if ((output_is_blk ||
419 !ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT)) &&
420 ext2fs_inode_table_loc(fs, i)) {
421 unsigned int end = (unsigned) fs->inode_blocks_per_group;
422 /* skip unused blocks */
423 if (!output_is_blk && ext2fs_has_group_desc_csum(fs))
424 end -= (ext2fs_bg_itable_unused(fs, i) /
425 EXT2_INODES_PER_BLOCK(fs->super));
426 for (j = 0, b = ext2fs_inode_table_loc(fs, i);
427 j < end;
428 j++, b++) {
429 ext2fs_mark_block_bitmap2(meta_block_map, b);
430 meta_blocks_count++;
431 }
432 }
433
434 /*
435 * Mark block used for the block bitmap
436 */
437 if (!ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT) &&
438 ext2fs_block_bitmap_loc(fs, i)) {
439 ext2fs_mark_block_bitmap2(meta_block_map,
440 ext2fs_block_bitmap_loc(fs, i));
441 meta_blocks_count++;
442 }
443
444 /*
445 * Mark block used for the inode bitmap
446 */
447 if (!ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT) &&
448 ext2fs_inode_bitmap_loc(fs, i)) {
449 ext2fs_mark_block_bitmap2(meta_block_map,
450 ext2fs_inode_bitmap_loc(fs, i));
451 meta_blocks_count++;
452 }
453 }
454 }
455
456 /*
457 * This function returns 1 if the specified block is all zeros
458 */
459 static int check_zero_block(char *buf, int blocksize)
460 {
461 char *cp = buf;
462 int left = blocksize;
463
464 if (output_is_blk)
465 return 0;
466 while (left > 0) {
467 if (*cp++)
468 return 0;
469 left--;
470 }
471 return 1;
472 }
473
474 static int name_id[256];
475
476 #define EXT4_MAX_REC_LEN ((1<<16)-1)
477
478 static void scramble_dir_block(ext2_filsys fs, blk64_t blk, char *buf)
479 {
480 char *p, *end, *cp;
481 struct ext2_dir_entry_2 *dirent;
482 unsigned int rec_len;
483 int id, len;
484
485 end = buf + fs->blocksize;
486 for (p = buf; p < end-8; p += rec_len) {
487 dirent = (struct ext2_dir_entry_2 *) p;
488 rec_len = dirent->rec_len;
489 #ifdef WORDS_BIGENDIAN
490 rec_len = ext2fs_swab16(rec_len);
491 #endif
492 if (rec_len == EXT4_MAX_REC_LEN || rec_len == 0)
493 rec_len = fs->blocksize;
494 else
495 rec_len = (rec_len & 65532) | ((rec_len & 3) << 16);
496 #if 0
497 printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len);
498 #endif
499 if (rec_len < 8 || (rec_len % 4) ||
500 (p+rec_len > end)) {
501 printf(_("Corrupt directory block %llu: "
502 "bad rec_len (%d)\n"),
503 (unsigned long long) blk, rec_len);
504 rec_len = end - p;
505 (void) ext2fs_set_rec_len(fs, rec_len,
506 (struct ext2_dir_entry *) dirent);
507 #ifdef WORDS_BIGENDIAN
508 dirent->rec_len = ext2fs_swab16(dirent->rec_len);
509 #endif
510 continue;
511 }
512 if (dirent->name_len + 8U > rec_len) {
513 printf(_("Corrupt directory block %llu: "
514 "bad name_len (%d)\n"),
515 (unsigned long long) blk, dirent->name_len);
516 dirent->name_len = rec_len - 8;
517 continue;
518 }
519 cp = p+8;
520 len = rec_len - dirent->name_len - 8;
521 if (len > 0)
522 memset(cp+dirent->name_len, 0, len);
523 if (dirent->name_len==1 && cp[0] == '.')
524 continue;
525 if (dirent->name_len==2 && cp[0] == '.' && cp[1] == '.')
526 continue;
527
528 memset(cp, 'A', dirent->name_len);
529 len = dirent->name_len;
530 id = name_id[len]++;
531 while ((len > 0) && (id > 0)) {
532 *cp += id % 26;
533 id = id / 26;
534 cp++;
535 len--;
536 }
537 }
538 }
539
540 static char got_sigint;
541
542 static void sigint_handler(int unused EXT2FS_ATTR((unused)))
543 {
544 got_sigint = 1;
545 signal (SIGINT, SIG_DFL);
546 }
547
548 #define calc_percent(a, b) ((int) ((100.0 * (((float) (a)) / \
549 ((float) (b)))) + 0.5))
550 #define calc_rate(t, b, d) (((float)(t) / ((1024 * 1024) / (b))) / (d))
551
552 static int print_progress(blk64_t num, blk64_t total)
553 {
554 return fprintf(stderr, _("%llu / %llu blocks (%d%%)"), num, total,
555 calc_percent(num, total));
556 }
557
558 static void output_meta_data_blocks(ext2_filsys fs, int fd, int flags)
559 {
560 errcode_t retval;
561 blk64_t blk;
562 char *buf, *zero_buf;
563 int sparse = 0;
564 blk64_t start = 0;
565 blk64_t distance = 0;
566 blk64_t end = ext2fs_blocks_count(fs->super);
567 time_t last_update = 0;
568 time_t start_time = 0;
569 blk64_t total_written = 0;
570 int bscount = 0;
571
572 retval = ext2fs_get_mem(fs->blocksize, &buf);
573 if (retval) {
574 com_err(program_name, retval, "%s",
575 _("while allocating buffer"));
576 exit(1);
577 }
578 retval = ext2fs_get_memzero(fs->blocksize, &zero_buf);
579 if (retval) {
580 com_err(program_name, retval, "%s",
581 _("while allocating buffer"));
582 exit(1);
583 }
584 if (show_progress) {
585 fprintf(stderr, "%s", _("Copying "));
586 bscount = print_progress(total_written, meta_blocks_count);
587 fflush(stderr);
588 last_update = time(NULL);
589 start_time = time(NULL);
590 }
591 /* when doing an in place move to the right, you can't start
592 at the beginning or you will overwrite data, so instead
593 divide the fs up into distance size chunks and write them
594 in reverse. */
595 if (move_mode && dest_offset > source_offset) {
596 distance = (dest_offset - source_offset) / fs->blocksize;
597 if (distance < ext2fs_blocks_count(fs->super))
598 start = ext2fs_blocks_count(fs->super) - distance;
599 }
600 if (move_mode)
601 signal (SIGINT, sigint_handler);
602 more_blocks:
603 if (distance)
604 seek_set(fd, (start * fs->blocksize) + dest_offset);
605 for (blk = start; blk < end; blk++) {
606 if (got_sigint) {
607 if (distance) {
608 /* moving to the right */
609 if (distance >= ext2fs_blocks_count(fs->super)||
610 start == ext2fs_blocks_count(fs->super) -
611 distance)
612 kill(getpid(), SIGINT);
613 } else {
614 /* moving to the left */
615 if (blk < (source_offset - dest_offset) /
616 fs->blocksize)
617 kill(getpid(), SIGINT);
618 }
619 if (show_progress)
620 fputc('\r', stderr);
621 fprintf(stderr, "%s",
622 _("Stopping now will destroy the filesystem, "
623 "interrupt again if you are sure\n"));
624 if (show_progress) {
625 fprintf(stderr, "%s", _("Copying "));
626 bscount = print_progress(total_written,
627 meta_blocks_count);
628 fflush(stderr);
629 }
630
631 got_sigint = 0;
632 }
633 if (show_progress && last_update != time(NULL)) {
634 time_t duration;
635 last_update = time(NULL);
636 while (bscount--)
637 fputc('\b', stderr);
638 bscount = print_progress(total_written,
639 meta_blocks_count);
640 duration = time(NULL) - start_time;
641 if (duration > 5 && total_written) {
642 time_t est = (duration * meta_blocks_count /
643 total_written) - duration;
644 char buff[30];
645 strftime(buff, 30, "%T", gmtime(&est));
646 bscount +=
647 fprintf(stderr,
648 _(" %s remaining at %.2f MB/s"),
649 buff, calc_rate(total_written,
650 fs->blocksize,
651 duration));
652 }
653 fflush (stderr);
654 }
655 if ((blk >= fs->super->s_first_data_block) &&
656 ext2fs_test_block_bitmap2(meta_block_map, blk)) {
657 retval = io_channel_read_blk64(fs->io, blk, 1, buf);
658 if (retval) {
659 com_err(program_name, retval,
660 _("error reading block %llu"), blk);
661 }
662 total_written++;
663 if (scramble_block_map &&
664 ext2fs_test_block_bitmap2(scramble_block_map, blk))
665 scramble_dir_block(fs, blk, buf);
666 if ((flags & E2IMAGE_CHECK_ZERO_FLAG) &&
667 check_zero_block(buf, fs->blocksize))
668 goto sparse_write;
669 if (sparse)
670 seek_relative(fd, sparse);
671 sparse = 0;
672 if (check_block(fd, buf, check_buf, fs->blocksize)) {
673 seek_relative(fd, fs->blocksize);
674 skipped_blocks++;
675 } else
676 generic_write(fd, buf, fs->blocksize, blk);
677 } else {
678 sparse_write:
679 if (fd == 1) {
680 if (!nop_flag)
681 generic_write(fd, zero_buf,
682 fs->blocksize, blk);
683 continue;
684 }
685 sparse += fs->blocksize;
686 if (sparse > 1024*1024) {
687 seek_relative(fd, 1024*1024);
688 sparse -= 1024*1024;
689 }
690 }
691 }
692 if (distance && start) {
693 if (start < distance) {
694 end = start;
695 start = 0;
696 } else {
697 end -= distance;
698 start -= distance;
699 if (end < distance) {
700 /* past overlap, do rest in one go */
701 end = start;
702 start = 0;
703 }
704 }
705 sparse = 0;
706 goto more_blocks;
707 }
708 signal (SIGINT, SIG_DFL);
709 if (show_progress) {
710 time_t duration = time(NULL) - start_time;
711 char buff[30];
712 fputc('\r', stderr);
713 strftime(buff, 30, "%T", gmtime(&duration));
714 fprintf(stderr, _("Copied %llu / %llu blocks (%d%%) in %s "),
715 total_written, meta_blocks_count,
716 calc_percent(total_written, meta_blocks_count), buff);
717 if (duration)
718 fprintf(stderr, _("at %.2f MB/s"),
719 calc_rate(total_written, fs->blocksize, duration));
720 fputs(" \n", stderr);
721 }
722 #ifdef HAVE_FTRUNCATE64
723 if (sparse) {
724 ext2_loff_t offset;
725 if (distance)
726 offset = seek_set(fd,
727 fs->blocksize * ext2fs_blocks_count(fs->super) + dest_offset);
728 else
729 offset = seek_relative(fd, sparse);
730
731 if (ftruncate64(fd, offset) < 0) {
732 seek_relative(fd, -1);
733 generic_write(fd, zero_buf, 1, NO_BLK);
734 }
735 }
736 #else
737 if (sparse && !distance) {
738 seek_relative(fd, sparse-1);
739 generic_write(fd, zero_buf, 1, NO_BLK);
740 }
741 #endif
742 ext2fs_free_mem(&zero_buf);
743 ext2fs_free_mem(&buf);
744 }
745
746 static void init_l1_table(struct ext2_qcow2_image *image)
747 {
748 __u64 *l1_table;
749 errcode_t ret;
750
751 ret = ext2fs_get_arrayzero(image->l1_size, sizeof(__u64), &l1_table);
752 if (ret) {
753 com_err(program_name, ret, "%s",
754 _("while allocating l1 table"));
755 exit(1);
756 }
757
758 image->l1_table = l1_table;
759 }
760
761 static void init_l2_cache(struct ext2_qcow2_image *image)
762 {
763 unsigned int count, i;
764 struct ext2_qcow2_l2_cache *cache;
765 struct ext2_qcow2_l2_table *table;
766 errcode_t ret;
767
768 ret = ext2fs_get_arrayzero(1, sizeof(struct ext2_qcow2_l2_cache),
769 &cache);
770 if (ret)
771 goto alloc_err;
772
773 count = (image->l1_size > L2_CACHE_PREALLOC) ? L2_CACHE_PREALLOC :
774 image->l1_size;
775
776 cache->count = count;
777 cache->free = count;
778 cache->next_offset = image->l2_offset;
779
780 for (i = 0; i < count; i++) {
781 ret = ext2fs_get_arrayzero(1,
782 sizeof(struct ext2_qcow2_l2_table), &table);
783 if (ret)
784 goto alloc_err;
785
786 ret = ext2fs_get_arrayzero(image->l2_size,
787 sizeof(__u64), &table->data);
788 if (ret)
789 goto alloc_err;
790
791 table->next = cache->free_head;
792 cache->free_head = table;
793 }
794
795 image->l2_cache = cache;
796 return;
797
798 alloc_err:
799 com_err(program_name, ret, "%s", _("while allocating l2 cache"));
800 exit(1);
801 }
802
803 static void put_l2_cache(struct ext2_qcow2_image *image)
804 {
805 struct ext2_qcow2_l2_cache *cache = image->l2_cache;
806 struct ext2_qcow2_l2_table *tmp, *table;
807
808 if (!cache)
809 return;
810
811 table = cache->free_head;
812 cache->free_head = NULL;
813 again:
814 while (table) {
815 tmp = table;
816 table = table->next;
817 ext2fs_free_mem(&tmp->data);
818 ext2fs_free_mem(&tmp);
819 }
820
821 if (cache->free != cache->count) {
822 fprintf(stderr, "%s", _("Warning: There are still tables in "
823 "the cache while putting the cache, "
824 "data will be lost so the image may "
825 "not be valid.\n"));
826 table = cache->used_head;
827 cache->used_head = NULL;
828 goto again;
829 }
830
831 ext2fs_free_mem(&cache);
832 }
833
834 static int init_refcount(struct ext2_qcow2_image *img, blk64_t table_offset)
835 {
836 struct ext2_qcow2_refcount *ref;
837 blk64_t table_clusters;
838 errcode_t ret;
839
840 ref = &(img->refcount);
841
842 /*
843 * One refcount block addresses 2048 clusters, one refcount table
844 * addresses cluster/sizeof(__u64) refcount blocks, and we need
845 * to address meta_blocks_count clusters + qcow2 metadata clusters
846 * in the worst case.
847 */
848 table_clusters = meta_blocks_count + (table_offset >>
849 img->cluster_bits);
850 table_clusters >>= (img->cluster_bits + 6 - 1);
851 table_clusters = (table_clusters == 0) ? 1 : table_clusters;
852
853 ref->refcount_table_offset = table_offset;
854 ref->refcount_table_clusters = table_clusters;
855 ref->refcount_table_index = 0;
856 ref->refcount_block_index = 0;
857
858 /* Allocate refcount table */
859 ret = ext2fs_get_arrayzero(ref->refcount_table_clusters,
860 img->cluster_size, &ref->refcount_table);
861 if (ret)
862 return ret;
863
864 /* Allocate refcount block */
865 ret = ext2fs_get_arrayzero(1, img->cluster_size, &ref->refcount_block);
866 if (ret)
867 ext2fs_free_mem(&ref->refcount_table);
868
869 return ret;
870 }
871
872 static int initialize_qcow2_image(int fd, ext2_filsys fs,
873 struct ext2_qcow2_image *image)
874 {
875 struct ext2_qcow2_hdr *header;
876 blk64_t total_size, offset;
877 int shift, l2_bits, header_size, l1_size, ret;
878 int cluster_bits = get_bits_from_size(fs->blocksize);
879 struct ext2_super_block *sb = fs->super;
880
881 /* Allocate header */
882 ret = ext2fs_get_memzero(sizeof(struct ext2_qcow2_hdr), &header);
883 if (ret)
884 return ret;
885
886 total_size = ext2fs_blocks_count(sb) << cluster_bits;
887 image->cluster_size = fs->blocksize;
888 image->l2_size = 1 << (cluster_bits - 3);
889 image->cluster_bits = cluster_bits;
890 image->fd = fd;
891
892 header->magic = ext2fs_cpu_to_be32(QCOW_MAGIC);
893 header->version = ext2fs_cpu_to_be32(QCOW_VERSION);
894 header->size = ext2fs_cpu_to_be64(total_size);
895 header->cluster_bits = ext2fs_cpu_to_be32(cluster_bits);
896
897 header_size = (sizeof(struct ext2_qcow2_hdr) + 7) & ~7;
898 offset = align_offset(header_size, image->cluster_size);
899
900 header->l1_table_offset = ext2fs_cpu_to_be64(offset);
901 image->l1_offset = offset;
902
903 l2_bits = cluster_bits - 3;
904 shift = cluster_bits + l2_bits;
905 l1_size = ((total_size + (1LL << shift) - 1) >> shift);
906 header->l1_size = ext2fs_cpu_to_be32(l1_size);
907 image->l1_size = l1_size;
908
909 /* Make space for L1 table */
910 offset += align_offset(l1_size * sizeof(blk64_t), image->cluster_size);
911
912 /* Initialize refcounting */
913 ret = init_refcount(image, offset);
914 if (ret) {
915 ext2fs_free_mem(&header);
916 return ret;
917 }
918 header->refcount_table_offset = ext2fs_cpu_to_be64(offset);
919 header->refcount_table_clusters =
920 ext2fs_cpu_to_be32(image->refcount.refcount_table_clusters);
921 offset += image->cluster_size;
922 offset += image->refcount.refcount_table_clusters <<
923 image->cluster_bits;
924
925 /* Make space for L2 tables */
926 image->l2_offset = offset;
927 offset += image->cluster_size;
928
929 /* Make space for first refcount block */
930 image->refcount.refcount_block_offset = offset;
931
932 image->hdr = header;
933 /* Initialize l1 and l2 tables */
934 init_l1_table(image);
935 init_l2_cache(image);
936
937 return 0;
938 }
939
940 static void free_qcow2_image(struct ext2_qcow2_image *img)
941 {
942 if (!img)
943 return;
944
945 if (img->hdr)
946 ext2fs_free_mem(&img->hdr);
947
948 if (img->l1_table)
949 ext2fs_free_mem(&img->l1_table);
950
951 if (img->refcount.refcount_table)
952 ext2fs_free_mem(&img->refcount.refcount_table);
953 if (img->refcount.refcount_block)
954 ext2fs_free_mem(&img->refcount.refcount_block);
955
956 put_l2_cache(img);
957
958 ext2fs_free_mem(&img);
959 }
960
961 /**
962 * Put table from used list (used_head) into free list (free_head).
963 * l2_table is used to return pointer to the next used table (used_head).
964 */
965 static void put_used_table(struct ext2_qcow2_image *img,
966 struct ext2_qcow2_l2_table **l2_table)
967 {
968 struct ext2_qcow2_l2_cache *cache = img->l2_cache;
969 struct ext2_qcow2_l2_table *table;
970
971 table = cache->used_head;
972 cache->used_head = table->next;
973
974 assert(table);
975 if (!table->next)
976 cache->used_tail = NULL;
977
978 /* Clean the table for case we will need to use it again */
979 memset(table->data, 0, img->cluster_size);
980 table->next = cache->free_head;
981 cache->free_head = table;
982
983 cache->free++;
984
985 *l2_table = cache->used_head;
986 }
987
988 static void flush_l2_cache(struct ext2_qcow2_image *image)
989 {
990 blk64_t seek = 0;
991 ext2_loff_t offset;
992 struct ext2_qcow2_l2_cache *cache = image->l2_cache;
993 struct ext2_qcow2_l2_table *table = cache->used_head;
994 int fd = image->fd;
995
996 /* Store current position */
997 offset = seek_relative(fd, 0);
998
999 assert(table);
1000 while (cache->free < cache->count) {
1001 if (seek != table->offset) {
1002 seek_set(fd, table->offset);
1003 seek = table->offset;
1004 }
1005
1006 generic_write(fd, (char *)table->data, image->cluster_size,
1007 NO_BLK);
1008 put_used_table(image, &table);
1009 seek += image->cluster_size;
1010 }
1011
1012 /* Restore previous position */
1013 seek_set(fd, offset);
1014 }
1015
1016 /**
1017 * Get first free table (from free_head) and put it into tail of used list
1018 * (to used_tail).
1019 * l2_table is used to return pointer to moved table.
1020 * Returns 1 if the cache is full, 0 otherwise.
1021 */
1022 static void get_free_table(struct ext2_qcow2_image *image,
1023 struct ext2_qcow2_l2_table **l2_table)
1024 {
1025 struct ext2_qcow2_l2_table *table;
1026 struct ext2_qcow2_l2_cache *cache = image->l2_cache;
1027
1028 if (0 == cache->free)
1029 flush_l2_cache(image);
1030
1031 table = cache->free_head;
1032 assert(table);
1033 cache->free_head = table->next;
1034
1035 if (cache->used_tail)
1036 cache->used_tail->next = table;
1037 else
1038 /* First item in the used list */
1039 cache->used_head = table;
1040
1041 cache->used_tail = table;
1042 cache->free--;
1043
1044 *l2_table = table;
1045 }
1046
1047 static int add_l2_item(struct ext2_qcow2_image *img, blk64_t blk,
1048 blk64_t data, blk64_t next)
1049 {
1050 struct ext2_qcow2_l2_cache *cache = img->l2_cache;
1051 struct ext2_qcow2_l2_table *table = cache->used_tail;
1052 blk64_t l1_index = blk / img->l2_size;
1053 blk64_t l2_index = blk & (img->l2_size - 1);
1054 int ret = 0;
1055
1056 /*
1057 * Need to create new table if it does not exist,
1058 * or if it is full
1059 */
1060 if (!table || (table->l1_index != l1_index)) {
1061 get_free_table(img, &table);
1062 table->l1_index = l1_index;
1063 table->offset = cache->next_offset;
1064 cache->next_offset = next;
1065 img->l1_table[l1_index] =
1066 ext2fs_cpu_to_be64(table->offset | QCOW_OFLAG_COPIED);
1067 ret++;
1068 }
1069
1070 table->data[l2_index] = ext2fs_cpu_to_be64(data | QCOW_OFLAG_COPIED);
1071 return ret;
1072 }
1073
1074 static int update_refcount(int fd, struct ext2_qcow2_image *img,
1075 blk64_t offset, blk64_t rfblk_pos)
1076 {
1077 struct ext2_qcow2_refcount *ref;
1078 __u32 table_index;
1079 int ret = 0;
1080
1081 ref = &(img->refcount);
1082 table_index = offset >> (2 * img->cluster_bits - 1);
1083
1084 /*
1085 * Need to create new refcount block when the offset addresses
1086 * another item in the refcount table
1087 */
1088 if (table_index != ref->refcount_table_index) {
1089
1090 seek_set(fd, ref->refcount_block_offset);
1091
1092 generic_write(fd, (char *)ref->refcount_block,
1093 img->cluster_size, NO_BLK);
1094 memset(ref->refcount_block, 0, img->cluster_size);
1095
1096 ref->refcount_table[ref->refcount_table_index] =
1097 ext2fs_cpu_to_be64(ref->refcount_block_offset);
1098 ref->refcount_block_offset = rfblk_pos;
1099 ref->refcount_block_index = 0;
1100 ref->refcount_table_index = table_index;
1101 ret++;
1102 }
1103
1104 /*
1105 * We are relying on the fact that we are creating the qcow2
1106 * image sequentially, hence we will always allocate refcount
1107 * block items sequentialy.
1108 */
1109 ref->refcount_block[ref->refcount_block_index] = ext2fs_cpu_to_be16(1);
1110 ref->refcount_block_index++;
1111 return ret;
1112 }
1113
1114 static int sync_refcount(int fd, struct ext2_qcow2_image *img)
1115 {
1116 struct ext2_qcow2_refcount *ref;
1117
1118 ref = &(img->refcount);
1119
1120 ref->refcount_table[ref->refcount_table_index] =
1121 ext2fs_cpu_to_be64(ref->refcount_block_offset);
1122 seek_set(fd, ref->refcount_table_offset);
1123 generic_write(fd, (char *)ref->refcount_table,
1124 ref->refcount_table_clusters << img->cluster_bits, NO_BLK);
1125
1126 seek_set(fd, ref->refcount_block_offset);
1127 generic_write(fd, (char *)ref->refcount_block, img->cluster_size,
1128 NO_BLK);
1129 return 0;
1130 }
1131
1132 static void output_qcow2_meta_data_blocks(ext2_filsys fs, int fd)
1133 {
1134 errcode_t retval;
1135 blk64_t blk, offset, size, end;
1136 char *buf;
1137 struct ext2_qcow2_image *img;
1138 unsigned int header_size;
1139
1140 /* allocate struct ext2_qcow2_image */
1141 retval = ext2fs_get_mem(sizeof(struct ext2_qcow2_image), &img);
1142 if (retval) {
1143 com_err(program_name, retval, "%s",
1144 _("while allocating ext2_qcow2_image"));
1145 exit(1);
1146 }
1147
1148 retval = initialize_qcow2_image(fd, fs, img);
1149 if (retval) {
1150 com_err(program_name, retval, "%s",
1151 _("while initializing ext2_qcow2_image"));
1152 exit(1);
1153 }
1154 header_size = align_offset(sizeof(struct ext2_qcow2_hdr),
1155 img->cluster_size);
1156 write_header(fd, img->hdr, sizeof(struct ext2_qcow2_hdr), header_size);
1157
1158 /* Refcount all qcow2 related metadata up to refcount_block_offset */
1159 end = img->refcount.refcount_block_offset;
1160 seek_set(fd, end);
1161 blk = end + img->cluster_size;
1162 for (offset = 0; offset <= end; offset += img->cluster_size) {
1163 if (update_refcount(fd, img, offset, blk)) {
1164 blk += img->cluster_size;
1165 /*
1166 * If we create new refcount block, we need to refcount
1167 * it as well.
1168 */
1169 end += img->cluster_size;
1170 }
1171 }
1172 seek_set(fd, offset);
1173
1174 retval = ext2fs_get_mem(fs->blocksize, &buf);
1175 if (retval) {
1176 com_err(program_name, retval, "%s",
1177 _("while allocating buffer"));
1178 exit(1);
1179 }
1180 /* Write qcow2 data blocks */
1181 for (blk = 0; blk < ext2fs_blocks_count(fs->super); blk++) {
1182 if ((blk >= fs->super->s_first_data_block) &&
1183 ext2fs_test_block_bitmap2(meta_block_map, blk)) {
1184 retval = io_channel_read_blk64(fs->io, blk, 1, buf);
1185 if (retval) {
1186 com_err(program_name, retval,
1187 _("error reading block %llu"), blk);
1188 continue;
1189 }
1190 if (scramble_block_map &&
1191 ext2fs_test_block_bitmap2(scramble_block_map, blk))
1192 scramble_dir_block(fs, blk, buf);
1193 if (check_zero_block(buf, fs->blocksize))
1194 continue;
1195
1196 if (update_refcount(fd, img, offset, offset)) {
1197 /* Make space for another refcount block */
1198 offset += img->cluster_size;
1199 seek_set(fd, offset);
1200 /*
1201 * We have created the new refcount block, this
1202 * means that we need to refcount it as well.
1203 * So the previous update_refcount refcounted
1204 * the block itself and now we are going to
1205 * create refcount for data. New refcount
1206 * block should not be created!
1207 */
1208 if (update_refcount(fd, img, offset, offset)) {
1209 fprintf(stderr, "%s",
1210 _("Programming error: multiple "
1211 "sequential refcount blocks "
1212 "created!\n"));
1213 exit(1);
1214 }
1215 }
1216
1217 generic_write(fd, buf, fs->blocksize, blk);
1218
1219 if (add_l2_item(img, blk, offset,
1220 offset + img->cluster_size)) {
1221 offset += img->cluster_size;
1222 if (update_refcount(fd, img, offset,
1223 offset + img->cluster_size)) {
1224 offset += img->cluster_size;
1225 if (update_refcount(fd, img, offset,
1226 offset)) {
1227 fprintf(stderr, "%s",
1228 _("Programming error: multiple sequential refcount "
1229 "blocks created!\n"));
1230 exit(1);
1231 }
1232 }
1233 offset += img->cluster_size;
1234 seek_set(fd, offset);
1235 continue;
1236 }
1237
1238 offset += img->cluster_size;
1239 }
1240 }
1241 update_refcount(fd, img, offset, offset);
1242 flush_l2_cache(img);
1243 sync_refcount(fd, img);
1244
1245 /* Write l1_table*/
1246 seek_set(fd, img->l1_offset);
1247 size = img->l1_size * sizeof(__u64);
1248 generic_write(fd, (char *)img->l1_table, size, NO_BLK);
1249
1250 ext2fs_free_mem(&buf);
1251 free_qcow2_image(img);
1252 }
1253
1254 static void write_raw_image_file(ext2_filsys fs, int fd, int type, int flags)
1255 {
1256 struct process_block_struct pb;
1257 struct ext2_inode inode;
1258 ext2_inode_scan scan;
1259 ext2_ino_t ino;
1260 errcode_t retval;
1261 char * block_buf;
1262
1263 meta_blocks_count = 0;
1264 retval = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
1265 &meta_block_map);
1266 if (retval) {
1267 com_err(program_name, retval, "%s",
1268 _("while allocating block bitmap"));
1269 exit(1);
1270 }
1271
1272 if (flags & E2IMAGE_SCRAMBLE_FLAG) {
1273 retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
1274 &scramble_block_map);
1275 if (retval) {
1276 com_err(program_name, retval, "%s",
1277 _("while allocating scramble block bitmap"));
1278 exit(1);
1279 }
1280 }
1281
1282 mark_table_blocks(fs);
1283 if (show_progress)
1284 printf("%s", _("Scanning inodes...\n"));
1285
1286 retval = ext2fs_open_inode_scan(fs, 0, &scan);
1287 if (retval) {
1288 com_err(program_name, retval, "%s",
1289 _("while opening inode scan"));
1290 exit(1);
1291 }
1292
1293 retval = ext2fs_get_mem(fs->blocksize * 3, &block_buf);
1294 if (retval) {
1295 com_err(program_name, 0, "%s",
1296 _("Can't allocate block buffer"));
1297 exit(1);
1298 }
1299
1300 use_inode_shortcuts(fs, 1);
1301 stashed_inode = &inode;
1302 while (1) {
1303 retval = ext2fs_get_next_inode(scan, &ino, &inode);
1304 if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
1305 continue;
1306 if (retval) {
1307 com_err(program_name, retval, "%s",
1308 _("while getting next inode"));
1309 exit(1);
1310 }
1311 if (ino == 0)
1312 break;
1313 if (!inode.i_links_count)
1314 continue;
1315 if (ext2fs_file_acl_block(fs, &inode)) {
1316 ext2fs_mark_block_bitmap2(meta_block_map,
1317 ext2fs_file_acl_block(fs, &inode));
1318 meta_blocks_count++;
1319 }
1320 if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
1321 continue;
1322
1323 stashed_ino = ino;
1324 pb.ino = ino;
1325 pb.is_dir = LINUX_S_ISDIR(inode.i_mode);
1326 if (LINUX_S_ISDIR(inode.i_mode) ||
1327 (LINUX_S_ISLNK(inode.i_mode) &&
1328 ext2fs_inode_has_valid_blocks2(fs, &inode)) ||
1329 ino == fs->super->s_journal_inum) {
1330 retval = ext2fs_block_iterate3(fs, ino,
1331 BLOCK_FLAG_READ_ONLY, block_buf,
1332 process_dir_block, &pb);
1333 if (retval) {
1334 com_err(program_name, retval,
1335 _("while iterating over inode %u"),
1336 ino);
1337 exit(1);
1338 }
1339 } else {
1340 if ((inode.i_flags & EXT4_EXTENTS_FL) ||
1341 inode.i_block[EXT2_IND_BLOCK] ||
1342 inode.i_block[EXT2_DIND_BLOCK] ||
1343 inode.i_block[EXT2_TIND_BLOCK] || all_data) {
1344 retval = ext2fs_block_iterate3(fs,
1345 ino, BLOCK_FLAG_READ_ONLY, block_buf,
1346 process_file_block, &pb);
1347 if (retval) {
1348 com_err(program_name, retval,
1349 _("while iterating over inode %u"), ino);
1350 exit(1);
1351 }
1352 }
1353 }
1354 }
1355 use_inode_shortcuts(fs, 0);
1356
1357 if (type & E2IMAGE_QCOW2)
1358 output_qcow2_meta_data_blocks(fs, fd);
1359 else
1360 output_meta_data_blocks(fs, fd, flags);
1361
1362 ext2fs_free_mem(&block_buf);
1363 ext2fs_close_inode_scan(scan);
1364 ext2fs_free_block_bitmap(meta_block_map);
1365 if (type & E2IMAGE_SCRAMBLE_FLAG)
1366 ext2fs_free_block_bitmap(scramble_block_map);
1367 }
1368
1369 static void install_image(char *device, char *image_fn, int type)
1370 {
1371 errcode_t retval;
1372 ext2_filsys fs;
1373 int open_flag = EXT2_FLAG_IMAGE_FILE | EXT2_FLAG_64BITS;
1374 int fd = 0;
1375 io_manager io_ptr;
1376 io_channel io;
1377
1378 if (type) {
1379 com_err(program_name, 0, "%s",
1380 _("Raw and qcow2 images cannot be installed"));
1381 exit(1);
1382 }
1383
1384 #ifdef CONFIG_TESTIO_DEBUG
1385 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
1386 io_ptr = test_io_manager;
1387 test_io_backing_manager = unix_io_manager;
1388 } else
1389 #endif
1390 io_ptr = unix_io_manager;
1391
1392 retval = ext2fs_open (image_fn, open_flag, 0, 0,
1393 io_ptr, &fs);
1394 if (retval) {
1395 com_err(program_name, retval, _("while trying to open %s"),
1396 image_fn);
1397 exit(1);
1398 }
1399
1400 retval = ext2fs_read_bitmaps (fs);
1401 if (retval) {
1402 com_err(program_name, retval, "%s", _("error reading bitmaps"));
1403 exit(1);
1404 }
1405
1406 fd = ext2fs_open_file(image_fn, O_RDONLY, 0);
1407 if (fd < 0) {
1408 perror(image_fn);
1409 exit(1);
1410 }
1411
1412 retval = io_ptr->open(device, IO_FLAG_RW, &io);
1413 if (retval) {
1414 com_err(device, 0, "%s", _("while opening device file"));
1415 exit(1);
1416 }
1417
1418 ext2fs_rewrite_to_io(fs, io);
1419
1420 seek_set(fd, fs->image_header->offset_inode);
1421
1422 retval = ext2fs_image_inode_read(fs, fd, 0);
1423 if (retval) {
1424 com_err(image_fn, 0, "%s",
1425 _("while restoring the image table"));
1426 exit(1);
1427 }
1428
1429 close(fd);
1430 ext2fs_close_free(&fs);
1431 }
1432
1433 static struct ext2_qcow2_hdr *check_qcow2_image(int *fd, char *name)
1434 {
1435
1436 *fd = ext2fs_open_file(name, O_RDONLY, 0600);
1437 if (*fd < 0)
1438 return NULL;
1439
1440 return qcow2_read_header(*fd);
1441 }
1442
1443 int main (int argc, char ** argv)
1444 {
1445 int c;
1446 errcode_t retval;
1447 ext2_filsys fs;
1448 char *image_fn, offset_opt[64];
1449 struct ext2_qcow2_hdr *header = NULL;
1450 int open_flag = EXT2_FLAG_64BITS;
1451 int img_type = 0;
1452 int flags = 0;
1453 int mount_flags = 0;
1454 int qcow2_fd = 0;
1455 int fd = 0;
1456 int ret = 0;
1457 int ignore_rw_mount = 0;
1458 int check = 0;
1459 struct stat st;
1460
1461 #ifdef ENABLE_NLS
1462 setlocale(LC_MESSAGES, "");
1463 setlocale(LC_CTYPE, "");
1464 bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
1465 textdomain(NLS_CAT_NAME);
1466 set_com_err_gettext(gettext);
1467 #endif
1468 fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION,
1469 E2FSPROGS_DATE);
1470 if (argc && *argv)
1471 program_name = *argv;
1472 add_error_table(&et_ext2_error_table);
1473 while ((c = getopt(argc, argv, "nrsIQafo:O:pc")) != EOF)
1474 switch (c) {
1475 case 'I':
1476 flags |= E2IMAGE_INSTALL_FLAG;
1477 break;
1478 case 'Q':
1479 if (img_type)
1480 usage();
1481 img_type |= E2IMAGE_QCOW2;
1482 break;
1483 case 'r':
1484 if (img_type)
1485 usage();
1486 img_type |= E2IMAGE_RAW;
1487 break;
1488 case 's':
1489 flags |= E2IMAGE_SCRAMBLE_FLAG;
1490 break;
1491 case 'a':
1492 all_data = 1;
1493 break;
1494 case 'f':
1495 ignore_rw_mount = 1;
1496 break;
1497 case 'n':
1498 nop_flag = 1;
1499 break;
1500 case 'o':
1501 source_offset = strtoull(optarg, NULL, 0);
1502 break;
1503 case 'O':
1504 dest_offset = strtoull(optarg, NULL, 0);
1505 break;
1506 case 'p':
1507 show_progress = 1;
1508 break;
1509 case 'c':
1510 check = 1;
1511 break;
1512 default:
1513 usage();
1514 }
1515 if (optind == argc - 1 &&
1516 (source_offset || dest_offset))
1517 move_mode = 1;
1518 else if (optind != argc - 2 )
1519 usage();
1520
1521 if (all_data && !img_type) {
1522 com_err(program_name, 0, "%s", _("-a option can only be used "
1523 "with raw or QCOW2 images."));
1524 exit(1);
1525 }
1526 if ((source_offset || dest_offset) && img_type != E2IMAGE_RAW) {
1527 com_err(program_name, 0, "%s",
1528 _("Offsets are only allowed with raw images."));
1529 exit(1);
1530 }
1531 if (move_mode && img_type != E2IMAGE_RAW) {
1532 com_err(program_name, 0, "%s",
1533 _("Move mode is only allowed with raw images."));
1534 exit(1);
1535 }
1536 if (move_mode && !all_data) {
1537 com_err(program_name, 0, "%s",
1538 _("Move mode requires all data mode."));
1539 exit(1);
1540 }
1541 device_name = argv[optind];
1542 if (move_mode)
1543 image_fn = device_name;
1544 else image_fn = argv[optind+1];
1545
1546 retval = ext2fs_check_if_mounted(device_name, &mount_flags);
1547 if (retval) {
1548 com_err(program_name, retval, "%s", _("checking if mounted"));
1549 exit(1);
1550 }
1551
1552 if (img_type && !ignore_rw_mount &&
1553 (mount_flags & EXT2_MF_MOUNTED) &&
1554 !(mount_flags & EXT2_MF_READONLY)) {
1555 fprintf(stderr, "%s", _("\nRunning e2image on a R/W mounted "
1556 "filesystem can result in an\n"
1557 "inconsistent image which will not be useful "
1558 "for debugging purposes.\n"
1559 "Use -f option if you really want to do that.\n"));
1560 exit(1);
1561 }
1562
1563 if (flags & E2IMAGE_INSTALL_FLAG) {
1564 install_image(device_name, image_fn, img_type);
1565 exit (0);
1566 }
1567
1568 if (img_type & E2IMAGE_RAW) {
1569 header = check_qcow2_image(&qcow2_fd, device_name);
1570 if (header) {
1571 flags |= E2IMAGE_IS_QCOW2_FLAG;
1572 goto skip_device;
1573 }
1574 }
1575 sprintf(offset_opt, "offset=%llu", source_offset);
1576 retval = ext2fs_open2(device_name, offset_opt, open_flag, 0, 0,
1577 unix_io_manager, &fs);
1578 if (retval) {
1579 com_err (program_name, retval, _("while trying to open %s"),
1580 device_name);
1581 fputs(_("Couldn't find valid filesystem superblock.\n"), stdout);
1582 if (retval == EXT2_ET_BAD_MAGIC)
1583 check_plausibility(device_name, CHECK_FS_EXIST, NULL);
1584 exit(1);
1585 }
1586
1587 skip_device:
1588 if (strcmp(image_fn, "-") == 0)
1589 fd = 1;
1590 else {
1591 int o_flags = O_CREAT|O_RDWR;
1592
1593 if (img_type != E2IMAGE_RAW)
1594 o_flags |= O_TRUNC;
1595 if (access(image_fn, F_OK) != 0)
1596 flags |= E2IMAGE_CHECK_ZERO_FLAG;
1597 fd = ext2fs_open_file(image_fn, o_flags, 0600);
1598 if (fd < 0) {
1599 com_err(program_name, errno,
1600 _("while trying to open %s"), image_fn);
1601 exit(1);
1602 }
1603 }
1604 if (dest_offset)
1605 seek_set(fd, dest_offset);
1606
1607 if ((img_type & E2IMAGE_QCOW2) && (fd == 1)) {
1608 com_err(program_name, 0, "%s",
1609 _("QCOW2 image can not be written to the stdout!\n"));
1610 exit(1);
1611 }
1612 if (fd != 1) {
1613 if (fstat(fd, &st)) {
1614 com_err(program_name, 0, "%s",
1615 _("Can not stat output\n"));
1616 exit(1);
1617 }
1618 if (S_ISBLK(st.st_mode))
1619 output_is_blk = 1;
1620 }
1621 if (flags & E2IMAGE_IS_QCOW2_FLAG) {
1622 ret = qcow2_write_raw_image(qcow2_fd, fd, header);
1623 if (ret) {
1624 if (ret == -QCOW_COMPRESSED)
1625 fprintf(stderr, _("Image (%s) is compressed\n"),
1626 image_fn);
1627 if (ret == -QCOW_ENCRYPTED)
1628 fprintf(stderr, _("Image (%s) is encrypted\n"),
1629 image_fn);
1630 com_err(program_name, ret,
1631 _("while trying to convert qcow2 image"
1632 " (%s) into raw image (%s)"),
1633 device_name, image_fn);
1634 }
1635 goto out;
1636 }
1637
1638 if (check) {
1639 if (img_type != E2IMAGE_RAW) {
1640 fprintf(stderr, "%s", _("The -c option only supported "
1641 "in raw mode\n"));
1642 exit(1);
1643 }
1644 if (fd == 1) {
1645 fprintf(stderr, "%s", _("The -c option not supported "
1646 "when writing to stdout\n"));
1647 exit(1);
1648 }
1649 retval = ext2fs_get_mem(fs->blocksize, &check_buf);
1650 if (retval) {
1651 com_err(program_name, retval, "%s",
1652 _("while allocating check_buf"));
1653 exit(1);
1654 }
1655 }
1656 if (show_progress && (img_type != E2IMAGE_RAW)) {
1657 fprintf(stderr, "%s",
1658 _("The -p option only supported in raw mode\n"));
1659 exit(1);
1660 }
1661 if (img_type)
1662 write_raw_image_file(fs, fd, img_type, flags);
1663 else
1664 write_image_file(fs, fd);
1665
1666 ext2fs_close_free(&fs);
1667 if (check)
1668 printf(_("%d blocks already contained the data to be copied\n"),
1669 skipped_blocks);
1670
1671 out:
1672 if (header)
1673 free(header);
1674 if (qcow2_fd)
1675 close(qcow2_fd);
1676 remove_error_table(&et_ext2_error_table);
1677 return ret;
1678 }
Unnamed repository; edit this file 'description' to name the repository.