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 "qapi-visit.h"
  25 #include "qapi/qmp-output-visitor.h"
  26 #include "qapi/qmp/qjson.h"
  27 #include "qemu-common.h"
  28 #include "qemu/option.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/osdep.h"
  31 #include "sysemu/sysemu.h"
  32 #include "sysemu/block-backend.h"
  33 #include "block/block_int.h"
  34 #include "block/blockjob.h"
  35 #include "block/qapi.h"
  36 #include <getopt.h>
  37
  38 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
  39                           ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  40
  41 typedef struct img_cmd_t {
  42     const char *name;
  43     int (*handler)(int argc, char **argv);
  44 } img_cmd_t;
  45
  46 enum {
  47     OPTION_OUTPUT = 256,
  48     OPTION_BACKING_CHAIN = 257,
  49 };
  50
  51 typedef enum OutputFormat {
  52     OFORMAT_JSON,
  53     OFORMAT_HUMAN,
  54 } OutputFormat;
  55
  56 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  57 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  58 #define BDRV_DEFAULT_CACHE "writeback"
  59
  60 static void format_print(void *opaque, const char *name)
  61 {
  62     printf(" %s", name);
  63 }
  64
  65 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
  66 {
  67     va_list ap;
  68
  69     error_printf("qemu-img: ");
  70
  71     va_start(ap, fmt);
  72     error_vprintf(fmt, ap);
  73     va_end(ap);
  74
  75     error_printf("\nTry 'qemu-img --help' for more information\n");
  76     exit(EXIT_FAILURE);
  77 }
  78
  79 /* Please keep in synch with qemu-img.texi */
  80 static void QEMU_NORETURN help(void)
  81 {
  82     const char *help_msg =
  83            QEMU_IMG_VERSION
  84            "usage: qemu-img command [command options]\n"
  85            "QEMU disk image utility\n"
  86            "\n"
  87            "Command syntax:\n"
  88 #define DEF(option, callback, arg_string)        \
  89            "  " arg_string "\n"
  90 #include "qemu-img-cmds.h"
  91 #undef DEF
  92 #undef GEN_DOCS
  93            "\n"
  94            "Command parameters:\n"
  95            "  'filename' is a disk image filename\n"
  96            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  97            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  98            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
  99            "    'directsync' and 'unsafe' (default for convert)\n"
 100            "  'src_cache' is the cache mode used to read input disk images, the valid\n"
 101            "    options are the same as for the 'cache' option\n"
 102            "  'size' is the disk image size in bytes. Optional suffixes\n"
 103            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
 104            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
 105            "    supported. 'b' is ignored.\n"
 106            "  'output_filename' is the destination disk image filename\n"
 107            "  'output_fmt' is the destination format\n"
 108            "  'options' is a comma separated list of format specific options in a\n"
 109            "    name=value format. Use -o ? for an overview of the options supported by the\n"
 110            "    used format\n"
 111            "  'snapshot_param' is param used for internal snapshot, format\n"
 112            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
 113            "    '[ID_OR_NAME]'\n"
 114            "  'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
 115            "    instead\n"
 116            "  '-c' indicates that target image must be compressed (qcow format only)\n"
 117            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
 118            "       match exactly. The image doesn't need a working backing file before\n"
 119            "       rebasing in this case (useful for renaming the backing file)\n"
 120            "  '-h' with or without a command shows this help and lists the supported formats\n"
 121            "  '-p' show progress of command (only certain commands)\n"
 122            "  '-q' use Quiet mode - do not print any output (except errors)\n"
 123            "  '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
 124            "       contain only zeros for qemu-img to create a sparse image during\n"
 125            "       conversion. If the number of bytes is 0, the source will not be scanned for\n"
 126            "       unallocated or zero sectors, and the destination image will always be\n"
 127            "       fully allocated\n"
 128            "  '--output' takes the format in which the output must be done (human or json)\n"
 129            "  '-n' skips the target volume creation (useful if the volume is created\n"
 130            "       prior to running qemu-img)\n"
 131            "\n"
 132            "Parameters to check subcommand:\n"
 133            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
 134            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
 135            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
 136            "       hiding corruption that has already occurred.\n"
 137            "\n"
 138            "Parameters to snapshot subcommand:\n"
 139            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 140            "  '-a' applies a snapshot (revert disk to saved state)\n"
 141            "  '-c' creates a snapshot\n"
 142            "  '-d' deletes a snapshot\n"
 143            "  '-l' lists all snapshots in the given image\n"
 144            "\n"
 145            "Parameters to compare subcommand:\n"
 146            "  '-f' first image format\n"
 147            "  '-F' second image format\n"
 148            "  '-s' run in Strict mode - fail on different image size or sector allocation\n";
 149
 150     printf("%s\nSupported formats:", help_msg);
 151     bdrv_iterate_format(format_print, NULL);
 152     printf("\n");
 153     exit(EXIT_SUCCESS);
 154 }
 155
 156 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
 157 {
 158     int ret = 0;
 159     if (!quiet) {
 160         va_list args;
 161         va_start(args, fmt);
 162         ret = vprintf(fmt, args);
 163         va_end(args);
 164     }
 165     return ret;
 166 }
 167
 168
 169 static int print_block_option_help(const char *filename, const char *fmt)
 170 {
 171     BlockDriver *drv, *proto_drv;
 172     QemuOptsList *create_opts = NULL;
 173     Error *local_err = NULL;
 174
 175     /* Find driver and parse its options */
 176     drv = bdrv_find_format(fmt);
 177     if (!drv) {
 178         error_report("Unknown file format '%s'", fmt);
 179         return 1;
 180     }
 181
 182     create_opts = qemu_opts_append(create_opts, drv->create_opts);
 183     if (filename) {
 184         proto_drv = bdrv_find_protocol(filename, true, &local_err);
 185         if (!proto_drv) {
 186             error_report_err(local_err);
 187             qemu_opts_free(create_opts);
 188             return 1;
 189         }
 190         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 191     }
 192
 193     qemu_opts_print_help(create_opts);
 194     qemu_opts_free(create_opts);
 195     return 0;
 196 }
 197
 198 static BlockBackend *img_open(const char *id, const char *filename,
 199                               const char *fmt, int flags,
 200                               bool require_io, bool quiet)
 201 {
 202     BlockBackend *blk;
 203     BlockDriverState *bs;
 204     char password[256];
 205     Error *local_err = NULL;
 206     QDict *options = NULL;
 207
 208     if (fmt) {
 209         options = qdict_new();
 210         qdict_put(options, "driver", qstring_from_str(fmt));
 211     }
 212
 213     blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
 214     if (!blk) {
 215         error_report("Could not open '%s': %s", filename,
 216                      error_get_pretty(local_err));
 217         error_free(local_err);
 218         goto fail;
 219     }
 220
 221     bs = blk_bs(blk);
 222     if (bdrv_is_encrypted(bs) && require_io) {
 223         qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
 224         if (qemu_read_password(password, sizeof(password)) < 0) {
 225             error_report("No password given");
 226             goto fail;
 227         }
 228         if (bdrv_set_key(bs, password) < 0) {
 229             error_report("invalid password");
 230             goto fail;
 231         }
 232     }
 233     return blk;
 234 fail:
 235     blk_unref(blk);
 236     return NULL;
 237 }
 238
 239 static int add_old_style_options(const char *fmt, QemuOpts *opts,
 240                                  const char *base_filename,
 241                                  const char *base_fmt)
 242 {
 243     Error *err = NULL;
 244
 245     if (base_filename) {
 246         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
 247         if (err) {
 248             error_report("Backing file not supported for file format '%s'",
 249                          fmt);
 250             error_free(err);
 251             return -1;
 252         }
 253     }
 254     if (base_fmt) {
 255         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
 256         if (err) {
 257             error_report("Backing file format not supported for file "
 258                          "format '%s'", fmt);
 259             error_free(err);
 260             return -1;
 261         }
 262     }
 263     return 0;
 264 }
 265
 266 static int img_create(int argc, char **argv)
 267 {
 268     int c;
 269     uint64_t img_size = -1;
 270     const char *fmt = "raw";
 271     const char *base_fmt = NULL;
 272     const char *filename;
 273     const char *base_filename = NULL;
 274     char *options = NULL;
 275     Error *local_err = NULL;
 276     bool quiet = false;
 277
 278     for(;;) {
 279         c = getopt(argc, argv, "F:b:f:he6o:q");
 280         if (c == -1) {
 281             break;
 282         }
 283         switch(c) {
 284         case '?':
 285         case 'h':
 286             help();
 287             break;
 288         case 'F':
 289             base_fmt = optarg;
 290             break;
 291         case 'b':
 292             base_filename = optarg;
 293             break;
 294         case 'f':
 295             fmt = optarg;
 296             break;
 297         case 'e':
 298             error_report("option -e is deprecated, please use \'-o "
 299                   "encryption\' instead!");
 300             goto fail;
 301         case '6':
 302             error_report("option -6 is deprecated, please use \'-o "
 303                   "compat6\' instead!");
 304             goto fail;
 305         case 'o':
 306             if (!is_valid_option_list(optarg)) {
 307                 error_report("Invalid option list: %s", optarg);
 308                 goto fail;
 309             }
 310             if (!options) {
 311                 options = g_strdup(optarg);
 312             } else {
 313                 char *old_options = options;
 314                 options = g_strdup_printf("%s,%s", options, optarg);
 315                 g_free(old_options);
 316             }
 317             break;
 318         case 'q':
 319             quiet = true;
 320             break;
 321         }
 322     }
 323
 324     /* Get the filename */
 325     filename = (optind < argc) ? argv[optind] : NULL;
 326     if (options && has_help_option(options)) {
 327         g_free(options);
 328         return print_block_option_help(filename, fmt);
 329     }
 330
 331     if (optind >= argc) {
 332         error_exit("Expecting image file name");
 333     }
 334     optind++;
 335
 336     /* Get image size, if specified */
 337     if (optind < argc) {
 338         int64_t sval;
 339         char *end;
 340         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 341         if (sval < 0 || *end) {
 342             if (sval == -ERANGE) {
 343                 error_report("Image size must be less than 8 EiB!");
 344             } else {
 345                 error_report("Invalid image size specified! You may use k, M, "
 346                       "G, T, P or E suffixes for ");
 347                 error_report("kilobytes, megabytes, gigabytes, terabytes, "
 348                              "petabytes and exabytes.");
 349             }
 350             goto fail;
 351         }
 352         img_size = (uint64_t)sval;
 353     }
 354     if (optind != argc) {
 355         error_exit("Unexpected argument: %s", argv[optind]);
 356     }
 357
 358     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 359                     options, img_size, BDRV_O_FLAGS, &local_err, quiet);
 360     if (local_err) {
 361         error_report("%s: %s", filename, error_get_pretty(local_err));
 362         error_free(local_err);
 363         goto fail;
 364     }
 365
 366     g_free(options);
 367     return 0;
 368
 369 fail:
 370     g_free(options);
 371     return 1;
 372 }
 373
 374 static void dump_json_image_check(ImageCheck *check, bool quiet)
 375 {
 376     Error *local_err = NULL;
 377     QString *str;
 378     QmpOutputVisitor *ov = qmp_output_visitor_new();
 379     QObject *obj;
 380     visit_type_ImageCheck(qmp_output_get_visitor(ov),
 381                           &check, NULL, &local_err);
 382     obj = qmp_output_get_qobject(ov);
 383     str = qobject_to_json_pretty(obj);
 384     assert(str != NULL);
 385     qprintf(quiet, "%s\n", qstring_get_str(str));
 386     qobject_decref(obj);
 387     qmp_output_visitor_cleanup(ov);
 388     QDECREF(str);
 389 }
 390
 391 static void dump_human_image_check(ImageCheck *check, bool quiet)
 392 {
 393     if (!(check->corruptions || check->leaks || check->check_errors)) {
 394         qprintf(quiet, "No errors were found on the image.\n");
 395     } else {
 396         if (check->corruptions) {
 397             qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
 398                     "Data may be corrupted, or further writes to the image "
 399                     "may corrupt it.\n",
 400                     check->corruptions);
 401         }
 402
 403         if (check->leaks) {
 404             qprintf(quiet,
 405                     "\n%" PRId64 " leaked clusters were found on the image.\n"
 406                     "This means waste of disk space, but no harm to data.\n",
 407                     check->leaks);
 408         }
 409
 410         if (check->check_errors) {
 411             qprintf(quiet,
 412                     "\n%" PRId64
 413                     " internal errors have occurred during the check.\n",
 414                     check->check_errors);
 415         }
 416     }
 417
 418     if (check->total_clusters != 0 && check->allocated_clusters != 0) {
 419         qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
 420                 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
 421                 check->allocated_clusters, check->total_clusters,
 422                 check->allocated_clusters * 100.0 / check->total_clusters,
 423                 check->fragmented_clusters * 100.0 / check->allocated_clusters,
 424                 check->compressed_clusters * 100.0 /
 425                 check->allocated_clusters);
 426     }
 427
 428     if (check->image_end_offset) {
 429         qprintf(quiet,
 430                 "Image end offset: %" PRId64 "\n", check->image_end_offset);
 431     }
 432 }
 433
 434 static int collect_image_check(BlockDriverState *bs,
 435                    ImageCheck *check,
 436                    const char *filename,
 437                    const char *fmt,
 438                    int fix)
 439 {
 440     int ret;
 441     BdrvCheckResult result;
 442
 443     ret = bdrv_check(bs, &result, fix);
 444     if (ret < 0) {
 445         return ret;
 446     }
 447
 448     check->filename                 = g_strdup(filename);
 449     check->format                   = g_strdup(bdrv_get_format_name(bs));
 450     check->check_errors             = result.check_errors;
 451     check->corruptions              = result.corruptions;
 452     check->has_corruptions          = result.corruptions != 0;
 453     check->leaks                    = result.leaks;
 454     check->has_leaks                = result.leaks != 0;
 455     check->corruptions_fixed        = result.corruptions_fixed;
 456     check->has_corruptions_fixed    = result.corruptions != 0;
 457     check->leaks_fixed              = result.leaks_fixed;
 458     check->has_leaks_fixed          = result.leaks != 0;
 459     check->image_end_offset         = result.image_end_offset;
 460     check->has_image_end_offset     = result.image_end_offset != 0;
 461     check->total_clusters           = result.bfi.total_clusters;
 462     check->has_total_clusters       = result.bfi.total_clusters != 0;
 463     check->allocated_clusters       = result.bfi.allocated_clusters;
 464     check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
 465     check->fragmented_clusters      = result.bfi.fragmented_clusters;
 466     check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
 467     check->compressed_clusters      = result.bfi.compressed_clusters;
 468     check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
 469
 470     return 0;
 471 }
 472
 473 /*
 474  * Checks an image for consistency. Exit codes:
 475  *
 476  *  0 - Check completed, image is good
 477  *  1 - Check not completed because of internal errors
 478  *  2 - Check completed, image is corrupted
 479  *  3 - Check completed, image has leaked clusters, but is good otherwise
 480  * 63 - Checks are not supported by the image format
 481  */
 482 static int img_check(int argc, char **argv)
 483 {
 484     int c, ret;
 485     OutputFormat output_format = OFORMAT_HUMAN;
 486     const char *filename, *fmt, *output, *cache;
 487     BlockBackend *blk;
 488     BlockDriverState *bs;
 489     int fix = 0;
 490     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 491     ImageCheck *check;
 492     bool quiet = false;
 493
 494     fmt = NULL;
 495     output = NULL;
 496     cache = BDRV_DEFAULT_CACHE;
 497     for(;;) {
 498         int option_index = 0;
 499         static const struct option long_options[] = {
 500             {"help", no_argument, 0, 'h'},
 501             {"format", required_argument, 0, 'f'},
 502             {"repair", required_argument, 0, 'r'},
 503             {"output", required_argument, 0, OPTION_OUTPUT},
 504             {0, 0, 0, 0}
 505         };
 506         c = getopt_long(argc, argv, "hf:r:T:q",
 507                         long_options, &option_index);
 508         if (c == -1) {
 509             break;
 510         }
 511         switch(c) {
 512         case '?':
 513         case 'h':
 514             help();
 515             break;
 516         case 'f':
 517             fmt = optarg;
 518             break;
 519         case 'r':
 520             flags |= BDRV_O_RDWR;
 521
 522             if (!strcmp(optarg, "leaks")) {
 523                 fix = BDRV_FIX_LEAKS;
 524             } else if (!strcmp(optarg, "all")) {
 525                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 526             } else {
 527                 error_exit("Unknown option value for -r "
 528                            "(expecting 'leaks' or 'all'): %s", optarg);
 529             }
 530             break;
 531         case OPTION_OUTPUT:
 532             output = optarg;
 533             break;
 534         case 'T':
 535             cache = optarg;
 536             break;
 537         case 'q':
 538             quiet = true;
 539             break;
 540         }
 541     }
 542     if (optind != argc - 1) {
 543         error_exit("Expecting one image file name");
 544     }
 545     filename = argv[optind++];
 546
 547     if (output && !strcmp(output, "json")) {
 548         output_format = OFORMAT_JSON;
 549     } else if (output && !strcmp(output, "human")) {
 550         output_format = OFORMAT_HUMAN;
 551     } else if (output) {
 552         error_report("--output must be used with human or json as argument.");
 553         return 1;
 554     }
 555
 556     ret = bdrv_parse_cache_flags(cache, &flags);
 557     if (ret < 0) {
 558         error_report("Invalid source cache option: %s", cache);
 559         return 1;
 560     }
 561
 562     blk = img_open("image", filename, fmt, flags, true, quiet);
 563     if (!blk) {
 564         return 1;
 565     }
 566     bs = blk_bs(blk);
 567
 568     check = g_new0(ImageCheck, 1);
 569     ret = collect_image_check(bs, check, filename, fmt, fix);
 570
 571     if (ret == -ENOTSUP) {
 572         error_report("This image format does not support checks");
 573         ret = 63;
 574         goto fail;
 575     }
 576
 577     if (check->corruptions_fixed || check->leaks_fixed) {
 578         int corruptions_fixed, leaks_fixed;
 579
 580         leaks_fixed         = check->leaks_fixed;
 581         corruptions_fixed   = check->corruptions_fixed;
 582
 583         if (output_format == OFORMAT_HUMAN) {
 584             qprintf(quiet,
 585                     "The following inconsistencies were found and repaired:\n\n"
 586                     "    %" PRId64 " leaked clusters\n"
 587                     "    %" PRId64 " corruptions\n\n"
 588                     "Double checking the fixed image now...\n",
 589                     check->leaks_fixed,
 590                     check->corruptions_fixed);
 591         }
 592
 593         ret = collect_image_check(bs, check, filename, fmt, 0);
 594
 595         check->leaks_fixed          = leaks_fixed;
 596         check->corruptions_fixed    = corruptions_fixed;
 597     }
 598
 599     if (!ret) {
 600         switch (output_format) {
 601         case OFORMAT_HUMAN:
 602             dump_human_image_check(check, quiet);
 603             break;
 604         case OFORMAT_JSON:
 605             dump_json_image_check(check, quiet);
 606             break;
 607         }
 608     }
 609
 610     if (ret || check->check_errors) {
 611         if (ret) {
 612             error_report("Check failed: %s", strerror(-ret));
 613         } else {
 614             error_report("Check failed");
 615         }
 616         ret = 1;
 617         goto fail;
 618     }
 619
 620     if (check->corruptions) {
 621         ret = 2;
 622     } else if (check->leaks) {
 623         ret = 3;
 624     } else {
 625         ret = 0;
 626     }
 627
 628 fail:
 629     qapi_free_ImageCheck(check);
 630     blk_unref(blk);
 631     return ret;
 632 }
 633
 634 typedef struct CommonBlockJobCBInfo {
 635     BlockDriverState *bs;
 636     Error **errp;
 637 } CommonBlockJobCBInfo;
 638
 639 static void common_block_job_cb(void *opaque, int ret)
 640 {
 641     CommonBlockJobCBInfo *cbi = opaque;
 642
 643     if (ret < 0) {
 644         error_setg_errno(cbi->errp, -ret, "Block job failed");
 645     }
 646
 647     /* Drop this block job's reference */
 648     bdrv_unref(cbi->bs);
 649 }
 650
 651 static void run_block_job(BlockJob *job, Error **errp)
 652 {
 653     AioContext *aio_context = bdrv_get_aio_context(job->bs);
 654
 655     do {
 656         aio_poll(aio_context, true);
 657         qemu_progress_print((float)job->offset / job->len * 100.f, 0);
 658     } while (!job->ready);
 659
 660     block_job_complete_sync(job, errp);
 661
 662     /* A block job may finish instantaneously without publishing any progress,
 663      * so just signal completion here */
 664     qemu_progress_print(100.f, 0);
 665 }
 666
 667 static int img_commit(int argc, char **argv)
 668 {
 669     int c, ret, flags;
 670     const char *filename, *fmt, *cache, *base;
 671     BlockBackend *blk;
 672     BlockDriverState *bs, *base_bs;
 673     bool progress = false, quiet = false, drop = false;
 674     Error *local_err = NULL;
 675     CommonBlockJobCBInfo cbi;
 676
 677     fmt = NULL;
 678     cache = BDRV_DEFAULT_CACHE;
 679     base = NULL;
 680     for(;;) {
 681         c = getopt(argc, argv, "f:ht:b:dpq");
 682         if (c == -1) {
 683             break;
 684         }
 685         switch(c) {
 686         case '?':
 687         case 'h':
 688             help();
 689             break;
 690         case 'f':
 691             fmt = optarg;
 692             break;
 693         case 't':
 694             cache = optarg;
 695             break;
 696         case 'b':
 697             base = optarg;
 698             /* -b implies -d */
 699             drop = true;
 700             break;
 701         case 'd':
 702             drop = true;
 703             break;
 704         case 'p':
 705             progress = true;
 706             break;
 707         case 'q':
 708             quiet = true;
 709             break;
 710         }
 711     }
 712
 713     /* Progress is not shown in Quiet mode */
 714     if (quiet) {
 715         progress = false;
 716     }
 717
 718     if (optind != argc - 1) {
 719         error_exit("Expecting one image file name");
 720     }
 721     filename = argv[optind++];
 722
 723     flags = BDRV_O_RDWR | BDRV_O_UNMAP;
 724     ret = bdrv_parse_cache_flags(cache, &flags);
 725     if (ret < 0) {
 726         error_report("Invalid cache option: %s", cache);
 727         return 1;
 728     }
 729
 730     blk = img_open("image", filename, fmt, flags, true, quiet);
 731     if (!blk) {
 732         return 1;
 733     }
 734     bs = blk_bs(blk);
 735
 736     qemu_progress_init(progress, 1.f);
 737     qemu_progress_print(0.f, 100);
 738
 739     if (base) {
 740         base_bs = bdrv_find_backing_image(bs, base);
 741         if (!base_bs) {
 742             error_set(&local_err, QERR_BASE_NOT_FOUND, base);
 743             goto done;
 744         }
 745     } else {
 746         /* This is different from QMP, which by default uses the deepest file in
 747          * the backing chain (i.e., the very base); however, the traditional
 748          * behavior of qemu-img commit is using the immediate backing file. */
 749         base_bs = bs->backing_hd;
 750         if (!base_bs) {
 751             error_setg(&local_err, "Image does not have a backing file");
 752             goto done;
 753         }
 754     }
 755
 756     cbi = (CommonBlockJobCBInfo){
 757         .errp = &local_err,
 758         .bs   = bs,
 759     };
 760
 761     commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
 762                         common_block_job_cb, &cbi, &local_err);
 763     if (local_err) {
 764         goto done;
 765     }
 766
 767     /* The block job will swap base_bs and bs (which is not what we really want
 768      * here, but okay) and unref base_bs (after the swap, i.e., the old top
 769      * image). In order to still be able to empty that top image afterwards,
 770      * increment the reference counter here preemptively. */
 771     if (!drop) {
 772         bdrv_ref(base_bs);
 773     }
 774
 775     run_block_job(bs->job, &local_err);
 776     if (local_err) {
 777         goto unref_backing;
 778     }
 779
 780     if (!drop && base_bs->drv->bdrv_make_empty) {
 781         ret = base_bs->drv->bdrv_make_empty(base_bs);
 782         if (ret) {
 783             error_setg_errno(&local_err, -ret, "Could not empty %s",
 784                              filename);
 785             goto unref_backing;
 786         }
 787     }
 788
 789 unref_backing:
 790     if (!drop) {
 791         bdrv_unref(base_bs);
 792     }
 793
 794 done:
 795     qemu_progress_end();
 796
 797     blk_unref(blk);
 798
 799     if (local_err) {
 800         error_report_err(local_err);
 801         return 1;
 802     }
 803
 804     qprintf(quiet, "Image committed.\n");
 805     return 0;
 806 }
 807
 808 /*
 809  * Returns true iff the first sector pointed to by 'buf' contains at least
 810  * a non-NUL byte.
 811  *
 812  * 'pnum' is set to the number of sectors (including and immediately following
 813  * the first one) that are known to be in the same allocated/unallocated state.
 814  */
 815 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 816 {
 817     bool is_zero;
 818     int i;
 819
 820     if (n <= 0) {
 821         *pnum = 0;
 822         return 0;
 823     }
 824     is_zero = buffer_is_zero(buf, 512);
 825     for(i = 1; i < n; i++) {
 826         buf += 512;
 827         if (is_zero != buffer_is_zero(buf, 512)) {
 828             break;
 829         }
 830     }
 831     *pnum = i;
 832     return !is_zero;
 833 }
 834
 835 /*
 836  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 837  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 838  * breaking up write requests for only small sparse areas.
 839  */
 840 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 841     int min)
 842 {
 843     int ret;
 844     int num_checked, num_used;
 845
 846     if (n < min) {
 847         min = n;
 848     }
 849
 850     ret = is_allocated_sectors(buf, n, pnum);
 851     if (!ret) {
 852         return ret;
 853     }
 854
 855     num_used = *pnum;
 856     buf += BDRV_SECTOR_SIZE * *pnum;
 857     n -= *pnum;
 858     num_checked = num_used;
 859
 860     while (n > 0) {
 861         ret = is_allocated_sectors(buf, n, pnum);
 862
 863         buf += BDRV_SECTOR_SIZE * *pnum;
 864         n -= *pnum;
 865         num_checked += *pnum;
 866         if (ret) {
 867             num_used = num_checked;
 868         } else if (*pnum >= min) {
 869             break;
 870         }
 871     }
 872
 873     *pnum = num_used;
 874     return 1;
 875 }
 876
 877 /*
 878  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 879  * buffers matches, non-zero otherwise.
 880  *
 881  * pnum is set to the number of sectors (including and immediately following
 882  * the first one) that are known to have the same comparison result
 883  */
 884 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 885     int *pnum)
 886 {
 887     bool res;
 888     int i;
 889
 890     if (n <= 0) {
 891         *pnum = 0;
 892         return 0;
 893     }
 894
 895     res = !!memcmp(buf1, buf2, 512);
 896     for(i = 1; i < n; i++) {
 897         buf1 += 512;
 898         buf2 += 512;
 899
 900         if (!!memcmp(buf1, buf2, 512) != res) {
 901             break;
 902         }
 903     }
 904
 905     *pnum = i;
 906     return res;
 907 }
 908
 909 #define IO_BUF_SIZE (2 * 1024 * 1024)
 910
 911 static int64_t sectors_to_bytes(int64_t sectors)
 912 {
 913     return sectors << BDRV_SECTOR_BITS;
 914 }
 915
 916 static int64_t sectors_to_process(int64_t total, int64_t from)
 917 {
 918     return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
 919 }
 920
 921 /*
 922  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
 923  *
 924  * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
 925  * data and negative value on error.
 926  *
 927  * @param blk:  BlockBackend for the image
 928  * @param sect_num: Number of first sector to check
 929  * @param sect_count: Number of sectors to check
 930  * @param filename: Name of disk file we are checking (logging purpose)
 931  * @param buffer: Allocated buffer for storing read data
 932  * @param quiet: Flag for quiet mode
 933  */
 934 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
 935                                int sect_count, const char *filename,
 936                                uint8_t *buffer, bool quiet)
 937 {
 938     int pnum, ret = 0;
 939     ret = blk_read(blk, sect_num, buffer, sect_count);
 940     if (ret < 0) {
 941         error_report("Error while reading offset %" PRId64 " of %s: %s",
 942                      sectors_to_bytes(sect_num), filename, strerror(-ret));
 943         return ret;
 944     }
 945     ret = is_allocated_sectors(buffer, sect_count, &pnum);
 946     if (ret || pnum != sect_count) {
 947         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
 948                 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
 949         return 1;
 950     }
 951
 952     return 0;
 953 }
 954
 955 /*
 956  * Compares two images. Exit codes:
 957  *
 958  * 0 - Images are identical
 959  * 1 - Images differ
 960  * >1 - Error occurred
 961  */
 962 static int img_compare(int argc, char **argv)
 963 {
 964     const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
 965     BlockBackend *blk1, *blk2;
 966     BlockDriverState *bs1, *bs2;
 967     int64_t total_sectors1, total_sectors2;
 968     uint8_t *buf1 = NULL, *buf2 = NULL;
 969     int pnum1, pnum2;
 970     int allocated1, allocated2;
 971     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
 972     bool progress = false, quiet = false, strict = false;
 973     int flags;
 974     int64_t total_sectors;
 975     int64_t sector_num = 0;
 976     int64_t nb_sectors;
 977     int c, pnum;
 978     uint64_t progress_base;
 979
 980     cache = BDRV_DEFAULT_CACHE;
 981     for (;;) {
 982         c = getopt(argc, argv, "hf:F:T:pqs");
 983         if (c == -1) {
 984             break;
 985         }
 986         switch (c) {
 987         case '?':
 988         case 'h':
 989             help();
 990             break;
 991         case 'f':
 992             fmt1 = optarg;
 993             break;
 994         case 'F':
 995             fmt2 = optarg;
 996             break;
 997         case 'T':
 998             cache = optarg;
 999             break;
1000         case 'p':
1001             progress = true;
1002             break;
1003         case 'q':
1004             quiet = true;
1005             break;
1006         case 's':
1007             strict = true;
1008             break;
1009         }
1010     }
1011
1012     /* Progress is not shown in Quiet mode */
1013     if (quiet) {
1014         progress = false;
1015     }
1016
1017
1018     if (optind != argc - 2) {
1019         error_exit("Expecting two image file names");
1020     }
1021     filename1 = argv[optind++];
1022     filename2 = argv[optind++];
1023
1024     /* Initialize before goto out */
1025     qemu_progress_init(progress, 2.0);
1026
1027     flags = BDRV_O_FLAGS;
1028     ret = bdrv_parse_cache_flags(cache, &flags);
1029     if (ret < 0) {
1030         error_report("Invalid source cache option: %s", cache);
1031         ret = 2;
1032         goto out3;
1033     }
1034
1035     blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
1036     if (!blk1) {
1037         ret = 2;
1038         goto out3;
1039     }
1040     bs1 = blk_bs(blk1);
1041
1042     blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
1043     if (!blk2) {
1044         ret = 2;
1045         goto out2;
1046     }
1047     bs2 = blk_bs(blk2);
1048
1049     buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1050     buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1051     total_sectors1 = blk_nb_sectors(blk1);
1052     if (total_sectors1 < 0) {
1053         error_report("Can't get size of %s: %s",
1054                      filename1, strerror(-total_sectors1));
1055         ret = 4;
1056         goto out;
1057     }
1058     total_sectors2 = blk_nb_sectors(blk2);
1059     if (total_sectors2 < 0) {
1060         error_report("Can't get size of %s: %s",
1061                      filename2, strerror(-total_sectors2));
1062         ret = 4;
1063         goto out;
1064     }
1065     total_sectors = MIN(total_sectors1, total_sectors2);
1066     progress_base = MAX(total_sectors1, total_sectors2);
1067
1068     qemu_progress_print(0, 100);
1069
1070     if (strict && total_sectors1 != total_sectors2) {
1071         ret = 1;
1072         qprintf(quiet, "Strict mode: Image size mismatch!\n");
1073         goto out;
1074     }
1075
1076     for (;;) {
1077         nb_sectors = sectors_to_process(total_sectors, sector_num);
1078         if (nb_sectors <= 0) {
1079             break;
1080         }
1081         allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
1082                                              &pnum1);
1083         if (allocated1 < 0) {
1084             ret = 3;
1085             error_report("Sector allocation test failed for %s", filename1);
1086             goto out;
1087         }
1088
1089         allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
1090                                              &pnum2);
1091         if (allocated2 < 0) {
1092             ret = 3;
1093             error_report("Sector allocation test failed for %s", filename2);
1094             goto out;
1095         }
1096         nb_sectors = MIN(pnum1, pnum2);
1097
1098         if (allocated1 == allocated2) {
1099             if (allocated1) {
1100                 ret = blk_read(blk1, sector_num, buf1, nb_sectors);
1101                 if (ret < 0) {
1102                     error_report("Error while reading offset %" PRId64 " of %s:"
1103                                  " %s", sectors_to_bytes(sector_num), filename1,
1104                                  strerror(-ret));
1105                     ret = 4;
1106                     goto out;
1107                 }
1108                 ret = blk_read(blk2, sector_num, buf2, nb_sectors);
1109                 if (ret < 0) {
1110                     error_report("Error while reading offset %" PRId64
1111                                  " of %s: %s", sectors_to_bytes(sector_num),
1112                                  filename2, strerror(-ret));
1113                     ret = 4;
1114                     goto out;
1115                 }
1116                 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1117                 if (ret || pnum != nb_sectors) {
1118                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1119                             sectors_to_bytes(
1120                                 ret ? sector_num : sector_num + pnum));
1121                     ret = 1;
1122                     goto out;
1123                 }
1124             }
1125         } else {
1126             if (strict) {
1127                 ret = 1;
1128                 qprintf(quiet, "Strict mode: Offset %" PRId64
1129                         " allocation mismatch!\n",
1130                         sectors_to_bytes(sector_num));
1131                 goto out;
1132             }
1133
1134             if (allocated1) {
1135                 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1136                                           filename1, buf1, quiet);
1137             } else {
1138                 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1139                                           filename2, buf1, quiet);
1140             }
1141             if (ret) {
1142                 if (ret < 0) {
1143                     error_report("Error while reading offset %" PRId64 ": %s",
1144                                  sectors_to_bytes(sector_num), strerror(-ret));
1145                     ret = 4;
1146                 }
1147                 goto out;
1148             }
1149         }
1150         sector_num += nb_sectors;
1151         qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1152     }
1153
1154     if (total_sectors1 != total_sectors2) {
1155         BlockBackend *blk_over;
1156         int64_t total_sectors_over;
1157         const char *filename_over;
1158
1159         qprintf(quiet, "Warning: Image size mismatch!\n");
1160         if (total_sectors1 > total_sectors2) {
1161             total_sectors_over = total_sectors1;
1162             blk_over = blk1;
1163             filename_over = filename1;
1164         } else {
1165             total_sectors_over = total_sectors2;
1166             blk_over = blk2;
1167             filename_over = filename2;
1168         }
1169
1170         for (;;) {
1171             nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1172             if (nb_sectors <= 0) {
1173                 break;
1174             }
1175             ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
1176                                           nb_sectors, &pnum);
1177             if (ret < 0) {
1178                 ret = 3;
1179                 error_report("Sector allocation test failed for %s",
1180                              filename_over);
1181                 goto out;
1182
1183             }
1184             nb_sectors = pnum;
1185             if (ret) {
1186                 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1187                                           filename_over, buf1, quiet);
1188                 if (ret) {
1189                     if (ret < 0) {
1190                         error_report("Error while reading offset %" PRId64
1191                                      " of %s: %s", sectors_to_bytes(sector_num),
1192                                      filename_over, strerror(-ret));
1193                         ret = 4;
1194                     }
1195                     goto out;
1196                 }
1197             }
1198             sector_num += nb_sectors;
1199             qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1200         }
1201     }
1202
1203     qprintf(quiet, "Images are identical.\n");
1204     ret = 0;
1205
1206 out:
1207     qemu_vfree(buf1);
1208     qemu_vfree(buf2);
1209     blk_unref(blk2);
1210 out2:
1211     blk_unref(blk1);
1212 out3:
1213     qemu_progress_end();
1214     return ret;
1215 }
1216
1217 enum ImgConvertBlockStatus {
1218     BLK_DATA,
1219     BLK_ZERO,
1220     BLK_BACKING_FILE,
1221 };
1222
1223 typedef struct ImgConvertState {
1224     BlockBackend **src;
1225     int64_t *src_sectors;
1226     int src_cur, src_num;
1227     int64_t src_cur_offset;
1228     int64_t total_sectors;
1229     int64_t allocated_sectors;
1230     enum ImgConvertBlockStatus status;
1231     int64_t sector_next_status;
1232     BlockBackend *target;
1233     bool has_zero_init;
1234     bool compressed;
1235     bool target_has_backing;
1236     int min_sparse;
1237     size_t cluster_sectors;
1238     size_t buf_sectors;
1239 } ImgConvertState;
1240
1241 static void convert_select_part(ImgConvertState *s, int64_t sector_num)
1242 {
1243     assert(sector_num >= s->src_cur_offset);
1244     while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
1245         s->src_cur_offset += s->src_sectors[s->src_cur];
1246         s->src_cur++;
1247         assert(s->src_cur < s->src_num);
1248     }
1249 }
1250
1251 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1252 {
1253     int64_t ret;
1254     int n;
1255
1256     convert_select_part(s, sector_num);
1257
1258     assert(s->total_sectors > sector_num);
1259     n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1260
1261     if (s->sector_next_status <= sector_num) {
1262         ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
1263                                     sector_num - s->src_cur_offset,
1264                                     n, &n);
1265         if (ret < 0) {
1266             return ret;
1267         }
1268
1269         if (ret & BDRV_BLOCK_ZERO) {
1270             s->status = BLK_ZERO;
1271         } else if (ret & BDRV_BLOCK_DATA) {
1272             s->status = BLK_DATA;
1273         } else if (!s->target_has_backing) {
1274             /* Without a target backing file we must copy over the contents of
1275              * the backing file as well. */
1276             /* TODO Check block status of the backing file chain to avoid
1277              * needlessly reading zeroes and limiting the iteration to the
1278              * buffer size */
1279             s->status = BLK_DATA;
1280         } else {
1281             s->status = BLK_BACKING_FILE;
1282         }
1283
1284         s->sector_next_status = sector_num + n;
1285     }
1286
1287     n = MIN(n, s->sector_next_status - sector_num);
1288     if (s->status == BLK_DATA) {
1289         n = MIN(n, s->buf_sectors);
1290     }
1291
1292     /* We need to write complete clusters for compressed images, so if an
1293      * unallocated area is shorter than that, we must consider the whole
1294      * cluster allocated. */
1295     if (s->compressed) {
1296         if (n < s->cluster_sectors) {
1297             n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1298             s->status = BLK_DATA;
1299         } else {
1300             n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1301         }
1302     }
1303
1304     return n;
1305 }
1306
1307 static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1308                         uint8_t *buf)
1309 {
1310     int n;
1311     int ret;
1312
1313     if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
1314         return 0;
1315     }
1316
1317     assert(nb_sectors <= s->buf_sectors);
1318     while (nb_sectors > 0) {
1319         BlockBackend *blk;
1320         int64_t bs_sectors;
1321
1322         /* In the case of compression with multiple source files, we can get a
1323          * nb_sectors that spreads into the next part. So we must be able to
1324          * read across multiple BDSes for one convert_read() call. */
1325         convert_select_part(s, sector_num);
1326         blk = s->src[s->src_cur];
1327         bs_sectors = s->src_sectors[s->src_cur];
1328
1329         n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
1330         ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
1331         if (ret < 0) {
1332             return ret;
1333         }
1334
1335         sector_num += n;
1336         nb_sectors -= n;
1337         buf += n * BDRV_SECTOR_SIZE;
1338     }
1339
1340     return 0;
1341 }
1342
1343 static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
1344                          const uint8_t *buf)
1345 {
1346     int ret;
1347
1348     while (nb_sectors > 0) {
1349         int n = nb_sectors;
1350
1351         switch (s->status) {
1352         case BLK_BACKING_FILE:
1353             /* If we have a backing file, leave clusters unallocated that are
1354              * unallocated in the source image, so that the backing file is
1355              * visible at the respective offset. */
1356             assert(s->target_has_backing);
1357             break;
1358
1359         case BLK_DATA:
1360             /* We must always write compressed clusters as a whole, so don't
1361              * try to find zeroed parts in the buffer. We can only save the
1362              * write if the buffer is completely zeroed and we're allowed to
1363              * keep the target sparse. */
1364             if (s->compressed) {
1365                 if (s->has_zero_init && s->min_sparse &&
1366                     buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
1367                 {
1368                     assert(!s->target_has_backing);
1369                     break;
1370                 }
1371
1372                 ret = blk_write_compressed(s->target, sector_num, buf, n);
1373                 if (ret < 0) {
1374                     return ret;
1375                 }
1376                 break;
1377             }
1378
1379             /* If there is real non-zero data or we're told to keep the target
1380              * fully allocated (-S 0), we must write it. Otherwise we can treat
1381              * it as zero sectors. */
1382             if (!s->min_sparse ||
1383                 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
1384             {
1385                 ret = blk_write(s->target, sector_num, buf, n);
1386                 if (ret < 0) {
1387                     return ret;
1388                 }
1389                 break;
1390             }
1391             /* fall-through */
1392
1393         case BLK_ZERO:
1394             if (s->has_zero_init) {
1395                 break;
1396             }
1397             ret = blk_write_zeroes(s->target, sector_num, n, 0);
1398             if (ret < 0) {
1399                 return ret;
1400             }
1401             break;
1402         }
1403
1404         sector_num += n;
1405         nb_sectors -= n;
1406         buf += n * BDRV_SECTOR_SIZE;
1407     }
1408
1409     return 0;
1410 }
1411
1412 static int convert_do_copy(ImgConvertState *s)
1413 {
1414     uint8_t *buf = NULL;
1415     int64_t sector_num, allocated_done;
1416     int ret;
1417     int n;
1418
1419     /* Check whether we have zero initialisation or can get it efficiently */
1420     s->has_zero_init = s->min_sparse && !s->target_has_backing
1421                      ? bdrv_has_zero_init(blk_bs(s->target))
1422                      : false;
1423
1424     if (!s->has_zero_init && !s->target_has_backing &&
1425         bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1426     {
1427         ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
1428         if (ret == 0) {
1429             s->has_zero_init = true;
1430         }
1431     }
1432
1433     /* Allocate buffer for copied data. For compressed images, only one cluster
1434      * can be copied at a time. */
1435     if (s->compressed) {
1436         if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1437             error_report("invalid cluster size");
1438             ret = -EINVAL;
1439             goto fail;
1440         }
1441         s->buf_sectors = s->cluster_sectors;
1442     }
1443     buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1444
1445     /* Calculate allocated sectors for progress */
1446     s->allocated_sectors = 0;
1447     sector_num = 0;
1448     while (sector_num < s->total_sectors) {
1449         n = convert_iteration_sectors(s, sector_num);
1450         if (n < 0) {
1451             ret = n;
1452             goto fail;
1453         }
1454         if (s->status == BLK_DATA) {
1455             s->allocated_sectors += n;
1456         }
1457         sector_num += n;
1458     }
1459
1460     /* Do the copy */
1461     s->src_cur = 0;
1462     s->src_cur_offset = 0;
1463     s->sector_next_status = 0;
1464
1465     sector_num = 0;
1466     allocated_done = 0;
1467
1468     while (sector_num < s->total_sectors) {
1469         n = convert_iteration_sectors(s, sector_num);
1470         if (n < 0) {
1471             ret = n;
1472             goto fail;
1473         }
1474         if (s->status == BLK_DATA) {
1475             allocated_done += n;
1476             qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
1477                                 0);
1478         }
1479
1480         ret = convert_read(s, sector_num, n, buf);
1481         if (ret < 0) {
1482             error_report("error while reading sector %" PRId64
1483                          ": %s", sector_num, strerror(-ret));
1484             goto fail;
1485         }
1486
1487         ret = convert_write(s, sector_num, n, buf);
1488         if (ret < 0) {
1489             error_report("error while writing sector %" PRId64
1490                          ": %s", sector_num, strerror(-ret));
1491             goto fail;
1492         }
1493
1494         sector_num += n;
1495     }
1496
1497     if (s->compressed) {
1498         /* signal EOF to align */
1499         ret = blk_write_compressed(s->target, 0, NULL, 0);
1500         if (ret < 0) {
1501             goto fail;
1502         }
1503     }
1504
1505     ret = 0;
1506 fail:
1507     qemu_vfree(buf);
1508     return ret;
1509 }
1510
1511 static int img_convert(int argc, char **argv)
1512 {
1513     int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
1514     int64_t ret = 0;
1515     int progress = 0, flags, src_flags;
1516     const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
1517     BlockDriver *drv, *proto_drv;
1518     BlockBackend **blk = NULL, *out_blk = NULL;
1519     BlockDriverState **bs = NULL, *out_bs = NULL;
1520     int64_t total_sectors;
1521     int64_t *bs_sectors = NULL;
1522     size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1523     BlockDriverInfo bdi;
1524     QemuOpts *opts = NULL;
1525     QemuOptsList *create_opts = NULL;
1526     const char *out_baseimg_param;
1527     char *options = NULL;
1528     const char *snapshot_name = NULL;
1529     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1530     bool quiet = false;
1531     Error *local_err = NULL;
1532     QemuOpts *sn_opts = NULL;
1533     ImgConvertState state;
1534
1535     fmt = NULL;
1536     out_fmt = "raw";
1537     cache = "unsafe";
1538     src_cache = BDRV_DEFAULT_CACHE;
1539     out_baseimg = NULL;
1540     compress = 0;
1541     skip_create = 0;
1542     for(;;) {
1543         c = getopt(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn");
1544         if (c == -1) {
1545             break;
1546         }
1547         switch(c) {
1548         case '?':
1549         case 'h':
1550             help();
1551             break;
1552         case 'f':
1553             fmt = optarg;
1554             break;
1555         case 'O':
1556             out_fmt = optarg;
1557             break;
1558         case 'B':
1559             out_baseimg = optarg;
1560             break;
1561         case 'c':
1562             compress = 1;
1563             break;
1564         case 'e':
1565             error_report("option -e is deprecated, please use \'-o "
1566                   "encryption\' instead!");
1567             ret = -1;
1568             goto fail_getopt;
1569         case '6':
1570             error_report("option -6 is deprecated, please use \'-o "
1571                   "compat6\' instead!");
1572             ret = -1;
1573             goto fail_getopt;
1574         case 'o':
1575             if (!is_valid_option_list(optarg)) {
1576                 error_report("Invalid option list: %s", optarg);
1577                 ret = -1;
1578                 goto fail_getopt;
1579             }
1580             if (!options) {
1581                 options = g_strdup(optarg);
1582             } else {
1583                 char *old_options = options;
1584                 options = g_strdup_printf("%s,%s", options, optarg);
1585                 g_free(old_options);
1586             }
1587             break;
1588         case 's':
1589             snapshot_name = optarg;
1590             break;
1591         case 'l':
1592             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1593                 sn_opts = qemu_opts_parse(&internal_snapshot_opts, optarg, 0);
1594                 if (!sn_opts) {
1595                     error_report("Failed in parsing snapshot param '%s'",
1596                                  optarg);
1597                     ret = -1;
1598                     goto fail_getopt;
1599                 }
1600             } else {
1601                 snapshot_name = optarg;
1602             }
1603             break;
1604         case 'S':
1605         {
1606             int64_t sval;
1607             char *end;
1608             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1609             if (sval < 0 || *end) {
1610                 error_report("Invalid minimum zero buffer size for sparse output specified");
1611                 ret = -1;
1612                 goto fail_getopt;
1613             }
1614
1615             min_sparse = sval / BDRV_SECTOR_SIZE;
1616             break;
1617         }
1618         case 'p':
1619             progress = 1;
1620             break;
1621         case 't':
1622             cache = optarg;
1623             break;
1624         case 'T':
1625             src_cache = optarg;
1626             break;
1627         case 'q':
1628             quiet = true;
1629             break;
1630         case 'n':
1631             skip_create = 1;
1632             break;
1633         }
1634     }
1635
1636     /* Initialize before goto out */
1637     if (quiet) {
1638         progress = 0;
1639     }
1640     qemu_progress_init(progress, 1.0);
1641
1642
1643     bs_n = argc - optind - 1;
1644     out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1645
1646     if (options && has_help_option(options)) {
1647         ret = print_block_option_help(out_filename, out_fmt);
1648         goto out;
1649     }
1650
1651     if (bs_n < 1) {
1652         error_exit("Must specify image file name");
1653     }
1654
1655
1656     if (bs_n > 1 && out_baseimg) {
1657         error_report("-B makes no sense when concatenating multiple input "
1658                      "images");
1659         ret = -1;
1660         goto out;
1661     }
1662
1663     src_flags = BDRV_O_FLAGS;
1664     ret = bdrv_parse_cache_flags(src_cache, &src_flags);
1665     if (ret < 0) {
1666         error_report("Invalid source cache option: %s", src_cache);
1667         goto out;
1668     }
1669
1670     qemu_progress_print(0, 100);
1671
1672     blk = g_new0(BlockBackend *, bs_n);
1673     bs = g_new0(BlockDriverState *, bs_n);
1674     bs_sectors = g_new(int64_t, bs_n);
1675
1676     total_sectors = 0;
1677     for (bs_i = 0; bs_i < bs_n; bs_i++) {
1678         char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
1679                             : g_strdup("source");
1680         blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags,
1681                              true, quiet);
1682         g_free(id);
1683         if (!blk[bs_i]) {
1684             ret = -1;
1685             goto out;
1686         }
1687         bs[bs_i] = blk_bs(blk[bs_i]);
1688         bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
1689         if (bs_sectors[bs_i] < 0) {
1690             error_report("Could not get size of %s: %s",
1691                          argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1692             ret = -1;
1693             goto out;
1694         }
1695         total_sectors += bs_sectors[bs_i];
1696     }
1697
1698     if (sn_opts) {
1699         ret = bdrv_snapshot_load_tmp(bs[0],
1700                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1701                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1702                                      &local_err);
1703     } else if (snapshot_name != NULL) {
1704         if (bs_n > 1) {
1705             error_report("No support for concatenating multiple snapshot");
1706             ret = -1;
1707             goto out;
1708         }
1709
1710         bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1711     }
1712     if (local_err) {
1713         error_report("Failed to load snapshot: %s",
1714                      error_get_pretty(local_err));
1715         error_free(local_err);
1716         ret = -1;
1717         goto out;
1718     }
1719
1720     /* Find driver and parse its options */
1721     drv = bdrv_find_format(out_fmt);
1722     if (!drv) {
1723         error_report("Unknown file format '%s'", out_fmt);
1724         ret = -1;
1725         goto out;
1726     }
1727
1728     proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
1729     if (!proto_drv) {
1730         error_report_err(local_err);
1731         ret = -1;
1732         goto out;
1733     }
1734
1735     if (!skip_create) {
1736         if (!drv->create_opts) {
1737             error_report("Format driver '%s' does not support image creation",
1738                          drv->format_name);
1739             ret = -1;
1740             goto out;
1741         }
1742
1743         if (!proto_drv->create_opts) {
1744             error_report("Protocol driver '%s' does not support image creation",
1745                          proto_drv->format_name);
1746             ret = -1;
1747             goto out;
1748         }
1749
1750         create_opts = qemu_opts_append(create_opts, drv->create_opts);
1751         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1752
1753         opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1754         if (options) {
1755             qemu_opts_do_parse(opts, options, NULL, &local_err);
1756             if (local_err) {
1757                 error_report_err(local_err);
1758                 ret = -1;
1759                 goto out;
1760             }
1761         }
1762
1763         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
1764                             &error_abort);
1765         ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1766         if (ret < 0) {
1767             goto out;
1768         }
1769     }
1770
1771     /* Get backing file name if -o backing_file was used */
1772     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1773     if (out_baseimg_param) {
1774         out_baseimg = out_baseimg_param;
1775     }
1776
1777     /* Check if compression is supported */
1778     if (compress) {
1779         bool encryption =
1780             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1781         const char *preallocation =
1782             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
1783
1784         if (!drv->bdrv_write_compressed) {
1785             error_report("Compression not supported for this file format");
1786             ret = -1;
1787             goto out;
1788         }
1789
1790         if (encryption) {
1791             error_report("Compression and encryption not supported at "
1792                          "the same time");
1793             ret = -1;
1794             goto out;
1795         }
1796
1797         if (preallocation
1798             && strcmp(preallocation, "off"))
1799         {
1800             error_report("Compression and preallocation not supported at "
1801                          "the same time");
1802             ret = -1;
1803             goto out;
1804         }
1805     }
1806
1807     if (!skip_create) {
1808         /* Create the new image */
1809         ret = bdrv_create(drv, out_filename, opts, &local_err);
1810         if (ret < 0) {
1811             error_report("%s: error while converting %s: %s",
1812                          out_filename, out_fmt, error_get_pretty(local_err));
1813             error_free(local_err);
1814             goto out;
1815         }
1816     }
1817
1818     flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1819     ret = bdrv_parse_cache_flags(cache, &flags);
1820     if (ret < 0) {
1821         error_report("Invalid cache option: %s", cache);
1822         goto out;
1823     }
1824
1825     out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
1826     if (!out_blk) {
1827         ret = -1;
1828         goto out;
1829     }
1830     out_bs = blk_bs(out_blk);
1831
1832     /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1833      * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1834      * as maximum. */
1835     bufsectors = MIN(32768,
1836                      MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1837                                          out_bs->bl.discard_alignment))
1838                     );
1839
1840     if (skip_create) {
1841         int64_t output_sectors = blk_nb_sectors(out_blk);
1842         if (output_sectors < 0) {
1843             error_report("unable to get output image length: %s",
1844                          strerror(-output_sectors));
1845             ret = -1;
1846             goto out;
1847         } else if (output_sectors < total_sectors) {
1848             error_report("output file is smaller than input file");
1849             ret = -1;
1850             goto out;
1851         }
1852     }
1853
1854     cluster_sectors = 0;
1855     ret = bdrv_get_info(out_bs, &bdi);
1856     if (ret < 0) {
1857         if (compress) {
1858             error_report("could not get block driver info");
1859             goto out;
1860         }
1861     } else {
1862         compress = compress || bdi.needs_compressed_writes;
1863         cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1864     }
1865
1866     state = (ImgConvertState) {
1867         .src                = blk,
1868         .src_sectors        = bs_sectors,
1869         .src_num            = bs_n,
1870         .total_sectors      = total_sectors,
1871         .target             = out_blk,
1872         .compressed         = compress,
1873         .target_has_backing = (bool) out_baseimg,
1874         .min_sparse         = min_sparse,
1875         .cluster_sectors    = cluster_sectors,
1876         .buf_sectors        = bufsectors,
1877     };
1878     ret = convert_do_copy(&state);
1879
1880 out:
1881     if (!ret) {
1882         qemu_progress_print(100, 0);
1883     }
1884     qemu_progress_end();
1885     qemu_opts_del(opts);
1886     qemu_opts_free(create_opts);
1887     qemu_opts_del(sn_opts);
1888     blk_unref(out_blk);
1889     g_free(bs);
1890     if (blk) {
1891         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1892             blk_unref(blk[bs_i]);
1893         }
1894         g_free(blk);
1895     }
1896     g_free(bs_sectors);
1897 fail_getopt:
1898     g_free(options);
1899
1900     if (ret) {
1901         return 1;
1902     }
1903     return 0;
1904 }
1905
1906
1907 static void dump_snapshots(BlockDriverState *bs)
1908 {
1909     QEMUSnapshotInfo *sn_tab, *sn;
1910     int nb_sns, i;
1911
1912     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1913     if (nb_sns <= 0)
1914         return;
1915     printf("Snapshot list:\n");
1916     bdrv_snapshot_dump(fprintf, stdout, NULL);
1917     printf("\n");
1918     for(i = 0; i < nb_sns; i++) {
1919         sn = &sn_tab[i];
1920         bdrv_snapshot_dump(fprintf, stdout, sn);
1921         printf("\n");
1922     }
1923     g_free(sn_tab);
1924 }
1925
1926 static void dump_json_image_info_list(ImageInfoList *list)
1927 {
1928     Error *local_err = NULL;
1929     QString *str;
1930     QmpOutputVisitor *ov = qmp_output_visitor_new();
1931     QObject *obj;
1932     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1933                              &list, NULL, &local_err);
1934     obj = qmp_output_get_qobject(ov);
1935     str = qobject_to_json_pretty(obj);
1936     assert(str != NULL);
1937     printf("%s\n", qstring_get_str(str));
1938     qobject_decref(obj);
1939     qmp_output_visitor_cleanup(ov);
1940     QDECREF(str);
1941 }
1942
1943 static void dump_json_image_info(ImageInfo *info)
1944 {
1945     Error *local_err = NULL;
1946     QString *str;
1947     QmpOutputVisitor *ov = qmp_output_visitor_new();
1948     QObject *obj;
1949     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1950                          &info, NULL, &local_err);
1951     obj = qmp_output_get_qobject(ov);
1952     str = qobject_to_json_pretty(obj);
1953     assert(str != NULL);
1954     printf("%s\n", qstring_get_str(str));
1955     qobject_decref(obj);
1956     qmp_output_visitor_cleanup(ov);
1957     QDECREF(str);
1958 }
1959
1960 static void dump_human_image_info_list(ImageInfoList *list)
1961 {
1962     ImageInfoList *elem;
1963     bool delim = false;
1964
1965     for (elem = list; elem; elem = elem->next) {
1966         if (delim) {
1967             printf("\n");
1968         }
1969         delim = true;
1970
1971         bdrv_image_info_dump(fprintf, stdout, elem->value);
1972     }
1973 }
1974
1975 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1976 {
1977     return strcmp(a, b) == 0;
1978 }
1979
1980 /**
1981  * Open an image file chain and return an ImageInfoList
1982  *
1983  * @filename: topmost image filename
1984  * @fmt: topmost image format (may be NULL to autodetect)
1985  * @chain: true  - enumerate entire backing file chain
1986  *         false - only topmost image file
1987  *
1988  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1989  * image file.  If there was an error a message will have been printed to
1990  * stderr.
1991  */
1992 static ImageInfoList *collect_image_info_list(const char *filename,
1993                                               const char *fmt,
1994                                               bool chain)
1995 {
1996     ImageInfoList *head = NULL;
1997     ImageInfoList **last = &head;
1998     GHashTable *filenames;
1999     Error *err = NULL;
2000
2001     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2002
2003     while (filename) {
2004         BlockBackend *blk;
2005         BlockDriverState *bs;
2006         ImageInfo *info;
2007         ImageInfoList *elem;
2008
2009         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2010             error_report("Backing file '%s' creates an infinite loop.",
2011                          filename);
2012             goto err;
2013         }
2014         g_hash_table_insert(filenames, (gpointer)filename, NULL);
2015
2016         blk = img_open("image", filename, fmt,
2017                        BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
2018         if (!blk) {
2019             goto err;
2020         }
2021         bs = blk_bs(blk);
2022
2023         bdrv_query_image_info(bs, &info, &err);
2024         if (err) {
2025             error_report_err(err);
2026             blk_unref(blk);
2027             goto err;
2028         }
2029
2030         elem = g_new0(ImageInfoList, 1);
2031         elem->value = info;
2032         *last = elem;
2033         last = &elem->next;
2034
2035         blk_unref(blk);
2036
2037         filename = fmt = NULL;
2038         if (chain) {
2039             if (info->has_full_backing_filename) {
2040                 filename = info->full_backing_filename;
2041             } else if (info->has_backing_filename) {
2042                 filename = info->backing_filename;
2043             }
2044             if (info->has_backing_filename_format) {
2045                 fmt = info->backing_filename_format;
2046             }
2047         }
2048     }
2049     g_hash_table_destroy(filenames);
2050     return head;
2051
2052 err:
2053     qapi_free_ImageInfoList(head);
2054     g_hash_table_destroy(filenames);
2055     return NULL;
2056 }
2057
2058 static int img_info(int argc, char **argv)
2059 {
2060     int c;
2061     OutputFormat output_format = OFORMAT_HUMAN;
2062     bool chain = false;
2063     const char *filename, *fmt, *output;
2064     ImageInfoList *list;
2065
2066     fmt = NULL;
2067     output = NULL;
2068     for(;;) {
2069         int option_index = 0;
2070         static const struct option long_options[] = {
2071             {"help", no_argument, 0, 'h'},
2072             {"format", required_argument, 0, 'f'},
2073             {"output", required_argument, 0, OPTION_OUTPUT},
2074             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2075             {0, 0, 0, 0}
2076         };
2077         c = getopt_long(argc, argv, "f:h",
2078                         long_options, &option_index);
2079         if (c == -1) {
2080             break;
2081         }
2082         switch(c) {
2083         case '?':
2084         case 'h':
2085             help();
2086             break;
2087         case 'f':
2088             fmt = optarg;
2089             break;
2090         case OPTION_OUTPUT:
2091             output = optarg;
2092             break;
2093         case OPTION_BACKING_CHAIN:
2094             chain = true;
2095             break;
2096         }
2097     }
2098     if (optind != argc - 1) {
2099         error_exit("Expecting one image file name");
2100     }
2101     filename = argv[optind++];
2102
2103     if (output && !strcmp(output, "json")) {
2104         output_format = OFORMAT_JSON;
2105     } else if (output && !strcmp(output, "human")) {
2106         output_format = OFORMAT_HUMAN;
2107     } else if (output) {
2108         error_report("--output must be used with human or json as argument.");
2109         return 1;
2110     }
2111
2112     list = collect_image_info_list(filename, fmt, chain);
2113     if (!list) {
2114         return 1;
2115     }
2116
2117     switch (output_format) {
2118     case OFORMAT_HUMAN:
2119         dump_human_image_info_list(list);
2120         break;
2121     case OFORMAT_JSON:
2122         if (chain) {
2123             dump_json_image_info_list(list);
2124         } else {
2125             dump_json_image_info(list->value);
2126         }
2127         break;
2128     }
2129
2130     qapi_free_ImageInfoList(list);
2131     return 0;
2132 }
2133
2134
2135 typedef struct MapEntry {
2136     int flags;
2137     int depth;
2138     int64_t start;
2139     int64_t length;
2140     int64_t offset;
2141     BlockDriverState *bs;
2142 } MapEntry;
2143
2144 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2145                            MapEntry *next)
2146 {
2147     switch (output_format) {
2148     case OFORMAT_HUMAN:
2149         if ((e->flags & BDRV_BLOCK_DATA) &&
2150             !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
2151             error_report("File contains external, encrypted or compressed clusters.");
2152             exit(1);
2153         }
2154         if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
2155             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2156                    e->start, e->length, e->offset, e->bs->filename);
2157         }
2158         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2159          * Modify the flags here to allow more coalescing.
2160          */
2161         if (next &&
2162             (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
2163             next->flags &= ~BDRV_BLOCK_DATA;
2164             next->flags |= BDRV_BLOCK_ZERO;
2165         }
2166         break;
2167     case OFORMAT_JSON:
2168         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2169                " \"zero\": %s, \"data\": %s",
2170                (e->start == 0 ? "[" : ",\n"),
2171                e->start, e->length, e->depth,
2172                (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2173                (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2174         if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
2175             printf(", \"offset\": %"PRId64"", e->offset);
2176         }
2177         putchar('}');
2178
2179         if (!next) {
2180             printf("]\n");
2181         }
2182         break;
2183     }
2184 }
2185
2186 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2187                             int nb_sectors, MapEntry *e)
2188 {
2189     int64_t ret;
2190     int depth;
2191
2192     /* As an optimization, we could cache the current range of unallocated
2193      * clusters in each file of the chain, and avoid querying the same
2194      * range repeatedly.
2195      */
2196
2197     depth = 0;
2198     for (;;) {
2199         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2200         if (ret < 0) {
2201             return ret;
2202         }
2203         assert(nb_sectors);
2204         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2205             break;
2206         }
2207         bs = bs->backing_hd;
2208         if (bs == NULL) {
2209             ret = 0;
2210             break;
2211         }
2212
2213         depth++;
2214     }
2215
2216     e->start = sector_num * BDRV_SECTOR_SIZE;
2217     e->length = nb_sectors * BDRV_SECTOR_SIZE;
2218     e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2219     e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2220     e->depth = depth;
2221     e->bs = bs;
2222     return 0;
2223 }
2224
2225 static int img_map(int argc, char **argv)
2226 {
2227     int c;
2228     OutputFormat output_format = OFORMAT_HUMAN;
2229     BlockBackend *blk;
2230     BlockDriverState *bs;
2231     const char *filename, *fmt, *output;
2232     int64_t length;
2233     MapEntry curr = { .length = 0 }, next;
2234     int ret = 0;
2235
2236     fmt = NULL;
2237     output = NULL;
2238     for (;;) {
2239         int option_index = 0;
2240         static const struct option long_options[] = {
2241             {"help", no_argument, 0, 'h'},
2242             {"format", required_argument, 0, 'f'},
2243             {"output", required_argument, 0, OPTION_OUTPUT},
2244             {0, 0, 0, 0}
2245         };
2246         c = getopt_long(argc, argv, "f:h",
2247                         long_options, &option_index);
2248         if (c == -1) {
2249             break;
2250         }
2251         switch (c) {
2252         case '?':
2253         case 'h':
2254             help();
2255             break;
2256         case 'f':
2257             fmt = optarg;
2258             break;
2259         case OPTION_OUTPUT:
2260             output = optarg;
2261             break;
2262         }
2263     }
2264     if (optind != argc - 1) {
2265         error_exit("Expecting one image file name");
2266     }
2267     filename = argv[optind];
2268
2269     if (output && !strcmp(output, "json")) {
2270         output_format = OFORMAT_JSON;
2271     } else if (output && !strcmp(output, "human")) {
2272         output_format = OFORMAT_HUMAN;
2273     } else if (output) {
2274         error_report("--output must be used with human or json as argument.");
2275         return 1;
2276     }
2277
2278     blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2279     if (!blk) {
2280         return 1;
2281     }
2282     bs = blk_bs(blk);
2283
2284     if (output_format == OFORMAT_HUMAN) {
2285         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2286     }
2287
2288     length = blk_getlength(blk);
2289     while (curr.start + curr.length < length) {
2290         int64_t nsectors_left;
2291         int64_t sector_num;
2292         int n;
2293
2294         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2295
2296         /* Probe up to 1 GiB at a time.  */
2297         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2298         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2299         ret = get_block_status(bs, sector_num, n, &next);
2300
2301         if (ret < 0) {
2302             error_report("Could not read file metadata: %s", strerror(-ret));
2303             goto out;
2304         }
2305
2306         if (curr.length != 0 && curr.flags == next.flags &&
2307             curr.depth == next.depth &&
2308             ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2309              curr.offset + curr.length == next.offset)) {
2310             curr.length += next.length;
2311             continue;
2312         }
2313
2314         if (curr.length > 0) {
2315             dump_map_entry(output_format, &curr, &next);
2316         }
2317         curr = next;
2318     }
2319
2320     dump_map_entry(output_format, &curr, NULL);
2321
2322 out:
2323     blk_unref(blk);
2324     return ret < 0;
2325 }
2326
2327 #define SNAPSHOT_LIST   1
2328 #define SNAPSHOT_CREATE 2
2329 #define SNAPSHOT_APPLY  3
2330 #define SNAPSHOT_DELETE 4
2331
2332 static int img_snapshot(int argc, char **argv)
2333 {
2334     BlockBackend *blk;
2335     BlockDriverState *bs;
2336     QEMUSnapshotInfo sn;
2337     char *filename, *snapshot_name = NULL;
2338     int c, ret = 0, bdrv_oflags;
2339     int action = 0;
2340     qemu_timeval tv;
2341     bool quiet = false;
2342     Error *err = NULL;
2343
2344     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2345     /* Parse commandline parameters */
2346     for(;;) {
2347         c = getopt(argc, argv, "la:c:d:hq");
2348         if (c == -1) {
2349             break;
2350         }
2351         switch(c) {
2352         case '?':
2353         case 'h':
2354             help();
2355             return 0;
2356         case 'l':
2357             if (action) {
2358                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2359                 return 0;
2360             }
2361             action = SNAPSHOT_LIST;
2362             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2363             break;
2364         case 'a':
2365             if (action) {
2366                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2367                 return 0;
2368             }
2369             action = SNAPSHOT_APPLY;
2370             snapshot_name = optarg;
2371             break;
2372         case 'c':
2373             if (action) {
2374                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2375                 return 0;
2376             }
2377             action = SNAPSHOT_CREATE;
2378             snapshot_name = optarg;
2379             break;
2380         case 'd':
2381             if (action) {
2382                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2383                 return 0;
2384             }
2385             action = SNAPSHOT_DELETE;
2386             snapshot_name = optarg;
2387             break;
2388         case 'q':
2389             quiet = true;
2390             break;
2391         }
2392     }
2393
2394     if (optind != argc - 1) {
2395         error_exit("Expecting one image file name");
2396     }
2397     filename = argv[optind++];
2398
2399     /* Open the image */
2400     blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2401     if (!blk) {
2402         return 1;
2403     }
2404     bs = blk_bs(blk);
2405
2406     /* Perform the requested action */
2407     switch(action) {
2408     case SNAPSHOT_LIST:
2409         dump_snapshots(bs);
2410         break;
2411
2412     case SNAPSHOT_CREATE:
2413         memset(&sn, 0, sizeof(sn));
2414         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2415
2416         qemu_gettimeofday(&tv);
2417         sn.date_sec = tv.tv_sec;
2418         sn.date_nsec = tv.tv_usec * 1000;
2419
2420         ret = bdrv_snapshot_create(bs, &sn);
2421         if (ret) {
2422             error_report("Could not create snapshot '%s': %d (%s)",
2423                 snapshot_name, ret, strerror(-ret));
2424         }
2425         break;
2426
2427     case SNAPSHOT_APPLY:
2428         ret = bdrv_snapshot_goto(bs, snapshot_name);
2429         if (ret) {
2430             error_report("Could not apply snapshot '%s': %d (%s)",
2431                 snapshot_name, ret, strerror(-ret));
2432         }
2433         break;
2434
2435     case SNAPSHOT_DELETE:
2436         bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2437         if (err) {
2438             error_report("Could not delete snapshot '%s': (%s)",
2439                          snapshot_name, error_get_pretty(err));
2440             error_free(err);
2441             ret = 1;
2442         }
2443         break;
2444     }
2445
2446     /* Cleanup */
2447     blk_unref(blk);
2448     if (ret) {
2449         return 1;
2450     }
2451     return 0;
2452 }
2453
2454 static int img_rebase(int argc, char **argv)
2455 {
2456     BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2457     BlockDriverState *bs = NULL;
2458     char *filename;
2459     const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2460     int c, flags, src_flags, ret;
2461     int unsafe = 0;
2462     int progress = 0;
2463     bool quiet = false;
2464     Error *local_err = NULL;
2465
2466     /* Parse commandline parameters */
2467     fmt = NULL;
2468     cache = BDRV_DEFAULT_CACHE;
2469     src_cache = BDRV_DEFAULT_CACHE;
2470     out_baseimg = NULL;
2471     out_basefmt = NULL;
2472     for(;;) {
2473         c = getopt(argc, argv, "hf:F:b:upt:T:q");
2474         if (c == -1) {
2475             break;
2476         }
2477         switch(c) {
2478         case '?':
2479         case 'h':
2480             help();
2481             return 0;
2482         case 'f':
2483             fmt = optarg;
2484             break;
2485         case 'F':
2486             out_basefmt = optarg;
2487             break;
2488         case 'b':
2489             out_baseimg = optarg;
2490             break;
2491         case 'u':
2492             unsafe = 1;
2493             break;
2494         case 'p':
2495             progress = 1;
2496             break;
2497         case 't':
2498             cache = optarg;
2499             break;
2500         case 'T':
2501             src_cache = optarg;
2502             break;
2503         case 'q':
2504             quiet = true;
2505             break;
2506         }
2507     }
2508
2509     if (quiet) {
2510         progress = 0;
2511     }
2512
2513     if (optind != argc - 1) {
2514         error_exit("Expecting one image file name");
2515     }
2516     if (!unsafe && !out_baseimg) {
2517         error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2518     }
2519     filename = argv[optind++];
2520
2521     qemu_progress_init(progress, 2.0);
2522     qemu_progress_print(0, 100);
2523
2524     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2525     ret = bdrv_parse_cache_flags(cache, &flags);
2526     if (ret < 0) {
2527         error_report("Invalid cache option: %s", cache);
2528         goto out;
2529     }
2530
2531     src_flags = BDRV_O_FLAGS;
2532     ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2533     if (ret < 0) {
2534         error_report("Invalid source cache option: %s", src_cache);
2535         goto out;
2536     }
2537
2538     /*
2539      * Open the images.
2540      *
2541      * Ignore the old backing file for unsafe rebase in case we want to correct
2542      * the reference to a renamed or moved backing file.
2543      */
2544     blk = img_open("image", filename, fmt, flags, true, quiet);
2545     if (!blk) {
2546         ret = -1;
2547         goto out;
2548     }
2549     bs = blk_bs(blk);
2550
2551     if (out_basefmt != NULL) {
2552         if (bdrv_find_format(out_basefmt) == NULL) {
2553             error_report("Invalid format name: '%s'", out_basefmt);
2554             ret = -1;
2555             goto out;
2556         }
2557     }
2558
2559     /* For safe rebasing we need to compare old and new backing file */
2560     if (!unsafe) {
2561         char backing_name[PATH_MAX];
2562         QDict *options = NULL;
2563
2564         if (bs->backing_format[0] != '\0') {
2565             options = qdict_new();
2566             qdict_put(options, "driver", qstring_from_str(bs->backing_format));
2567         }
2568
2569         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2570         blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
2571                                        options, src_flags, &local_err);
2572         if (!blk_old_backing) {
2573             error_report("Could not open old backing file '%s': %s",
2574                          backing_name, error_get_pretty(local_err));
2575             error_free(local_err);
2576             goto out;
2577         }
2578
2579         if (out_baseimg[0]) {
2580             if (out_basefmt) {
2581                 options = qdict_new();
2582                 qdict_put(options, "driver", qstring_from_str(out_basefmt));
2583             } else {
2584                 options = NULL;
2585             }
2586
2587             blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
2588                                            options, src_flags, &local_err);
2589             if (!blk_new_backing) {
2590                 error_report("Could not open new backing file '%s': %s",
2591                              out_baseimg, error_get_pretty(local_err));
2592                 error_free(local_err);
2593                 goto out;
2594             }
2595         }
2596     }
2597
2598     /*
2599      * Check each unallocated cluster in the COW file. If it is unallocated,
2600      * accesses go to the backing file. We must therefore compare this cluster
2601      * in the old and new backing file, and if they differ we need to copy it
2602      * from the old backing file into the COW file.
2603      *
2604      * If qemu-img crashes during this step, no harm is done. The content of
2605      * the image is the same as the original one at any time.
2606      */
2607     if (!unsafe) {
2608         int64_t num_sectors;
2609         int64_t old_backing_num_sectors;
2610         int64_t new_backing_num_sectors = 0;
2611         uint64_t sector;
2612         int n;
2613         uint8_t * buf_old;
2614         uint8_t * buf_new;
2615         float local_progress = 0;
2616
2617         buf_old = blk_blockalign(blk, IO_BUF_SIZE);
2618         buf_new = blk_blockalign(blk, IO_BUF_SIZE);
2619
2620         num_sectors = blk_nb_sectors(blk);
2621         if (num_sectors < 0) {
2622             error_report("Could not get size of '%s': %s",
2623                          filename, strerror(-num_sectors));
2624             ret = -1;
2625             goto out;
2626         }
2627         old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
2628         if (old_backing_num_sectors < 0) {
2629             char backing_name[PATH_MAX];
2630
2631             bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2632             error_report("Could not get size of '%s': %s",
2633                          backing_name, strerror(-old_backing_num_sectors));
2634             ret = -1;
2635             goto out;
2636         }
2637         if (blk_new_backing) {
2638             new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
2639             if (new_backing_num_sectors < 0) {
2640                 error_report("Could not get size of '%s': %s",
2641                              out_baseimg, strerror(-new_backing_num_sectors));
2642                 ret = -1;
2643                 goto out;
2644             }
2645         }
2646
2647         if (num_sectors != 0) {
2648             local_progress = (float)100 /
2649                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2650         }
2651
2652         for (sector = 0; sector < num_sectors; sector += n) {
2653
2654             /* How many sectors can we handle with the next read? */
2655             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2656                 n = (IO_BUF_SIZE / 512);
2657             } else {
2658                 n = num_sectors - sector;
2659             }
2660
2661             /* If the cluster is allocated, we don't need to take action */
2662             ret = bdrv_is_allocated(bs, sector, n, &n);
2663             if (ret < 0) {
2664                 error_report("error while reading image metadata: %s",
2665                              strerror(-ret));
2666                 goto out;
2667             }
2668             if (ret) {
2669                 continue;
2670             }
2671
2672             /*
2673              * Read old and new backing file and take into consideration that
2674              * backing files may be smaller than the COW image.
2675              */
2676             if (sector >= old_backing_num_sectors) {
2677                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2678             } else {
2679                 if (sector + n > old_backing_num_sectors) {
2680                     n = old_backing_num_sectors - sector;
2681                 }
2682
2683                 ret = blk_read(blk_old_backing, sector, buf_old, n);
2684                 if (ret < 0) {
2685                     error_report("error while reading from old backing file");
2686                     goto out;
2687                 }
2688             }
2689
2690             if (sector >= new_backing_num_sectors || !blk_new_backing) {
2691                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2692             } else {
2693                 if (sector + n > new_backing_num_sectors) {
2694                     n = new_backing_num_sectors - sector;
2695                 }
2696
2697                 ret = blk_read(blk_new_backing, sector, buf_new, n);
2698                 if (ret < 0) {
2699                     error_report("error while reading from new backing file");
2700                     goto out;
2701                 }
2702             }
2703
2704             /* If they differ, we need to write to the COW file */
2705             uint64_t written = 0;
2706
2707             while (written < n) {
2708                 int pnum;
2709
2710                 if (compare_sectors(buf_old + written * 512,
2711                     buf_new + written * 512, n - written, &pnum))
2712                 {
2713                     ret = blk_write(blk, sector + written,
2714                                     buf_old + written * 512, pnum);
2715                     if (ret < 0) {
2716                         error_report("Error while writing to COW image: %s",
2717                             strerror(-ret));
2718                         goto out;
2719                     }
2720                 }
2721
2722                 written += pnum;
2723             }
2724             qemu_progress_print(local_progress, 100);
2725         }
2726
2727         qemu_vfree(buf_old);
2728         qemu_vfree(buf_new);
2729     }
2730
2731     /*
2732      * Change the backing file. All clusters that are different from the old
2733      * backing file are overwritten in the COW file now, so the visible content
2734      * doesn't change when we switch the backing file.
2735      */
2736     if (out_baseimg && *out_baseimg) {
2737         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2738     } else {
2739         ret = bdrv_change_backing_file(bs, NULL, NULL);
2740     }
2741
2742     if (ret == -ENOSPC) {
2743         error_report("Could not change the backing file to '%s': No "
2744                      "space left in the file header", out_baseimg);
2745     } else if (ret < 0) {
2746         error_report("Could not change the backing file to '%s': %s",
2747             out_baseimg, strerror(-ret));
2748     }
2749
2750     qemu_progress_print(100, 0);
2751     /*
2752      * TODO At this point it is possible to check if any clusters that are
2753      * allocated in the COW file are the same in the backing file. If so, they
2754      * could be dropped from the COW file. Don't do this before switching the
2755      * backing file, in case of a crash this would lead to corruption.
2756      */
2757 out:
2758     qemu_progress_end();
2759     /* Cleanup */
2760     if (!unsafe) {
2761         blk_unref(blk_old_backing);
2762         blk_unref(blk_new_backing);
2763     }
2764
2765     blk_unref(blk);
2766     if (ret) {
2767         return 1;
2768     }
2769     return 0;
2770 }
2771
2772 static int img_resize(int argc, char **argv)
2773 {
2774     Error *err = NULL;
2775     int c, ret, relative;
2776     const char *filename, *fmt, *size;
2777     int64_t n, total_size;
2778     bool quiet = false;
2779     BlockBackend *blk = NULL;
2780     QemuOpts *param;
2781     static QemuOptsList resize_options = {
2782         .name = "resize_options",
2783         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2784         .desc = {
2785             {
2786                 .name = BLOCK_OPT_SIZE,
2787                 .type = QEMU_OPT_SIZE,
2788                 .help = "Virtual disk size"
2789             }, {
2790                 /* end of list */
2791             }
2792         },
2793     };
2794
2795     /* Remove size from argv manually so that negative numbers are not treated
2796      * as options by getopt. */
2797     if (argc < 3) {
2798         error_exit("Not enough arguments");
2799         return 1;
2800     }
2801
2802     size = argv[--argc];
2803
2804     /* Parse getopt arguments */
2805     fmt = NULL;
2806     for(;;) {
2807         c = getopt(argc, argv, "f:hq");
2808         if (c == -1) {
2809             break;
2810         }
2811         switch(c) {
2812         case '?':
2813         case 'h':
2814             help();
2815             break;
2816         case 'f':
2817             fmt = optarg;
2818             break;
2819         case 'q':
2820             quiet = true;
2821             break;
2822         }
2823     }
2824     if (optind != argc - 1) {
2825         error_exit("Expecting one image file name");
2826     }
2827     filename = argv[optind++];
2828
2829     /* Choose grow, shrink, or absolute resize mode */
2830     switch (size[0]) {
2831     case '+':
2832         relative = 1;
2833         size++;
2834         break;
2835     case '-':
2836         relative = -1;
2837         size++;
2838         break;
2839     default:
2840         relative = 0;
2841         break;
2842     }
2843
2844     /* Parse size */
2845     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2846     qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
2847     if (err) {
2848         error_report_err(err);
2849         ret = -1;
2850         qemu_opts_del(param);
2851         goto out;
2852     }
2853     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2854     qemu_opts_del(param);
2855
2856     blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2857                    true, quiet);
2858     if (!blk) {
2859         ret = -1;
2860         goto out;
2861     }
2862
2863     if (relative) {
2864         total_size = blk_getlength(blk) + n * relative;
2865     } else {
2866         total_size = n;
2867     }
2868     if (total_size <= 0) {
2869         error_report("New image size must be positive");
2870         ret = -1;
2871         goto out;
2872     }
2873
2874     ret = blk_truncate(blk, total_size);
2875     switch (ret) {
2876     case 0:
2877         qprintf(quiet, "Image resized.\n");
2878         break;
2879     case -ENOTSUP:
2880         error_report("This image does not support resize");
2881         break;
2882     case -EACCES:
2883         error_report("Image is read-only");
2884         break;
2885     default:
2886         error_report("Error resizing image (%d)", -ret);
2887         break;
2888     }
2889 out:
2890     blk_unref(blk);
2891     if (ret) {
2892         return 1;
2893     }
2894     return 0;
2895 }
2896
2897 static void amend_status_cb(BlockDriverState *bs,
2898                             int64_t offset, int64_t total_work_size)
2899 {
2900     qemu_progress_print(100.f * offset / total_work_size, 0);
2901 }
2902
2903 static int img_amend(int argc, char **argv)
2904 {
2905     Error *err = NULL;
2906     int c, ret = 0;
2907     char *options = NULL;
2908     QemuOptsList *create_opts = NULL;
2909     QemuOpts *opts = NULL;
2910     const char *fmt = NULL, *filename, *cache;
2911     int flags;
2912     bool quiet = false, progress = false;
2913     BlockBackend *blk = NULL;
2914     BlockDriverState *bs = NULL;
2915
2916     cache = BDRV_DEFAULT_CACHE;
2917     for (;;) {
2918         c = getopt(argc, argv, "ho:f:t:pq");
2919         if (c == -1) {
2920             break;
2921         }
2922
2923         switch (c) {
2924             case 'h':
2925             case '?':
2926                 help();
2927                 break;
2928             case 'o':
2929                 if (!is_valid_option_list(optarg)) {
2930                     error_report("Invalid option list: %s", optarg);
2931                     ret = -1;
2932                     goto out;
2933                 }
2934                 if (!options) {
2935                     options = g_strdup(optarg);
2936                 } else {
2937                     char *old_options = options;
2938                     options = g_strdup_printf("%s,%s", options, optarg);
2939                     g_free(old_options);
2940                 }
2941                 break;
2942             case 'f':
2943                 fmt = optarg;
2944                 break;
2945             case 't':
2946                 cache = optarg;
2947                 break;
2948             case 'p':
2949                 progress = true;
2950                 break;
2951             case 'q':
2952                 quiet = true;
2953                 break;
2954         }
2955     }
2956
2957     if (!options) {
2958         error_exit("Must specify options (-o)");
2959     }
2960
2961     if (quiet) {
2962         progress = false;
2963     }
2964     qemu_progress_init(progress, 1.0);
2965
2966     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2967     if (fmt && has_help_option(options)) {
2968         /* If a format is explicitly specified (and possibly no filename is
2969          * given), print option help here */
2970         ret = print_block_option_help(filename, fmt);
2971         goto out;
2972     }
2973
2974     if (optind != argc - 1) {
2975         error_report("Expecting one image file name");
2976         ret = -1;
2977         goto out;
2978     }
2979
2980     flags = BDRV_O_FLAGS | BDRV_O_RDWR;
2981     ret = bdrv_parse_cache_flags(cache, &flags);
2982     if (ret < 0) {
2983         error_report("Invalid cache option: %s", cache);
2984         goto out;
2985     }
2986
2987     blk = img_open("image", filename, fmt, flags, true, quiet);
2988     if (!blk) {
2989         ret = -1;
2990         goto out;
2991     }
2992     bs = blk_bs(blk);
2993
2994     fmt = bs->drv->format_name;
2995
2996     if (has_help_option(options)) {
2997         /* If the format was auto-detected, print option help here */
2998         ret = print_block_option_help(filename, fmt);
2999         goto out;
3000     }
3001
3002     if (!bs->drv->create_opts) {
3003         error_report("Format driver '%s' does not support any options to amend",
3004                      fmt);
3005         ret = -1;
3006         goto out;
3007     }
3008
3009     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3010     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3011     if (options) {
3012         qemu_opts_do_parse(opts, options, NULL, &err);
3013         if (err) {
3014             error_report_err(err);
3015             ret = -1;
3016             goto out;
3017         }
3018     }
3019
3020     /* In case the driver does not call amend_status_cb() */
3021     qemu_progress_print(0.f, 0);
3022     ret = bdrv_amend_options(bs, opts, &amend_status_cb);
3023     qemu_progress_print(100.f, 0);
3024     if (ret < 0) {
3025         error_report("Error while amending options: %s", strerror(-ret));
3026         goto out;
3027     }
3028
3029 out:
3030     qemu_progress_end();
3031
3032     blk_unref(blk);
3033     qemu_opts_del(opts);
3034     qemu_opts_free(create_opts);
3035     g_free(options);
3036
3037     if (ret) {
3038         return 1;
3039     }
3040     return 0;
3041 }
3042
3043 static const img_cmd_t img_cmds[] = {
3044 #define DEF(option, callback, arg_string)        \
3045     { option, callback },
3046 #include "qemu-img-cmds.h"
3047 #undef DEF
3048 #undef GEN_DOCS
3049     { NULL, NULL, },
3050 };
3051
3052 int main(int argc, char **argv)
3053 {
3054     const img_cmd_t *cmd;
3055     const char *cmdname;
3056     Error *local_error = NULL;
3057     int c;
3058     static const struct option long_options[] = {
3059         {"help", no_argument, 0, 'h'},
3060         {"version", no_argument, 0, 'v'},
3061         {0, 0, 0, 0}
3062     };
3063
3064 #ifdef CONFIG_POSIX
3065     signal(SIGPIPE, SIG_IGN);
3066 #endif
3067
3068     error_set_progname(argv[0]);
3069     qemu_init_exec_dir(argv[0]);
3070
3071     if (qemu_init_main_loop(&local_error)) {
3072         error_report_err(local_error);
3073         exit(EXIT_FAILURE);
3074     }
3075
3076     bdrv_init();
3077     if (argc < 2) {
3078         error_exit("Not enough arguments");
3079     }
3080     cmdname = argv[1];
3081
3082     /* find the command */
3083     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3084         if (!strcmp(cmdname, cmd->name)) {
3085             return cmd->handler(argc - 1, argv + 1);
3086         }
3087     }
3088
3089     c = getopt_long(argc, argv, "h", long_options, NULL);
3090
3091     if (c == 'h') {
3092         help();
3093     }
3094     if (c == 'v') {
3095         printf(QEMU_IMG_VERSION);
3096         return 0;
3097     }
3098
3099     /* not found */
3100     error_exit("Command not found: %s", cmdname);
3101 }