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