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