qemu-img.c

   1 /*
   2  * QEMU disk image utility
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qapi-visit.h"
  25 #include "qapi/qmp-output-visitor.h"
  26 #include "qjson.h"
  27 #include "qemu-common.h"
  28 #include "qemu-option.h"
  29 #include "qemu-error.h"
  30 #include "osdep.h"
  31 #include "sysemu.h"
  32 #include "block_int.h"
  33 #include <getopt.h>
  34 #include <stdio.h>
  35
  36 #ifdef _WIN32
  37 #include <windows.h>
  38 #endif
  39
  40 typedef struct img_cmd_t {
  41     const char *name;
  42     int (*handler)(int argc, char **argv);
  43 } img_cmd_t;
  44
  45 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  46 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  47 #define BDRV_DEFAULT_CACHE "writeback"
  48
  49 static void format_print(void *opaque, const char *name)
  50 {
  51     printf(" %s", name);
  52 }
  53
  54 /* Please keep in synch with qemu-img.texi */
  55 static void help(void)
  56 {
  57     const char *help_msg =
  58            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  59            "usage: qemu-img command [command options]\n"
  60            "QEMU disk image utility\n"
  61            "\n"
  62            "Command syntax:\n"
  63 #define DEF(option, callback, arg_string)        \
  64            "  " arg_string "\n"
  65 #include "qemu-img-cmds.h"
  66 #undef DEF
  67 #undef GEN_DOCS
  68            "\n"
  69            "Command parameters:\n"
  70            "  'filename' is a disk image filename\n"
  71            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  72            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  73            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
  74            "    'directsync' and 'unsafe' (default for convert)\n"
  75            "  'size' is the disk image size in bytes. Optional suffixes\n"
  76            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
  77            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
  78            "  'output_filename' is the destination disk image filename\n"
  79            "  'output_fmt' is the destination format\n"
  80            "  'options' is a comma separated list of format specific options in a\n"
  81            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  82            "    used format\n"
  83            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  84            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
  85            "       match exactly. The image doesn't need a working backing file before\n"
  86            "       rebasing in this case (useful for renaming the backing file)\n"
  87            "  '-h' with or without a command shows this help and lists the supported formats\n"
  88            "  '-p' show progress of command (only certain commands)\n"
  89            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
  90            "       for qemu-img to create a sparse image during conversion\n"
  91            "  '--output' takes the format in which the output must be done (human or json)\n"
  92            "\n"
  93            "Parameters to check subcommand:\n"
  94            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
  95            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
  96            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
  97            "       hiding corruption that has already occurred.\n"
  98            "\n"
  99            "Parameters to snapshot subcommand:\n"
 100            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 101            "  '-a' applies a snapshot (revert disk to saved state)\n"
 102            "  '-c' creates a snapshot\n"
 103            "  '-d' deletes a snapshot\n"
 104            "  '-l' lists all snapshots in the given image\n";
 105
 106     printf("%s\nSupported formats:", help_msg);
 107     bdrv_iterate_format(format_print, NULL);
 108     printf("\n");
 109     exit(1);
 110 }
 111
 112 #if defined(WIN32)
 113 /* XXX: put correct support for win32 */
 114 static int read_password(char *buf, int buf_size)
 115 {
 116     int c, i;
 117     printf("Password: ");
 118     fflush(stdout);
 119     i = 0;
 120     for(;;) {
 121         c = getchar();
 122         if (c == '\n')
 123             break;
 124         if (i < (buf_size - 1))
 125             buf[i++] = c;
 126     }
 127     buf[i] = '\0';
 128     return 0;
 129 }
 130
 131 #else
 132
 133 #include <termios.h>
 134
 135 static struct termios oldtty;
 136
 137 static void term_exit(void)
 138 {
 139     tcsetattr (0, TCSANOW, &oldtty);
 140 }
 141
 142 static void term_init(void)
 143 {
 144     struct termios tty;
 145
 146     tcgetattr (0, &tty);
 147     oldtty = tty;
 148
 149     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 150                           |INLCR|IGNCR|ICRNL|IXON);
 151     tty.c_oflag |= OPOST;
 152     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 153     tty.c_cflag &= ~(CSIZE|PARENB);
 154     tty.c_cflag |= CS8;
 155     tty.c_cc[VMIN] = 1;
 156     tty.c_cc[VTIME] = 0;
 157
 158     tcsetattr (0, TCSANOW, &tty);
 159
 160     atexit(term_exit);
 161 }
 162
 163 static int read_password(char *buf, int buf_size)
 164 {
 165     uint8_t ch;
 166     int i, ret;
 167
 168     printf("password: ");
 169     fflush(stdout);
 170     term_init();
 171     i = 0;
 172     for(;;) {
 173         ret = read(0, &ch, 1);
 174         if (ret == -1) {
 175             if (errno == EAGAIN || errno == EINTR) {
 176                 continue;
 177             } else {
 178                 ret = -1;
 179                 break;
 180             }
 181         } else if (ret == 0) {
 182             ret = -1;
 183             break;
 184         } else {
 185             if (ch == '\r') {
 186                 ret = 0;
 187                 break;
 188             }
 189             if (i < (buf_size - 1))
 190                 buf[i++] = ch;
 191         }
 192     }
 193     term_exit();
 194     buf[i] = '\0';
 195     printf("\n");
 196     return ret;
 197 }
 198 #endif
 199
 200 static int print_block_option_help(const char *filename, const char *fmt)
 201 {
 202     BlockDriver *drv, *proto_drv;
 203     QEMUOptionParameter *create_options = NULL;
 204
 205     /* Find driver and parse its options */
 206     drv = bdrv_find_format(fmt);
 207     if (!drv) {
 208         error_report("Unknown file format '%s'", fmt);
 209         return 1;
 210     }
 211
 212     proto_drv = bdrv_find_protocol(filename);
 213     if (!proto_drv) {
 214         error_report("Unknown protocol '%s'", filename);
 215         return 1;
 216     }
 217
 218     create_options = append_option_parameters(create_options,
 219                                               drv->create_options);
 220     create_options = append_option_parameters(create_options,
 221                                               proto_drv->create_options);
 222     print_option_help(create_options);
 223     free_option_parameters(create_options);
 224     return 0;
 225 }
 226
 227 static BlockDriverState *bdrv_new_open(const char *filename,
 228                                        const char *fmt,
 229                                        int flags,
 230                                        bool require_io)
 231 {
 232     BlockDriverState *bs;
 233     BlockDriver *drv;
 234     char password[256];
 235     int ret;
 236
 237     bs = bdrv_new("image");
 238
 239     if (fmt) {
 240         drv = bdrv_find_format(fmt);
 241         if (!drv) {
 242             error_report("Unknown file format '%s'", fmt);
 243             goto fail;
 244         }
 245     } else {
 246         drv = NULL;
 247     }
 248
 249     ret = bdrv_open(bs, filename, flags, drv);
 250     if (ret < 0) {
 251         error_report("Could not open '%s': %s", filename, strerror(-ret));
 252         goto fail;
 253     }
 254
 255     if (bdrv_is_encrypted(bs) && require_io) {
 256         printf("Disk image '%s' is encrypted.\n", filename);
 257         if (read_password(password, sizeof(password)) < 0) {
 258             error_report("No password given");
 259             goto fail;
 260         }
 261         if (bdrv_set_key(bs, password) < 0) {
 262             error_report("invalid password");
 263             goto fail;
 264         }
 265     }
 266     return bs;
 267 fail:
 268     if (bs) {
 269         bdrv_delete(bs);
 270     }
 271     return NULL;
 272 }
 273
 274 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 275                                  const char *base_filename,
 276                                  const char *base_fmt)
 277 {
 278     if (base_filename) {
 279         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 280             error_report("Backing file not supported for file format '%s'",
 281                          fmt);
 282             return -1;
 283         }
 284     }
 285     if (base_fmt) {
 286         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 287             error_report("Backing file format not supported for file "
 288                          "format '%s'", fmt);
 289             return -1;
 290         }
 291     }
 292     return 0;
 293 }
 294
 295 static int img_create(int argc, char **argv)
 296 {
 297     int c, ret = 0;
 298     uint64_t img_size = -1;
 299     const char *fmt = "raw";
 300     const char *base_fmt = NULL;
 301     const char *filename;
 302     const char *base_filename = NULL;
 303     char *options = NULL;
 304
 305     for(;;) {
 306         c = getopt(argc, argv, "F:b:f:he6o:");
 307         if (c == -1) {
 308             break;
 309         }
 310         switch(c) {
 311         case '?':
 312         case 'h':
 313             help();
 314             break;
 315         case 'F':
 316             base_fmt = optarg;
 317             break;
 318         case 'b':
 319             base_filename = optarg;
 320             break;
 321         case 'f':
 322             fmt = optarg;
 323             break;
 324         case 'e':
 325             error_report("option -e is deprecated, please use \'-o "
 326                   "encryption\' instead!");
 327             return 1;
 328         case '6':
 329             error_report("option -6 is deprecated, please use \'-o "
 330                   "compat6\' instead!");
 331             return 1;
 332         case 'o':
 333             options = optarg;
 334             break;
 335         }
 336     }
 337
 338     /* Get the filename */
 339     if (optind >= argc) {
 340         help();
 341     }
 342     filename = argv[optind++];
 343
 344     /* Get image size, if specified */
 345     if (optind < argc) {
 346         int64_t sval;
 347         char *end;
 348         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 349         if (sval < 0 || *end) {
 350             error_report("Invalid image size specified! You may use k, M, G or "
 351                   "T suffixes for ");
 352             error_report("kilobytes, megabytes, gigabytes and terabytes.");
 353             ret = -1;
 354             goto out;
 355         }
 356         img_size = (uint64_t)sval;
 357     }
 358
 359     if (options && is_help_option(options)) {
 360         ret = print_block_option_help(filename, fmt);
 361         goto out;
 362     }
 363
 364     ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
 365                           options, img_size, BDRV_O_FLAGS);
 366 out:
 367     if (ret) {
 368         return 1;
 369     }
 370     return 0;
 371 }
 372
 373 /*
 374  * Checks an image for consistency. Exit codes:
 375  *
 376  * 0 - Check completed, image is good
 377  * 1 - Check not completed because of internal errors
 378  * 2 - Check completed, image is corrupted
 379  * 3 - Check completed, image has leaked clusters, but is good otherwise
 380  */
 381 static int img_check(int argc, char **argv)
 382 {
 383     int c, ret;
 384     const char *filename, *fmt;
 385     BlockDriverState *bs;
 386     BdrvCheckResult result;
 387     int fix = 0;
 388     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 389
 390     fmt = NULL;
 391     for(;;) {
 392         c = getopt(argc, argv, "f:hr:");
 393         if (c == -1) {
 394             break;
 395         }
 396         switch(c) {
 397         case '?':
 398         case 'h':
 399             help();
 400             break;
 401         case 'f':
 402             fmt = optarg;
 403             break;
 404         case 'r':
 405             flags |= BDRV_O_RDWR;
 406
 407             if (!strcmp(optarg, "leaks")) {
 408                 fix = BDRV_FIX_LEAKS;
 409             } else if (!strcmp(optarg, "all")) {
 410                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 411             } else {
 412                 help();
 413             }
 414             break;
 415         }
 416     }
 417     if (optind >= argc) {
 418         help();
 419     }
 420     filename = argv[optind++];
 421
 422     bs = bdrv_new_open(filename, fmt, flags, true);
 423     if (!bs) {
 424         return 1;
 425     }
 426     ret = bdrv_check(bs, &result, fix);
 427
 428     if (ret == -ENOTSUP) {
 429         error_report("This image format does not support checks");
 430         bdrv_delete(bs);
 431         return 1;
 432     }
 433
 434     if (result.corruptions_fixed || result.leaks_fixed) {
 435         printf("The following inconsistencies were found and repaired:\n\n"
 436                "    %d leaked clusters\n"
 437                "    %d corruptions\n\n"
 438                "Double checking the fixed image now...\n",
 439                result.leaks_fixed,
 440                result.corruptions_fixed);
 441         ret = bdrv_check(bs, &result, 0);
 442     }
 443
 444     if (!(result.corruptions || result.leaks || result.check_errors)) {
 445         printf("No errors were found on the image.\n");
 446     } else {
 447         if (result.corruptions) {
 448             printf("\n%d errors were found on the image.\n"
 449                 "Data may be corrupted, or further writes to the image "
 450                 "may corrupt it.\n",
 451                 result.corruptions);
 452         }
 453
 454         if (result.leaks) {
 455             printf("\n%d leaked clusters were found on the image.\n"
 456                 "This means waste of disk space, but no harm to data.\n",
 457                 result.leaks);
 458         }
 459
 460         if (result.check_errors) {
 461             printf("\n%d internal errors have occurred during the check.\n",
 462                 result.check_errors);
 463         }
 464     }
 465
 466     if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
 467         printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
 468         result.bfi.allocated_clusters, result.bfi.total_clusters,
 469         result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
 470         result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
 471     }
 472
 473     bdrv_delete(bs);
 474
 475     if (ret < 0 || result.check_errors) {
 476         printf("\nAn error has occurred during the check: %s\n"
 477             "The check is not complete and may have missed error.\n",
 478             strerror(-ret));
 479         return 1;
 480     }
 481
 482     if (result.corruptions) {
 483         return 2;
 484     } else if (result.leaks) {
 485         return 3;
 486     } else {
 487         return 0;
 488     }
 489 }
 490
 491 static int img_commit(int argc, char **argv)
 492 {
 493     int c, ret, flags;
 494     const char *filename, *fmt, *cache;
 495     BlockDriverState *bs;
 496
 497     fmt = NULL;
 498     cache = BDRV_DEFAULT_CACHE;
 499     for(;;) {
 500         c = getopt(argc, argv, "f:ht:");
 501         if (c == -1) {
 502             break;
 503         }
 504         switch(c) {
 505         case '?':
 506         case 'h':
 507             help();
 508             break;
 509         case 'f':
 510             fmt = optarg;
 511             break;
 512         case 't':
 513             cache = optarg;
 514             break;
 515         }
 516     }
 517     if (optind >= argc) {
 518         help();
 519     }
 520     filename = argv[optind++];
 521
 522     flags = BDRV_O_RDWR;
 523     ret = bdrv_parse_cache_flags(cache, &flags);
 524     if (ret < 0) {
 525         error_report("Invalid cache option: %s", cache);
 526         return -1;
 527     }
 528
 529     bs = bdrv_new_open(filename, fmt, flags, true);
 530     if (!bs) {
 531         return 1;
 532     }
 533     ret = bdrv_commit(bs);
 534     switch(ret) {
 535     case 0:
 536         printf("Image committed.\n");
 537         break;
 538     case -ENOENT:
 539         error_report("No disk inserted");
 540         break;
 541     case -EACCES:
 542         error_report("Image is read-only");
 543         break;
 544     case -ENOTSUP:
 545         error_report("Image is already committed");
 546         break;
 547     default:
 548         error_report("Error while committing image");
 549         break;
 550     }
 551
 552     bdrv_delete(bs);
 553     if (ret) {
 554         return 1;
 555     }
 556     return 0;
 557 }
 558
 559 /*
 560  * Returns true iff the first sector pointed to by 'buf' contains at least
 561  * a non-NUL byte.
 562  *
 563  * 'pnum' is set to the number of sectors (including and immediately following
 564  * the first one) that are known to be in the same allocated/unallocated state.
 565  */
 566 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 567 {
 568     bool is_zero;
 569     int i;
 570
 571     if (n <= 0) {
 572         *pnum = 0;
 573         return 0;
 574     }
 575     is_zero = buffer_is_zero(buf, 512);
 576     for(i = 1; i < n; i++) {
 577         buf += 512;
 578         if (is_zero != buffer_is_zero(buf, 512)) {
 579             break;
 580         }
 581     }
 582     *pnum = i;
 583     return !is_zero;
 584 }
 585
 586 /*
 587  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 588  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 589  * breaking up write requests for only small sparse areas.
 590  */
 591 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 592     int min)
 593 {
 594     int ret;
 595     int num_checked, num_used;
 596
 597     if (n < min) {
 598         min = n;
 599     }
 600
 601     ret = is_allocated_sectors(buf, n, pnum);
 602     if (!ret) {
 603         return ret;
 604     }
 605
 606     num_used = *pnum;
 607     buf += BDRV_SECTOR_SIZE * *pnum;
 608     n -= *pnum;
 609     num_checked = num_used;
 610
 611     while (n > 0) {
 612         ret = is_allocated_sectors(buf, n, pnum);
 613
 614         buf += BDRV_SECTOR_SIZE * *pnum;
 615         n -= *pnum;
 616         num_checked += *pnum;
 617         if (ret) {
 618             num_used = num_checked;
 619         } else if (*pnum >= min) {
 620             break;
 621         }
 622     }
 623
 624     *pnum = num_used;
 625     return 1;
 626 }
 627
 628 /*
 629  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 630  * buffers matches, non-zero otherwise.
 631  *
 632  * pnum is set to the number of sectors (including and immediately following
 633  * the first one) that are known to have the same comparison result
 634  */
 635 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 636     int *pnum)
 637 {
 638     int res, i;
 639
 640     if (n <= 0) {
 641         *pnum = 0;
 642         return 0;
 643     }
 644
 645     res = !!memcmp(buf1, buf2, 512);
 646     for(i = 1; i < n; i++) {
 647         buf1 += 512;
 648         buf2 += 512;
 649
 650         if (!!memcmp(buf1, buf2, 512) != res) {
 651             break;
 652         }
 653     }
 654
 655     *pnum = i;
 656     return res;
 657 }
 658
 659 #define IO_BUF_SIZE (2 * 1024 * 1024)
 660
 661 static int img_convert(int argc, char **argv)
 662 {
 663     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
 664     int progress = 0, flags;
 665     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
 666     BlockDriver *drv, *proto_drv;
 667     BlockDriverState **bs = NULL, *out_bs = NULL;
 668     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 669     uint64_t bs_sectors;
 670     uint8_t * buf = NULL;
 671     const uint8_t *buf1;
 672     BlockDriverInfo bdi;
 673     QEMUOptionParameter *param = NULL, *create_options = NULL;
 674     QEMUOptionParameter *out_baseimg_param;
 675     char *options = NULL;
 676     const char *snapshot_name = NULL;
 677     float local_progress = 0;
 678     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
 679
 680     fmt = NULL;
 681     out_fmt = "raw";
 682     cache = "unsafe";
 683     out_baseimg = NULL;
 684     compress = 0;
 685     for(;;) {
 686         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
 687         if (c == -1) {
 688             break;
 689         }
 690         switch(c) {
 691         case '?':
 692         case 'h':
 693             help();
 694             break;
 695         case 'f':
 696             fmt = optarg;
 697             break;
 698         case 'O':
 699             out_fmt = optarg;
 700             break;
 701         case 'B':
 702             out_baseimg = optarg;
 703             break;
 704         case 'c':
 705             compress = 1;
 706             break;
 707         case 'e':
 708             error_report("option -e is deprecated, please use \'-o "
 709                   "encryption\' instead!");
 710             return 1;
 711         case '6':
 712             error_report("option -6 is deprecated, please use \'-o "
 713                   "compat6\' instead!");
 714             return 1;
 715         case 'o':
 716             options = optarg;
 717             break;
 718         case 's':
 719             snapshot_name = optarg;
 720             break;
 721         case 'S':
 722         {
 723             int64_t sval;
 724             char *end;
 725             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
 726             if (sval < 0 || *end) {
 727                 error_report("Invalid minimum zero buffer size for sparse output specified");
 728                 return 1;
 729             }
 730
 731             min_sparse = sval / BDRV_SECTOR_SIZE;
 732             break;
 733         }
 734         case 'p':
 735             progress = 1;
 736             break;
 737         case 't':
 738             cache = optarg;
 739             break;
 740         }
 741     }
 742
 743     bs_n = argc - optind - 1;
 744     if (bs_n < 1) {
 745         help();
 746     }
 747
 748     out_filename = argv[argc - 1];
 749
 750     /* Initialize before goto out */
 751     qemu_progress_init(progress, 2.0);
 752
 753     if (options && is_help_option(options)) {
 754         ret = print_block_option_help(out_filename, out_fmt);
 755         goto out;
 756     }
 757
 758     if (bs_n > 1 && out_baseimg) {
 759         error_report("-B makes no sense when concatenating multiple input "
 760                      "images");
 761         ret = -1;
 762         goto out;
 763     }
 764
 765     qemu_progress_print(0, 100);
 766
 767     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
 768
 769     total_sectors = 0;
 770     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 771         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
 772         if (!bs[bs_i]) {
 773             error_report("Could not open '%s'", argv[optind + bs_i]);
 774             ret = -1;
 775             goto out;
 776         }
 777         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 778         total_sectors += bs_sectors;
 779     }
 780
 781     if (snapshot_name != NULL) {
 782         if (bs_n > 1) {
 783             error_report("No support for concatenating multiple snapshot");
 784             ret = -1;
 785             goto out;
 786         }
 787         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
 788             error_report("Failed to load snapshot");
 789             ret = -1;
 790             goto out;
 791         }
 792     }
 793
 794     /* Find driver and parse its options */
 795     drv = bdrv_find_format(out_fmt);
 796     if (!drv) {
 797         error_report("Unknown file format '%s'", out_fmt);
 798         ret = -1;
 799         goto out;
 800     }
 801
 802     proto_drv = bdrv_find_protocol(out_filename);
 803     if (!proto_drv) {
 804         error_report("Unknown protocol '%s'", out_filename);
 805         ret = -1;
 806         goto out;
 807     }
 808
 809     create_options = append_option_parameters(create_options,
 810                                               drv->create_options);
 811     create_options = append_option_parameters(create_options,
 812                                               proto_drv->create_options);
 813
 814     if (options) {
 815         param = parse_option_parameters(options, create_options, param);
 816         if (param == NULL) {
 817             error_report("Invalid options for file format '%s'.", out_fmt);
 818             ret = -1;
 819             goto out;
 820         }
 821     } else {
 822         param = parse_option_parameters("", create_options, param);
 823     }
 824
 825     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 826     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
 827     if (ret < 0) {
 828         goto out;
 829     }
 830
 831     /* Get backing file name if -o backing_file was used */
 832     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 833     if (out_baseimg_param) {
 834         out_baseimg = out_baseimg_param->value.s;
 835     }
 836
 837     /* Check if compression is supported */
 838     if (compress) {
 839         QEMUOptionParameter *encryption =
 840             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 841         QEMUOptionParameter *preallocation =
 842             get_option_parameter(param, BLOCK_OPT_PREALLOC);
 843
 844         if (!drv->bdrv_write_compressed) {
 845             error_report("Compression not supported for this file format");
 846             ret = -1;
 847             goto out;
 848         }
 849
 850         if (encryption && encryption->value.n) {
 851             error_report("Compression and encryption not supported at "
 852                          "the same time");
 853             ret = -1;
 854             goto out;
 855         }
 856
 857         if (preallocation && preallocation->value.s
 858             && strcmp(preallocation->value.s, "off"))
 859         {
 860             error_report("Compression and preallocation not supported at "
 861                          "the same time");
 862             ret = -1;
 863             goto out;
 864         }
 865     }
 866
 867     /* Create the new image */
 868     ret = bdrv_create(drv, out_filename, param);
 869     if (ret < 0) {
 870         if (ret == -ENOTSUP) {
 871             error_report("Formatting not supported for file format '%s'",
 872                          out_fmt);
 873         } else if (ret == -EFBIG) {
 874             error_report("The image size is too large for file format '%s'",
 875                          out_fmt);
 876         } else {
 877             error_report("%s: error while converting %s: %s",
 878                          out_filename, out_fmt, strerror(-ret));
 879         }
 880         goto out;
 881     }
 882
 883     flags = BDRV_O_RDWR;
 884     ret = bdrv_parse_cache_flags(cache, &flags);
 885     if (ret < 0) {
 886         error_report("Invalid cache option: %s", cache);
 887         return -1;
 888     }
 889
 890     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
 891     if (!out_bs) {
 892         ret = -1;
 893         goto out;
 894     }
 895
 896     bs_i = 0;
 897     bs_offset = 0;
 898     bdrv_get_geometry(bs[0], &bs_sectors);
 899     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
 900
 901     if (compress) {
 902         ret = bdrv_get_info(out_bs, &bdi);
 903         if (ret < 0) {
 904             error_report("could not get block driver info");
 905             goto out;
 906         }
 907         cluster_size = bdi.cluster_size;
 908         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
 909             error_report("invalid cluster size");
 910             ret = -1;
 911             goto out;
 912         }
 913         cluster_sectors = cluster_size >> 9;
 914         sector_num = 0;
 915
 916         nb_sectors = total_sectors;
 917         if (nb_sectors != 0) {
 918             local_progress = (float)100 /
 919                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
 920         }
 921
 922         for(;;) {
 923             int64_t bs_num;
 924             int remainder;
 925             uint8_t *buf2;
 926
 927             nb_sectors = total_sectors - sector_num;
 928             if (nb_sectors <= 0)
 929                 break;
 930             if (nb_sectors >= cluster_sectors)
 931                 n = cluster_sectors;
 932             else
 933                 n = nb_sectors;
 934
 935             bs_num = sector_num - bs_offset;
 936             assert (bs_num >= 0);
 937             remainder = n;
 938             buf2 = buf;
 939             while (remainder > 0) {
 940                 int nlow;
 941                 while (bs_num == bs_sectors) {
 942                     bs_i++;
 943                     assert (bs_i < bs_n);
 944                     bs_offset += bs_sectors;
 945                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 946                     bs_num = 0;
 947                     /* printf("changing part: sector_num=%" PRId64 ", "
 948                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
 949                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
 950                 }
 951                 assert (bs_num < bs_sectors);
 952
 953                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 954
 955                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
 956                 if (ret < 0) {
 957                     error_report("error while reading sector %" PRId64 ": %s",
 958                                  bs_num, strerror(-ret));
 959                     goto out;
 960                 }
 961
 962                 buf2 += nlow * 512;
 963                 bs_num += nlow;
 964
 965                 remainder -= nlow;
 966             }
 967             assert (remainder == 0);
 968
 969             if (n < cluster_sectors) {
 970                 memset(buf + n * 512, 0, cluster_size - n * 512);
 971             }
 972             if (!buffer_is_zero(buf, cluster_size)) {
 973                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
 974                                             cluster_sectors);
 975                 if (ret != 0) {
 976                     error_report("error while compressing sector %" PRId64
 977                                  ": %s", sector_num, strerror(-ret));
 978                     goto out;
 979                 }
 980             }
 981             sector_num += n;
 982             qemu_progress_print(local_progress, 100);
 983         }
 984         /* signal EOF to align */
 985         bdrv_write_compressed(out_bs, 0, NULL, 0);
 986     } else {
 987         int has_zero_init = bdrv_has_zero_init(out_bs);
 988
 989         sector_num = 0; // total number of sectors converted so far
 990         nb_sectors = total_sectors - sector_num;
 991         if (nb_sectors != 0) {
 992             local_progress = (float)100 /
 993                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
 994         }
 995
 996         for(;;) {
 997             nb_sectors = total_sectors - sector_num;
 998             if (nb_sectors <= 0) {
 999                 break;
1000             }
1001             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1002                 n = (IO_BUF_SIZE / 512);
1003             } else {
1004                 n = nb_sectors;
1005             }
1006
1007             while (sector_num - bs_offset >= bs_sectors) {
1008                 bs_i ++;
1009                 assert (bs_i < bs_n);
1010                 bs_offset += bs_sectors;
1011                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1012                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1013                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1014                    sector_num, bs_i, bs_offset, bs_sectors); */
1015             }
1016
1017             if (n > bs_offset + bs_sectors - sector_num) {
1018                 n = bs_offset + bs_sectors - sector_num;
1019             }
1020
1021             if (has_zero_init) {
1022                 /* If the output image is being created as a copy on write image,
1023                    assume that sectors which are unallocated in the input image
1024                    are present in both the output's and input's base images (no
1025                    need to copy them). */
1026                 if (out_baseimg) {
1027                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1028                                            n, &n1)) {
1029                         sector_num += n1;
1030                         continue;
1031                     }
1032                     /* The next 'n1' sectors are allocated in the input image. Copy
1033                        only those as they may be followed by unallocated sectors. */
1034                     n = n1;
1035                 }
1036             } else {
1037                 n1 = n;
1038             }
1039
1040             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1041             if (ret < 0) {
1042                 error_report("error while reading sector %" PRId64 ": %s",
1043                              sector_num - bs_offset, strerror(-ret));
1044                 goto out;
1045             }
1046             /* NOTE: at the same time we convert, we do not write zero
1047                sectors to have a chance to compress the image. Ideally, we
1048                should add a specific call to have the info to go faster */
1049             buf1 = buf;
1050             while (n > 0) {
1051                 /* If the output image is being created as a copy on write image,
1052                    copy all sectors even the ones containing only NUL bytes,
1053                    because they may differ from the sectors in the base image.
1054
1055                    If the output is to a host device, we also write out
1056                    sectors that are entirely 0, since whatever data was
1057                    already there is garbage, not 0s. */
1058                 if (!has_zero_init || out_baseimg ||
1059                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1060                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1061                     if (ret < 0) {
1062                         error_report("error while writing sector %" PRId64
1063                                      ": %s", sector_num, strerror(-ret));
1064                         goto out;
1065                     }
1066                 }
1067                 sector_num += n1;
1068                 n -= n1;
1069                 buf1 += n1 * 512;
1070             }
1071             qemu_progress_print(local_progress, 100);
1072         }
1073     }
1074 out:
1075     qemu_progress_end();
1076     free_option_parameters(create_options);
1077     free_option_parameters(param);
1078     qemu_vfree(buf);
1079     if (out_bs) {
1080         bdrv_delete(out_bs);
1081     }
1082     if (bs) {
1083         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1084             if (bs[bs_i]) {
1085                 bdrv_delete(bs[bs_i]);
1086             }
1087         }
1088         g_free(bs);
1089     }
1090     if (ret) {
1091         return 1;
1092     }
1093     return 0;
1094 }
1095
1096
1097 static void dump_snapshots(BlockDriverState *bs)
1098 {
1099     QEMUSnapshotInfo *sn_tab, *sn;
1100     int nb_sns, i;
1101     char buf[256];
1102
1103     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1104     if (nb_sns <= 0)
1105         return;
1106     printf("Snapshot list:\n");
1107     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1108     for(i = 0; i < nb_sns; i++) {
1109         sn = &sn_tab[i];
1110         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1111     }
1112     g_free(sn_tab);
1113 }
1114
1115 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1116 {
1117     int i, sn_count;
1118     QEMUSnapshotInfo *sn_tab = NULL;
1119     SnapshotInfoList *info_list, *cur_item = NULL;
1120     sn_count = bdrv_snapshot_list(bs, &sn_tab);
1121
1122     for (i = 0; i < sn_count; i++) {
1123         info->has_snapshots = true;
1124         info_list = g_new0(SnapshotInfoList, 1);
1125
1126         info_list->value                = g_new0(SnapshotInfo, 1);
1127         info_list->value->id            = g_strdup(sn_tab[i].id_str);
1128         info_list->value->name          = g_strdup(sn_tab[i].name);
1129         info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1130         info_list->value->date_sec      = sn_tab[i].date_sec;
1131         info_list->value->date_nsec     = sn_tab[i].date_nsec;
1132         info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
1133         info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1134
1135         /* XXX: waiting for the qapi to support qemu-queue.h types */
1136         if (!cur_item) {
1137             info->snapshots = cur_item = info_list;
1138         } else {
1139             cur_item->next = info_list;
1140             cur_item = info_list;
1141         }
1142
1143     }
1144
1145     g_free(sn_tab);
1146 }
1147
1148 static void dump_json_image_info(ImageInfo *info)
1149 {
1150     Error *errp = NULL;
1151     QString *str;
1152     QmpOutputVisitor *ov = qmp_output_visitor_new();
1153     QObject *obj;
1154     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1155                          &info, NULL, &errp);
1156     obj = qmp_output_get_qobject(ov);
1157     str = qobject_to_json_pretty(obj);
1158     assert(str != NULL);
1159     printf("%s\n", qstring_get_str(str));
1160     qobject_decref(obj);
1161     qmp_output_visitor_cleanup(ov);
1162     QDECREF(str);
1163 }
1164
1165 static void collect_image_info(BlockDriverState *bs,
1166                    ImageInfo *info,
1167                    const char *filename,
1168                    const char *fmt)
1169 {
1170     uint64_t total_sectors;
1171     char backing_filename[1024];
1172     char backing_filename2[1024];
1173     BlockDriverInfo bdi;
1174
1175     bdrv_get_geometry(bs, &total_sectors);
1176
1177     info->filename        = g_strdup(filename);
1178     info->format          = g_strdup(bdrv_get_format_name(bs));
1179     info->virtual_size    = total_sectors * 512;
1180     info->actual_size     = bdrv_get_allocated_file_size(bs);
1181     info->has_actual_size = info->actual_size >= 0;
1182     if (bdrv_is_encrypted(bs)) {
1183         info->encrypted = true;
1184         info->has_encrypted = true;
1185     }
1186     if (bdrv_get_info(bs, &bdi) >= 0) {
1187         if (bdi.cluster_size != 0) {
1188             info->cluster_size = bdi.cluster_size;
1189             info->has_cluster_size = true;
1190         }
1191         info->dirty_flag = bdi.is_dirty;
1192         info->has_dirty_flag = true;
1193     }
1194     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1195     if (backing_filename[0] != '\0') {
1196         info->backing_filename = g_strdup(backing_filename);
1197         info->has_backing_filename = true;
1198         bdrv_get_full_backing_filename(bs, backing_filename2,
1199                                        sizeof(backing_filename2));
1200
1201         if (strcmp(backing_filename, backing_filename2) != 0) {
1202             info->full_backing_filename =
1203                         g_strdup(backing_filename2);
1204             info->has_full_backing_filename = true;
1205         }
1206
1207         if (bs->backing_format[0]) {
1208             info->backing_filename_format = g_strdup(bs->backing_format);
1209             info->has_backing_filename_format = true;
1210         }
1211     }
1212 }
1213
1214 static void dump_human_image_info(ImageInfo *info)
1215 {
1216     char size_buf[128], dsize_buf[128];
1217     if (!info->has_actual_size) {
1218         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1219     } else {
1220         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1221                                 info->actual_size);
1222     }
1223     get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1224     printf("image: %s\n"
1225            "file format: %s\n"
1226            "virtual size: %s (%" PRId64 " bytes)\n"
1227            "disk size: %s\n",
1228            info->filename, info->format, size_buf,
1229            info->virtual_size,
1230            dsize_buf);
1231
1232     if (info->has_encrypted && info->encrypted) {
1233         printf("encrypted: yes\n");
1234     }
1235
1236     if (info->has_cluster_size) {
1237         printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1238     }
1239
1240     if (info->has_dirty_flag && info->dirty_flag) {
1241         printf("cleanly shut down: no\n");
1242     }
1243
1244     if (info->has_backing_filename) {
1245         printf("backing file: %s", info->backing_filename);
1246         if (info->has_full_backing_filename) {
1247             printf(" (actual path: %s)", info->full_backing_filename);
1248         }
1249         putchar('\n');
1250         if (info->has_backing_filename_format) {
1251             printf("backing file format: %s\n", info->backing_filename_format);
1252         }
1253     }
1254 }
1255
1256 enum {OPTION_OUTPUT = 256};
1257
1258 typedef enum OutputFormat {
1259     OFORMAT_JSON,
1260     OFORMAT_HUMAN,
1261 } OutputFormat;
1262
1263 static int img_info(int argc, char **argv)
1264 {
1265     int c;
1266     OutputFormat output_format = OFORMAT_HUMAN;
1267     const char *filename, *fmt, *output;
1268     BlockDriverState *bs;
1269     ImageInfo *info;
1270
1271     fmt = NULL;
1272     output = NULL;
1273     for(;;) {
1274         int option_index = 0;
1275         static const struct option long_options[] = {
1276             {"help", no_argument, 0, 'h'},
1277             {"format", required_argument, 0, 'f'},
1278             {"output", required_argument, 0, OPTION_OUTPUT},
1279             {0, 0, 0, 0}
1280         };
1281         c = getopt_long(argc, argv, "f:h",
1282                         long_options, &option_index);
1283         if (c == -1) {
1284             break;
1285         }
1286         switch(c) {
1287         case '?':
1288         case 'h':
1289             help();
1290             break;
1291         case 'f':
1292             fmt = optarg;
1293             break;
1294         case OPTION_OUTPUT:
1295             output = optarg;
1296             break;
1297         }
1298     }
1299     if (optind >= argc) {
1300         help();
1301     }
1302     filename = argv[optind++];
1303
1304     if (output && !strcmp(output, "json")) {
1305         output_format = OFORMAT_JSON;
1306     } else if (output && !strcmp(output, "human")) {
1307         output_format = OFORMAT_HUMAN;
1308     } else if (output) {
1309         error_report("--output must be used with human or json as argument.");
1310         return 1;
1311     }
1312
1313     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING, false);
1314     if (!bs) {
1315         return 1;
1316     }
1317
1318     info = g_new0(ImageInfo, 1);
1319     collect_image_info(bs, info, filename, fmt);
1320
1321     switch (output_format) {
1322     case OFORMAT_HUMAN:
1323         dump_human_image_info(info);
1324         dump_snapshots(bs);
1325         break;
1326     case OFORMAT_JSON:
1327         collect_snapshots(bs, info);
1328         dump_json_image_info(info);
1329         break;
1330     }
1331
1332     qapi_free_ImageInfo(info);
1333     bdrv_delete(bs);
1334     return 0;
1335 }
1336
1337 #define SNAPSHOT_LIST   1
1338 #define SNAPSHOT_CREATE 2
1339 #define SNAPSHOT_APPLY  3
1340 #define SNAPSHOT_DELETE 4
1341
1342 static int img_snapshot(int argc, char **argv)
1343 {
1344     BlockDriverState *bs;
1345     QEMUSnapshotInfo sn;
1346     char *filename, *snapshot_name = NULL;
1347     int c, ret = 0, bdrv_oflags;
1348     int action = 0;
1349     qemu_timeval tv;
1350
1351     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1352     /* Parse commandline parameters */
1353     for(;;) {
1354         c = getopt(argc, argv, "la:c:d:h");
1355         if (c == -1) {
1356             break;
1357         }
1358         switch(c) {
1359         case '?':
1360         case 'h':
1361             help();
1362             return 0;
1363         case 'l':
1364             if (action) {
1365                 help();
1366                 return 0;
1367             }
1368             action = SNAPSHOT_LIST;
1369             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1370             break;
1371         case 'a':
1372             if (action) {
1373                 help();
1374                 return 0;
1375             }
1376             action = SNAPSHOT_APPLY;
1377             snapshot_name = optarg;
1378             break;
1379         case 'c':
1380             if (action) {
1381                 help();
1382                 return 0;
1383             }
1384             action = SNAPSHOT_CREATE;
1385             snapshot_name = optarg;
1386             break;
1387         case 'd':
1388             if (action) {
1389                 help();
1390                 return 0;
1391             }
1392             action = SNAPSHOT_DELETE;
1393             snapshot_name = optarg;
1394             break;
1395         }
1396     }
1397
1398     if (optind >= argc) {
1399         help();
1400     }
1401     filename = argv[optind++];
1402
1403     /* Open the image */
1404     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1405     if (!bs) {
1406         return 1;
1407     }
1408
1409     /* Perform the requested action */
1410     switch(action) {
1411     case SNAPSHOT_LIST:
1412         dump_snapshots(bs);
1413         break;
1414
1415     case SNAPSHOT_CREATE:
1416         memset(&sn, 0, sizeof(sn));
1417         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1418
1419         qemu_gettimeofday(&tv);
1420         sn.date_sec = tv.tv_sec;
1421         sn.date_nsec = tv.tv_usec * 1000;
1422
1423         ret = bdrv_snapshot_create(bs, &sn);
1424         if (ret) {
1425             error_report("Could not create snapshot '%s': %d (%s)",
1426                 snapshot_name, ret, strerror(-ret));
1427         }
1428         break;
1429
1430     case SNAPSHOT_APPLY:
1431         ret = bdrv_snapshot_goto(bs, snapshot_name);
1432         if (ret) {
1433             error_report("Could not apply snapshot '%s': %d (%s)",
1434                 snapshot_name, ret, strerror(-ret));
1435         }
1436         break;
1437
1438     case SNAPSHOT_DELETE:
1439         ret = bdrv_snapshot_delete(bs, snapshot_name);
1440         if (ret) {
1441             error_report("Could not delete snapshot '%s': %d (%s)",
1442                 snapshot_name, ret, strerror(-ret));
1443         }
1444         break;
1445     }
1446
1447     /* Cleanup */
1448     bdrv_delete(bs);
1449     if (ret) {
1450         return 1;
1451     }
1452     return 0;
1453 }
1454
1455 static int img_rebase(int argc, char **argv)
1456 {
1457     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1458     BlockDriver *old_backing_drv, *new_backing_drv;
1459     char *filename;
1460     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1461     int c, flags, ret;
1462     int unsafe = 0;
1463     int progress = 0;
1464
1465     /* Parse commandline parameters */
1466     fmt = NULL;
1467     cache = BDRV_DEFAULT_CACHE;
1468     out_baseimg = NULL;
1469     out_basefmt = NULL;
1470     for(;;) {
1471         c = getopt(argc, argv, "uhf:F:b:pt:");
1472         if (c == -1) {
1473             break;
1474         }
1475         switch(c) {
1476         case '?':
1477         case 'h':
1478             help();
1479             return 0;
1480         case 'f':
1481             fmt = optarg;
1482             break;
1483         case 'F':
1484             out_basefmt = optarg;
1485             break;
1486         case 'b':
1487             out_baseimg = optarg;
1488             break;
1489         case 'u':
1490             unsafe = 1;
1491             break;
1492         case 'p':
1493             progress = 1;
1494             break;
1495         case 't':
1496             cache = optarg;
1497             break;
1498         }
1499     }
1500
1501     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1502         help();
1503     }
1504     filename = argv[optind++];
1505
1506     qemu_progress_init(progress, 2.0);
1507     qemu_progress_print(0, 100);
1508
1509     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1510     ret = bdrv_parse_cache_flags(cache, &flags);
1511     if (ret < 0) {
1512         error_report("Invalid cache option: %s", cache);
1513         return -1;
1514     }
1515
1516     /*
1517      * Open the images.
1518      *
1519      * Ignore the old backing file for unsafe rebase in case we want to correct
1520      * the reference to a renamed or moved backing file.
1521      */
1522     bs = bdrv_new_open(filename, fmt, flags, true);
1523     if (!bs) {
1524         return 1;
1525     }
1526
1527     /* Find the right drivers for the backing files */
1528     old_backing_drv = NULL;
1529     new_backing_drv = NULL;
1530
1531     if (!unsafe && bs->backing_format[0] != '\0') {
1532         old_backing_drv = bdrv_find_format(bs->backing_format);
1533         if (old_backing_drv == NULL) {
1534             error_report("Invalid format name: '%s'", bs->backing_format);
1535             ret = -1;
1536             goto out;
1537         }
1538     }
1539
1540     if (out_basefmt != NULL) {
1541         new_backing_drv = bdrv_find_format(out_basefmt);
1542         if (new_backing_drv == NULL) {
1543             error_report("Invalid format name: '%s'", out_basefmt);
1544             ret = -1;
1545             goto out;
1546         }
1547     }
1548
1549     /* For safe rebasing we need to compare old and new backing file */
1550     if (unsafe) {
1551         /* Make the compiler happy */
1552         bs_old_backing = NULL;
1553         bs_new_backing = NULL;
1554     } else {
1555         char backing_name[1024];
1556
1557         bs_old_backing = bdrv_new("old_backing");
1558         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1559         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1560                         old_backing_drv);
1561         if (ret) {
1562             error_report("Could not open old backing file '%s'", backing_name);
1563             goto out;
1564         }
1565         if (out_baseimg[0]) {
1566             bs_new_backing = bdrv_new("new_backing");
1567             ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1568                         new_backing_drv);
1569             if (ret) {
1570                 error_report("Could not open new backing file '%s'",
1571                              out_baseimg);
1572                 goto out;
1573             }
1574         }
1575     }
1576
1577     /*
1578      * Check each unallocated cluster in the COW file. If it is unallocated,
1579      * accesses go to the backing file. We must therefore compare this cluster
1580      * in the old and new backing file, and if they differ we need to copy it
1581      * from the old backing file into the COW file.
1582      *
1583      * If qemu-img crashes during this step, no harm is done. The content of
1584      * the image is the same as the original one at any time.
1585      */
1586     if (!unsafe) {
1587         uint64_t num_sectors;
1588         uint64_t old_backing_num_sectors;
1589         uint64_t new_backing_num_sectors = 0;
1590         uint64_t sector;
1591         int n;
1592         uint8_t * buf_old;
1593         uint8_t * buf_new;
1594         float local_progress = 0;
1595
1596         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1597         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
1598
1599         bdrv_get_geometry(bs, &num_sectors);
1600         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1601         if (bs_new_backing) {
1602             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
1603         }
1604
1605         if (num_sectors != 0) {
1606             local_progress = (float)100 /
1607                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1608         }
1609
1610         for (sector = 0; sector < num_sectors; sector += n) {
1611
1612             /* How many sectors can we handle with the next read? */
1613             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1614                 n = (IO_BUF_SIZE / 512);
1615             } else {
1616                 n = num_sectors - sector;
1617             }
1618
1619             /* If the cluster is allocated, we don't need to take action */
1620             ret = bdrv_is_allocated(bs, sector, n, &n);
1621             if (ret) {
1622                 continue;
1623             }
1624
1625             /*
1626              * Read old and new backing file and take into consideration that
1627              * backing files may be smaller than the COW image.
1628              */
1629             if (sector >= old_backing_num_sectors) {
1630                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1631             } else {
1632                 if (sector + n > old_backing_num_sectors) {
1633                     n = old_backing_num_sectors - sector;
1634                 }
1635
1636                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1637                 if (ret < 0) {
1638                     error_report("error while reading from old backing file");
1639                     goto out;
1640                 }
1641             }
1642
1643             if (sector >= new_backing_num_sectors || !bs_new_backing) {
1644                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1645             } else {
1646                 if (sector + n > new_backing_num_sectors) {
1647                     n = new_backing_num_sectors - sector;
1648                 }
1649
1650                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1651                 if (ret < 0) {
1652                     error_report("error while reading from new backing file");
1653                     goto out;
1654                 }
1655             }
1656
1657             /* If they differ, we need to write to the COW file */
1658             uint64_t written = 0;
1659
1660             while (written < n) {
1661                 int pnum;
1662
1663                 if (compare_sectors(buf_old + written * 512,
1664                     buf_new + written * 512, n - written, &pnum))
1665                 {
1666                     ret = bdrv_write(bs, sector + written,
1667                         buf_old + written * 512, pnum);
1668                     if (ret < 0) {
1669                         error_report("Error while writing to COW image: %s",
1670                             strerror(-ret));
1671                         goto out;
1672                     }
1673                 }
1674
1675                 written += pnum;
1676             }
1677             qemu_progress_print(local_progress, 100);
1678         }
1679
1680         qemu_vfree(buf_old);
1681         qemu_vfree(buf_new);
1682     }
1683
1684     /*
1685      * Change the backing file. All clusters that are different from the old
1686      * backing file are overwritten in the COW file now, so the visible content
1687      * doesn't change when we switch the backing file.
1688      */
1689     if (out_baseimg && *out_baseimg) {
1690         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1691     } else {
1692         ret = bdrv_change_backing_file(bs, NULL, NULL);
1693     }
1694
1695     if (ret == -ENOSPC) {
1696         error_report("Could not change the backing file to '%s': No "
1697                      "space left in the file header", out_baseimg);
1698     } else if (ret < 0) {
1699         error_report("Could not change the backing file to '%s': %s",
1700             out_baseimg, strerror(-ret));
1701     }
1702
1703     qemu_progress_print(100, 0);
1704     /*
1705      * TODO At this point it is possible to check if any clusters that are
1706      * allocated in the COW file are the same in the backing file. If so, they
1707      * could be dropped from the COW file. Don't do this before switching the
1708      * backing file, in case of a crash this would lead to corruption.
1709      */
1710 out:
1711     qemu_progress_end();
1712     /* Cleanup */
1713     if (!unsafe) {
1714         if (bs_old_backing != NULL) {
1715             bdrv_delete(bs_old_backing);
1716         }
1717         if (bs_new_backing != NULL) {
1718             bdrv_delete(bs_new_backing);
1719         }
1720     }
1721
1722     bdrv_delete(bs);
1723     if (ret) {
1724         return 1;
1725     }
1726     return 0;
1727 }
1728
1729 static int img_resize(int argc, char **argv)
1730 {
1731     int c, ret, relative;
1732     const char *filename, *fmt, *size;
1733     int64_t n, total_size;
1734     BlockDriverState *bs = NULL;
1735     QemuOpts *param;
1736     static QemuOptsList resize_options = {
1737         .name = "resize_options",
1738         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
1739         .desc = {
1740             {
1741                 .name = BLOCK_OPT_SIZE,
1742                 .type = QEMU_OPT_SIZE,
1743                 .help = "Virtual disk size"
1744             }, {
1745                 /* end of list */
1746             }
1747         },
1748     };
1749
1750     /* Remove size from argv manually so that negative numbers are not treated
1751      * as options by getopt. */
1752     if (argc < 3) {
1753         help();
1754         return 1;
1755     }
1756
1757     size = argv[--argc];
1758
1759     /* Parse getopt arguments */
1760     fmt = NULL;
1761     for(;;) {
1762         c = getopt(argc, argv, "f:h");
1763         if (c == -1) {
1764             break;
1765         }
1766         switch(c) {
1767         case '?':
1768         case 'h':
1769             help();
1770             break;
1771         case 'f':
1772             fmt = optarg;
1773             break;
1774         }
1775     }
1776     if (optind >= argc) {
1777         help();
1778     }
1779     filename = argv[optind++];
1780
1781     /* Choose grow, shrink, or absolute resize mode */
1782     switch (size[0]) {
1783     case '+':
1784         relative = 1;
1785         size++;
1786         break;
1787     case '-':
1788         relative = -1;
1789         size++;
1790         break;
1791     default:
1792         relative = 0;
1793         break;
1794     }
1795
1796     /* Parse size */
1797     param = qemu_opts_create(&resize_options, NULL, 0, NULL);
1798     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1799         /* Error message already printed when size parsing fails */
1800         ret = -1;
1801         qemu_opts_del(param);
1802         goto out;
1803     }
1804     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
1805     qemu_opts_del(param);
1806
1807     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1808     if (!bs) {
1809         ret = -1;
1810         goto out;
1811     }
1812
1813     if (relative) {
1814         total_size = bdrv_getlength(bs) + n * relative;
1815     } else {
1816         total_size = n;
1817     }
1818     if (total_size <= 0) {
1819         error_report("New image size must be positive");
1820         ret = -1;
1821         goto out;
1822     }
1823
1824     ret = bdrv_truncate(bs, total_size);
1825     switch (ret) {
1826     case 0:
1827         printf("Image resized.\n");
1828         break;
1829     case -ENOTSUP:
1830         error_report("This image does not support resize");
1831         break;
1832     case -EACCES:
1833         error_report("Image is read-only");
1834         break;
1835     default:
1836         error_report("Error resizing image (%d)", -ret);
1837         break;
1838     }
1839 out:
1840     if (bs) {
1841         bdrv_delete(bs);
1842     }
1843     if (ret) {
1844         return 1;
1845     }
1846     return 0;
1847 }
1848
1849 static const img_cmd_t img_cmds[] = {
1850 #define DEF(option, callback, arg_string)        \
1851     { option, callback },
1852 #include "qemu-img-cmds.h"
1853 #undef DEF
1854 #undef GEN_DOCS
1855     { NULL, NULL, },
1856 };
1857
1858 int main(int argc, char **argv)
1859 {
1860     const img_cmd_t *cmd;
1861     const char *cmdname;
1862
1863     error_set_progname(argv[0]);
1864
1865     bdrv_init();
1866     if (argc < 2)
1867         help();
1868     cmdname = argv[1];
1869     argc--; argv++;
1870
1871     qemu_init_main_loop();
1872
1873     /* find the command */
1874     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1875         if (!strcmp(cmdname, cmd->name)) {
1876             return cmd->handler(argc, argv);
1877         }
1878     }
1879
1880     /* not found */
1881     help();
1882     return 0;
1883 }