qemu-img.c

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