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