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