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