qemu-img.c

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