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_delete(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_delete(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_delete(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_delete(bs2);
1110     qemu_vfree(buf1);
1111     qemu_vfree(buf2);
1112 out2:
1113     bdrv_delete(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 (has_zero_init) {
1506                 /* If the output image is being created as a copy on write image,
1507                    assume that sectors which are unallocated in the input image
1508                    are present in both the output's and input's base images (no
1509                    need to copy them). */
1510                 if (out_baseimg) {
1511                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1512                                            n, &n1)) {
1513                         sector_num += n1;
1514                         continue;
1515                     }
1516                     /* The next 'n1' sectors are allocated in the input image. Copy
1517                        only those as they may be followed by unallocated sectors. */
1518                     n = n1;
1519                 }
1520             } else {
1521                 n1 = n;
1522             }
1523
1524             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1525             if (ret < 0) {
1526                 error_report("error while reading sector %" PRId64 ": %s",
1527                              sector_num - bs_offset, strerror(-ret));
1528                 goto out;
1529             }
1530             /* NOTE: at the same time we convert, we do not write zero
1531                sectors to have a chance to compress the image. Ideally, we
1532                should add a specific call to have the info to go faster */
1533             buf1 = buf;
1534             while (n > 0) {
1535                 /* If the output image is being created as a copy on write image,
1536                    copy all sectors even the ones containing only NUL bytes,
1537                    because they may differ from the sectors in the base image.
1538
1539                    If the output is to a host device, we also write out
1540                    sectors that are entirely 0, since whatever data was
1541                    already there is garbage, not 0s. */
1542                 if (!has_zero_init || out_baseimg ||
1543                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1544                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1545                     if (ret < 0) {
1546                         error_report("error while writing sector %" PRId64
1547                                      ": %s", sector_num, strerror(-ret));
1548                         goto out;
1549                     }
1550                 }
1551                 sector_num += n1;
1552                 n -= n1;
1553                 buf1 += n1 * 512;
1554             }
1555             qemu_progress_print(local_progress, 100);
1556         }
1557     }
1558 out:
1559     qemu_progress_end();
1560     free_option_parameters(create_options);
1561     free_option_parameters(param);
1562     qemu_vfree(buf);
1563     if (out_bs) {
1564         bdrv_delete(out_bs);
1565     }
1566     if (bs) {
1567         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1568             if (bs[bs_i]) {
1569                 bdrv_delete(bs[bs_i]);
1570             }
1571         }
1572         g_free(bs);
1573     }
1574     if (ret) {
1575         return 1;
1576     }
1577     return 0;
1578 }
1579
1580
1581 static void dump_snapshots(BlockDriverState *bs)
1582 {
1583     QEMUSnapshotInfo *sn_tab, *sn;
1584     int nb_sns, i;
1585
1586     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1587     if (nb_sns <= 0)
1588         return;
1589     printf("Snapshot list:\n");
1590     bdrv_snapshot_dump(fprintf, stdout, NULL);
1591     printf("\n");
1592     for(i = 0; i < nb_sns; i++) {
1593         sn = &sn_tab[i];
1594         bdrv_snapshot_dump(fprintf, stdout, sn);
1595         printf("\n");
1596     }
1597     g_free(sn_tab);
1598 }
1599
1600 static void dump_json_image_info_list(ImageInfoList *list)
1601 {
1602     Error *errp = NULL;
1603     QString *str;
1604     QmpOutputVisitor *ov = qmp_output_visitor_new();
1605     QObject *obj;
1606     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1607                              &list, NULL, &errp);
1608     obj = qmp_output_get_qobject(ov);
1609     str = qobject_to_json_pretty(obj);
1610     assert(str != NULL);
1611     printf("%s\n", qstring_get_str(str));
1612     qobject_decref(obj);
1613     qmp_output_visitor_cleanup(ov);
1614     QDECREF(str);
1615 }
1616
1617 static void dump_json_image_info(ImageInfo *info)
1618 {
1619     Error *errp = NULL;
1620     QString *str;
1621     QmpOutputVisitor *ov = qmp_output_visitor_new();
1622     QObject *obj;
1623     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1624                          &info, NULL, &errp);
1625     obj = qmp_output_get_qobject(ov);
1626     str = qobject_to_json_pretty(obj);
1627     assert(str != NULL);
1628     printf("%s\n", qstring_get_str(str));
1629     qobject_decref(obj);
1630     qmp_output_visitor_cleanup(ov);
1631     QDECREF(str);
1632 }
1633
1634 static void dump_human_image_info_list(ImageInfoList *list)
1635 {
1636     ImageInfoList *elem;
1637     bool delim = false;
1638
1639     for (elem = list; elem; elem = elem->next) {
1640         if (delim) {
1641             printf("\n");
1642         }
1643         delim = true;
1644
1645         bdrv_image_info_dump(fprintf, stdout, elem->value);
1646     }
1647 }
1648
1649 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1650 {
1651     return strcmp(a, b) == 0;
1652 }
1653
1654 /**
1655  * Open an image file chain and return an ImageInfoList
1656  *
1657  * @filename: topmost image filename
1658  * @fmt: topmost image format (may be NULL to autodetect)
1659  * @chain: true  - enumerate entire backing file chain
1660  *         false - only topmost image file
1661  *
1662  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1663  * image file.  If there was an error a message will have been printed to
1664  * stderr.
1665  */
1666 static ImageInfoList *collect_image_info_list(const char *filename,
1667                                               const char *fmt,
1668                                               bool chain)
1669 {
1670     ImageInfoList *head = NULL;
1671     ImageInfoList **last = &head;
1672     GHashTable *filenames;
1673     Error *err = NULL;
1674
1675     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1676
1677     while (filename) {
1678         BlockDriverState *bs;
1679         ImageInfo *info;
1680         ImageInfoList *elem;
1681
1682         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1683             error_report("Backing file '%s' creates an infinite loop.",
1684                          filename);
1685             goto err;
1686         }
1687         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1688
1689         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1690                            false, false);
1691         if (!bs) {
1692             goto err;
1693         }
1694
1695         bdrv_query_image_info(bs, &info, &err);
1696         if (error_is_set(&err)) {
1697             error_report("%s", error_get_pretty(err));
1698             error_free(err);
1699             goto err;
1700         }
1701
1702         elem = g_new0(ImageInfoList, 1);
1703         elem->value = info;
1704         *last = elem;
1705         last = &elem->next;
1706
1707         bdrv_delete(bs);
1708
1709         filename = fmt = NULL;
1710         if (chain) {
1711             if (info->has_full_backing_filename) {
1712                 filename = info->full_backing_filename;
1713             } else if (info->has_backing_filename) {
1714                 filename = info->backing_filename;
1715             }
1716             if (info->has_backing_filename_format) {
1717                 fmt = info->backing_filename_format;
1718             }
1719         }
1720     }
1721     g_hash_table_destroy(filenames);
1722     return head;
1723
1724 err:
1725     qapi_free_ImageInfoList(head);
1726     g_hash_table_destroy(filenames);
1727     return NULL;
1728 }
1729
1730 static int img_info(int argc, char **argv)
1731 {
1732     int c;
1733     OutputFormat output_format = OFORMAT_HUMAN;
1734     bool chain = false;
1735     const char *filename, *fmt, *output;
1736     ImageInfoList *list;
1737
1738     fmt = NULL;
1739     output = NULL;
1740     for(;;) {
1741         int option_index = 0;
1742         static const struct option long_options[] = {
1743             {"help", no_argument, 0, 'h'},
1744             {"format", required_argument, 0, 'f'},
1745             {"output", required_argument, 0, OPTION_OUTPUT},
1746             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1747             {0, 0, 0, 0}
1748         };
1749         c = getopt_long(argc, argv, "f:h",
1750                         long_options, &option_index);
1751         if (c == -1) {
1752             break;
1753         }
1754         switch(c) {
1755         case '?':
1756         case 'h':
1757             help();
1758             break;
1759         case 'f':
1760             fmt = optarg;
1761             break;
1762         case OPTION_OUTPUT:
1763             output = optarg;
1764             break;
1765         case OPTION_BACKING_CHAIN:
1766             chain = true;
1767             break;
1768         }
1769     }
1770     if (optind != argc - 1) {
1771         help();
1772     }
1773     filename = argv[optind++];
1774
1775     if (output && !strcmp(output, "json")) {
1776         output_format = OFORMAT_JSON;
1777     } else if (output && !strcmp(output, "human")) {
1778         output_format = OFORMAT_HUMAN;
1779     } else if (output) {
1780         error_report("--output must be used with human or json as argument.");
1781         return 1;
1782     }
1783
1784     list = collect_image_info_list(filename, fmt, chain);
1785     if (!list) {
1786         return 1;
1787     }
1788
1789     switch (output_format) {
1790     case OFORMAT_HUMAN:
1791         dump_human_image_info_list(list);
1792         break;
1793     case OFORMAT_JSON:
1794         if (chain) {
1795             dump_json_image_info_list(list);
1796         } else {
1797             dump_json_image_info(list->value);
1798         }
1799         break;
1800     }
1801
1802     qapi_free_ImageInfoList(list);
1803     return 0;
1804 }
1805
1806 #define SNAPSHOT_LIST   1
1807 #define SNAPSHOT_CREATE 2
1808 #define SNAPSHOT_APPLY  3
1809 #define SNAPSHOT_DELETE 4
1810
1811 static int img_snapshot(int argc, char **argv)
1812 {
1813     BlockDriverState *bs;
1814     QEMUSnapshotInfo sn;
1815     char *filename, *snapshot_name = NULL;
1816     int c, ret = 0, bdrv_oflags;
1817     int action = 0;
1818     qemu_timeval tv;
1819     bool quiet = false;
1820
1821     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1822     /* Parse commandline parameters */
1823     for(;;) {
1824         c = getopt(argc, argv, "la:c:d:hq");
1825         if (c == -1) {
1826             break;
1827         }
1828         switch(c) {
1829         case '?':
1830         case 'h':
1831             help();
1832             return 0;
1833         case 'l':
1834             if (action) {
1835                 help();
1836                 return 0;
1837             }
1838             action = SNAPSHOT_LIST;
1839             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1840             break;
1841         case 'a':
1842             if (action) {
1843                 help();
1844                 return 0;
1845             }
1846             action = SNAPSHOT_APPLY;
1847             snapshot_name = optarg;
1848             break;
1849         case 'c':
1850             if (action) {
1851                 help();
1852                 return 0;
1853             }
1854             action = SNAPSHOT_CREATE;
1855             snapshot_name = optarg;
1856             break;
1857         case 'd':
1858             if (action) {
1859                 help();
1860                 return 0;
1861             }
1862             action = SNAPSHOT_DELETE;
1863             snapshot_name = optarg;
1864             break;
1865         case 'q':
1866             quiet = true;
1867             break;
1868         }
1869     }
1870
1871     if (optind != argc - 1) {
1872         help();
1873     }
1874     filename = argv[optind++];
1875
1876     /* Open the image */
1877     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
1878     if (!bs) {
1879         return 1;
1880     }
1881
1882     /* Perform the requested action */
1883     switch(action) {
1884     case SNAPSHOT_LIST:
1885         dump_snapshots(bs);
1886         break;
1887
1888     case SNAPSHOT_CREATE:
1889         memset(&sn, 0, sizeof(sn));
1890         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1891
1892         qemu_gettimeofday(&tv);
1893         sn.date_sec = tv.tv_sec;
1894         sn.date_nsec = tv.tv_usec * 1000;
1895
1896         ret = bdrv_snapshot_create(bs, &sn);
1897         if (ret) {
1898             error_report("Could not create snapshot '%s': %d (%s)",
1899                 snapshot_name, ret, strerror(-ret));
1900         }
1901         break;
1902
1903     case SNAPSHOT_APPLY:
1904         ret = bdrv_snapshot_goto(bs, snapshot_name);
1905         if (ret) {
1906             error_report("Could not apply snapshot '%s': %d (%s)",
1907                 snapshot_name, ret, strerror(-ret));
1908         }
1909         break;
1910
1911     case SNAPSHOT_DELETE:
1912         ret = bdrv_snapshot_delete(bs, snapshot_name);
1913         if (ret) {
1914             error_report("Could not delete snapshot '%s': %d (%s)",
1915                 snapshot_name, ret, strerror(-ret));
1916         }
1917         break;
1918     }
1919
1920     /* Cleanup */
1921     bdrv_delete(bs);
1922     if (ret) {
1923         return 1;
1924     }
1925     return 0;
1926 }
1927
1928 static int img_rebase(int argc, char **argv)
1929 {
1930     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1931     BlockDriver *old_backing_drv, *new_backing_drv;
1932     char *filename;
1933     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1934     int c, flags, ret;
1935     int unsafe = 0;
1936     int progress = 0;
1937     bool quiet = false;
1938
1939     /* Parse commandline parameters */
1940     fmt = NULL;
1941     cache = BDRV_DEFAULT_CACHE;
1942     out_baseimg = NULL;
1943     out_basefmt = NULL;
1944     for(;;) {
1945         c = getopt(argc, argv, "uhf:F:b:pt:q");
1946         if (c == -1) {
1947             break;
1948         }
1949         switch(c) {
1950         case '?':
1951         case 'h':
1952             help();
1953             return 0;
1954         case 'f':
1955             fmt = optarg;
1956             break;
1957         case 'F':
1958             out_basefmt = optarg;
1959             break;
1960         case 'b':
1961             out_baseimg = optarg;
1962             break;
1963         case 'u':
1964             unsafe = 1;
1965             break;
1966         case 'p':
1967             progress = 1;
1968             break;
1969         case 't':
1970             cache = optarg;
1971             break;
1972         case 'q':
1973             quiet = true;
1974             break;
1975         }
1976     }
1977
1978     if (quiet) {
1979         progress = 0;
1980     }
1981
1982     if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
1983         help();
1984     }
1985     filename = argv[optind++];
1986
1987     qemu_progress_init(progress, 2.0);
1988     qemu_progress_print(0, 100);
1989
1990     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1991     ret = bdrv_parse_cache_flags(cache, &flags);
1992     if (ret < 0) {
1993         error_report("Invalid cache option: %s", cache);
1994         return -1;
1995     }
1996
1997     /*
1998      * Open the images.
1999      *
2000      * Ignore the old backing file for unsafe rebase in case we want to correct
2001      * the reference to a renamed or moved backing file.
2002      */
2003     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2004     if (!bs) {
2005         return 1;
2006     }
2007
2008     /* Find the right drivers for the backing files */
2009     old_backing_drv = NULL;
2010     new_backing_drv = NULL;
2011
2012     if (!unsafe && bs->backing_format[0] != '\0') {
2013         old_backing_drv = bdrv_find_format(bs->backing_format);
2014         if (old_backing_drv == NULL) {
2015             error_report("Invalid format name: '%s'", bs->backing_format);
2016             ret = -1;
2017             goto out;
2018         }
2019     }
2020
2021     if (out_basefmt != NULL) {
2022         new_backing_drv = bdrv_find_format(out_basefmt);
2023         if (new_backing_drv == NULL) {
2024             error_report("Invalid format name: '%s'", out_basefmt);
2025             ret = -1;
2026             goto out;
2027         }
2028     }
2029
2030     /* For safe rebasing we need to compare old and new backing file */
2031     if (unsafe) {
2032         /* Make the compiler happy */
2033         bs_old_backing = NULL;
2034         bs_new_backing = NULL;
2035     } else {
2036         char backing_name[1024];
2037
2038         bs_old_backing = bdrv_new("old_backing");
2039         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2040         ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2041                         old_backing_drv);
2042         if (ret) {
2043             error_report("Could not open old backing file '%s'", backing_name);
2044             goto out;
2045         }
2046         if (out_baseimg[0]) {
2047             bs_new_backing = bdrv_new("new_backing");
2048             ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2049                         new_backing_drv);
2050             if (ret) {
2051                 error_report("Could not open new backing file '%s'",
2052                              out_baseimg);
2053                 goto out;
2054             }
2055         }
2056     }
2057
2058     /*
2059      * Check each unallocated cluster in the COW file. If it is unallocated,
2060      * accesses go to the backing file. We must therefore compare this cluster
2061      * in the old and new backing file, and if they differ we need to copy it
2062      * from the old backing file into the COW file.
2063      *
2064      * If qemu-img crashes during this step, no harm is done. The content of
2065      * the image is the same as the original one at any time.
2066      */
2067     if (!unsafe) {
2068         uint64_t num_sectors;
2069         uint64_t old_backing_num_sectors;
2070         uint64_t new_backing_num_sectors = 0;
2071         uint64_t sector;
2072         int n;
2073         uint8_t * buf_old;
2074         uint8_t * buf_new;
2075         float local_progress = 0;
2076
2077         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2078         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2079
2080         bdrv_get_geometry(bs, &num_sectors);
2081         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2082         if (bs_new_backing) {
2083             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2084         }
2085
2086         if (num_sectors != 0) {
2087             local_progress = (float)100 /
2088                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2089         }
2090
2091         for (sector = 0; sector < num_sectors; sector += n) {
2092
2093             /* How many sectors can we handle with the next read? */
2094             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2095                 n = (IO_BUF_SIZE / 512);
2096             } else {
2097                 n = num_sectors - sector;
2098             }
2099
2100             /* If the cluster is allocated, we don't need to take action */
2101             ret = bdrv_is_allocated(bs, sector, n, &n);
2102             if (ret) {
2103                 continue;
2104             }
2105
2106             /*
2107              * Read old and new backing file and take into consideration that
2108              * backing files may be smaller than the COW image.
2109              */
2110             if (sector >= old_backing_num_sectors) {
2111                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2112             } else {
2113                 if (sector + n > old_backing_num_sectors) {
2114                     n = old_backing_num_sectors - sector;
2115                 }
2116
2117                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2118                 if (ret < 0) {
2119                     error_report("error while reading from old backing file");
2120                     goto out;
2121                 }
2122             }
2123
2124             if (sector >= new_backing_num_sectors || !bs_new_backing) {
2125                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2126             } else {
2127                 if (sector + n > new_backing_num_sectors) {
2128                     n = new_backing_num_sectors - sector;
2129                 }
2130
2131                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2132                 if (ret < 0) {
2133                     error_report("error while reading from new backing file");
2134                     goto out;
2135                 }
2136             }
2137
2138             /* If they differ, we need to write to the COW file */
2139             uint64_t written = 0;
2140
2141             while (written < n) {
2142                 int pnum;
2143
2144                 if (compare_sectors(buf_old + written * 512,
2145                     buf_new + written * 512, n - written, &pnum))
2146                 {
2147                     ret = bdrv_write(bs, sector + written,
2148                         buf_old + written * 512, pnum);
2149                     if (ret < 0) {
2150                         error_report("Error while writing to COW image: %s",
2151                             strerror(-ret));
2152                         goto out;
2153                     }
2154                 }
2155
2156                 written += pnum;
2157             }
2158             qemu_progress_print(local_progress, 100);
2159         }
2160
2161         qemu_vfree(buf_old);
2162         qemu_vfree(buf_new);
2163     }
2164
2165     /*
2166      * Change the backing file. All clusters that are different from the old
2167      * backing file are overwritten in the COW file now, so the visible content
2168      * doesn't change when we switch the backing file.
2169      */
2170     if (out_baseimg && *out_baseimg) {
2171         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2172     } else {
2173         ret = bdrv_change_backing_file(bs, NULL, NULL);
2174     }
2175
2176     if (ret == -ENOSPC) {
2177         error_report("Could not change the backing file to '%s': No "
2178                      "space left in the file header", out_baseimg);
2179     } else if (ret < 0) {
2180         error_report("Could not change the backing file to '%s': %s",
2181             out_baseimg, strerror(-ret));
2182     }
2183
2184     qemu_progress_print(100, 0);
2185     /*
2186      * TODO At this point it is possible to check if any clusters that are
2187      * allocated in the COW file are the same in the backing file. If so, they
2188      * could be dropped from the COW file. Don't do this before switching the
2189      * backing file, in case of a crash this would lead to corruption.
2190      */
2191 out:
2192     qemu_progress_end();
2193     /* Cleanup */
2194     if (!unsafe) {
2195         if (bs_old_backing != NULL) {
2196             bdrv_delete(bs_old_backing);
2197         }
2198         if (bs_new_backing != NULL) {
2199             bdrv_delete(bs_new_backing);
2200         }
2201     }
2202
2203     bdrv_delete(bs);
2204     if (ret) {
2205         return 1;
2206     }
2207     return 0;
2208 }
2209
2210 static int img_resize(int argc, char **argv)
2211 {
2212     int c, ret, relative;
2213     const char *filename, *fmt, *size;
2214     int64_t n, total_size;
2215     bool quiet = false;
2216     BlockDriverState *bs = NULL;
2217     QemuOpts *param;
2218     static QemuOptsList resize_options = {
2219         .name = "resize_options",
2220         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2221         .desc = {
2222             {
2223                 .name = BLOCK_OPT_SIZE,
2224                 .type = QEMU_OPT_SIZE,
2225                 .help = "Virtual disk size"
2226             }, {
2227                 /* end of list */
2228             }
2229         },
2230     };
2231
2232     /* Remove size from argv manually so that negative numbers are not treated
2233      * as options by getopt. */
2234     if (argc < 3) {
2235         help();
2236         return 1;
2237     }
2238
2239     size = argv[--argc];
2240
2241     /* Parse getopt arguments */
2242     fmt = NULL;
2243     for(;;) {
2244         c = getopt(argc, argv, "f:hq");
2245         if (c == -1) {
2246             break;
2247         }
2248         switch(c) {
2249         case '?':
2250         case 'h':
2251             help();
2252             break;
2253         case 'f':
2254             fmt = optarg;
2255             break;
2256         case 'q':
2257             quiet = true;
2258             break;
2259         }
2260     }
2261     if (optind != argc - 1) {
2262         help();
2263     }
2264     filename = argv[optind++];
2265
2266     /* Choose grow, shrink, or absolute resize mode */
2267     switch (size[0]) {
2268     case '+':
2269         relative = 1;
2270         size++;
2271         break;
2272     case '-':
2273         relative = -1;
2274         size++;
2275         break;
2276     default:
2277         relative = 0;
2278         break;
2279     }
2280
2281     /* Parse size */
2282     param = qemu_opts_create_nofail(&resize_options);
2283     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2284         /* Error message already printed when size parsing fails */
2285         ret = -1;
2286         qemu_opts_del(param);
2287         goto out;
2288     }
2289     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2290     qemu_opts_del(param);
2291
2292     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2293     if (!bs) {
2294         ret = -1;
2295         goto out;
2296     }
2297
2298     if (relative) {
2299         total_size = bdrv_getlength(bs) + n * relative;
2300     } else {
2301         total_size = n;
2302     }
2303     if (total_size <= 0) {
2304         error_report("New image size must be positive");
2305         ret = -1;
2306         goto out;
2307     }
2308
2309     ret = bdrv_truncate(bs, total_size);
2310     switch (ret) {
2311     case 0:
2312         qprintf(quiet, "Image resized.\n");
2313         break;
2314     case -ENOTSUP:
2315         error_report("This image does not support resize");
2316         break;
2317     case -EACCES:
2318         error_report("Image is read-only");
2319         break;
2320     default:
2321         error_report("Error resizing image (%d)", -ret);
2322         break;
2323     }
2324 out:
2325     if (bs) {
2326         bdrv_delete(bs);
2327     }
2328     if (ret) {
2329         return 1;
2330     }
2331     return 0;
2332 }
2333
2334 static const img_cmd_t img_cmds[] = {
2335 #define DEF(option, callback, arg_string)        \
2336     { option, callback },
2337 #include "qemu-img-cmds.h"
2338 #undef DEF
2339 #undef GEN_DOCS
2340     { NULL, NULL, },
2341 };
2342
2343 int main(int argc, char **argv)
2344 {
2345     const img_cmd_t *cmd;
2346     const char *cmdname;
2347
2348 #ifdef CONFIG_POSIX
2349     signal(SIGPIPE, SIG_IGN);
2350 #endif
2351
2352     error_set_progname(argv[0]);
2353
2354     qemu_init_main_loop();
2355     bdrv_init();
2356     if (argc < 2)
2357         help();
2358     cmdname = argv[1];
2359     argc--; argv++;
2360
2361     /* find the command */
2362     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2363         if (!strcmp(cmdname, cmd->name)) {
2364             return cmd->handler(argc, argv);
2365         }
2366     }
2367
2368     /* not found */
2369     help();
2370     return 0;
2371 }