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