qemu-img.c

   1 /*
   2  * QEMU disk image utility
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu-common.h"
  25 #include "qemu-option.h"
  26 #include "qemu-error.h"
  27 #include "osdep.h"
  28 #include "sysemu.h"
  29 #include "block_int.h"
  30 #include <stdio.h>
  31
  32 #ifdef _WIN32
  33 #include <windows.h>
  34 #endif
  35
  36 typedef struct img_cmd_t {
  37     const char *name;
  38     int (*handler)(int argc, char **argv);
  39 } img_cmd_t;
  40
  41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  43 #define BDRV_DEFAULT_CACHE "writeback"
  44
  45 static void format_print(void *opaque, const char *name)
  46 {
  47     printf(" %s", name);
  48 }
  49
  50 /* Please keep in synch with qemu-img.texi */
  51 static void help(void)
  52 {
  53     const char *help_msg =
  54            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  55            "usage: qemu-img command [command options]\n"
  56            "QEMU disk image utility\n"
  57            "\n"
  58            "Command syntax:\n"
  59 #define DEF(option, callback, arg_string)        \
  60            "  " arg_string "\n"
  61 #include "qemu-img-cmds.h"
  62 #undef DEF
  63 #undef GEN_DOCS
  64            "\n"
  65            "Command parameters:\n"
  66            "  'filename' is a disk image filename\n"
  67            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  68            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  69            "    options are: 'none', 'writeback' (default), 'writethrough' and 'unsafe'\n"
  70            "  'size' is the disk image size in bytes. Optional suffixes\n"
  71            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
  72            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
  73            "  'output_filename' is the destination disk image filename\n"
  74            "  'output_fmt' is the destination format\n"
  75            "  'options' is a comma separated list of format specific options in a\n"
  76            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  77            "    used format\n"
  78            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  79            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
  80            "       match exactly. The image doesn't need a working backing file before\n"
  81            "       rebasing in this case (useful for renaming the backing file)\n"
  82            "  '-h' with or without a command shows this help and lists the supported formats\n"
  83            "  '-p' show progress of command (only certain commands)\n"
  84            "\n"
  85            "Parameters to snapshot subcommand:\n"
  86            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
  87            "  '-a' applies a snapshot (revert disk to saved state)\n"
  88            "  '-c' creates a snapshot\n"
  89            "  '-d' deletes a snapshot\n"
  90            "  '-l' lists all snapshots in the given image\n";
  91
  92     printf("%s\nSupported formats:", help_msg);
  93     bdrv_iterate_format(format_print, NULL);
  94     printf("\n");
  95     exit(1);
  96 }
  97
  98 #if defined(WIN32)
  99 /* XXX: put correct support for win32 */
 100 static int read_password(char *buf, int buf_size)
 101 {
 102     int c, i;
 103     printf("Password: ");
 104     fflush(stdout);
 105     i = 0;
 106     for(;;) {
 107         c = getchar();
 108         if (c == '\n')
 109             break;
 110         if (i < (buf_size - 1))
 111             buf[i++] = c;
 112     }
 113     buf[i] = '\0';
 114     return 0;
 115 }
 116
 117 #else
 118
 119 #include <termios.h>
 120
 121 static struct termios oldtty;
 122
 123 static void term_exit(void)
 124 {
 125     tcsetattr (0, TCSANOW, &oldtty);
 126 }
 127
 128 static void term_init(void)
 129 {
 130     struct termios tty;
 131
 132     tcgetattr (0, &tty);
 133     oldtty = tty;
 134
 135     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 136                           |INLCR|IGNCR|ICRNL|IXON);
 137     tty.c_oflag |= OPOST;
 138     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 139     tty.c_cflag &= ~(CSIZE|PARENB);
 140     tty.c_cflag |= CS8;
 141     tty.c_cc[VMIN] = 1;
 142     tty.c_cc[VTIME] = 0;
 143
 144     tcsetattr (0, TCSANOW, &tty);
 145
 146     atexit(term_exit);
 147 }
 148
 149 static int read_password(char *buf, int buf_size)
 150 {
 151     uint8_t ch;
 152     int i, ret;
 153
 154     printf("password: ");
 155     fflush(stdout);
 156     term_init();
 157     i = 0;
 158     for(;;) {
 159         ret = read(0, &ch, 1);
 160         if (ret == -1) {
 161             if (errno == EAGAIN || errno == EINTR) {
 162                 continue;
 163             } else {
 164                 ret = -1;
 165                 break;
 166             }
 167         } else if (ret == 0) {
 168             ret = -1;
 169             break;
 170         } else {
 171             if (ch == '\r') {
 172                 ret = 0;
 173                 break;
 174             }
 175             if (i < (buf_size - 1))
 176                 buf[i++] = ch;
 177         }
 178     }
 179     term_exit();
 180     buf[i] = '\0';
 181     printf("\n");
 182     return ret;
 183 }
 184 #endif
 185
 186 static int set_cache_flag(const char *mode, int *flags)
 187 {
 188     *flags &= ~BDRV_O_CACHE_MASK;
 189
 190     if (!strcmp(mode, "none") || !strcmp(mode, "off")) {
 191         *flags |= BDRV_O_CACHE_WB;
 192         *flags |= BDRV_O_NOCACHE;
 193     } else if (!strcmp(mode, "writeback")) {
 194         *flags |= BDRV_O_CACHE_WB;
 195     } else if (!strcmp(mode, "unsafe")) {
 196         *flags |= BDRV_O_CACHE_WB;
 197         *flags |= BDRV_O_NO_FLUSH;
 198     } else if (!strcmp(mode, "writethrough")) {
 199         /* this is the default */
 200     } else {
 201         return -1;
 202     }
 203
 204     return 0;
 205 }
 206
 207 static int print_block_option_help(const char *filename, const char *fmt)
 208 {
 209     BlockDriver *drv, *proto_drv;
 210     QEMUOptionParameter *create_options = NULL;
 211
 212     /* Find driver and parse its options */
 213     drv = bdrv_find_format(fmt);
 214     if (!drv) {
 215         error_report("Unknown file format '%s'", fmt);
 216         return 1;
 217     }
 218
 219     proto_drv = bdrv_find_protocol(filename);
 220     if (!proto_drv) {
 221         error_report("Unknown protocol '%s'", filename);
 222         return 1;
 223     }
 224
 225     create_options = append_option_parameters(create_options,
 226                                               drv->create_options);
 227     create_options = append_option_parameters(create_options,
 228                                               proto_drv->create_options);
 229     print_option_help(create_options);
 230     free_option_parameters(create_options);
 231     return 0;
 232 }
 233
 234 static BlockDriverState *bdrv_new_open(const char *filename,
 235                                        const char *fmt,
 236                                        int flags)
 237 {
 238     BlockDriverState *bs;
 239     BlockDriver *drv;
 240     char password[256];
 241     int ret;
 242
 243     bs = bdrv_new("image");
 244
 245     if (fmt) {
 246         drv = bdrv_find_format(fmt);
 247         if (!drv) {
 248             error_report("Unknown file format '%s'", fmt);
 249             goto fail;
 250         }
 251     } else {
 252         drv = NULL;
 253     }
 254
 255     ret = bdrv_open(bs, filename, flags, drv);
 256     if (ret < 0) {
 257         error_report("Could not open '%s': %s", filename, strerror(-ret));
 258         goto fail;
 259     }
 260
 261     if (bdrv_is_encrypted(bs)) {
 262         printf("Disk image '%s' is encrypted.\n", filename);
 263         if (read_password(password, sizeof(password)) < 0) {
 264             error_report("No password given");
 265             goto fail;
 266         }
 267         if (bdrv_set_key(bs, password) < 0) {
 268             error_report("invalid password");
 269             goto fail;
 270         }
 271     }
 272     return bs;
 273 fail:
 274     if (bs) {
 275         bdrv_delete(bs);
 276     }
 277     return NULL;
 278 }
 279
 280 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 281                                  const char *base_filename,
 282                                  const char *base_fmt)
 283 {
 284     if (base_filename) {
 285         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 286             error_report("Backing file not supported for file format '%s'",
 287                          fmt);
 288             return -1;
 289         }
 290     }
 291     if (base_fmt) {
 292         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 293             error_report("Backing file format not supported for file "
 294                          "format '%s'", fmt);
 295             return -1;
 296         }
 297     }
 298     return 0;
 299 }
 300
 301 static int img_create(int argc, char **argv)
 302 {
 303     int c, ret = 0;
 304     uint64_t img_size = -1;
 305     const char *fmt = "raw";
 306     const char *base_fmt = NULL;
 307     const char *filename;
 308     const char *base_filename = NULL;
 309     char *options = NULL;
 310
 311     for(;;) {
 312         c = getopt(argc, argv, "F:b:f:he6o:");
 313         if (c == -1) {
 314             break;
 315         }
 316         switch(c) {
 317         case '?':
 318         case 'h':
 319             help();
 320             break;
 321         case 'F':
 322             base_fmt = optarg;
 323             break;
 324         case 'b':
 325             base_filename = optarg;
 326             break;
 327         case 'f':
 328             fmt = optarg;
 329             break;
 330         case 'e':
 331             error_report("option -e is deprecated, please use \'-o "
 332                   "encryption\' instead!");
 333             return 1;
 334         case '6':
 335             error_report("option -6 is deprecated, please use \'-o "
 336                   "compat6\' instead!");
 337             return 1;
 338         case 'o':
 339             options = optarg;
 340             break;
 341         }
 342     }
 343
 344     /* Get the filename */
 345     if (optind >= argc) {
 346         help();
 347     }
 348     filename = argv[optind++];
 349
 350     /* Get image size, if specified */
 351     if (optind < argc) {
 352         int64_t sval;
 353         sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
 354         if (sval < 0) {
 355             error_report("Invalid image size specified! You may use k, M, G or "
 356                   "T suffixes for ");
 357             error_report("kilobytes, megabytes, gigabytes and terabytes.");
 358             ret = -1;
 359             goto out;
 360         }
 361         img_size = (uint64_t)sval;
 362     }
 363
 364     if (options && !strcmp(options, "?")) {
 365         ret = print_block_option_help(filename, fmt);
 366         goto out;
 367     }
 368
 369     ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
 370                           options, img_size, BDRV_O_FLAGS);
 371 out:
 372     if (ret) {
 373         return 1;
 374     }
 375     return 0;
 376 }
 377
 378 /*
 379  * Checks an image for consistency. Exit codes:
 380  *
 381  * 0 - Check completed, image is good
 382  * 1 - Check not completed because of internal errors
 383  * 2 - Check completed, image is corrupted
 384  * 3 - Check completed, image has leaked clusters, but is good otherwise
 385  */
 386 static int img_check(int argc, char **argv)
 387 {
 388     int c, ret;
 389     const char *filename, *fmt;
 390     BlockDriverState *bs;
 391     BdrvCheckResult result;
 392
 393     fmt = NULL;
 394     for(;;) {
 395         c = getopt(argc, argv, "f:h");
 396         if (c == -1) {
 397             break;
 398         }
 399         switch(c) {
 400         case '?':
 401         case 'h':
 402             help();
 403             break;
 404         case 'f':
 405             fmt = optarg;
 406             break;
 407         }
 408     }
 409     if (optind >= argc) {
 410         help();
 411     }
 412     filename = argv[optind++];
 413
 414     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
 415     if (!bs) {
 416         return 1;
 417     }
 418     ret = bdrv_check(bs, &result);
 419
 420     if (ret == -ENOTSUP) {
 421         error_report("This image format does not support checks");
 422         bdrv_delete(bs);
 423         return 1;
 424     }
 425
 426     if (!(result.corruptions || result.leaks || result.check_errors)) {
 427         printf("No errors were found on the image.\n");
 428     } else {
 429         if (result.corruptions) {
 430             printf("\n%d errors were found on the image.\n"
 431                 "Data may be corrupted, or further writes to the image "
 432                 "may corrupt it.\n",
 433                 result.corruptions);
 434         }
 435
 436         if (result.leaks) {
 437             printf("\n%d leaked clusters were found on the image.\n"
 438                 "This means waste of disk space, but no harm to data.\n",
 439                 result.leaks);
 440         }
 441
 442         if (result.check_errors) {
 443             printf("\n%d internal errors have occurred during the check.\n",
 444                 result.check_errors);
 445         }
 446     }
 447
 448     bdrv_delete(bs);
 449
 450     if (ret < 0 || result.check_errors) {
 451         printf("\nAn error has occurred during the check: %s\n"
 452             "The check is not complete and may have missed error.\n",
 453             strerror(-ret));
 454         return 1;
 455     }
 456
 457     if (result.corruptions) {
 458         return 2;
 459     } else if (result.leaks) {
 460         return 3;
 461     } else {
 462         return 0;
 463     }
 464 }
 465
 466 static int img_commit(int argc, char **argv)
 467 {
 468     int c, ret, flags;
 469     const char *filename, *fmt, *cache;
 470     BlockDriverState *bs;
 471
 472     fmt = NULL;
 473     cache = BDRV_DEFAULT_CACHE;
 474     for(;;) {
 475         c = getopt(argc, argv, "f:ht:");
 476         if (c == -1) {
 477             break;
 478         }
 479         switch(c) {
 480         case '?':
 481         case 'h':
 482             help();
 483             break;
 484         case 'f':
 485             fmt = optarg;
 486             break;
 487         case 't':
 488             cache = optarg;
 489             break;
 490         }
 491     }
 492     if (optind >= argc) {
 493         help();
 494     }
 495     filename = argv[optind++];
 496
 497     flags = BDRV_O_RDWR;
 498     ret = set_cache_flag(cache, &flags);
 499     if (ret < 0) {
 500         error_report("Invalid cache option: %s", cache);
 501         return -1;
 502     }
 503
 504     bs = bdrv_new_open(filename, fmt, flags);
 505     if (!bs) {
 506         return 1;
 507     }
 508     ret = bdrv_commit(bs);
 509     switch(ret) {
 510     case 0:
 511         printf("Image committed.\n");
 512         break;
 513     case -ENOENT:
 514         error_report("No disk inserted");
 515         break;
 516     case -EACCES:
 517         error_report("Image is read-only");
 518         break;
 519     case -ENOTSUP:
 520         error_report("Image is already committed");
 521         break;
 522     default:
 523         error_report("Error while committing image");
 524         break;
 525     }
 526
 527     bdrv_delete(bs);
 528     if (ret) {
 529         return 1;
 530     }
 531     return 0;
 532 }
 533
 534 /*
 535  * Checks whether the sector is not a zero sector.
 536  *
 537  * Attention! The len must be a multiple of 4 * sizeof(long) due to
 538  * restriction of optimizations in this function.
 539  */
 540 static int is_not_zero(const uint8_t *sector, int len)
 541 {
 542     /*
 543      * Use long as the biggest available internal data type that fits into the
 544      * CPU register and unroll the loop to smooth out the effect of memory
 545      * latency.
 546      */
 547
 548     int i;
 549     long d0, d1, d2, d3;
 550     const long * const data = (const long *) sector;
 551
 552     len /= sizeof(long);
 553
 554     for(i = 0; i < len; i += 4) {
 555         d0 = data[i + 0];
 556         d1 = data[i + 1];
 557         d2 = data[i + 2];
 558         d3 = data[i + 3];
 559
 560         if (d0 || d1 || d2 || d3) {
 561             return 1;
 562         }
 563     }
 564
 565     return 0;
 566 }
 567
 568 /*
 569  * Returns true iff the first sector pointed to by 'buf' contains at least
 570  * a non-NUL byte.
 571  *
 572  * 'pnum' is set to the number of sectors (including and immediately following
 573  * the first one) that are known to be in the same allocated/unallocated state.
 574  */
 575 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 576 {
 577     int v, i;
 578
 579     if (n <= 0) {
 580         *pnum = 0;
 581         return 0;
 582     }
 583     v = is_not_zero(buf, 512);
 584     for(i = 1; i < n; i++) {
 585         buf += 512;
 586         if (v != is_not_zero(buf, 512))
 587             break;
 588     }
 589     *pnum = i;
 590     return v;
 591 }
 592
 593 /*
 594  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 595  * buffers matches, non-zero otherwise.
 596  *
 597  * pnum is set to the number of sectors (including and immediately following
 598  * the first one) that are known to have the same comparison result
 599  */
 600 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 601     int *pnum)
 602 {
 603     int res, i;
 604
 605     if (n <= 0) {
 606         *pnum = 0;
 607         return 0;
 608     }
 609
 610     res = !!memcmp(buf1, buf2, 512);
 611     for(i = 1; i < n; i++) {
 612         buf1 += 512;
 613         buf2 += 512;
 614
 615         if (!!memcmp(buf1, buf2, 512) != res) {
 616             break;
 617         }
 618     }
 619
 620     *pnum = i;
 621     return res;
 622 }
 623
 624 #define IO_BUF_SIZE (2 * 1024 * 1024)
 625
 626 static int img_convert(int argc, char **argv)
 627 {
 628     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
 629     int progress = 0, flags;
 630     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
 631     BlockDriver *drv, *proto_drv;
 632     BlockDriverState **bs = NULL, *out_bs = NULL;
 633     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 634     uint64_t bs_sectors;
 635     uint8_t * buf = NULL;
 636     const uint8_t *buf1;
 637     BlockDriverInfo bdi;
 638     QEMUOptionParameter *param = NULL, *create_options = NULL;
 639     QEMUOptionParameter *out_baseimg_param;
 640     char *options = NULL;
 641     const char *snapshot_name = NULL;
 642     float local_progress;
 643
 644     fmt = NULL;
 645     out_fmt = "raw";
 646     cache = "unsafe";
 647     out_baseimg = NULL;
 648     compress = 0;
 649     for(;;) {
 650         c = getopt(argc, argv, "f:O:B:s:hce6o:pt:");
 651         if (c == -1) {
 652             break;
 653         }
 654         switch(c) {
 655         case '?':
 656         case 'h':
 657             help();
 658             break;
 659         case 'f':
 660             fmt = optarg;
 661             break;
 662         case 'O':
 663             out_fmt = optarg;
 664             break;
 665         case 'B':
 666             out_baseimg = optarg;
 667             break;
 668         case 'c':
 669             compress = 1;
 670             break;
 671         case 'e':
 672             error_report("option -e is deprecated, please use \'-o "
 673                   "encryption\' instead!");
 674             return 1;
 675         case '6':
 676             error_report("option -6 is deprecated, please use \'-o "
 677                   "compat6\' instead!");
 678             return 1;
 679         case 'o':
 680             options = optarg;
 681             break;
 682         case 's':
 683             snapshot_name = optarg;
 684             break;
 685         case 'p':
 686             progress = 1;
 687             break;
 688         case 't':
 689             cache = optarg;
 690             break;
 691         }
 692     }
 693
 694     bs_n = argc - optind - 1;
 695     if (bs_n < 1) {
 696         help();
 697     }
 698
 699     out_filename = argv[argc - 1];
 700
 701     if (options && !strcmp(options, "?")) {
 702         ret = print_block_option_help(out_filename, out_fmt);
 703         goto out;
 704     }
 705
 706     if (bs_n > 1 && out_baseimg) {
 707         error_report("-B makes no sense when concatenating multiple input "
 708                      "images");
 709         ret = -1;
 710         goto out;
 711     }
 712
 713     qemu_progress_init(progress, 2.0);
 714     qemu_progress_print(0, 100);
 715
 716     bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
 717
 718     total_sectors = 0;
 719     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 720         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
 721         if (!bs[bs_i]) {
 722             error_report("Could not open '%s'", argv[optind + bs_i]);
 723             ret = -1;
 724             goto out;
 725         }
 726         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 727         total_sectors += bs_sectors;
 728     }
 729
 730     if (snapshot_name != NULL) {
 731         if (bs_n > 1) {
 732             error_report("No support for concatenating multiple snapshot");
 733             ret = -1;
 734             goto out;
 735         }
 736         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
 737             error_report("Failed to load snapshot");
 738             ret = -1;
 739             goto out;
 740         }
 741     }
 742
 743     /* Find driver and parse its options */
 744     drv = bdrv_find_format(out_fmt);
 745     if (!drv) {
 746         error_report("Unknown file format '%s'", out_fmt);
 747         ret = -1;
 748         goto out;
 749     }
 750
 751     proto_drv = bdrv_find_protocol(out_filename);
 752     if (!proto_drv) {
 753         error_report("Unknown protocol '%s'", out_filename);
 754         ret = -1;
 755         goto out;
 756     }
 757
 758     create_options = append_option_parameters(create_options,
 759                                               drv->create_options);
 760     create_options = append_option_parameters(create_options,
 761                                               proto_drv->create_options);
 762
 763     if (options) {
 764         param = parse_option_parameters(options, create_options, param);
 765         if (param == NULL) {
 766             error_report("Invalid options for file format '%s'.", out_fmt);
 767             ret = -1;
 768             goto out;
 769         }
 770     } else {
 771         param = parse_option_parameters("", create_options, param);
 772     }
 773
 774     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 775     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
 776     if (ret < 0) {
 777         goto out;
 778     }
 779
 780     /* Get backing file name if -o backing_file was used */
 781     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 782     if (out_baseimg_param) {
 783         out_baseimg = out_baseimg_param->value.s;
 784     }
 785
 786     /* Check if compression is supported */
 787     if (compress) {
 788         QEMUOptionParameter *encryption =
 789             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 790
 791         if (!drv->bdrv_write_compressed) {
 792             error_report("Compression not supported for this file format");
 793             ret = -1;
 794             goto out;
 795         }
 796
 797         if (encryption && encryption->value.n) {
 798             error_report("Compression and encryption not supported at "
 799                          "the same time");
 800             ret = -1;
 801             goto out;
 802         }
 803     }
 804
 805     /* Create the new image */
 806     ret = bdrv_create(drv, out_filename, param);
 807     if (ret < 0) {
 808         if (ret == -ENOTSUP) {
 809             error_report("Formatting not supported for file format '%s'",
 810                          out_fmt);
 811         } else if (ret == -EFBIG) {
 812             error_report("The image size is too large for file format '%s'",
 813                          out_fmt);
 814         } else {
 815             error_report("%s: error while converting %s: %s",
 816                          out_filename, out_fmt, strerror(-ret));
 817         }
 818         goto out;
 819     }
 820
 821     flags = BDRV_O_RDWR;
 822     ret = set_cache_flag(cache, &flags);
 823     if (ret < 0) {
 824         error_report("Invalid cache option: %s", cache);
 825         return -1;
 826     }
 827
 828     out_bs = bdrv_new_open(out_filename, out_fmt, flags);
 829     if (!out_bs) {
 830         ret = -1;
 831         goto out;
 832     }
 833
 834     bs_i = 0;
 835     bs_offset = 0;
 836     bdrv_get_geometry(bs[0], &bs_sectors);
 837     buf = qemu_malloc(IO_BUF_SIZE);
 838
 839     if (compress) {
 840         ret = bdrv_get_info(out_bs, &bdi);
 841         if (ret < 0) {
 842             error_report("could not get block driver info");
 843             goto out;
 844         }
 845         cluster_size = bdi.cluster_size;
 846         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
 847             error_report("invalid cluster size");
 848             ret = -1;
 849             goto out;
 850         }
 851         cluster_sectors = cluster_size >> 9;
 852         sector_num = 0;
 853
 854         nb_sectors = total_sectors;
 855         local_progress = (float)100 /
 856             (nb_sectors / MIN(nb_sectors, cluster_sectors));
 857
 858         for(;;) {
 859             int64_t bs_num;
 860             int remainder;
 861             uint8_t *buf2;
 862
 863             nb_sectors = total_sectors - sector_num;
 864             if (nb_sectors <= 0)
 865                 break;
 866             if (nb_sectors >= cluster_sectors)
 867                 n = cluster_sectors;
 868             else
 869                 n = nb_sectors;
 870
 871             bs_num = sector_num - bs_offset;
 872             assert (bs_num >= 0);
 873             remainder = n;
 874             buf2 = buf;
 875             while (remainder > 0) {
 876                 int nlow;
 877                 while (bs_num == bs_sectors) {
 878                     bs_i++;
 879                     assert (bs_i < bs_n);
 880                     bs_offset += bs_sectors;
 881                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 882                     bs_num = 0;
 883                     /* printf("changing part: sector_num=%" PRId64 ", "
 884                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
 885                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
 886                 }
 887                 assert (bs_num < bs_sectors);
 888
 889                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 890
 891                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
 892                 if (ret < 0) {
 893                     error_report("error while reading");
 894                     goto out;
 895                 }
 896
 897                 buf2 += nlow * 512;
 898                 bs_num += nlow;
 899
 900                 remainder -= nlow;
 901             }
 902             assert (remainder == 0);
 903
 904             if (n < cluster_sectors) {
 905                 memset(buf + n * 512, 0, cluster_size - n * 512);
 906             }
 907             if (is_not_zero(buf, cluster_size)) {
 908                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
 909                                             cluster_sectors);
 910                 if (ret != 0) {
 911                     error_report("error while compressing sector %" PRId64,
 912                           sector_num);
 913                     goto out;
 914                 }
 915             }
 916             sector_num += n;
 917             qemu_progress_print(local_progress, 100);
 918         }
 919         /* signal EOF to align */
 920         bdrv_write_compressed(out_bs, 0, NULL, 0);
 921     } else {
 922         int has_zero_init = bdrv_has_zero_init(out_bs);
 923
 924         sector_num = 0; // total number of sectors converted so far
 925         nb_sectors = total_sectors - sector_num;
 926         local_progress = (float)100 /
 927             (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
 928
 929         for(;;) {
 930             nb_sectors = total_sectors - sector_num;
 931             if (nb_sectors <= 0) {
 932                 break;
 933             }
 934             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
 935                 n = (IO_BUF_SIZE / 512);
 936             } else {
 937                 n = nb_sectors;
 938             }
 939
 940             while (sector_num - bs_offset >= bs_sectors) {
 941                 bs_i ++;
 942                 assert (bs_i < bs_n);
 943                 bs_offset += bs_sectors;
 944                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
 945                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
 946                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
 947                    sector_num, bs_i, bs_offset, bs_sectors); */
 948             }
 949
 950             if (n > bs_offset + bs_sectors - sector_num) {
 951                 n = bs_offset + bs_sectors - sector_num;
 952             }
 953
 954             if (has_zero_init) {
 955                 /* If the output image is being created as a copy on write image,
 956                    assume that sectors which are unallocated in the input image
 957                    are present in both the output's and input's base images (no
 958                    need to copy them). */
 959                 if (out_baseimg) {
 960                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
 961                                            n, &n1)) {
 962                         sector_num += n1;
 963                         continue;
 964                     }
 965                     /* The next 'n1' sectors are allocated in the input image. Copy
 966                        only those as they may be followed by unallocated sectors. */
 967                     n = n1;
 968                 }
 969             } else {
 970                 n1 = n;
 971             }
 972
 973             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
 974             if (ret < 0) {
 975                 error_report("error while reading");
 976                 goto out;
 977             }
 978             /* NOTE: at the same time we convert, we do not write zero
 979                sectors to have a chance to compress the image. Ideally, we
 980                should add a specific call to have the info to go faster */
 981             buf1 = buf;
 982             while (n > 0) {
 983                 /* If the output image is being created as a copy on write image,
 984                    copy all sectors even the ones containing only NUL bytes,
 985                    because they may differ from the sectors in the base image.
 986
 987                    If the output is to a host device, we also write out
 988                    sectors that are entirely 0, since whatever data was
 989                    already there is garbage, not 0s. */
 990                 if (!has_zero_init || out_baseimg ||
 991                     is_allocated_sectors(buf1, n, &n1)) {
 992                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
 993                     if (ret < 0) {
 994                         error_report("error while writing");
 995                         goto out;
 996                     }
 997                 }
 998                 sector_num += n1;
 999                 n -= n1;
1000                 buf1 += n1 * 512;
1001             }
1002             qemu_progress_print(local_progress, 100);
1003         }
1004     }
1005 out:
1006     qemu_progress_end();
1007     free_option_parameters(create_options);
1008     free_option_parameters(param);
1009     qemu_free(buf);
1010     if (out_bs) {
1011         bdrv_delete(out_bs);
1012     }
1013     if (bs) {
1014         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1015             if (bs[bs_i]) {
1016                 bdrv_delete(bs[bs_i]);
1017             }
1018         }
1019         qemu_free(bs);
1020     }
1021     if (ret) {
1022         return 1;
1023     }
1024     return 0;
1025 }
1026
1027 #ifdef _WIN32
1028 static int64_t get_allocated_file_size(const char *filename)
1029 {
1030     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
1031     get_compressed_t get_compressed;
1032     struct _stati64 st;
1033
1034     /* WinNT support GetCompressedFileSize to determine allocate size */
1035     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1036     if (get_compressed) {
1037         DWORD high, low;
1038         low = get_compressed(filename, &high);
1039         if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
1040             return (((int64_t) high) << 32) + low;
1041     }
1042
1043     if (_stati64(filename, &st) < 0)
1044         return -1;
1045     return st.st_size;
1046 }
1047 #else
1048 static int64_t get_allocated_file_size(const char *filename)
1049 {
1050     struct stat st;
1051     if (stat(filename, &st) < 0)
1052         return -1;
1053     return (int64_t)st.st_blocks * 512;
1054 }
1055 #endif
1056
1057 static void dump_snapshots(BlockDriverState *bs)
1058 {
1059     QEMUSnapshotInfo *sn_tab, *sn;
1060     int nb_sns, i;
1061     char buf[256];
1062
1063     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1064     if (nb_sns <= 0)
1065         return;
1066     printf("Snapshot list:\n");
1067     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1068     for(i = 0; i < nb_sns; i++) {
1069         sn = &sn_tab[i];
1070         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1071     }
1072     qemu_free(sn_tab);
1073 }
1074
1075 static int img_info(int argc, char **argv)
1076 {
1077     int c;
1078     const char *filename, *fmt;
1079     BlockDriverState *bs;
1080     char fmt_name[128], size_buf[128], dsize_buf[128];
1081     uint64_t total_sectors;
1082     int64_t allocated_size;
1083     char backing_filename[1024];
1084     char backing_filename2[1024];
1085     BlockDriverInfo bdi;
1086
1087     fmt = NULL;
1088     for(;;) {
1089         c = getopt(argc, argv, "f:h");
1090         if (c == -1) {
1091             break;
1092         }
1093         switch(c) {
1094         case '?':
1095         case 'h':
1096             help();
1097             break;
1098         case 'f':
1099             fmt = optarg;
1100             break;
1101         }
1102     }
1103     if (optind >= argc) {
1104         help();
1105     }
1106     filename = argv[optind++];
1107
1108     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1109     if (!bs) {
1110         return 1;
1111     }
1112     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1113     bdrv_get_geometry(bs, &total_sectors);
1114     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1115     allocated_size = get_allocated_file_size(filename);
1116     if (allocated_size < 0) {
1117         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1118     } else {
1119         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1120                                 allocated_size);
1121     }
1122     printf("image: %s\n"
1123            "file format: %s\n"
1124            "virtual size: %s (%" PRId64 " bytes)\n"
1125            "disk size: %s\n",
1126            filename, fmt_name, size_buf,
1127            (total_sectors * 512),
1128            dsize_buf);
1129     if (bdrv_is_encrypted(bs)) {
1130         printf("encrypted: yes\n");
1131     }
1132     if (bdrv_get_info(bs, &bdi) >= 0) {
1133         if (bdi.cluster_size != 0) {
1134             printf("cluster_size: %d\n", bdi.cluster_size);
1135         }
1136     }
1137     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1138     if (backing_filename[0] != '\0') {
1139         path_combine(backing_filename2, sizeof(backing_filename2),
1140                      filename, backing_filename);
1141         printf("backing file: %s (actual path: %s)\n",
1142                backing_filename,
1143                backing_filename2);
1144     }
1145     dump_snapshots(bs);
1146     bdrv_delete(bs);
1147     return 0;
1148 }
1149
1150 #define SNAPSHOT_LIST   1
1151 #define SNAPSHOT_CREATE 2
1152 #define SNAPSHOT_APPLY  3
1153 #define SNAPSHOT_DELETE 4
1154
1155 static int img_snapshot(int argc, char **argv)
1156 {
1157     BlockDriverState *bs;
1158     QEMUSnapshotInfo sn;
1159     char *filename, *snapshot_name = NULL;
1160     int c, ret = 0, bdrv_oflags;
1161     int action = 0;
1162     qemu_timeval tv;
1163
1164     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1165     /* Parse commandline parameters */
1166     for(;;) {
1167         c = getopt(argc, argv, "la:c:d:h");
1168         if (c == -1) {
1169             break;
1170         }
1171         switch(c) {
1172         case '?':
1173         case 'h':
1174             help();
1175             return 0;
1176         case 'l':
1177             if (action) {
1178                 help();
1179                 return 0;
1180             }
1181             action = SNAPSHOT_LIST;
1182             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1183             break;
1184         case 'a':
1185             if (action) {
1186                 help();
1187                 return 0;
1188             }
1189             action = SNAPSHOT_APPLY;
1190             snapshot_name = optarg;
1191             break;
1192         case 'c':
1193             if (action) {
1194                 help();
1195                 return 0;
1196             }
1197             action = SNAPSHOT_CREATE;
1198             snapshot_name = optarg;
1199             break;
1200         case 'd':
1201             if (action) {
1202                 help();
1203                 return 0;
1204             }
1205             action = SNAPSHOT_DELETE;
1206             snapshot_name = optarg;
1207             break;
1208         }
1209     }
1210
1211     if (optind >= argc) {
1212         help();
1213     }
1214     filename = argv[optind++];
1215
1216     /* Open the image */
1217     bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1218     if (!bs) {
1219         return 1;
1220     }
1221
1222     /* Perform the requested action */
1223     switch(action) {
1224     case SNAPSHOT_LIST:
1225         dump_snapshots(bs);
1226         break;
1227
1228     case SNAPSHOT_CREATE:
1229         memset(&sn, 0, sizeof(sn));
1230         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1231
1232         qemu_gettimeofday(&tv);
1233         sn.date_sec = tv.tv_sec;
1234         sn.date_nsec = tv.tv_usec * 1000;
1235
1236         ret = bdrv_snapshot_create(bs, &sn);
1237         if (ret) {
1238             error_report("Could not create snapshot '%s': %d (%s)",
1239                 snapshot_name, ret, strerror(-ret));
1240         }
1241         break;
1242
1243     case SNAPSHOT_APPLY:
1244         ret = bdrv_snapshot_goto(bs, snapshot_name);
1245         if (ret) {
1246             error_report("Could not apply snapshot '%s': %d (%s)",
1247                 snapshot_name, ret, strerror(-ret));
1248         }
1249         break;
1250
1251     case SNAPSHOT_DELETE:
1252         ret = bdrv_snapshot_delete(bs, snapshot_name);
1253         if (ret) {
1254             error_report("Could not delete snapshot '%s': %d (%s)",
1255                 snapshot_name, ret, strerror(-ret));
1256         }
1257         break;
1258     }
1259
1260     /* Cleanup */
1261     bdrv_delete(bs);
1262     if (ret) {
1263         return 1;
1264     }
1265     return 0;
1266 }
1267
1268 static int img_rebase(int argc, char **argv)
1269 {
1270     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1271     BlockDriver *old_backing_drv, *new_backing_drv;
1272     char *filename;
1273     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1274     int c, flags, ret;
1275     int unsafe = 0;
1276     int progress = 0;
1277
1278     /* Parse commandline parameters */
1279     fmt = NULL;
1280     cache = BDRV_DEFAULT_CACHE;
1281     out_baseimg = NULL;
1282     out_basefmt = NULL;
1283     for(;;) {
1284         c = getopt(argc, argv, "uhf:F:b:pt:");
1285         if (c == -1) {
1286             break;
1287         }
1288         switch(c) {
1289         case '?':
1290         case 'h':
1291             help();
1292             return 0;
1293         case 'f':
1294             fmt = optarg;
1295             break;
1296         case 'F':
1297             out_basefmt = optarg;
1298             break;
1299         case 'b':
1300             out_baseimg = optarg;
1301             break;
1302         case 'u':
1303             unsafe = 1;
1304             break;
1305         case 'p':
1306             progress = 1;
1307             break;
1308         case 't':
1309             cache = optarg;
1310             break;
1311         }
1312     }
1313
1314     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1315         help();
1316     }
1317     filename = argv[optind++];
1318
1319     qemu_progress_init(progress, 2.0);
1320     qemu_progress_print(0, 100);
1321
1322     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1323     ret = set_cache_flag(cache, &flags);
1324     if (ret < 0) {
1325         error_report("Invalid cache option: %s", cache);
1326         return -1;
1327     }
1328
1329     /*
1330      * Open the images.
1331      *
1332      * Ignore the old backing file for unsafe rebase in case we want to correct
1333      * the reference to a renamed or moved backing file.
1334      */
1335     bs = bdrv_new_open(filename, fmt, flags);
1336     if (!bs) {
1337         return 1;
1338     }
1339
1340     /* Find the right drivers for the backing files */
1341     old_backing_drv = NULL;
1342     new_backing_drv = NULL;
1343
1344     if (!unsafe && bs->backing_format[0] != '\0') {
1345         old_backing_drv = bdrv_find_format(bs->backing_format);
1346         if (old_backing_drv == NULL) {
1347             error_report("Invalid format name: '%s'", bs->backing_format);
1348             ret = -1;
1349             goto out;
1350         }
1351     }
1352
1353     if (out_basefmt != NULL) {
1354         new_backing_drv = bdrv_find_format(out_basefmt);
1355         if (new_backing_drv == NULL) {
1356             error_report("Invalid format name: '%s'", out_basefmt);
1357             ret = -1;
1358             goto out;
1359         }
1360     }
1361
1362     /* For safe rebasing we need to compare old and new backing file */
1363     if (unsafe) {
1364         /* Make the compiler happy */
1365         bs_old_backing = NULL;
1366         bs_new_backing = NULL;
1367     } else {
1368         char backing_name[1024];
1369
1370         bs_old_backing = bdrv_new("old_backing");
1371         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1372         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1373                         old_backing_drv);
1374         if (ret) {
1375             error_report("Could not open old backing file '%s'", backing_name);
1376             goto out;
1377         }
1378
1379         bs_new_backing = bdrv_new("new_backing");
1380         ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1381                         new_backing_drv);
1382         if (ret) {
1383             error_report("Could not open new backing file '%s'", out_baseimg);
1384             goto out;
1385         }
1386     }
1387
1388     /*
1389      * Check each unallocated cluster in the COW file. If it is unallocated,
1390      * accesses go to the backing file. We must therefore compare this cluster
1391      * in the old and new backing file, and if they differ we need to copy it
1392      * from the old backing file into the COW file.
1393      *
1394      * If qemu-img crashes during this step, no harm is done. The content of
1395      * the image is the same as the original one at any time.
1396      */
1397     if (!unsafe) {
1398         uint64_t num_sectors;
1399         uint64_t sector;
1400         int n;
1401         uint8_t * buf_old;
1402         uint8_t * buf_new;
1403         float local_progress;
1404
1405         buf_old = qemu_malloc(IO_BUF_SIZE);
1406         buf_new = qemu_malloc(IO_BUF_SIZE);
1407
1408         bdrv_get_geometry(bs, &num_sectors);
1409
1410         local_progress = (float)100 /
1411             (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1412         for (sector = 0; sector < num_sectors; sector += n) {
1413
1414             /* How many sectors can we handle with the next read? */
1415             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1416                 n = (IO_BUF_SIZE / 512);
1417             } else {
1418                 n = num_sectors - sector;
1419             }
1420
1421             /* If the cluster is allocated, we don't need to take action */
1422             ret = bdrv_is_allocated(bs, sector, n, &n);
1423             if (ret) {
1424                 continue;
1425             }
1426
1427             /* Read old and new backing file */
1428             ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1429             if (ret < 0) {
1430                 error_report("error while reading from old backing file");
1431                 goto out;
1432             }
1433             ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1434             if (ret < 0) {
1435                 error_report("error while reading from new backing file");
1436                 goto out;
1437             }
1438
1439             /* If they differ, we need to write to the COW file */
1440             uint64_t written = 0;
1441
1442             while (written < n) {
1443                 int pnum;
1444
1445                 if (compare_sectors(buf_old + written * 512,
1446                     buf_new + written * 512, n - written, &pnum))
1447                 {
1448                     ret = bdrv_write(bs, sector + written,
1449                         buf_old + written * 512, pnum);
1450                     if (ret < 0) {
1451                         error_report("Error while writing to COW image: %s",
1452                             strerror(-ret));
1453                         goto out;
1454                     }
1455                 }
1456
1457                 written += pnum;
1458             }
1459             qemu_progress_print(local_progress, 100);
1460         }
1461
1462         qemu_free(buf_old);
1463         qemu_free(buf_new);
1464     }
1465
1466     /*
1467      * Change the backing file. All clusters that are different from the old
1468      * backing file are overwritten in the COW file now, so the visible content
1469      * doesn't change when we switch the backing file.
1470      */
1471     ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1472     if (ret == -ENOSPC) {
1473         error_report("Could not change the backing file to '%s': No "
1474                      "space left in the file header", out_baseimg);
1475     } else if (ret < 0) {
1476         error_report("Could not change the backing file to '%s': %s",
1477             out_baseimg, strerror(-ret));
1478     }
1479
1480     qemu_progress_print(100, 0);
1481     /*
1482      * TODO At this point it is possible to check if any clusters that are
1483      * allocated in the COW file are the same in the backing file. If so, they
1484      * could be dropped from the COW file. Don't do this before switching the
1485      * backing file, in case of a crash this would lead to corruption.
1486      */
1487 out:
1488     qemu_progress_end();
1489     /* Cleanup */
1490     if (!unsafe) {
1491         if (bs_old_backing != NULL) {
1492             bdrv_delete(bs_old_backing);
1493         }
1494         if (bs_new_backing != NULL) {
1495             bdrv_delete(bs_new_backing);
1496         }
1497     }
1498
1499     bdrv_delete(bs);
1500     if (ret) {
1501         return 1;
1502     }
1503     return 0;
1504 }
1505
1506 static int img_resize(int argc, char **argv)
1507 {
1508     int c, ret, relative;
1509     const char *filename, *fmt, *size;
1510     int64_t n, total_size;
1511     BlockDriverState *bs = NULL;
1512     QEMUOptionParameter *param;
1513     QEMUOptionParameter resize_options[] = {
1514         {
1515             .name = BLOCK_OPT_SIZE,
1516             .type = OPT_SIZE,
1517             .help = "Virtual disk size"
1518         },
1519         { NULL }
1520     };
1521
1522     /* Remove size from argv manually so that negative numbers are not treated
1523      * as options by getopt. */
1524     if (argc < 3) {
1525         help();
1526         return 1;
1527     }
1528
1529     size = argv[--argc];
1530
1531     /* Parse getopt arguments */
1532     fmt = NULL;
1533     for(;;) {
1534         c = getopt(argc, argv, "f:h");
1535         if (c == -1) {
1536             break;
1537         }
1538         switch(c) {
1539         case '?':
1540         case 'h':
1541             help();
1542             break;
1543         case 'f':
1544             fmt = optarg;
1545             break;
1546         }
1547     }
1548     if (optind >= argc) {
1549         help();
1550     }
1551     filename = argv[optind++];
1552
1553     /* Choose grow, shrink, or absolute resize mode */
1554     switch (size[0]) {
1555     case '+':
1556         relative = 1;
1557         size++;
1558         break;
1559     case '-':
1560         relative = -1;
1561         size++;
1562         break;
1563     default:
1564         relative = 0;
1565         break;
1566     }
1567
1568     /* Parse size */
1569     param = parse_option_parameters("", resize_options, NULL);
1570     if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1571         /* Error message already printed when size parsing fails */
1572         ret = -1;
1573         goto out;
1574     }
1575     n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1576     free_option_parameters(param);
1577
1578     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1579     if (!bs) {
1580         ret = -1;
1581         goto out;
1582     }
1583
1584     if (relative) {
1585         total_size = bdrv_getlength(bs) + n * relative;
1586     } else {
1587         total_size = n;
1588     }
1589     if (total_size <= 0) {
1590         error_report("New image size must be positive");
1591         ret = -1;
1592         goto out;
1593     }
1594
1595     ret = bdrv_truncate(bs, total_size);
1596     switch (ret) {
1597     case 0:
1598         printf("Image resized.\n");
1599         break;
1600     case -ENOTSUP:
1601         error_report("This image format does not support resize");
1602         break;
1603     case -EACCES:
1604         error_report("Image is read-only");
1605         break;
1606     default:
1607         error_report("Error resizing image (%d)", -ret);
1608         break;
1609     }
1610 out:
1611     if (bs) {
1612         bdrv_delete(bs);
1613     }
1614     if (ret) {
1615         return 1;
1616     }
1617     return 0;
1618 }
1619
1620 static const img_cmd_t img_cmds[] = {
1621 #define DEF(option, callback, arg_string)        \
1622     { option, callback },
1623 #include "qemu-img-cmds.h"
1624 #undef DEF
1625 #undef GEN_DOCS
1626     { NULL, NULL, },
1627 };
1628
1629 int main(int argc, char **argv)
1630 {
1631     const img_cmd_t *cmd;
1632     const char *cmdname;
1633
1634     error_set_progname(argv[0]);
1635
1636     bdrv_init();
1637     if (argc < 2)
1638         help();
1639     cmdname = argv[1];
1640     argc--; argv++;
1641
1642     /* find the command */
1643     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1644         if (!strcmp(cmdname, cmd->name)) {
1645             return cmd->handler(argc, argv);
1646         }
1647     }
1648
1649     /* not found */
1650     help();
1651     return 0;
1652 }