qemu-img.c

   1 /*
   2  * QEMU disk image utility
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qapi-visit.h"
  25 #include "qapi/qmp-output-visitor.h"
  26 #include "qapi/qmp/qjson.h"
  27 #include "qemu-common.h"
  28 #include "qemu/option.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/osdep.h"
  31 #include "sysemu/sysemu.h"
  32 #include "block/block_int.h"
  33 #include "block/qapi.h"
  34 #include <getopt.h>
  35 #include <glib.h>
  36
  37 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION \
  38                           ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  39
  40 typedef struct img_cmd_t {
  41     const char *name;
  42     int (*handler)(int argc, char **argv);
  43 } img_cmd_t;
  44
  45 enum {
  46     OPTION_OUTPUT = 256,
  47     OPTION_BACKING_CHAIN = 257,
  48 };
  49
  50 typedef enum OutputFormat {
  51     OFORMAT_JSON,
  52     OFORMAT_HUMAN,
  53 } OutputFormat;
  54
  55 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  56 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  57 #define BDRV_DEFAULT_CACHE "writeback"
  58
  59 static gint compare_data(gconstpointer a, gconstpointer b, gpointer user)
  60 {
  61     return g_strcmp0(a, b);
  62 }
  63
  64 static void print_format(gpointer data, gpointer user)
  65 {
  66     printf(" %s", (char *)data);
  67 }
  68
  69 static void add_format_to_seq(void *opaque, const char *fmt_name)
  70 {
  71     GSequence *seq = opaque;
  72
  73     g_sequence_insert_sorted(seq, (gpointer)fmt_name,
  74                              compare_data, NULL);
  75 }
  76
  77 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
  78 {
  79     va_list ap;
  80
  81     error_printf("qemu-img: ");
  82
  83     va_start(ap, fmt);
  84     error_vprintf(fmt, ap);
  85     va_end(ap);
  86
  87     error_printf("\nTry 'qemu-img --help' for more information\n");
  88     exit(EXIT_FAILURE);
  89 }
  90
  91 /* Please keep in synch with qemu-img.texi */
  92 static void QEMU_NORETURN help(void)
  93 {
  94     const char *help_msg =
  95            QEMU_IMG_VERSION
  96            "usage: qemu-img command [command options]\n"
  97            "QEMU disk image utility\n"
  98            "\n"
  99            "Command syntax:\n"
 100 #define DEF(option, callback, arg_string)        \
 101            "  " arg_string "\n"
 102 #include "qemu-img-cmds.h"
 103 #undef DEF
 104 #undef GEN_DOCS
 105            "\n"
 106            "Command parameters:\n"
 107            "  'filename' is a disk image filename\n"
 108            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
 109            "  'cache' is the cache mode used to write the output disk image, the valid\n"
 110            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
 111            "    'directsync' and 'unsafe' (default for convert)\n"
 112            "  'size' is the disk image size in bytes. Optional suffixes\n"
 113            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
 114            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
 115            "    supported. 'b' is ignored.\n"
 116            "  'output_filename' is the destination disk image filename\n"
 117            "  'output_fmt' is the destination format\n"
 118            "  'options' is a comma separated list of format specific options in a\n"
 119            "    name=value format. Use -o ? for an overview of the options supported by the\n"
 120            "    used format\n"
 121            "  'snapshot_param' is param used for internal snapshot, format\n"
 122            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
 123            "    '[ID_OR_NAME]'\n"
 124            "  'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
 125            "    instead\n"
 126            "  '-c' indicates that target image must be compressed (qcow format only)\n"
 127            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
 128            "       match exactly. The image doesn't need a working backing file before\n"
 129            "       rebasing in this case (useful for renaming the backing file)\n"
 130            "  '-h' with or without a command shows this help and lists the supported formats\n"
 131            "  '-p' show progress of command (only certain commands)\n"
 132            "  '-q' use Quiet mode - do not print any output (except errors)\n"
 133            "  '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
 134            "       contain only zeros for qemu-img to create a sparse image during\n"
 135            "       conversion. If the number of bytes is 0, the source will not be scanned for\n"
 136            "       unallocated or zero sectors, and the destination image will always be\n"
 137            "       fully allocated\n"
 138            "  '--output' takes the format in which the output must be done (human or json)\n"
 139            "  '-n' skips the target volume creation (useful if the volume is created\n"
 140            "       prior to running qemu-img)\n"
 141            "\n"
 142            "Parameters to check subcommand:\n"
 143            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
 144            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
 145            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
 146            "       hiding corruption that has already occurred.\n"
 147            "\n"
 148            "Parameters to snapshot subcommand:\n"
 149            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 150            "  '-a' applies a snapshot (revert disk to saved state)\n"
 151            "  '-c' creates a snapshot\n"
 152            "  '-d' deletes a snapshot\n"
 153            "  '-l' lists all snapshots in the given image\n"
 154            "\n"
 155            "Parameters to compare subcommand:\n"
 156            "  '-f' first image format\n"
 157            "  '-F' second image format\n"
 158            "  '-s' run in Strict mode - fail on different image size or sector allocation\n";
 159     GSequence *seq;
 160
 161     printf("%s\nSupported formats:", help_msg);
 162     seq = g_sequence_new(NULL);
 163     bdrv_iterate_format(add_format_to_seq, seq);
 164     g_sequence_foreach(seq, print_format, NULL);
 165     printf("\n");
 166     g_sequence_free(seq);
 167
 168     exit(EXIT_SUCCESS);
 169 }
 170
 171 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
 172 {
 173     int ret = 0;
 174     if (!quiet) {
 175         va_list args;
 176         va_start(args, fmt);
 177         ret = vprintf(fmt, args);
 178         va_end(args);
 179     }
 180     return ret;
 181 }
 182
 183 #if defined(WIN32)
 184 /* XXX: put correct support for win32 */
 185 static int read_password(char *buf, int buf_size)
 186 {
 187     int c, i;
 188     printf("Password: ");
 189     fflush(stdout);
 190     i = 0;
 191     for(;;) {
 192         c = getchar();
 193         if (c == '\n')
 194             break;
 195         if (i < (buf_size - 1))
 196             buf[i++] = c;
 197     }
 198     buf[i] = '\0';
 199     return 0;
 200 }
 201
 202 #else
 203
 204 #include <termios.h>
 205
 206 static struct termios oldtty;
 207
 208 static void term_exit(void)
 209 {
 210     tcsetattr (0, TCSANOW, &oldtty);
 211 }
 212
 213 static void term_init(void)
 214 {
 215     struct termios tty;
 216
 217     tcgetattr (0, &tty);
 218     oldtty = tty;
 219
 220     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 221                           |INLCR|IGNCR|ICRNL|IXON);
 222     tty.c_oflag |= OPOST;
 223     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 224     tty.c_cflag &= ~(CSIZE|PARENB);
 225     tty.c_cflag |= CS8;
 226     tty.c_cc[VMIN] = 1;
 227     tty.c_cc[VTIME] = 0;
 228
 229     tcsetattr (0, TCSANOW, &tty);
 230
 231     atexit(term_exit);
 232 }
 233
 234 static int read_password(char *buf, int buf_size)
 235 {
 236     uint8_t ch;
 237     int i, ret;
 238
 239     printf("password: ");
 240     fflush(stdout);
 241     term_init();
 242     i = 0;
 243     for(;;) {
 244         ret = read(0, &ch, 1);
 245         if (ret == -1) {
 246             if (errno == EAGAIN || errno == EINTR) {
 247                 continue;
 248             } else {
 249                 break;
 250             }
 251         } else if (ret == 0) {
 252             ret = -1;
 253             break;
 254         } else {
 255             if (ch == '\r') {
 256                 ret = 0;
 257                 break;
 258             }
 259             if (i < (buf_size - 1))
 260                 buf[i++] = ch;
 261         }
 262     }
 263     term_exit();
 264     buf[i] = '\0';
 265     printf("\n");
 266     return ret;
 267 }
 268 #endif
 269
 270 static int print_block_option_help(const char *filename, const char *fmt)
 271 {
 272     BlockDriver *drv, *proto_drv;
 273     QemuOptsList *create_opts = NULL;
 274
 275     /* Find driver and parse its options */
 276     drv = bdrv_find_format(fmt);
 277     if (!drv) {
 278         error_report("Unknown file format '%s'", fmt);
 279         return 1;
 280     }
 281
 282     create_opts = qemu_opts_append(create_opts, drv->create_opts);
 283     if (filename) {
 284         proto_drv = bdrv_find_protocol(filename, true);
 285         if (!proto_drv) {
 286             error_report("Unknown protocol '%s'", filename);
 287             qemu_opts_free(create_opts);
 288             return 1;
 289         }
 290         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 291     }
 292
 293     qemu_opts_print_help(create_opts);
 294     qemu_opts_free(create_opts);
 295     return 0;
 296 }
 297
 298 static BlockDriverState *bdrv_new_open(const char *id,
 299                                        const char *filename,
 300                                        const char *fmt,
 301                                        int flags,
 302                                        bool require_io,
 303                                        bool quiet)
 304 {
 305     BlockDriverState *bs;
 306     BlockDriver *drv;
 307     char password[256];
 308     Error *local_err = NULL;
 309     int ret;
 310
 311     bs = bdrv_new(id, &error_abort);
 312
 313     if (fmt) {
 314         drv = bdrv_find_format(fmt);
 315         if (!drv) {
 316             error_report("Unknown file format '%s'", fmt);
 317             goto fail;
 318         }
 319     } else {
 320         drv = NULL;
 321     }
 322
 323     ret = bdrv_open(&bs, filename, NULL, NULL, flags, drv, &local_err);
 324     if (ret < 0) {
 325         error_report("Could not open '%s': %s", filename,
 326                      error_get_pretty(local_err));
 327         error_free(local_err);
 328         goto fail;
 329     }
 330
 331     if (bdrv_is_encrypted(bs) && require_io) {
 332         qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
 333         if (read_password(password, sizeof(password)) < 0) {
 334             error_report("No password given");
 335             goto fail;
 336         }
 337         if (bdrv_set_key(bs, password) < 0) {
 338             error_report("invalid password");
 339             goto fail;
 340         }
 341     }
 342     return bs;
 343 fail:
 344     bdrv_unref(bs);
 345     return NULL;
 346 }
 347
 348 static int add_old_style_options(const char *fmt, QemuOpts *opts,
 349                                  const char *base_filename,
 350                                  const char *base_fmt)
 351 {
 352     if (base_filename) {
 353         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
 354             error_report("Backing file not supported for file format '%s'",
 355                          fmt);
 356             return -1;
 357         }
 358     }
 359     if (base_fmt) {
 360         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 361             error_report("Backing file format not supported for file "
 362                          "format '%s'", fmt);
 363             return -1;
 364         }
 365     }
 366     return 0;
 367 }
 368
 369 static int img_create(int argc, char **argv)
 370 {
 371     int c;
 372     uint64_t img_size = -1;
 373     const char *fmt = "raw";
 374     const char *base_fmt = NULL;
 375     const char *filename;
 376     const char *base_filename = NULL;
 377     char *options = NULL;
 378     Error *local_err = NULL;
 379     bool quiet = false;
 380
 381     for(;;) {
 382         c = getopt(argc, argv, "F:b:f:he6o:q");
 383         if (c == -1) {
 384             break;
 385         }
 386         switch(c) {
 387         case '?':
 388         case 'h':
 389             help();
 390             break;
 391         case 'F':
 392             base_fmt = optarg;
 393             break;
 394         case 'b':
 395             base_filename = optarg;
 396             break;
 397         case 'f':
 398             fmt = optarg;
 399             break;
 400         case 'e':
 401             error_report("option -e is deprecated, please use \'-o "
 402                   "encryption\' instead!");
 403             goto fail;
 404         case '6':
 405             error_report("option -6 is deprecated, please use \'-o "
 406                   "compat6\' instead!");
 407             goto fail;
 408         case 'o':
 409             if (!is_valid_option_list(optarg)) {
 410                 error_report("Invalid option list: %s", optarg);
 411                 goto fail;
 412             }
 413             if (!options) {
 414                 options = g_strdup(optarg);
 415             } else {
 416                 char *old_options = options;
 417                 options = g_strdup_printf("%s,%s", options, optarg);
 418                 g_free(old_options);
 419             }
 420             break;
 421         case 'q':
 422             quiet = true;
 423             break;
 424         }
 425     }
 426
 427     /* Get the filename */
 428     filename = (optind < argc) ? argv[optind] : NULL;
 429     if (options && has_help_option(options)) {
 430         g_free(options);
 431         return print_block_option_help(filename, fmt);
 432     }
 433
 434     if (optind >= argc) {
 435         error_exit("Expecting image file name");
 436     }
 437     optind++;
 438
 439     /* Get image size, if specified */
 440     if (optind < argc) {
 441         int64_t sval;
 442         char *end;
 443         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 444         if (sval < 0 || *end) {
 445             if (sval == -ERANGE) {
 446                 error_report("Image size must be less than 8 EiB!");
 447             } else {
 448                 error_report("Invalid image size specified! You may use k, M, "
 449                       "G, T, P or E suffixes for ");
 450                 error_report("kilobytes, megabytes, gigabytes, terabytes, "
 451                              "petabytes and exabytes.");
 452             }
 453             goto fail;
 454         }
 455         img_size = (uint64_t)sval;
 456     }
 457     if (optind != argc) {
 458         error_exit("Unexpected argument: %s", argv[optind]);
 459     }
 460
 461     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 462                     options, img_size, BDRV_O_FLAGS, &local_err, quiet);
 463     if (local_err) {
 464         error_report("%s: %s", filename, error_get_pretty(local_err));
 465         error_free(local_err);
 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),
 484                           &check, NULL, &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;
 590     BlockDriverState *bs;
 591     int fix = 0;
 592     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 593     ImageCheck *check;
 594     bool quiet = false;
 595
 596     fmt = NULL;
 597     output = NULL;
 598     for(;;) {
 599         int option_index = 0;
 600         static const struct option long_options[] = {
 601             {"help", no_argument, 0, 'h'},
 602             {"format", required_argument, 0, 'f'},
 603             {"repair", required_argument, 0, 'r'},
 604             {"output", required_argument, 0, OPTION_OUTPUT},
 605             {0, 0, 0, 0}
 606         };
 607         c = getopt_long(argc, argv, "f:hr:q",
 608                         long_options, &option_index);
 609         if (c == -1) {
 610             break;
 611         }
 612         switch(c) {
 613         case '?':
 614         case 'h':
 615             help();
 616             break;
 617         case 'f':
 618             fmt = optarg;
 619             break;
 620         case 'r':
 621             flags |= BDRV_O_RDWR;
 622
 623             if (!strcmp(optarg, "leaks")) {
 624                 fix = BDRV_FIX_LEAKS;
 625             } else if (!strcmp(optarg, "all")) {
 626                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 627             } else {
 628                 error_exit("Unknown option value for -r "
 629                            "(expecting 'leaks' or 'all'): %s", optarg);
 630             }
 631             break;
 632         case OPTION_OUTPUT:
 633             output = optarg;
 634             break;
 635         case 'q':
 636             quiet = true;
 637             break;
 638         }
 639     }
 640     if (optind != argc - 1) {
 641         error_exit("Expecting one image file name");
 642     }
 643     filename = argv[optind++];
 644
 645     if (output && !strcmp(output, "json")) {
 646         output_format = OFORMAT_JSON;
 647     } else if (output && !strcmp(output, "human")) {
 648         output_format = OFORMAT_HUMAN;
 649     } else if (output) {
 650         error_report("--output must be used with human or json as argument.");
 651         return 1;
 652     }
 653
 654     bs = bdrv_new_open("image", filename, fmt, flags, true, quiet);
 655     if (!bs) {
 656         return 1;
 657     }
 658
 659     check = g_new0(ImageCheck, 1);
 660     ret = collect_image_check(bs, check, filename, fmt, fix);
 661
 662     if (ret == -ENOTSUP) {
 663         error_report("This image format does not support checks");
 664         ret = 63;
 665         goto fail;
 666     }
 667
 668     if (check->corruptions_fixed || check->leaks_fixed) {
 669         int corruptions_fixed, leaks_fixed;
 670
 671         leaks_fixed         = check->leaks_fixed;
 672         corruptions_fixed   = check->corruptions_fixed;
 673
 674         if (output_format == OFORMAT_HUMAN) {
 675             qprintf(quiet,
 676                     "The following inconsistencies were found and repaired:\n\n"
 677                     "    %" PRId64 " leaked clusters\n"
 678                     "    %" PRId64 " corruptions\n\n"
 679                     "Double checking the fixed image now...\n",
 680                     check->leaks_fixed,
 681                     check->corruptions_fixed);
 682         }
 683
 684         ret = collect_image_check(bs, check, filename, fmt, 0);
 685
 686         check->leaks_fixed          = leaks_fixed;
 687         check->corruptions_fixed    = corruptions_fixed;
 688     }
 689
 690     switch (output_format) {
 691     case OFORMAT_HUMAN:
 692         dump_human_image_check(check, quiet);
 693         break;
 694     case OFORMAT_JSON:
 695         dump_json_image_check(check, quiet);
 696         break;
 697     }
 698
 699     if (ret || check->check_errors) {
 700         ret = 1;
 701         goto fail;
 702     }
 703
 704     if (check->corruptions) {
 705         ret = 2;
 706     } else if (check->leaks) {
 707         ret = 3;
 708     } else {
 709         ret = 0;
 710     }
 711
 712 fail:
 713     qapi_free_ImageCheck(check);
 714     bdrv_unref(bs);
 715
 716     return ret;
 717 }
 718
 719 static int img_commit(int argc, char **argv)
 720 {
 721     int c, ret, flags;
 722     const char *filename, *fmt, *cache;
 723     BlockDriverState *bs;
 724     bool quiet = false;
 725
 726     fmt = NULL;
 727     cache = BDRV_DEFAULT_CACHE;
 728     for(;;) {
 729         c = getopt(argc, argv, "f:ht:q");
 730         if (c == -1) {
 731             break;
 732         }
 733         switch(c) {
 734         case '?':
 735         case 'h':
 736             help();
 737             break;
 738         case 'f':
 739             fmt = optarg;
 740             break;
 741         case 't':
 742             cache = optarg;
 743             break;
 744         case 'q':
 745             quiet = true;
 746             break;
 747         }
 748     }
 749     if (optind != argc - 1) {
 750         error_exit("Expecting one image file name");
 751     }
 752     filename = argv[optind++];
 753
 754     flags = BDRV_O_RDWR;
 755     ret = bdrv_parse_cache_flags(cache, &flags);
 756     if (ret < 0) {
 757         error_report("Invalid cache option: %s", cache);
 758         return -1;
 759     }
 760
 761     bs = bdrv_new_open("image", filename, fmt, flags, true, quiet);
 762     if (!bs) {
 763         return 1;
 764     }
 765     ret = bdrv_commit(bs);
 766     switch(ret) {
 767     case 0:
 768         qprintf(quiet, "Image committed.\n");
 769         break;
 770     case -ENOENT:
 771         error_report("No disk inserted");
 772         break;
 773     case -EACCES:
 774         error_report("Image is read-only");
 775         break;
 776     case -ENOTSUP:
 777         error_report("Image is already committed");
 778         break;
 779     default:
 780         error_report("Error while committing image");
 781         break;
 782     }
 783
 784     bdrv_unref(bs);
 785     if (ret) {
 786         return 1;
 787     }
 788     return 0;
 789 }
 790
 791 /*
 792  * Returns true iff the first sector pointed to by 'buf' contains at least
 793  * a non-NUL byte.
 794  *
 795  * 'pnum' is set to the number of sectors (including and immediately following
 796  * the first one) that are known to be in the same allocated/unallocated state.
 797  */
 798 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 799 {
 800     bool is_zero;
 801     int i;
 802
 803     if (n <= 0) {
 804         *pnum = 0;
 805         return 0;
 806     }
 807     is_zero = buffer_is_zero(buf, 512);
 808     for(i = 1; i < n; i++) {
 809         buf += 512;
 810         if (is_zero != buffer_is_zero(buf, 512)) {
 811             break;
 812         }
 813     }
 814     *pnum = i;
 815     return !is_zero;
 816 }
 817
 818 /*
 819  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 820  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 821  * breaking up write requests for only small sparse areas.
 822  */
 823 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 824     int min)
 825 {
 826     int ret;
 827     int num_checked, num_used;
 828
 829     if (n < min) {
 830         min = n;
 831     }
 832
 833     ret = is_allocated_sectors(buf, n, pnum);
 834     if (!ret) {
 835         return ret;
 836     }
 837
 838     num_used = *pnum;
 839     buf += BDRV_SECTOR_SIZE * *pnum;
 840     n -= *pnum;
 841     num_checked = num_used;
 842
 843     while (n > 0) {
 844         ret = is_allocated_sectors(buf, n, pnum);
 845
 846         buf += BDRV_SECTOR_SIZE * *pnum;
 847         n -= *pnum;
 848         num_checked += *pnum;
 849         if (ret) {
 850             num_used = num_checked;
 851         } else if (*pnum >= min) {
 852             break;
 853         }
 854     }
 855
 856     *pnum = num_used;
 857     return 1;
 858 }
 859
 860 /*
 861  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 862  * buffers matches, non-zero otherwise.
 863  *
 864  * pnum is set to the number of sectors (including and immediately following
 865  * the first one) that are known to have the same comparison result
 866  */
 867 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 868     int *pnum)
 869 {
 870     int res, i;
 871
 872     if (n <= 0) {
 873         *pnum = 0;
 874         return 0;
 875     }
 876
 877     res = !!memcmp(buf1, buf2, 512);
 878     for(i = 1; i < n; i++) {
 879         buf1 += 512;
 880         buf2 += 512;
 881
 882         if (!!memcmp(buf1, buf2, 512) != res) {
 883             break;
 884         }
 885     }
 886
 887     *pnum = i;
 888     return res;
 889 }
 890
 891 #define IO_BUF_SIZE (2 * 1024 * 1024)
 892
 893 static int64_t sectors_to_bytes(int64_t sectors)
 894 {
 895     return sectors << BDRV_SECTOR_BITS;
 896 }
 897
 898 static int64_t sectors_to_process(int64_t total, int64_t from)
 899 {
 900     return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
 901 }
 902
 903 /*
 904  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
 905  *
 906  * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
 907  * data and negative value on error.
 908  *
 909  * @param bs:  Driver used for accessing file
 910  * @param sect_num: Number of first sector to check
 911  * @param sect_count: Number of sectors to check
 912  * @param filename: Name of disk file we are checking (logging purpose)
 913  * @param buffer: Allocated buffer for storing read data
 914  * @param quiet: Flag for quiet mode
 915  */
 916 static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
 917                                int sect_count, const char *filename,
 918                                uint8_t *buffer, bool quiet)
 919 {
 920     int pnum, ret = 0;
 921     ret = bdrv_read(bs, sect_num, buffer, sect_count);
 922     if (ret < 0) {
 923         error_report("Error while reading offset %" PRId64 " of %s: %s",
 924                      sectors_to_bytes(sect_num), filename, strerror(-ret));
 925         return ret;
 926     }
 927     ret = is_allocated_sectors(buffer, sect_count, &pnum);
 928     if (ret || pnum != sect_count) {
 929         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
 930                 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
 931         return 1;
 932     }
 933
 934     return 0;
 935 }
 936
 937 /*
 938  * Compares two images. Exit codes:
 939  *
 940  * 0 - Images are identical
 941  * 1 - Images differ
 942  * >1 - Error occurred
 943  */
 944 static int img_compare(int argc, char **argv)
 945 {
 946     const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
 947     BlockDriverState *bs1, *bs2;
 948     int64_t total_sectors1, total_sectors2;
 949     uint8_t *buf1 = NULL, *buf2 = NULL;
 950     int pnum1, pnum2;
 951     int allocated1, allocated2;
 952     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
 953     bool progress = false, quiet = false, strict = false;
 954     int64_t total_sectors;
 955     int64_t sector_num = 0;
 956     int64_t nb_sectors;
 957     int c, pnum;
 958     uint64_t progress_base;
 959
 960     for (;;) {
 961         c = getopt(argc, argv, "hpf:F:sq");
 962         if (c == -1) {
 963             break;
 964         }
 965         switch (c) {
 966         case '?':
 967         case 'h':
 968             help();
 969             break;
 970         case 'f':
 971             fmt1 = optarg;
 972             break;
 973         case 'F':
 974             fmt2 = optarg;
 975             break;
 976         case 'p':
 977             progress = true;
 978             break;
 979         case 'q':
 980             quiet = true;
 981             break;
 982         case 's':
 983             strict = true;
 984             break;
 985         }
 986     }
 987
 988     /* Progress is not shown in Quiet mode */
 989     if (quiet) {
 990         progress = false;
 991     }
 992
 993
 994     if (optind != argc - 2) {
 995         error_exit("Expecting two image file names");
 996     }
 997     filename1 = argv[optind++];
 998     filename2 = argv[optind++];
 999
1000     /* Initialize before goto out */
1001     qemu_progress_init(progress, 2.0);
1002
1003     bs1 = bdrv_new_open("image 1", filename1, fmt1, BDRV_O_FLAGS, true, quiet);
1004     if (!bs1) {
1005         error_report("Can't open file %s", filename1);
1006         ret = 2;
1007         goto out3;
1008     }
1009
1010     bs2 = bdrv_new_open("image 2", filename2, fmt2, BDRV_O_FLAGS, true, quiet);
1011     if (!bs2) {
1012         error_report("Can't open file %s", filename2);
1013         ret = 2;
1014         goto out2;
1015     }
1016
1017     buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
1018     buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
1019     total_sectors1 = bdrv_nb_sectors(bs1);
1020     if (total_sectors1 < 0) {
1021         error_report("Can't get size of %s: %s",
1022                      filename1, strerror(-total_sectors1));
1023         ret = 4;
1024         goto out;
1025     }
1026     total_sectors2 = bdrv_nb_sectors(bs2);
1027     if (total_sectors2 < 0) {
1028         error_report("Can't get size of %s: %s",
1029                      filename2, strerror(-total_sectors2));
1030         ret = 4;
1031         goto out;
1032     }
1033     total_sectors = MIN(total_sectors1, total_sectors2);
1034     progress_base = MAX(total_sectors1, total_sectors2);
1035
1036     qemu_progress_print(0, 100);
1037
1038     if (strict && total_sectors1 != total_sectors2) {
1039         ret = 1;
1040         qprintf(quiet, "Strict mode: Image size mismatch!\n");
1041         goto out;
1042     }
1043
1044     for (;;) {
1045         nb_sectors = sectors_to_process(total_sectors, sector_num);
1046         if (nb_sectors <= 0) {
1047             break;
1048         }
1049         allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
1050                                              &pnum1);
1051         if (allocated1 < 0) {
1052             ret = 3;
1053             error_report("Sector allocation test failed for %s", filename1);
1054             goto out;
1055         }
1056
1057         allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
1058                                              &pnum2);
1059         if (allocated2 < 0) {
1060             ret = 3;
1061             error_report("Sector allocation test failed for %s", filename2);
1062             goto out;
1063         }
1064         nb_sectors = MIN(pnum1, pnum2);
1065
1066         if (allocated1 == allocated2) {
1067             if (allocated1) {
1068                 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
1069                 if (ret < 0) {
1070                     error_report("Error while reading offset %" PRId64 " of %s:"
1071                                  " %s", sectors_to_bytes(sector_num), filename1,
1072                                  strerror(-ret));
1073                     ret = 4;
1074                     goto out;
1075                 }
1076                 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1077                 if (ret < 0) {
1078                     error_report("Error while reading offset %" PRId64
1079                                  " of %s: %s", sectors_to_bytes(sector_num),
1080                                  filename2, strerror(-ret));
1081                     ret = 4;
1082                     goto out;
1083                 }
1084                 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1085                 if (ret || pnum != nb_sectors) {
1086                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1087                             sectors_to_bytes(
1088                                 ret ? sector_num : sector_num + pnum));
1089                     ret = 1;
1090                     goto out;
1091                 }
1092             }
1093         } else {
1094             if (strict) {
1095                 ret = 1;
1096                 qprintf(quiet, "Strict mode: Offset %" PRId64
1097                         " allocation mismatch!\n",
1098                         sectors_to_bytes(sector_num));
1099                 goto out;
1100             }
1101
1102             if (allocated1) {
1103                 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1104                                           filename1, buf1, quiet);
1105             } else {
1106                 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1107                                           filename2, buf1, quiet);
1108             }
1109             if (ret) {
1110                 if (ret < 0) {
1111                     error_report("Error while reading offset %" PRId64 ": %s",
1112                                  sectors_to_bytes(sector_num), strerror(-ret));
1113                     ret = 4;
1114                 }
1115                 goto out;
1116             }
1117         }
1118         sector_num += nb_sectors;
1119         qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1120     }
1121
1122     if (total_sectors1 != total_sectors2) {
1123         BlockDriverState *bs_over;
1124         int64_t total_sectors_over;
1125         const char *filename_over;
1126
1127         qprintf(quiet, "Warning: Image size mismatch!\n");
1128         if (total_sectors1 > total_sectors2) {
1129             total_sectors_over = total_sectors1;
1130             bs_over = bs1;
1131             filename_over = filename1;
1132         } else {
1133             total_sectors_over = total_sectors2;
1134             bs_over = bs2;
1135             filename_over = filename2;
1136         }
1137
1138         for (;;) {
1139             nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1140             if (nb_sectors <= 0) {
1141                 break;
1142             }
1143             ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1144                                           nb_sectors, &pnum);
1145             if (ret < 0) {
1146                 ret = 3;
1147                 error_report("Sector allocation test failed for %s",
1148                              filename_over);
1149                 goto out;
1150
1151             }
1152             nb_sectors = pnum;
1153             if (ret) {
1154                 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1155                                           filename_over, buf1, quiet);
1156                 if (ret) {
1157                     if (ret < 0) {
1158                         error_report("Error while reading offset %" PRId64
1159                                      " of %s: %s", sectors_to_bytes(sector_num),
1160                                      filename_over, strerror(-ret));
1161                         ret = 4;
1162                     }
1163                     goto out;
1164                 }
1165             }
1166             sector_num += nb_sectors;
1167             qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1168         }
1169     }
1170
1171     qprintf(quiet, "Images are identical.\n");
1172     ret = 0;
1173
1174 out:
1175     bdrv_unref(bs2);
1176     qemu_vfree(buf1);
1177     qemu_vfree(buf2);
1178 out2:
1179     bdrv_unref(bs1);
1180 out3:
1181     qemu_progress_end();
1182     return ret;
1183 }
1184
1185 static int img_convert(int argc, char **argv)
1186 {
1187     int c, n, n1, bs_n, bs_i, compress, cluster_sectors, skip_create;
1188     int64_t ret = 0;
1189     int progress = 0, flags;
1190     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1191     BlockDriver *drv, *proto_drv;
1192     BlockDriverState **bs = NULL, *out_bs = NULL;
1193     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1194     int64_t *bs_sectors = NULL;
1195     uint8_t * buf = NULL;
1196     size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
1197     const uint8_t *buf1;
1198     BlockDriverInfo bdi;
1199     QemuOpts *opts = NULL;
1200     QemuOptsList *create_opts = NULL;
1201     const char *out_baseimg_param;
1202     char *options = NULL;
1203     const char *snapshot_name = NULL;
1204     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1205     bool quiet = false;
1206     Error *local_err = NULL;
1207     QemuOpts *sn_opts = NULL;
1208
1209     fmt = NULL;
1210     out_fmt = "raw";
1211     cache = "unsafe";
1212     out_baseimg = NULL;
1213     compress = 0;
1214     skip_create = 0;
1215     for(;;) {
1216         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:qnl:");
1217         if (c == -1) {
1218             break;
1219         }
1220         switch(c) {
1221         case '?':
1222         case 'h':
1223             help();
1224             break;
1225         case 'f':
1226             fmt = optarg;
1227             break;
1228         case 'O':
1229             out_fmt = optarg;
1230             break;
1231         case 'B':
1232             out_baseimg = optarg;
1233             break;
1234         case 'c':
1235             compress = 1;
1236             break;
1237         case 'e':
1238             error_report("option -e is deprecated, please use \'-o "
1239                   "encryption\' instead!");
1240             ret = -1;
1241             goto fail_getopt;
1242         case '6':
1243             error_report("option -6 is deprecated, please use \'-o "
1244                   "compat6\' instead!");
1245             ret = -1;
1246             goto fail_getopt;
1247         case 'o':
1248             if (!is_valid_option_list(optarg)) {
1249                 error_report("Invalid option list: %s", optarg);
1250                 ret = -1;
1251                 goto fail_getopt;
1252             }
1253             if (!options) {
1254                 options = g_strdup(optarg);
1255             } else {
1256                 char *old_options = options;
1257                 options = g_strdup_printf("%s,%s", options, optarg);
1258                 g_free(old_options);
1259             }
1260             break;
1261         case 's':
1262             snapshot_name = optarg;
1263             break;
1264         case 'l':
1265             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
1266                 sn_opts = qemu_opts_parse(&internal_snapshot_opts, optarg, 0);
1267                 if (!sn_opts) {
1268                     error_report("Failed in parsing snapshot param '%s'",
1269                                  optarg);
1270                     ret = -1;
1271                     goto fail_getopt;
1272                 }
1273             } else {
1274                 snapshot_name = optarg;
1275             }
1276             break;
1277         case 'S':
1278         {
1279             int64_t sval;
1280             char *end;
1281             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1282             if (sval < 0 || *end) {
1283                 error_report("Invalid minimum zero buffer size for sparse output specified");
1284                 ret = -1;
1285                 goto fail_getopt;
1286             }
1287
1288             min_sparse = sval / BDRV_SECTOR_SIZE;
1289             break;
1290         }
1291         case 'p':
1292             progress = 1;
1293             break;
1294         case 't':
1295             cache = optarg;
1296             break;
1297         case 'q':
1298             quiet = true;
1299             break;
1300         case 'n':
1301             skip_create = 1;
1302             break;
1303         }
1304     }
1305
1306     /* Initialize before goto out */
1307     if (quiet) {
1308         progress = 0;
1309     }
1310     qemu_progress_init(progress, 1.0);
1311
1312
1313     bs_n = argc - optind - 1;
1314     out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
1315
1316     if (options && has_help_option(options)) {
1317         ret = print_block_option_help(out_filename, out_fmt);
1318         goto out;
1319     }
1320
1321     if (bs_n < 1) {
1322         error_exit("Must specify image file name");
1323     }
1324
1325
1326     if (bs_n > 1 && out_baseimg) {
1327         error_report("-B makes no sense when concatenating multiple input "
1328                      "images");
1329         ret = -1;
1330         goto out;
1331     }
1332
1333     qemu_progress_print(0, 100);
1334
1335     bs = g_new0(BlockDriverState *, bs_n);
1336     bs_sectors = g_new(int64_t, bs_n);
1337
1338     total_sectors = 0;
1339     for (bs_i = 0; bs_i < bs_n; bs_i++) {
1340         char *id = bs_n > 1 ? g_strdup_printf("source %d", bs_i)
1341                             : g_strdup("source");
1342         bs[bs_i] = bdrv_new_open(id, argv[optind + bs_i], fmt, BDRV_O_FLAGS,
1343                                  true, quiet);
1344         g_free(id);
1345         if (!bs[bs_i]) {
1346             error_report("Could not open '%s'", argv[optind + bs_i]);
1347             ret = -1;
1348             goto out;
1349         }
1350         bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]);
1351         if (bs_sectors[bs_i] < 0) {
1352             error_report("Could not get size of %s: %s",
1353                          argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
1354             ret = -1;
1355             goto out;
1356         }
1357         total_sectors += bs_sectors[bs_i];
1358     }
1359
1360     if (sn_opts) {
1361         ret = bdrv_snapshot_load_tmp(bs[0],
1362                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1363                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1364                                      &local_err);
1365     } else if (snapshot_name != NULL) {
1366         if (bs_n > 1) {
1367             error_report("No support for concatenating multiple snapshot");
1368             ret = -1;
1369             goto out;
1370         }
1371
1372         bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
1373     }
1374     if (local_err) {
1375         error_report("Failed to load snapshot: %s",
1376                      error_get_pretty(local_err));
1377         error_free(local_err);
1378         ret = -1;
1379         goto out;
1380     }
1381
1382     /* Find driver and parse its options */
1383     drv = bdrv_find_format(out_fmt);
1384     if (!drv) {
1385         error_report("Unknown file format '%s'", out_fmt);
1386         ret = -1;
1387         goto out;
1388     }
1389
1390     proto_drv = bdrv_find_protocol(out_filename, true);
1391     if (!proto_drv) {
1392         error_report("Unknown protocol '%s'", out_filename);
1393         ret = -1;
1394         goto out;
1395     }
1396
1397     create_opts = qemu_opts_append(create_opts, drv->create_opts);
1398     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
1399
1400     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
1401     if (options && qemu_opts_do_parse(opts, options, NULL)) {
1402         error_report("Invalid options for file format '%s'", out_fmt);
1403         ret = -1;
1404         goto out;
1405     }
1406
1407     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512);
1408     ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
1409     if (ret < 0) {
1410         goto out;
1411     }
1412
1413     /* Get backing file name if -o backing_file was used */
1414     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
1415     if (out_baseimg_param) {
1416         out_baseimg = out_baseimg_param;
1417     }
1418
1419     /* Check if compression is supported */
1420     if (compress) {
1421         bool encryption =
1422             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
1423         const char *preallocation =
1424             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
1425
1426         if (!drv->bdrv_write_compressed) {
1427             error_report("Compression not supported for this file format");
1428             ret = -1;
1429             goto out;
1430         }
1431
1432         if (encryption) {
1433             error_report("Compression and encryption not supported at "
1434                          "the same time");
1435             ret = -1;
1436             goto out;
1437         }
1438
1439         if (preallocation
1440             && strcmp(preallocation, "off"))
1441         {
1442             error_report("Compression and preallocation not supported at "
1443                          "the same time");
1444             ret = -1;
1445             goto out;
1446         }
1447     }
1448
1449     if (!skip_create) {
1450         /* Create the new image */
1451         ret = bdrv_create(drv, out_filename, opts, &local_err);
1452         if (ret < 0) {
1453             error_report("%s: error while converting %s: %s",
1454                          out_filename, out_fmt, error_get_pretty(local_err));
1455             error_free(local_err);
1456             goto out;
1457         }
1458     }
1459
1460     flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
1461     ret = bdrv_parse_cache_flags(cache, &flags);
1462     if (ret < 0) {
1463         error_report("Invalid cache option: %s", cache);
1464         goto out;
1465     }
1466
1467     out_bs = bdrv_new_open("target", out_filename, out_fmt, flags, true, quiet);
1468     if (!out_bs) {
1469         ret = -1;
1470         goto out;
1471     }
1472
1473     bs_i = 0;
1474     bs_offset = 0;
1475
1476     /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
1477      * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
1478      * as maximum. */
1479     bufsectors = MIN(32768,
1480                      MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
1481                                          out_bs->bl.discard_alignment))
1482                     );
1483
1484     buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE);
1485
1486     if (skip_create) {
1487         int64_t output_sectors = bdrv_nb_sectors(out_bs);
1488         if (output_sectors < 0) {
1489             error_report("unable to get output image length: %s\n",
1490                          strerror(-output_sectors));
1491             ret = -1;
1492             goto out;
1493         } else if (output_sectors < total_sectors) {
1494             error_report("output file is smaller than input file");
1495             ret = -1;
1496             goto out;
1497         }
1498     }
1499
1500     cluster_sectors = 0;
1501     ret = bdrv_get_info(out_bs, &bdi);
1502     if (ret < 0) {
1503         if (compress) {
1504             error_report("could not get block driver info");
1505             goto out;
1506         }
1507     } else {
1508         compress = compress || bdi.needs_compressed_writes;
1509         cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
1510     }
1511
1512     if (compress) {
1513         if (cluster_sectors <= 0 || cluster_sectors > bufsectors) {
1514             error_report("invalid cluster size");
1515             ret = -1;
1516             goto out;
1517         }
1518         sector_num = 0;
1519
1520         nb_sectors = total_sectors;
1521
1522         for(;;) {
1523             int64_t bs_num;
1524             int remainder;
1525             uint8_t *buf2;
1526
1527             nb_sectors = total_sectors - sector_num;
1528             if (nb_sectors <= 0)
1529                 break;
1530             if (nb_sectors >= cluster_sectors)
1531                 n = cluster_sectors;
1532             else
1533                 n = nb_sectors;
1534
1535             bs_num = sector_num - bs_offset;
1536             assert (bs_num >= 0);
1537             remainder = n;
1538             buf2 = buf;
1539             while (remainder > 0) {
1540                 int nlow;
1541                 while (bs_num == bs_sectors[bs_i]) {
1542                     bs_offset += bs_sectors[bs_i];
1543                     bs_i++;
1544                     assert (bs_i < bs_n);
1545                     bs_num = 0;
1546                     /* printf("changing part: sector_num=%" PRId64 ", "
1547                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1548                        "\n", sector_num, bs_i, bs_offset, bs_sectors[bs_i]); */
1549                 }
1550                 assert (bs_num < bs_sectors[bs_i]);
1551
1552                 nlow = remainder > bs_sectors[bs_i] - bs_num
1553                     ? bs_sectors[bs_i] - bs_num : remainder;
1554
1555                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1556                 if (ret < 0) {
1557                     error_report("error while reading sector %" PRId64 ": %s",
1558                                  bs_num, strerror(-ret));
1559                     goto out;
1560                 }
1561
1562                 buf2 += nlow * 512;
1563                 bs_num += nlow;
1564
1565                 remainder -= nlow;
1566             }
1567             assert (remainder == 0);
1568
1569             if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1570                 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1571                 if (ret != 0) {
1572                     error_report("error while compressing sector %" PRId64
1573                                  ": %s", sector_num, strerror(-ret));
1574                     goto out;
1575                 }
1576             }
1577             sector_num += n;
1578             qemu_progress_print(100.0 * sector_num / total_sectors, 0);
1579         }
1580         /* signal EOF to align */
1581         bdrv_write_compressed(out_bs, 0, NULL, 0);
1582     } else {
1583         int64_t sectors_to_read, sectors_read, sector_num_next_status;
1584         bool count_allocated_sectors;
1585         int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0;
1586
1587         if (!has_zero_init && bdrv_can_write_zeroes_with_unmap(out_bs)) {
1588             ret = bdrv_make_zero(out_bs, BDRV_REQ_MAY_UNMAP);
1589             if (ret < 0) {
1590                 goto out;
1591             }
1592             has_zero_init = 1;
1593         }
1594
1595         sectors_to_read = total_sectors;
1596         count_allocated_sectors = progress && (out_baseimg || has_zero_init);
1597 restart:
1598         sector_num = 0; // total number of sectors converted so far
1599         sectors_read = 0;
1600         sector_num_next_status = 0;
1601
1602         for(;;) {
1603             nb_sectors = total_sectors - sector_num;
1604             if (nb_sectors <= 0) {
1605                 if (count_allocated_sectors) {
1606                     sectors_to_read = sectors_read;
1607                     count_allocated_sectors = false;
1608                     goto restart;
1609                 }
1610                 ret = 0;
1611                 break;
1612             }
1613
1614             while (sector_num - bs_offset >= bs_sectors[bs_i]) {
1615                 bs_offset += bs_sectors[bs_i];
1616                 bs_i ++;
1617                 assert (bs_i < bs_n);
1618                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1619                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1620                    sector_num, bs_i, bs_offset, bs_sectors[bs_i]); */
1621             }
1622
1623             if ((out_baseimg || has_zero_init) &&
1624                 sector_num >= sector_num_next_status) {
1625                 n = nb_sectors > INT_MAX ? INT_MAX : nb_sectors;
1626                 ret = bdrv_get_block_status(bs[bs_i], sector_num - bs_offset,
1627                                             n, &n1);
1628                 if (ret < 0) {
1629                     error_report("error while reading block status of sector %"
1630                                  PRId64 ": %s", sector_num - bs_offset,
1631                                  strerror(-ret));
1632                     goto out;
1633                 }
1634                 /* If the output image is zero initialized, we are not working
1635                  * on a shared base and the input is zero we can skip the next
1636                  * n1 sectors */
1637                 if (has_zero_init && !out_baseimg && (ret & BDRV_BLOCK_ZERO)) {
1638                     sector_num += n1;
1639                     continue;
1640                 }
1641                 /* If the output image is being created as a copy on write
1642                  * image, assume that sectors which are unallocated in the
1643                  * input image are present in both the output's and input's
1644                  * base images (no need to copy them). */
1645                 if (out_baseimg) {
1646                     if (!(ret & BDRV_BLOCK_DATA)) {
1647                         sector_num += n1;
1648                         continue;
1649                     }
1650                     /* The next 'n1' sectors are allocated in the input image.
1651                      * Copy only those as they may be followed by unallocated
1652                      * sectors. */
1653                     nb_sectors = n1;
1654                 }
1655                 /* avoid redundant callouts to get_block_status */
1656                 sector_num_next_status = sector_num + n1;
1657             }
1658
1659             n = MIN(nb_sectors, bufsectors);
1660
1661             /* round down request length to an aligned sector, but
1662              * do not bother doing this on short requests. They happen
1663              * when we found an all-zero area, and the next sector to
1664              * write will not be sector_num + n. */
1665             if (cluster_sectors > 0 && n >= cluster_sectors) {
1666                 int64_t next_aligned_sector = (sector_num + n);
1667                 next_aligned_sector -= next_aligned_sector % cluster_sectors;
1668                 if (sector_num + n > next_aligned_sector) {
1669                     n = next_aligned_sector - sector_num;
1670                 }
1671             }
1672
1673             n = MIN(n, bs_sectors[bs_i] - (sector_num - bs_offset));
1674
1675             sectors_read += n;
1676             if (count_allocated_sectors) {
1677                 sector_num += n;
1678                 continue;
1679             }
1680
1681             n1 = n;
1682             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1683             if (ret < 0) {
1684                 error_report("error while reading sector %" PRId64 ": %s",
1685                              sector_num - bs_offset, strerror(-ret));
1686                 goto out;
1687             }
1688             /* NOTE: at the same time we convert, we do not write zero
1689                sectors to have a chance to compress the image. Ideally, we
1690                should add a specific call to have the info to go faster */
1691             buf1 = buf;
1692             while (n > 0) {
1693                 if (!has_zero_init ||
1694                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1695                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1696                     if (ret < 0) {
1697                         error_report("error while writing sector %" PRId64
1698                                      ": %s", sector_num, strerror(-ret));
1699                         goto out;
1700                     }
1701                 }
1702                 sector_num += n1;
1703                 n -= n1;
1704                 buf1 += n1 * 512;
1705             }
1706             qemu_progress_print(100.0 * sectors_read / sectors_to_read, 0);
1707         }
1708     }
1709 out:
1710     if (!ret) {
1711         qemu_progress_print(100, 0);
1712     }
1713     qemu_progress_end();
1714     qemu_opts_del(opts);
1715     qemu_opts_free(create_opts);
1716     qemu_vfree(buf);
1717     if (sn_opts) {
1718         qemu_opts_del(sn_opts);
1719     }
1720     if (out_bs) {
1721         bdrv_unref(out_bs);
1722     }
1723     if (bs) {
1724         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1725             if (bs[bs_i]) {
1726                 bdrv_unref(bs[bs_i]);
1727             }
1728         }
1729         g_free(bs);
1730     }
1731     g_free(bs_sectors);
1732 fail_getopt:
1733     g_free(options);
1734
1735     if (ret) {
1736         return 1;
1737     }
1738     return 0;
1739 }
1740
1741
1742 static void dump_snapshots(BlockDriverState *bs)
1743 {
1744     QEMUSnapshotInfo *sn_tab, *sn;
1745     int nb_sns, i;
1746
1747     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1748     if (nb_sns <= 0)
1749         return;
1750     printf("Snapshot list:\n");
1751     bdrv_snapshot_dump(fprintf, stdout, NULL);
1752     printf("\n");
1753     for(i = 0; i < nb_sns; i++) {
1754         sn = &sn_tab[i];
1755         bdrv_snapshot_dump(fprintf, stdout, sn);
1756         printf("\n");
1757     }
1758     g_free(sn_tab);
1759 }
1760
1761 static void dump_json_image_info_list(ImageInfoList *list)
1762 {
1763     Error *local_err = NULL;
1764     QString *str;
1765     QmpOutputVisitor *ov = qmp_output_visitor_new();
1766     QObject *obj;
1767     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1768                              &list, NULL, &local_err);
1769     obj = qmp_output_get_qobject(ov);
1770     str = qobject_to_json_pretty(obj);
1771     assert(str != NULL);
1772     printf("%s\n", qstring_get_str(str));
1773     qobject_decref(obj);
1774     qmp_output_visitor_cleanup(ov);
1775     QDECREF(str);
1776 }
1777
1778 static void dump_json_image_info(ImageInfo *info)
1779 {
1780     Error *local_err = NULL;
1781     QString *str;
1782     QmpOutputVisitor *ov = qmp_output_visitor_new();
1783     QObject *obj;
1784     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1785                          &info, NULL, &local_err);
1786     obj = qmp_output_get_qobject(ov);
1787     str = qobject_to_json_pretty(obj);
1788     assert(str != NULL);
1789     printf("%s\n", qstring_get_str(str));
1790     qobject_decref(obj);
1791     qmp_output_visitor_cleanup(ov);
1792     QDECREF(str);
1793 }
1794
1795 static void dump_human_image_info_list(ImageInfoList *list)
1796 {
1797     ImageInfoList *elem;
1798     bool delim = false;
1799
1800     for (elem = list; elem; elem = elem->next) {
1801         if (delim) {
1802             printf("\n");
1803         }
1804         delim = true;
1805
1806         bdrv_image_info_dump(fprintf, stdout, elem->value);
1807     }
1808 }
1809
1810 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1811 {
1812     return strcmp(a, b) == 0;
1813 }
1814
1815 /**
1816  * Open an image file chain and return an ImageInfoList
1817  *
1818  * @filename: topmost image filename
1819  * @fmt: topmost image format (may be NULL to autodetect)
1820  * @chain: true  - enumerate entire backing file chain
1821  *         false - only topmost image file
1822  *
1823  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1824  * image file.  If there was an error a message will have been printed to
1825  * stderr.
1826  */
1827 static ImageInfoList *collect_image_info_list(const char *filename,
1828                                               const char *fmt,
1829                                               bool chain)
1830 {
1831     ImageInfoList *head = NULL;
1832     ImageInfoList **last = &head;
1833     GHashTable *filenames;
1834     Error *err = NULL;
1835
1836     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1837
1838     while (filename) {
1839         BlockDriverState *bs;
1840         ImageInfo *info;
1841         ImageInfoList *elem;
1842
1843         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1844             error_report("Backing file '%s' creates an infinite loop.",
1845                          filename);
1846             goto err;
1847         }
1848         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1849
1850         bs = bdrv_new_open("image", filename, fmt,
1851                            BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
1852         if (!bs) {
1853             goto err;
1854         }
1855
1856         bdrv_query_image_info(bs, &info, &err);
1857         if (err) {
1858             error_report("%s", error_get_pretty(err));
1859             error_free(err);
1860             bdrv_unref(bs);
1861             goto err;
1862         }
1863
1864         elem = g_new0(ImageInfoList, 1);
1865         elem->value = info;
1866         *last = elem;
1867         last = &elem->next;
1868
1869         bdrv_unref(bs);
1870
1871         filename = fmt = NULL;
1872         if (chain) {
1873             if (info->has_full_backing_filename) {
1874                 filename = info->full_backing_filename;
1875             } else if (info->has_backing_filename) {
1876                 filename = info->backing_filename;
1877             }
1878             if (info->has_backing_filename_format) {
1879                 fmt = info->backing_filename_format;
1880             }
1881         }
1882     }
1883     g_hash_table_destroy(filenames);
1884     return head;
1885
1886 err:
1887     qapi_free_ImageInfoList(head);
1888     g_hash_table_destroy(filenames);
1889     return NULL;
1890 }
1891
1892 static int img_info(int argc, char **argv)
1893 {
1894     int c;
1895     OutputFormat output_format = OFORMAT_HUMAN;
1896     bool chain = false;
1897     const char *filename, *fmt, *output;
1898     ImageInfoList *list;
1899
1900     fmt = NULL;
1901     output = NULL;
1902     for(;;) {
1903         int option_index = 0;
1904         static const struct option long_options[] = {
1905             {"help", no_argument, 0, 'h'},
1906             {"format", required_argument, 0, 'f'},
1907             {"output", required_argument, 0, OPTION_OUTPUT},
1908             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1909             {0, 0, 0, 0}
1910         };
1911         c = getopt_long(argc, argv, "f:h",
1912                         long_options, &option_index);
1913         if (c == -1) {
1914             break;
1915         }
1916         switch(c) {
1917         case '?':
1918         case 'h':
1919             help();
1920             break;
1921         case 'f':
1922             fmt = optarg;
1923             break;
1924         case OPTION_OUTPUT:
1925             output = optarg;
1926             break;
1927         case OPTION_BACKING_CHAIN:
1928             chain = true;
1929             break;
1930         }
1931     }
1932     if (optind != argc - 1) {
1933         error_exit("Expecting one image file name");
1934     }
1935     filename = argv[optind++];
1936
1937     if (output && !strcmp(output, "json")) {
1938         output_format = OFORMAT_JSON;
1939     } else if (output && !strcmp(output, "human")) {
1940         output_format = OFORMAT_HUMAN;
1941     } else if (output) {
1942         error_report("--output must be used with human or json as argument.");
1943         return 1;
1944     }
1945
1946     list = collect_image_info_list(filename, fmt, chain);
1947     if (!list) {
1948         return 1;
1949     }
1950
1951     switch (output_format) {
1952     case OFORMAT_HUMAN:
1953         dump_human_image_info_list(list);
1954         break;
1955     case OFORMAT_JSON:
1956         if (chain) {
1957             dump_json_image_info_list(list);
1958         } else {
1959             dump_json_image_info(list->value);
1960         }
1961         break;
1962     }
1963
1964     qapi_free_ImageInfoList(list);
1965     return 0;
1966 }
1967
1968
1969 typedef struct MapEntry {
1970     int flags;
1971     int depth;
1972     int64_t start;
1973     int64_t length;
1974     int64_t offset;
1975     BlockDriverState *bs;
1976 } MapEntry;
1977
1978 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
1979                            MapEntry *next)
1980 {
1981     switch (output_format) {
1982     case OFORMAT_HUMAN:
1983         if ((e->flags & BDRV_BLOCK_DATA) &&
1984             !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
1985             error_report("File contains external, encrypted or compressed clusters.");
1986             exit(1);
1987         }
1988         if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
1989             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
1990                    e->start, e->length, e->offset, e->bs->filename);
1991         }
1992         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
1993          * Modify the flags here to allow more coalescing.
1994          */
1995         if (next &&
1996             (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
1997             next->flags &= ~BDRV_BLOCK_DATA;
1998             next->flags |= BDRV_BLOCK_ZERO;
1999         }
2000         break;
2001     case OFORMAT_JSON:
2002         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
2003                " \"zero\": %s, \"data\": %s",
2004                (e->start == 0 ? "[" : ",\n"),
2005                e->start, e->length, e->depth,
2006                (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
2007                (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
2008         if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
2009             printf(", \"offset\": %"PRId64"", e->offset);
2010         }
2011         putchar('}');
2012
2013         if (!next) {
2014             printf("]\n");
2015         }
2016         break;
2017     }
2018 }
2019
2020 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2021                             int nb_sectors, MapEntry *e)
2022 {
2023     int64_t ret;
2024     int depth;
2025
2026     /* As an optimization, we could cache the current range of unallocated
2027      * clusters in each file of the chain, and avoid querying the same
2028      * range repeatedly.
2029      */
2030
2031     depth = 0;
2032     for (;;) {
2033         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
2034         if (ret < 0) {
2035             return ret;
2036         }
2037         assert(nb_sectors);
2038         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2039             break;
2040         }
2041         bs = bs->backing_hd;
2042         if (bs == NULL) {
2043             ret = 0;
2044             break;
2045         }
2046
2047         depth++;
2048     }
2049
2050     e->start = sector_num * BDRV_SECTOR_SIZE;
2051     e->length = nb_sectors * BDRV_SECTOR_SIZE;
2052     e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
2053     e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
2054     e->depth = depth;
2055     e->bs = bs;
2056     return 0;
2057 }
2058
2059 static int img_map(int argc, char **argv)
2060 {
2061     int c;
2062     OutputFormat output_format = OFORMAT_HUMAN;
2063     BlockDriverState *bs;
2064     const char *filename, *fmt, *output;
2065     int64_t length;
2066     MapEntry curr = { .length = 0 }, next;
2067     int ret = 0;
2068
2069     fmt = NULL;
2070     output = NULL;
2071     for (;;) {
2072         int option_index = 0;
2073         static const struct option long_options[] = {
2074             {"help", no_argument, 0, 'h'},
2075             {"format", required_argument, 0, 'f'},
2076             {"output", required_argument, 0, OPTION_OUTPUT},
2077             {0, 0, 0, 0}
2078         };
2079         c = getopt_long(argc, argv, "f:h",
2080                         long_options, &option_index);
2081         if (c == -1) {
2082             break;
2083         }
2084         switch (c) {
2085         case '?':
2086         case 'h':
2087             help();
2088             break;
2089         case 'f':
2090             fmt = optarg;
2091             break;
2092         case OPTION_OUTPUT:
2093             output = optarg;
2094             break;
2095         }
2096     }
2097     if (optind != argc - 1) {
2098         error_exit("Expecting one image file name");
2099     }
2100     filename = argv[optind];
2101
2102     if (output && !strcmp(output, "json")) {
2103         output_format = OFORMAT_JSON;
2104     } else if (output && !strcmp(output, "human")) {
2105         output_format = OFORMAT_HUMAN;
2106     } else if (output) {
2107         error_report("--output must be used with human or json as argument.");
2108         return 1;
2109     }
2110
2111     bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
2112     if (!bs) {
2113         return 1;
2114     }
2115
2116     if (output_format == OFORMAT_HUMAN) {
2117         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2118     }
2119
2120     length = bdrv_getlength(bs);
2121     while (curr.start + curr.length < length) {
2122         int64_t nsectors_left;
2123         int64_t sector_num;
2124         int n;
2125
2126         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2127
2128         /* Probe up to 1 GiB at a time.  */
2129         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2130         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2131         ret = get_block_status(bs, sector_num, n, &next);
2132
2133         if (ret < 0) {
2134             error_report("Could not read file metadata: %s", strerror(-ret));
2135             goto out;
2136         }
2137
2138         if (curr.length != 0 && curr.flags == next.flags &&
2139             curr.depth == next.depth &&
2140             ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
2141              curr.offset + curr.length == next.offset)) {
2142             curr.length += next.length;
2143             continue;
2144         }
2145
2146         if (curr.length > 0) {
2147             dump_map_entry(output_format, &curr, &next);
2148         }
2149         curr = next;
2150     }
2151
2152     dump_map_entry(output_format, &curr, NULL);
2153
2154 out:
2155     bdrv_unref(bs);
2156     return ret < 0;
2157 }
2158
2159 #define SNAPSHOT_LIST   1
2160 #define SNAPSHOT_CREATE 2
2161 #define SNAPSHOT_APPLY  3
2162 #define SNAPSHOT_DELETE 4
2163
2164 static int img_snapshot(int argc, char **argv)
2165 {
2166     BlockDriverState *bs;
2167     QEMUSnapshotInfo sn;
2168     char *filename, *snapshot_name = NULL;
2169     int c, ret = 0, bdrv_oflags;
2170     int action = 0;
2171     qemu_timeval tv;
2172     bool quiet = false;
2173     Error *err = NULL;
2174
2175     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2176     /* Parse commandline parameters */
2177     for(;;) {
2178         c = getopt(argc, argv, "la:c:d:hq");
2179         if (c == -1) {
2180             break;
2181         }
2182         switch(c) {
2183         case '?':
2184         case 'h':
2185             help();
2186             return 0;
2187         case 'l':
2188             if (action) {
2189                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2190                 return 0;
2191             }
2192             action = SNAPSHOT_LIST;
2193             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2194             break;
2195         case 'a':
2196             if (action) {
2197                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2198                 return 0;
2199             }
2200             action = SNAPSHOT_APPLY;
2201             snapshot_name = optarg;
2202             break;
2203         case 'c':
2204             if (action) {
2205                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2206                 return 0;
2207             }
2208             action = SNAPSHOT_CREATE;
2209             snapshot_name = optarg;
2210             break;
2211         case 'd':
2212             if (action) {
2213                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2214                 return 0;
2215             }
2216             action = SNAPSHOT_DELETE;
2217             snapshot_name = optarg;
2218             break;
2219         case 'q':
2220             quiet = true;
2221             break;
2222         }
2223     }
2224
2225     if (optind != argc - 1) {
2226         error_exit("Expecting one image file name");
2227     }
2228     filename = argv[optind++];
2229
2230     /* Open the image */
2231     bs = bdrv_new_open("image", filename, NULL, bdrv_oflags, true, quiet);
2232     if (!bs) {
2233         return 1;
2234     }
2235
2236     /* Perform the requested action */
2237     switch(action) {
2238     case SNAPSHOT_LIST:
2239         dump_snapshots(bs);
2240         break;
2241
2242     case SNAPSHOT_CREATE:
2243         memset(&sn, 0, sizeof(sn));
2244         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2245
2246         qemu_gettimeofday(&tv);
2247         sn.date_sec = tv.tv_sec;
2248         sn.date_nsec = tv.tv_usec * 1000;
2249
2250         ret = bdrv_snapshot_create(bs, &sn);
2251         if (ret) {
2252             error_report("Could not create snapshot '%s': %d (%s)",
2253                 snapshot_name, ret, strerror(-ret));
2254         }
2255         break;
2256
2257     case SNAPSHOT_APPLY:
2258         ret = bdrv_snapshot_goto(bs, snapshot_name);
2259         if (ret) {
2260             error_report("Could not apply snapshot '%s': %d (%s)",
2261                 snapshot_name, ret, strerror(-ret));
2262         }
2263         break;
2264
2265     case SNAPSHOT_DELETE:
2266         bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2267         if (err) {
2268             error_report("Could not delete snapshot '%s': (%s)",
2269                          snapshot_name, error_get_pretty(err));
2270             error_free(err);
2271             ret = 1;
2272         }
2273         break;
2274     }
2275
2276     /* Cleanup */
2277     bdrv_unref(bs);
2278     if (ret) {
2279         return 1;
2280     }
2281     return 0;
2282 }
2283
2284 static int img_rebase(int argc, char **argv)
2285 {
2286     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2287     BlockDriver *old_backing_drv, *new_backing_drv;
2288     char *filename;
2289     const char *fmt, *cache, *out_basefmt, *out_baseimg;
2290     int c, flags, ret;
2291     int unsafe = 0;
2292     int progress = 0;
2293     bool quiet = false;
2294     Error *local_err = NULL;
2295
2296     /* Parse commandline parameters */
2297     fmt = NULL;
2298     cache = BDRV_DEFAULT_CACHE;
2299     out_baseimg = NULL;
2300     out_basefmt = NULL;
2301     for(;;) {
2302         c = getopt(argc, argv, "uhf:F:b:pt:q");
2303         if (c == -1) {
2304             break;
2305         }
2306         switch(c) {
2307         case '?':
2308         case 'h':
2309             help();
2310             return 0;
2311         case 'f':
2312             fmt = optarg;
2313             break;
2314         case 'F':
2315             out_basefmt = optarg;
2316             break;
2317         case 'b':
2318             out_baseimg = optarg;
2319             break;
2320         case 'u':
2321             unsafe = 1;
2322             break;
2323         case 'p':
2324             progress = 1;
2325             break;
2326         case 't':
2327             cache = optarg;
2328             break;
2329         case 'q':
2330             quiet = true;
2331             break;
2332         }
2333     }
2334
2335     if (quiet) {
2336         progress = 0;
2337     }
2338
2339     if (optind != argc - 1) {
2340         error_exit("Expecting one image file name");
2341     }
2342     if (!unsafe && !out_baseimg) {
2343         error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
2344     }
2345     filename = argv[optind++];
2346
2347     qemu_progress_init(progress, 2.0);
2348     qemu_progress_print(0, 100);
2349
2350     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2351     ret = bdrv_parse_cache_flags(cache, &flags);
2352     if (ret < 0) {
2353         error_report("Invalid cache option: %s", cache);
2354         return -1;
2355     }
2356
2357     /*
2358      * Open the images.
2359      *
2360      * Ignore the old backing file for unsafe rebase in case we want to correct
2361      * the reference to a renamed or moved backing file.
2362      */
2363     bs = bdrv_new_open("image", filename, fmt, flags, true, quiet);
2364     if (!bs) {
2365         return 1;
2366     }
2367
2368     /* Find the right drivers for the backing files */
2369     old_backing_drv = NULL;
2370     new_backing_drv = NULL;
2371
2372     if (!unsafe && bs->backing_format[0] != '\0') {
2373         old_backing_drv = bdrv_find_format(bs->backing_format);
2374         if (old_backing_drv == NULL) {
2375             error_report("Invalid format name: '%s'", bs->backing_format);
2376             ret = -1;
2377             goto out;
2378         }
2379     }
2380
2381     if (out_basefmt != NULL) {
2382         new_backing_drv = bdrv_find_format(out_basefmt);
2383         if (new_backing_drv == NULL) {
2384             error_report("Invalid format name: '%s'", out_basefmt);
2385             ret = -1;
2386             goto out;
2387         }
2388     }
2389
2390     /* For safe rebasing we need to compare old and new backing file */
2391     if (unsafe) {
2392         /* Make the compiler happy */
2393         bs_old_backing = NULL;
2394         bs_new_backing = NULL;
2395     } else {
2396         char backing_name[1024];
2397
2398         bs_old_backing = bdrv_new("old_backing", &error_abort);
2399         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2400         ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, BDRV_O_FLAGS,
2401                         old_backing_drv, &local_err);
2402         if (ret) {
2403             error_report("Could not open old backing file '%s': %s",
2404                          backing_name, error_get_pretty(local_err));
2405             error_free(local_err);
2406             goto out;
2407         }
2408         if (out_baseimg[0]) {
2409             bs_new_backing = bdrv_new("new_backing", &error_abort);
2410             ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL,
2411                             BDRV_O_FLAGS, new_backing_drv, &local_err);
2412             if (ret) {
2413                 error_report("Could not open new backing file '%s': %s",
2414                              out_baseimg, error_get_pretty(local_err));
2415                 error_free(local_err);
2416                 goto out;
2417             }
2418         }
2419     }
2420
2421     /*
2422      * Check each unallocated cluster in the COW file. If it is unallocated,
2423      * accesses go to the backing file. We must therefore compare this cluster
2424      * in the old and new backing file, and if they differ we need to copy it
2425      * from the old backing file into the COW file.
2426      *
2427      * If qemu-img crashes during this step, no harm is done. The content of
2428      * the image is the same as the original one at any time.
2429      */
2430     if (!unsafe) {
2431         int64_t num_sectors;
2432         int64_t old_backing_num_sectors;
2433         int64_t new_backing_num_sectors = 0;
2434         uint64_t sector;
2435         int n;
2436         uint8_t * buf_old;
2437         uint8_t * buf_new;
2438         float local_progress = 0;
2439
2440         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2441         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2442
2443         num_sectors = bdrv_nb_sectors(bs);
2444         if (num_sectors < 0) {
2445             error_report("Could not get size of '%s': %s",
2446                          filename, strerror(-num_sectors));
2447             ret = -1;
2448             goto out;
2449         }
2450         old_backing_num_sectors = bdrv_nb_sectors(bs_old_backing);
2451         if (old_backing_num_sectors < 0) {
2452             char backing_name[1024];
2453
2454             bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2455             error_report("Could not get size of '%s': %s",
2456                          backing_name, strerror(-old_backing_num_sectors));
2457             ret = -1;
2458             goto out;
2459         }
2460         if (bs_new_backing) {
2461             new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing);
2462             if (new_backing_num_sectors < 0) {
2463                 error_report("Could not get size of '%s': %s",
2464                              out_baseimg, strerror(-new_backing_num_sectors));
2465                 ret = -1;
2466                 goto out;
2467             }
2468         }
2469
2470         if (num_sectors != 0) {
2471             local_progress = (float)100 /
2472                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2473         }
2474
2475         for (sector = 0; sector < num_sectors; sector += n) {
2476
2477             /* How many sectors can we handle with the next read? */
2478             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2479                 n = (IO_BUF_SIZE / 512);
2480             } else {
2481                 n = num_sectors - sector;
2482             }
2483
2484             /* If the cluster is allocated, we don't need to take action */
2485             ret = bdrv_is_allocated(bs, sector, n, &n);
2486             if (ret < 0) {
2487                 error_report("error while reading image metadata: %s",
2488                              strerror(-ret));
2489                 goto out;
2490             }
2491             if (ret) {
2492                 continue;
2493             }
2494
2495             /*
2496              * Read old and new backing file and take into consideration that
2497              * backing files may be smaller than the COW image.
2498              */
2499             if (sector >= old_backing_num_sectors) {
2500                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2501             } else {
2502                 if (sector + n > old_backing_num_sectors) {
2503                     n = old_backing_num_sectors - sector;
2504                 }
2505
2506                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2507                 if (ret < 0) {
2508                     error_report("error while reading from old backing file");
2509                     goto out;
2510                 }
2511             }
2512
2513             if (sector >= new_backing_num_sectors || !bs_new_backing) {
2514                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2515             } else {
2516                 if (sector + n > new_backing_num_sectors) {
2517                     n = new_backing_num_sectors - sector;
2518                 }
2519
2520                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2521                 if (ret < 0) {
2522                     error_report("error while reading from new backing file");
2523                     goto out;
2524                 }
2525             }
2526
2527             /* If they differ, we need to write to the COW file */
2528             uint64_t written = 0;
2529
2530             while (written < n) {
2531                 int pnum;
2532
2533                 if (compare_sectors(buf_old + written * 512,
2534                     buf_new + written * 512, n - written, &pnum))
2535                 {
2536                     ret = bdrv_write(bs, sector + written,
2537                         buf_old + written * 512, pnum);
2538                     if (ret < 0) {
2539                         error_report("Error while writing to COW image: %s",
2540                             strerror(-ret));
2541                         goto out;
2542                     }
2543                 }
2544
2545                 written += pnum;
2546             }
2547             qemu_progress_print(local_progress, 100);
2548         }
2549
2550         qemu_vfree(buf_old);
2551         qemu_vfree(buf_new);
2552     }
2553
2554     /*
2555      * Change the backing file. All clusters that are different from the old
2556      * backing file are overwritten in the COW file now, so the visible content
2557      * doesn't change when we switch the backing file.
2558      */
2559     if (out_baseimg && *out_baseimg) {
2560         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2561     } else {
2562         ret = bdrv_change_backing_file(bs, NULL, NULL);
2563     }
2564
2565     if (ret == -ENOSPC) {
2566         error_report("Could not change the backing file to '%s': No "
2567                      "space left in the file header", out_baseimg);
2568     } else if (ret < 0) {
2569         error_report("Could not change the backing file to '%s': %s",
2570             out_baseimg, strerror(-ret));
2571     }
2572
2573     qemu_progress_print(100, 0);
2574     /*
2575      * TODO At this point it is possible to check if any clusters that are
2576      * allocated in the COW file are the same in the backing file. If so, they
2577      * could be dropped from the COW file. Don't do this before switching the
2578      * backing file, in case of a crash this would lead to corruption.
2579      */
2580 out:
2581     qemu_progress_end();
2582     /* Cleanup */
2583     if (!unsafe) {
2584         if (bs_old_backing != NULL) {
2585             bdrv_unref(bs_old_backing);
2586         }
2587         if (bs_new_backing != NULL) {
2588             bdrv_unref(bs_new_backing);
2589         }
2590     }
2591
2592     bdrv_unref(bs);
2593     if (ret) {
2594         return 1;
2595     }
2596     return 0;
2597 }
2598
2599 static int img_resize(int argc, char **argv)
2600 {
2601     int c, ret, relative;
2602     const char *filename, *fmt, *size;
2603     int64_t n, total_size;
2604     bool quiet = false;
2605     BlockDriverState *bs = NULL;
2606     QemuOpts *param;
2607     static QemuOptsList resize_options = {
2608         .name = "resize_options",
2609         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2610         .desc = {
2611             {
2612                 .name = BLOCK_OPT_SIZE,
2613                 .type = QEMU_OPT_SIZE,
2614                 .help = "Virtual disk size"
2615             }, {
2616                 /* end of list */
2617             }
2618         },
2619     };
2620
2621     /* Remove size from argv manually so that negative numbers are not treated
2622      * as options by getopt. */
2623     if (argc < 3) {
2624         error_exit("Not enough arguments");
2625         return 1;
2626     }
2627
2628     size = argv[--argc];
2629
2630     /* Parse getopt arguments */
2631     fmt = NULL;
2632     for(;;) {
2633         c = getopt(argc, argv, "f:hq");
2634         if (c == -1) {
2635             break;
2636         }
2637         switch(c) {
2638         case '?':
2639         case 'h':
2640             help();
2641             break;
2642         case 'f':
2643             fmt = optarg;
2644             break;
2645         case 'q':
2646             quiet = true;
2647             break;
2648         }
2649     }
2650     if (optind != argc - 1) {
2651         error_exit("Expecting one image file name");
2652     }
2653     filename = argv[optind++];
2654
2655     /* Choose grow, shrink, or absolute resize mode */
2656     switch (size[0]) {
2657     case '+':
2658         relative = 1;
2659         size++;
2660         break;
2661     case '-':
2662         relative = -1;
2663         size++;
2664         break;
2665     default:
2666         relative = 0;
2667         break;
2668     }
2669
2670     /* Parse size */
2671     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
2672     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2673         /* Error message already printed when size parsing fails */
2674         ret = -1;
2675         qemu_opts_del(param);
2676         goto out;
2677     }
2678     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2679     qemu_opts_del(param);
2680
2681     bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
2682                        true, quiet);
2683     if (!bs) {
2684         ret = -1;
2685         goto out;
2686     }
2687
2688     if (relative) {
2689         total_size = bdrv_getlength(bs) + n * relative;
2690     } else {
2691         total_size = n;
2692     }
2693     if (total_size <= 0) {
2694         error_report("New image size must be positive");
2695         ret = -1;
2696         goto out;
2697     }
2698
2699     ret = bdrv_truncate(bs, total_size);
2700     switch (ret) {
2701     case 0:
2702         qprintf(quiet, "Image resized.\n");
2703         break;
2704     case -ENOTSUP:
2705         error_report("This image does not support resize");
2706         break;
2707     case -EACCES:
2708         error_report("Image is read-only");
2709         break;
2710     default:
2711         error_report("Error resizing image (%d)", -ret);
2712         break;
2713     }
2714 out:
2715     if (bs) {
2716         bdrv_unref(bs);
2717     }
2718     if (ret) {
2719         return 1;
2720     }
2721     return 0;
2722 }
2723
2724 static int img_amend(int argc, char **argv)
2725 {
2726     int c, ret = 0;
2727     char *options = NULL;
2728     QemuOptsList *create_opts = NULL;
2729     QemuOpts *opts = NULL;
2730     const char *fmt = NULL, *filename;
2731     bool quiet = false;
2732     BlockDriverState *bs = NULL;
2733
2734     for (;;) {
2735         c = getopt(argc, argv, "hqf:o:");
2736         if (c == -1) {
2737             break;
2738         }
2739
2740         switch (c) {
2741             case 'h':
2742             case '?':
2743                 help();
2744                 break;
2745             case 'o':
2746                 if (!is_valid_option_list(optarg)) {
2747                     error_report("Invalid option list: %s", optarg);
2748                     ret = -1;
2749                     goto out;
2750                 }
2751                 if (!options) {
2752                     options = g_strdup(optarg);
2753                 } else {
2754                     char *old_options = options;
2755                     options = g_strdup_printf("%s,%s", options, optarg);
2756                     g_free(old_options);
2757                 }
2758                 break;
2759             case 'f':
2760                 fmt = optarg;
2761                 break;
2762             case 'q':
2763                 quiet = true;
2764                 break;
2765         }
2766     }
2767
2768     if (!options) {
2769         error_exit("Must specify options (-o)");
2770     }
2771
2772     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
2773     if (fmt && has_help_option(options)) {
2774         /* If a format is explicitly specified (and possibly no filename is
2775          * given), print option help here */
2776         ret = print_block_option_help(filename, fmt);
2777         goto out;
2778     }
2779
2780     if (optind != argc - 1) {
2781         error_exit("Expecting one image file name");
2782     }
2783
2784     bs = bdrv_new_open("image", filename, fmt,
2785                        BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2786     if (!bs) {
2787         error_report("Could not open image '%s'", filename);
2788         ret = -1;
2789         goto out;
2790     }
2791
2792     fmt = bs->drv->format_name;
2793
2794     if (has_help_option(options)) {
2795         /* If the format was auto-detected, print option help here */
2796         ret = print_block_option_help(filename, fmt);
2797         goto out;
2798     }
2799
2800     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
2801     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2802     if (options && qemu_opts_do_parse(opts, options, NULL)) {
2803         error_report("Invalid options for file format '%s'", fmt);
2804         ret = -1;
2805         goto out;
2806     }
2807
2808     ret = bdrv_amend_options(bs, opts);
2809     if (ret < 0) {
2810         error_report("Error while amending options: %s", strerror(-ret));
2811         goto out;
2812     }
2813
2814 out:
2815     if (bs) {
2816         bdrv_unref(bs);
2817     }
2818     qemu_opts_del(opts);
2819     qemu_opts_free(create_opts);
2820     g_free(options);
2821
2822     if (ret) {
2823         return 1;
2824     }
2825     return 0;
2826 }
2827
2828 static const img_cmd_t img_cmds[] = {
2829 #define DEF(option, callback, arg_string)        \
2830     { option, callback },
2831 #include "qemu-img-cmds.h"
2832 #undef DEF
2833 #undef GEN_DOCS
2834     { NULL, NULL, },
2835 };
2836
2837 int main(int argc, char **argv)
2838 {
2839     const img_cmd_t *cmd;
2840     const char *cmdname;
2841     int c;
2842     static const struct option long_options[] = {
2843         {"help", no_argument, 0, 'h'},
2844         {"version", no_argument, 0, 'v'},
2845         {0, 0, 0, 0}
2846     };
2847
2848 #ifdef CONFIG_POSIX
2849     signal(SIGPIPE, SIG_IGN);
2850 #endif
2851
2852     error_set_progname(argv[0]);
2853     qemu_init_exec_dir(argv[0]);
2854
2855     qemu_init_main_loop();
2856     bdrv_init();
2857     if (argc < 2) {
2858         error_exit("Not enough arguments");
2859     }
2860     cmdname = argv[1];
2861
2862     /* find the command */
2863     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
2864         if (!strcmp(cmdname, cmd->name)) {
2865             return cmd->handler(argc - 1, argv + 1);
2866         }
2867     }
2868
2869     c = getopt_long(argc, argv, "h", long_options, NULL);
2870
2871     if (c == 'h') {
2872         help();
2873     }
2874     if (c == 'v') {
2875         printf(QEMU_IMG_VERSION);
2876         return 0;
2877     }
2878
2879     /* not found */
2880     error_exit("Command not found: %s", cmdname);
2881 }