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