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