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 \
  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
 265     /* Find driver and parse its options */
 266     drv = bdrv_find_format(fmt);
 267     if (!drv) {
 268         error_report("Unknown file format '%s'", fmt);
 269         return 1;
 270     }
 271
 272     create_opts = qemu_opts_append(create_opts, drv->create_opts);
 273     if (filename) {
 274         proto_drv = bdrv_find_protocol(filename, true);
 275         if (!proto_drv) {
 276             error_report("Unknown protocol '%s'", filename);
 277             qemu_opts_free(create_opts);
 278             return 1;
 279         }
 280         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 281     }
 282
 283     qemu_opts_print_help(create_opts);
 284     qemu_opts_free(create_opts);
 285     return 0;
 286 }
 287
 288 static BlockBackend *img_open(const char *id, const char *filename,
 289                               const char *fmt, int flags,
 290                               bool require_io, bool quiet)
 291 {
 292     BlockBackend *blk;
 293     BlockDriverState *bs;
 294     BlockDriver *drv;
 295     char password[256];
 296     Error *local_err = NULL;
 297     int ret;
 298
 299     blk = blk_new_with_bs(id, &error_abort);
 300     bs = blk_bs(blk);
 301
 302     if (fmt) {
 303         drv = bdrv_find_format(fmt);
 304         if (!drv) {
 305             error_report("Unknown file format '%s'", fmt);
 306             goto fail;
 307         }
 308     } else {
 309         drv = NULL;
 310     }
 311
 312     ret = bdrv_open(&bs, filename, NULL, NULL, flags, drv, &local_err);
 313     if (ret < 0) {
 314         error_report("Could not open '%s': %s", filename,
 315                      error_get_pretty(local_err));
 316         error_free(local_err);
 317         goto fail;
 318     }
 319
 320     if (bdrv_is_encrypted(bs) && require_io) {
 321         qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
 322         if (read_password(password, sizeof(password)) < 0) {
 323             error_report("No password given");
 324             goto fail;
 325         }
 326         if (bdrv_set_key(bs, password) < 0) {
 327             error_report("invalid password");
 328             goto fail;
 329         }
 330     }
 331     return blk;
 332 fail:
 333     blk_unref(blk);
 334     return NULL;
 335 }
 336
 337 static int add_old_style_options(const char *fmt, QemuOpts *opts,
 338                                  const char *base_filename,
 339                                  const char *base_fmt)
 340 {
 341     if (base_filename) {
 342         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
 343             error_report("Backing file not supported for file format '%s'",
 344                          fmt);
 345             return -1;
 346         }
 347     }
 348     if (base_fmt) {
 349         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 350             error_report("Backing file format not supported for file "
 351                          "format '%s'", fmt);
 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         qerror_report_err(local_err);
 893         error_free(local_err);
 894         return 1;
 895     }
 896
 897     qprintf(quiet, "Image committed.\n");
 898     return 0;
 899 }
 900
 901 /*
 902  * Returns true iff the first sector pointed to by 'buf' contains at least
 903  * a non-NUL byte.
 904  *
 905  * 'pnum' is set to the number of sectors (including and immediately following
 906  * the first one) that are known to be in the same allocated/unallocated state.
 907  */
 908 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 909 {
 910     bool is_zero;
 911     int i;
 912
 913     if (n <= 0) {
 914         *pnum = 0;
 915         return 0;
 916     }
 917     is_zero = buffer_is_zero(buf, 512);
 918     for(i = 1; i < n; i++) {
 919         buf += 512;
 920         if (is_zero != buffer_is_zero(buf, 512)) {
 921             break;
 922         }
 923     }
 924     *pnum = i;
 925     return !is_zero;
 926 }
 927
 928 /*
 929  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 930  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 931  * breaking up write requests for only small sparse areas.
 932  */
 933 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 934     int min)
 935 {
 936     int ret;
 937     int num_checked, num_used;
 938
 939     if (n < min) {
 940         min = n;
 941     }
 942
 943     ret = is_allocated_sectors(buf, n, pnum);
 944     if (!ret) {
 945         return ret;
 946     }
 947
 948     num_used = *pnum;
 949     buf += BDRV_SECTOR_SIZE * *pnum;
 950     n -= *pnum;
 951     num_checked = num_used;
 952
 953     while (n > 0) {
 954         ret = is_allocated_sectors(buf, n, pnum);
 955
 956         buf += BDRV_SECTOR_SIZE * *pnum;
 957         n -= *pnum;
 958         num_checked += *pnum;
 959         if (ret) {
 960             num_used = num_checked;
 961         } else if (*pnum >= min) {
 962             break;
 963         }
 964     }
 965
 966     *pnum = num_used;
 967     return 1;
 968 }
 969
 970 /*
 971  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 972  * buffers matches, non-zero otherwise.
 973  *
 974  * pnum is set to the number of sectors (including and immediately following
 975  * the first one) that are known to have the same comparison result
 976  */
 977 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 978     int *pnum)
 979 {
 980     int res, 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 bs:  Driver used for accessing file
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(BlockDriverState *bs, 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 = bdrv_read(bs, 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 = qemu_blockalign(bs1, IO_BUF_SIZE);
1142     buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
1143     total_sectors1 = bdrv_nb_sectors(bs1);
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 = bdrv_nb_sectors(bs2);
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 = bdrv_read(bs1, 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 = bdrv_read(bs2, 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(bs1, sector_num, nb_sectors,
1228                                           filename1, buf1, quiet);
1229             } else {
1230                 ret = check_empty_sectors(bs2, 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         BlockDriverState *bs_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             bs_over = bs1;
1255             filename_over = filename1;
1256         } else {
1257             total_sectors_over = total_sectors2;
1258             bs_over = bs2;
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(bs_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(bs_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] = bdrv_nb_sectors(bs[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);
1528     if (!proto_drv) {
1529         error_report("Unknown protocol '%s'", out_filename);
1530         ret = -1;
1531         goto out;
1532     }
1533
1534     create_opts = qemu_opts_append(create_opts, drv->create_opts);
1535     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1536
1537     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1538     if (options && qemu_opts_do_parse(opts, options, NULL)) {
1539         error_report("Invalid options for file format '%s'", out_fmt);
1540         ret = -1;
1541         goto out;
1542     }
1543
1544     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512);
1545     ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1546     if (ret < 0) {
1547         goto out;
1548     }
1549
1550     /* Get backing file name if -o backing_file was used */
1551     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1552     if (out_baseimg_param) {
1553         out_baseimg = out_baseimg_param;
1554     }
1555
1556     /* Check if compression is supported */
1557     if (compress) {
1558         bool encryption =
1559             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1560         const char *preallocation =
1561             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
1562
1563         if (!drv->bdrv_write_compressed) {
1564             error_report("Compression not supported for this file format");
1565             ret = -1;
1566             goto out;
1567         }
1568
1569         if (encryption) {
1570             error_report("Compression and encryption not supported at "
1571                          "the same time");
1572             ret = -1;
1573             goto out;
1574         }
1575
1576         if (preallocation
1577             && strcmp(preallocation, "off"))
1578         {
1579             error_report("Compression and preallocation not supported at "
1580                          "the same time");
1581             ret = -1;
1582             goto out;
1583         }
1584     }
1585
1586     if (!skip_create) {
1587         /* Create the new image */
1588         ret = bdrv_create(drv, out_filename, opts, &local_err);
1589         if (ret < 0) {
1590             error_report("%s: error while converting %s: %s",
1591                          out_filename, out_fmt, error_get_pretty(local_err));
1592             error_free(local_err);
1593             goto out;
1594         }
1595     }
1596
1597     flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1598     ret = bdrv_parse_cache_flags(cache, &flags);
1599     if (ret < 0) {
1600         error_report("Invalid cache option: %s", cache);
1601         goto out;
1602     }
1603
1604     out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
1605     if (!out_blk) {
1606         ret = -1;
1607         goto out;
1608     }
1609     out_bs = blk_bs(out_blk);
1610
1611     bs_i = 0;
1612     bs_offset = 0;
1613
1614     /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1615      * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1616      * as maximum. */
1617     bufsectors = MIN(32768,
1618                      MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1619                                          out_bs->bl.discard_alignment))
1620                     );
1621
1622     buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE);
1623
1624     if (skip_create) {
1625         int64_t output_sectors = bdrv_nb_sectors(out_bs);
1626         if (output_sectors < 0) {
1627             error_report("unable to get output image length: %s\n",
1628                          strerror(-output_sectors));
1629             ret = -1;
1630             goto out;
1631         } else if (output_sectors < total_sectors) {
1632             error_report("output file is smaller than input file");
1633             ret = -1;
1634             goto out;
1635         }
1636     }
1637
1638     cluster_sectors = 0;
1639     ret = bdrv_get_info(out_bs, &bdi);
1640     if (ret < 0) {
1641         if (compress) {
1642             error_report("could not get block driver info");
1643             goto out;
1644         }
1645     } else {
1646         compress = compress || bdi.needs_compressed_writes;
1647         cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1648     }
1649
1650     if (compress) {
1651         if (cluster_sectors <= 0 || cluster_sectors > bufsectors) {
1652             error_report("invalid cluster size");
1653             ret = -1;
1654             goto out;
1655         }
1656         sector_num = 0;
1657
1658         nb_sectors = total_sectors;
1659
1660         for(;;) {
1661             int64_t bs_num;
1662             int remainder;
1663             uint8_t *buf2;
1664
1665             nb_sectors = total_sectors - sector_num;
1666             if (nb_sectors <= 0)
1667                 break;
1668             if (nb_sectors >= cluster_sectors)
1669                 n = cluster_sectors;
1670             else
1671                 n = nb_sectors;
1672
1673             bs_num = sector_num - bs_offset;
1674             assert (bs_num >= 0);
1675             remainder = n;
1676             buf2 = buf;
1677             while (remainder > 0) {
1678                 int nlow;
1679                 while (bs_num == bs_sectors[bs_i]) {
1680                     bs_offset += bs_sectors[bs_i];
1681                     bs_i++;
1682                     assert (bs_i < bs_n);
1683                     bs_num = 0;
1684                     /* printf("changing part: sector_num=%" PRId64 ", "
1685                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1686                        "\n", sector_num, bs_i, bs_offset, bs_sectors[bs_i]); */
1687                 }
1688                 assert (bs_num < bs_sectors[bs_i]);
1689
1690                 nlow = remainder > bs_sectors[bs_i] - bs_num
1691                     ? bs_sectors[bs_i] - bs_num : remainder;
1692
1693                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1694                 if (ret < 0) {
1695                     error_report("error while reading sector %" PRId64 ": %s",
1696                                  bs_num, strerror(-ret));
1697                     goto out;
1698                 }
1699
1700                 buf2 += nlow * 512;
1701                 bs_num += nlow;
1702
1703                 remainder -= nlow;
1704             }
1705             assert (remainder == 0);
1706
1707             if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1708                 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1709                 if (ret != 0) {
1710                     error_report("error while compressing sector %" PRId64
1711                                  ": %s", sector_num, strerror(-ret));
1712                     goto out;
1713                 }
1714             }
1715             sector_num += n;
1716             qemu_progress_print(100.0 * sector_num / total_sectors, 0);
1717         }
1718         /* signal EOF to align */
1719         bdrv_write_compressed(out_bs, 0, NULL, 0);
1720     } else {
1721         int64_t sectors_to_read, sectors_read, sector_num_next_status;
1722         bool count_allocated_sectors;
1723         int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0;
1724
1725         if (!has_zero_init && bdrv_can_write_zeroes_with_unmap(out_bs)) {
1726             ret = bdrv_make_zero(out_bs, BDRV_REQ_MAY_UNMAP);
1727             if (ret < 0) {
1728                 goto out;
1729             }
1730             has_zero_init = 1;
1731         }
1732
1733         sectors_to_read = total_sectors;
1734         count_allocated_sectors = progress && (out_baseimg || has_zero_init);
1735 restart:
1736         sector_num = 0; // total number of sectors converted so far
1737         sectors_read = 0;
1738         sector_num_next_status = 0;
1739
1740         for(;;) {
1741             nb_sectors = total_sectors - sector_num;
1742             if (nb_sectors <= 0) {
1743                 if (count_allocated_sectors) {
1744                     sectors_to_read = sectors_read;
1745                     count_allocated_sectors = false;
1746                     goto restart;
1747                 }
1748                 ret = 0;
1749                 break;
1750             }
1751
1752             while (sector_num - bs_offset >= bs_sectors[bs_i]) {
1753                 bs_offset += bs_sectors[bs_i];
1754                 bs_i ++;
1755                 assert (bs_i < bs_n);
1756                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1757                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1758                    sector_num, bs_i, bs_offset, bs_sectors[bs_i]); */
1759             }
1760
1761             if ((out_baseimg || has_zero_init) &&
1762                 sector_num >= sector_num_next_status) {
1763                 n = nb_sectors > INT_MAX ? INT_MAX : nb_sectors;
1764                 ret = bdrv_get_block_status(bs[bs_i], sector_num - bs_offset,
1765                                             n, &n1);
1766                 if (ret < 0) {
1767                     error_report("error while reading block status of sector %"
1768                                  PRId64 ": %s", sector_num - bs_offset,
1769                                  strerror(-ret));
1770                     goto out;
1771                 }
1772                 /* If the output image is zero initialized, we are not working
1773                  * on a shared base and the input is zero we can skip the next
1774                  * n1 sectors */
1775                 if (has_zero_init && !out_baseimg && (ret & BDRV_BLOCK_ZERO)) {
1776                     sector_num += n1;
1777                     continue;
1778                 }
1779                 /* If the output image is being created as a copy on write
1780                  * image, assume that sectors which are unallocated in the
1781                  * input image are present in both the output's and input's
1782                  * base images (no need to copy them). */
1783                 if (out_baseimg) {
1784                     if (!(ret & BDRV_BLOCK_DATA)) {
1785                         sector_num += n1;
1786                         continue;
1787                     }
1788                     /* The next 'n1' sectors are allocated in the input image.
1789                      * Copy only those as they may be followed by unallocated
1790                      * sectors. */
1791                     nb_sectors = n1;
1792                 }
1793                 /* avoid redundant callouts to get_block_status */
1794                 sector_num_next_status = sector_num + n1;
1795             }
1796
1797             n = MIN(nb_sectors, bufsectors);
1798
1799             /* round down request length to an aligned sector, but
1800              * do not bother doing this on short requests. They happen
1801              * when we found an all-zero area, and the next sector to
1802              * write will not be sector_num + n. */
1803             if (cluster_sectors > 0 && n >= cluster_sectors) {
1804                 int64_t next_aligned_sector = (sector_num + n);
1805                 next_aligned_sector -= next_aligned_sector % cluster_sectors;
1806                 if (sector_num + n > next_aligned_sector) {
1807                     n = next_aligned_sector - sector_num;
1808                 }
1809             }
1810
1811             n = MIN(n, bs_sectors[bs_i] - (sector_num - bs_offset));
1812
1813             sectors_read += n;
1814             if (count_allocated_sectors) {
1815                 sector_num += n;
1816                 continue;
1817             }
1818
1819             n1 = n;
1820             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1821             if (ret < 0) {
1822                 error_report("error while reading sector %" PRId64 ": %s",
1823                              sector_num - bs_offset, strerror(-ret));
1824                 goto out;
1825             }
1826             /* NOTE: at the same time we convert, we do not write zero
1827                sectors to have a chance to compress the image. Ideally, we
1828                should add a specific call to have the info to go faster */
1829             buf1 = buf;
1830             while (n > 0) {
1831                 if (!has_zero_init ||
1832                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1833                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1834                     if (ret < 0) {
1835                         error_report("error while writing sector %" PRId64
1836                                      ": %s", sector_num, strerror(-ret));
1837                         goto out;
1838                     }
1839                 }
1840                 sector_num += n1;
1841                 n -= n1;
1842                 buf1 += n1 * 512;
1843             }
1844             qemu_progress_print(100.0 * sectors_read / sectors_to_read, 0);
1845         }
1846     }
1847 out:
1848     if (!ret) {
1849         qemu_progress_print(100, 0);
1850     }
1851     qemu_progress_end();
1852     qemu_opts_del(opts);
1853     qemu_opts_free(create_opts);
1854     qemu_vfree(buf);
1855     qemu_opts_del(sn_opts);
1856     blk_unref(out_blk);
1857     g_free(bs);
1858     if (blk) {
1859         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1860             blk_unref(blk[bs_i]);
1861         }
1862         g_free(blk);
1863     }
1864     g_free(bs_sectors);
1865 fail_getopt:
1866     g_free(options);
1867
1868     if (ret) {
1869         return 1;
1870     }
1871     return 0;
1872 }
1873
1874
1875 static void dump_snapshots(BlockDriverState *bs)
1876 {
1877     QEMUSnapshotInfo *sn_tab, *sn;
1878     int nb_sns, i;
1879
1880     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1881     if (nb_sns <= 0)
1882         return;
1883     printf("Snapshot list:\n");
1884     bdrv_snapshot_dump(fprintf, stdout, NULL);
1885     printf("\n");
1886     for(i = 0; i < nb_sns; i++) {
1887         sn = &sn_tab[i];
1888         bdrv_snapshot_dump(fprintf, stdout, sn);
1889         printf("\n");
1890     }
1891     g_free(sn_tab);
1892 }
1893
1894 static void dump_json_image_info_list(ImageInfoList *list)
1895 {
1896     Error *local_err = NULL;
1897     QString *str;
1898     QmpOutputVisitor *ov = qmp_output_visitor_new();
1899     QObject *obj;
1900     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1901                              &list, NULL, &local_err);
1902     obj = qmp_output_get_qobject(ov);
1903     str = qobject_to_json_pretty(obj);
1904     assert(str != NULL);
1905     printf("%s\n", qstring_get_str(str));
1906     qobject_decref(obj);
1907     qmp_output_visitor_cleanup(ov);
1908     QDECREF(str);
1909 }
1910
1911 static void dump_json_image_info(ImageInfo *info)
1912 {
1913     Error *local_err = NULL;
1914     QString *str;
1915     QmpOutputVisitor *ov = qmp_output_visitor_new();
1916     QObject *obj;
1917     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1918                          &info, NULL, &local_err);
1919     obj = qmp_output_get_qobject(ov);
1920     str = qobject_to_json_pretty(obj);
1921     assert(str != NULL);
1922     printf("%s\n", qstring_get_str(str));
1923     qobject_decref(obj);
1924     qmp_output_visitor_cleanup(ov);
1925     QDECREF(str);
1926 }
1927
1928 static void dump_human_image_info_list(ImageInfoList *list)
1929 {
1930     ImageInfoList *elem;
1931     bool delim = false;
1932
1933     for (elem = list; elem; elem = elem->next) {
1934         if (delim) {
1935             printf("\n");
1936         }
1937         delim = true;
1938
1939         bdrv_image_info_dump(fprintf, stdout, elem->value);
1940     }
1941 }
1942
1943 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1944 {
1945     return strcmp(a, b) == 0;
1946 }
1947
1948 /**
1949  * Open an image file chain and return an ImageInfoList
1950  *
1951  * @filename: topmost image filename
1952  * @fmt: topmost image format (may be NULL to autodetect)
1953  * @chain: true  - enumerate entire backing file chain
1954  *         false - only topmost image file
1955  *
1956  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1957  * image file.  If there was an error a message will have been printed to
1958  * stderr.
1959  */
1960 static ImageInfoList *collect_image_info_list(const char *filename,
1961                                               const char *fmt,
1962                                               bool chain)
1963 {
1964     ImageInfoList *head = NULL;
1965     ImageInfoList **last = &head;
1966     GHashTable *filenames;
1967     Error *err = NULL;
1968
1969     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1970
1971     while (filename) {
1972         BlockBackend *blk;
1973         BlockDriverState *bs;
1974         ImageInfo *info;
1975         ImageInfoList *elem;
1976
1977         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1978             error_report("Backing file '%s' creates an infinite loop.",
1979                          filename);
1980             goto err;
1981         }
1982         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1983
1984         blk = img_open("image", filename, fmt,
1985                        BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
1986         if (!blk) {
1987             goto err;
1988         }
1989         bs = blk_bs(blk);
1990
1991         bdrv_query_image_info(bs, &info, &err);
1992         if (err) {
1993             error_report("%s", error_get_pretty(err));
1994             error_free(err);
1995             blk_unref(blk);
1996             goto err;
1997         }
1998
1999         elem = g_new0(ImageInfoList, 1);
2000         elem->value = info;
2001         *last = elem;
2002         last = &elem->next;
2003
2004         blk_unref(blk);
2005
2006         filename = fmt = NULL;
2007         if (chain) {
2008             if (info->has_full_backing_filename) {
2009                 filename = info->full_backing_filename;
2010             } else if (info->has_backing_filename) {
2011                 filename = info->backing_filename;
2012             }
2013             if (info->has_backing_filename_format) {
2014                 fmt = info->backing_filename_format;
2015             }
2016         }
2017     }
2018     g_hash_table_destroy(filenames);
2019     return head;
2020
2021 err:
2022     qapi_free_ImageInfoList(head);
2023     g_hash_table_destroy(filenames);
2024     return NULL;
2025 }
2026
2027 static int img_info(int argc, char **argv)
2028 {
2029     int c;
2030     OutputFormat output_format = OFORMAT_HUMAN;
2031     bool chain = false;
2032     const char *filename, *fmt, *output;
2033     ImageInfoList *list;
2034
2035     fmt = NULL;
2036     output = NULL;
2037     for(;;) {
2038         int option_index = 0;
2039         static const struct option long_options[] = {
2040             {"help", no_argument, 0, 'h'},
2041             {"format", required_argument, 0, 'f'},
2042             {"output", required_argument, 0, OPTION_OUTPUT},
2043             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2044             {0, 0, 0, 0}
2045         };
2046         c = getopt_long(argc, argv, "f:h",
2047                         long_options, &option_index);
2048         if (c == -1) {
2049             break;
2050         }
2051         switch(c) {
2052         case '?':
2053         case 'h':
2054             help();
2055             break;
2056         case 'f':
2057             fmt = optarg;
2058             break;
2059         case OPTION_OUTPUT:
2060             output = optarg;
2061             break;
2062         case OPTION_BACKING_CHAIN:
2063             chain = true;
2064             break;
2065         }
2066     }
2067     if (optind != argc - 1) {
2068         error_exit("Expecting one image file name");
2069     }
2070     filename = argv[optind++];
2071
2072     if (output && !strcmp(output, "json")) {
2073         output_format = OFORMAT_JSON;
2074     } else if (output && !strcmp(output, "human")) {
2075         output_format = OFORMAT_HUMAN;
2076     } else if (output) {
2077         error_report("--output must be used with human or json as argument.");
2078         return 1;
2079     }
2080
2081     list = collect_image_info_list(filename, fmt, chain);
2082     if (!list) {
2083         return 1;
2084     }
2085
2086     switch (output_format) {
2087     case OFORMAT_HUMAN:
2088         dump_human_image_info_list(list);
2089         break;
2090     case OFORMAT_JSON:
2091         if (chain) {
2092             dump_json_image_info_list(list);
2093         } else {
2094             dump_json_image_info(list->value);
2095         }
2096         break;
2097     }
2098
2099     qapi_free_ImageInfoList(list);
2100     return 0;
2101 }
2102
2103
2104 typedef struct MapEntry {
2105     int flags;
2106     int depth;
2107     int64_t start;
2108     int64_t length;
2109     int64_t offset;
2110     BlockDriverState *bs;
2111 } MapEntry;
2112
2113 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2114                            MapEntry *next)
2115 {
2116     switch (output_format) {
2117     case OFORMAT_HUMAN:
2118         if ((e->flags & BDRV_BLOCK_DATA) &&
2119             !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
2120             error_report("File contains external, encrypted or compressed clusters.");
2121             exit(1);
2122         }
2123         if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
2124             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2125                    e->start, e->length, e->offset, e->bs->filename);
2126         }
2127         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2128          * Modify the flags here to allow more coalescing.
2129          */
2130         if (next &&
2131             (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
2132             next->flags &= ~BDRV_BLOCK_DATA;
2133             next->flags |= BDRV_BLOCK_ZERO;
2134         }
2135         break;
2136     case OFORMAT_JSON:
2137         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2138                " \"zero\": %s, \"data\": %s",
2139                (e->start == 0 ? "[" : ",\n"),
2140                e->start, e->length, e->depth,
2141                (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2142                (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2143         if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
2144             printf(", \"offset\": %"PRId64"", e->offset);
2145         }
2146         putchar('}');
2147
2148         if (!next) {
2149             printf("]\n");
2150         }
2151         break;
2152     }
2153 }
2154
2155 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2156                             int nb_sectors, MapEntry *e)
2157 {
2158     int64_t ret;
2159     int depth;
2160
2161     /* As an optimization, we could cache the current range of unallocated
2162      * clusters in each file of the chain, and avoid querying the same
2163      * range repeatedly.
2164      */
2165
2166     depth = 0;
2167     for (;;) {
2168         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2169         if (ret < 0) {
2170             return ret;
2171         }
2172         assert(nb_sectors);
2173         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2174             break;
2175         }
2176         bs = bs->backing_hd;
2177         if (bs == NULL) {
2178             ret = 0;
2179             break;
2180         }
2181
2182         depth++;
2183     }
2184
2185     e->start = sector_num * BDRV_SECTOR_SIZE;
2186     e->length = nb_sectors * BDRV_SECTOR_SIZE;
2187     e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2188     e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2189     e->depth = depth;
2190     e->bs = bs;
2191     return 0;
2192 }
2193
2194 static int img_map(int argc, char **argv)
2195 {
2196     int c;
2197     OutputFormat output_format = OFORMAT_HUMAN;
2198     BlockBackend *blk;
2199     BlockDriverState *bs;
2200     const char *filename, *fmt, *output;
2201     int64_t length;
2202     MapEntry curr = { .length = 0 }, next;
2203     int ret = 0;
2204
2205     fmt = NULL;
2206     output = NULL;
2207     for (;;) {
2208         int option_index = 0;
2209         static const struct option long_options[] = {
2210             {"help", no_argument, 0, 'h'},
2211             {"format", required_argument, 0, 'f'},
2212             {"output", required_argument, 0, OPTION_OUTPUT},
2213             {0, 0, 0, 0}
2214         };
2215         c = getopt_long(argc, argv, "f:h",
2216                         long_options, &option_index);
2217         if (c == -1) {
2218             break;
2219         }
2220         switch (c) {
2221         case '?':
2222         case 'h':
2223             help();
2224             break;
2225         case 'f':
2226             fmt = optarg;
2227             break;
2228         case OPTION_OUTPUT:
2229             output = optarg;
2230             break;
2231         }
2232     }
2233     if (optind != argc - 1) {
2234         error_exit("Expecting one image file name");
2235     }
2236     filename = argv[optind];
2237
2238     if (output && !strcmp(output, "json")) {
2239         output_format = OFORMAT_JSON;
2240     } else if (output && !strcmp(output, "human")) {
2241         output_format = OFORMAT_HUMAN;
2242     } else if (output) {
2243         error_report("--output must be used with human or json as argument.");
2244         return 1;
2245     }
2246
2247     blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2248     if (!blk) {
2249         return 1;
2250     }
2251     bs = blk_bs(blk);
2252
2253     if (output_format == OFORMAT_HUMAN) {
2254         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2255     }
2256
2257     length = bdrv_getlength(bs);
2258     while (curr.start + curr.length < length) {
2259         int64_t nsectors_left;
2260         int64_t sector_num;
2261         int n;
2262
2263         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2264
2265         /* Probe up to 1 GiB at a time.  */
2266         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2267         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2268         ret = get_block_status(bs, sector_num, n, &next);
2269
2270         if (ret < 0) {
2271             error_report("Could not read file metadata: %s", strerror(-ret));
2272             goto out;
2273         }
2274
2275         if (curr.length != 0 && curr.flags == next.flags &&
2276             curr.depth == next.depth &&
2277             ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2278              curr.offset + curr.length == next.offset)) {
2279             curr.length += next.length;
2280             continue;
2281         }
2282
2283         if (curr.length > 0) {
2284             dump_map_entry(output_format, &curr, &next);
2285         }
2286         curr = next;
2287     }
2288
2289     dump_map_entry(output_format, &curr, NULL);
2290
2291 out:
2292     blk_unref(blk);
2293     return ret < 0;
2294 }
2295
2296 #define SNAPSHOT_LIST   1
2297 #define SNAPSHOT_CREATE 2
2298 #define SNAPSHOT_APPLY  3
2299 #define SNAPSHOT_DELETE 4
2300
2301 static int img_snapshot(int argc, char **argv)
2302 {
2303     BlockBackend *blk;
2304     BlockDriverState *bs;
2305     QEMUSnapshotInfo sn;
2306     char *filename, *snapshot_name = NULL;
2307     int c, ret = 0, bdrv_oflags;
2308     int action = 0;
2309     qemu_timeval tv;
2310     bool quiet = false;
2311     Error *err = NULL;
2312
2313     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2314     /* Parse commandline parameters */
2315     for(;;) {
2316         c = getopt(argc, argv, "la:c:d:hq");
2317         if (c == -1) {
2318             break;
2319         }
2320         switch(c) {
2321         case '?':
2322         case 'h':
2323             help();
2324             return 0;
2325         case 'l':
2326             if (action) {
2327                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2328                 return 0;
2329             }
2330             action = SNAPSHOT_LIST;
2331             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2332             break;
2333         case 'a':
2334             if (action) {
2335                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2336                 return 0;
2337             }
2338             action = SNAPSHOT_APPLY;
2339             snapshot_name = optarg;
2340             break;
2341         case 'c':
2342             if (action) {
2343                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2344                 return 0;
2345             }
2346             action = SNAPSHOT_CREATE;
2347             snapshot_name = optarg;
2348             break;
2349         case 'd':
2350             if (action) {
2351                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2352                 return 0;
2353             }
2354             action = SNAPSHOT_DELETE;
2355             snapshot_name = optarg;
2356             break;
2357         case 'q':
2358             quiet = true;
2359             break;
2360         }
2361     }
2362
2363     if (optind != argc - 1) {
2364         error_exit("Expecting one image file name");
2365     }
2366     filename = argv[optind++];
2367
2368     /* Open the image */
2369     blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
2370     if (!blk) {
2371         return 1;
2372     }
2373     bs = blk_bs(blk);
2374
2375     /* Perform the requested action */
2376     switch(action) {
2377     case SNAPSHOT_LIST:
2378         dump_snapshots(bs);
2379         break;
2380
2381     case SNAPSHOT_CREATE:
2382         memset(&sn, 0, sizeof(sn));
2383         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2384
2385         qemu_gettimeofday(&tv);
2386         sn.date_sec = tv.tv_sec;
2387         sn.date_nsec = tv.tv_usec * 1000;
2388
2389         ret = bdrv_snapshot_create(bs, &sn);
2390         if (ret) {
2391             error_report("Could not create snapshot '%s': %d (%s)",
2392                 snapshot_name, ret, strerror(-ret));
2393         }
2394         break;
2395
2396     case SNAPSHOT_APPLY:
2397         ret = bdrv_snapshot_goto(bs, snapshot_name);
2398         if (ret) {
2399             error_report("Could not apply snapshot '%s': %d (%s)",
2400                 snapshot_name, ret, strerror(-ret));
2401         }
2402         break;
2403
2404     case SNAPSHOT_DELETE:
2405         bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2406         if (err) {
2407             error_report("Could not delete snapshot '%s': (%s)",
2408                          snapshot_name, error_get_pretty(err));
2409             error_free(err);
2410             ret = 1;
2411         }
2412         break;
2413     }
2414
2415     /* Cleanup */
2416     blk_unref(blk);
2417     if (ret) {
2418         return 1;
2419     }
2420     return 0;
2421 }
2422
2423 static int img_rebase(int argc, char **argv)
2424 {
2425     BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
2426     BlockDriverState *bs = NULL, *bs_old_backing = NULL, *bs_new_backing = NULL;
2427     BlockDriver *old_backing_drv, *new_backing_drv;
2428     char *filename;
2429     const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
2430     int c, flags, src_flags, ret;
2431     int unsafe = 0;
2432     int progress = 0;
2433     bool quiet = false;
2434     Error *local_err = NULL;
2435
2436     /* Parse commandline parameters */
2437     fmt = NULL;
2438     cache = BDRV_DEFAULT_CACHE;
2439     src_cache = BDRV_DEFAULT_CACHE;
2440     out_baseimg = NULL;
2441     out_basefmt = NULL;
2442     for(;;) {
2443         c = getopt(argc, argv, "hf:F:b:upt:T:q");
2444         if (c == -1) {
2445             break;
2446         }
2447         switch(c) {
2448         case '?':
2449         case 'h':
2450             help();
2451             return 0;
2452         case 'f':
2453             fmt = optarg;
2454             break;
2455         case 'F':
2456             out_basefmt = optarg;
2457             break;
2458         case 'b':
2459             out_baseimg = optarg;
2460             break;
2461         case 'u':
2462             unsafe = 1;
2463             break;
2464         case 'p':
2465             progress = 1;
2466             break;
2467         case 't':
2468             cache = optarg;
2469             break;
2470         case 'T':
2471             src_cache = optarg;
2472             break;
2473         case 'q':
2474             quiet = true;
2475             break;
2476         }
2477     }
2478
2479     if (quiet) {
2480         progress = 0;
2481     }
2482
2483     if (optind != argc - 1) {
2484         error_exit("Expecting one image file name");
2485     }
2486     if (!unsafe && !out_baseimg) {
2487         error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2488     }
2489     filename = argv[optind++];
2490
2491     qemu_progress_init(progress, 2.0);
2492     qemu_progress_print(0, 100);
2493
2494     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2495     ret = bdrv_parse_cache_flags(cache, &flags);
2496     if (ret < 0) {
2497         error_report("Invalid cache option: %s", cache);
2498         goto out;
2499     }
2500
2501     src_flags = BDRV_O_FLAGS;
2502     ret = bdrv_parse_cache_flags(src_cache, &src_flags);
2503     if (ret < 0) {
2504         error_report("Invalid source cache option: %s", src_cache);
2505         goto out;
2506     }
2507
2508     /*
2509      * Open the images.
2510      *
2511      * Ignore the old backing file for unsafe rebase in case we want to correct
2512      * the reference to a renamed or moved backing file.
2513      */
2514     blk = img_open("image", filename, fmt, flags, true, quiet);
2515     if (!blk) {
2516         ret = -1;
2517         goto out;
2518     }
2519     bs = blk_bs(blk);
2520
2521     /* Find the right drivers for the backing files */
2522     old_backing_drv = NULL;
2523     new_backing_drv = NULL;
2524
2525     if (!unsafe && bs->backing_format[0] != '\0') {
2526         old_backing_drv = bdrv_find_format(bs->backing_format);
2527         if (old_backing_drv == NULL) {
2528             error_report("Invalid format name: '%s'", bs->backing_format);
2529             ret = -1;
2530             goto out;
2531         }
2532     }
2533
2534     if (out_basefmt != NULL) {
2535         new_backing_drv = bdrv_find_format(out_basefmt);
2536         if (new_backing_drv == NULL) {
2537             error_report("Invalid format name: '%s'", out_basefmt);
2538             ret = -1;
2539             goto out;
2540         }
2541     }
2542
2543     /* For safe rebasing we need to compare old and new backing file */
2544     if (!unsafe) {
2545         char backing_name[1024];
2546
2547         blk_old_backing = blk_new_with_bs("old_backing", &error_abort);
2548         bs_old_backing = blk_bs(blk_old_backing);
2549         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2550         ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, src_flags,
2551                         old_backing_drv, &local_err);
2552         if (ret) {
2553             error_report("Could not open old backing file '%s': %s",
2554                          backing_name, error_get_pretty(local_err));
2555             error_free(local_err);
2556             goto out;
2557         }
2558         if (out_baseimg[0]) {
2559             blk_new_backing = blk_new_with_bs("new_backing", &error_abort);
2560             bs_new_backing = blk_bs(blk_new_backing);
2561             ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL, src_flags,
2562                             new_backing_drv, &local_err);
2563             if (ret) {
2564                 error_report("Could not open new backing file '%s': %s",
2565                              out_baseimg, error_get_pretty(local_err));
2566                 error_free(local_err);
2567                 goto out;
2568             }
2569         }
2570     }
2571
2572     /*
2573      * Check each unallocated cluster in the COW file. If it is unallocated,
2574      * accesses go to the backing file. We must therefore compare this cluster
2575      * in the old and new backing file, and if they differ we need to copy it
2576      * from the old backing file into the COW file.
2577      *
2578      * If qemu-img crashes during this step, no harm is done. The content of
2579      * the image is the same as the original one at any time.
2580      */
2581     if (!unsafe) {
2582         int64_t num_sectors;
2583         int64_t old_backing_num_sectors;
2584         int64_t new_backing_num_sectors = 0;
2585         uint64_t sector;
2586         int n;
2587         uint8_t * buf_old;
2588         uint8_t * buf_new;
2589         float local_progress = 0;
2590
2591         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2592         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2593
2594         num_sectors = bdrv_nb_sectors(bs);
2595         if (num_sectors < 0) {
2596             error_report("Could not get size of '%s': %s",
2597                          filename, strerror(-num_sectors));
2598             ret = -1;
2599             goto out;
2600         }
2601         old_backing_num_sectors = bdrv_nb_sectors(bs_old_backing);
2602         if (old_backing_num_sectors < 0) {
2603             char backing_name[1024];
2604
2605             bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2606             error_report("Could not get size of '%s': %s",
2607                          backing_name, strerror(-old_backing_num_sectors));
2608             ret = -1;
2609             goto out;
2610         }
2611         if (bs_new_backing) {
2612             new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing);
2613             if (new_backing_num_sectors < 0) {
2614                 error_report("Could not get size of '%s': %s",
2615                              out_baseimg, strerror(-new_backing_num_sectors));
2616                 ret = -1;
2617                 goto out;
2618             }
2619         }
2620
2621         if (num_sectors != 0) {
2622             local_progress = (float)100 /
2623                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2624         }
2625
2626         for (sector = 0; sector < num_sectors; sector += n) {
2627
2628             /* How many sectors can we handle with the next read? */
2629             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2630                 n = (IO_BUF_SIZE / 512);
2631             } else {
2632                 n = num_sectors - sector;
2633             }
2634
2635             /* If the cluster is allocated, we don't need to take action */
2636             ret = bdrv_is_allocated(bs, sector, n, &n);
2637             if (ret < 0) {
2638                 error_report("error while reading image metadata: %s",
2639                              strerror(-ret));
2640                 goto out;
2641             }
2642             if (ret) {
2643                 continue;
2644             }
2645
2646             /*
2647              * Read old and new backing file and take into consideration that
2648              * backing files may be smaller than the COW image.
2649              */
2650             if (sector >= old_backing_num_sectors) {
2651                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2652             } else {
2653                 if (sector + n > old_backing_num_sectors) {
2654                     n = old_backing_num_sectors - sector;
2655                 }
2656
2657                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2658                 if (ret < 0) {
2659                     error_report("error while reading from old backing file");
2660                     goto out;
2661                 }
2662             }
2663
2664             if (sector >= new_backing_num_sectors || !bs_new_backing) {
2665                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2666             } else {
2667                 if (sector + n > new_backing_num_sectors) {
2668                     n = new_backing_num_sectors - sector;
2669                 }
2670
2671                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2672                 if (ret < 0) {
2673                     error_report("error while reading from new backing file");
2674                     goto out;
2675                 }
2676             }
2677
2678             /* If they differ, we need to write to the COW file */
2679             uint64_t written = 0;
2680
2681             while (written < n) {
2682                 int pnum;
2683
2684                 if (compare_sectors(buf_old + written * 512,
2685                     buf_new + written * 512, n - written, &pnum))
2686                 {
2687                     ret = bdrv_write(bs, sector + written,
2688                         buf_old + written * 512, pnum);
2689                     if (ret < 0) {
2690                         error_report("Error while writing to COW image: %s",
2691                             strerror(-ret));
2692                         goto out;
2693                     }
2694                 }
2695
2696                 written += pnum;
2697             }
2698             qemu_progress_print(local_progress, 100);
2699         }
2700
2701         qemu_vfree(buf_old);
2702         qemu_vfree(buf_new);
2703     }
2704
2705     /*
2706      * Change the backing file. All clusters that are different from the old
2707      * backing file are overwritten in the COW file now, so the visible content
2708      * doesn't change when we switch the backing file.
2709      */
2710     if (out_baseimg && *out_baseimg) {
2711         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2712     } else {
2713         ret = bdrv_change_backing_file(bs, NULL, NULL);
2714     }
2715
2716     if (ret == -ENOSPC) {
2717         error_report("Could not change the backing file to '%s': No "
2718                      "space left in the file header", out_baseimg);
2719     } else if (ret < 0) {
2720         error_report("Could not change the backing file to '%s': %s",
2721             out_baseimg, strerror(-ret));
2722     }
2723
2724     qemu_progress_print(100, 0);
2725     /*
2726      * TODO At this point it is possible to check if any clusters that are
2727      * allocated in the COW file are the same in the backing file. If so, they
2728      * could be dropped from the COW file. Don't do this before switching the
2729      * backing file, in case of a crash this would lead to corruption.
2730      */
2731 out:
2732     qemu_progress_end();
2733     /* Cleanup */
2734     if (!unsafe) {
2735         blk_unref(blk_old_backing);
2736         blk_unref(blk_new_backing);
2737     }
2738
2739     blk_unref(blk);
2740     if (ret) {
2741         return 1;
2742     }
2743     return 0;
2744 }
2745
2746 static int img_resize(int argc, char **argv)
2747 {
2748     int c, ret, relative;
2749     const char *filename, *fmt, *size;
2750     int64_t n, total_size;
2751     bool quiet = false;
2752     BlockBackend *blk = NULL;
2753     BlockDriverState *bs = NULL;
2754     QemuOpts *param;
2755     static QemuOptsList resize_options = {
2756         .name = "resize_options",
2757         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2758         .desc = {
2759             {
2760                 .name = BLOCK_OPT_SIZE,
2761                 .type = QEMU_OPT_SIZE,
2762                 .help = "Virtual disk size"
2763             }, {
2764                 /* end of list */
2765             }
2766         },
2767     };
2768
2769     /* Remove size from argv manually so that negative numbers are not treated
2770      * as options by getopt. */
2771     if (argc < 3) {
2772         error_exit("Not enough arguments");
2773         return 1;
2774     }
2775
2776     size = argv[--argc];
2777
2778     /* Parse getopt arguments */
2779     fmt = NULL;
2780     for(;;) {
2781         c = getopt(argc, argv, "f:hq");
2782         if (c == -1) {
2783             break;
2784         }
2785         switch(c) {
2786         case '?':
2787         case 'h':
2788             help();
2789             break;
2790         case 'f':
2791             fmt = optarg;
2792             break;
2793         case 'q':
2794             quiet = true;
2795             break;
2796         }
2797     }
2798     if (optind != argc - 1) {
2799         error_exit("Expecting one image file name");
2800     }
2801     filename = argv[optind++];
2802
2803     /* Choose grow, shrink, or absolute resize mode */
2804     switch (size[0]) {
2805     case '+':
2806         relative = 1;
2807         size++;
2808         break;
2809     case '-':
2810         relative = -1;
2811         size++;
2812         break;
2813     default:
2814         relative = 0;
2815         break;
2816     }
2817
2818     /* Parse size */
2819     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2820     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2821         /* Error message already printed when size parsing fails */
2822         ret = -1;
2823         qemu_opts_del(param);
2824         goto out;
2825     }
2826     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2827     qemu_opts_del(param);
2828
2829     blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2830                    true, quiet);
2831     if (!blk) {
2832         ret = -1;
2833         goto out;
2834     }
2835     bs = blk_bs(blk);
2836
2837     if (relative) {
2838         total_size = bdrv_getlength(bs) + n * relative;
2839     } else {
2840         total_size = n;
2841     }
2842     if (total_size <= 0) {
2843         error_report("New image size must be positive");
2844         ret = -1;
2845         goto out;
2846     }
2847
2848     ret = bdrv_truncate(bs, total_size);
2849     switch (ret) {
2850     case 0:
2851         qprintf(quiet, "Image resized.\n");
2852         break;
2853     case -ENOTSUP:
2854         error_report("This image does not support resize");
2855         break;
2856     case -EACCES:
2857         error_report("Image is read-only");
2858         break;
2859     default:
2860         error_report("Error resizing image (%d)", -ret);
2861         break;
2862     }
2863 out:
2864     blk_unref(blk);
2865     if (ret) {
2866         return 1;
2867     }
2868     return 0;
2869 }
2870
2871 static void amend_status_cb(BlockDriverState *bs,
2872                             int64_t offset, int64_t total_work_size)
2873 {
2874     qemu_progress_print(100.f * offset / total_work_size, 0);
2875 }
2876
2877 static int img_amend(int argc, char **argv)
2878 {
2879     int c, ret = 0;
2880     char *options = NULL;
2881     QemuOptsList *create_opts = NULL;
2882     QemuOpts *opts = NULL;
2883     const char *fmt = NULL, *filename, *cache;
2884     int flags;
2885     bool quiet = false, progress = false;
2886     BlockBackend *blk = NULL;
2887     BlockDriverState *bs = NULL;
2888
2889     cache = BDRV_DEFAULT_CACHE;
2890     for (;;) {
2891         c = getopt(argc, argv, "ho:f:t:pq");
2892         if (c == -1) {
2893             break;
2894         }
2895
2896         switch (c) {
2897             case 'h':
2898             case '?':
2899                 help();
2900                 break;
2901             case 'o':
2902                 if (!is_valid_option_list(optarg)) {
2903                     error_report("Invalid option list: %s", optarg);
2904                     ret = -1;
2905                     goto out;
2906                 }
2907                 if (!options) {
2908                     options = g_strdup(optarg);
2909                 } else {
2910                     char *old_options = options;
2911                     options = g_strdup_printf("%s,%s", options, optarg);
2912                     g_free(old_options);
2913                 }
2914                 break;
2915             case 'f':
2916                 fmt = optarg;
2917                 break;
2918             case 't':
2919                 cache = optarg;
2920                 break;
2921             case 'p':
2922                 progress = true;
2923                 break;
2924             case 'q':
2925                 quiet = true;
2926                 break;
2927         }
2928     }
2929
2930     if (!options) {
2931         error_exit("Must specify options (-o)");
2932     }
2933
2934     if (quiet) {
2935         progress = false;
2936     }
2937     qemu_progress_init(progress, 1.0);
2938
2939     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2940     if (fmt && has_help_option(options)) {
2941         /* If a format is explicitly specified (and possibly no filename is
2942          * given), print option help here */
2943         ret = print_block_option_help(filename, fmt);
2944         goto out;
2945     }
2946
2947     if (optind != argc - 1) {
2948         error_report("Expecting one image file name");
2949         ret = -1;
2950         goto out;
2951     }
2952
2953     flags = BDRV_O_FLAGS | BDRV_O_RDWR;
2954     ret = bdrv_parse_cache_flags(cache, &flags);
2955     if (ret < 0) {
2956         error_report("Invalid cache option: %s", cache);
2957         goto out;
2958     }
2959
2960     blk = img_open("image", filename, fmt, flags, true, quiet);
2961     if (!blk) {
2962         ret = -1;
2963         goto out;
2964     }
2965     bs = blk_bs(blk);
2966
2967     fmt = bs->drv->format_name;
2968
2969     if (has_help_option(options)) {
2970         /* If the format was auto-detected, print option help here */
2971         ret = print_block_option_help(filename, fmt);
2972         goto out;
2973     }
2974
2975     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
2976     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2977     if (options && qemu_opts_do_parse(opts, options, NULL)) {
2978         error_report("Invalid options for file format '%s'", fmt);
2979         ret = -1;
2980         goto out;
2981     }
2982
2983     /* In case the driver does not call amend_status_cb() */
2984     qemu_progress_print(0.f, 0);
2985     ret = bdrv_amend_options(bs, opts, &amend_status_cb);
2986     qemu_progress_print(100.f, 0);
2987     if (ret < 0) {
2988         error_report("Error while amending options: %s", strerror(-ret));
2989         goto out;
2990     }
2991
2992 out:
2993     qemu_progress_end();
2994
2995     blk_unref(blk);
2996     qemu_opts_del(opts);
2997     qemu_opts_free(create_opts);
2998     g_free(options);
2999
3000     if (ret) {
3001         return 1;
3002     }
3003     return 0;
3004 }
3005
3006 static const img_cmd_t img_cmds[] = {
3007 #define DEF(option, callback, arg_string)        \
3008     { option, callback },
3009 #include "qemu-img-cmds.h"
3010 #undef DEF
3011 #undef GEN_DOCS
3012     { NULL, NULL, },
3013 };
3014
3015 int main(int argc, char **argv)
3016 {
3017     const img_cmd_t *cmd;
3018     const char *cmdname;
3019     Error *local_error = NULL;
3020     int c;
3021     static const struct option long_options[] = {
3022         {"help", no_argument, 0, 'h'},
3023         {"version", no_argument, 0, 'v'},
3024         {0, 0, 0, 0}
3025     };
3026
3027 #ifdef CONFIG_POSIX
3028     signal(SIGPIPE, SIG_IGN);
3029 #endif
3030
3031     error_set_progname(argv[0]);
3032     qemu_init_exec_dir(argv[0]);
3033
3034     if (qemu_init_main_loop(&local_error)) {
3035         error_report("%s", error_get_pretty(local_error));
3036         error_free(local_error);
3037         exit(EXIT_FAILURE);
3038     }
3039
3040     bdrv_init();
3041     if (argc < 2) {
3042         error_exit("Not enough arguments");
3043     }
3044     cmdname = argv[1];
3045
3046     /* find the command */
3047     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
3048         if (!strcmp(cmdname, cmd->name)) {
3049             return cmd->handler(argc - 1, argv + 1);
3050         }
3051     }
3052
3053     c = getopt_long(argc, argv, "h", long_options, NULL);
3054
3055     if (c == 'h') {
3056         help();
3057     }
3058     if (c == 'v') {
3059         printf(QEMU_IMG_VERSION);
3060         return 0;
3061     }
3062
3063     /* not found */
3064     error_exit("Command not found: %s", cmdname);
3065 }