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