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