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