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