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