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
  25 #include "qemu/osdep.h"
  26 #include <getopt.h>
  27
  28 #include "qemu-common.h"
  29 #include "qemu-version.h"
  30 #include "qapi/error.h"
  31 #include "qapi/qapi-commands-block-core.h"
  32 #include "qapi/qapi-visit-block-core.h"
  33 #include "qapi/qobject-output-visitor.h"
  34 #include "qapi/qmp/qjson.h"
  35 #include "qapi/qmp/qdict.h"
  36 #include "qapi/qmp/qstring.h"
  37 #include "qemu/cutils.h"
  38 #include "qemu/config-file.h"
  39 #include "qemu/option.h"
  40 #include "qemu/error-report.h"
  41 #include "qemu/log.h"
  42 #include "qemu/main-loop.h"
  43 #include "qemu/module.h"
  44 #include "qemu/units.h"
  45 #include "qom/object_interfaces.h"
  46 #include "sysemu/block-backend.h"
  47 #include "block/block_int.h"
  48 #include "block/blockjob.h"
  49 #include "block/qapi.h"
  50 #include "crypto/init.h"
  51 #include "trace/control.h"
  52
  53 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \
  54                           "\n" QEMU_COPYRIGHT "\n"
  55
  56 typedef struct img_cmd_t {
  57     const char *name;
  58     int (*handler)(int argc, char **argv);
  59 } img_cmd_t;
  60
  61 enum {
  62     OPTION_OUTPUT = 256,
  63     OPTION_BACKING_CHAIN = 257,
  64     OPTION_OBJECT = 258,
  65     OPTION_IMAGE_OPTS = 259,
  66     OPTION_PATTERN = 260,
  67     OPTION_FLUSH_INTERVAL = 261,
  68     OPTION_NO_DRAIN = 262,
  69     OPTION_TARGET_IMAGE_OPTS = 263,
  70     OPTION_SIZE = 264,
  71     OPTION_PREALLOCATION = 265,
  72     OPTION_SHRINK = 266,
  73     OPTION_SALVAGE = 267,
  74     OPTION_TARGET_IS_ZERO = 268,
  75     OPTION_ADD = 269,
  76     OPTION_REMOVE = 270,
  77     OPTION_CLEAR = 271,
  78     OPTION_ENABLE = 272,
  79     OPTION_DISABLE = 273,
  80     OPTION_MERGE = 274,
  81 };
  82
  83 typedef enum OutputFormat {
  84     OFORMAT_JSON,
  85     OFORMAT_HUMAN,
  86 } OutputFormat;
  87
  88 /* Default to cache=writeback as data integrity is not important for qemu-img */
  89 #define BDRV_DEFAULT_CACHE "writeback"
  90
  91 static void format_print(void *opaque, const char *name)
  92 {
  93     printf(" %s", name);
  94 }
  95
  96 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
  97 {
  98     va_list ap;
  99
 100     va_start(ap, fmt);
 101     error_vreport(fmt, ap);
 102     va_end(ap);
 103
 104     error_printf("Try 'qemu-img --help' for more information\n");
 105     exit(EXIT_FAILURE);
 106 }
 107
 108 static void QEMU_NORETURN missing_argument(const char *option)
 109 {
 110     error_exit("missing argument for option '%s'", option);
 111 }
 112
 113 static void QEMU_NORETURN unrecognized_option(const char *option)
 114 {
 115     error_exit("unrecognized option '%s'", option);
 116 }
 117
 118 /* Please keep in synch with docs/tools/qemu-img.rst */
 119 static void QEMU_NORETURN help(void)
 120 {
 121     const char *help_msg =
 122            QEMU_IMG_VERSION
 123            "usage: qemu-img [standard options] command [command options]\n"
 124            "QEMU disk image utility\n"
 125            "\n"
 126            "    '-h', '--help'       display this help and exit\n"
 127            "    '-V', '--version'    output version information and exit\n"
 128            "    '-T', '--trace'      [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
 129            "                         specify tracing options\n"
 130            "\n"
 131            "Command syntax:\n"
 132 #define DEF(option, callback, arg_string)        \
 133            "  " arg_string "\n"
 134 #include "qemu-img-cmds.h"
 135 #undef DEF
 136            "\n"
 137            "Command parameters:\n"
 138            "  'filename' is a disk image filename\n"
 139            "  'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
 140            "    manual page for a description of the object properties. The most common\n"
 141            "    object type is a 'secret', which is used to supply passwords and/or\n"
 142            "    encryption keys.\n"
 143            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
 144            "  'cache' is the cache mode used to write the output disk image, the valid\n"
 145            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
 146            "    'directsync' and 'unsafe' (default for convert)\n"
 147            "  'src_cache' is the cache mode used to read input disk images, the valid\n"
 148            "    options are the same as for the 'cache' option\n"
 149            "  'size' is the disk image size in bytes. Optional suffixes\n"
 150            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
 151            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
 152            "    supported. 'b' is ignored.\n"
 153            "  'output_filename' is the destination disk image filename\n"
 154            "  'output_fmt' is the destination format\n"
 155            "  'options' is a comma separated list of format specific options in a\n"
 156            "    name=value format. Use -o ? for an overview of the options supported by the\n"
 157            "    used format\n"
 158            "  'snapshot_param' is param used for internal snapshot, format\n"
 159            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
 160            "    '[ID_OR_NAME]'\n"
 161            "  '-c' indicates that target image must be compressed (qcow format only)\n"
 162            "  '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
 163            "       new backing file match exactly. The image doesn't need a working\n"
 164            "       backing file before rebasing in this case (useful for renaming the\n"
 165            "       backing file). For image creation, allow creating without attempting\n"
 166            "       to open the backing file.\n"
 167            "  '-h' with or without a command shows this help and lists the supported formats\n"
 168            "  '-p' show progress of command (only certain commands)\n"
 169            "  '-q' use Quiet mode - do not print any output (except errors)\n"
 170            "  '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
 171            "       contain only zeros for qemu-img to create a sparse image during\n"
 172            "       conversion. If the number of bytes is 0, the source will not be scanned for\n"
 173            "       unallocated or zero sectors, and the destination image will always be\n"
 174            "       fully allocated\n"
 175            "  '--output' takes the format in which the output must be done (human or json)\n"
 176            "  '-n' skips the target volume creation (useful if the volume is created\n"
 177            "       prior to running qemu-img)\n"
 178            "\n"
 179            "Parameters to bitmap subcommand:\n"
 180            "  'bitmap' is the name of the bitmap to manipulate, through one or more\n"
 181            "       actions from '--add', '--remove', '--clear', '--enable', '--disable',\n"
 182            "       or '--merge source'\n"
 183            "  '-g granularity' sets the granularity for '--add' actions\n"
 184            "  '-b source' and '-F src_fmt' tell '--merge' actions to find the source\n"
 185            "       bitmaps from an alternative file\n"
 186            "\n"
 187            "Parameters to check subcommand:\n"
 188            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
 189            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
 190            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
 191            "       hiding corruption that has already occurred.\n"
 192            "\n"
 193            "Parameters to convert subcommand:\n"
 194            "  '-m' specifies how many coroutines work in parallel during the convert\n"
 195            "       process (defaults to 8)\n"
 196            "  '-W' allow to write to the target out of order rather than sequential\n"
 197            "\n"
 198            "Parameters to snapshot subcommand:\n"
 199            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 200            "  '-a' applies a snapshot (revert disk to saved state)\n"
 201            "  '-c' creates a snapshot\n"
 202            "  '-d' deletes a snapshot\n"
 203            "  '-l' lists all snapshots in the given image\n"
 204            "\n"
 205            "Parameters to compare subcommand:\n"
 206            "  '-f' first image format\n"
 207            "  '-F' second image format\n"
 208            "  '-s' run in Strict mode - fail on different image size or sector allocation\n"
 209            "\n"
 210            "Parameters to dd subcommand:\n"
 211            "  'bs=BYTES' read and write up to BYTES bytes at a time "
 212            "(default: 512)\n"
 213            "  'count=N' copy only N input blocks\n"
 214            "  'if=FILE' read from FILE\n"
 215            "  'of=FILE' write to FILE\n"
 216            "  'skip=N' skip N bs-sized blocks at the start of input\n";
 217
 218     printf("%s\nSupported formats:", help_msg);
 219     bdrv_iterate_format(format_print, NULL, false);
 220     printf("\n\n" QEMU_HELP_BOTTOM "\n");
 221     exit(EXIT_SUCCESS);
 222 }
 223
 224 static QemuOptsList qemu_object_opts = {
 225     .name = "object",
 226     .implied_opt_name = "qom-type",
 227     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
 228     .desc = {
 229         { }
 230     },
 231 };
 232
 233 static bool qemu_img_object_print_help(const char *type, QemuOpts *opts)
 234 {
 235     if (user_creatable_print_help(type, opts)) {
 236         exit(0);
 237     }
 238     return true;
 239 }
 240
 241 /*
 242  * Is @optarg safe for accumulate_options()?
 243  * It is when multiple of them can be joined together separated by ','.
 244  * To make that work, @optarg must not start with ',' (or else a
 245  * separating ',' preceding it gets escaped), and it must not end with
 246  * an odd number of ',' (or else a separating ',' following it gets
 247  * escaped), or be empty (or else a separating ',' preceding it can
 248  * escape a separating ',' following it).
 249  *
 250  */
 251 static bool is_valid_option_list(const char *optarg)
 252 {
 253     size_t len = strlen(optarg);
 254     size_t i;
 255
 256     if (!optarg[0] || optarg[0] == ',') {
 257         return false;
 258     }
 259
 260     for (i = len; i > 0 && optarg[i - 1] == ','; i--) {
 261     }
 262     if ((len - i) % 2) {
 263         return false;
 264     }
 265
 266     return true;
 267 }
 268
 269 static int accumulate_options(char **options, char *optarg)
 270 {
 271     char *new_options;
 272
 273     if (!is_valid_option_list(optarg)) {
 274         error_report("Invalid option list: %s", optarg);
 275         return -1;
 276     }
 277
 278     if (!*options) {
 279         *options = g_strdup(optarg);
 280     } else {
 281         new_options = g_strdup_printf("%s,%s", *options, optarg);
 282         g_free(*options);
 283         *options = new_options;
 284     }
 285     return 0;
 286 }
 287
 288 static QemuOptsList qemu_source_opts = {
 289     .name = "source",
 290     .implied_opt_name = "file",
 291     .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
 292     .desc = {
 293         { }
 294     },
 295 };
 296
 297 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
 298 {
 299     int ret = 0;
 300     if (!quiet) {
 301         va_list args;
 302         va_start(args, fmt);
 303         ret = vprintf(fmt, args);
 304         va_end(args);
 305     }
 306     return ret;
 307 }
 308
 309
 310 static int print_block_option_help(const char *filename, const char *fmt)
 311 {
 312     BlockDriver *drv, *proto_drv;
 313     QemuOptsList *create_opts = NULL;
 314     Error *local_err = NULL;
 315
 316     /* Find driver and parse its options */
 317     drv = bdrv_find_format(fmt);
 318     if (!drv) {
 319         error_report("Unknown file format '%s'", fmt);
 320         return 1;
 321     }
 322
 323     if (!drv->create_opts) {
 324         error_report("Format driver '%s' does not support image creation", fmt);
 325         return 1;
 326     }
 327
 328     create_opts = qemu_opts_append(create_opts, drv->create_opts);
 329     if (filename) {
 330         proto_drv = bdrv_find_protocol(filename, true, &local_err);
 331         if (!proto_drv) {
 332             error_report_err(local_err);
 333             qemu_opts_free(create_opts);
 334             return 1;
 335         }
 336         if (!proto_drv->create_opts) {
 337             error_report("Protocol driver '%s' does not support image creation",
 338                          proto_drv->format_name);
 339             qemu_opts_free(create_opts);
 340             return 1;
 341         }
 342         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 343     }
 344
 345     if (filename) {
 346         printf("Supported options:\n");
 347     } else {
 348         printf("Supported %s options:\n", fmt);
 349     }
 350     qemu_opts_print_help(create_opts, false);
 351     qemu_opts_free(create_opts);
 352
 353     if (!filename) {
 354         printf("\n"
 355                "The protocol level may support further options.\n"
 356                "Specify the target filename to include those options.\n");
 357     }
 358
 359     return 0;
 360 }
 361
 362
 363 static BlockBackend *img_open_opts(const char *optstr,
 364                                    QemuOpts *opts, int flags, bool writethrough,
 365                                    bool quiet, bool force_share)
 366 {
 367     QDict *options;
 368     Error *local_err = NULL;
 369     BlockBackend *blk;
 370     options = qemu_opts_to_qdict(opts, NULL);
 371     if (force_share) {
 372         if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
 373             && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) {
 374             error_report("--force-share/-U conflicts with image options");
 375             qobject_unref(options);
 376             return NULL;
 377         }
 378         qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on");
 379     }
 380     blk = blk_new_open(NULL, NULL, options, flags, &local_err);
 381     if (!blk) {
 382         error_reportf_err(local_err, "Could not open '%s': ", optstr);
 383         return NULL;
 384     }
 385     blk_set_enable_write_cache(blk, !writethrough);
 386
 387     return blk;
 388 }
 389
 390 static BlockBackend *img_open_file(const char *filename,
 391                                    QDict *options,
 392                                    const char *fmt, int flags,
 393                                    bool writethrough, bool quiet,
 394                                    bool force_share)
 395 {
 396     BlockBackend *blk;
 397     Error *local_err = NULL;
 398
 399     if (!options) {
 400         options = qdict_new();
 401     }
 402     if (fmt) {
 403         qdict_put_str(options, "driver", fmt);
 404     }
 405
 406     if (force_share) {
 407         qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
 408     }
 409     blk = blk_new_open(filename, NULL, options, flags, &local_err);
 410     if (!blk) {
 411         error_reportf_err(local_err, "Could not open '%s': ", filename);
 412         return NULL;
 413     }
 414     blk_set_enable_write_cache(blk, !writethrough);
 415
 416     return blk;
 417 }
 418
 419
 420 static int img_add_key_secrets(void *opaque,
 421                                const char *name, const char *value,
 422                                Error **errp)
 423 {
 424     QDict *options = opaque;
 425
 426     if (g_str_has_suffix(name, "key-secret")) {
 427         qdict_put_str(options, name, value);
 428     }
 429
 430     return 0;
 431 }
 432
 433
 434 static BlockBackend *img_open(bool image_opts,
 435                               const char *filename,
 436                               const char *fmt, int flags, bool writethrough,
 437                               bool quiet, bool force_share)
 438 {
 439     BlockBackend *blk;
 440     if (image_opts) {
 441         QemuOpts *opts;
 442         if (fmt) {
 443             error_report("--image-opts and --format are mutually exclusive");
 444             return NULL;
 445         }
 446         opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
 447                                        filename, true);
 448         if (!opts) {
 449             return NULL;
 450         }
 451         blk = img_open_opts(filename, opts, flags, writethrough, quiet,
 452                             force_share);
 453     } else {
 454         blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
 455                             force_share);
 456     }
 457     return blk;
 458 }
 459
 460
 461 static int add_old_style_options(const char *fmt, QemuOpts *opts,
 462                                  const char *base_filename,
 463                                  const char *base_fmt)
 464 {
 465     Error *err = NULL;
 466
 467     if (base_filename) {
 468         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
 469         if (err) {
 470             error_report("Backing file not supported for file format '%s'",
 471                          fmt);
 472             error_free(err);
 473             return -1;
 474         }
 475     }
 476     if (base_fmt) {
 477         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
 478         if (err) {
 479             error_report("Backing file format not supported for file "
 480                          "format '%s'", fmt);
 481             error_free(err);
 482             return -1;
 483         }
 484     }
 485     return 0;
 486 }
 487
 488 static int64_t cvtnum_full(const char *name, const char *value, int64_t min,
 489                            int64_t max)
 490 {
 491     int err;
 492     uint64_t res;
 493
 494     err = qemu_strtosz(value, NULL, &res);
 495     if (err < 0 && err != -ERANGE) {
 496         error_report("Invalid %s specified. You may use "
 497                      "k, M, G, T, P or E suffixes for", name);
 498         error_report("kilobytes, megabytes, gigabytes, terabytes, "
 499                      "petabytes and exabytes.");
 500         return err;
 501     }
 502     if (err == -ERANGE || res > max || res < min) {
 503         error_report("Invalid %s specified. Must be between %" PRId64
 504                      " and %" PRId64 ".", name, min, max);
 505         return -ERANGE;
 506     }
 507     return res;
 508 }
 509
 510 static int64_t cvtnum(const char *name, const char *value)
 511 {
 512     return cvtnum_full(name, value, 0, INT64_MAX);
 513 }
 514
 515 static int img_create(int argc, char **argv)
 516 {
 517     int c;
 518     uint64_t img_size = -1;
 519     const char *fmt = "raw";
 520     const char *base_fmt = NULL;
 521     const char *filename;
 522     const char *base_filename = NULL;
 523     char *options = NULL;
 524     Error *local_err = NULL;
 525     bool quiet = false;
 526     int flags = 0;
 527
 528     for(;;) {
 529         static const struct option long_options[] = {
 530             {"help", no_argument, 0, 'h'},
 531             {"object", required_argument, 0, OPTION_OBJECT},
 532             {0, 0, 0, 0}
 533         };
 534         c = getopt_long(argc, argv, ":F:b:f:ho:qu",
 535                         long_options, NULL);
 536         if (c == -1) {
 537             break;
 538         }
 539         switch(c) {
 540         case ':':
 541             missing_argument(argv[optind - 1]);
 542             break;
 543         case '?':
 544             unrecognized_option(argv[optind - 1]);
 545             break;
 546         case 'h':
 547             help();
 548             break;
 549         case 'F':
 550             base_fmt = optarg;
 551             break;
 552         case 'b':
 553             base_filename = optarg;
 554             break;
 555         case 'f':
 556             fmt = optarg;
 557             break;
 558         case 'o':
 559             if (accumulate_options(&options, optarg) < 0) {
 560                 goto fail;
 561             }
 562             break;
 563         case 'q':
 564             quiet = true;
 565             break;
 566         case 'u':
 567             flags |= BDRV_O_NO_BACKING;
 568             break;
 569         case OPTION_OBJECT: {
 570             QemuOpts *opts;
 571             opts = qemu_opts_parse_noisily(&qemu_object_opts,
 572                                            optarg, true);
 573             if (!opts) {
 574                 goto fail;
 575             }
 576         }   break;
 577         }
 578     }
 579
 580     /* Get the filename */
 581     filename = (optind < argc) ? argv[optind] : NULL;
 582     if (options && has_help_option(options)) {
 583         g_free(options);
 584         return print_block_option_help(filename, fmt);
 585     }
 586
 587     if (optind >= argc) {
 588         error_exit("Expecting image file name");
 589     }
 590     optind++;
 591
 592     if (qemu_opts_foreach(&qemu_object_opts,
 593                           user_creatable_add_opts_foreach,
 594                           qemu_img_object_print_help, &error_fatal)) {
 595         goto fail;
 596     }
 597
 598     /* Get image size, if specified */
 599     if (optind < argc) {
 600         int64_t sval;
 601
 602         sval = cvtnum("image size", argv[optind++]);
 603         if (sval < 0) {
 604             goto fail;
 605         }
 606         img_size = (uint64_t)sval;
 607     }
 608     if (optind != argc) {
 609         error_exit("Unexpected argument: %s", argv[optind]);
 610     }
 611
 612     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 613                     options, img_size, flags, quiet, &local_err);
 614     if (local_err) {
 615         error_reportf_err(local_err, "%s: ", filename);
 616         goto fail;
 617     }
 618
 619     g_free(options);
 620     return 0;
 621
 622 fail:
 623     g_free(options);
 624     return 1;
 625 }
 626
 627 static void dump_json_image_check(ImageCheck *check, bool quiet)
 628 {
 629     QString *str;
 630     QObject *obj;
 631     Visitor *v = qobject_output_visitor_new(&obj);
 632
 633     visit_type_ImageCheck(v, NULL, &check, &error_abort);
 634     visit_complete(v, &obj);
 635     str = qobject_to_json_pretty(obj);
 636     assert(str != NULL);
 637     qprintf(quiet, "%s\n", qstring_get_str(str));
 638     qobject_unref(obj);
 639     visit_free(v);
 640     qobject_unref(str);
 641 }
 642
 643 static void dump_human_image_check(ImageCheck *check, bool quiet)
 644 {
 645     if (!(check->corruptions || check->leaks || check->check_errors)) {
 646         qprintf(quiet, "No errors were found on the image.\n");
 647     } else {
 648         if (check->corruptions) {
 649             qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
 650                     "Data may be corrupted, or further writes to the image "
 651                     "may corrupt it.\n",
 652                     check->corruptions);
 653         }
 654
 655         if (check->leaks) {
 656             qprintf(quiet,
 657                     "\n%" PRId64 " leaked clusters were found on the image.\n"
 658                     "This means waste of disk space, but no harm to data.\n",
 659                     check->leaks);
 660         }
 661
 662         if (check->check_errors) {
 663             qprintf(quiet,
 664                     "\n%" PRId64
 665                     " internal errors have occurred during the check.\n",
 666                     check->check_errors);
 667         }
 668     }
 669
 670     if (check->total_clusters != 0 && check->allocated_clusters != 0) {
 671         qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
 672                 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
 673                 check->allocated_clusters, check->total_clusters,
 674                 check->allocated_clusters * 100.0 / check->total_clusters,
 675                 check->fragmented_clusters * 100.0 / check->allocated_clusters,
 676                 check->compressed_clusters * 100.0 /
 677                 check->allocated_clusters);
 678     }
 679
 680     if (check->image_end_offset) {
 681         qprintf(quiet,
 682                 "Image end offset: %" PRId64 "\n", check->image_end_offset);
 683     }
 684 }
 685
 686 static int collect_image_check(BlockDriverState *bs,
 687                    ImageCheck *check,
 688                    const char *filename,
 689                    const char *fmt,
 690                    int fix)
 691 {
 692     int ret;
 693     BdrvCheckResult result;
 694
 695     ret = bdrv_check(bs, &result, fix);
 696     if (ret < 0) {
 697         return ret;
 698     }
 699
 700     check->filename                 = g_strdup(filename);
 701     check->format                   = g_strdup(bdrv_get_format_name(bs));
 702     check->check_errors             = result.check_errors;
 703     check->corruptions              = result.corruptions;
 704     check->has_corruptions          = result.corruptions != 0;
 705     check->leaks                    = result.leaks;
 706     check->has_leaks                = result.leaks != 0;
 707     check->corruptions_fixed        = result.corruptions_fixed;
 708     check->has_corruptions_fixed    = result.corruptions_fixed != 0;
 709     check->leaks_fixed              = result.leaks_fixed;
 710     check->has_leaks_fixed          = result.leaks_fixed != 0;
 711     check->image_end_offset         = result.image_end_offset;
 712     check->has_image_end_offset     = result.image_end_offset != 0;
 713     check->total_clusters           = result.bfi.total_clusters;
 714     check->has_total_clusters       = result.bfi.total_clusters != 0;
 715     check->allocated_clusters       = result.bfi.allocated_clusters;
 716     check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
 717     check->fragmented_clusters      = result.bfi.fragmented_clusters;
 718     check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
 719     check->compressed_clusters      = result.bfi.compressed_clusters;
 720     check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
 721
 722     return 0;
 723 }
 724
 725 /*
 726  * Checks an image for consistency. Exit codes:
 727  *
 728  *  0 - Check completed, image is good
 729  *  1 - Check not completed because of internal errors
 730  *  2 - Check completed, image is corrupted
 731  *  3 - Check completed, image has leaked clusters, but is good otherwise
 732  * 63 - Checks are not supported by the image format
 733  */
 734 static int img_check(int argc, char **argv)
 735 {
 736     int c, ret;
 737     OutputFormat output_format = OFORMAT_HUMAN;
 738     const char *filename, *fmt, *output, *cache;
 739     BlockBackend *blk;
 740     BlockDriverState *bs;
 741     int fix = 0;
 742     int flags = BDRV_O_CHECK;
 743     bool writethrough;
 744     ImageCheck *check;
 745     bool quiet = false;
 746     bool image_opts = false;
 747     bool force_share = false;
 748
 749     fmt = NULL;
 750     output = NULL;
 751     cache = BDRV_DEFAULT_CACHE;
 752
 753     for(;;) {
 754         int option_index = 0;
 755         static const struct option long_options[] = {
 756             {"help", no_argument, 0, 'h'},
 757             {"format", required_argument, 0, 'f'},
 758             {"repair", required_argument, 0, 'r'},
 759             {"output", required_argument, 0, OPTION_OUTPUT},
 760             {"object", required_argument, 0, OPTION_OBJECT},
 761             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
 762             {"force-share", no_argument, 0, 'U'},
 763             {0, 0, 0, 0}
 764         };
 765         c = getopt_long(argc, argv, ":hf:r:T:qU",
 766                         long_options, &option_index);
 767         if (c == -1) {
 768             break;
 769         }
 770         switch(c) {
 771         case ':':
 772             missing_argument(argv[optind - 1]);
 773             break;
 774         case '?':
 775             unrecognized_option(argv[optind - 1]);
 776             break;
 777         case 'h':
 778             help();
 779             break;
 780         case 'f':
 781             fmt = optarg;
 782             break;
 783         case 'r':
 784             flags |= BDRV_O_RDWR;
 785
 786             if (!strcmp(optarg, "leaks")) {
 787                 fix = BDRV_FIX_LEAKS;
 788             } else if (!strcmp(optarg, "all")) {
 789                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 790             } else {
 791                 error_exit("Unknown option value for -r "
 792                            "(expecting 'leaks' or 'all'): %s", optarg);
 793             }
 794             break;
 795         case OPTION_OUTPUT:
 796             output = optarg;
 797             break;
 798         case 'T':
 799             cache = optarg;
 800             break;
 801         case 'q':
 802             quiet = true;
 803             break;
 804         case 'U':
 805             force_share = true;
 806             break;
 807         case OPTION_OBJECT: {
 808             QemuOpts *opts;
 809             opts = qemu_opts_parse_noisily(&qemu_object_opts,
 810                                            optarg, true);
 811             if (!opts) {
 812                 return 1;
 813             }
 814         }   break;
 815         case OPTION_IMAGE_OPTS:
 816             image_opts = true;
 817             break;
 818         }
 819     }
 820     if (optind != argc - 1) {
 821         error_exit("Expecting one image file name");
 822     }
 823     filename = argv[optind++];
 824
 825     if (output && !strcmp(output, "json")) {
 826         output_format = OFORMAT_JSON;
 827     } else if (output && !strcmp(output, "human")) {
 828         output_format = OFORMAT_HUMAN;
 829     } else if (output) {
 830         error_report("--output must be used with human or json as argument.");
 831         return 1;
 832     }
 833
 834     if (qemu_opts_foreach(&qemu_object_opts,
 835                           user_creatable_add_opts_foreach,
 836                           qemu_img_object_print_help, &error_fatal)) {
 837         return 1;
 838     }
 839
 840     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
 841     if (ret < 0) {
 842         error_report("Invalid source cache option: %s", cache);
 843         return 1;
 844     }
 845
 846     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
 847                    force_share);
 848     if (!blk) {
 849         return 1;
 850     }
 851     bs = blk_bs(blk);
 852
 853     check = g_new0(ImageCheck, 1);
 854     ret = collect_image_check(bs, check, filename, fmt, fix);
 855
 856     if (ret == -ENOTSUP) {
 857         error_report("This image format does not support checks");
 858         ret = 63;
 859         goto fail;
 860     }
 861
 862     if (check->corruptions_fixed || check->leaks_fixed) {
 863         int corruptions_fixed, leaks_fixed;
 864         bool has_leaks_fixed, has_corruptions_fixed;
 865
 866         leaks_fixed         = check->leaks_fixed;
 867         has_leaks_fixed     = check->has_leaks_fixed;
 868         corruptions_fixed   = check->corruptions_fixed;
 869         has_corruptions_fixed = check->has_corruptions_fixed;
 870
 871         if (output_format == OFORMAT_HUMAN) {
 872             qprintf(quiet,
 873                     "The following inconsistencies were found and repaired:\n\n"
 874                     "    %" PRId64 " leaked clusters\n"
 875                     "    %" PRId64 " corruptions\n\n"
 876                     "Double checking the fixed image now...\n",
 877                     check->leaks_fixed,
 878                     check->corruptions_fixed);
 879         }
 880
 881         qapi_free_ImageCheck(check);
 882         check = g_new0(ImageCheck, 1);
 883         ret = collect_image_check(bs, check, filename, fmt, 0);
 884
 885         check->leaks_fixed          = leaks_fixed;
 886         check->has_leaks_fixed      = has_leaks_fixed;
 887         check->corruptions_fixed    = corruptions_fixed;
 888         check->has_corruptions_fixed = has_corruptions_fixed;
 889     }
 890
 891     if (!ret) {
 892         switch (output_format) {
 893         case OFORMAT_HUMAN:
 894             dump_human_image_check(check, quiet);
 895             break;
 896         case OFORMAT_JSON:
 897             dump_json_image_check(check, quiet);
 898             break;
 899         }
 900     }
 901
 902     if (ret || check->check_errors) {
 903         if (ret) {
 904             error_report("Check failed: %s", strerror(-ret));
 905         } else {
 906             error_report("Check failed");
 907         }
 908         ret = 1;
 909         goto fail;
 910     }
 911
 912     if (check->corruptions) {
 913         ret = 2;
 914     } else if (check->leaks) {
 915         ret = 3;
 916     } else {
 917         ret = 0;
 918     }
 919
 920 fail:
 921     qapi_free_ImageCheck(check);
 922     blk_unref(blk);
 923     return ret;
 924 }
 925
 926 typedef struct CommonBlockJobCBInfo {
 927     BlockDriverState *bs;
 928     Error **errp;
 929 } CommonBlockJobCBInfo;
 930
 931 static void common_block_job_cb(void *opaque, int ret)
 932 {
 933     CommonBlockJobCBInfo *cbi = opaque;
 934
 935     if (ret < 0) {
 936         error_setg_errno(cbi->errp, -ret, "Block job failed");
 937     }
 938 }
 939
 940 static void run_block_job(BlockJob *job, Error **errp)
 941 {
 942     AioContext *aio_context = blk_get_aio_context(job->blk);
 943     int ret = 0;
 944
 945     aio_context_acquire(aio_context);
 946     job_ref(&job->job);
 947     do {
 948         float progress = 0.0f;
 949         aio_poll(aio_context, true);
 950         if (job->job.progress.total) {
 951             progress = (float)job->job.progress.current /
 952                        job->job.progress.total * 100.f;
 953         }
 954         qemu_progress_print(progress, 0);
 955     } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
 956
 957     if (!job_is_completed(&job->job)) {
 958         ret = job_complete_sync(&job->job, errp);
 959     } else {
 960         ret = job->job.ret;
 961     }
 962     job_unref(&job->job);
 963     aio_context_release(aio_context);
 964
 965     /* publish completion progress only when success */
 966     if (!ret) {
 967         qemu_progress_print(100.f, 0);
 968     }
 969 }
 970
 971 static int img_commit(int argc, char **argv)
 972 {
 973     int c, ret, flags;
 974     const char *filename, *fmt, *cache, *base;
 975     BlockBackend *blk;
 976     BlockDriverState *bs, *base_bs;
 977     BlockJob *job;
 978     bool progress = false, quiet = false, drop = false;
 979     bool writethrough;
 980     Error *local_err = NULL;
 981     CommonBlockJobCBInfo cbi;
 982     bool image_opts = false;
 983     AioContext *aio_context;
 984
 985     fmt = NULL;
 986     cache = BDRV_DEFAULT_CACHE;
 987     base = NULL;
 988     for(;;) {
 989         static const struct option long_options[] = {
 990             {"help", no_argument, 0, 'h'},
 991             {"object", required_argument, 0, OPTION_OBJECT},
 992             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
 993             {0, 0, 0, 0}
 994         };
 995         c = getopt_long(argc, argv, ":f:ht:b:dpq",
 996                         long_options, NULL);
 997         if (c == -1) {
 998             break;
 999         }
1000         switch(c) {
1001         case ':':
1002             missing_argument(argv[optind - 1]);
1003             break;
1004         case '?':
1005             unrecognized_option(argv[optind - 1]);
1006             break;
1007         case 'h':
1008             help();
1009             break;
1010         case 'f':
1011             fmt = optarg;
1012             break;
1013         case 't':
1014             cache = optarg;
1015             break;
1016         case 'b':
1017             base = optarg;
1018             /* -b implies -d */
1019             drop = true;
1020             break;
1021         case 'd':
1022             drop = true;
1023             break;
1024         case 'p':
1025             progress = true;
1026             break;
1027         case 'q':
1028             quiet = true;
1029             break;
1030         case OPTION_OBJECT: {
1031             QemuOpts *opts;
1032             opts = qemu_opts_parse_noisily(&qemu_object_opts,
1033                                            optarg, true);
1034             if (!opts) {
1035                 return 1;
1036             }
1037         }   break;
1038         case OPTION_IMAGE_OPTS:
1039             image_opts = true;
1040             break;
1041         }
1042     }
1043
1044     /* Progress is not shown in Quiet mode */
1045     if (quiet) {
1046         progress = false;
1047     }
1048
1049     if (optind != argc - 1) {
1050         error_exit("Expecting one image file name");
1051     }
1052     filename = argv[optind++];
1053
1054     if (qemu_opts_foreach(&qemu_object_opts,
1055                           user_creatable_add_opts_foreach,
1056                           qemu_img_object_print_help, &error_fatal)) {
1057         return 1;
1058     }
1059
1060     flags = BDRV_O_RDWR | BDRV_O_UNMAP;
1061     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1062     if (ret < 0) {
1063         error_report("Invalid cache option: %s", cache);
1064         return 1;
1065     }
1066
1067     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
1068                    false);
1069     if (!blk) {
1070         return 1;
1071     }
1072     bs = blk_bs(blk);
1073
1074     qemu_progress_init(progress, 1.f);
1075     qemu_progress_print(0.f, 100);
1076
1077     if (base) {
1078         base_bs = bdrv_find_backing_image(bs, base);
1079         if (!base_bs) {
1080             error_setg(&local_err,
1081                        "Did not find '%s' in the backing chain of '%s'",
1082                        base, filename);
1083             goto done;
1084         }
1085     } else {
1086         /* This is different from QMP, which by default uses the deepest file in
1087          * the backing chain (i.e., the very base); however, the traditional
1088          * behavior of qemu-img commit is using the immediate backing file. */
1089         base_bs = backing_bs(bs);
1090         if (!base_bs) {
1091             error_setg(&local_err, "Image does not have a backing file");
1092             goto done;
1093         }
1094     }
1095
1096     cbi = (CommonBlockJobCBInfo){
1097         .errp = &local_err,
1098         .bs   = bs,
1099     };
1100
1101     aio_context = bdrv_get_aio_context(bs);
1102     aio_context_acquire(aio_context);
1103     commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,
1104                         BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1105                         &cbi, false, &local_err);
1106     aio_context_release(aio_context);
1107     if (local_err) {
1108         goto done;
1109     }
1110
1111     /* When the block job completes, the BlockBackend reference will point to
1112      * the old backing file. In order to avoid that the top image is already
1113      * deleted, so we can still empty it afterwards, increment the reference
1114      * counter here preemptively. */
1115     if (!drop) {
1116         bdrv_ref(bs);
1117     }
1118
1119     job = block_job_get("commit");
1120     assert(job);
1121     run_block_job(job, &local_err);
1122     if (local_err) {
1123         goto unref_backing;
1124     }
1125
1126     if (!drop) {
1127         BlockBackend *old_backing_blk;
1128
1129         old_backing_blk = blk_new_with_bs(bs, BLK_PERM_WRITE, BLK_PERM_ALL,
1130                                           &local_err);
1131         if (!old_backing_blk) {
1132             goto unref_backing;
1133         }
1134         ret = blk_make_empty(old_backing_blk, &local_err);
1135         blk_unref(old_backing_blk);
1136         if (ret == -ENOTSUP) {
1137             error_free(local_err);
1138             local_err = NULL;
1139         } else if (ret < 0) {
1140             goto unref_backing;
1141         }
1142     }
1143
1144 unref_backing:
1145     if (!drop) {
1146         bdrv_unref(bs);
1147     }
1148
1149 done:
1150     qemu_progress_end();
1151
1152     blk_unref(blk);
1153
1154     if (local_err) {
1155         error_report_err(local_err);
1156         return 1;
1157     }
1158
1159     qprintf(quiet, "Image committed.\n");
1160     return 0;
1161 }
1162
1163 /*
1164  * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1165  * of the first sector boundary within buf where the sector contains a
1166  * non-zero byte.  This function is robust to a buffer that is not
1167  * sector-aligned.
1168  */
1169 static int64_t find_nonzero(const uint8_t *buf, int64_t n)
1170 {
1171     int64_t i;
1172     int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE);
1173
1174     for (i = 0; i < end; i += BDRV_SECTOR_SIZE) {
1175         if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) {
1176             return i;
1177         }
1178     }
1179     if (i < n && !buffer_is_zero(buf + i, n - end)) {
1180         return i;
1181     }
1182     return -1;
1183 }
1184
1185 /*
1186  * Returns true iff the first sector pointed to by 'buf' contains at least
1187  * a non-NUL byte.
1188  *
1189  * 'pnum' is set to the number of sectors (including and immediately following
1190  * the first one) that are known to be in the same allocated/unallocated state.
1191  * The function will try to align the end offset to alignment boundaries so
1192  * that the request will at least end aligned and consequtive requests will
1193  * also start at an aligned offset.
1194  */
1195 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
1196                                 int64_t sector_num, int alignment)
1197 {
1198     bool is_zero;
1199     int i, tail;
1200
1201     if (n <= 0) {
1202         *pnum = 0;
1203         return 0;
1204     }
1205     is_zero = buffer_is_zero(buf, 512);
1206     for(i = 1; i < n; i++) {
1207         buf += 512;
1208         if (is_zero != buffer_is_zero(buf, 512)) {
1209             break;
1210         }
1211     }
1212
1213     tail = (sector_num + i) & (alignment - 1);
1214     if (tail) {
1215         if (is_zero && i <= tail) {
1216             /* treat unallocated areas which only consist
1217              * of a small tail as allocated. */
1218             is_zero = false;
1219         }
1220         if (!is_zero) {
1221             /* align up end offset of allocated areas. */
1222             i += alignment - tail;
1223             i = MIN(i, n);
1224         } else {
1225             /* align down end offset of zero areas. */
1226             i -= tail;
1227         }
1228     }
1229     *pnum = i;
1230     return !is_zero;
1231 }
1232
1233 /*
1234  * Like is_allocated_sectors, but if the buffer starts with a used sector,
1235  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1236  * breaking up write requests for only small sparse areas.
1237  */
1238 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1239     int min, int64_t sector_num, int alignment)
1240 {
1241     int ret;
1242     int num_checked, num_used;
1243
1244     if (n < min) {
1245         min = n;
1246     }
1247
1248     ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1249     if (!ret) {
1250         return ret;
1251     }
1252
1253     num_used = *pnum;
1254     buf += BDRV_SECTOR_SIZE * *pnum;
1255     n -= *pnum;
1256     sector_num += *pnum;
1257     num_checked = num_used;
1258
1259     while (n > 0) {
1260         ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1261
1262         buf += BDRV_SECTOR_SIZE * *pnum;
1263         n -= *pnum;
1264         sector_num += *pnum;
1265         num_checked += *pnum;
1266         if (ret) {
1267             num_used = num_checked;
1268         } else if (*pnum >= min) {
1269             break;
1270         }
1271     }
1272
1273     *pnum = num_used;
1274     return 1;
1275 }
1276
1277 /*
1278  * Compares two buffers sector by sector. Returns 0 if the first
1279  * sector of each buffer matches, non-zero otherwise.
1280  *
1281  * pnum is set to the sector-aligned size of the buffer prefix that
1282  * has the same matching status as the first sector.
1283  */
1284 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,
1285                            int64_t bytes, int64_t *pnum)
1286 {
1287     bool res;
1288     int64_t i = MIN(bytes, BDRV_SECTOR_SIZE);
1289
1290     assert(bytes > 0);
1291
1292     res = !!memcmp(buf1, buf2, i);
1293     while (i < bytes) {
1294         int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE);
1295
1296         if (!!memcmp(buf1 + i, buf2 + i, len) != res) {
1297             break;
1298         }
1299         i += len;
1300     }
1301
1302     *pnum = i;
1303     return res;
1304 }
1305
1306 #define IO_BUF_SIZE (2 * MiB)
1307
1308 /*
1309  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1310  *
1311  * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1312  * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1313  * failure), and 4 on error (the exit status for read errors), after emitting
1314  * an error message.
1315  *
1316  * @param blk:  BlockBackend for the image
1317  * @param offset: Starting offset to check
1318  * @param bytes: Number of bytes to check
1319  * @param filename: Name of disk file we are checking (logging purpose)
1320  * @param buffer: Allocated buffer for storing read data
1321  * @param quiet: Flag for quiet mode
1322  */
1323 static int check_empty_sectors(BlockBackend *blk, int64_t offset,
1324                                int64_t bytes, const char *filename,
1325                                uint8_t *buffer, bool quiet)
1326 {
1327     int ret = 0;
1328     int64_t idx;
1329
1330     ret = blk_pread(blk, offset, buffer, bytes);
1331     if (ret < 0) {
1332         error_report("Error while reading offset %" PRId64 " of %s: %s",
1333                      offset, filename, strerror(-ret));
1334         return 4;
1335     }
1336     idx = find_nonzero(buffer, bytes);
1337     if (idx >= 0) {
1338         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1339                 offset + idx);
1340         return 1;
1341     }
1342
1343     return 0;
1344 }
1345
1346 /*
1347  * Compares two images. Exit codes:
1348  *
1349  * 0 - Images are identical
1350  * 1 - Images differ
1351  * >1 - Error occurred
1352  */
1353 static int img_compare(int argc, char **argv)
1354 {
1355     const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1356     BlockBackend *blk1, *blk2;
1357     BlockDriverState *bs1, *bs2;
1358     int64_t total_size1, total_size2;
1359     uint8_t *buf1 = NULL, *buf2 = NULL;
1360     int64_t pnum1, pnum2;
1361     int allocated1, allocated2;
1362     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1363     bool progress = false, quiet = false, strict = false;
1364     int flags;
1365     bool writethrough;
1366     int64_t total_size;
1367     int64_t offset = 0;
1368     int64_t chunk;
1369     int c;
1370     uint64_t progress_base;
1371     bool image_opts = false;
1372     bool force_share = false;
1373
1374     cache = BDRV_DEFAULT_CACHE;
1375     for (;;) {
1376         static const struct option long_options[] = {
1377             {"help", no_argument, 0, 'h'},
1378             {"object", required_argument, 0, OPTION_OBJECT},
1379             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1380             {"force-share", no_argument, 0, 'U'},
1381             {0, 0, 0, 0}
1382         };
1383         c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1384                         long_options, NULL);
1385         if (c == -1) {
1386             break;
1387         }
1388         switch (c) {
1389         case ':':
1390             missing_argument(argv[optind - 1]);
1391             break;
1392         case '?':
1393             unrecognized_option(argv[optind - 1]);
1394             break;
1395         case 'h':
1396             help();
1397             break;
1398         case 'f':
1399             fmt1 = optarg;
1400             break;
1401         case 'F':
1402             fmt2 = optarg;
1403             break;
1404         case 'T':
1405             cache = optarg;
1406             break;
1407         case 'p':
1408             progress = true;
1409             break;
1410         case 'q':
1411             quiet = true;
1412             break;
1413         case 's':
1414             strict = true;
1415             break;
1416         case 'U':
1417             force_share = true;
1418             break;
1419         case OPTION_OBJECT: {
1420             QemuOpts *opts;
1421             opts = qemu_opts_parse_noisily(&qemu_object_opts,
1422                                            optarg, true);
1423             if (!opts) {
1424                 ret = 2;
1425                 goto out4;
1426             }
1427         }   break;
1428         case OPTION_IMAGE_OPTS:
1429             image_opts = true;
1430             break;
1431         }
1432     }
1433
1434     /* Progress is not shown in Quiet mode */
1435     if (quiet) {
1436         progress = false;
1437     }
1438
1439
1440     if (optind != argc - 2) {
1441         error_exit("Expecting two image file names");
1442     }
1443     filename1 = argv[optind++];
1444     filename2 = argv[optind++];
1445
1446     if (qemu_opts_foreach(&qemu_object_opts,
1447                           user_creatable_add_opts_foreach,
1448                           qemu_img_object_print_help, &error_fatal)) {
1449         ret = 2;
1450         goto out4;
1451     }
1452
1453     /* Initialize before goto out */
1454     qemu_progress_init(progress, 2.0);
1455
1456     flags = 0;
1457     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1458     if (ret < 0) {
1459         error_report("Invalid source cache option: %s", cache);
1460         ret = 2;
1461         goto out3;
1462     }
1463
1464     blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1465                     force_share);
1466     if (!blk1) {
1467         ret = 2;
1468         goto out3;
1469     }
1470
1471     blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1472                     force_share);
1473     if (!blk2) {
1474         ret = 2;
1475         goto out2;
1476     }
1477     bs1 = blk_bs(blk1);
1478     bs2 = blk_bs(blk2);
1479
1480     buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1481     buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1482     total_size1 = blk_getlength(blk1);
1483     if (total_size1 < 0) {
1484         error_report("Can't get size of %s: %s",
1485                      filename1, strerror(-total_size1));
1486         ret = 4;
1487         goto out;
1488     }
1489     total_size2 = blk_getlength(blk2);
1490     if (total_size2 < 0) {
1491         error_report("Can't get size of %s: %s",
1492                      filename2, strerror(-total_size2));
1493         ret = 4;
1494         goto out;
1495     }
1496     total_size = MIN(total_size1, total_size2);
1497     progress_base = MAX(total_size1, total_size2);
1498
1499     qemu_progress_print(0, 100);
1500
1501     if (strict && total_size1 != total_size2) {
1502         ret = 1;
1503         qprintf(quiet, "Strict mode: Image size mismatch!\n");
1504         goto out;
1505     }
1506
1507     while (offset < total_size) {
1508         int status1, status2;
1509
1510         status1 = bdrv_block_status_above(bs1, NULL, offset,
1511                                           total_size1 - offset, &pnum1, NULL,
1512                                           NULL);
1513         if (status1 < 0) {
1514             ret = 3;
1515             error_report("Sector allocation test failed for %s", filename1);
1516             goto out;
1517         }
1518         allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1519
1520         status2 = bdrv_block_status_above(bs2, NULL, offset,
1521                                           total_size2 - offset, &pnum2, NULL,
1522                                           NULL);
1523         if (status2 < 0) {
1524             ret = 3;
1525             error_report("Sector allocation test failed for %s", filename2);
1526             goto out;
1527         }
1528         allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1529
1530         assert(pnum1 && pnum2);
1531         chunk = MIN(pnum1, pnum2);
1532
1533         if (strict) {
1534             if (status1 != status2) {
1535                 ret = 1;
1536                 qprintf(quiet, "Strict mode: Offset %" PRId64
1537                         " block status mismatch!\n", offset);
1538                 goto out;
1539             }
1540         }
1541         if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1542             /* nothing to do */
1543         } else if (allocated1 == allocated2) {
1544             if (allocated1) {
1545                 int64_t pnum;
1546
1547                 chunk = MIN(chunk, IO_BUF_SIZE);
1548                 ret = blk_pread(blk1, offset, buf1, chunk);
1549                 if (ret < 0) {
1550                     error_report("Error while reading offset %" PRId64
1551                                  " of %s: %s",
1552                                  offset, filename1, strerror(-ret));
1553                     ret = 4;
1554                     goto out;
1555                 }
1556                 ret = blk_pread(blk2, offset, buf2, chunk);
1557                 if (ret < 0) {
1558                     error_report("Error while reading offset %" PRId64
1559                                  " of %s: %s",
1560                                  offset, filename2, strerror(-ret));
1561                     ret = 4;
1562                     goto out;
1563                 }
1564                 ret = compare_buffers(buf1, buf2, chunk, &pnum);
1565                 if (ret || pnum != chunk) {
1566                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1567                             offset + (ret ? 0 : pnum));
1568                     ret = 1;
1569                     goto out;
1570                 }
1571             }
1572         } else {
1573             chunk = MIN(chunk, IO_BUF_SIZE);
1574             if (allocated1) {
1575                 ret = check_empty_sectors(blk1, offset, chunk,
1576                                           filename1, buf1, quiet);
1577             } else {
1578                 ret = check_empty_sectors(blk2, offset, chunk,
1579                                           filename2, buf1, quiet);
1580             }
1581             if (ret) {
1582                 goto out;
1583             }
1584         }
1585         offset += chunk;
1586         qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1587     }
1588
1589     if (total_size1 != total_size2) {
1590         BlockBackend *blk_over;
1591         const char *filename_over;
1592
1593         qprintf(quiet, "Warning: Image size mismatch!\n");
1594         if (total_size1 > total_size2) {
1595             blk_over = blk1;
1596             filename_over = filename1;
1597         } else {
1598             blk_over = blk2;
1599             filename_over = filename2;
1600         }
1601
1602         while (offset < progress_base) {
1603             ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,
1604                                           progress_base - offset, &chunk,
1605                                           NULL, NULL);
1606             if (ret < 0) {
1607                 ret = 3;
1608                 error_report("Sector allocation test failed for %s",
1609                              filename_over);
1610                 goto out;
1611
1612             }
1613             if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {
1614                 chunk = MIN(chunk, IO_BUF_SIZE);
1615                 ret = check_empty_sectors(blk_over, offset, chunk,
1616                                           filename_over, buf1, quiet);
1617                 if (ret) {
1618                     goto out;
1619                 }
1620             }
1621             offset += chunk;
1622             qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1623         }
1624     }
1625
1626     qprintf(quiet, "Images are identical.\n");
1627     ret = 0;
1628
1629 out:
1630     qemu_vfree(buf1);
1631     qemu_vfree(buf2);
1632     blk_unref(blk2);
1633 out2:
1634     blk_unref(blk1);
1635 out3:
1636     qemu_progress_end();
1637 out4:
1638     return ret;
1639 }
1640
1641 enum ImgConvertBlockStatus {
1642     BLK_DATA,
1643     BLK_ZERO,
1644     BLK_BACKING_FILE,
1645 };
1646
1647 #define MAX_COROUTINES 16
1648
1649 typedef struct ImgConvertState {
1650     BlockBackend **src;
1651     int64_t *src_sectors;
1652     int src_num;
1653     int64_t total_sectors;
1654     int64_t allocated_sectors;
1655     int64_t allocated_done;
1656     int64_t sector_num;
1657     int64_t wr_offs;
1658     enum ImgConvertBlockStatus status;
1659     int64_t sector_next_status;
1660     BlockBackend *target;
1661     bool has_zero_init;
1662     bool compressed;
1663     bool unallocated_blocks_are_zero;
1664     bool target_is_new;
1665     bool target_has_backing;
1666     int64_t target_backing_sectors; /* negative if unknown */
1667     bool wr_in_order;
1668     bool copy_range;
1669     bool salvage;
1670     bool quiet;
1671     int min_sparse;
1672     int alignment;
1673     size_t cluster_sectors;
1674     size_t buf_sectors;
1675     long num_coroutines;
1676     int running_coroutines;
1677     Coroutine *co[MAX_COROUTINES];
1678     int64_t wait_sector_num[MAX_COROUTINES];
1679     CoMutex lock;
1680     int ret;
1681 } ImgConvertState;
1682
1683 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1684                                 int *src_cur, int64_t *src_cur_offset)
1685 {
1686     *src_cur = 0;
1687     *src_cur_offset = 0;
1688     while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1689         *src_cur_offset += s->src_sectors[*src_cur];
1690         (*src_cur)++;
1691         assert(*src_cur < s->src_num);
1692     }
1693 }
1694
1695 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1696 {
1697     int64_t src_cur_offset;
1698     int ret, n, src_cur;
1699     bool post_backing_zero = false;
1700
1701     convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1702
1703     assert(s->total_sectors > sector_num);
1704     n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1705
1706     if (s->target_backing_sectors >= 0) {
1707         if (sector_num >= s->target_backing_sectors) {
1708             post_backing_zero = s->unallocated_blocks_are_zero;
1709         } else if (sector_num + n > s->target_backing_sectors) {
1710             /* Split requests around target_backing_sectors (because
1711              * starting from there, zeros are handled differently) */
1712             n = s->target_backing_sectors - sector_num;
1713         }
1714     }
1715
1716     if (s->sector_next_status <= sector_num) {
1717         uint64_t offset = (sector_num - src_cur_offset) * BDRV_SECTOR_SIZE;
1718         int64_t count;
1719
1720         do {
1721             count = n * BDRV_SECTOR_SIZE;
1722
1723             if (s->target_has_backing) {
1724                 ret = bdrv_block_status(blk_bs(s->src[src_cur]), offset,
1725                                         count, &count, NULL, NULL);
1726             } else {
1727                 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,
1728                                               offset, count, &count, NULL,
1729                                               NULL);
1730             }
1731
1732             if (ret < 0) {
1733                 if (s->salvage) {
1734                     if (n == 1) {
1735                         if (!s->quiet) {
1736                             warn_report("error while reading block status at "
1737                                         "offset %" PRIu64 ": %s", offset,
1738                                         strerror(-ret));
1739                         }
1740                         /* Just try to read the data, then */
1741                         ret = BDRV_BLOCK_DATA;
1742                         count = BDRV_SECTOR_SIZE;
1743                     } else {
1744                         /* Retry on a shorter range */
1745                         n = DIV_ROUND_UP(n, 4);
1746                     }
1747                 } else {
1748                     error_report("error while reading block status at offset "
1749                                  "%" PRIu64 ": %s", offset, strerror(-ret));
1750                     return ret;
1751                 }
1752             }
1753         } while (ret < 0);
1754
1755         n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
1756
1757         if (ret & BDRV_BLOCK_ZERO) {
1758             s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;
1759         } else if (ret & BDRV_BLOCK_DATA) {
1760             s->status = BLK_DATA;
1761         } else {
1762             s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1763         }
1764
1765         s->sector_next_status = sector_num + n;
1766     }
1767
1768     n = MIN(n, s->sector_next_status - sector_num);
1769     if (s->status == BLK_DATA) {
1770         n = MIN(n, s->buf_sectors);
1771     }
1772
1773     /* We need to write complete clusters for compressed images, so if an
1774      * unallocated area is shorter than that, we must consider the whole
1775      * cluster allocated. */
1776     if (s->compressed) {
1777         if (n < s->cluster_sectors) {
1778             n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1779             s->status = BLK_DATA;
1780         } else {
1781             n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1782         }
1783     }
1784
1785     return n;
1786 }
1787
1788 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1789                                         int nb_sectors, uint8_t *buf)
1790 {
1791     uint64_t single_read_until = 0;
1792     int n, ret;
1793
1794     assert(nb_sectors <= s->buf_sectors);
1795     while (nb_sectors > 0) {
1796         BlockBackend *blk;
1797         int src_cur;
1798         int64_t bs_sectors, src_cur_offset;
1799         uint64_t offset;
1800
1801         /* In the case of compression with multiple source files, we can get a
1802          * nb_sectors that spreads into the next part. So we must be able to
1803          * read across multiple BDSes for one convert_read() call. */
1804         convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1805         blk = s->src[src_cur];
1806         bs_sectors = s->src_sectors[src_cur];
1807
1808         offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1809
1810         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1811         if (single_read_until > offset) {
1812             n = 1;
1813         }
1814
1815         ret = blk_co_pread(blk, offset, n << BDRV_SECTOR_BITS, buf, 0);
1816         if (ret < 0) {
1817             if (s->salvage) {
1818                 if (n > 1) {
1819                     single_read_until = offset + (n << BDRV_SECTOR_BITS);
1820                     continue;
1821                 } else {
1822                     if (!s->quiet) {
1823                         warn_report("error while reading offset %" PRIu64
1824                                     ": %s", offset, strerror(-ret));
1825                     }
1826                     memset(buf, 0, BDRV_SECTOR_SIZE);
1827                 }
1828             } else {
1829                 return ret;
1830             }
1831         }
1832
1833         sector_num += n;
1834         nb_sectors -= n;
1835         buf += n * BDRV_SECTOR_SIZE;
1836     }
1837
1838     return 0;
1839 }
1840
1841
1842 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1843                                          int nb_sectors, uint8_t *buf,
1844                                          enum ImgConvertBlockStatus status)
1845 {
1846     int ret;
1847
1848     while (nb_sectors > 0) {
1849         int n = nb_sectors;
1850         BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1851
1852         switch (status) {
1853         case BLK_BACKING_FILE:
1854             /* If we have a backing file, leave clusters unallocated that are
1855              * unallocated in the source image, so that the backing file is
1856              * visible at the respective offset. */
1857             assert(s->target_has_backing);
1858             break;
1859
1860         case BLK_DATA:
1861             /* If we're told to keep the target fully allocated (-S 0) or there
1862              * is real non-zero data, we must write it. Otherwise we can treat
1863              * it as zero sectors.
1864              * Compressed clusters need to be written as a whole, so in that
1865              * case we can only save the write if the buffer is completely
1866              * zeroed. */
1867             if (!s->min_sparse ||
1868                 (!s->compressed &&
1869                  is_allocated_sectors_min(buf, n, &n, s->min_sparse,
1870                                           sector_num, s->alignment)) ||
1871                 (s->compressed &&
1872                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1873             {
1874                 ret = blk_co_pwrite(s->target, sector_num << BDRV_SECTOR_BITS,
1875                                     n << BDRV_SECTOR_BITS, buf, flags);
1876                 if (ret < 0) {
1877                     return ret;
1878                 }
1879                 break;
1880             }
1881             /* fall-through */
1882
1883         case BLK_ZERO:
1884             if (s->has_zero_init) {
1885                 assert(!s->target_has_backing);
1886                 break;
1887             }
1888             ret = blk_co_pwrite_zeroes(s->target,
1889                                        sector_num << BDRV_SECTOR_BITS,
1890                                        n << BDRV_SECTOR_BITS,
1891                                        BDRV_REQ_MAY_UNMAP);
1892             if (ret < 0) {
1893                 return ret;
1894             }
1895             break;
1896         }
1897
1898         sector_num += n;
1899         nb_sectors -= n;
1900         buf += n * BDRV_SECTOR_SIZE;
1901     }
1902
1903     return 0;
1904 }
1905
1906 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
1907                                               int nb_sectors)
1908 {
1909     int n, ret;
1910
1911     while (nb_sectors > 0) {
1912         BlockBackend *blk;
1913         int src_cur;
1914         int64_t bs_sectors, src_cur_offset;
1915         int64_t offset;
1916
1917         convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1918         offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1919         blk = s->src[src_cur];
1920         bs_sectors = s->src_sectors[src_cur];
1921
1922         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1923
1924         ret = blk_co_copy_range(blk, offset, s->target,
1925                                 sector_num << BDRV_SECTOR_BITS,
1926                                 n << BDRV_SECTOR_BITS, 0, 0);
1927         if (ret < 0) {
1928             return ret;
1929         }
1930
1931         sector_num += n;
1932         nb_sectors -= n;
1933     }
1934     return 0;
1935 }
1936
1937 static void coroutine_fn convert_co_do_copy(void *opaque)
1938 {
1939     ImgConvertState *s = opaque;
1940     uint8_t *buf = NULL;
1941     int ret, i;
1942     int index = -1;
1943
1944     for (i = 0; i < s->num_coroutines; i++) {
1945         if (s->co[i] == qemu_coroutine_self()) {
1946             index = i;
1947             break;
1948         }
1949     }
1950     assert(index >= 0);
1951
1952     s->running_coroutines++;
1953     buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1954
1955     while (1) {
1956         int n;
1957         int64_t sector_num;
1958         enum ImgConvertBlockStatus status;
1959         bool copy_range;
1960
1961         qemu_co_mutex_lock(&s->lock);
1962         if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1963             qemu_co_mutex_unlock(&s->lock);
1964             break;
1965         }
1966         n = convert_iteration_sectors(s, s->sector_num);
1967         if (n < 0) {
1968             qemu_co_mutex_unlock(&s->lock);
1969             s->ret = n;
1970             break;
1971         }
1972         /* save current sector and allocation status to local variables */
1973         sector_num = s->sector_num;
1974         status = s->status;
1975         if (!s->min_sparse && s->status == BLK_ZERO) {
1976             n = MIN(n, s->buf_sectors);
1977         }
1978         /* increment global sector counter so that other coroutines can
1979          * already continue reading beyond this request */
1980         s->sector_num += n;
1981         qemu_co_mutex_unlock(&s->lock);
1982
1983         if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
1984             s->allocated_done += n;
1985             qemu_progress_print(100.0 * s->allocated_done /
1986                                         s->allocated_sectors, 0);
1987         }
1988
1989 retry:
1990         copy_range = s->copy_range && s->status == BLK_DATA;
1991         if (status == BLK_DATA && !copy_range) {
1992             ret = convert_co_read(s, sector_num, n, buf);
1993             if (ret < 0) {
1994                 error_report("error while reading at byte %lld: %s",
1995                              sector_num * BDRV_SECTOR_SIZE, strerror(-ret));
1996                 s->ret = ret;
1997             }
1998         } else if (!s->min_sparse && status == BLK_ZERO) {
1999             status = BLK_DATA;
2000             memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
2001         }
2002
2003         if (s->wr_in_order) {
2004             /* keep writes in order */
2005             while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
2006                 s->wait_sector_num[index] = sector_num;
2007                 qemu_coroutine_yield();
2008             }
2009             s->wait_sector_num[index] = -1;
2010         }
2011
2012         if (s->ret == -EINPROGRESS) {
2013             if (copy_range) {
2014                 ret = convert_co_copy_range(s, sector_num, n);
2015                 if (ret) {
2016                     s->copy_range = false;
2017                     goto retry;
2018                 }
2019             } else {
2020                 ret = convert_co_write(s, sector_num, n, buf, status);
2021             }
2022             if (ret < 0) {
2023                 error_report("error while writing at byte %lld: %s",
2024                              sector_num * BDRV_SECTOR_SIZE, strerror(-ret));
2025                 s->ret = ret;
2026             }
2027         }
2028
2029         if (s->wr_in_order) {
2030             /* reenter the coroutine that might have waited
2031              * for this write to complete */
2032             s->wr_offs = sector_num + n;
2033             for (i = 0; i < s->num_coroutines; i++) {
2034                 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
2035                     /*
2036                      * A -> B -> A cannot occur because A has
2037                      * s->wait_sector_num[i] == -1 during A -> B.  Therefore
2038                      * B will never enter A during this time window.
2039                      */
2040                     qemu_coroutine_enter(s->co[i]);
2041                     break;
2042                 }
2043             }
2044         }
2045     }
2046
2047     qemu_vfree(buf);
2048     s->co[index] = NULL;
2049     s->running_coroutines--;
2050     if (!s->running_coroutines && s->ret == -EINPROGRESS) {
2051         /* the convert job finished successfully */
2052         s->ret = 0;
2053     }
2054 }
2055
2056 static int convert_do_copy(ImgConvertState *s)
2057 {
2058     int ret, i, n;
2059     int64_t sector_num = 0;
2060
2061     /* Check whether we have zero initialisation or can get it efficiently */
2062     if (!s->has_zero_init && s->target_is_new && s->min_sparse &&
2063         !s->target_has_backing) {
2064         s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
2065     }
2066
2067     if (!s->has_zero_init && !s->target_has_backing &&
2068         bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
2069     {
2070         ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK);
2071         if (ret == 0) {
2072             s->has_zero_init = true;
2073         }
2074     }
2075
2076     /* Allocate buffer for copied data. For compressed images, only one cluster
2077      * can be copied at a time. */
2078     if (s->compressed) {
2079         if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
2080             error_report("invalid cluster size");
2081             return -EINVAL;
2082         }
2083         s->buf_sectors = s->cluster_sectors;
2084     }
2085
2086     while (sector_num < s->total_sectors) {
2087         n = convert_iteration_sectors(s, sector_num);
2088         if (n < 0) {
2089             return n;
2090         }
2091         if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
2092         {
2093             s->allocated_sectors += n;
2094         }
2095         sector_num += n;
2096     }
2097
2098     /* Do the copy */
2099     s->sector_next_status = 0;
2100     s->ret = -EINPROGRESS;
2101
2102     qemu_co_mutex_init(&s->lock);
2103     for (i = 0; i < s->num_coroutines; i++) {
2104         s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
2105         s->wait_sector_num[i] = -1;
2106         qemu_coroutine_enter(s->co[i]);
2107     }
2108
2109     while (s->running_coroutines) {
2110         main_loop_wait(false);
2111     }
2112
2113     if (s->compressed && !s->ret) {
2114         /* signal EOF to align */
2115         ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
2116         if (ret < 0) {
2117             return ret;
2118         }
2119     }
2120
2121     return s->ret;
2122 }
2123
2124 #define MAX_BUF_SECTORS 32768
2125
2126 static int img_convert(int argc, char **argv)
2127 {
2128     int c, bs_i, flags, src_flags = 0;
2129     const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
2130                *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
2131                *out_filename, *out_baseimg_param, *snapshot_name = NULL;
2132     BlockDriver *drv = NULL, *proto_drv = NULL;
2133     BlockDriverInfo bdi;
2134     BlockDriverState *out_bs;
2135     QemuOpts *opts = NULL, *sn_opts = NULL;
2136     QemuOptsList *create_opts = NULL;
2137     QDict *open_opts = NULL;
2138     char *options = NULL;
2139     Error *local_err = NULL;
2140     bool writethrough, src_writethrough, image_opts = false,
2141          skip_create = false, progress = false, tgt_image_opts = false;
2142     int64_t ret = -EINVAL;
2143     bool force_share = false;
2144     bool explict_min_sparse = false;
2145
2146     ImgConvertState s = (ImgConvertState) {
2147         /* Need at least 4k of zeros for sparse detection */
2148         .min_sparse         = 8,
2149         .copy_range         = false,
2150         .buf_sectors        = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
2151         .wr_in_order        = true,
2152         .num_coroutines     = 8,
2153     };
2154
2155     for(;;) {
2156         static const struct option long_options[] = {
2157             {"help", no_argument, 0, 'h'},
2158             {"object", required_argument, 0, OPTION_OBJECT},
2159             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2160             {"force-share", no_argument, 0, 'U'},
2161             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
2162             {"salvage", no_argument, 0, OPTION_SALVAGE},
2163             {"target-is-zero", no_argument, 0, OPTION_TARGET_IS_ZERO},
2164             {0, 0, 0, 0}
2165         };
2166         c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
2167                         long_options, NULL);
2168         if (c == -1) {
2169             break;
2170         }
2171         switch(c) {
2172         case ':':
2173             missing_argument(argv[optind - 1]);
2174             break;
2175         case '?':
2176             unrecognized_option(argv[optind - 1]);
2177             break;
2178         case 'h':
2179             help();
2180             break;
2181         case 'f':
2182             fmt = optarg;
2183             break;
2184         case 'O':
2185             out_fmt = optarg;
2186             break;
2187         case 'B':
2188             out_baseimg = optarg;
2189             break;
2190         case 'C':
2191             s.copy_range = true;
2192             break;
2193         case 'c':
2194             s.compressed = true;
2195             break;
2196         case 'o':
2197             if (accumulate_options(&options, optarg) < 0) {
2198                 goto fail_getopt;
2199             }
2200             break;
2201         case 'l':
2202             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2203                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2204                                                   optarg, false);
2205                 if (!sn_opts) {
2206                     error_report("Failed in parsing snapshot param '%s'",
2207                                  optarg);
2208                     goto fail_getopt;
2209                 }
2210             } else {
2211                 snapshot_name = optarg;
2212             }
2213             break;
2214         case 'S':
2215         {
2216             int64_t sval;
2217
2218             sval = cvtnum("buffer size for sparse output", optarg);
2219             if (sval < 0) {
2220                 goto fail_getopt;
2221             } else if (!QEMU_IS_ALIGNED(sval, BDRV_SECTOR_SIZE) ||
2222                 sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) {
2223                 error_report("Invalid buffer size for sparse output specified. "
2224                     "Valid sizes are multiples of %llu up to %llu. Select "
2225                     "0 to disable sparse detection (fully allocates output).",
2226                     BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE);
2227                 goto fail_getopt;
2228             }
2229
2230             s.min_sparse = sval / BDRV_SECTOR_SIZE;
2231             explict_min_sparse = true;
2232             break;
2233         }
2234         case 'p':
2235             progress = true;
2236             break;
2237         case 't':
2238             cache = optarg;
2239             break;
2240         case 'T':
2241             src_cache = optarg;
2242             break;
2243         case 'q':
2244             s.quiet = true;
2245             break;
2246         case 'n':
2247             skip_create = true;
2248             break;
2249         case 'm':
2250             if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2251                 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2252                 error_report("Invalid number of coroutines. Allowed number of"
2253                              " coroutines is between 1 and %d", MAX_COROUTINES);
2254                 goto fail_getopt;
2255             }
2256             break;
2257         case 'W':
2258             s.wr_in_order = false;
2259             break;
2260         case 'U':
2261             force_share = true;
2262             break;
2263         case OPTION_OBJECT: {
2264             QemuOpts *object_opts;
2265             object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2266                                                   optarg, true);
2267             if (!object_opts) {
2268                 goto fail_getopt;
2269             }
2270             break;
2271         }
2272         case OPTION_IMAGE_OPTS:
2273             image_opts = true;
2274             break;
2275         case OPTION_SALVAGE:
2276             s.salvage = true;
2277             break;
2278         case OPTION_TARGET_IMAGE_OPTS:
2279             tgt_image_opts = true;
2280             break;
2281         case OPTION_TARGET_IS_ZERO:
2282             /*
2283              * The user asserting that the target is blank has the
2284              * same effect as the target driver supporting zero
2285              * initialisation.
2286              */
2287             s.has_zero_init = true;
2288             break;
2289         }
2290     }
2291
2292     if (!out_fmt && !tgt_image_opts) {
2293         out_fmt = "raw";
2294     }
2295
2296     if (qemu_opts_foreach(&qemu_object_opts,
2297                           user_creatable_add_opts_foreach,
2298                           qemu_img_object_print_help, &error_fatal)) {
2299         goto fail_getopt;
2300     }
2301
2302     if (s.compressed && s.copy_range) {
2303         error_report("Cannot enable copy offloading when -c is used");
2304         goto fail_getopt;
2305     }
2306
2307     if (explict_min_sparse && s.copy_range) {
2308         error_report("Cannot enable copy offloading when -S is used");
2309         goto fail_getopt;
2310     }
2311
2312     if (s.copy_range && s.salvage) {
2313         error_report("Cannot use copy offloading in salvaging mode");
2314         goto fail_getopt;
2315     }
2316
2317     if (tgt_image_opts && !skip_create) {
2318         error_report("--target-image-opts requires use of -n flag");
2319         goto fail_getopt;
2320     }
2321
2322     if (skip_create && options) {
2323         warn_report("-o has no effect when skipping image creation");
2324         warn_report("This will become an error in future QEMU versions.");
2325     }
2326
2327     if (s.has_zero_init && !skip_create) {
2328         error_report("--target-is-zero requires use of -n flag");
2329         goto fail_getopt;
2330     }
2331
2332     s.src_num = argc - optind - 1;
2333     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2334
2335     if (options && has_help_option(options)) {
2336         if (out_fmt) {
2337             ret = print_block_option_help(out_filename, out_fmt);
2338             goto fail_getopt;
2339         } else {
2340             error_report("Option help requires a format be specified");
2341             goto fail_getopt;
2342         }
2343     }
2344
2345     if (s.src_num < 1) {
2346         error_report("Must specify image file name");
2347         goto fail_getopt;
2348     }
2349
2350
2351     /* ret is still -EINVAL until here */
2352     ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2353     if (ret < 0) {
2354         error_report("Invalid source cache option: %s", src_cache);
2355         goto fail_getopt;
2356     }
2357
2358     /* Initialize before goto out */
2359     if (s.quiet) {
2360         progress = false;
2361     }
2362     qemu_progress_init(progress, 1.0);
2363     qemu_progress_print(0, 100);
2364
2365     s.src = g_new0(BlockBackend *, s.src_num);
2366     s.src_sectors = g_new(int64_t, s.src_num);
2367
2368     for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2369         s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2370                                fmt, src_flags, src_writethrough, s.quiet,
2371                                force_share);
2372         if (!s.src[bs_i]) {
2373             ret = -1;
2374             goto out;
2375         }
2376         s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2377         if (s.src_sectors[bs_i] < 0) {
2378             error_report("Could not get size of %s: %s",
2379                          argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2380             ret = -1;
2381             goto out;
2382         }
2383         s.total_sectors += s.src_sectors[bs_i];
2384     }
2385
2386     if (sn_opts) {
2387         bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2388                                qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2389                                qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2390                                &local_err);
2391     } else if (snapshot_name != NULL) {
2392         if (s.src_num > 1) {
2393             error_report("No support for concatenating multiple snapshot");
2394             ret = -1;
2395             goto out;
2396         }
2397
2398         bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2399                                              &local_err);
2400     }
2401     if (local_err) {
2402         error_reportf_err(local_err, "Failed to load snapshot: ");
2403         ret = -1;
2404         goto out;
2405     }
2406
2407     if (!skip_create) {
2408         /* Find driver and parse its options */
2409         drv = bdrv_find_format(out_fmt);
2410         if (!drv) {
2411             error_report("Unknown file format '%s'", out_fmt);
2412             ret = -1;
2413             goto out;
2414         }
2415
2416         proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2417         if (!proto_drv) {
2418             error_report_err(local_err);
2419             ret = -1;
2420             goto out;
2421         }
2422
2423         if (!drv->create_opts) {
2424             error_report("Format driver '%s' does not support image creation",
2425                          drv->format_name);
2426             ret = -1;
2427             goto out;
2428         }
2429
2430         if (!proto_drv->create_opts) {
2431             error_report("Protocol driver '%s' does not support image creation",
2432                          proto_drv->format_name);
2433             ret = -1;
2434             goto out;
2435         }
2436
2437         create_opts = qemu_opts_append(create_opts, drv->create_opts);
2438         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2439
2440         opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2441         if (options) {
2442             qemu_opts_do_parse(opts, options, NULL, &local_err);
2443             if (local_err) {
2444                 error_report_err(local_err);
2445                 ret = -1;
2446                 goto out;
2447             }
2448         }
2449
2450         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2451                             &error_abort);
2452         ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2453         if (ret < 0) {
2454             goto out;
2455         }
2456     }
2457
2458     /* Get backing file name if -o backing_file was used */
2459     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2460     if (out_baseimg_param) {
2461         out_baseimg = out_baseimg_param;
2462     }
2463     s.target_has_backing = (bool) out_baseimg;
2464
2465     if (s.has_zero_init && s.target_has_backing) {
2466         error_report("Cannot use --target-is-zero when the destination "
2467                      "image has a backing file");
2468         goto out;
2469     }
2470
2471     if (s.src_num > 1 && out_baseimg) {
2472         error_report("Having a backing file for the target makes no sense when "
2473                      "concatenating multiple input images");
2474         ret = -1;
2475         goto out;
2476     }
2477
2478     /* Check if compression is supported */
2479     if (s.compressed) {
2480         bool encryption =
2481             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2482         const char *encryptfmt =
2483             qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2484         const char *preallocation =
2485             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2486
2487         if (drv && !block_driver_can_compress(drv)) {
2488             error_report("Compression not supported for this file format");
2489             ret = -1;
2490             goto out;
2491         }
2492
2493         if (encryption || encryptfmt) {
2494             error_report("Compression and encryption not supported at "
2495                          "the same time");
2496             ret = -1;
2497             goto out;
2498         }
2499
2500         if (preallocation
2501             && strcmp(preallocation, "off"))
2502         {
2503             error_report("Compression and preallocation not supported at "
2504                          "the same time");
2505             ret = -1;
2506             goto out;
2507         }
2508     }
2509
2510     /*
2511      * The later open call will need any decryption secrets, and
2512      * bdrv_create() will purge "opts", so extract them now before
2513      * they are lost.
2514      */
2515     if (!skip_create) {
2516         open_opts = qdict_new();
2517         qemu_opt_foreach(opts, img_add_key_secrets, open_opts, &error_abort);
2518     }
2519
2520     if (!skip_create) {
2521         /* Create the new image */
2522         ret = bdrv_create(drv, out_filename, opts, &local_err);
2523         if (ret < 0) {
2524             error_reportf_err(local_err, "%s: error while converting %s: ",
2525                               out_filename, out_fmt);
2526             goto out;
2527         }
2528     }
2529
2530     s.target_is_new = !skip_create;
2531
2532     flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2533     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2534     if (ret < 0) {
2535         error_report("Invalid cache option: %s", cache);
2536         goto out;
2537     }
2538
2539     if (skip_create) {
2540         s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2541                             flags, writethrough, s.quiet, false);
2542     } else {
2543         /* TODO ultimately we should allow --target-image-opts
2544          * to be used even when -n is not given.
2545          * That has to wait for bdrv_create to be improved
2546          * to allow filenames in option syntax
2547          */
2548         s.target = img_open_file(out_filename, open_opts, out_fmt,
2549                                  flags, writethrough, s.quiet, false);
2550         open_opts = NULL; /* blk_new_open will have freed it */
2551     }
2552     if (!s.target) {
2553         ret = -1;
2554         goto out;
2555     }
2556     out_bs = blk_bs(s.target);
2557
2558     if (s.compressed && !block_driver_can_compress(out_bs->drv)) {
2559         error_report("Compression not supported for this file format");
2560         ret = -1;
2561         goto out;
2562     }
2563
2564     /* increase bufsectors from the default 4096 (2M) if opt_transfer
2565      * or discard_alignment of the out_bs is greater. Limit to
2566      * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2567     s.buf_sectors = MIN(MAX_BUF_SECTORS,
2568                         MAX(s.buf_sectors,
2569                             MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2570                                 out_bs->bl.pdiscard_alignment >>
2571                                 BDRV_SECTOR_BITS)));
2572
2573     /* try to align the write requests to the destination to avoid unnecessary
2574      * RMW cycles. */
2575     s.alignment = MAX(pow2floor(s.min_sparse),
2576                       DIV_ROUND_UP(out_bs->bl.request_alignment,
2577                                    BDRV_SECTOR_SIZE));
2578     assert(is_power_of_2(s.alignment));
2579
2580     if (skip_create) {
2581         int64_t output_sectors = blk_nb_sectors(s.target);
2582         if (output_sectors < 0) {
2583             error_report("unable to get output image length: %s",
2584                          strerror(-output_sectors));
2585             ret = -1;
2586             goto out;
2587         } else if (output_sectors < s.total_sectors) {
2588             error_report("output file is smaller than input file");
2589             ret = -1;
2590             goto out;
2591         }
2592     }
2593
2594     if (s.target_has_backing && s.target_is_new) {
2595         /* Errors are treated as "backing length unknown" (which means
2596          * s.target_backing_sectors has to be negative, which it will
2597          * be automatically).  The backing file length is used only
2598          * for optimizations, so such a case is not fatal. */
2599         s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
2600     } else {
2601         s.target_backing_sectors = -1;
2602     }
2603
2604     ret = bdrv_get_info(out_bs, &bdi);
2605     if (ret < 0) {
2606         if (s.compressed) {
2607             error_report("could not get block driver info");
2608             goto out;
2609         }
2610     } else {
2611         s.compressed = s.compressed || bdi.needs_compressed_writes;
2612         s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2613         s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;
2614     }
2615
2616     ret = convert_do_copy(&s);
2617 out:
2618     if (!ret) {
2619         qemu_progress_print(100, 0);
2620     }
2621     qemu_progress_end();
2622     qemu_opts_del(opts);
2623     qemu_opts_free(create_opts);
2624     qemu_opts_del(sn_opts);
2625     qobject_unref(open_opts);
2626     blk_unref(s.target);
2627     if (s.src) {
2628         for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2629             blk_unref(s.src[bs_i]);
2630         }
2631         g_free(s.src);
2632     }
2633     g_free(s.src_sectors);
2634 fail_getopt:
2635     g_free(options);
2636
2637     return !!ret;
2638 }
2639
2640
2641 static void dump_snapshots(BlockDriverState *bs)
2642 {
2643     QEMUSnapshotInfo *sn_tab, *sn;
2644     int nb_sns, i;
2645
2646     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2647     if (nb_sns <= 0)
2648         return;
2649     printf("Snapshot list:\n");
2650     bdrv_snapshot_dump(NULL);
2651     printf("\n");
2652     for(i = 0; i < nb_sns; i++) {
2653         sn = &sn_tab[i];
2654         bdrv_snapshot_dump(sn);
2655         printf("\n");
2656     }
2657     g_free(sn_tab);
2658 }
2659
2660 static void dump_json_image_info_list(ImageInfoList *list)
2661 {
2662     QString *str;
2663     QObject *obj;
2664     Visitor *v = qobject_output_visitor_new(&obj);
2665
2666     visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2667     visit_complete(v, &obj);
2668     str = qobject_to_json_pretty(obj);
2669     assert(str != NULL);
2670     printf("%s\n", qstring_get_str(str));
2671     qobject_unref(obj);
2672     visit_free(v);
2673     qobject_unref(str);
2674 }
2675
2676 static void dump_json_image_info(ImageInfo *info)
2677 {
2678     QString *str;
2679     QObject *obj;
2680     Visitor *v = qobject_output_visitor_new(&obj);
2681
2682     visit_type_ImageInfo(v, NULL, &info, &error_abort);
2683     visit_complete(v, &obj);
2684     str = qobject_to_json_pretty(obj);
2685     assert(str != NULL);
2686     printf("%s\n", qstring_get_str(str));
2687     qobject_unref(obj);
2688     visit_free(v);
2689     qobject_unref(str);
2690 }
2691
2692 static void dump_human_image_info_list(ImageInfoList *list)
2693 {
2694     ImageInfoList *elem;
2695     bool delim = false;
2696
2697     for (elem = list; elem; elem = elem->next) {
2698         if (delim) {
2699             printf("\n");
2700         }
2701         delim = true;
2702
2703         bdrv_image_info_dump(elem->value);
2704     }
2705 }
2706
2707 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2708 {
2709     return strcmp(a, b) == 0;
2710 }
2711
2712 /**
2713  * Open an image file chain and return an ImageInfoList
2714  *
2715  * @filename: topmost image filename
2716  * @fmt: topmost image format (may be NULL to autodetect)
2717  * @chain: true  - enumerate entire backing file chain
2718  *         false - only topmost image file
2719  *
2720  * Returns a list of ImageInfo objects or NULL if there was an error opening an
2721  * image file.  If there was an error a message will have been printed to
2722  * stderr.
2723  */
2724 static ImageInfoList *collect_image_info_list(bool image_opts,
2725                                               const char *filename,
2726                                               const char *fmt,
2727                                               bool chain, bool force_share)
2728 {
2729     ImageInfoList *head = NULL;
2730     ImageInfoList **last = &head;
2731     GHashTable *filenames;
2732     Error *err = NULL;
2733
2734     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2735
2736     while (filename) {
2737         BlockBackend *blk;
2738         BlockDriverState *bs;
2739         ImageInfo *info;
2740         ImageInfoList *elem;
2741
2742         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2743             error_report("Backing file '%s' creates an infinite loop.",
2744                          filename);
2745             goto err;
2746         }
2747         g_hash_table_insert(filenames, (gpointer)filename, NULL);
2748
2749         blk = img_open(image_opts, filename, fmt,
2750                        BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2751                        force_share);
2752         if (!blk) {
2753             goto err;
2754         }
2755         bs = blk_bs(blk);
2756
2757         bdrv_query_image_info(bs, &info, &err);
2758         if (err) {
2759             error_report_err(err);
2760             blk_unref(blk);
2761             goto err;
2762         }
2763
2764         elem = g_new0(ImageInfoList, 1);
2765         elem->value = info;
2766         *last = elem;
2767         last = &elem->next;
2768
2769         blk_unref(blk);
2770
2771         /* Clear parameters that only apply to the topmost image */
2772         filename = fmt = NULL;
2773         image_opts = false;
2774
2775         if (chain) {
2776             if (info->has_full_backing_filename) {
2777                 filename = info->full_backing_filename;
2778             } else if (info->has_backing_filename) {
2779                 error_report("Could not determine absolute backing filename,"
2780                              " but backing filename '%s' present",
2781                              info->backing_filename);
2782                 goto err;
2783             }
2784             if (info->has_backing_filename_format) {
2785                 fmt = info->backing_filename_format;
2786             }
2787         }
2788     }
2789     g_hash_table_destroy(filenames);
2790     return head;
2791
2792 err:
2793     qapi_free_ImageInfoList(head);
2794     g_hash_table_destroy(filenames);
2795     return NULL;
2796 }
2797
2798 static int img_info(int argc, char **argv)
2799 {
2800     int c;
2801     OutputFormat output_format = OFORMAT_HUMAN;
2802     bool chain = false;
2803     const char *filename, *fmt, *output;
2804     ImageInfoList *list;
2805     bool image_opts = false;
2806     bool force_share = false;
2807
2808     fmt = NULL;
2809     output = NULL;
2810     for(;;) {
2811         int option_index = 0;
2812         static const struct option long_options[] = {
2813             {"help", no_argument, 0, 'h'},
2814             {"format", required_argument, 0, 'f'},
2815             {"output", required_argument, 0, OPTION_OUTPUT},
2816             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2817             {"object", required_argument, 0, OPTION_OBJECT},
2818             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2819             {"force-share", no_argument, 0, 'U'},
2820             {0, 0, 0, 0}
2821         };
2822         c = getopt_long(argc, argv, ":f:hU",
2823                         long_options, &option_index);
2824         if (c == -1) {
2825             break;
2826         }
2827         switch(c) {
2828         case ':':
2829             missing_argument(argv[optind - 1]);
2830             break;
2831         case '?':
2832             unrecognized_option(argv[optind - 1]);
2833             break;
2834         case 'h':
2835             help();
2836             break;
2837         case 'f':
2838             fmt = optarg;
2839             break;
2840         case 'U':
2841             force_share = true;
2842             break;
2843         case OPTION_OUTPUT:
2844             output = optarg;
2845             break;
2846         case OPTION_BACKING_CHAIN:
2847             chain = true;
2848             break;
2849         case OPTION_OBJECT: {
2850             QemuOpts *opts;
2851             opts = qemu_opts_parse_noisily(&qemu_object_opts,
2852                                            optarg, true);
2853             if (!opts) {
2854                 return 1;
2855             }
2856         }   break;
2857         case OPTION_IMAGE_OPTS:
2858             image_opts = true;
2859             break;
2860         }
2861     }
2862     if (optind != argc - 1) {
2863         error_exit("Expecting one image file name");
2864     }
2865     filename = argv[optind++];
2866
2867     if (output && !strcmp(output, "json")) {
2868         output_format = OFORMAT_JSON;
2869     } else if (output && !strcmp(output, "human")) {
2870         output_format = OFORMAT_HUMAN;
2871     } else if (output) {
2872         error_report("--output must be used with human or json as argument.");
2873         return 1;
2874     }
2875
2876     if (qemu_opts_foreach(&qemu_object_opts,
2877                           user_creatable_add_opts_foreach,
2878                           qemu_img_object_print_help, &error_fatal)) {
2879         return 1;
2880     }
2881
2882     list = collect_image_info_list(image_opts, filename, fmt, chain,
2883                                    force_share);
2884     if (!list) {
2885         return 1;
2886     }
2887
2888     switch (output_format) {
2889     case OFORMAT_HUMAN:
2890         dump_human_image_info_list(list);
2891         break;
2892     case OFORMAT_JSON:
2893         if (chain) {
2894             dump_json_image_info_list(list);
2895         } else {
2896             dump_json_image_info(list->value);
2897         }
2898         break;
2899     }
2900
2901     qapi_free_ImageInfoList(list);
2902     return 0;
2903 }
2904
2905 static int dump_map_entry(OutputFormat output_format, MapEntry *e,
2906                           MapEntry *next)
2907 {
2908     switch (output_format) {
2909     case OFORMAT_HUMAN:
2910         if (e->data && !e->has_offset) {
2911             error_report("File contains external, encrypted or compressed clusters.");
2912             return -1;
2913         }
2914         if (e->data && !e->zero) {
2915             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2916                    e->start, e->length,
2917                    e->has_offset ? e->offset : 0,
2918                    e->has_filename ? e->filename : "");
2919         }
2920         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2921          * Modify the flags here to allow more coalescing.
2922          */
2923         if (next && (!next->data || next->zero)) {
2924             next->data = false;
2925             next->zero = true;
2926         }
2927         break;
2928     case OFORMAT_JSON:
2929         printf("{ \"start\": %"PRId64", \"length\": %"PRId64","
2930                " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2931                e->start, e->length, e->depth,
2932                e->zero ? "true" : "false",
2933                e->data ? "true" : "false");
2934         if (e->has_offset) {
2935             printf(", \"offset\": %"PRId64"", e->offset);
2936         }
2937         putchar('}');
2938
2939         if (next) {
2940             puts(",");
2941         }
2942         break;
2943     }
2944     return 0;
2945 }
2946
2947 static int get_block_status(BlockDriverState *bs, int64_t offset,
2948                             int64_t bytes, MapEntry *e)
2949 {
2950     int ret;
2951     int depth;
2952     BlockDriverState *file;
2953     bool has_offset;
2954     int64_t map;
2955     char *filename = NULL;
2956
2957     /* As an optimization, we could cache the current range of unallocated
2958      * clusters in each file of the chain, and avoid querying the same
2959      * range repeatedly.
2960      */
2961
2962     depth = 0;
2963     for (;;) {
2964         ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file);
2965         if (ret < 0) {
2966             return ret;
2967         }
2968         assert(bytes);
2969         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2970             break;
2971         }
2972         bs = backing_bs(bs);
2973         if (bs == NULL) {
2974             ret = 0;
2975             break;
2976         }
2977
2978         depth++;
2979     }
2980
2981     has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2982
2983     if (file && has_offset) {
2984         bdrv_refresh_filename(file);
2985         filename = file->filename;
2986     }
2987
2988     *e = (MapEntry) {
2989         .start = offset,
2990         .length = bytes,
2991         .data = !!(ret & BDRV_BLOCK_DATA),
2992         .zero = !!(ret & BDRV_BLOCK_ZERO),
2993         .offset = map,
2994         .has_offset = has_offset,
2995         .depth = depth,
2996         .has_filename = filename,
2997         .filename = filename,
2998     };
2999
3000     return 0;
3001 }
3002
3003 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
3004 {
3005     if (curr->length == 0) {
3006         return false;
3007     }
3008     if (curr->zero != next->zero ||
3009         curr->data != next->data ||
3010         curr->depth != next->depth ||
3011         curr->has_filename != next->has_filename ||
3012         curr->has_offset != next->has_offset) {
3013         return false;
3014     }
3015     if (curr->has_filename && strcmp(curr->filename, next->filename)) {
3016         return false;
3017     }
3018     if (curr->has_offset && curr->offset + curr->length != next->offset) {
3019         return false;
3020     }
3021     return true;
3022 }
3023
3024 static int img_map(int argc, char **argv)
3025 {
3026     int c;
3027     OutputFormat output_format = OFORMAT_HUMAN;
3028     BlockBackend *blk;
3029     BlockDriverState *bs;
3030     const char *filename, *fmt, *output;
3031     int64_t length;
3032     MapEntry curr = { .length = 0 }, next;
3033     int ret = 0;
3034     bool image_opts = false;
3035     bool force_share = false;
3036     int64_t start_offset = 0;
3037     int64_t max_length = -1;
3038
3039     fmt = NULL;
3040     output = NULL;
3041     for (;;) {
3042         int option_index = 0;
3043         static const struct option long_options[] = {
3044             {"help", no_argument, 0, 'h'},
3045             {"format", required_argument, 0, 'f'},
3046             {"output", required_argument, 0, OPTION_OUTPUT},
3047             {"object", required_argument, 0, OPTION_OBJECT},
3048             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3049             {"force-share", no_argument, 0, 'U'},
3050             {"start-offset", required_argument, 0, 's'},
3051             {"max-length", required_argument, 0, 'l'},
3052             {0, 0, 0, 0}
3053         };
3054         c = getopt_long(argc, argv, ":f:s:l:hU",
3055                         long_options, &option_index);
3056         if (c == -1) {
3057             break;
3058         }
3059         switch (c) {
3060         case ':':
3061             missing_argument(argv[optind - 1]);
3062             break;
3063         case '?':
3064             unrecognized_option(argv[optind - 1]);
3065             break;
3066         case 'h':
3067             help();
3068             break;
3069         case 'f':
3070             fmt = optarg;
3071             break;
3072         case 'U':
3073             force_share = true;
3074             break;
3075         case OPTION_OUTPUT:
3076             output = optarg;
3077             break;
3078         case 's':
3079             start_offset = cvtnum("start offset", optarg);
3080             if (start_offset < 0) {
3081                 return 1;
3082             }
3083             break;
3084         case 'l':
3085             max_length = cvtnum("max length", optarg);
3086             if (max_length < 0) {
3087                 return 1;
3088             }
3089             break;
3090         case OPTION_OBJECT: {
3091             QemuOpts *opts;
3092             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3093                                            optarg, true);
3094             if (!opts) {
3095                 return 1;
3096             }
3097         }   break;
3098         case OPTION_IMAGE_OPTS:
3099             image_opts = true;
3100             break;
3101         }
3102     }
3103     if (optind != argc - 1) {
3104         error_exit("Expecting one image file name");
3105     }
3106     filename = argv[optind];
3107
3108     if (output && !strcmp(output, "json")) {
3109         output_format = OFORMAT_JSON;
3110     } else if (output && !strcmp(output, "human")) {
3111         output_format = OFORMAT_HUMAN;
3112     } else if (output) {
3113         error_report("--output must be used with human or json as argument.");
3114         return 1;
3115     }
3116
3117     if (qemu_opts_foreach(&qemu_object_opts,
3118                           user_creatable_add_opts_foreach,
3119                           qemu_img_object_print_help, &error_fatal)) {
3120         return 1;
3121     }
3122
3123     blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
3124     if (!blk) {
3125         return 1;
3126     }
3127     bs = blk_bs(blk);
3128
3129     if (output_format == OFORMAT_HUMAN) {
3130         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
3131     } else if (output_format == OFORMAT_JSON) {
3132         putchar('[');
3133     }
3134
3135     length = blk_getlength(blk);
3136     if (length < 0) {
3137         error_report("Failed to get size for '%s'", filename);
3138         return 1;
3139     }
3140     if (max_length != -1) {
3141         length = MIN(start_offset + max_length, length);
3142     }
3143
3144     curr.start = start_offset;
3145     while (curr.start + curr.length < length) {
3146         int64_t offset = curr.start + curr.length;
3147         int64_t n;
3148
3149         /* Probe up to 1 GiB at a time.  */
3150         n = MIN(1 * GiB, length - offset);
3151         ret = get_block_status(bs, offset, n, &next);
3152
3153         if (ret < 0) {
3154             error_report("Could not read file metadata: %s", strerror(-ret));
3155             goto out;
3156         }
3157
3158         if (entry_mergeable(&curr, &next)) {
3159             curr.length += next.length;
3160             continue;
3161         }
3162
3163         if (curr.length > 0) {
3164             ret = dump_map_entry(output_format, &curr, &next);
3165             if (ret < 0) {
3166                 goto out;
3167             }
3168         }
3169         curr = next;
3170     }
3171
3172     ret = dump_map_entry(output_format, &curr, NULL);
3173     if (output_format == OFORMAT_JSON) {
3174         puts("]");
3175     }
3176
3177 out:
3178     blk_unref(blk);
3179     return ret < 0;
3180 }
3181
3182 #define SNAPSHOT_LIST   1
3183 #define SNAPSHOT_CREATE 2
3184 #define SNAPSHOT_APPLY  3
3185 #define SNAPSHOT_DELETE 4
3186
3187 static int img_snapshot(int argc, char **argv)
3188 {
3189     BlockBackend *blk;
3190     BlockDriverState *bs;
3191     QEMUSnapshotInfo sn;
3192     char *filename, *snapshot_name = NULL;
3193     int c, ret = 0, bdrv_oflags;
3194     int action = 0;
3195     qemu_timeval tv;
3196     bool quiet = false;
3197     Error *err = NULL;
3198     bool image_opts = false;
3199     bool force_share = false;
3200
3201     bdrv_oflags = BDRV_O_RDWR;
3202     /* Parse commandline parameters */
3203     for(;;) {
3204         static const struct option long_options[] = {
3205             {"help", no_argument, 0, 'h'},
3206             {"object", required_argument, 0, OPTION_OBJECT},
3207             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3208             {"force-share", no_argument, 0, 'U'},
3209             {0, 0, 0, 0}
3210         };
3211         c = getopt_long(argc, argv, ":la:c:d:hqU",
3212                         long_options, NULL);
3213         if (c == -1) {
3214             break;
3215         }
3216         switch(c) {
3217         case ':':
3218             missing_argument(argv[optind - 1]);
3219             break;
3220         case '?':
3221             unrecognized_option(argv[optind - 1]);
3222             break;
3223         case 'h':
3224             help();
3225             return 0;
3226         case 'l':
3227             if (action) {
3228                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3229                 return 0;
3230             }
3231             action = SNAPSHOT_LIST;
3232             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
3233             break;
3234         case 'a':
3235             if (action) {
3236                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3237                 return 0;
3238             }
3239             action = SNAPSHOT_APPLY;
3240             snapshot_name = optarg;
3241             break;
3242         case 'c':
3243             if (action) {
3244                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3245                 return 0;
3246             }
3247             action = SNAPSHOT_CREATE;
3248             snapshot_name = optarg;
3249             break;
3250         case 'd':
3251             if (action) {
3252                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3253                 return 0;
3254             }
3255             action = SNAPSHOT_DELETE;
3256             snapshot_name = optarg;
3257             break;
3258         case 'q':
3259             quiet = true;
3260             break;
3261         case 'U':
3262             force_share = true;
3263             break;
3264         case OPTION_OBJECT: {
3265             QemuOpts *opts;
3266             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3267                                            optarg, true);
3268             if (!opts) {
3269                 return 1;
3270             }
3271         }   break;
3272         case OPTION_IMAGE_OPTS:
3273             image_opts = true;
3274             break;
3275         }
3276     }
3277
3278     if (optind != argc - 1) {
3279         error_exit("Expecting one image file name");
3280     }
3281     filename = argv[optind++];
3282
3283     if (qemu_opts_foreach(&qemu_object_opts,
3284                           user_creatable_add_opts_foreach,
3285                           qemu_img_object_print_help, &error_fatal)) {
3286         return 1;
3287     }
3288
3289     /* Open the image */
3290     blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
3291                    force_share);
3292     if (!blk) {
3293         return 1;
3294     }
3295     bs = blk_bs(blk);
3296
3297     /* Perform the requested action */
3298     switch(action) {
3299     case SNAPSHOT_LIST:
3300         dump_snapshots(bs);
3301         break;
3302
3303     case SNAPSHOT_CREATE:
3304         memset(&sn, 0, sizeof(sn));
3305         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3306
3307         qemu_gettimeofday(&tv);
3308         sn.date_sec = tv.tv_sec;
3309         sn.date_nsec = tv.tv_usec * 1000;
3310
3311         ret = bdrv_snapshot_create(bs, &sn);
3312         if (ret) {
3313             error_report("Could not create snapshot '%s': %d (%s)",
3314                 snapshot_name, ret, strerror(-ret));
3315         }
3316         break;
3317
3318     case SNAPSHOT_APPLY:
3319         ret = bdrv_snapshot_goto(bs, snapshot_name, &err);
3320         if (ret) {
3321             error_reportf_err(err, "Could not apply snapshot '%s': ",
3322                               snapshot_name);
3323         }
3324         break;
3325
3326     case SNAPSHOT_DELETE:
3327         ret = bdrv_snapshot_find(bs, &sn, snapshot_name);
3328         if (ret < 0) {
3329             error_report("Could not delete snapshot '%s': snapshot not "
3330                          "found", snapshot_name);
3331             ret = 1;
3332         } else {
3333             ret = bdrv_snapshot_delete(bs, sn.id_str, sn.name, &err);
3334             if (ret < 0) {
3335                 error_reportf_err(err, "Could not delete snapshot '%s': ",
3336                                   snapshot_name);
3337                 ret = 1;
3338             }
3339         }
3340         break;
3341     }
3342
3343     /* Cleanup */
3344     blk_unref(blk);
3345     if (ret) {
3346         return 1;
3347     }
3348     return 0;
3349 }
3350
3351 static int img_rebase(int argc, char **argv)
3352 {
3353     BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
3354     uint8_t *buf_old = NULL;
3355     uint8_t *buf_new = NULL;
3356     BlockDriverState *bs = NULL, *prefix_chain_bs = NULL;
3357     char *filename;
3358     const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
3359     int c, flags, src_flags, ret;
3360     bool writethrough, src_writethrough;
3361     int unsafe = 0;
3362     bool force_share = false;
3363     int progress = 0;
3364     bool quiet = false;
3365     Error *local_err = NULL;
3366     bool image_opts = false;
3367
3368     /* Parse commandline parameters */
3369     fmt = NULL;
3370     cache = BDRV_DEFAULT_CACHE;
3371     src_cache = BDRV_DEFAULT_CACHE;
3372     out_baseimg = NULL;
3373     out_basefmt = NULL;
3374     for(;;) {
3375         static const struct option long_options[] = {
3376             {"help", no_argument, 0, 'h'},
3377             {"object", required_argument, 0, OPTION_OBJECT},
3378             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3379             {"force-share", no_argument, 0, 'U'},
3380             {0, 0, 0, 0}
3381         };
3382         c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU",
3383                         long_options, NULL);
3384         if (c == -1) {
3385             break;
3386         }
3387         switch(c) {
3388         case ':':
3389             missing_argument(argv[optind - 1]);
3390             break;
3391         case '?':
3392             unrecognized_option(argv[optind - 1]);
3393             break;
3394         case 'h':
3395             help();
3396             return 0;
3397         case 'f':
3398             fmt = optarg;
3399             break;
3400         case 'F':
3401             out_basefmt = optarg;
3402             break;
3403         case 'b':
3404             out_baseimg = optarg;
3405             break;
3406         case 'u':
3407             unsafe = 1;
3408             break;
3409         case 'p':
3410             progress = 1;
3411             break;
3412         case 't':
3413             cache = optarg;
3414             break;
3415         case 'T':
3416             src_cache = optarg;
3417             break;
3418         case 'q':
3419             quiet = true;
3420             break;
3421         case OPTION_OBJECT: {
3422             QemuOpts *opts;
3423             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3424                                            optarg, true);
3425             if (!opts) {
3426                 return 1;
3427             }
3428         }   break;
3429         case OPTION_IMAGE_OPTS:
3430             image_opts = true;
3431             break;
3432         case 'U':
3433             force_share = true;
3434             break;
3435         }
3436     }
3437
3438     if (quiet) {
3439         progress = 0;
3440     }
3441
3442     if (optind != argc - 1) {
3443         error_exit("Expecting one image file name");
3444     }
3445     if (!unsafe && !out_baseimg) {
3446         error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3447     }
3448     filename = argv[optind++];
3449
3450     if (qemu_opts_foreach(&qemu_object_opts,
3451                           user_creatable_add_opts_foreach,
3452                           qemu_img_object_print_help, &error_fatal)) {
3453         return 1;
3454     }
3455
3456     qemu_progress_init(progress, 2.0);
3457     qemu_progress_print(0, 100);
3458
3459     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
3460     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3461     if (ret < 0) {
3462         error_report("Invalid cache option: %s", cache);
3463         goto out;
3464     }
3465
3466     src_flags = 0;
3467     ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
3468     if (ret < 0) {
3469         error_report("Invalid source cache option: %s", src_cache);
3470         goto out;
3471     }
3472
3473     /* The source files are opened read-only, don't care about WCE */
3474     assert((src_flags & BDRV_O_RDWR) == 0);
3475     (void) src_writethrough;
3476
3477     /*
3478      * Open the images.
3479      *
3480      * Ignore the old backing file for unsafe rebase in case we want to correct
3481      * the reference to a renamed or moved backing file.
3482      */
3483     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3484                    false);
3485     if (!blk) {
3486         ret = -1;
3487         goto out;
3488     }
3489     bs = blk_bs(blk);
3490
3491     if (out_basefmt != NULL) {
3492         if (bdrv_find_format(out_basefmt) == NULL) {
3493             error_report("Invalid format name: '%s'", out_basefmt);
3494             ret = -1;
3495             goto out;
3496         }
3497     }
3498
3499     /* For safe rebasing we need to compare old and new backing file */
3500     if (!unsafe) {
3501         QDict *options = NULL;
3502         BlockDriverState *base_bs = backing_bs(bs);
3503
3504         if (base_bs) {
3505             blk_old_backing = blk_new(qemu_get_aio_context(),
3506                                       BLK_PERM_CONSISTENT_READ,
3507                                       BLK_PERM_ALL);
3508             ret = blk_insert_bs(blk_old_backing, base_bs,
3509                                 &local_err);
3510             if (ret < 0) {
3511                 error_reportf_err(local_err,
3512                                   "Could not reuse old backing file '%s': ",
3513                                   base_bs->filename);
3514                 goto out;
3515             }
3516         } else {
3517             blk_old_backing = NULL;
3518         }
3519
3520         if (out_baseimg[0]) {
3521             const char *overlay_filename;
3522             char *out_real_path;
3523
3524             options = qdict_new();
3525             if (out_basefmt) {
3526                 qdict_put_str(options, "driver", out_basefmt);
3527             }
3528             if (force_share) {
3529                 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3530             }
3531
3532             bdrv_refresh_filename(bs);
3533             overlay_filename = bs->exact_filename[0] ? bs->exact_filename
3534                                                      : bs->filename;
3535             out_real_path =
3536                 bdrv_get_full_backing_filename_from_filename(overlay_filename,
3537                                                              out_baseimg,
3538                                                              &local_err);
3539             if (local_err) {
3540                 qobject_unref(options);
3541                 error_reportf_err(local_err,
3542                                   "Could not resolve backing filename: ");
3543                 ret = -1;
3544                 goto out;
3545             }
3546
3547             /*
3548              * Find out whether we rebase an image on top of a previous image
3549              * in its chain.
3550              */
3551             prefix_chain_bs = bdrv_find_backing_image(bs, out_real_path);
3552             if (prefix_chain_bs) {
3553                 qobject_unref(options);
3554                 g_free(out_real_path);
3555
3556                 blk_new_backing = blk_new(qemu_get_aio_context(),
3557                                           BLK_PERM_CONSISTENT_READ,
3558                                           BLK_PERM_ALL);
3559                 ret = blk_insert_bs(blk_new_backing, prefix_chain_bs,
3560                                     &local_err);
3561                 if (ret < 0) {
3562                     error_reportf_err(local_err,
3563                                       "Could not reuse backing file '%s': ",
3564                                       out_baseimg);
3565                     goto out;
3566                 }
3567             } else {
3568                 blk_new_backing = blk_new_open(out_real_path, NULL,
3569                                                options, src_flags, &local_err);
3570                 g_free(out_real_path);
3571                 if (!blk_new_backing) {
3572                     error_reportf_err(local_err,
3573                                       "Could not open new backing file '%s': ",
3574                                       out_baseimg);
3575                     ret = -1;
3576                     goto out;
3577                 }
3578             }
3579         }
3580     }
3581
3582     /*
3583      * Check each unallocated cluster in the COW file. If it is unallocated,
3584      * accesses go to the backing file. We must therefore compare this cluster
3585      * in the old and new backing file, and if they differ we need to copy it
3586      * from the old backing file into the COW file.
3587      *
3588      * If qemu-img crashes during this step, no harm is done. The content of
3589      * the image is the same as the original one at any time.
3590      */
3591     if (!unsafe) {
3592         int64_t size;
3593         int64_t old_backing_size = 0;
3594         int64_t new_backing_size = 0;
3595         uint64_t offset;
3596         int64_t n;
3597         float local_progress = 0;
3598
3599         buf_old = blk_blockalign(blk, IO_BUF_SIZE);
3600         buf_new = blk_blockalign(blk, IO_BUF_SIZE);
3601
3602         size = blk_getlength(blk);
3603         if (size < 0) {
3604             error_report("Could not get size of '%s': %s",
3605                          filename, strerror(-size));
3606             ret = -1;
3607             goto out;
3608         }
3609         if (blk_old_backing) {
3610             old_backing_size = blk_getlength(blk_old_backing);
3611             if (old_backing_size < 0) {
3612                 char backing_name[PATH_MAX];
3613
3614                 bdrv_get_backing_filename(bs, backing_name,
3615                                           sizeof(backing_name));
3616                 error_report("Could not get size of '%s': %s",
3617                              backing_name, strerror(-old_backing_size));
3618                 ret = -1;
3619                 goto out;
3620             }
3621         }
3622         if (blk_new_backing) {
3623             new_backing_size = blk_getlength(blk_new_backing);
3624             if (new_backing_size < 0) {
3625                 error_report("Could not get size of '%s': %s",
3626                              out_baseimg, strerror(-new_backing_size));
3627                 ret = -1;
3628                 goto out;
3629             }
3630         }
3631
3632         if (size != 0) {
3633             local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE));
3634         }
3635
3636         for (offset = 0; offset < size; offset += n) {
3637             bool buf_old_is_zero = false;
3638
3639             /* How many bytes can we handle with the next read? */
3640             n = MIN(IO_BUF_SIZE, size - offset);
3641
3642             /* If the cluster is allocated, we don't need to take action */
3643             ret = bdrv_is_allocated(bs, offset, n, &n);
3644             if (ret < 0) {
3645                 error_report("error while reading image metadata: %s",
3646                              strerror(-ret));
3647                 goto out;
3648             }
3649             if (ret) {
3650                 continue;
3651             }
3652
3653             if (prefix_chain_bs) {
3654                 /*
3655                  * If cluster wasn't changed since prefix_chain, we don't need
3656                  * to take action
3657                  */
3658                 ret = bdrv_is_allocated_above(backing_bs(bs), prefix_chain_bs,
3659                                               false, offset, n, &n);
3660                 if (ret < 0) {
3661                     error_report("error while reading image metadata: %s",
3662                                  strerror(-ret));
3663                     goto out;
3664                 }
3665                 if (!ret) {
3666                     continue;
3667                 }
3668             }
3669
3670             /*
3671              * Read old and new backing file and take into consideration that
3672              * backing files may be smaller than the COW image.
3673              */
3674             if (offset >= old_backing_size) {
3675                 memset(buf_old, 0, n);
3676                 buf_old_is_zero = true;
3677             } else {
3678                 if (offset + n > old_backing_size) {
3679                     n = old_backing_size - offset;
3680                 }
3681
3682                 ret = blk_pread(blk_old_backing, offset, buf_old, n);
3683                 if (ret < 0) {
3684                     error_report("error while reading from old backing file");
3685                     goto out;
3686                 }
3687             }
3688
3689             if (offset >= new_backing_size || !blk_new_backing) {
3690                 memset(buf_new, 0, n);
3691             } else {
3692                 if (offset + n > new_backing_size) {
3693                     n = new_backing_size - offset;
3694                 }
3695
3696                 ret = blk_pread(blk_new_backing, offset, buf_new, n);
3697                 if (ret < 0) {
3698                     error_report("error while reading from new backing file");
3699                     goto out;
3700                 }
3701             }
3702
3703             /* If they differ, we need to write to the COW file */
3704             uint64_t written = 0;
3705
3706             while (written < n) {
3707                 int64_t pnum;
3708
3709                 if (compare_buffers(buf_old + written, buf_new + written,
3710                                     n - written, &pnum))
3711                 {
3712                     if (buf_old_is_zero) {
3713                         ret = blk_pwrite_zeroes(blk, offset + written, pnum, 0);
3714                     } else {
3715                         ret = blk_pwrite(blk, offset + written,
3716                                          buf_old + written, pnum, 0);
3717                     }
3718                     if (ret < 0) {
3719                         error_report("Error while writing to COW image: %s",
3720                             strerror(-ret));
3721                         goto out;
3722                     }
3723                 }
3724
3725                 written += pnum;
3726             }
3727             qemu_progress_print(local_progress, 100);
3728         }
3729     }
3730
3731     /*
3732      * Change the backing file. All clusters that are different from the old
3733      * backing file are overwritten in the COW file now, so the visible content
3734      * doesn't change when we switch the backing file.
3735      */
3736     if (out_baseimg && *out_baseimg) {
3737         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3738     } else {
3739         ret = bdrv_change_backing_file(bs, NULL, NULL);
3740     }
3741
3742     if (ret == -ENOSPC) {
3743         error_report("Could not change the backing file to '%s': No "
3744                      "space left in the file header", out_baseimg);
3745     } else if (ret < 0) {
3746         error_report("Could not change the backing file to '%s': %s",
3747             out_baseimg, strerror(-ret));
3748     }
3749
3750     qemu_progress_print(100, 0);
3751     /*
3752      * TODO At this point it is possible to check if any clusters that are
3753      * allocated in the COW file are the same in the backing file. If so, they
3754      * could be dropped from the COW file. Don't do this before switching the
3755      * backing file, in case of a crash this would lead to corruption.
3756      */
3757 out:
3758     qemu_progress_end();
3759     /* Cleanup */
3760     if (!unsafe) {
3761         blk_unref(blk_old_backing);
3762         blk_unref(blk_new_backing);
3763     }
3764     qemu_vfree(buf_old);
3765     qemu_vfree(buf_new);
3766
3767     blk_unref(blk);
3768     if (ret) {
3769         return 1;
3770     }
3771     return 0;
3772 }
3773
3774 static int img_resize(int argc, char **argv)
3775 {
3776     Error *err = NULL;
3777     int c, ret, relative;
3778     const char *filename, *fmt, *size;
3779     int64_t n, total_size, current_size;
3780     bool quiet = false;
3781     BlockBackend *blk = NULL;
3782     PreallocMode prealloc = PREALLOC_MODE_OFF;
3783     QemuOpts *param;
3784
3785     static QemuOptsList resize_options = {
3786         .name = "resize_options",
3787         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3788         .desc = {
3789             {
3790                 .name = BLOCK_OPT_SIZE,
3791                 .type = QEMU_OPT_SIZE,
3792                 .help = "Virtual disk size"
3793             }, {
3794                 /* end of list */
3795             }
3796         },
3797     };
3798     bool image_opts = false;
3799     bool shrink = false;
3800
3801     /* Remove size from argv manually so that negative numbers are not treated
3802      * as options by getopt. */
3803     if (argc < 3) {
3804         error_exit("Not enough arguments");
3805         return 1;
3806     }
3807
3808     size = argv[--argc];
3809
3810     /* Parse getopt arguments */
3811     fmt = NULL;
3812     for(;;) {
3813         static const struct option long_options[] = {
3814             {"help", no_argument, 0, 'h'},
3815             {"object", required_argument, 0, OPTION_OBJECT},
3816             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3817             {"preallocation", required_argument, 0, OPTION_PREALLOCATION},
3818             {"shrink", no_argument, 0, OPTION_SHRINK},
3819             {0, 0, 0, 0}
3820         };
3821         c = getopt_long(argc, argv, ":f:hq",
3822                         long_options, NULL);
3823         if (c == -1) {
3824             break;
3825         }
3826         switch(c) {
3827         case ':':
3828             missing_argument(argv[optind - 1]);
3829             break;
3830         case '?':
3831             unrecognized_option(argv[optind - 1]);
3832             break;
3833         case 'h':
3834             help();
3835             break;
3836         case 'f':
3837             fmt = optarg;
3838             break;
3839         case 'q':
3840             quiet = true;
3841             break;
3842         case OPTION_OBJECT: {
3843             QemuOpts *opts;
3844             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3845                                            optarg, true);
3846             if (!opts) {
3847                 return 1;
3848             }
3849         }   break;
3850         case OPTION_IMAGE_OPTS:
3851             image_opts = true;
3852             break;
3853         case OPTION_PREALLOCATION:
3854             prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg,
3855                                        PREALLOC_MODE__MAX, NULL);
3856             if (prealloc == PREALLOC_MODE__MAX) {
3857                 error_report("Invalid preallocation mode '%s'", optarg);
3858                 return 1;
3859             }
3860             break;
3861         case OPTION_SHRINK:
3862             shrink = true;
3863             break;
3864         }
3865     }
3866     if (optind != argc - 1) {
3867         error_exit("Expecting image file name and size");
3868     }
3869     filename = argv[optind++];
3870
3871     if (qemu_opts_foreach(&qemu_object_opts,
3872                           user_creatable_add_opts_foreach,
3873                           qemu_img_object_print_help, &error_fatal)) {
3874         return 1;
3875     }
3876
3877     /* Choose grow, shrink, or absolute resize mode */
3878     switch (size[0]) {
3879     case '+':
3880         relative = 1;
3881         size++;
3882         break;
3883     case '-':
3884         relative = -1;
3885         size++;
3886         break;
3887     default:
3888         relative = 0;
3889         break;
3890     }
3891
3892     /* Parse size */
3893     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3894     qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3895     if (err) {
3896         error_report_err(err);
3897         ret = -1;
3898         qemu_opts_del(param);
3899         goto out;
3900     }
3901     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3902     qemu_opts_del(param);
3903
3904     blk = img_open(image_opts, filename, fmt,
3905                    BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet,
3906                    false);
3907     if (!blk) {
3908         ret = -1;
3909         goto out;
3910     }
3911
3912     current_size = blk_getlength(blk);
3913     if (current_size < 0) {
3914         error_report("Failed to inquire current image length: %s",
3915                      strerror(-current_size));
3916         ret = -1;
3917         goto out;
3918     }
3919
3920     if (relative) {
3921         total_size = current_size + n * relative;
3922     } else {
3923         total_size = n;
3924     }
3925     if (total_size <= 0) {
3926         error_report("New image size must be positive");
3927         ret = -1;
3928         goto out;
3929     }
3930
3931     if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) {
3932         error_report("Preallocation can only be used for growing images");
3933         ret = -1;
3934         goto out;
3935     }
3936
3937     if (total_size < current_size && !shrink) {
3938         warn_report("Shrinking an image will delete all data beyond the "
3939                     "shrunken image's end. Before performing such an "
3940                     "operation, make sure there is no important data there.");
3941
3942         if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) {
3943             error_report(
3944               "Use the --shrink option to perform a shrink operation.");
3945             ret = -1;
3946             goto out;
3947         } else {
3948             warn_report("Using the --shrink option will suppress this message. "
3949                         "Note that future versions of qemu-img may refuse to "
3950                         "shrink images without this option.");
3951         }
3952     }
3953
3954     /*
3955      * The user expects the image to have the desired size after
3956      * resizing, so pass @exact=true.  It is of no use to report
3957      * success when the image has not actually been resized.
3958      */
3959     ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
3960     if (!ret) {
3961         qprintf(quiet, "Image resized.\n");
3962     } else {
3963         error_report_err(err);
3964     }
3965 out:
3966     blk_unref(blk);
3967     if (ret) {
3968         return 1;
3969     }
3970     return 0;
3971 }
3972
3973 static void amend_status_cb(BlockDriverState *bs,
3974                             int64_t offset, int64_t total_work_size,
3975                             void *opaque)
3976 {
3977     qemu_progress_print(100.f * offset / total_work_size, 0);
3978 }
3979
3980 static int print_amend_option_help(const char *format)
3981 {
3982     BlockDriver *drv;
3983
3984     /* Find driver and parse its options */
3985     drv = bdrv_find_format(format);
3986     if (!drv) {
3987         error_report("Unknown file format '%s'", format);
3988         return 1;
3989     }
3990
3991     if (!drv->bdrv_amend_options) {
3992         error_report("Format driver '%s' does not support option amendment",
3993                      format);
3994         return 1;
3995     }
3996
3997     /* Every driver supporting amendment must have create_opts */
3998     assert(drv->create_opts);
3999
4000     printf("Creation options for '%s':\n", format);
4001     qemu_opts_print_help(drv->create_opts, false);
4002     printf("\nNote that not all of these options may be amendable.\n");
4003     return 0;
4004 }
4005
4006 static int img_amend(int argc, char **argv)
4007 {
4008     Error *err = NULL;
4009     int c, ret = 0;
4010     char *options = NULL;
4011     QemuOptsList *create_opts = NULL;
4012     QemuOpts *opts = NULL;
4013     const char *fmt = NULL, *filename, *cache;
4014     int flags;
4015     bool writethrough;
4016     bool quiet = false, progress = false;
4017     BlockBackend *blk = NULL;
4018     BlockDriverState *bs = NULL;
4019     bool image_opts = false;
4020
4021     cache = BDRV_DEFAULT_CACHE;
4022     for (;;) {
4023         static const struct option long_options[] = {
4024             {"help", no_argument, 0, 'h'},
4025             {"object", required_argument, 0, OPTION_OBJECT},
4026             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4027             {0, 0, 0, 0}
4028         };
4029         c = getopt_long(argc, argv, ":ho:f:t:pq",
4030                         long_options, NULL);
4031         if (c == -1) {
4032             break;
4033         }
4034
4035         switch (c) {
4036         case ':':
4037             missing_argument(argv[optind - 1]);
4038             break;
4039         case '?':
4040             unrecognized_option(argv[optind - 1]);
4041             break;
4042         case 'h':
4043             help();
4044             break;
4045         case 'o':
4046             if (accumulate_options(&options, optarg) < 0) {
4047                 ret = -1;
4048                 goto out_no_progress;
4049             }
4050             break;
4051         case 'f':
4052             fmt = optarg;
4053             break;
4054         case 't':
4055             cache = optarg;
4056             break;
4057         case 'p':
4058             progress = true;
4059             break;
4060         case 'q':
4061             quiet = true;
4062             break;
4063         case OPTION_OBJECT:
4064             opts = qemu_opts_parse_noisily(&qemu_object_opts,
4065                                            optarg, true);
4066             if (!opts) {
4067                 ret = -1;
4068                 goto out_no_progress;
4069             }
4070             break;
4071         case OPTION_IMAGE_OPTS:
4072             image_opts = true;
4073             break;
4074         }
4075     }
4076
4077     if (!options) {
4078         error_exit("Must specify options (-o)");
4079     }
4080
4081     if (qemu_opts_foreach(&qemu_object_opts,
4082                           user_creatable_add_opts_foreach,
4083                           qemu_img_object_print_help, &error_fatal)) {
4084         ret = -1;
4085         goto out_no_progress;
4086     }
4087
4088     if (quiet) {
4089         progress = false;
4090     }
4091     qemu_progress_init(progress, 1.0);
4092
4093     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
4094     if (fmt && has_help_option(options)) {
4095         /* If a format is explicitly specified (and possibly no filename is
4096          * given), print option help here */
4097         ret = print_amend_option_help(fmt);
4098         goto out;
4099     }
4100
4101     if (optind != argc - 1) {
4102         error_report("Expecting one image file name");
4103         ret = -1;
4104         goto out;
4105     }
4106
4107     flags = BDRV_O_RDWR;
4108     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
4109     if (ret < 0) {
4110         error_report("Invalid cache option: %s", cache);
4111         goto out;
4112     }
4113
4114     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4115                    false);
4116     if (!blk) {
4117         ret = -1;
4118         goto out;
4119     }
4120     bs = blk_bs(blk);
4121
4122     fmt = bs->drv->format_name;
4123
4124     if (has_help_option(options)) {
4125         /* If the format was auto-detected, print option help here */
4126         ret = print_amend_option_help(fmt);
4127         goto out;
4128     }
4129
4130     if (!bs->drv->bdrv_amend_options) {
4131         error_report("Format driver '%s' does not support option amendment",
4132                      fmt);
4133         ret = -1;
4134         goto out;
4135     }
4136
4137     /* Every driver supporting amendment must have create_opts */
4138     assert(bs->drv->create_opts);
4139
4140     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
4141     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4142     qemu_opts_do_parse(opts, options, NULL, &err);
4143     if (err) {
4144         error_report_err(err);
4145         ret = -1;
4146         goto out;
4147     }
4148
4149     /* In case the driver does not call amend_status_cb() */
4150     qemu_progress_print(0.f, 0);
4151     ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err);
4152     qemu_progress_print(100.f, 0);
4153     if (ret < 0) {
4154         error_report_err(err);
4155         goto out;
4156     }
4157
4158 out:
4159     qemu_progress_end();
4160
4161 out_no_progress:
4162     blk_unref(blk);
4163     qemu_opts_del(opts);
4164     qemu_opts_free(create_opts);
4165     g_free(options);
4166
4167     if (ret) {
4168         return 1;
4169     }
4170     return 0;
4171 }
4172
4173 typedef struct BenchData {
4174     BlockBackend *blk;
4175     uint64_t image_size;
4176     bool write;
4177     int bufsize;
4178     int step;
4179     int nrreq;
4180     int n;
4181     int flush_interval;
4182     bool drain_on_flush;
4183     uint8_t *buf;
4184     QEMUIOVector *qiov;
4185
4186     int in_flight;
4187     bool in_flush;
4188     uint64_t offset;
4189 } BenchData;
4190
4191 static void bench_undrained_flush_cb(void *opaque, int ret)
4192 {
4193     if (ret < 0) {
4194         error_report("Failed flush request: %s", strerror(-ret));
4195         exit(EXIT_FAILURE);
4196     }
4197 }
4198
4199 static void bench_cb(void *opaque, int ret)
4200 {
4201     BenchData *b = opaque;
4202     BlockAIOCB *acb;
4203
4204     if (ret < 0) {
4205         error_report("Failed request: %s", strerror(-ret));
4206         exit(EXIT_FAILURE);
4207     }
4208
4209     if (b->in_flush) {
4210         /* Just finished a flush with drained queue: Start next requests */
4211         assert(b->in_flight == 0);
4212         b->in_flush = false;
4213     } else if (b->in_flight > 0) {
4214         int remaining = b->n - b->in_flight;
4215
4216         b->n--;
4217         b->in_flight--;
4218
4219         /* Time for flush? Drain queue if requested, then flush */
4220         if (b->flush_interval && remaining % b->flush_interval == 0) {
4221             if (!b->in_flight || !b->drain_on_flush) {
4222                 BlockCompletionFunc *cb;
4223
4224                 if (b->drain_on_flush) {
4225                     b->in_flush = true;
4226                     cb = bench_cb;
4227                 } else {
4228                     cb = bench_undrained_flush_cb;
4229                 }
4230
4231                 acb = blk_aio_flush(b->blk, cb, b);
4232                 if (!acb) {
4233                     error_report("Failed to issue flush request");
4234                     exit(EXIT_FAILURE);
4235                 }
4236             }
4237             if (b->drain_on_flush) {
4238                 return;
4239             }
4240         }
4241     }
4242
4243     while (b->n > b->in_flight && b->in_flight < b->nrreq) {
4244         int64_t offset = b->offset;
4245         /* blk_aio_* might look for completed I/Os and kick bench_cb
4246          * again, so make sure this operation is counted by in_flight
4247          * and b->offset is ready for the next submission.
4248          */
4249         b->in_flight++;
4250         b->offset += b->step;
4251         b->offset %= b->image_size;
4252         if (b->write) {
4253             acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b);
4254         } else {
4255             acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b);
4256         }
4257         if (!acb) {
4258             error_report("Failed to issue request");
4259             exit(EXIT_FAILURE);
4260         }
4261     }
4262 }
4263
4264 static int img_bench(int argc, char **argv)
4265 {
4266     int c, ret = 0;
4267     const char *fmt = NULL, *filename;
4268     bool quiet = false;
4269     bool image_opts = false;
4270     bool is_write = false;
4271     int count = 75000;
4272     int depth = 64;
4273     int64_t offset = 0;
4274     size_t bufsize = 4096;
4275     int pattern = 0;
4276     size_t step = 0;
4277     int flush_interval = 0;
4278     bool drain_on_flush = true;
4279     int64_t image_size;
4280     BlockBackend *blk = NULL;
4281     BenchData data = {};
4282     int flags = 0;
4283     bool writethrough = false;
4284     struct timeval t1, t2;
4285     int i;
4286     bool force_share = false;
4287     size_t buf_size;
4288
4289     for (;;) {
4290         static const struct option long_options[] = {
4291             {"help", no_argument, 0, 'h'},
4292             {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
4293             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4294             {"pattern", required_argument, 0, OPTION_PATTERN},
4295             {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
4296             {"force-share", no_argument, 0, 'U'},
4297             {0, 0, 0, 0}
4298         };
4299         c = getopt_long(argc, argv, ":hc:d:f:ni:o:qs:S:t:wU", long_options,
4300                         NULL);
4301         if (c == -1) {
4302             break;
4303         }
4304
4305         switch (c) {
4306         case ':':
4307             missing_argument(argv[optind - 1]);
4308             break;
4309         case '?':
4310             unrecognized_option(argv[optind - 1]);
4311             break;
4312         case 'h':
4313             help();
4314             break;
4315         case 'c':
4316         {
4317             unsigned long res;
4318
4319             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4320                 error_report("Invalid request count specified");
4321                 return 1;
4322             }
4323             count = res;
4324             break;
4325         }
4326         case 'd':
4327         {
4328             unsigned long res;
4329
4330             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4331                 error_report("Invalid queue depth specified");
4332                 return 1;
4333             }
4334             depth = res;
4335             break;
4336         }
4337         case 'f':
4338             fmt = optarg;
4339             break;
4340         case 'n':
4341             flags |= BDRV_O_NATIVE_AIO;
4342             break;
4343         case 'i':
4344             ret = bdrv_parse_aio(optarg, &flags);
4345             if (ret < 0) {
4346                 error_report("Invalid aio option: %s", optarg);
4347                 ret = -1;
4348                 goto out;
4349             }
4350             break;
4351         case 'o':
4352         {
4353             offset = cvtnum("offset", optarg);
4354             if (offset < 0) {
4355                 return 1;
4356             }
4357             break;
4358         }
4359             break;
4360         case 'q':
4361             quiet = true;
4362             break;
4363         case 's':
4364         {
4365             int64_t sval;
4366
4367             sval = cvtnum_full("buffer size", optarg, 0, INT_MAX);
4368             if (sval < 0) {
4369                 return 1;
4370             }
4371
4372             bufsize = sval;
4373             break;
4374         }
4375         case 'S':
4376         {
4377             int64_t sval;
4378
4379             sval = cvtnum_full("step_size", optarg, 0, INT_MAX);
4380             if (sval < 0) {
4381                 return 1;
4382             }
4383
4384             step = sval;
4385             break;
4386         }
4387         case 't':
4388             ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
4389             if (ret < 0) {
4390                 error_report("Invalid cache mode");
4391                 ret = -1;
4392                 goto out;
4393             }
4394             break;
4395         case 'w':
4396             flags |= BDRV_O_RDWR;
4397             is_write = true;
4398             break;
4399         case 'U':
4400             force_share = true;
4401             break;
4402         case OPTION_PATTERN:
4403         {
4404             unsigned long res;
4405
4406             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
4407                 error_report("Invalid pattern byte specified");
4408                 return 1;
4409             }
4410             pattern = res;
4411             break;
4412         }
4413         case OPTION_FLUSH_INTERVAL:
4414         {
4415             unsigned long res;
4416
4417             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4418                 error_report("Invalid flush interval specified");
4419                 return 1;
4420             }
4421             flush_interval = res;
4422             break;
4423         }
4424         case OPTION_NO_DRAIN:
4425             drain_on_flush = false;
4426             break;
4427         case OPTION_IMAGE_OPTS:
4428             image_opts = true;
4429             break;
4430         }
4431     }
4432
4433     if (optind != argc - 1) {
4434         error_exit("Expecting one image file name");
4435     }
4436     filename = argv[argc - 1];
4437
4438     if (!is_write && flush_interval) {
4439         error_report("--flush-interval is only available in write tests");
4440         ret = -1;
4441         goto out;
4442     }
4443     if (flush_interval && flush_interval < depth) {
4444         error_report("Flush interval can't be smaller than depth");
4445         ret = -1;
4446         goto out;
4447     }
4448
4449     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4450                    force_share);
4451     if (!blk) {
4452         ret = -1;
4453         goto out;
4454     }
4455
4456     image_size = blk_getlength(blk);
4457     if (image_size < 0) {
4458         ret = image_size;
4459         goto out;
4460     }
4461
4462     data = (BenchData) {
4463         .blk            = blk,
4464         .image_size     = image_size,
4465         .bufsize        = bufsize,
4466         .step           = step ?: bufsize,
4467         .nrreq          = depth,
4468         .n              = count,
4469         .offset         = offset,
4470         .write          = is_write,
4471         .flush_interval = flush_interval,
4472         .drain_on_flush = drain_on_flush,
4473     };
4474     printf("Sending %d %s requests, %d bytes each, %d in parallel "
4475            "(starting at offset %" PRId64 ", step size %d)\n",
4476            data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
4477            data.offset, data.step);
4478     if (flush_interval) {
4479         printf("Sending flush every %d requests\n", flush_interval);
4480     }
4481
4482     buf_size = data.nrreq * data.bufsize;
4483     data.buf = blk_blockalign(blk, buf_size);
4484     memset(data.buf, pattern, data.nrreq * data.bufsize);
4485
4486     blk_register_buf(blk, data.buf, buf_size);
4487
4488     data.qiov = g_new(QEMUIOVector, data.nrreq);
4489     for (i = 0; i < data.nrreq; i++) {
4490         qemu_iovec_init(&data.qiov[i], 1);
4491         qemu_iovec_add(&data.qiov[i],
4492                        data.buf + i * data.bufsize, data.bufsize);
4493     }
4494
4495     gettimeofday(&t1, NULL);
4496     bench_cb(&data, 0);
4497
4498     while (data.n > 0) {
4499         main_loop_wait(false);
4500     }
4501     gettimeofday(&t2, NULL);
4502
4503     printf("Run completed in %3.3f seconds.\n",
4504            (t2.tv_sec - t1.tv_sec)
4505            + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
4506
4507 out:
4508     if (data.buf) {
4509         blk_unregister_buf(blk, data.buf);
4510     }
4511     qemu_vfree(data.buf);
4512     blk_unref(blk);
4513
4514     if (ret) {
4515         return 1;
4516     }
4517     return 0;
4518 }
4519
4520 enum ImgBitmapAct {
4521     BITMAP_ADD,
4522     BITMAP_REMOVE,
4523     BITMAP_CLEAR,
4524     BITMAP_ENABLE,
4525     BITMAP_DISABLE,
4526     BITMAP_MERGE,
4527 };
4528 typedef struct ImgBitmapAction {
4529     enum ImgBitmapAct act;
4530     const char *src; /* only used for merge */
4531     QSIMPLEQ_ENTRY(ImgBitmapAction) next;
4532 } ImgBitmapAction;
4533
4534 static int img_bitmap(int argc, char **argv)
4535 {
4536     Error *err = NULL;
4537     int c, ret = 1;
4538     QemuOpts *opts = NULL;
4539     const char *fmt = NULL, *src_fmt = NULL, *src_filename = NULL;
4540     const char *filename, *bitmap;
4541     BlockBackend *blk = NULL, *src = NULL;
4542     BlockDriverState *bs = NULL, *src_bs = NULL;
4543     bool image_opts = false;
4544     int64_t granularity = 0;
4545     bool add = false, merge = false;
4546     QSIMPLEQ_HEAD(, ImgBitmapAction) actions;
4547     ImgBitmapAction *act, *act_next;
4548     const char *op;
4549
4550     QSIMPLEQ_INIT(&actions);
4551
4552     for (;;) {
4553         static const struct option long_options[] = {
4554             {"help", no_argument, 0, 'h'},
4555             {"object", required_argument, 0, OPTION_OBJECT},
4556             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4557             {"add", no_argument, 0, OPTION_ADD},
4558             {"remove", no_argument, 0, OPTION_REMOVE},
4559             {"clear", no_argument, 0, OPTION_CLEAR},
4560             {"enable", no_argument, 0, OPTION_ENABLE},
4561             {"disable", no_argument, 0, OPTION_DISABLE},
4562             {"merge", required_argument, 0, OPTION_MERGE},
4563             {"granularity", required_argument, 0, 'g'},
4564             {"source-file", required_argument, 0, 'b'},
4565             {"source-format", required_argument, 0, 'F'},
4566             {0, 0, 0, 0}
4567         };
4568         c = getopt_long(argc, argv, ":b:f:F:g:h", long_options, NULL);
4569         if (c == -1) {
4570             break;
4571         }
4572
4573         switch (c) {
4574         case ':':
4575             missing_argument(argv[optind - 1]);
4576             break;
4577         case '?':
4578             unrecognized_option(argv[optind - 1]);
4579             break;
4580         case 'h':
4581             help();
4582             break;
4583         case 'b':
4584             src_filename = optarg;
4585             break;
4586         case 'f':
4587             fmt = optarg;
4588             break;
4589         case 'F':
4590             src_fmt = optarg;
4591             break;
4592         case 'g':
4593             granularity = cvtnum("granularity", optarg);
4594             if (granularity < 0) {
4595                 return 1;
4596             }
4597             break;
4598         case OPTION_ADD:
4599             act = g_new0(ImgBitmapAction, 1);
4600             act->act = BITMAP_ADD;
4601             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4602             add = true;
4603             break;
4604         case OPTION_REMOVE:
4605             act = g_new0(ImgBitmapAction, 1);
4606             act->act = BITMAP_REMOVE;
4607             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4608             break;
4609         case OPTION_CLEAR:
4610             act = g_new0(ImgBitmapAction, 1);
4611             act->act = BITMAP_CLEAR;
4612             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4613             break;
4614         case OPTION_ENABLE:
4615             act = g_new0(ImgBitmapAction, 1);
4616             act->act = BITMAP_ENABLE;
4617             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4618             break;
4619         case OPTION_DISABLE:
4620             act = g_new0(ImgBitmapAction, 1);
4621             act->act = BITMAP_DISABLE;
4622             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4623             break;
4624         case OPTION_MERGE:
4625             act = g_new0(ImgBitmapAction, 1);
4626             act->act = BITMAP_MERGE;
4627             act->src = optarg;
4628             QSIMPLEQ_INSERT_TAIL(&actions, act, next);
4629             merge = true;
4630             break;
4631         case OPTION_OBJECT:
4632             opts = qemu_opts_parse_noisily(&qemu_object_opts, optarg, true);
4633             if (!opts) {
4634                 goto out;
4635             }
4636             break;
4637         case OPTION_IMAGE_OPTS:
4638             image_opts = true;
4639             break;
4640         }
4641     }
4642
4643     if (qemu_opts_foreach(&qemu_object_opts,
4644                           user_creatable_add_opts_foreach,
4645                           qemu_img_object_print_help, &error_fatal)) {
4646         goto out;
4647     }
4648
4649     if (QSIMPLEQ_EMPTY(&actions)) {
4650         error_report("Need at least one of --add, --remove, --clear, "
4651                      "--enable, --disable, or --merge");
4652         goto out;
4653     }
4654
4655     if (granularity && !add) {
4656         error_report("granularity only supported with --add");
4657         goto out;
4658     }
4659     if (src_fmt && !src_filename) {
4660         error_report("-F only supported with -b");
4661         goto out;
4662     }
4663     if (src_filename && !merge) {
4664         error_report("Merge bitmap source file only supported with "
4665                      "--merge");
4666         goto out;
4667     }
4668
4669     if (optind != argc - 2) {
4670         error_report("Expecting filename and bitmap name");
4671         goto out;
4672     }
4673
4674     filename = argv[optind];
4675     bitmap = argv[optind + 1];
4676
4677     blk = img_open(image_opts, filename, fmt, BDRV_O_RDWR, false, false,
4678                    false);
4679     if (!blk) {
4680         goto out;
4681     }
4682     bs = blk_bs(blk);
4683     if (src_filename) {
4684         src = img_open(false, src_filename, src_fmt, 0, false, false, false);
4685         if (!src) {
4686             goto out;
4687         }
4688         src_bs = blk_bs(src);
4689     } else {
4690         src_bs = bs;
4691     }
4692
4693     QSIMPLEQ_FOREACH_SAFE(act, &actions, next, act_next) {
4694         switch (act->act) {
4695         case BITMAP_ADD:
4696             qmp_block_dirty_bitmap_add(bs->node_name, bitmap,
4697                                        !!granularity, granularity, true, true,
4698                                        false, false, &err);
4699             op = "add";
4700             break;
4701         case BITMAP_REMOVE:
4702             qmp_block_dirty_bitmap_remove(bs->node_name, bitmap, &err);
4703             op = "remove";
4704             break;
4705         case BITMAP_CLEAR:
4706             qmp_block_dirty_bitmap_clear(bs->node_name, bitmap, &err);
4707             op = "clear";
4708             break;
4709         case BITMAP_ENABLE:
4710             qmp_block_dirty_bitmap_enable(bs->node_name, bitmap, &err);
4711             op = "enable";
4712             break;
4713         case BITMAP_DISABLE:
4714             qmp_block_dirty_bitmap_disable(bs->node_name, bitmap, &err);
4715             op = "disable";
4716             break;
4717         case BITMAP_MERGE: {
4718             BlockDirtyBitmapMergeSource *merge_src;
4719             BlockDirtyBitmapMergeSourceList *list;
4720
4721             merge_src = g_new0(BlockDirtyBitmapMergeSource, 1);
4722             merge_src->type = QTYPE_QDICT;
4723             merge_src->u.external.node = g_strdup(src_bs->node_name);
4724             merge_src->u.external.name = g_strdup(act->src);
4725             list = g_new0(BlockDirtyBitmapMergeSourceList, 1);
4726             list->value = merge_src;
4727             qmp_block_dirty_bitmap_merge(bs->node_name, bitmap, list, &err);
4728             qapi_free_BlockDirtyBitmapMergeSourceList(list);
4729             op = "merge";
4730             break;
4731         }
4732         default:
4733             g_assert_not_reached();
4734         }
4735
4736         if (err) {
4737             error_reportf_err(err, "Operation %s on bitmap %s failed: ",
4738                               op, bitmap);
4739             goto out;
4740         }
4741         g_free(act);
4742     }
4743
4744     ret = 0;
4745
4746  out:
4747     blk_unref(src);
4748     blk_unref(blk);
4749     qemu_opts_del(opts);
4750     return ret;
4751 }
4752
4753 #define C_BS      01
4754 #define C_COUNT   02
4755 #define C_IF      04
4756 #define C_OF      010
4757 #define C_SKIP    020
4758
4759 struct DdInfo {
4760     unsigned int flags;
4761     int64_t count;
4762 };
4763
4764 struct DdIo {
4765     int bsz;    /* Block size */
4766     char *filename;
4767     uint8_t *buf;
4768     int64_t offset;
4769 };
4770
4771 struct DdOpts {
4772     const char *name;
4773     int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
4774     unsigned int flag;
4775 };
4776
4777 static int img_dd_bs(const char *arg,
4778                      struct DdIo *in, struct DdIo *out,
4779                      struct DdInfo *dd)
4780 {
4781     int64_t res;
4782
4783     res = cvtnum_full("bs", arg, 1, INT_MAX);
4784
4785     if (res < 0) {
4786         return 1;
4787     }
4788     in->bsz = out->bsz = res;
4789
4790     return 0;
4791 }
4792
4793 static int img_dd_count(const char *arg,
4794                         struct DdIo *in, struct DdIo *out,
4795                         struct DdInfo *dd)
4796 {
4797     dd->count = cvtnum("count", arg);
4798
4799     if (dd->count < 0) {
4800         return 1;
4801     }
4802
4803     return 0;
4804 }
4805
4806 static int img_dd_if(const char *arg,
4807                      struct DdIo *in, struct DdIo *out,
4808                      struct DdInfo *dd)
4809 {
4810     in->filename = g_strdup(arg);
4811
4812     return 0;
4813 }
4814
4815 static int img_dd_of(const char *arg,
4816                      struct DdIo *in, struct DdIo *out,
4817                      struct DdInfo *dd)
4818 {
4819     out->filename = g_strdup(arg);
4820
4821     return 0;
4822 }
4823
4824 static int img_dd_skip(const char *arg,
4825                        struct DdIo *in, struct DdIo *out,
4826                        struct DdInfo *dd)
4827 {
4828     in->offset = cvtnum("skip", arg);
4829
4830     if (in->offset < 0) {
4831         return 1;
4832     }
4833
4834     return 0;
4835 }
4836
4837 static int img_dd(int argc, char **argv)
4838 {
4839     int ret = 0;
4840     char *arg = NULL;
4841     char *tmp;
4842     BlockDriver *drv = NULL, *proto_drv = NULL;
4843     BlockBackend *blk1 = NULL, *blk2 = NULL;
4844     QemuOpts *opts = NULL;
4845     QemuOptsList *create_opts = NULL;
4846     Error *local_err = NULL;
4847     bool image_opts = false;
4848     int c, i;
4849     const char *out_fmt = "raw";
4850     const char *fmt = NULL;
4851     int64_t size = 0;
4852     int64_t block_count = 0, out_pos, in_pos;
4853     bool force_share = false;
4854     struct DdInfo dd = {
4855         .flags = 0,
4856         .count = 0,
4857     };
4858     struct DdIo in = {
4859         .bsz = 512, /* Block size is by default 512 bytes */
4860         .filename = NULL,
4861         .buf = NULL,
4862         .offset = 0
4863     };
4864     struct DdIo out = {
4865         .bsz = 512,
4866         .filename = NULL,
4867         .buf = NULL,
4868         .offset = 0
4869     };
4870
4871     const struct DdOpts options[] = {
4872         { "bs", img_dd_bs, C_BS },
4873         { "count", img_dd_count, C_COUNT },
4874         { "if", img_dd_if, C_IF },
4875         { "of", img_dd_of, C_OF },
4876         { "skip", img_dd_skip, C_SKIP },
4877         { NULL, NULL, 0 }
4878     };
4879     const struct option long_options[] = {
4880         { "help", no_argument, 0, 'h'},
4881         { "object", required_argument, 0, OPTION_OBJECT},
4882         { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4883         { "force-share", no_argument, 0, 'U'},
4884         { 0, 0, 0, 0 }
4885     };
4886
4887     while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) {
4888         if (c == EOF) {
4889             break;
4890         }
4891         switch (c) {
4892         case 'O':
4893             out_fmt = optarg;
4894             break;
4895         case 'f':
4896             fmt = optarg;
4897             break;
4898         case ':':
4899             missing_argument(argv[optind - 1]);
4900             break;
4901         case '?':
4902             unrecognized_option(argv[optind - 1]);
4903             break;
4904         case 'h':
4905             help();
4906             break;
4907         case 'U':
4908             force_share = true;
4909             break;
4910         case OPTION_OBJECT:
4911             if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) {
4912                 ret = -1;
4913                 goto out;
4914             }
4915             break;
4916         case OPTION_IMAGE_OPTS:
4917             image_opts = true;
4918             break;
4919         }
4920     }
4921
4922     for (i = optind; i < argc; i++) {
4923         int j;
4924         arg = g_strdup(argv[i]);
4925
4926         tmp = strchr(arg, '=');
4927         if (tmp == NULL) {
4928             error_report("unrecognized operand %s", arg);
4929             ret = -1;
4930             goto out;
4931         }
4932
4933         *tmp++ = '\0';
4934
4935         for (j = 0; options[j].name != NULL; j++) {
4936             if (!strcmp(arg, options[j].name)) {
4937                 break;
4938             }
4939         }
4940         if (options[j].name == NULL) {
4941             error_report("unrecognized operand %s", arg);
4942             ret = -1;
4943             goto out;
4944         }
4945
4946         if (options[j].f(tmp, &in, &out, &dd) != 0) {
4947             ret = -1;
4948             goto out;
4949         }
4950         dd.flags |= options[j].flag;
4951         g_free(arg);
4952         arg = NULL;
4953     }
4954
4955     if (!(dd.flags & C_IF && dd.flags & C_OF)) {
4956         error_report("Must specify both input and output files");
4957         ret = -1;
4958         goto out;
4959     }
4960
4961     if (qemu_opts_foreach(&qemu_object_opts,
4962                           user_creatable_add_opts_foreach,
4963                           qemu_img_object_print_help, &error_fatal)) {
4964         ret = -1;
4965         goto out;
4966     }
4967
4968     blk1 = img_open(image_opts, in.filename, fmt, 0, false, false,
4969                     force_share);
4970
4971     if (!blk1) {
4972         ret = -1;
4973         goto out;
4974     }
4975
4976     drv = bdrv_find_format(out_fmt);
4977     if (!drv) {
4978         error_report("Unknown file format");
4979         ret = -1;
4980         goto out;
4981     }
4982     proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
4983
4984     if (!proto_drv) {
4985         error_report_err(local_err);
4986         ret = -1;
4987         goto out;
4988     }
4989     if (!drv->create_opts) {
4990         error_report("Format driver '%s' does not support image creation",
4991                      drv->format_name);
4992         ret = -1;
4993         goto out;
4994     }
4995     if (!proto_drv->create_opts) {
4996         error_report("Protocol driver '%s' does not support image creation",
4997                      proto_drv->format_name);
4998         ret = -1;
4999         goto out;
5000     }
5001     create_opts = qemu_opts_append(create_opts, drv->create_opts);
5002     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5003
5004     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5005
5006     size = blk_getlength(blk1);
5007     if (size < 0) {
5008         error_report("Failed to get size for '%s'", in.filename);
5009         ret = -1;
5010         goto out;
5011     }
5012
5013     if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz &&
5014         dd.count * in.bsz < size) {
5015         size = dd.count * in.bsz;
5016     }
5017
5018     /* Overflow means the specified offset is beyond input image's size */
5019     if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
5020                               size < in.bsz * in.offset)) {
5021         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort);
5022     } else {
5023         qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
5024                             size - in.bsz * in.offset, &error_abort);
5025     }
5026
5027     ret = bdrv_create(drv, out.filename, opts, &local_err);
5028     if (ret < 0) {
5029         error_reportf_err(local_err,
5030                           "%s: error while creating output image: ",
5031                           out.filename);
5032         ret = -1;
5033         goto out;
5034     }
5035
5036     /* TODO, we can't honour --image-opts for the target,
5037      * since it needs to be given in a format compatible
5038      * with the bdrv_create() call above which does not
5039      * support image-opts style.
5040      */
5041     blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR,
5042                          false, false, false);
5043
5044     if (!blk2) {
5045         ret = -1;
5046         goto out;
5047     }
5048
5049     if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
5050                               size < in.offset * in.bsz)) {
5051         /* We give a warning if the skip option is bigger than the input
5052          * size and create an empty output disk image (i.e. like dd(1)).
5053          */
5054         error_report("%s: cannot skip to specified offset", in.filename);
5055         in_pos = size;
5056     } else {
5057         in_pos = in.offset * in.bsz;
5058     }
5059
5060     in.buf = g_new(uint8_t, in.bsz);
5061
5062     for (out_pos = 0; in_pos < size; block_count++) {
5063         int in_ret, out_ret;
5064
5065         if (in_pos + in.bsz > size) {
5066             in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
5067         } else {
5068             in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
5069         }
5070         if (in_ret < 0) {
5071             error_report("error while reading from input image file: %s",
5072                          strerror(-in_ret));
5073             ret = -1;
5074             goto out;
5075         }
5076         in_pos += in_ret;
5077
5078         out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
5079
5080         if (out_ret < 0) {
5081             error_report("error while writing to output image file: %s",
5082                          strerror(-out_ret));
5083             ret = -1;
5084             goto out;
5085         }
5086         out_pos += out_ret;
5087     }
5088
5089 out:
5090     g_free(arg);
5091     qemu_opts_del(opts);
5092     qemu_opts_free(create_opts);
5093     blk_unref(blk1);
5094     blk_unref(blk2);
5095     g_free(in.filename);
5096     g_free(out.filename);
5097     g_free(in.buf);
5098     g_free(out.buf);
5099
5100     if (ret) {
5101         return 1;
5102     }
5103     return 0;
5104 }
5105
5106 static void dump_json_block_measure_info(BlockMeasureInfo *info)
5107 {
5108     QString *str;
5109     QObject *obj;
5110     Visitor *v = qobject_output_visitor_new(&obj);
5111
5112     visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort);
5113     visit_complete(v, &obj);
5114     str = qobject_to_json_pretty(obj);
5115     assert(str != NULL);
5116     printf("%s\n", qstring_get_str(str));
5117     qobject_unref(obj);
5118     visit_free(v);
5119     qobject_unref(str);
5120 }
5121
5122 static int img_measure(int argc, char **argv)
5123 {
5124     static const struct option long_options[] = {
5125         {"help", no_argument, 0, 'h'},
5126         {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
5127         {"object", required_argument, 0, OPTION_OBJECT},
5128         {"output", required_argument, 0, OPTION_OUTPUT},
5129         {"size", required_argument, 0, OPTION_SIZE},
5130         {"force-share", no_argument, 0, 'U'},
5131         {0, 0, 0, 0}
5132     };
5133     OutputFormat output_format = OFORMAT_HUMAN;
5134     BlockBackend *in_blk = NULL;
5135     BlockDriver *drv;
5136     const char *filename = NULL;
5137     const char *fmt = NULL;
5138     const char *out_fmt = "raw";
5139     char *options = NULL;
5140     char *snapshot_name = NULL;
5141     bool force_share = false;
5142     QemuOpts *opts = NULL;
5143     QemuOpts *object_opts = NULL;
5144     QemuOpts *sn_opts = NULL;
5145     QemuOptsList *create_opts = NULL;
5146     bool image_opts = false;
5147     uint64_t img_size = UINT64_MAX;
5148     BlockMeasureInfo *info = NULL;
5149     Error *local_err = NULL;
5150     int ret = 1;
5151     int c;
5152
5153     while ((c = getopt_long(argc, argv, "hf:O:o:l:U",
5154                             long_options, NULL)) != -1) {
5155         switch (c) {
5156         case '?':
5157         case 'h':
5158             help();
5159             break;
5160         case 'f':
5161             fmt = optarg;
5162             break;
5163         case 'O':
5164             out_fmt = optarg;
5165             break;
5166         case 'o':
5167             if (accumulate_options(&options, optarg) < 0) {
5168                 goto out;
5169             }
5170             break;
5171         case 'l':
5172             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
5173                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
5174                                                   optarg, false);
5175                 if (!sn_opts) {
5176                     error_report("Failed in parsing snapshot param '%s'",
5177                                  optarg);
5178                     goto out;
5179                 }
5180             } else {
5181                 snapshot_name = optarg;
5182             }
5183             break;
5184         case 'U':
5185             force_share = true;
5186             break;
5187         case OPTION_OBJECT:
5188             object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
5189                                                   optarg, true);
5190             if (!object_opts) {
5191                 goto out;
5192             }
5193             break;
5194         case OPTION_IMAGE_OPTS:
5195             image_opts = true;
5196             break;
5197         case OPTION_OUTPUT:
5198             if (!strcmp(optarg, "json")) {
5199                 output_format = OFORMAT_JSON;
5200             } else if (!strcmp(optarg, "human")) {
5201                 output_format = OFORMAT_HUMAN;
5202             } else {
5203                 error_report("--output must be used with human or json "
5204                              "as argument.");
5205                 goto out;
5206             }
5207             break;
5208         case OPTION_SIZE:
5209         {
5210             int64_t sval;
5211
5212             sval = cvtnum("image size", optarg);
5213             if (sval < 0) {
5214                 goto out;
5215             }
5216             img_size = (uint64_t)sval;
5217         }
5218         break;
5219         }
5220     }
5221
5222     if (qemu_opts_foreach(&qemu_object_opts,
5223                           user_creatable_add_opts_foreach,
5224                           qemu_img_object_print_help, &error_fatal)) {
5225         goto out;
5226     }
5227
5228     if (argc - optind > 1) {
5229         error_report("At most one filename argument is allowed.");
5230         goto out;
5231     } else if (argc - optind == 1) {
5232         filename = argv[optind];
5233     }
5234
5235     if (!filename && (image_opts || fmt || snapshot_name || sn_opts)) {
5236         error_report("--image-opts, -f, and -l require a filename argument.");
5237         goto out;
5238     }
5239     if (filename && img_size != UINT64_MAX) {
5240         error_report("--size N cannot be used together with a filename.");
5241         goto out;
5242     }
5243     if (!filename && img_size == UINT64_MAX) {
5244         error_report("Either --size N or one filename must be specified.");
5245         goto out;
5246     }
5247
5248     if (filename) {
5249         in_blk = img_open(image_opts, filename, fmt, 0,
5250                           false, false, force_share);
5251         if (!in_blk) {
5252             goto out;
5253         }
5254
5255         if (sn_opts) {
5256             bdrv_snapshot_load_tmp(blk_bs(in_blk),
5257                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
5258                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
5259                     &local_err);
5260         } else if (snapshot_name != NULL) {
5261             bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk),
5262                     snapshot_name, &local_err);
5263         }
5264         if (local_err) {
5265             error_reportf_err(local_err, "Failed to load snapshot: ");
5266             goto out;
5267         }
5268     }
5269
5270     drv = bdrv_find_format(out_fmt);
5271     if (!drv) {
5272         error_report("Unknown file format '%s'", out_fmt);
5273         goto out;
5274     }
5275     if (!drv->create_opts) {
5276         error_report("Format driver '%s' does not support image creation",
5277                      drv->format_name);
5278         goto out;
5279     }
5280
5281     create_opts = qemu_opts_append(create_opts, drv->create_opts);
5282     create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
5283     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5284     if (options) {
5285         qemu_opts_do_parse(opts, options, NULL, &local_err);
5286         if (local_err) {
5287             error_report_err(local_err);
5288             error_report("Invalid options for file format '%s'", out_fmt);
5289             goto out;
5290         }
5291     }
5292     if (img_size != UINT64_MAX) {
5293         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
5294     }
5295
5296     info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err);
5297     if (local_err) {
5298         error_report_err(local_err);
5299         goto out;
5300     }
5301
5302     if (output_format == OFORMAT_HUMAN) {
5303         printf("required size: %" PRIu64 "\n", info->required);
5304         printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated);
5305     } else {
5306         dump_json_block_measure_info(info);
5307     }
5308
5309     ret = 0;
5310
5311 out:
5312     qapi_free_BlockMeasureInfo(info);
5313     qemu_opts_del(object_opts);
5314     qemu_opts_del(opts);
5315     qemu_opts_del(sn_opts);
5316     qemu_opts_free(create_opts);
5317     g_free(options);
5318     blk_unref(in_blk);
5319     return ret;
5320 }
5321
5322 static const img_cmd_t img_cmds[] = {
5323 #define DEF(option, callback, arg_string)        \
5324     { option, callback },
5325 #include "qemu-img-cmds.h"
5326 #undef DEF
5327     { NULL, NULL, },
5328 };
5329
5330 int main(int argc, char **argv)
5331 {
5332     const img_cmd_t *cmd;
5333     const char *cmdname;
5334     Error *local_error = NULL;
5335     char *trace_file = NULL;
5336     int c;
5337     static const struct option long_options[] = {
5338         {"help", no_argument, 0, 'h'},
5339         {"version", no_argument, 0, 'V'},
5340         {"trace", required_argument, NULL, 'T'},
5341         {0, 0, 0, 0}
5342     };
5343
5344 #ifdef CONFIG_POSIX
5345     signal(SIGPIPE, SIG_IGN);
5346 #endif
5347
5348     error_init(argv[0]);
5349     module_call_init(MODULE_INIT_TRACE);
5350     qemu_init_exec_dir(argv[0]);
5351
5352     if (qemu_init_main_loop(&local_error)) {
5353         error_report_err(local_error);
5354         exit(EXIT_FAILURE);
5355     }
5356
5357     qcrypto_init(&error_fatal);
5358
5359     module_call_init(MODULE_INIT_QOM);
5360     bdrv_init();
5361     if (argc < 2) {
5362         error_exit("Not enough arguments");
5363     }
5364
5365     qemu_add_opts(&qemu_object_opts);
5366     qemu_add_opts(&qemu_source_opts);
5367     qemu_add_opts(&qemu_trace_opts);
5368
5369     while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) {
5370         switch (c) {
5371         case ':':
5372             missing_argument(argv[optind - 1]);
5373             return 0;
5374         case '?':
5375             unrecognized_option(argv[optind - 1]);
5376             return 0;
5377         case 'h':
5378             help();
5379             return 0;
5380         case 'V':
5381             printf(QEMU_IMG_VERSION);
5382             return 0;
5383         case 'T':
5384             g_free(trace_file);
5385             trace_file = trace_opt_parse(optarg);
5386             break;
5387         }
5388     }
5389
5390     cmdname = argv[optind];
5391
5392     /* reset getopt_long scanning */
5393     argc -= optind;
5394     if (argc < 1) {
5395         return 0;
5396     }
5397     argv += optind;
5398     qemu_reset_optind();
5399
5400     if (!trace_init_backends()) {
5401         exit(1);
5402     }
5403     trace_init_file(trace_file);
5404     qemu_set_log(LOG_TRACE);
5405
5406     /* find the command */
5407     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
5408         if (!strcmp(cmdname, cmd->name)) {
5409             return cmd->handler(argc, argv);
5410         }
5411     }
5412
5413     /* not found */
5414     error_exit("Command not found: %s", cmdname);
5415 }