qemu-img.c

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