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 "osdep.h"
  27 #include "block_int.h"
  28 #include <stdio.h>
  29
  30 #ifdef _WIN32
  31 #include <windows.h>
  32 #endif
  33
  34 typedef struct img_cmd_t {
  35     const char *name;
  36     int (*handler)(int argc, char **argv);
  37 } img_cmd_t;
  38
  39 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  40 #define BRDV_O_FLAGS BDRV_O_CACHE_WB
  41
  42 static void QEMU_NORETURN error(const char *fmt, ...)
  43 {
  44     va_list ap;
  45     va_start(ap, fmt);
  46     fprintf(stderr, "qemu-img: ");
  47     vfprintf(stderr, fmt, ap);
  48     fprintf(stderr, "\n");
  49     exit(1);
  50     va_end(ap);
  51 }
  52
  53 static void format_print(void *opaque, const char *name)
  54 {
  55     printf(" %s", name);
  56 }
  57
  58 /* Please keep in synch with qemu-img.texi */
  59 static void help(void)
  60 {
  61     printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  62            "usage: qemu-img command [command options]\n"
  63            "QEMU disk image utility\n"
  64            "\n"
  65            "Command syntax:\n"
  66 #define DEF(option, callback, arg_string)        \
  67            "  " arg_string "\n"
  68 #include "qemu-img-cmds.h"
  69 #undef DEF
  70 #undef GEN_DOCS
  71            "\n"
  72            "Command parameters:\n"
  73            "  'filename' is a disk image filename\n"
  74            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  75            "  'size' is the disk image size in bytes. Optional suffixes\n"
  76            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
  77            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
  78            "  'output_filename' is the destination disk image filename\n"
  79            "  'output_fmt' is the destination format\n"
  80            "  'options' is a comma separated list of format specific options in a\n"
  81            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  82            "    used format\n"
  83            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  84            "  '-h' with or without a command shows this help and lists the supported formats\n"
  85            "\n"
  86            "Parameters to snapshot subcommand:\n"
  87            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
  88            "  '-a' applies a snapshot (revert disk to saved state)\n"
  89            "  '-c' creates a snapshot\n"
  90            "  '-d' deletes a snapshot\n"
  91            "  '-l' lists all snapshots in the given image\n"
  92            );
  93     printf("\nSupported formats:");
  94     bdrv_iterate_format(format_print, NULL);
  95     printf("\n");
  96     exit(1);
  97 }
  98
  99 #if defined(WIN32)
 100 /* XXX: put correct support for win32 */
 101 static int read_password(char *buf, int buf_size)
 102 {
 103     int c, i;
 104     printf("Password: ");
 105     fflush(stdout);
 106     i = 0;
 107     for(;;) {
 108         c = getchar();
 109         if (c == '\n')
 110             break;
 111         if (i < (buf_size - 1))
 112             buf[i++] = c;
 113     }
 114     buf[i] = '\0';
 115     return 0;
 116 }
 117
 118 #else
 119
 120 #include <termios.h>
 121
 122 static struct termios oldtty;
 123
 124 static void term_exit(void)
 125 {
 126     tcsetattr (0, TCSANOW, &oldtty);
 127 }
 128
 129 static void term_init(void)
 130 {
 131     struct termios tty;
 132
 133     tcgetattr (0, &tty);
 134     oldtty = tty;
 135
 136     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 137                           |INLCR|IGNCR|ICRNL|IXON);
 138     tty.c_oflag |= OPOST;
 139     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 140     tty.c_cflag &= ~(CSIZE|PARENB);
 141     tty.c_cflag |= CS8;
 142     tty.c_cc[VMIN] = 1;
 143     tty.c_cc[VTIME] = 0;
 144
 145     tcsetattr (0, TCSANOW, &tty);
 146
 147     atexit(term_exit);
 148 }
 149
 150 static int read_password(char *buf, int buf_size)
 151 {
 152     uint8_t ch;
 153     int i, ret;
 154
 155     printf("password: ");
 156     fflush(stdout);
 157     term_init();
 158     i = 0;
 159     for(;;) {
 160         ret = read(0, &ch, 1);
 161         if (ret == -1) {
 162             if (errno == EAGAIN || errno == EINTR) {
 163                 continue;
 164             } else {
 165                 ret = -1;
 166                 break;
 167             }
 168         } else if (ret == 0) {
 169             ret = -1;
 170             break;
 171         } else {
 172             if (ch == '\r') {
 173                 ret = 0;
 174                 break;
 175             }
 176             if (i < (buf_size - 1))
 177                 buf[i++] = ch;
 178         }
 179     }
 180     term_exit();
 181     buf[i] = '\0';
 182     printf("\n");
 183     return ret;
 184 }
 185 #endif
 186
 187 static BlockDriverState *bdrv_new_open(const char *filename,
 188                                        const char *fmt)
 189 {
 190     BlockDriverState *bs;
 191     BlockDriver *drv;
 192     char password[256];
 193
 194     bs = bdrv_new("");
 195     if (!bs)
 196         error("Not enough memory");
 197     if (fmt) {
 198         drv = bdrv_find_format(fmt);
 199         if (!drv)
 200             error("Unknown file format '%s'", fmt);
 201     } else {
 202         drv = NULL;
 203     }
 204     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
 205         error("Could not open '%s'", filename);
 206     }
 207     if (bdrv_is_encrypted(bs)) {
 208         printf("Disk image '%s' is encrypted.\n", filename);
 209         if (read_password(password, sizeof(password)) < 0)
 210             error("No password given");
 211         if (bdrv_set_key(bs, password) < 0)
 212             error("invalid password");
 213     }
 214     return bs;
 215 }
 216
 217 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 218     int flags, const char *base_filename, const char *base_fmt)
 219 {
 220     if (flags & BLOCK_FLAG_ENCRYPT) {
 221         if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
 222             error("Encryption not supported for file format '%s'", fmt);
 223         }
 224     }
 225     if (flags & BLOCK_FLAG_COMPAT6) {
 226         if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
 227             error("VMDK version 6 not supported for file format '%s'", fmt);
 228         }
 229     }
 230
 231     if (base_filename) {
 232         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 233             error("Backing file not supported for file format '%s'", fmt);
 234         }
 235     }
 236     if (base_fmt) {
 237         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 238             error("Backing file format not supported for file format '%s'", fmt);
 239         }
 240     }
 241 }
 242
 243 static int img_create(int argc, char **argv)
 244 {
 245     int c, ret, flags;
 246     const char *fmt = "raw";
 247     const char *base_fmt = NULL;
 248     const char *filename;
 249     const char *base_filename = NULL;
 250     BlockDriver *drv;
 251     QEMUOptionParameter *param = NULL;
 252     char *options = NULL;
 253
 254     flags = 0;
 255     for(;;) {
 256         c = getopt(argc, argv, "F:b:f:he6o:");
 257         if (c == -1)
 258             break;
 259         switch(c) {
 260         case 'h':
 261             help();
 262             break;
 263         case 'F':
 264             base_fmt = optarg;
 265             break;
 266         case 'b':
 267             base_filename = optarg;
 268             break;
 269         case 'f':
 270             fmt = optarg;
 271             break;
 272         case 'e':
 273             flags |= BLOCK_FLAG_ENCRYPT;
 274             break;
 275         case '6':
 276             flags |= BLOCK_FLAG_COMPAT6;
 277             break;
 278         case 'o':
 279             options = optarg;
 280             break;
 281         }
 282     }
 283
 284     /* Find driver and parse its options */
 285     drv = bdrv_find_format(fmt);
 286     if (!drv)
 287         error("Unknown file format '%s'", fmt);
 288
 289     if (options && !strcmp(options, "?")) {
 290         print_option_help(drv->create_options);
 291         return 0;
 292     }
 293
 294     /* Create parameter list with default values */
 295     param = parse_option_parameters("", drv->create_options, param);
 296     set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
 297
 298     /* Parse -o options */
 299     if (options) {
 300         param = parse_option_parameters(options, drv->create_options, param);
 301         if (param == NULL) {
 302             error("Invalid options for file format '%s'.", fmt);
 303         }
 304     }
 305
 306     /* Get the filename */
 307     if (optind >= argc)
 308         help();
 309     filename = argv[optind++];
 310
 311     /* Add size to parameters */
 312     if (optind < argc) {
 313         set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
 314     }
 315
 316     /* Add old-style options to parameters */
 317     add_old_style_options(fmt, param, flags, base_filename, base_fmt);
 318
 319     // The size for the image must always be specified, with one exception:
 320     // If we are using a backing file, we can obtain the size from there
 321     if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
 322
 323         QEMUOptionParameter *backing_file =
 324             get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 325         QEMUOptionParameter *backing_fmt =
 326             get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
 327
 328         if (backing_file && backing_file->value.s) {
 329             BlockDriverState *bs;
 330             uint64_t size;
 331             const char *fmt = NULL;
 332             char buf[32];
 333
 334             if (backing_fmt && backing_fmt->value.s) {
 335                  if (bdrv_find_format(backing_fmt->value.s)) {
 336                      fmt = backing_fmt->value.s;
 337                 } else {
 338                      error("Unknown backing file format '%s'",
 339                         backing_fmt->value.s);
 340                 }
 341             }
 342
 343             bs = bdrv_new_open(backing_file->value.s, fmt);
 344             bdrv_get_geometry(bs, &size);
 345             size *= 512;
 346             bdrv_delete(bs);
 347
 348             snprintf(buf, sizeof(buf), "%" PRId64, size);
 349             set_option_parameter(param, BLOCK_OPT_SIZE, buf);
 350         } else {
 351             error("Image creation needs a size parameter");
 352         }
 353     }
 354
 355     printf("Formatting '%s', fmt=%s ", filename, fmt);
 356     print_option_parameters(param);
 357     puts("");
 358
 359     ret = bdrv_create(drv, filename, param);
 360     free_option_parameters(param);
 361
 362     if (ret < 0) {
 363         if (ret == -ENOTSUP) {
 364             error("Formatting or formatting option not supported for file format '%s'", fmt);
 365         } else if (ret == -EFBIG) {
 366             error("The image size is too large for file format '%s'", fmt);
 367         } else {
 368             error("Error while formatting");
 369         }
 370     }
 371     return 0;
 372 }
 373
 374 static int img_check(int argc, char **argv)
 375 {
 376     int c, ret;
 377     const char *filename, *fmt;
 378     BlockDriver *drv;
 379     BlockDriverState *bs;
 380
 381     fmt = NULL;
 382     for(;;) {
 383         c = getopt(argc, argv, "f:h");
 384         if (c == -1)
 385             break;
 386         switch(c) {
 387         case 'h':
 388             help();
 389             break;
 390         case 'f':
 391             fmt = optarg;
 392             break;
 393         }
 394     }
 395     if (optind >= argc)
 396         help();
 397     filename = argv[optind++];
 398
 399     bs = bdrv_new("");
 400     if (!bs)
 401         error("Not enough memory");
 402     if (fmt) {
 403         drv = bdrv_find_format(fmt);
 404         if (!drv)
 405             error("Unknown file format '%s'", fmt);
 406     } else {
 407         drv = NULL;
 408     }
 409     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
 410         error("Could not open '%s'", filename);
 411     }
 412     ret = bdrv_check(bs);
 413     switch(ret) {
 414     case 0:
 415         printf("No errors were found on the image.\n");
 416         break;
 417     case -ENOTSUP:
 418         error("This image format does not support checks");
 419         break;
 420     default:
 421         if (ret < 0) {
 422             error("An error occurred during the check");
 423         } else {
 424             printf("%d errors were found on the image.\n", ret);
 425         }
 426         break;
 427     }
 428
 429     bdrv_delete(bs);
 430     return 0;
 431 }
 432
 433 static int img_commit(int argc, char **argv)
 434 {
 435     int c, ret;
 436     const char *filename, *fmt;
 437     BlockDriver *drv;
 438     BlockDriverState *bs;
 439
 440     fmt = NULL;
 441     for(;;) {
 442         c = getopt(argc, argv, "f:h");
 443         if (c == -1)
 444             break;
 445         switch(c) {
 446         case 'h':
 447             help();
 448             break;
 449         case 'f':
 450             fmt = optarg;
 451             break;
 452         }
 453     }
 454     if (optind >= argc)
 455         help();
 456     filename = argv[optind++];
 457
 458     bs = bdrv_new("");
 459     if (!bs)
 460         error("Not enough memory");
 461     if (fmt) {
 462         drv = bdrv_find_format(fmt);
 463         if (!drv)
 464             error("Unknown file format '%s'", fmt);
 465     } else {
 466         drv = NULL;
 467     }
 468     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
 469         error("Could not open '%s'", filename);
 470     }
 471     ret = bdrv_commit(bs);
 472     switch(ret) {
 473     case 0:
 474         printf("Image committed.\n");
 475         break;
 476     case -ENOENT:
 477         error("No disk inserted");
 478         break;
 479     case -EACCES:
 480         error("Image is read-only");
 481         break;
 482     case -ENOTSUP:
 483         error("Image is already committed");
 484         break;
 485     default:
 486         error("Error while committing image");
 487         break;
 488     }
 489
 490     bdrv_delete(bs);
 491     return 0;
 492 }
 493
 494 static int is_not_zero(const uint8_t *sector, int len)
 495 {
 496     int i;
 497     len >>= 2;
 498     for(i = 0;i < len; i++) {
 499         if (((uint32_t *)sector)[i] != 0)
 500             return 1;
 501     }
 502     return 0;
 503 }
 504
 505 /*
 506  * Returns true iff the first sector pointed to by 'buf' contains at least
 507  * a non-NUL byte.
 508  *
 509  * 'pnum' is set to the number of sectors (including and immediately following
 510  * the first one) that are known to be in the same allocated/unallocated state.
 511  */
 512 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 513 {
 514     int v, i;
 515
 516     if (n <= 0) {
 517         *pnum = 0;
 518         return 0;
 519     }
 520     v = is_not_zero(buf, 512);
 521     for(i = 1; i < n; i++) {
 522         buf += 512;
 523         if (v != is_not_zero(buf, 512))
 524             break;
 525     }
 526     *pnum = i;
 527     return v;
 528 }
 529
 530 #define IO_BUF_SIZE (2 * 1024 * 1024)
 531
 532 static int img_convert(int argc, char **argv)
 533 {
 534     int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
 535     const char *fmt, *out_fmt, *out_baseimg, *out_filename;
 536     BlockDriver *drv;
 537     BlockDriverState **bs, *out_bs;
 538     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 539     uint64_t bs_sectors;
 540     uint8_t * buf;
 541     const uint8_t *buf1;
 542     BlockDriverInfo bdi;
 543     QEMUOptionParameter *param = NULL;
 544     char *options = NULL;
 545
 546     fmt = NULL;
 547     out_fmt = "raw";
 548     out_baseimg = NULL;
 549     flags = 0;
 550     for(;;) {
 551         c = getopt(argc, argv, "f:O:B:hce6o:");
 552         if (c == -1)
 553             break;
 554         switch(c) {
 555         case 'h':
 556             help();
 557             break;
 558         case 'f':
 559             fmt = optarg;
 560             break;
 561         case 'O':
 562             out_fmt = optarg;
 563             break;
 564         case 'B':
 565             out_baseimg = optarg;
 566             break;
 567         case 'c':
 568             flags |= BLOCK_FLAG_COMPRESS;
 569             break;
 570         case 'e':
 571             flags |= BLOCK_FLAG_ENCRYPT;
 572             break;
 573         case '6':
 574             flags |= BLOCK_FLAG_COMPAT6;
 575             break;
 576         case 'o':
 577             options = optarg;
 578             break;
 579         }
 580     }
 581
 582     bs_n = argc - optind - 1;
 583     if (bs_n < 1) help();
 584
 585     out_filename = argv[argc - 1];
 586
 587     if (bs_n > 1 && out_baseimg)
 588         error("-B makes no sense when concatenating multiple input images");
 589
 590     bs = calloc(bs_n, sizeof(BlockDriverState *));
 591     if (!bs)
 592         error("Out of memory");
 593
 594     total_sectors = 0;
 595     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 596         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
 597         if (!bs[bs_i])
 598             error("Could not open '%s'", argv[optind + bs_i]);
 599         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 600         total_sectors += bs_sectors;
 601     }
 602
 603     /* Find driver and parse its options */
 604     drv = bdrv_find_format(out_fmt);
 605     if (!drv)
 606         error("Unknown file format '%s'", out_fmt);
 607
 608     if (options && !strcmp(options, "?")) {
 609         print_option_help(drv->create_options);
 610         free(bs);
 611         return 0;
 612     }
 613
 614     if (options) {
 615         param = parse_option_parameters(options, drv->create_options, param);
 616         if (param == NULL) {
 617             error("Invalid options for file format '%s'.", out_fmt);
 618         }
 619     } else {
 620         param = parse_option_parameters("", drv->create_options, param);
 621     }
 622
 623     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 624     add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
 625
 626     /* Check if compression is supported */
 627     if (flags & BLOCK_FLAG_COMPRESS) {
 628         QEMUOptionParameter *encryption =
 629             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 630
 631         if (!drv->bdrv_write_compressed) {
 632             error("Compression not supported for this file format");
 633         }
 634
 635         if (encryption && encryption->value.n) {
 636             error("Compression and encryption not supported at the same time");
 637         }
 638     }
 639
 640     /* Create the new image */
 641     ret = bdrv_create(drv, out_filename, param);
 642     free_option_parameters(param);
 643
 644     if (ret < 0) {
 645         if (ret == -ENOTSUP) {
 646             error("Formatting not supported for file format '%s'", out_fmt);
 647         } else if (ret == -EFBIG) {
 648             error("The image size is too large for file format '%s'", out_fmt);
 649         } else {
 650             error("Error while formatting '%s'", out_filename);
 651         }
 652     }
 653
 654     out_bs = bdrv_new_open(out_filename, out_fmt);
 655
 656     bs_i = 0;
 657     bs_offset = 0;
 658     bdrv_get_geometry(bs[0], &bs_sectors);
 659     buf = qemu_malloc(IO_BUF_SIZE);
 660
 661     if (flags & BLOCK_FLAG_COMPRESS) {
 662         if (bdrv_get_info(out_bs, &bdi) < 0)
 663             error("could not get block driver info");
 664         cluster_size = bdi.cluster_size;
 665         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
 666             error("invalid cluster size");
 667         cluster_sectors = cluster_size >> 9;
 668         sector_num = 0;
 669         for(;;) {
 670             int64_t bs_num;
 671             int remainder;
 672             uint8_t *buf2;
 673
 674             nb_sectors = total_sectors - sector_num;
 675             if (nb_sectors <= 0)
 676                 break;
 677             if (nb_sectors >= cluster_sectors)
 678                 n = cluster_sectors;
 679             else
 680                 n = nb_sectors;
 681
 682             bs_num = sector_num - bs_offset;
 683             assert (bs_num >= 0);
 684             remainder = n;
 685             buf2 = buf;
 686             while (remainder > 0) {
 687                 int nlow;
 688                 while (bs_num == bs_sectors) {
 689                     bs_i++;
 690                     assert (bs_i < bs_n);
 691                     bs_offset += bs_sectors;
 692                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 693                     bs_num = 0;
 694                     /* printf("changing part: sector_num=%lld, "
 695                        "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
 696                        sector_num, bs_i, bs_offset, bs_sectors); */
 697                 }
 698                 assert (bs_num < bs_sectors);
 699
 700                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 701
 702                 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
 703                     error("error while reading");
 704
 705                 buf2 += nlow * 512;
 706                 bs_num += nlow;
 707
 708                 remainder -= nlow;
 709             }
 710             assert (remainder == 0);
 711
 712             if (n < cluster_sectors)
 713                 memset(buf + n * 512, 0, cluster_size - n * 512);
 714             if (is_not_zero(buf, cluster_size)) {
 715                 if (bdrv_write_compressed(out_bs, sector_num, buf,
 716                                           cluster_sectors) != 0)
 717                     error("error while compressing sector %" PRId64,
 718                           sector_num);
 719             }
 720             sector_num += n;
 721         }
 722         /* signal EOF to align */
 723         bdrv_write_compressed(out_bs, 0, NULL, 0);
 724     } else {
 725         sector_num = 0; // total number of sectors converted so far
 726         for(;;) {
 727             nb_sectors = total_sectors - sector_num;
 728             if (nb_sectors <= 0)
 729                 break;
 730             if (nb_sectors >= (IO_BUF_SIZE / 512))
 731                 n = (IO_BUF_SIZE / 512);
 732             else
 733                 n = nb_sectors;
 734
 735             while (sector_num - bs_offset >= bs_sectors) {
 736                 bs_i ++;
 737                 assert (bs_i < bs_n);
 738                 bs_offset += bs_sectors;
 739                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
 740                 /* printf("changing part: sector_num=%lld, bs_i=%d, "
 741                   "bs_offset=%lld, bs_sectors=%lld\n",
 742                    sector_num, bs_i, bs_offset, bs_sectors); */
 743             }
 744
 745             if (n > bs_offset + bs_sectors - sector_num)
 746                 n = bs_offset + bs_sectors - sector_num;
 747
 748             if (!drv->no_zero_init) {
 749                 /* If the output image is being created as a copy on write image,
 750                    assume that sectors which are unallocated in the input image
 751                    are present in both the output's and input's base images (no
 752                    need to copy them). */
 753                 if (out_baseimg) {
 754                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
 755                                            n, &n1)) {
 756                         sector_num += n1;
 757                         continue;
 758                     }
 759                     /* The next 'n1' sectors are allocated in the input image. Copy
 760                        only those as they may be followed by unallocated sectors. */
 761                     n = n1;
 762                 }
 763             } else {
 764                 n1 = n;
 765             }
 766
 767             if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
 768                 error("error while reading");
 769             /* NOTE: at the same time we convert, we do not write zero
 770                sectors to have a chance to compress the image. Ideally, we
 771                should add a specific call to have the info to go faster */
 772             buf1 = buf;
 773             while (n > 0) {
 774                 /* If the output image is being created as a copy on write image,
 775                    copy all sectors even the ones containing only NUL bytes,
 776                    because they may differ from the sectors in the base image.
 777
 778                    If the output is to a host device, we also write out
 779                    sectors that are entirely 0, since whatever data was
 780                    already there is garbage, not 0s. */
 781                 if (drv->no_zero_init || out_baseimg ||
 782                     is_allocated_sectors(buf1, n, &n1)) {
 783                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
 784                         error("error while writing");
 785                 }
 786                 sector_num += n1;
 787                 n -= n1;
 788                 buf1 += n1 * 512;
 789             }
 790         }
 791     }
 792     qemu_free(buf);
 793     bdrv_delete(out_bs);
 794     for (bs_i = 0; bs_i < bs_n; bs_i++)
 795         bdrv_delete(bs[bs_i]);
 796     free(bs);
 797     return 0;
 798 }
 799
 800 #ifdef _WIN32
 801 static int64_t get_allocated_file_size(const char *filename)
 802 {
 803     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
 804     get_compressed_t get_compressed;
 805     struct _stati64 st;
 806
 807     /* WinNT support GetCompressedFileSize to determine allocate size */
 808     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
 809     if (get_compressed) {
 810         DWORD high, low;
 811         low = get_compressed(filename, &high);
 812         if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
 813             return (((int64_t) high) << 32) + low;
 814     }
 815
 816     if (_stati64(filename, &st) < 0)
 817         return -1;
 818     return st.st_size;
 819 }
 820 #else
 821 static int64_t get_allocated_file_size(const char *filename)
 822 {
 823     struct stat st;
 824     if (stat(filename, &st) < 0)
 825         return -1;
 826     return (int64_t)st.st_blocks * 512;
 827 }
 828 #endif
 829
 830 static void dump_snapshots(BlockDriverState *bs)
 831 {
 832     QEMUSnapshotInfo *sn_tab, *sn;
 833     int nb_sns, i;
 834     char buf[256];
 835
 836     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
 837     if (nb_sns <= 0)
 838         return;
 839     printf("Snapshot list:\n");
 840     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
 841     for(i = 0; i < nb_sns; i++) {
 842         sn = &sn_tab[i];
 843         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
 844     }
 845     qemu_free(sn_tab);
 846 }
 847
 848 static int img_info(int argc, char **argv)
 849 {
 850     int c;
 851     const char *filename, *fmt;
 852     BlockDriver *drv;
 853     BlockDriverState *bs;
 854     char fmt_name[128], size_buf[128], dsize_buf[128];
 855     uint64_t total_sectors;
 856     int64_t allocated_size;
 857     char backing_filename[1024];
 858     char backing_filename2[1024];
 859     BlockDriverInfo bdi;
 860
 861     fmt = NULL;
 862     for(;;) {
 863         c = getopt(argc, argv, "f:h");
 864         if (c == -1)
 865             break;
 866         switch(c) {
 867         case 'h':
 868             help();
 869             break;
 870         case 'f':
 871             fmt = optarg;
 872             break;
 873         }
 874     }
 875     if (optind >= argc)
 876         help();
 877     filename = argv[optind++];
 878
 879     bs = bdrv_new("");
 880     if (!bs)
 881         error("Not enough memory");
 882     if (fmt) {
 883         drv = bdrv_find_format(fmt);
 884         if (!drv)
 885             error("Unknown file format '%s'", fmt);
 886     } else {
 887         drv = NULL;
 888     }
 889     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
 890         error("Could not open '%s'", filename);
 891     }
 892     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
 893     bdrv_get_geometry(bs, &total_sectors);
 894     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
 895     allocated_size = get_allocated_file_size(filename);
 896     if (allocated_size < 0)
 897         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
 898     else
 899         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
 900                                 allocated_size);
 901     printf("image: %s\n"
 902            "file format: %s\n"
 903            "virtual size: %s (%" PRId64 " bytes)\n"
 904            "disk size: %s\n",
 905            filename, fmt_name, size_buf,
 906            (total_sectors * 512),
 907            dsize_buf);
 908     if (bdrv_is_encrypted(bs))
 909         printf("encrypted: yes\n");
 910     if (bdrv_get_info(bs, &bdi) >= 0) {
 911         if (bdi.cluster_size != 0)
 912             printf("cluster_size: %d\n", bdi.cluster_size);
 913     }
 914     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
 915     if (backing_filename[0] != '\0') {
 916         path_combine(backing_filename2, sizeof(backing_filename2),
 917                      filename, backing_filename);
 918         printf("backing file: %s (actual path: %s)\n",
 919                backing_filename,
 920                backing_filename2);
 921     }
 922     dump_snapshots(bs);
 923     bdrv_delete(bs);
 924     return 0;
 925 }
 926
 927 #define SNAPSHOT_LIST   1
 928 #define SNAPSHOT_CREATE 2
 929 #define SNAPSHOT_APPLY  3
 930 #define SNAPSHOT_DELETE 4
 931
 932 static int img_snapshot(int argc, char **argv)
 933 {
 934     BlockDriverState *bs;
 935     QEMUSnapshotInfo sn;
 936     char *filename, *snapshot_name = NULL;
 937     int c, ret;
 938     int action = 0;
 939     qemu_timeval tv;
 940
 941     /* Parse commandline parameters */
 942     for(;;) {
 943         c = getopt(argc, argv, "la:c:d:h");
 944         if (c == -1)
 945             break;
 946         switch(c) {
 947         case 'h':
 948             help();
 949             return 0;
 950         case 'l':
 951             if (action) {
 952                 help();
 953                 return 0;
 954             }
 955             action = SNAPSHOT_LIST;
 956             break;
 957         case 'a':
 958             if (action) {
 959                 help();
 960                 return 0;
 961             }
 962             action = SNAPSHOT_APPLY;
 963             snapshot_name = optarg;
 964             break;
 965         case 'c':
 966             if (action) {
 967                 help();
 968                 return 0;
 969             }
 970             action = SNAPSHOT_CREATE;
 971             snapshot_name = optarg;
 972             break;
 973         case 'd':
 974             if (action) {
 975                 help();
 976                 return 0;
 977             }
 978             action = SNAPSHOT_DELETE;
 979             snapshot_name = optarg;
 980             break;
 981         }
 982     }
 983
 984     if (optind >= argc)
 985         help();
 986     filename = argv[optind++];
 987
 988     /* Open the image */
 989     bs = bdrv_new("");
 990     if (!bs)
 991         error("Not enough memory");
 992
 993     if (bdrv_open2(bs, filename, 0, NULL) < 0) {
 994         error("Could not open '%s'", filename);
 995     }
 996
 997     /* Perform the requested action */
 998     switch(action) {
 999     case SNAPSHOT_LIST:
1000         dump_snapshots(bs);
1001         break;
1002
1003     case SNAPSHOT_CREATE:
1004         memset(&sn, 0, sizeof(sn));
1005         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1006
1007         qemu_gettimeofday(&tv);
1008         sn.date_sec = tv.tv_sec;
1009         sn.date_nsec = tv.tv_usec * 1000;
1010
1011         ret = bdrv_snapshot_create(bs, &sn);
1012         if (ret)
1013             error("Could not create snapshot '%s': %d (%s)",
1014                 snapshot_name, ret, strerror(-ret));
1015         break;
1016
1017     case SNAPSHOT_APPLY:
1018         ret = bdrv_snapshot_goto(bs, snapshot_name);
1019         if (ret)
1020             error("Could not apply snapshot '%s': %d (%s)",
1021                 snapshot_name, ret, strerror(-ret));
1022         break;
1023
1024     case SNAPSHOT_DELETE:
1025         ret = bdrv_snapshot_delete(bs, snapshot_name);
1026         if (ret)
1027             error("Could not delete snapshot '%s': %d (%s)",
1028                 snapshot_name, ret, strerror(-ret));
1029         break;
1030     }
1031
1032     /* Cleanup */
1033     bdrv_delete(bs);
1034
1035     return 0;
1036 }
1037
1038 static const img_cmd_t img_cmds[] = {
1039 #define DEF(option, callback, arg_string)        \
1040     { option, callback },
1041 #include "qemu-img-cmds.h"
1042 #undef DEF
1043 #undef GEN_DOCS
1044     { NULL, NULL, },
1045 };
1046
1047 int main(int argc, char **argv)
1048 {
1049     const img_cmd_t *cmd;
1050     const char *cmdname;
1051
1052     bdrv_init();
1053     if (argc < 2)
1054         help();
1055     cmdname = argv[1];
1056     argc--; argv++;
1057
1058     /* find the command */
1059     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1060         if (!strcmp(cmdname, cmd->name)) {
1061             return cmd->handler(argc, argv);
1062         }
1063     }
1064
1065     /* not found */
1066     help();
1067     return 0;
1068 }