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
1028 static void dump_snapshots(BlockDriverState *bs)
1029 {
1030     QEMUSnapshotInfo *sn_tab, *sn;
1031     int nb_sns, i;
1032     char buf[256];
1033
1034     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1035     if (nb_sns <= 0)
1036         return;
1037     printf("Snapshot list:\n");
1038     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1039     for(i = 0; i < nb_sns; i++) {
1040         sn = &sn_tab[i];
1041         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1042     }
1043     qemu_free(sn_tab);
1044 }
1045
1046 static int img_info(int argc, char **argv)
1047 {
1048     int c;
1049     const char *filename, *fmt;
1050     BlockDriverState *bs;
1051     char fmt_name[128], size_buf[128], dsize_buf[128];
1052     uint64_t total_sectors;
1053     int64_t allocated_size;
1054     char backing_filename[1024];
1055     char backing_filename2[1024];
1056     BlockDriverInfo bdi;
1057
1058     fmt = NULL;
1059     for(;;) {
1060         c = getopt(argc, argv, "f:h");
1061         if (c == -1) {
1062             break;
1063         }
1064         switch(c) {
1065         case '?':
1066         case 'h':
1067             help();
1068             break;
1069         case 'f':
1070             fmt = optarg;
1071             break;
1072         }
1073     }
1074     if (optind >= argc) {
1075         help();
1076     }
1077     filename = argv[optind++];
1078
1079     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1080     if (!bs) {
1081         return 1;
1082     }
1083     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1084     bdrv_get_geometry(bs, &total_sectors);
1085     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1086     allocated_size = bdrv_get_allocated_file_size(bs);
1087     if (allocated_size < 0) {
1088         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1089     } else {
1090         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1091                                 allocated_size);
1092     }
1093     printf("image: %s\n"
1094            "file format: %s\n"
1095            "virtual size: %s (%" PRId64 " bytes)\n"
1096            "disk size: %s\n",
1097            filename, fmt_name, size_buf,
1098            (total_sectors * 512),
1099            dsize_buf);
1100     if (bdrv_is_encrypted(bs)) {
1101         printf("encrypted: yes\n");
1102     }
1103     if (bdrv_get_info(bs, &bdi) >= 0) {
1104         if (bdi.cluster_size != 0) {
1105             printf("cluster_size: %d\n", bdi.cluster_size);
1106         }
1107     }
1108     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1109     if (backing_filename[0] != '\0') {
1110         path_combine(backing_filename2, sizeof(backing_filename2),
1111                      filename, backing_filename);
1112         printf("backing file: %s (actual path: %s)\n",
1113                backing_filename,
1114                backing_filename2);
1115     }
1116     dump_snapshots(bs);
1117     bdrv_delete(bs);
1118     return 0;
1119 }
1120
1121 #define SNAPSHOT_LIST   1
1122 #define SNAPSHOT_CREATE 2
1123 #define SNAPSHOT_APPLY  3
1124 #define SNAPSHOT_DELETE 4
1125
1126 static int img_snapshot(int argc, char **argv)
1127 {
1128     BlockDriverState *bs;
1129     QEMUSnapshotInfo sn;
1130     char *filename, *snapshot_name = NULL;
1131     int c, ret = 0, bdrv_oflags;
1132     int action = 0;
1133     qemu_timeval tv;
1134
1135     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1136     /* Parse commandline parameters */
1137     for(;;) {
1138         c = getopt(argc, argv, "la:c:d:h");
1139         if (c == -1) {
1140             break;
1141         }
1142         switch(c) {
1143         case '?':
1144         case 'h':
1145             help();
1146             return 0;
1147         case 'l':
1148             if (action) {
1149                 help();
1150                 return 0;
1151             }
1152             action = SNAPSHOT_LIST;
1153             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1154             break;
1155         case 'a':
1156             if (action) {
1157                 help();
1158                 return 0;
1159             }
1160             action = SNAPSHOT_APPLY;
1161             snapshot_name = optarg;
1162             break;
1163         case 'c':
1164             if (action) {
1165                 help();
1166                 return 0;
1167             }
1168             action = SNAPSHOT_CREATE;
1169             snapshot_name = optarg;
1170             break;
1171         case 'd':
1172             if (action) {
1173                 help();
1174                 return 0;
1175             }
1176             action = SNAPSHOT_DELETE;
1177             snapshot_name = optarg;
1178             break;
1179         }
1180     }
1181
1182     if (optind >= argc) {
1183         help();
1184     }
1185     filename = argv[optind++];
1186
1187     /* Open the image */
1188     bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1189     if (!bs) {
1190         return 1;
1191     }
1192
1193     /* Perform the requested action */
1194     switch(action) {
1195     case SNAPSHOT_LIST:
1196         dump_snapshots(bs);
1197         break;
1198
1199     case SNAPSHOT_CREATE:
1200         memset(&sn, 0, sizeof(sn));
1201         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1202
1203         qemu_gettimeofday(&tv);
1204         sn.date_sec = tv.tv_sec;
1205         sn.date_nsec = tv.tv_usec * 1000;
1206
1207         ret = bdrv_snapshot_create(bs, &sn);
1208         if (ret) {
1209             error_report("Could not create snapshot '%s': %d (%s)",
1210                 snapshot_name, ret, strerror(-ret));
1211         }
1212         break;
1213
1214     case SNAPSHOT_APPLY:
1215         ret = bdrv_snapshot_goto(bs, snapshot_name);
1216         if (ret) {
1217             error_report("Could not apply snapshot '%s': %d (%s)",
1218                 snapshot_name, ret, strerror(-ret));
1219         }
1220         break;
1221
1222     case SNAPSHOT_DELETE:
1223         ret = bdrv_snapshot_delete(bs, snapshot_name);
1224         if (ret) {
1225             error_report("Could not delete snapshot '%s': %d (%s)",
1226                 snapshot_name, ret, strerror(-ret));
1227         }
1228         break;
1229     }
1230
1231     /* Cleanup */
1232     bdrv_delete(bs);
1233     if (ret) {
1234         return 1;
1235     }
1236     return 0;
1237 }
1238
1239 static int img_rebase(int argc, char **argv)
1240 {
1241     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1242     BlockDriver *old_backing_drv, *new_backing_drv;
1243     char *filename;
1244     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1245     int c, flags, ret;
1246     int unsafe = 0;
1247     int progress = 0;
1248
1249     /* Parse commandline parameters */
1250     fmt = NULL;
1251     cache = BDRV_DEFAULT_CACHE;
1252     out_baseimg = NULL;
1253     out_basefmt = NULL;
1254     for(;;) {
1255         c = getopt(argc, argv, "uhf:F:b:pt:");
1256         if (c == -1) {
1257             break;
1258         }
1259         switch(c) {
1260         case '?':
1261         case 'h':
1262             help();
1263             return 0;
1264         case 'f':
1265             fmt = optarg;
1266             break;
1267         case 'F':
1268             out_basefmt = optarg;
1269             break;
1270         case 'b':
1271             out_baseimg = optarg;
1272             break;
1273         case 'u':
1274             unsafe = 1;
1275             break;
1276         case 'p':
1277             progress = 1;
1278             break;
1279         case 't':
1280             cache = optarg;
1281             break;
1282         }
1283     }
1284
1285     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1286         help();
1287     }
1288     filename = argv[optind++];
1289
1290     qemu_progress_init(progress, 2.0);
1291     qemu_progress_print(0, 100);
1292
1293     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1294     ret = set_cache_flag(cache, &flags);
1295     if (ret < 0) {
1296         error_report("Invalid cache option: %s", cache);
1297         return -1;
1298     }
1299
1300     /*
1301      * Open the images.
1302      *
1303      * Ignore the old backing file for unsafe rebase in case we want to correct
1304      * the reference to a renamed or moved backing file.
1305      */
1306     bs = bdrv_new_open(filename, fmt, flags);
1307     if (!bs) {
1308         return 1;
1309     }
1310
1311     /* Find the right drivers for the backing files */
1312     old_backing_drv = NULL;
1313     new_backing_drv = NULL;
1314
1315     if (!unsafe && bs->backing_format[0] != '\0') {
1316         old_backing_drv = bdrv_find_format(bs->backing_format);
1317         if (old_backing_drv == NULL) {
1318             error_report("Invalid format name: '%s'", bs->backing_format);
1319             ret = -1;
1320             goto out;
1321         }
1322     }
1323
1324     if (out_basefmt != NULL) {
1325         new_backing_drv = bdrv_find_format(out_basefmt);
1326         if (new_backing_drv == NULL) {
1327             error_report("Invalid format name: '%s'", out_basefmt);
1328             ret = -1;
1329             goto out;
1330         }
1331     }
1332
1333     /* For safe rebasing we need to compare old and new backing file */
1334     if (unsafe) {
1335         /* Make the compiler happy */
1336         bs_old_backing = NULL;
1337         bs_new_backing = NULL;
1338     } else {
1339         char backing_name[1024];
1340
1341         bs_old_backing = bdrv_new("old_backing");
1342         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1343         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1344                         old_backing_drv);
1345         if (ret) {
1346             error_report("Could not open old backing file '%s'", backing_name);
1347             goto out;
1348         }
1349
1350         bs_new_backing = bdrv_new("new_backing");
1351         ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1352                         new_backing_drv);
1353         if (ret) {
1354             error_report("Could not open new backing file '%s'", out_baseimg);
1355             goto out;
1356         }
1357     }
1358
1359     /*
1360      * Check each unallocated cluster in the COW file. If it is unallocated,
1361      * accesses go to the backing file. We must therefore compare this cluster
1362      * in the old and new backing file, and if they differ we need to copy it
1363      * from the old backing file into the COW file.
1364      *
1365      * If qemu-img crashes during this step, no harm is done. The content of
1366      * the image is the same as the original one at any time.
1367      */
1368     if (!unsafe) {
1369         uint64_t num_sectors;
1370         uint64_t sector;
1371         int n;
1372         uint8_t * buf_old;
1373         uint8_t * buf_new;
1374         float local_progress;
1375
1376         buf_old = qemu_malloc(IO_BUF_SIZE);
1377         buf_new = qemu_malloc(IO_BUF_SIZE);
1378
1379         bdrv_get_geometry(bs, &num_sectors);
1380
1381         local_progress = (float)100 /
1382             (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1383         for (sector = 0; sector < num_sectors; sector += n) {
1384
1385             /* How many sectors can we handle with the next read? */
1386             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1387                 n = (IO_BUF_SIZE / 512);
1388             } else {
1389                 n = num_sectors - sector;
1390             }
1391
1392             /* If the cluster is allocated, we don't need to take action */
1393             ret = bdrv_is_allocated(bs, sector, n, &n);
1394             if (ret) {
1395                 continue;
1396             }
1397
1398             /* Read old and new backing file */
1399             ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1400             if (ret < 0) {
1401                 error_report("error while reading from old backing file");
1402                 goto out;
1403             }
1404             ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1405             if (ret < 0) {
1406                 error_report("error while reading from new backing file");
1407                 goto out;
1408             }
1409
1410             /* If they differ, we need to write to the COW file */
1411             uint64_t written = 0;
1412
1413             while (written < n) {
1414                 int pnum;
1415
1416                 if (compare_sectors(buf_old + written * 512,
1417                     buf_new + written * 512, n - written, &pnum))
1418                 {
1419                     ret = bdrv_write(bs, sector + written,
1420                         buf_old + written * 512, pnum);
1421                     if (ret < 0) {
1422                         error_report("Error while writing to COW image: %s",
1423                             strerror(-ret));
1424                         goto out;
1425                     }
1426                 }
1427
1428                 written += pnum;
1429             }
1430             qemu_progress_print(local_progress, 100);
1431         }
1432
1433         qemu_free(buf_old);
1434         qemu_free(buf_new);
1435     }
1436
1437     /*
1438      * Change the backing file. All clusters that are different from the old
1439      * backing file are overwritten in the COW file now, so the visible content
1440      * doesn't change when we switch the backing file.
1441      */
1442     ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1443     if (ret == -ENOSPC) {
1444         error_report("Could not change the backing file to '%s': No "
1445                      "space left in the file header", out_baseimg);
1446     } else if (ret < 0) {
1447         error_report("Could not change the backing file to '%s': %s",
1448             out_baseimg, strerror(-ret));
1449     }
1450
1451     qemu_progress_print(100, 0);
1452     /*
1453      * TODO At this point it is possible to check if any clusters that are
1454      * allocated in the COW file are the same in the backing file. If so, they
1455      * could be dropped from the COW file. Don't do this before switching the
1456      * backing file, in case of a crash this would lead to corruption.
1457      */
1458 out:
1459     qemu_progress_end();
1460     /* Cleanup */
1461     if (!unsafe) {
1462         if (bs_old_backing != NULL) {
1463             bdrv_delete(bs_old_backing);
1464         }
1465         if (bs_new_backing != NULL) {
1466             bdrv_delete(bs_new_backing);
1467         }
1468     }
1469
1470     bdrv_delete(bs);
1471     if (ret) {
1472         return 1;
1473     }
1474     return 0;
1475 }
1476
1477 static int img_resize(int argc, char **argv)
1478 {
1479     int c, ret, relative;
1480     const char *filename, *fmt, *size;
1481     int64_t n, total_size;
1482     BlockDriverState *bs = NULL;
1483     QEMUOptionParameter *param;
1484     QEMUOptionParameter resize_options[] = {
1485         {
1486             .name = BLOCK_OPT_SIZE,
1487             .type = OPT_SIZE,
1488             .help = "Virtual disk size"
1489         },
1490         { NULL }
1491     };
1492
1493     /* Remove size from argv manually so that negative numbers are not treated
1494      * as options by getopt. */
1495     if (argc < 3) {
1496         help();
1497         return 1;
1498     }
1499
1500     size = argv[--argc];
1501
1502     /* Parse getopt arguments */
1503     fmt = NULL;
1504     for(;;) {
1505         c = getopt(argc, argv, "f:h");
1506         if (c == -1) {
1507             break;
1508         }
1509         switch(c) {
1510         case '?':
1511         case 'h':
1512             help();
1513             break;
1514         case 'f':
1515             fmt = optarg;
1516             break;
1517         }
1518     }
1519     if (optind >= argc) {
1520         help();
1521     }
1522     filename = argv[optind++];
1523
1524     /* Choose grow, shrink, or absolute resize mode */
1525     switch (size[0]) {
1526     case '+':
1527         relative = 1;
1528         size++;
1529         break;
1530     case '-':
1531         relative = -1;
1532         size++;
1533         break;
1534     default:
1535         relative = 0;
1536         break;
1537     }
1538
1539     /* Parse size */
1540     param = parse_option_parameters("", resize_options, NULL);
1541     if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1542         /* Error message already printed when size parsing fails */
1543         ret = -1;
1544         goto out;
1545     }
1546     n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1547     free_option_parameters(param);
1548
1549     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1550     if (!bs) {
1551         ret = -1;
1552         goto out;
1553     }
1554
1555     if (relative) {
1556         total_size = bdrv_getlength(bs) + n * relative;
1557     } else {
1558         total_size = n;
1559     }
1560     if (total_size <= 0) {
1561         error_report("New image size must be positive");
1562         ret = -1;
1563         goto out;
1564     }
1565
1566     ret = bdrv_truncate(bs, total_size);
1567     switch (ret) {
1568     case 0:
1569         printf("Image resized.\n");
1570         break;
1571     case -ENOTSUP:
1572         error_report("This image format does not support resize");
1573         break;
1574     case -EACCES:
1575         error_report("Image is read-only");
1576         break;
1577     default:
1578         error_report("Error resizing image (%d)", -ret);
1579         break;
1580     }
1581 out:
1582     if (bs) {
1583         bdrv_delete(bs);
1584     }
1585     if (ret) {
1586         return 1;
1587     }
1588     return 0;
1589 }
1590
1591 static const img_cmd_t img_cmds[] = {
1592 #define DEF(option, callback, arg_string)        \
1593     { option, callback },
1594 #include "qemu-img-cmds.h"
1595 #undef DEF
1596 #undef GEN_DOCS
1597     { NULL, NULL, },
1598 };
1599
1600 int main(int argc, char **argv)
1601 {
1602     const img_cmd_t *cmd;
1603     const char *cmdname;
1604
1605     error_set_progname(argv[0]);
1606
1607     bdrv_init();
1608     if (argc < 2)
1609         help();
1610     cmdname = argv[1];
1611     argc--; argv++;
1612
1613     /* find the command */
1614     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1615         if (!strcmp(cmdname, cmd->name)) {
1616             return cmd->handler(argc, argv);
1617         }
1618     }
1619
1620     /* not found */
1621     help();
1622     return 0;
1623 }