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