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