qemu-img.c

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