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