qemu-img.c

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