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 "qapi/qmp/qjson.h"
  27 #include "qemu-common.h"
  28 #include "qemu/option.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/osdep.h"
  31 #include "sysemu/sysemu.h"
  32 #include "block/block_int.h"
  33 #include "block/qapi.h"
  34 #include <getopt.h>
  35 #include <stdio.h>
  36 #include <stdarg.h>
  37
  38 #ifdef _WIN32
  39 #include <windows.h>
  40 #endif
  41
  42 typedef struct img_cmd_t {
  43     const char *name;
  44     int (*handler)(int argc, char **argv);
  45 } img_cmd_t;
  46
  47 enum {
  48     OPTION_OUTPUT = 256,
  49     OPTION_BACKING_CHAIN = 257,
  50 };
  51
  52 typedef enum OutputFormat {
  53     OFORMAT_JSON,
  54     OFORMAT_HUMAN,
  55 } OutputFormat;
  56
  57 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  58 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  59 #define BDRV_DEFAULT_CACHE "writeback"
  60
  61 static void format_print(void *opaque, const char *name)
  62 {
  63     printf(" %s", name);
  64 }
  65
  66 /* Please keep in synch with qemu-img.texi */
  67 static void help(void)
  68 {
  69     const char *help_msg =
  70            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  71            "usage: qemu-img command [command options]\n"
  72            "QEMU disk image utility\n"
  73            "\n"
  74            "Command syntax:\n"
  75 #define DEF(option, callback, arg_string)        \
  76            "  " arg_string "\n"
  77 #include "qemu-img-cmds.h"
  78 #undef DEF
  79 #undef GEN_DOCS
  80            "\n"
  81            "Command parameters:\n"
  82            "  'filename' is a disk image filename\n"
  83            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  84            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  85            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
  86            "    'directsync' and 'unsafe' (default for convert)\n"
  87            "  'size' is the disk image size in bytes. Optional suffixes\n"
  88            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
  89            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
  90            "    supported. 'b' is ignored.\n"
  91            "  'output_filename' is the destination disk image filename\n"
  92            "  'output_fmt' is the destination format\n"
  93            "  'options' is a comma separated list of format specific options in a\n"
  94            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  95            "    used format\n"
  96            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  97            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
  98            "       match exactly. The image doesn't need a working backing file before\n"
  99            "       rebasing in this case (useful for renaming the backing file)\n"
 100            "  '-h' with or without a command shows this help and lists the supported formats\n"
 101            "  '-p' show progress of command (only certain commands)\n"
 102            "  '-q' use Quiet mode - do not print any output (except errors)\n"
 103            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
 104            "       for qemu-img to create a sparse image during conversion\n"
 105            "  '--output' takes the format in which the output must be done (human or json)\n"
 106            "  '-n' skips the target volume creation (useful if the volume is created\n"
 107            "       prior to running qemu-img)\n"
 108            "\n"
 109            "Parameters to check subcommand:\n"
 110            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
 111            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
 112            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
 113            "       hiding corruption that has already occurred.\n"
 114            "\n"
 115            "Parameters to snapshot subcommand:\n"
 116            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 117            "  '-a' applies a snapshot (revert disk to saved state)\n"
 118            "  '-c' creates a snapshot\n"
 119            "  '-d' deletes a snapshot\n"
 120            "  '-l' lists all snapshots in the given image\n"
 121            "\n"
 122            "Parameters to compare subcommand:\n"
 123            "  '-f' first image format\n"
 124            "  '-F' second image format\n"
 125            "  '-s' run in Strict mode - fail on different image size or sector allocation\n";
 126
 127     printf("%s\nSupported formats:", help_msg);
 128     bdrv_iterate_format(format_print, NULL);
 129     printf("\n");
 130     exit(1);
 131 }
 132
 133 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
 134 {
 135     int ret = 0;
 136     if (!quiet) {
 137         va_list args;
 138         va_start(args, fmt);
 139         ret = vprintf(fmt, args);
 140         va_end(args);
 141     }
 142     return ret;
 143 }
 144
 145 #if defined(WIN32)
 146 /* XXX: put correct support for win32 */
 147 static int read_password(char *buf, int buf_size)
 148 {
 149     int c, i;
 150     printf("Password: ");
 151     fflush(stdout);
 152     i = 0;
 153     for(;;) {
 154         c = getchar();
 155         if (c == '\n')
 156             break;
 157         if (i < (buf_size - 1))
 158             buf[i++] = c;
 159     }
 160     buf[i] = '\0';
 161     return 0;
 162 }
 163
 164 #else
 165
 166 #include <termios.h>
 167
 168 static struct termios oldtty;
 169
 170 static void term_exit(void)
 171 {
 172     tcsetattr (0, TCSANOW, &oldtty);
 173 }
 174
 175 static void term_init(void)
 176 {
 177     struct termios tty;
 178
 179     tcgetattr (0, &tty);
 180     oldtty = tty;
 181
 182     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 183                           |INLCR|IGNCR|ICRNL|IXON);
 184     tty.c_oflag |= OPOST;
 185     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 186     tty.c_cflag &= ~(CSIZE|PARENB);
 187     tty.c_cflag |= CS8;
 188     tty.c_cc[VMIN] = 1;
 189     tty.c_cc[VTIME] = 0;
 190
 191     tcsetattr (0, TCSANOW, &tty);
 192
 193     atexit(term_exit);
 194 }
 195
 196 static int read_password(char *buf, int buf_size)
 197 {
 198     uint8_t ch;
 199     int i, ret;
 200
 201     printf("password: ");
 202     fflush(stdout);
 203     term_init();
 204     i = 0;
 205     for(;;) {
 206         ret = read(0, &ch, 1);
 207         if (ret == -1) {
 208             if (errno == EAGAIN || errno == EINTR) {
 209                 continue;
 210             } else {
 211                 ret = -1;
 212                 break;
 213             }
 214         } else if (ret == 0) {
 215             ret = -1;
 216             break;
 217         } else {
 218             if (ch == '\r') {
 219                 ret = 0;
 220                 break;
 221             }
 222             if (i < (buf_size - 1))
 223                 buf[i++] = ch;
 224         }
 225     }
 226     term_exit();
 227     buf[i] = '\0';
 228     printf("\n");
 229     return ret;
 230 }
 231 #endif
 232
 233 static int print_block_option_help(const char *filename, const char *fmt)
 234 {
 235     BlockDriver *drv, *proto_drv;
 236     QEMUOptionParameter *create_options = NULL;
 237
 238     /* Find driver and parse its options */
 239     drv = bdrv_find_format(fmt);
 240     if (!drv) {
 241         error_report("Unknown file format '%s'", fmt);
 242         return 1;
 243     }
 244
 245     proto_drv = bdrv_find_protocol(filename, true);
 246     if (!proto_drv) {
 247         error_report("Unknown protocol '%s'", filename);
 248         return 1;
 249     }
 250
 251     create_options = append_option_parameters(create_options,
 252                                               drv->create_options);
 253     create_options = append_option_parameters(create_options,
 254                                               proto_drv->create_options);
 255     print_option_help(create_options);
 256     free_option_parameters(create_options);
 257     return 0;
 258 }
 259
 260 static BlockDriverState *bdrv_new_open(const char *filename,
 261                                        const char *fmt,
 262                                        int flags,
 263                                        bool require_io,
 264                                        bool quiet)
 265 {
 266     BlockDriverState *bs;
 267     BlockDriver *drv;
 268     char password[256];
 269     Error *local_err = NULL;
 270     int ret;
 271
 272     bs = bdrv_new("image");
 273
 274     if (fmt) {
 275         drv = bdrv_find_format(fmt);
 276         if (!drv) {
 277             error_report("Unknown file format '%s'", fmt);
 278             goto fail;
 279         }
 280     } else {
 281         drv = NULL;
 282     }
 283
 284     ret = bdrv_open(bs, filename, NULL, flags, drv, &local_err);
 285     if (ret < 0) {
 286         error_report("Could not open '%s': %s", filename,
 287                      error_get_pretty(local_err));
 288         error_free(local_err);
 289         goto fail;
 290     }
 291
 292     if (bdrv_is_encrypted(bs) && require_io) {
 293         qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
 294         if (read_password(password, sizeof(password)) < 0) {
 295             error_report("No password given");
 296             goto fail;
 297         }
 298         if (bdrv_set_key(bs, password) < 0) {
 299             error_report("invalid password");
 300             goto fail;
 301         }
 302     }
 303     return bs;
 304 fail:
 305     if (bs) {
 306         bdrv_unref(bs);
 307     }
 308     return NULL;
 309 }
 310
 311 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 312                                  const char *base_filename,
 313                                  const char *base_fmt)
 314 {
 315     if (base_filename) {
 316         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 317             error_report("Backing file not supported for file format '%s'",
 318                          fmt);
 319             return -1;
 320         }
 321     }
 322     if (base_fmt) {
 323         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 324             error_report("Backing file format not supported for file "
 325                          "format '%s'", fmt);
 326             return -1;
 327         }
 328     }
 329     return 0;
 330 }
 331
 332 static int img_create(int argc, char **argv)
 333 {
 334     int c;
 335     uint64_t img_size = -1;
 336     const char *fmt = "raw";
 337     const char *base_fmt = NULL;
 338     const char *filename;
 339     const char *base_filename = NULL;
 340     char *options = NULL;
 341     Error *local_err = NULL;
 342     bool quiet = false;
 343
 344     for(;;) {
 345         c = getopt(argc, argv, "F:b:f:he6o:q");
 346         if (c == -1) {
 347             break;
 348         }
 349         switch(c) {
 350         case '?':
 351         case 'h':
 352             help();
 353             break;
 354         case 'F':
 355             base_fmt = optarg;
 356             break;
 357         case 'b':
 358             base_filename = optarg;
 359             break;
 360         case 'f':
 361             fmt = optarg;
 362             break;
 363         case 'e':
 364             error_report("option -e is deprecated, please use \'-o "
 365                   "encryption\' instead!");
 366             return 1;
 367         case '6':
 368             error_report("option -6 is deprecated, please use \'-o "
 369                   "compat6\' instead!");
 370             return 1;
 371         case 'o':
 372             options = optarg;
 373             break;
 374         case 'q':
 375             quiet = true;
 376             break;
 377         }
 378     }
 379
 380     /* Get the filename */
 381     if (optind >= argc) {
 382         help();
 383     }
 384     filename = argv[optind++];
 385
 386     /* Get image size, if specified */
 387     if (optind < argc) {
 388         int64_t sval;
 389         char *end;
 390         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 391         if (sval < 0 || *end) {
 392             if (sval == -ERANGE) {
 393                 error_report("Image size must be less than 8 EiB!");
 394             } else {
 395                 error_report("Invalid image size specified! You may use k, M, "
 396                       "G, T, P or E suffixes for ");
 397                 error_report("kilobytes, megabytes, gigabytes, terabytes, "
 398                              "petabytes and exabytes.");
 399             }
 400             return 1;
 401         }
 402         img_size = (uint64_t)sval;
 403     }
 404     if (optind != argc) {
 405         help();
 406     }
 407
 408     if (options && is_help_option(options)) {
 409         return print_block_option_help(filename, fmt);
 410     }
 411
 412     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 413                     options, img_size, BDRV_O_FLAGS, &local_err, quiet);
 414     if (error_is_set(&local_err)) {
 415         error_report("%s", error_get_pretty(local_err));
 416         error_free(local_err);
 417         return 1;
 418     }
 419
 420     return 0;
 421 }
 422
 423 static void dump_json_image_check(ImageCheck *check, bool quiet)
 424 {
 425     Error *errp = NULL;
 426     QString *str;
 427     QmpOutputVisitor *ov = qmp_output_visitor_new();
 428     QObject *obj;
 429     visit_type_ImageCheck(qmp_output_get_visitor(ov),
 430                           &check, NULL, &errp);
 431     obj = qmp_output_get_qobject(ov);
 432     str = qobject_to_json_pretty(obj);
 433     assert(str != NULL);
 434     qprintf(quiet, "%s\n", qstring_get_str(str));
 435     qobject_decref(obj);
 436     qmp_output_visitor_cleanup(ov);
 437     QDECREF(str);
 438 }
 439
 440 static void dump_human_image_check(ImageCheck *check, bool quiet)
 441 {
 442     if (!(check->corruptions || check->leaks || check->check_errors)) {
 443         qprintf(quiet, "No errors were found on the image.\n");
 444     } else {
 445         if (check->corruptions) {
 446             qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
 447                     "Data may be corrupted, or further writes to the image "
 448                     "may corrupt it.\n",
 449                     check->corruptions);
 450         }
 451
 452         if (check->leaks) {
 453             qprintf(quiet,
 454                     "\n%" PRId64 " leaked clusters were found on the image.\n"
 455                     "This means waste of disk space, but no harm to data.\n",
 456                     check->leaks);
 457         }
 458
 459         if (check->check_errors) {
 460             qprintf(quiet,
 461                     "\n%" PRId64
 462                     " internal errors have occurred during the check.\n",
 463                     check->check_errors);
 464         }
 465     }
 466
 467     if (check->total_clusters != 0 && check->allocated_clusters != 0) {
 468         qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
 469                 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
 470                 check->allocated_clusters, check->total_clusters,
 471                 check->allocated_clusters * 100.0 / check->total_clusters,
 472                 check->fragmented_clusters * 100.0 / check->allocated_clusters,
 473                 check->compressed_clusters * 100.0 /
 474                 check->allocated_clusters);
 475     }
 476
 477     if (check->image_end_offset) {
 478         qprintf(quiet,
 479                 "Image end offset: %" PRId64 "\n", check->image_end_offset);
 480     }
 481 }
 482
 483 static int collect_image_check(BlockDriverState *bs,
 484                    ImageCheck *check,
 485                    const char *filename,
 486                    const char *fmt,
 487                    int fix)
 488 {
 489     int ret;
 490     BdrvCheckResult result;
 491
 492     ret = bdrv_check(bs, &result, fix);
 493     if (ret < 0) {
 494         return ret;
 495     }
 496
 497     check->filename                 = g_strdup(filename);
 498     check->format                   = g_strdup(bdrv_get_format_name(bs));
 499     check->check_errors             = result.check_errors;
 500     check->corruptions              = result.corruptions;
 501     check->has_corruptions          = result.corruptions != 0;
 502     check->leaks                    = result.leaks;
 503     check->has_leaks                = result.leaks != 0;
 504     check->corruptions_fixed        = result.corruptions_fixed;
 505     check->has_corruptions_fixed    = result.corruptions != 0;
 506     check->leaks_fixed              = result.leaks_fixed;
 507     check->has_leaks_fixed          = result.leaks != 0;
 508     check->image_end_offset         = result.image_end_offset;
 509     check->has_image_end_offset     = result.image_end_offset != 0;
 510     check->total_clusters           = result.bfi.total_clusters;
 511     check->has_total_clusters       = result.bfi.total_clusters != 0;
 512     check->allocated_clusters       = result.bfi.allocated_clusters;
 513     check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
 514     check->fragmented_clusters      = result.bfi.fragmented_clusters;
 515     check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
 516     check->compressed_clusters      = result.bfi.compressed_clusters;
 517     check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
 518
 519     return 0;
 520 }
 521
 522 /*
 523  * Checks an image for consistency. Exit codes:
 524  *
 525  * 0 - Check completed, image is good
 526  * 1 - Check not completed because of internal errors
 527  * 2 - Check completed, image is corrupted
 528  * 3 - Check completed, image has leaked clusters, but is good otherwise
 529  */
 530 static int img_check(int argc, char **argv)
 531 {
 532     int c, ret;
 533     OutputFormat output_format = OFORMAT_HUMAN;
 534     const char *filename, *fmt, *output;
 535     BlockDriverState *bs;
 536     int fix = 0;
 537     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 538     ImageCheck *check;
 539     bool quiet = false;
 540
 541     fmt = NULL;
 542     output = NULL;
 543     for(;;) {
 544         int option_index = 0;
 545         static const struct option long_options[] = {
 546             {"help", no_argument, 0, 'h'},
 547             {"format", required_argument, 0, 'f'},
 548             {"repair", no_argument, 0, 'r'},
 549             {"output", required_argument, 0, OPTION_OUTPUT},
 550             {0, 0, 0, 0}
 551         };
 552         c = getopt_long(argc, argv, "f:hr:q",
 553                         long_options, &option_index);
 554         if (c == -1) {
 555             break;
 556         }
 557         switch(c) {
 558         case '?':
 559         case 'h':
 560             help();
 561             break;
 562         case 'f':
 563             fmt = optarg;
 564             break;
 565         case 'r':
 566             flags |= BDRV_O_RDWR;
 567
 568             if (!strcmp(optarg, "leaks")) {
 569                 fix = BDRV_FIX_LEAKS;
 570             } else if (!strcmp(optarg, "all")) {
 571                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 572             } else {
 573                 help();
 574             }
 575             break;
 576         case OPTION_OUTPUT:
 577             output = optarg;
 578             break;
 579         case 'q':
 580             quiet = true;
 581             break;
 582         }
 583     }
 584     if (optind != argc - 1) {
 585         help();
 586     }
 587     filename = argv[optind++];
 588
 589     if (output && !strcmp(output, "json")) {
 590         output_format = OFORMAT_JSON;
 591     } else if (output && !strcmp(output, "human")) {
 592         output_format = OFORMAT_HUMAN;
 593     } else if (output) {
 594         error_report("--output must be used with human or json as argument.");
 595         return 1;
 596     }
 597
 598     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
 599     if (!bs) {
 600         return 1;
 601     }
 602
 603     check = g_new0(ImageCheck, 1);
 604     ret = collect_image_check(bs, check, filename, fmt, fix);
 605
 606     if (ret == -ENOTSUP) {
 607         if (output_format == OFORMAT_HUMAN) {
 608             error_report("This image format does not support checks");
 609         }
 610         ret = 1;
 611         goto fail;
 612     }
 613
 614     if (check->corruptions_fixed || check->leaks_fixed) {
 615         int corruptions_fixed, leaks_fixed;
 616
 617         leaks_fixed         = check->leaks_fixed;
 618         corruptions_fixed   = check->corruptions_fixed;
 619
 620         if (output_format == OFORMAT_HUMAN) {
 621             qprintf(quiet,
 622                     "The following inconsistencies were found and repaired:\n\n"
 623                     "    %" PRId64 " leaked clusters\n"
 624                     "    %" PRId64 " corruptions\n\n"
 625                     "Double checking the fixed image now...\n",
 626                     check->leaks_fixed,
 627                     check->corruptions_fixed);
 628         }
 629
 630         ret = collect_image_check(bs, check, filename, fmt, 0);
 631
 632         check->leaks_fixed          = leaks_fixed;
 633         check->corruptions_fixed    = corruptions_fixed;
 634     }
 635
 636     switch (output_format) {
 637     case OFORMAT_HUMAN:
 638         dump_human_image_check(check, quiet);
 639         break;
 640     case OFORMAT_JSON:
 641         dump_json_image_check(check, quiet);
 642         break;
 643     }
 644
 645     if (ret || check->check_errors) {
 646         ret = 1;
 647         goto fail;
 648     }
 649
 650     if (check->corruptions) {
 651         ret = 2;
 652     } else if (check->leaks) {
 653         ret = 3;
 654     } else {
 655         ret = 0;
 656     }
 657
 658 fail:
 659     qapi_free_ImageCheck(check);
 660     bdrv_unref(bs);
 661
 662     return ret;
 663 }
 664
 665 static int img_commit(int argc, char **argv)
 666 {
 667     int c, ret, flags;
 668     const char *filename, *fmt, *cache;
 669     BlockDriverState *bs;
 670     bool quiet = false;
 671
 672     fmt = NULL;
 673     cache = BDRV_DEFAULT_CACHE;
 674     for(;;) {
 675         c = getopt(argc, argv, "f:ht:q");
 676         if (c == -1) {
 677             break;
 678         }
 679         switch(c) {
 680         case '?':
 681         case 'h':
 682             help();
 683             break;
 684         case 'f':
 685             fmt = optarg;
 686             break;
 687         case 't':
 688             cache = optarg;
 689             break;
 690         case 'q':
 691             quiet = true;
 692             break;
 693         }
 694     }
 695     if (optind != argc - 1) {
 696         help();
 697     }
 698     filename = argv[optind++];
 699
 700     flags = BDRV_O_RDWR;
 701     ret = bdrv_parse_cache_flags(cache, &flags);
 702     if (ret < 0) {
 703         error_report("Invalid cache option: %s", cache);
 704         return -1;
 705     }
 706
 707     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
 708     if (!bs) {
 709         return 1;
 710     }
 711     ret = bdrv_commit(bs);
 712     switch(ret) {
 713     case 0:
 714         qprintf(quiet, "Image committed.\n");
 715         break;
 716     case -ENOENT:
 717         error_report("No disk inserted");
 718         break;
 719     case -EACCES:
 720         error_report("Image is read-only");
 721         break;
 722     case -ENOTSUP:
 723         error_report("Image is already committed");
 724         break;
 725     default:
 726         error_report("Error while committing image");
 727         break;
 728     }
 729
 730     bdrv_unref(bs);
 731     if (ret) {
 732         return 1;
 733     }
 734     return 0;
 735 }
 736
 737 /*
 738  * Returns true iff the first sector pointed to by 'buf' contains at least
 739  * a non-NUL byte.
 740  *
 741  * 'pnum' is set to the number of sectors (including and immediately following
 742  * the first one) that are known to be in the same allocated/unallocated state.
 743  */
 744 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 745 {
 746     bool is_zero;
 747     int i;
 748
 749     if (n <= 0) {
 750         *pnum = 0;
 751         return 0;
 752     }
 753     is_zero = buffer_is_zero(buf, 512);
 754     for(i = 1; i < n; i++) {
 755         buf += 512;
 756         if (is_zero != buffer_is_zero(buf, 512)) {
 757             break;
 758         }
 759     }
 760     *pnum = i;
 761     return !is_zero;
 762 }
 763
 764 /*
 765  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 766  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 767  * breaking up write requests for only small sparse areas.
 768  */
 769 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 770     int min)
 771 {
 772     int ret;
 773     int num_checked, num_used;
 774
 775     if (n < min) {
 776         min = n;
 777     }
 778
 779     ret = is_allocated_sectors(buf, n, pnum);
 780     if (!ret) {
 781         return ret;
 782     }
 783
 784     num_used = *pnum;
 785     buf += BDRV_SECTOR_SIZE * *pnum;
 786     n -= *pnum;
 787     num_checked = num_used;
 788
 789     while (n > 0) {
 790         ret = is_allocated_sectors(buf, n, pnum);
 791
 792         buf += BDRV_SECTOR_SIZE * *pnum;
 793         n -= *pnum;
 794         num_checked += *pnum;
 795         if (ret) {
 796             num_used = num_checked;
 797         } else if (*pnum >= min) {
 798             break;
 799         }
 800     }
 801
 802     *pnum = num_used;
 803     return 1;
 804 }
 805
 806 /*
 807  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 808  * buffers matches, non-zero otherwise.
 809  *
 810  * pnum is set to the number of sectors (including and immediately following
 811  * the first one) that are known to have the same comparison result
 812  */
 813 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 814     int *pnum)
 815 {
 816     int res, i;
 817
 818     if (n <= 0) {
 819         *pnum = 0;
 820         return 0;
 821     }
 822
 823     res = !!memcmp(buf1, buf2, 512);
 824     for(i = 1; i < n; i++) {
 825         buf1 += 512;
 826         buf2 += 512;
 827
 828         if (!!memcmp(buf1, buf2, 512) != res) {
 829             break;
 830         }
 831     }
 832
 833     *pnum = i;
 834     return res;
 835 }
 836
 837 #define IO_BUF_SIZE (2 * 1024 * 1024)
 838
 839 static int64_t sectors_to_bytes(int64_t sectors)
 840 {
 841     return sectors << BDRV_SECTOR_BITS;
 842 }
 843
 844 static int64_t sectors_to_process(int64_t total, int64_t from)
 845 {
 846     return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
 847 }
 848
 849 /*
 850  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
 851  *
 852  * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
 853  * data and negative value on error.
 854  *
 855  * @param bs:  Driver used for accessing file
 856  * @param sect_num: Number of first sector to check
 857  * @param sect_count: Number of sectors to check
 858  * @param filename: Name of disk file we are checking (logging purpose)
 859  * @param buffer: Allocated buffer for storing read data
 860  * @param quiet: Flag for quiet mode
 861  */
 862 static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
 863                                int sect_count, const char *filename,
 864                                uint8_t *buffer, bool quiet)
 865 {
 866     int pnum, ret = 0;
 867     ret = bdrv_read(bs, sect_num, buffer, sect_count);
 868     if (ret < 0) {
 869         error_report("Error while reading offset %" PRId64 " of %s: %s",
 870                      sectors_to_bytes(sect_num), filename, strerror(-ret));
 871         return ret;
 872     }
 873     ret = is_allocated_sectors(buffer, sect_count, &pnum);
 874     if (ret || pnum != sect_count) {
 875         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
 876                 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
 877         return 1;
 878     }
 879
 880     return 0;
 881 }
 882
 883 /*
 884  * Compares two images. Exit codes:
 885  *
 886  * 0 - Images are identical
 887  * 1 - Images differ
 888  * >1 - Error occurred
 889  */
 890 static int img_compare(int argc, char **argv)
 891 {
 892     const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
 893     BlockDriverState *bs1, *bs2;
 894     int64_t total_sectors1, total_sectors2;
 895     uint8_t *buf1 = NULL, *buf2 = NULL;
 896     int pnum1, pnum2;
 897     int allocated1, allocated2;
 898     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
 899     bool progress = false, quiet = false, strict = false;
 900     int64_t total_sectors;
 901     int64_t sector_num = 0;
 902     int64_t nb_sectors;
 903     int c, pnum;
 904     uint64_t bs_sectors;
 905     uint64_t progress_base;
 906
 907     for (;;) {
 908         c = getopt(argc, argv, "hpf:F:sq");
 909         if (c == -1) {
 910             break;
 911         }
 912         switch (c) {
 913         case '?':
 914         case 'h':
 915             help();
 916             break;
 917         case 'f':
 918             fmt1 = optarg;
 919             break;
 920         case 'F':
 921             fmt2 = optarg;
 922             break;
 923         case 'p':
 924             progress = true;
 925             break;
 926         case 'q':
 927             quiet = true;
 928             break;
 929         case 's':
 930             strict = true;
 931             break;
 932         }
 933     }
 934
 935     /* Progress is not shown in Quiet mode */
 936     if (quiet) {
 937         progress = false;
 938     }
 939
 940
 941     if (optind != argc - 2) {
 942         help();
 943     }
 944     filename1 = argv[optind++];
 945     filename2 = argv[optind++];
 946
 947     /* Initialize before goto out */
 948     qemu_progress_init(progress, 2.0);
 949
 950     bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
 951     if (!bs1) {
 952         error_report("Can't open file %s", filename1);
 953         ret = 2;
 954         goto out3;
 955     }
 956
 957     bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
 958     if (!bs2) {
 959         error_report("Can't open file %s", filename2);
 960         ret = 2;
 961         goto out2;
 962     }
 963
 964     buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
 965     buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
 966     bdrv_get_geometry(bs1, &bs_sectors);
 967     total_sectors1 = bs_sectors;
 968     bdrv_get_geometry(bs2, &bs_sectors);
 969     total_sectors2 = bs_sectors;
 970     total_sectors = MIN(total_sectors1, total_sectors2);
 971     progress_base = MAX(total_sectors1, total_sectors2);
 972
 973     qemu_progress_print(0, 100);
 974
 975     if (strict && total_sectors1 != total_sectors2) {
 976         ret = 1;
 977         qprintf(quiet, "Strict mode: Image size mismatch!\n");
 978         goto out;
 979     }
 980
 981     for (;;) {
 982         nb_sectors = sectors_to_process(total_sectors, sector_num);
 983         if (nb_sectors <= 0) {
 984             break;
 985         }
 986         allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
 987                                              &pnum1);
 988         if (allocated1 < 0) {
 989             ret = 3;
 990             error_report("Sector allocation test failed for %s", filename1);
 991             goto out;
 992         }
 993
 994         allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
 995                                              &pnum2);
 996         if (allocated2 < 0) {
 997             ret = 3;
 998             error_report("Sector allocation test failed for %s", filename2);
 999             goto out;
1000         }
1001         nb_sectors = MIN(pnum1, pnum2);
1002
1003         if (allocated1 == allocated2) {
1004             if (allocated1) {
1005                 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
1006                 if (ret < 0) {
1007                     error_report("Error while reading offset %" PRId64 " of %s:"
1008                                  " %s", sectors_to_bytes(sector_num), filename1,
1009                                  strerror(-ret));
1010                     ret = 4;
1011                     goto out;
1012                 }
1013                 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1014                 if (ret < 0) {
1015                     error_report("Error while reading offset %" PRId64
1016                                  " of %s: %s", sectors_to_bytes(sector_num),
1017                                  filename2, strerror(-ret));
1018                     ret = 4;
1019                     goto out;
1020                 }
1021                 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1022                 if (ret || pnum != nb_sectors) {
1023                     ret = 1;
1024                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1025                             sectors_to_bytes(
1026                                 ret ? sector_num : sector_num + pnum));
1027                     goto out;
1028                 }
1029             }
1030         } else {
1031             if (strict) {
1032                 ret = 1;
1033                 qprintf(quiet, "Strict mode: Offset %" PRId64
1034                         " allocation mismatch!\n",
1035                         sectors_to_bytes(sector_num));
1036                 goto out;
1037             }
1038
1039             if (allocated1) {
1040                 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1041                                           filename1, buf1, quiet);
1042             } else {
1043                 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1044                                           filename2, buf1, quiet);
1045             }
1046             if (ret) {
1047                 if (ret < 0) {
1048                     ret = 4;
1049                     error_report("Error while reading offset %" PRId64 ": %s",
1050                                  sectors_to_bytes(sector_num), strerror(-ret));
1051                 }
1052                 goto out;
1053             }
1054         }
1055         sector_num += nb_sectors;
1056         qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1057     }
1058
1059     if (total_sectors1 != total_sectors2) {
1060         BlockDriverState *bs_over;
1061         int64_t total_sectors_over;
1062         const char *filename_over;
1063
1064         qprintf(quiet, "Warning: Image size mismatch!\n");
1065         if (total_sectors1 > total_sectors2) {
1066             total_sectors_over = total_sectors1;
1067             bs_over = bs1;
1068             filename_over = filename1;
1069         } else {
1070             total_sectors_over = total_sectors2;
1071             bs_over = bs2;
1072             filename_over = filename2;
1073         }
1074
1075         for (;;) {
1076             nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1077             if (nb_sectors <= 0) {
1078                 break;
1079             }
1080             ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1081                                           nb_sectors, &pnum);
1082             if (ret < 0) {
1083                 ret = 3;
1084                 error_report("Sector allocation test failed for %s",
1085                              filename_over);
1086                 goto out;
1087
1088             }
1089             nb_sectors = pnum;
1090             if (ret) {
1091                 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1092                                           filename_over, buf1, quiet);
1093                 if (ret) {
1094                     if (ret < 0) {
1095                         ret = 4;
1096                         error_report("Error while reading offset %" PRId64
1097                                      " of %s: %s", sectors_to_bytes(sector_num),
1098                                      filename_over, strerror(-ret));
1099                     }
1100                     goto out;
1101                 }
1102             }
1103             sector_num += nb_sectors;
1104             qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1105         }
1106     }
1107
1108     qprintf(quiet, "Images are identical.\n");
1109     ret = 0;
1110
1111 out:
1112     bdrv_unref(bs2);
1113     qemu_vfree(buf1);
1114     qemu_vfree(buf2);
1115 out2:
1116     bdrv_unref(bs1);
1117 out3:
1118     qemu_progress_end();
1119     return ret;
1120 }
1121
1122 static int img_convert(int argc, char **argv)
1123 {
1124     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size,
1125         cluster_sectors, skip_create;
1126     int progress = 0, flags;
1127     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1128     BlockDriver *drv, *proto_drv;
1129     BlockDriverState **bs = NULL, *out_bs = NULL;
1130     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1131     uint64_t bs_sectors;
1132     uint8_t * buf = NULL;
1133     const uint8_t *buf1;
1134     BlockDriverInfo bdi;
1135     QEMUOptionParameter *param = NULL, *create_options = NULL;
1136     QEMUOptionParameter *out_baseimg_param;
1137     char *options = NULL;
1138     const char *snapshot_name = NULL;
1139     float local_progress = 0;
1140     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1141     bool quiet = false;
1142
1143     fmt = NULL;
1144     out_fmt = "raw";
1145     cache = "unsafe";
1146     out_baseimg = NULL;
1147     compress = 0;
1148     skip_create = 0;
1149     for(;;) {
1150         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:qn");
1151         if (c == -1) {
1152             break;
1153         }
1154         switch(c) {
1155         case '?':
1156         case 'h':
1157             help();
1158             break;
1159         case 'f':
1160             fmt = optarg;
1161             break;
1162         case 'O':
1163             out_fmt = optarg;
1164             break;
1165         case 'B':
1166             out_baseimg = optarg;
1167             break;
1168         case 'c':
1169             compress = 1;
1170             break;
1171         case 'e':
1172             error_report("option -e is deprecated, please use \'-o "
1173                   "encryption\' instead!");
1174             return 1;
1175         case '6':
1176             error_report("option -6 is deprecated, please use \'-o "
1177                   "compat6\' instead!");
1178             return 1;
1179         case 'o':
1180             options = optarg;
1181             break;
1182         case 's':
1183             snapshot_name = optarg;
1184             break;
1185         case 'S':
1186         {
1187             int64_t sval;
1188             char *end;
1189             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1190             if (sval < 0 || *end) {
1191                 error_report("Invalid minimum zero buffer size for sparse output specified");
1192                 return 1;
1193             }
1194
1195             min_sparse = sval / BDRV_SECTOR_SIZE;
1196             break;
1197         }
1198         case 'p':
1199             progress = 1;
1200             break;
1201         case 't':
1202             cache = optarg;
1203             break;
1204         case 'q':
1205             quiet = true;
1206             break;
1207         case 'n':
1208             skip_create = 1;
1209             break;
1210         }
1211     }
1212
1213     if (quiet) {
1214         progress = 0;
1215     }
1216
1217     bs_n = argc - optind - 1;
1218     if (bs_n < 1) {
1219         help();
1220     }
1221
1222     out_filename = argv[argc - 1];
1223
1224     /* Initialize before goto out */
1225     qemu_progress_init(progress, 2.0);
1226
1227     if (options && is_help_option(options)) {
1228         ret = print_block_option_help(out_filename, out_fmt);
1229         goto out;
1230     }
1231
1232     if (bs_n > 1 && out_baseimg) {
1233         error_report("-B makes no sense when concatenating multiple input "
1234                      "images");
1235         ret = -1;
1236         goto out;
1237     }
1238
1239     qemu_progress_print(0, 100);
1240
1241     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
1242
1243     total_sectors = 0;
1244     for (bs_i = 0; bs_i < bs_n; bs_i++) {
1245         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1246                                  quiet);
1247         if (!bs[bs_i]) {
1248             error_report("Could not open '%s'", argv[optind + bs_i]);
1249             ret = -1;
1250             goto out;
1251         }
1252         bdrv_get_geometry(bs[bs_i], &bs_sectors);
1253         total_sectors += bs_sectors;
1254     }
1255
1256     if (snapshot_name != NULL) {
1257         if (bs_n > 1) {
1258             error_report("No support for concatenating multiple snapshot");
1259             ret = -1;
1260             goto out;
1261         }
1262         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1263             error_report("Failed to load snapshot");
1264             ret = -1;
1265             goto out;
1266         }
1267     }
1268
1269     /* Find driver and parse its options */
1270     drv = bdrv_find_format(out_fmt);
1271     if (!drv) {
1272         error_report("Unknown file format '%s'", out_fmt);
1273         ret = -1;
1274         goto out;
1275     }
1276
1277     proto_drv = bdrv_find_protocol(out_filename, true);
1278     if (!proto_drv) {
1279         error_report("Unknown protocol '%s'", out_filename);
1280         ret = -1;
1281         goto out;
1282     }
1283
1284     create_options = append_option_parameters(create_options,
1285                                               drv->create_options);
1286     create_options = append_option_parameters(create_options,
1287                                               proto_drv->create_options);
1288
1289     if (options) {
1290         param = parse_option_parameters(options, create_options, param);
1291         if (param == NULL) {
1292             error_report("Invalid options for file format '%s'.", out_fmt);
1293             ret = -1;
1294             goto out;
1295         }
1296     } else {
1297         param = parse_option_parameters("", create_options, param);
1298     }
1299
1300     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1301     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1302     if (ret < 0) {
1303         goto out;
1304     }
1305
1306     /* Get backing file name if -o backing_file was used */
1307     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1308     if (out_baseimg_param) {
1309         out_baseimg = out_baseimg_param->value.s;
1310     }
1311
1312     /* Check if compression is supported */
1313     if (compress) {
1314         QEMUOptionParameter *encryption =
1315             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1316         QEMUOptionParameter *preallocation =
1317             get_option_parameter(param, BLOCK_OPT_PREALLOC);
1318
1319         if (!drv->bdrv_write_compressed) {
1320             error_report("Compression not supported for this file format");
1321             ret = -1;
1322             goto out;
1323         }
1324
1325         if (encryption && encryption->value.n) {
1326             error_report("Compression and encryption not supported at "
1327                          "the same time");
1328             ret = -1;
1329             goto out;
1330         }
1331
1332         if (preallocation && preallocation->value.s
1333             && strcmp(preallocation->value.s, "off"))
1334         {
1335             error_report("Compression and preallocation not supported at "
1336                          "the same time");
1337             ret = -1;
1338             goto out;
1339         }
1340     }
1341
1342     if (!skip_create) {
1343         /* Create the new image */
1344         ret = bdrv_create(drv, out_filename, param);
1345         if (ret < 0) {
1346             if (ret == -ENOTSUP) {
1347                 error_report("Formatting not supported for file format '%s'",
1348                              out_fmt);
1349             } else if (ret == -EFBIG) {
1350                 error_report("The image size is too large for file format '%s'",
1351                              out_fmt);
1352             } else {
1353                 error_report("%s: error while converting %s: %s",
1354                              out_filename, out_fmt, strerror(-ret));
1355             }
1356             goto out;
1357         }
1358     }
1359
1360     flags = BDRV_O_RDWR;
1361     ret = bdrv_parse_cache_flags(cache, &flags);
1362     if (ret < 0) {
1363         error_report("Invalid cache option: %s", cache);
1364         return -1;
1365     }
1366
1367     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1368     if (!out_bs) {
1369         ret = -1;
1370         goto out;
1371     }
1372
1373     bs_i = 0;
1374     bs_offset = 0;
1375     bdrv_get_geometry(bs[0], &bs_sectors);
1376     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1377
1378     if (skip_create) {
1379         int64_t output_length = bdrv_getlength(out_bs);
1380         if (output_length < 0) {
1381             error_report("unable to get output image length: %s\n",
1382                          strerror(-output_length));
1383             ret = -1;
1384             goto out;
1385         } else if (output_length < total_sectors << BDRV_SECTOR_BITS) {
1386             error_report("output file is smaller than input file");
1387             ret = -1;
1388             goto out;
1389         }
1390     }
1391
1392     if (compress) {
1393         ret = bdrv_get_info(out_bs, &bdi);
1394         if (ret < 0) {
1395             error_report("could not get block driver info");
1396             goto out;
1397         }
1398         cluster_size = bdi.cluster_size;
1399         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1400             error_report("invalid cluster size");
1401             ret = -1;
1402             goto out;
1403         }
1404         cluster_sectors = cluster_size >> 9;
1405         sector_num = 0;
1406
1407         nb_sectors = total_sectors;
1408         if (nb_sectors != 0) {
1409             local_progress = (float)100 /
1410                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1411         }
1412
1413         for(;;) {
1414             int64_t bs_num;
1415             int remainder;
1416             uint8_t *buf2;
1417
1418             nb_sectors = total_sectors - sector_num;
1419             if (nb_sectors <= 0)
1420                 break;
1421             if (nb_sectors >= cluster_sectors)
1422                 n = cluster_sectors;
1423             else
1424                 n = nb_sectors;
1425
1426             bs_num = sector_num - bs_offset;
1427             assert (bs_num >= 0);
1428             remainder = n;
1429             buf2 = buf;
1430             while (remainder > 0) {
1431                 int nlow;
1432                 while (bs_num == bs_sectors) {
1433                     bs_i++;
1434                     assert (bs_i < bs_n);
1435                     bs_offset += bs_sectors;
1436                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
1437                     bs_num = 0;
1438                     /* printf("changing part: sector_num=%" PRId64 ", "
1439                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1440                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1441                 }
1442                 assert (bs_num < bs_sectors);
1443
1444                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1445
1446                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1447                 if (ret < 0) {
1448                     error_report("error while reading sector %" PRId64 ": %s",
1449                                  bs_num, strerror(-ret));
1450                     goto out;
1451                 }
1452
1453                 buf2 += nlow * 512;
1454                 bs_num += nlow;
1455
1456                 remainder -= nlow;
1457             }
1458             assert (remainder == 0);
1459
1460             if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1461                 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1462                 if (ret != 0) {
1463                     error_report("error while compressing sector %" PRId64
1464                                  ": %s", sector_num, strerror(-ret));
1465                     goto out;
1466                 }
1467             }
1468             sector_num += n;
1469             qemu_progress_print(local_progress, 100);
1470         }
1471         /* signal EOF to align */
1472         bdrv_write_compressed(out_bs, 0, NULL, 0);
1473     } else {
1474         int has_zero_init = bdrv_has_zero_init(out_bs);
1475
1476         sector_num = 0; // total number of sectors converted so far
1477         nb_sectors = total_sectors - sector_num;
1478         if (nb_sectors != 0) {
1479             local_progress = (float)100 /
1480                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1481         }
1482
1483         for(;;) {
1484             nb_sectors = total_sectors - sector_num;
1485             if (nb_sectors <= 0) {
1486                 break;
1487             }
1488             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1489                 n = (IO_BUF_SIZE / 512);
1490             } else {
1491                 n = nb_sectors;
1492             }
1493
1494             while (sector_num - bs_offset >= bs_sectors) {
1495                 bs_i ++;
1496                 assert (bs_i < bs_n);
1497                 bs_offset += bs_sectors;
1498                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1499                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1500                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1501                    sector_num, bs_i, bs_offset, bs_sectors); */
1502             }
1503
1504             if (n > bs_offset + bs_sectors - sector_num) {
1505                 n = bs_offset + bs_sectors - sector_num;
1506             }
1507
1508             /* If the output image is being created as a copy on write image,
1509                assume that sectors which are unallocated in the input image
1510                are present in both the output's and input's base images (no
1511                need to copy them). */
1512             if (out_baseimg) {
1513                 ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1514                                         n, &n1);
1515                 if (ret < 0) {
1516                     error_report("error while reading metadata for sector "
1517                                  "%" PRId64 ": %s",
1518                                  sector_num - bs_offset, strerror(-ret));
1519                     goto out;
1520                 }
1521                 if (!ret) {
1522                     sector_num += n1;
1523                     continue;
1524                 }
1525                 /* The next 'n1' sectors are allocated in the input image. Copy
1526                    only those as they may be followed by unallocated sectors. */
1527                 n = n1;
1528             } else {
1529                 n1 = n;
1530             }
1531
1532             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1533             if (ret < 0) {
1534                 error_report("error while reading sector %" PRId64 ": %s",
1535                              sector_num - bs_offset, strerror(-ret));
1536                 goto out;
1537             }
1538             /* NOTE: at the same time we convert, we do not write zero
1539                sectors to have a chance to compress the image. Ideally, we
1540                should add a specific call to have the info to go faster */
1541             buf1 = buf;
1542             while (n > 0) {
1543                 if (!has_zero_init ||
1544                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1545                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1546                     if (ret < 0) {
1547                         error_report("error while writing sector %" PRId64
1548                                      ": %s", sector_num, strerror(-ret));
1549                         goto out;
1550                     }
1551                 }
1552                 sector_num += n1;
1553                 n -= n1;
1554                 buf1 += n1 * 512;
1555             }
1556             qemu_progress_print(local_progress, 100);
1557         }
1558     }
1559 out:
1560     qemu_progress_end();
1561     free_option_parameters(create_options);
1562     free_option_parameters(param);
1563     qemu_vfree(buf);
1564     if (out_bs) {
1565         bdrv_unref(out_bs);
1566     }
1567     if (bs) {
1568         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1569             if (bs[bs_i]) {
1570                 bdrv_unref(bs[bs_i]);
1571             }
1572         }
1573         g_free(bs);
1574     }
1575     if (ret) {
1576         return 1;
1577     }
1578     return 0;
1579 }
1580
1581
1582 static void dump_snapshots(BlockDriverState *bs)
1583 {
1584     QEMUSnapshotInfo *sn_tab, *sn;
1585     int nb_sns, i;
1586
1587     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1588     if (nb_sns <= 0)
1589         return;
1590     printf("Snapshot list:\n");
1591     bdrv_snapshot_dump(fprintf, stdout, NULL);
1592     printf("\n");
1593     for(i = 0; i < nb_sns; i++) {
1594         sn = &sn_tab[i];
1595         bdrv_snapshot_dump(fprintf, stdout, sn);
1596         printf("\n");
1597     }
1598     g_free(sn_tab);
1599 }
1600
1601 static void dump_json_image_info_list(ImageInfoList *list)
1602 {
1603     Error *errp = NULL;
1604     QString *str;
1605     QmpOutputVisitor *ov = qmp_output_visitor_new();
1606     QObject *obj;
1607     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1608                              &list, NULL, &errp);
1609     obj = qmp_output_get_qobject(ov);
1610     str = qobject_to_json_pretty(obj);
1611     assert(str != NULL);
1612     printf("%s\n", qstring_get_str(str));
1613     qobject_decref(obj);
1614     qmp_output_visitor_cleanup(ov);
1615     QDECREF(str);
1616 }
1617
1618 static void dump_json_image_info(ImageInfo *info)
1619 {
1620     Error *errp = NULL;
1621     QString *str;
1622     QmpOutputVisitor *ov = qmp_output_visitor_new();
1623     QObject *obj;
1624     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1625                          &info, NULL, &errp);
1626     obj = qmp_output_get_qobject(ov);
1627     str = qobject_to_json_pretty(obj);
1628     assert(str != NULL);
1629     printf("%s\n", qstring_get_str(str));
1630     qobject_decref(obj);
1631     qmp_output_visitor_cleanup(ov);
1632     QDECREF(str);
1633 }
1634
1635 static void dump_human_image_info_list(ImageInfoList *list)
1636 {
1637     ImageInfoList *elem;
1638     bool delim = false;
1639
1640     for (elem = list; elem; elem = elem->next) {
1641         if (delim) {
1642             printf("\n");
1643         }
1644         delim = true;
1645
1646         bdrv_image_info_dump(fprintf, stdout, elem->value);
1647     }
1648 }
1649
1650 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1651 {
1652     return strcmp(a, b) == 0;
1653 }
1654
1655 /**
1656  * Open an image file chain and return an ImageInfoList
1657  *
1658  * @filename: topmost image filename
1659  * @fmt: topmost image format (may be NULL to autodetect)
1660  * @chain: true  - enumerate entire backing file chain
1661  *         false - only topmost image file
1662  *
1663  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1664  * image file.  If there was an error a message will have been printed to
1665  * stderr.
1666  */
1667 static ImageInfoList *collect_image_info_list(const char *filename,
1668                                               const char *fmt,
1669                                               bool chain)
1670 {
1671     ImageInfoList *head = NULL;
1672     ImageInfoList **last = &head;
1673     GHashTable *filenames;
1674     Error *err = NULL;
1675
1676     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1677
1678     while (filename) {
1679         BlockDriverState *bs;
1680         ImageInfo *info;
1681         ImageInfoList *elem;
1682
1683         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1684             error_report("Backing file '%s' creates an infinite loop.",
1685                          filename);
1686             goto err;
1687         }
1688         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1689
1690         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1691                            false, false);
1692         if (!bs) {
1693             goto err;
1694         }
1695
1696         bdrv_query_image_info(bs, &info, &err);
1697         if (error_is_set(&err)) {
1698             error_report("%s", error_get_pretty(err));
1699             error_free(err);
1700             goto err;
1701         }
1702
1703         elem = g_new0(ImageInfoList, 1);
1704         elem->value = info;
1705         *last = elem;
1706         last = &elem->next;
1707
1708         bdrv_unref(bs);
1709
1710         filename = fmt = NULL;
1711         if (chain) {
1712             if (info->has_full_backing_filename) {
1713                 filename = info->full_backing_filename;
1714             } else if (info->has_backing_filename) {
1715                 filename = info->backing_filename;
1716             }
1717             if (info->has_backing_filename_format) {
1718                 fmt = info->backing_filename_format;
1719             }
1720         }
1721     }
1722     g_hash_table_destroy(filenames);
1723     return head;
1724
1725 err:
1726     qapi_free_ImageInfoList(head);
1727     g_hash_table_destroy(filenames);
1728     return NULL;
1729 }
1730
1731 static int img_info(int argc, char **argv)
1732 {
1733     int c;
1734     OutputFormat output_format = OFORMAT_HUMAN;
1735     bool chain = false;
1736     const char *filename, *fmt, *output;
1737     ImageInfoList *list;
1738
1739     fmt = NULL;
1740     output = NULL;
1741     for(;;) {
1742         int option_index = 0;
1743         static const struct option long_options[] = {
1744             {"help", no_argument, 0, 'h'},
1745             {"format", required_argument, 0, 'f'},
1746             {"output", required_argument, 0, OPTION_OUTPUT},
1747             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1748             {0, 0, 0, 0}
1749         };
1750         c = getopt_long(argc, argv, "f:h",
1751                         long_options, &option_index);
1752         if (c == -1) {
1753             break;
1754         }
1755         switch(c) {
1756         case '?':
1757         case 'h':
1758             help();
1759             break;
1760         case 'f':
1761             fmt = optarg;
1762             break;
1763         case OPTION_OUTPUT:
1764             output = optarg;
1765             break;
1766         case OPTION_BACKING_CHAIN:
1767             chain = true;
1768             break;
1769         }
1770     }
1771     if (optind != argc - 1) {
1772         help();
1773     }
1774     filename = argv[optind++];
1775
1776     if (output && !strcmp(output, "json")) {
1777         output_format = OFORMAT_JSON;
1778     } else if (output && !strcmp(output, "human")) {
1779         output_format = OFORMAT_HUMAN;
1780     } else if (output) {
1781         error_report("--output must be used with human or json as argument.");
1782         return 1;
1783     }
1784
1785     list = collect_image_info_list(filename, fmt, chain);
1786     if (!list) {
1787         return 1;
1788     }
1789
1790     switch (output_format) {
1791     case OFORMAT_HUMAN:
1792         dump_human_image_info_list(list);
1793         break;
1794     case OFORMAT_JSON:
1795         if (chain) {
1796             dump_json_image_info_list(list);
1797         } else {
1798             dump_json_image_info(list->value);
1799         }
1800         break;
1801     }
1802
1803     qapi_free_ImageInfoList(list);
1804     return 0;
1805 }
1806
1807
1808 typedef struct MapEntry {
1809     int flags;
1810     int depth;
1811     int64_t start;
1812     int64_t length;
1813     int64_t offset;
1814     BlockDriverState *bs;
1815 } MapEntry;
1816
1817 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
1818                            MapEntry *next)
1819 {
1820     switch (output_format) {
1821     case OFORMAT_HUMAN:
1822         if ((e->flags & BDRV_BLOCK_DATA) &&
1823             !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
1824             error_report("File contains external, encrypted or compressed clusters.");
1825             exit(1);
1826         }
1827         if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
1828             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
1829                    e->start, e->length, e->offset, e->bs->filename);
1830         }
1831         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
1832          * Modify the flags here to allow more coalescing.
1833          */
1834         if (next &&
1835             (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
1836             next->flags &= ~BDRV_BLOCK_DATA;
1837             next->flags |= BDRV_BLOCK_ZERO;
1838         }
1839         break;
1840     case OFORMAT_JSON:
1841         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
1842                " \"zero\": %s, \"data\": %s",
1843                (e->start == 0 ? "[" : ",\n"),
1844                e->start, e->length, e->depth,
1845                (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
1846                (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
1847         if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
1848             printf(", 'offset': %"PRId64"", e->offset);
1849         }
1850         putchar('}');
1851
1852         if (!next) {
1853             printf("]\n");
1854         }
1855         break;
1856     }
1857 }
1858
1859 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
1860                             int nb_sectors, MapEntry *e)
1861 {
1862     int64_t ret;
1863     int depth;
1864
1865     /* As an optimization, we could cache the current range of unallocated
1866      * clusters in each file of the chain, and avoid querying the same
1867      * range repeatedly.
1868      */
1869
1870     depth = 0;
1871     for (;;) {
1872         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
1873         if (ret < 0) {
1874             return ret;
1875         }
1876         assert(nb_sectors);
1877         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
1878             break;
1879         }
1880         bs = bs->backing_hd;
1881         if (bs == NULL) {
1882             ret = 0;
1883             break;
1884         }
1885
1886         depth++;
1887     }
1888
1889     e->start = sector_num * BDRV_SECTOR_SIZE;
1890     e->length = nb_sectors * BDRV_SECTOR_SIZE;
1891     e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
1892     e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
1893     e->depth = depth;
1894     e->bs = bs;
1895     return 0;
1896 }
1897
1898 static int img_map(int argc, char **argv)
1899 {
1900     int c;
1901     OutputFormat output_format = OFORMAT_HUMAN;
1902     BlockDriverState *bs;
1903     const char *filename, *fmt, *output;
1904     int64_t length;
1905     MapEntry curr = { .length = 0 }, next;
1906     int ret = 0;
1907
1908     fmt = NULL;
1909     output = NULL;
1910     for (;;) {
1911         int option_index = 0;
1912         static const struct option long_options[] = {
1913             {"help", no_argument, 0, 'h'},
1914             {"format", required_argument, 0, 'f'},
1915             {"output", required_argument, 0, OPTION_OUTPUT},
1916             {0, 0, 0, 0}
1917         };
1918         c = getopt_long(argc, argv, "f:h",
1919                         long_options, &option_index);
1920         if (c == -1) {
1921             break;
1922         }
1923         switch (c) {
1924         case '?':
1925         case 'h':
1926             help();
1927             break;
1928         case 'f':
1929             fmt = optarg;
1930             break;
1931         case OPTION_OUTPUT:
1932             output = optarg;
1933             break;
1934         }
1935     }
1936     if (optind >= argc) {
1937         help();
1938     }
1939     filename = argv[optind++];
1940
1941     if (output && !strcmp(output, "json")) {
1942         output_format = OFORMAT_JSON;
1943     } else if (output && !strcmp(output, "human")) {
1944         output_format = OFORMAT_HUMAN;
1945     } else if (output) {
1946         error_report("--output must be used with human or json as argument.");
1947         return 1;
1948     }
1949
1950     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS, true, false);
1951     if (!bs) {
1952         return 1;
1953     }
1954
1955     if (output_format == OFORMAT_HUMAN) {
1956         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
1957     }
1958
1959     length = bdrv_getlength(bs);
1960     while (curr.start + curr.length < length) {
1961         int64_t nsectors_left;
1962         int64_t sector_num;
1963         int n;
1964
1965         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
1966
1967         /* Probe up to 1 GiB at a time.  */
1968         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
1969         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
1970         ret = get_block_status(bs, sector_num, n, &next);
1971
1972         if (ret < 0) {
1973             error_report("Could not read file metadata: %s", strerror(-ret));
1974             goto out;
1975         }
1976
1977         if (curr.length != 0 && curr.flags == next.flags &&
1978             curr.depth == next.depth &&
1979             ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
1980              curr.offset + curr.length == next.offset)) {
1981             curr.length += next.length;
1982             continue;
1983         }
1984
1985         if (curr.length > 0) {
1986             dump_map_entry(output_format, &curr, &next);
1987         }
1988         curr = next;
1989     }
1990
1991     dump_map_entry(output_format, &curr, NULL);
1992
1993 out:
1994     bdrv_unref(bs);
1995     return ret < 0;
1996 }
1997
1998 #define SNAPSHOT_LIST   1
1999 #define SNAPSHOT_CREATE 2
2000 #define SNAPSHOT_APPLY  3
2001 #define SNAPSHOT_DELETE 4
2002
2003 static int img_snapshot(int argc, char **argv)
2004 {
2005     BlockDriverState *bs;
2006     QEMUSnapshotInfo sn;
2007     char *filename, *snapshot_name = NULL;
2008     int c, ret = 0, bdrv_oflags;
2009     int action = 0;
2010     qemu_timeval tv;
2011     bool quiet = false;
2012     Error *err = NULL;
2013
2014     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2015     /* Parse commandline parameters */
2016     for(;;) {
2017         c = getopt(argc, argv, "la:c:d:hq");
2018         if (c == -1) {
2019             break;
2020         }
2021         switch(c) {
2022         case '?':
2023         case 'h':
2024             help();
2025             return 0;
2026         case 'l':
2027             if (action) {
2028                 help();
2029                 return 0;
2030             }
2031             action = SNAPSHOT_LIST;
2032             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2033             break;
2034         case 'a':
2035             if (action) {
2036                 help();
2037                 return 0;
2038             }
2039             action = SNAPSHOT_APPLY;
2040             snapshot_name = optarg;
2041             break;
2042         case 'c':
2043             if (action) {
2044                 help();
2045                 return 0;
2046             }
2047             action = SNAPSHOT_CREATE;
2048             snapshot_name = optarg;
2049             break;
2050         case 'd':
2051             if (action) {
2052                 help();
2053                 return 0;
2054             }
2055             action = SNAPSHOT_DELETE;
2056             snapshot_name = optarg;
2057             break;
2058         case 'q':
2059             quiet = true;
2060             break;
2061         }
2062     }
2063
2064     if (optind != argc - 1) {
2065         help();
2066     }
2067     filename = argv[optind++];
2068
2069     /* Open the image */
2070     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
2071     if (!bs) {
2072         return 1;
2073     }
2074
2075     /* Perform the requested action */
2076     switch(action) {
2077     case SNAPSHOT_LIST:
2078         dump_snapshots(bs);
2079         break;
2080
2081     case SNAPSHOT_CREATE:
2082         memset(&sn, 0, sizeof(sn));
2083         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2084
2085         qemu_gettimeofday(&tv);
2086         sn.date_sec = tv.tv_sec;
2087         sn.date_nsec = tv.tv_usec * 1000;
2088
2089         ret = bdrv_snapshot_create(bs, &sn);
2090         if (ret) {
2091             error_report("Could not create snapshot '%s': %d (%s)",
2092                 snapshot_name, ret, strerror(-ret));
2093         }
2094         break;
2095
2096     case SNAPSHOT_APPLY:
2097         ret = bdrv_snapshot_goto(bs, snapshot_name);
2098         if (ret) {
2099             error_report("Could not apply snapshot '%s': %d (%s)",
2100                 snapshot_name, ret, strerror(-ret));
2101         }
2102         break;
2103
2104     case SNAPSHOT_DELETE:
2105         bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2106         if (error_is_set(&err)) {
2107             error_report("Could not delete snapshot '%s': (%s)",
2108                          snapshot_name, error_get_pretty(err));
2109             error_free(err);
2110             ret = 1;
2111         }
2112         break;
2113     }
2114
2115     /* Cleanup */
2116     bdrv_unref(bs);
2117     if (ret) {
2118         return 1;
2119     }
2120     return 0;
2121 }
2122
2123 static int img_rebase(int argc, char **argv)
2124 {
2125     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2126     BlockDriver *old_backing_drv, *new_backing_drv;
2127     char *filename;
2128     const char *fmt, *cache, *out_basefmt, *out_baseimg;
2129     int c, flags, ret;
2130     int unsafe = 0;
2131     int progress = 0;
2132     bool quiet = false;
2133     Error *local_err = NULL;
2134
2135     /* Parse commandline parameters */
2136     fmt = NULL;
2137     cache = BDRV_DEFAULT_CACHE;
2138     out_baseimg = NULL;
2139     out_basefmt = NULL;
2140     for(;;) {
2141         c = getopt(argc, argv, "uhf:F:b:pt:q");
2142         if (c == -1) {
2143             break;
2144         }
2145         switch(c) {
2146         case '?':
2147         case 'h':
2148             help();
2149             return 0;
2150         case 'f':
2151             fmt = optarg;
2152             break;
2153         case 'F':
2154             out_basefmt = optarg;
2155             break;
2156         case 'b':
2157             out_baseimg = optarg;
2158             break;
2159         case 'u':
2160             unsafe = 1;
2161             break;
2162         case 'p':
2163             progress = 1;
2164             break;
2165         case 't':
2166             cache = optarg;
2167             break;
2168         case 'q':
2169             quiet = true;
2170             break;
2171         }
2172     }
2173
2174     if (quiet) {
2175         progress = 0;
2176     }
2177
2178     if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
2179         help();
2180     }
2181     filename = argv[optind++];
2182
2183     qemu_progress_init(progress, 2.0);
2184     qemu_progress_print(0, 100);
2185
2186     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2187     ret = bdrv_parse_cache_flags(cache, &flags);
2188     if (ret < 0) {
2189         error_report("Invalid cache option: %s", cache);
2190         return -1;
2191     }
2192
2193     /*
2194      * Open the images.
2195      *
2196      * Ignore the old backing file for unsafe rebase in case we want to correct
2197      * the reference to a renamed or moved backing file.
2198      */
2199     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2200     if (!bs) {
2201         return 1;
2202     }
2203
2204     /* Find the right drivers for the backing files */
2205     old_backing_drv = NULL;
2206     new_backing_drv = NULL;
2207
2208     if (!unsafe && bs->backing_format[0] != '\0') {
2209         old_backing_drv = bdrv_find_format(bs->backing_format);
2210         if (old_backing_drv == NULL) {
2211             error_report("Invalid format name: '%s'", bs->backing_format);
2212             ret = -1;
2213             goto out;
2214         }
2215     }
2216
2217     if (out_basefmt != NULL) {
2218         new_backing_drv = bdrv_find_format(out_basefmt);
2219         if (new_backing_drv == NULL) {
2220             error_report("Invalid format name: '%s'", out_basefmt);
2221             ret = -1;
2222             goto out;
2223         }
2224     }
2225
2226     /* For safe rebasing we need to compare old and new backing file */
2227     if (unsafe) {
2228         /* Make the compiler happy */
2229         bs_old_backing = NULL;
2230         bs_new_backing = NULL;
2231     } else {
2232         char backing_name[1024];
2233
2234         bs_old_backing = bdrv_new("old_backing");
2235         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2236         ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2237                         old_backing_drv, &local_err);
2238         if (ret) {
2239             error_report("Could not open old backing file '%s': %s",
2240                          backing_name, error_get_pretty(local_err));
2241             error_free(local_err);
2242             goto out;
2243         }
2244         if (out_baseimg[0]) {
2245             bs_new_backing = bdrv_new("new_backing");
2246             ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2247                         new_backing_drv, &local_err);
2248             if (ret) {
2249                 error_report("Could not open new backing file '%s': %s",
2250                              out_baseimg, error_get_pretty(local_err));
2251                 error_free(local_err);
2252                 goto out;
2253             }
2254         }
2255     }
2256
2257     /*
2258      * Check each unallocated cluster in the COW file. If it is unallocated,
2259      * accesses go to the backing file. We must therefore compare this cluster
2260      * in the old and new backing file, and if they differ we need to copy it
2261      * from the old backing file into the COW file.
2262      *
2263      * If qemu-img crashes during this step, no harm is done. The content of
2264      * the image is the same as the original one at any time.
2265      */
2266     if (!unsafe) {
2267         uint64_t num_sectors;
2268         uint64_t old_backing_num_sectors;
2269         uint64_t new_backing_num_sectors = 0;
2270         uint64_t sector;
2271         int n;
2272         uint8_t * buf_old;
2273         uint8_t * buf_new;
2274         float local_progress = 0;
2275
2276         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2277         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2278
2279         bdrv_get_geometry(bs, &num_sectors);
2280         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2281         if (bs_new_backing) {
2282             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2283         }
2284
2285         if (num_sectors != 0) {
2286             local_progress = (float)100 /
2287                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2288         }
2289
2290         for (sector = 0; sector < num_sectors; sector += n) {
2291
2292             /* How many sectors can we handle with the next read? */
2293             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2294                 n = (IO_BUF_SIZE / 512);
2295             } else {
2296                 n = num_sectors - sector;
2297             }
2298
2299             /* If the cluster is allocated, we don't need to take action */
2300             ret = bdrv_is_allocated(bs, sector, n, &n);
2301             if (ret < 0) {
2302                 error_report("error while reading image metadata: %s",
2303                              strerror(-ret));
2304                 goto out;
2305             }
2306             if (ret) {
2307                 continue;
2308             }
2309
2310             /*
2311              * Read old and new backing file and take into consideration that
2312              * backing files may be smaller than the COW image.
2313              */
2314             if (sector >= old_backing_num_sectors) {
2315                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2316             } else {
2317                 if (sector + n > old_backing_num_sectors) {
2318                     n = old_backing_num_sectors - sector;
2319                 }
2320
2321                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2322                 if (ret < 0) {
2323                     error_report("error while reading from old backing file");
2324                     goto out;
2325                 }
2326             }
2327
2328             if (sector >= new_backing_num_sectors || !bs_new_backing) {
2329                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2330             } else {
2331                 if (sector + n > new_backing_num_sectors) {
2332                     n = new_backing_num_sectors - sector;
2333                 }
2334
2335                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2336                 if (ret < 0) {
2337                     error_report("error while reading from new backing file");
2338                     goto out;
2339                 }
2340             }
2341
2342             /* If they differ, we need to write to the COW file */
2343             uint64_t written = 0;
2344
2345             while (written < n) {
2346                 int pnum;
2347
2348                 if (compare_sectors(buf_old + written * 512,
2349                     buf_new + written * 512, n - written, &pnum))
2350                 {
2351                     ret = bdrv_write(bs, sector + written,
2352                         buf_old + written * 512, pnum);
2353                     if (ret < 0) {
2354                         error_report("Error while writing to COW image: %s",
2355                             strerror(-ret));
2356                         goto out;
2357                     }
2358                 }
2359
2360                 written += pnum;
2361             }
2362             qemu_progress_print(local_progress, 100);
2363         }
2364
2365         qemu_vfree(buf_old);
2366         qemu_vfree(buf_new);
2367     }
2368
2369     /*
2370      * Change the backing file. All clusters that are different from the old
2371      * backing file are overwritten in the COW file now, so the visible content
2372      * doesn't change when we switch the backing file.
2373      */
2374     if (out_baseimg && *out_baseimg) {
2375         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2376     } else {
2377         ret = bdrv_change_backing_file(bs, NULL, NULL);
2378     }
2379
2380     if (ret == -ENOSPC) {
2381         error_report("Could not change the backing file to '%s': No "
2382                      "space left in the file header", out_baseimg);
2383     } else if (ret < 0) {
2384         error_report("Could not change the backing file to '%s': %s",
2385             out_baseimg, strerror(-ret));
2386     }
2387
2388     qemu_progress_print(100, 0);
2389     /*
2390      * TODO At this point it is possible to check if any clusters that are
2391      * allocated in the COW file are the same in the backing file. If so, they
2392      * could be dropped from the COW file. Don't do this before switching the
2393      * backing file, in case of a crash this would lead to corruption.
2394      */
2395 out:
2396     qemu_progress_end();
2397     /* Cleanup */
2398     if (!unsafe) {
2399         if (bs_old_backing != NULL) {
2400             bdrv_unref(bs_old_backing);
2401         }
2402         if (bs_new_backing != NULL) {
2403             bdrv_unref(bs_new_backing);
2404         }
2405     }
2406
2407     bdrv_unref(bs);
2408     if (ret) {
2409         return 1;
2410     }
2411     return 0;
2412 }
2413
2414 static int img_resize(int argc, char **argv)
2415 {
2416     int c, ret, relative;
2417     const char *filename, *fmt, *size;
2418     int64_t n, total_size;
2419     bool quiet = false;
2420     BlockDriverState *bs = NULL;
2421     QemuOpts *param;
2422     static QemuOptsList resize_options = {
2423         .name = "resize_options",
2424         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2425         .desc = {
2426             {
2427                 .name = BLOCK_OPT_SIZE,
2428                 .type = QEMU_OPT_SIZE,
2429                 .help = "Virtual disk size"
2430             }, {
2431                 /* end of list */
2432             }
2433         },
2434     };
2435
2436     /* Remove size from argv manually so that negative numbers are not treated
2437      * as options by getopt. */
2438     if (argc < 3) {
2439         help();
2440         return 1;
2441     }
2442
2443     size = argv[--argc];
2444
2445     /* Parse getopt arguments */
2446     fmt = NULL;
2447     for(;;) {
2448         c = getopt(argc, argv, "f:hq");
2449         if (c == -1) {
2450             break;
2451         }
2452         switch(c) {
2453         case '?':
2454         case 'h':
2455             help();
2456             break;
2457         case 'f':
2458             fmt = optarg;
2459             break;
2460         case 'q':
2461             quiet = true;
2462             break;
2463         }
2464     }
2465     if (optind != argc - 1) {
2466         help();
2467     }
2468     filename = argv[optind++];
2469
2470     /* Choose grow, shrink, or absolute resize mode */
2471     switch (size[0]) {
2472     case '+':
2473         relative = 1;
2474         size++;
2475         break;
2476     case '-':
2477         relative = -1;
2478         size++;
2479         break;
2480     default:
2481         relative = 0;
2482         break;
2483     }
2484
2485     /* Parse size */
2486     param = qemu_opts_create_nofail(&resize_options);
2487     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2488         /* Error message already printed when size parsing fails */
2489         ret = -1;
2490         qemu_opts_del(param);
2491         goto out;
2492     }
2493     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2494     qemu_opts_del(param);
2495
2496     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2497     if (!bs) {
2498         ret = -1;
2499         goto out;
2500     }
2501
2502     if (relative) {
2503         total_size = bdrv_getlength(bs) + n * relative;
2504     } else {
2505         total_size = n;
2506     }
2507     if (total_size <= 0) {
2508         error_report("New image size must be positive");
2509         ret = -1;
2510         goto out;
2511     }
2512
2513     ret = bdrv_truncate(bs, total_size);
2514     switch (ret) {
2515     case 0:
2516         qprintf(quiet, "Image resized.\n");
2517         break;
2518     case -ENOTSUP:
2519         error_report("This image does not support resize");
2520         break;
2521     case -EACCES:
2522         error_report("Image is read-only");
2523         break;
2524     default:
2525         error_report("Error resizing image (%d)", -ret);
2526         break;
2527     }
2528 out:
2529     if (bs) {
2530         bdrv_unref(bs);
2531     }
2532     if (ret) {
2533         return 1;
2534     }
2535     return 0;
2536 }
2537
2538 static int img_amend(int argc, char **argv)
2539 {
2540     int c, ret = 0;
2541     char *options = NULL;
2542     QEMUOptionParameter *create_options = NULL, *options_param = NULL;
2543     const char *fmt = NULL, *filename;
2544     bool quiet = false;
2545     BlockDriverState *bs = NULL;
2546
2547     for (;;) {
2548         c = getopt(argc, argv, "hqf:o:");
2549         if (c == -1) {
2550             break;
2551         }
2552
2553         switch (c) {
2554             case 'h':
2555             case '?':
2556                 help();
2557                 break;
2558             case 'o':
2559                 options = optarg;
2560                 break;
2561             case 'f':
2562                 fmt = optarg;
2563                 break;
2564             case 'q':
2565                 quiet = true;
2566                 break;
2567         }
2568     }
2569
2570     if (optind != argc - 1) {
2571         help();
2572     }
2573
2574     if (!options) {
2575         help();
2576     }
2577
2578     filename = argv[argc - 1];
2579
2580     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2581     if (!bs) {
2582         error_report("Could not open image '%s'", filename);
2583         ret = -1;
2584         goto out;
2585     }
2586
2587     fmt = bs->drv->format_name;
2588
2589     if (is_help_option(options)) {
2590         ret = print_block_option_help(filename, fmt);
2591         goto out;
2592     }
2593
2594     create_options = append_option_parameters(create_options,
2595             bs->drv->create_options);
2596     options_param = parse_option_parameters(options, create_options,
2597             options_param);
2598     if (options_param == NULL) {
2599         error_report("Invalid options for file format '%s'", fmt);
2600         ret = -1;
2601         goto out;
2602     }
2603
2604     ret = bdrv_amend_options(bs, options_param);
2605     if (ret < 0) {
2606         error_report("Error while amending options: %s", strerror(-ret));
2607         goto out;
2608     }
2609
2610 out:
2611     if (bs) {
2612         bdrv_unref(bs);
2613     }
2614     free_option_parameters(create_options);
2615     free_option_parameters(options_param);
2616     if (ret) {
2617         return 1;
2618     }
2619     return 0;
2620 }
2621
2622 static const img_cmd_t img_cmds[] = {
2623 #define DEF(option, callback, arg_string)        \
2624     { option, callback },
2625 #include "qemu-img-cmds.h"
2626 #undef DEF
2627 #undef GEN_DOCS
2628     { NULL, NULL, },
2629 };
2630
2631 int main(int argc, char **argv)
2632 {
2633     const img_cmd_t *cmd;
2634     const char *cmdname;
2635
2636 #ifdef CONFIG_POSIX
2637     signal(SIGPIPE, SIG_IGN);
2638 #endif
2639
2640     error_set_progname(argv[0]);
2641
2642     qemu_init_main_loop();
2643     bdrv_init();
2644     if (argc < 2)
2645         help();
2646     cmdname = argv[1];
2647     argc--; argv++;
2648
2649     /* find the command */
2650     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2651         if (!strcmp(cmdname, cmd->name)) {
2652             return cmd->handler(argc, argv);
2653         }
2654     }
2655
2656     /* not found */
2657     help();
2658     return 0;
2659 }