qemu-img.c

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