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