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