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