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     const char *help_msg =
  62            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  63            "usage: qemu-img command [command options]\n"
  64            "QEMU disk image utility\n"
  65            "\n"
  66            "Command syntax:\n"
  67 #define DEF(option, callback, arg_string)        \
  68            "  " arg_string "\n"
  69 #include "qemu-img-cmds.h"
  70 #undef DEF
  71 #undef GEN_DOCS
  72            "\n"
  73            "Command parameters:\n"
  74            "  'filename' is a disk image filename\n"
  75            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  76            "  'size' is the disk image size in bytes. Optional suffixes\n"
  77            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
  78            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
  79            "  'output_filename' is the destination disk image filename\n"
  80            "  'output_fmt' is the destination format\n"
  81            "  'options' is a comma separated list of format specific options in a\n"
  82            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  83            "    used format\n"
  84            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  85            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
  86            "       match exactly. The image doesn't need a working backing file before\n"
  87            "       rebasing in this case (useful for renaming the backing file)\n"
  88            "  '-h' with or without a command shows this help and lists the supported formats\n"
  89            "\n"
  90            "Parameters to snapshot subcommand:\n"
  91            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
  92            "  '-a' applies a snapshot (revert disk to saved state)\n"
  93            "  '-c' creates a snapshot\n"
  94            "  '-d' deletes a snapshot\n"
  95            "  '-l' lists all snapshots in the given image\n";
  96
  97     printf("%s\nSupported formats:", help_msg);
  98     bdrv_iterate_format(format_print, NULL);
  99     printf("\n");
 100     exit(1);
 101 }
 102
 103 #if defined(WIN32)
 104 /* XXX: put correct support for win32 */
 105 static int read_password(char *buf, int buf_size)
 106 {
 107     int c, i;
 108     printf("Password: ");
 109     fflush(stdout);
 110     i = 0;
 111     for(;;) {
 112         c = getchar();
 113         if (c == '\n')
 114             break;
 115         if (i < (buf_size - 1))
 116             buf[i++] = c;
 117     }
 118     buf[i] = '\0';
 119     return 0;
 120 }
 121
 122 #else
 123
 124 #include <termios.h>
 125
 126 static struct termios oldtty;
 127
 128 static void term_exit(void)
 129 {
 130     tcsetattr (0, TCSANOW, &oldtty);
 131 }
 132
 133 static void term_init(void)
 134 {
 135     struct termios tty;
 136
 137     tcgetattr (0, &tty);
 138     oldtty = tty;
 139
 140     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 141                           |INLCR|IGNCR|ICRNL|IXON);
 142     tty.c_oflag |= OPOST;
 143     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 144     tty.c_cflag &= ~(CSIZE|PARENB);
 145     tty.c_cflag |= CS8;
 146     tty.c_cc[VMIN] = 1;
 147     tty.c_cc[VTIME] = 0;
 148
 149     tcsetattr (0, TCSANOW, &tty);
 150
 151     atexit(term_exit);
 152 }
 153
 154 static int read_password(char *buf, int buf_size)
 155 {
 156     uint8_t ch;
 157     int i, ret;
 158
 159     printf("password: ");
 160     fflush(stdout);
 161     term_init();
 162     i = 0;
 163     for(;;) {
 164         ret = read(0, &ch, 1);
 165         if (ret == -1) {
 166             if (errno == EAGAIN || errno == EINTR) {
 167                 continue;
 168             } else {
 169                 ret = -1;
 170                 break;
 171             }
 172         } else if (ret == 0) {
 173             ret = -1;
 174             break;
 175         } else {
 176             if (ch == '\r') {
 177                 ret = 0;
 178                 break;
 179             }
 180             if (i < (buf_size - 1))
 181                 buf[i++] = ch;
 182         }
 183     }
 184     term_exit();
 185     buf[i] = '\0';
 186     printf("\n");
 187     return ret;
 188 }
 189 #endif
 190
 191 static BlockDriverState *bdrv_new_open(const char *filename,
 192                                        const char *fmt,
 193                                        int readonly)
 194 {
 195     BlockDriverState *bs;
 196     BlockDriver *drv;
 197     char password[256];
 198     int flags = BRDV_O_FLAGS;
 199
 200     bs = bdrv_new("");
 201     if (!bs)
 202         error("Not enough memory");
 203     if (fmt) {
 204         drv = bdrv_find_format(fmt);
 205         if (!drv)
 206             error("Unknown file format '%s'", fmt);
 207     } else {
 208         drv = NULL;
 209     }
 210     if (!readonly) {
 211         flags |= BDRV_O_RDWR;
 212     }
 213     if (bdrv_open2(bs, filename, flags, drv) < 0) {
 214         error("Could not open '%s'", filename);
 215     }
 216     if (bdrv_is_encrypted(bs)) {
 217         printf("Disk image '%s' is encrypted.\n", filename);
 218         if (read_password(password, sizeof(password)) < 0)
 219             error("No password given");
 220         if (bdrv_set_key(bs, password) < 0)
 221             error("invalid password");
 222     }
 223     return bs;
 224 }
 225
 226 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 227     int flags, const char *base_filename, const char *base_fmt)
 228 {
 229     if (flags & BLOCK_FLAG_ENCRYPT) {
 230         if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
 231             error("Encryption not supported for file format '%s'", fmt);
 232         }
 233     }
 234     if (flags & BLOCK_FLAG_COMPAT6) {
 235         if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
 236             error("VMDK version 6 not supported for file format '%s'", fmt);
 237         }
 238     }
 239
 240     if (base_filename) {
 241         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 242             error("Backing file not supported for file format '%s'", fmt);
 243         }
 244     }
 245     if (base_fmt) {
 246         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 247             error("Backing file format not supported for file format '%s'", fmt);
 248         }
 249     }
 250 }
 251
 252 static int img_create(int argc, char **argv)
 253 {
 254     int c, ret, flags;
 255     const char *fmt = "raw";
 256     const char *base_fmt = NULL;
 257     const char *filename;
 258     const char *base_filename = NULL;
 259     BlockDriver *drv;
 260     QEMUOptionParameter *param = NULL;
 261     char *options = NULL;
 262
 263     flags = 0;
 264     for(;;) {
 265         c = getopt(argc, argv, "F:b:f:he6o:");
 266         if (c == -1)
 267             break;
 268         switch(c) {
 269         case 'h':
 270             help();
 271             break;
 272         case 'F':
 273             base_fmt = optarg;
 274             break;
 275         case 'b':
 276             base_filename = optarg;
 277             break;
 278         case 'f':
 279             fmt = optarg;
 280             break;
 281         case 'e':
 282             flags |= BLOCK_FLAG_ENCRYPT;
 283             break;
 284         case '6':
 285             flags |= BLOCK_FLAG_COMPAT6;
 286             break;
 287         case 'o':
 288             options = optarg;
 289             break;
 290         }
 291     }
 292
 293     /* Find driver and parse its options */
 294     drv = bdrv_find_format(fmt);
 295     if (!drv)
 296         error("Unknown file format '%s'", fmt);
 297
 298     if (options && !strcmp(options, "?")) {
 299         print_option_help(drv->create_options);
 300         return 0;
 301     }
 302
 303     /* Create parameter list with default values */
 304     param = parse_option_parameters("", drv->create_options, param);
 305     set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
 306
 307     /* Parse -o options */
 308     if (options) {
 309         param = parse_option_parameters(options, drv->create_options, param);
 310         if (param == NULL) {
 311             error("Invalid options for file format '%s'.", fmt);
 312         }
 313     }
 314
 315     /* Get the filename */
 316     if (optind >= argc)
 317         help();
 318     filename = argv[optind++];
 319
 320     /* Add size to parameters */
 321     if (optind < argc) {
 322         set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
 323     }
 324
 325     /* Add old-style options to parameters */
 326     add_old_style_options(fmt, param, flags, base_filename, base_fmt);
 327
 328     // The size for the image must always be specified, with one exception:
 329     // If we are using a backing file, we can obtain the size from there
 330     if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
 331
 332         QEMUOptionParameter *backing_file =
 333             get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 334         QEMUOptionParameter *backing_fmt =
 335             get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
 336
 337         if (backing_file && backing_file->value.s) {
 338             BlockDriverState *bs;
 339             uint64_t size;
 340             const char *fmt = NULL;
 341             char buf[32];
 342
 343             if (backing_fmt && backing_fmt->value.s) {
 344                  if (bdrv_find_format(backing_fmt->value.s)) {
 345                      fmt = backing_fmt->value.s;
 346                 } else {
 347                      error("Unknown backing file format '%s'",
 348                         backing_fmt->value.s);
 349                 }
 350             }
 351
 352             bs = bdrv_new_open(backing_file->value.s, fmt, 1);
 353             bdrv_get_geometry(bs, &size);
 354             size *= 512;
 355             bdrv_delete(bs);
 356
 357             snprintf(buf, sizeof(buf), "%" PRId64, size);
 358             set_option_parameter(param, BLOCK_OPT_SIZE, buf);
 359         } else {
 360             error("Image creation needs a size parameter");
 361         }
 362     }
 363
 364     printf("Formatting '%s', fmt=%s ", filename, fmt);
 365     print_option_parameters(param);
 366     puts("");
 367
 368     ret = bdrv_create(drv, filename, param);
 369     free_option_parameters(param);
 370
 371     if (ret < 0) {
 372         if (ret == -ENOTSUP) {
 373             error("Formatting or formatting option not supported for file format '%s'", fmt);
 374         } else if (ret == -EFBIG) {
 375             error("The image size is too large for file format '%s'", fmt);
 376         } else {
 377             error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
 378         }
 379     }
 380     return 0;
 381 }
 382
 383 static int img_check(int argc, char **argv)
 384 {
 385     int c, ret;
 386     const char *filename, *fmt;
 387     BlockDriver *drv;
 388     BlockDriverState *bs;
 389
 390     fmt = NULL;
 391     for(;;) {
 392         c = getopt(argc, argv, "f:h");
 393         if (c == -1)
 394             break;
 395         switch(c) {
 396         case 'h':
 397             help();
 398             break;
 399         case 'f':
 400             fmt = optarg;
 401             break;
 402         }
 403     }
 404     if (optind >= argc)
 405         help();
 406     filename = argv[optind++];
 407
 408     bs = bdrv_new("");
 409     if (!bs)
 410         error("Not enough memory");
 411     if (fmt) {
 412         drv = bdrv_find_format(fmt);
 413         if (!drv)
 414             error("Unknown file format '%s'", fmt);
 415     } else {
 416         drv = NULL;
 417     }
 418     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
 419         error("Could not open '%s'", filename);
 420     }
 421     ret = bdrv_check(bs);
 422     switch(ret) {
 423     case 0:
 424         printf("No errors were found on the image.\n");
 425         break;
 426     case -ENOTSUP:
 427         error("This image format does not support checks");
 428         break;
 429     default:
 430         if (ret < 0) {
 431             error("An error occurred during the check");
 432         } else {
 433             printf("%d errors were found on the image.\n", ret);
 434         }
 435         break;
 436     }
 437
 438     bdrv_delete(bs);
 439     return 0;
 440 }
 441
 442 static int img_commit(int argc, char **argv)
 443 {
 444     int c, ret;
 445     const char *filename, *fmt;
 446     BlockDriver *drv;
 447     BlockDriverState *bs;
 448
 449     fmt = NULL;
 450     for(;;) {
 451         c = getopt(argc, argv, "f:h");
 452         if (c == -1)
 453             break;
 454         switch(c) {
 455         case 'h':
 456             help();
 457             break;
 458         case 'f':
 459             fmt = optarg;
 460             break;
 461         }
 462     }
 463     if (optind >= argc)
 464         help();
 465     filename = argv[optind++];
 466
 467     bs = bdrv_new("");
 468     if (!bs)
 469         error("Not enough memory");
 470     if (fmt) {
 471         drv = bdrv_find_format(fmt);
 472         if (!drv)
 473             error("Unknown file format '%s'", fmt);
 474     } else {
 475         drv = NULL;
 476     }
 477     if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_RDWR, drv) < 0) {
 478         error("Could not open '%s'", filename);
 479     }
 480     ret = bdrv_commit(bs);
 481     switch(ret) {
 482     case 0:
 483         printf("Image committed.\n");
 484         break;
 485     case -ENOENT:
 486         error("No disk inserted");
 487         break;
 488     case -EACCES:
 489         error("Image is read-only");
 490         break;
 491     case -ENOTSUP:
 492         error("Image is already committed");
 493         break;
 494     default:
 495         error("Error while committing image");
 496         break;
 497     }
 498
 499     bdrv_delete(bs);
 500     return 0;
 501 }
 502
 503 static int is_not_zero(const uint8_t *sector, int len)
 504 {
 505     int i;
 506     len >>= 2;
 507     for(i = 0;i < len; i++) {
 508         if (((uint32_t *)sector)[i] != 0)
 509             return 1;
 510     }
 511     return 0;
 512 }
 513
 514 /*
 515  * Returns true iff the first sector pointed to by 'buf' contains at least
 516  * a non-NUL byte.
 517  *
 518  * 'pnum' is set to the number of sectors (including and immediately following
 519  * the first one) that are known to be in the same allocated/unallocated state.
 520  */
 521 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 522 {
 523     int v, i;
 524
 525     if (n <= 0) {
 526         *pnum = 0;
 527         return 0;
 528     }
 529     v = is_not_zero(buf, 512);
 530     for(i = 1; i < n; i++) {
 531         buf += 512;
 532         if (v != is_not_zero(buf, 512))
 533             break;
 534     }
 535     *pnum = i;
 536     return v;
 537 }
 538
 539 /*
 540  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 541  * buffers matches, non-zero otherwise.
 542  *
 543  * pnum is set to the number of sectors (including and immediately following
 544  * the first one) that are known to have the same comparison result
 545  */
 546 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 547     int *pnum)
 548 {
 549     int res, i;
 550
 551     if (n <= 0) {
 552         *pnum = 0;
 553         return 0;
 554     }
 555
 556     res = !!memcmp(buf1, buf2, 512);
 557     for(i = 1; i < n; i++) {
 558         buf1 += 512;
 559         buf2 += 512;
 560
 561         if (!!memcmp(buf1, buf2, 512) != res) {
 562             break;
 563         }
 564     }
 565
 566     *pnum = i;
 567     return res;
 568 }
 569
 570 #define IO_BUF_SIZE (2 * 1024 * 1024)
 571
 572 static int img_convert(int argc, char **argv)
 573 {
 574     int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
 575     const char *fmt, *out_fmt, *out_baseimg, *out_filename;
 576     BlockDriver *drv;
 577     BlockDriverState **bs, *out_bs;
 578     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 579     uint64_t bs_sectors;
 580     uint8_t * buf;
 581     const uint8_t *buf1;
 582     BlockDriverInfo bdi;
 583     QEMUOptionParameter *param = NULL;
 584     char *options = NULL;
 585
 586     fmt = NULL;
 587     out_fmt = "raw";
 588     out_baseimg = NULL;
 589     flags = 0;
 590     for(;;) {
 591         c = getopt(argc, argv, "f:O:B:hce6o:");
 592         if (c == -1)
 593             break;
 594         switch(c) {
 595         case 'h':
 596             help();
 597             break;
 598         case 'f':
 599             fmt = optarg;
 600             break;
 601         case 'O':
 602             out_fmt = optarg;
 603             break;
 604         case 'B':
 605             out_baseimg = optarg;
 606             break;
 607         case 'c':
 608             flags |= BLOCK_FLAG_COMPRESS;
 609             break;
 610         case 'e':
 611             flags |= BLOCK_FLAG_ENCRYPT;
 612             break;
 613         case '6':
 614             flags |= BLOCK_FLAG_COMPAT6;
 615             break;
 616         case 'o':
 617             options = optarg;
 618             break;
 619         }
 620     }
 621
 622     bs_n = argc - optind - 1;
 623     if (bs_n < 1) help();
 624
 625     out_filename = argv[argc - 1];
 626
 627     if (bs_n > 1 && out_baseimg)
 628         error("-B makes no sense when concatenating multiple input images");
 629
 630     bs = calloc(bs_n, sizeof(BlockDriverState *));
 631     if (!bs)
 632         error("Out of memory");
 633
 634     total_sectors = 0;
 635     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 636         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, 1);
 637         if (!bs[bs_i])
 638             error("Could not open '%s'", argv[optind + bs_i]);
 639         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 640         total_sectors += bs_sectors;
 641     }
 642
 643     /* Find driver and parse its options */
 644     drv = bdrv_find_format(out_fmt);
 645     if (!drv)
 646         error("Unknown file format '%s'", out_fmt);
 647
 648     if (options && !strcmp(options, "?")) {
 649         print_option_help(drv->create_options);
 650         free(bs);
 651         return 0;
 652     }
 653
 654     if (options) {
 655         param = parse_option_parameters(options, drv->create_options, param);
 656         if (param == NULL) {
 657             error("Invalid options for file format '%s'.", out_fmt);
 658         }
 659     } else {
 660         param = parse_option_parameters("", drv->create_options, param);
 661     }
 662
 663     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 664     add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
 665
 666     /* Check if compression is supported */
 667     if (flags & BLOCK_FLAG_COMPRESS) {
 668         QEMUOptionParameter *encryption =
 669             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 670
 671         if (!drv->bdrv_write_compressed) {
 672             error("Compression not supported for this file format");
 673         }
 674
 675         if (encryption && encryption->value.n) {
 676             error("Compression and encryption not supported at the same time");
 677         }
 678     }
 679
 680     /* Create the new image */
 681     ret = bdrv_create(drv, out_filename, param);
 682     free_option_parameters(param);
 683
 684     if (ret < 0) {
 685         if (ret == -ENOTSUP) {
 686             error("Formatting not supported for file format '%s'", out_fmt);
 687         } else if (ret == -EFBIG) {
 688             error("The image size is too large for file format '%s'", out_fmt);
 689         } else {
 690             error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
 691         }
 692     }
 693
 694     out_bs = bdrv_new_open(out_filename, out_fmt, 0);
 695
 696     bs_i = 0;
 697     bs_offset = 0;
 698     bdrv_get_geometry(bs[0], &bs_sectors);
 699     buf = qemu_malloc(IO_BUF_SIZE);
 700
 701     if (flags & BLOCK_FLAG_COMPRESS) {
 702         if (bdrv_get_info(out_bs, &bdi) < 0)
 703             error("could not get block driver info");
 704         cluster_size = bdi.cluster_size;
 705         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
 706             error("invalid cluster size");
 707         cluster_sectors = cluster_size >> 9;
 708         sector_num = 0;
 709         for(;;) {
 710             int64_t bs_num;
 711             int remainder;
 712             uint8_t *buf2;
 713
 714             nb_sectors = total_sectors - sector_num;
 715             if (nb_sectors <= 0)
 716                 break;
 717             if (nb_sectors >= cluster_sectors)
 718                 n = cluster_sectors;
 719             else
 720                 n = nb_sectors;
 721
 722             bs_num = sector_num - bs_offset;
 723             assert (bs_num >= 0);
 724             remainder = n;
 725             buf2 = buf;
 726             while (remainder > 0) {
 727                 int nlow;
 728                 while (bs_num == bs_sectors) {
 729                     bs_i++;
 730                     assert (bs_i < bs_n);
 731                     bs_offset += bs_sectors;
 732                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 733                     bs_num = 0;
 734                     /* printf("changing part: sector_num=%lld, "
 735                        "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
 736                        sector_num, bs_i, bs_offset, bs_sectors); */
 737                 }
 738                 assert (bs_num < bs_sectors);
 739
 740                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 741
 742                 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
 743                     error("error while reading");
 744
 745                 buf2 += nlow * 512;
 746                 bs_num += nlow;
 747
 748                 remainder -= nlow;
 749             }
 750             assert (remainder == 0);
 751
 752             if (n < cluster_sectors)
 753                 memset(buf + n * 512, 0, cluster_size - n * 512);
 754             if (is_not_zero(buf, cluster_size)) {
 755                 if (bdrv_write_compressed(out_bs, sector_num, buf,
 756                                           cluster_sectors) != 0)
 757                     error("error while compressing sector %" PRId64,
 758                           sector_num);
 759             }
 760             sector_num += n;
 761         }
 762         /* signal EOF to align */
 763         bdrv_write_compressed(out_bs, 0, NULL, 0);
 764     } else {
 765         sector_num = 0; // total number of sectors converted so far
 766         for(;;) {
 767             nb_sectors = total_sectors - sector_num;
 768             if (nb_sectors <= 0)
 769                 break;
 770             if (nb_sectors >= (IO_BUF_SIZE / 512))
 771                 n = (IO_BUF_SIZE / 512);
 772             else
 773                 n = nb_sectors;
 774
 775             while (sector_num - bs_offset >= bs_sectors) {
 776                 bs_i ++;
 777                 assert (bs_i < bs_n);
 778                 bs_offset += bs_sectors;
 779                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
 780                 /* printf("changing part: sector_num=%lld, bs_i=%d, "
 781                   "bs_offset=%lld, bs_sectors=%lld\n",
 782                    sector_num, bs_i, bs_offset, bs_sectors); */
 783             }
 784
 785             if (n > bs_offset + bs_sectors - sector_num)
 786                 n = bs_offset + bs_sectors - sector_num;
 787
 788             if (!drv->no_zero_init) {
 789                 /* If the output image is being created as a copy on write image,
 790                    assume that sectors which are unallocated in the input image
 791                    are present in both the output's and input's base images (no
 792                    need to copy them). */
 793                 if (out_baseimg) {
 794                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
 795                                            n, &n1)) {
 796                         sector_num += n1;
 797                         continue;
 798                     }
 799                     /* The next 'n1' sectors are allocated in the input image. Copy
 800                        only those as they may be followed by unallocated sectors. */
 801                     n = n1;
 802                 }
 803             } else {
 804                 n1 = n;
 805             }
 806
 807             if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
 808                 error("error while reading");
 809             /* NOTE: at the same time we convert, we do not write zero
 810                sectors to have a chance to compress the image. Ideally, we
 811                should add a specific call to have the info to go faster */
 812             buf1 = buf;
 813             while (n > 0) {
 814                 /* If the output image is being created as a copy on write image,
 815                    copy all sectors even the ones containing only NUL bytes,
 816                    because they may differ from the sectors in the base image.
 817
 818                    If the output is to a host device, we also write out
 819                    sectors that are entirely 0, since whatever data was
 820                    already there is garbage, not 0s. */
 821                 if (drv->no_zero_init || out_baseimg ||
 822                     is_allocated_sectors(buf1, n, &n1)) {
 823                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
 824                         error("error while writing");
 825                 }
 826                 sector_num += n1;
 827                 n -= n1;
 828                 buf1 += n1 * 512;
 829             }
 830         }
 831     }
 832     qemu_free(buf);
 833     bdrv_delete(out_bs);
 834     for (bs_i = 0; bs_i < bs_n; bs_i++)
 835         bdrv_delete(bs[bs_i]);
 836     free(bs);
 837     return 0;
 838 }
 839
 840 #ifdef _WIN32
 841 static int64_t get_allocated_file_size(const char *filename)
 842 {
 843     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
 844     get_compressed_t get_compressed;
 845     struct _stati64 st;
 846
 847     /* WinNT support GetCompressedFileSize to determine allocate size */
 848     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
 849     if (get_compressed) {
 850         DWORD high, low;
 851         low = get_compressed(filename, &high);
 852         if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
 853             return (((int64_t) high) << 32) + low;
 854     }
 855
 856     if (_stati64(filename, &st) < 0)
 857         return -1;
 858     return st.st_size;
 859 }
 860 #else
 861 static int64_t get_allocated_file_size(const char *filename)
 862 {
 863     struct stat st;
 864     if (stat(filename, &st) < 0)
 865         return -1;
 866     return (int64_t)st.st_blocks * 512;
 867 }
 868 #endif
 869
 870 static void dump_snapshots(BlockDriverState *bs)
 871 {
 872     QEMUSnapshotInfo *sn_tab, *sn;
 873     int nb_sns, i;
 874     char buf[256];
 875
 876     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
 877     if (nb_sns <= 0)
 878         return;
 879     printf("Snapshot list:\n");
 880     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
 881     for(i = 0; i < nb_sns; i++) {
 882         sn = &sn_tab[i];
 883         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
 884     }
 885     qemu_free(sn_tab);
 886 }
 887
 888 static int img_info(int argc, char **argv)
 889 {
 890     int c;
 891     const char *filename, *fmt;
 892     BlockDriver *drv;
 893     BlockDriverState *bs;
 894     char fmt_name[128], size_buf[128], dsize_buf[128];
 895     uint64_t total_sectors;
 896     int64_t allocated_size;
 897     char backing_filename[1024];
 898     char backing_filename2[1024];
 899     BlockDriverInfo bdi;
 900
 901     fmt = NULL;
 902     for(;;) {
 903         c = getopt(argc, argv, "f:h");
 904         if (c == -1)
 905             break;
 906         switch(c) {
 907         case 'h':
 908             help();
 909             break;
 910         case 'f':
 911             fmt = optarg;
 912             break;
 913         }
 914     }
 915     if (optind >= argc)
 916         help();
 917     filename = argv[optind++];
 918
 919     bs = bdrv_new("");
 920     if (!bs)
 921         error("Not enough memory");
 922     if (fmt) {
 923         drv = bdrv_find_format(fmt);
 924         if (!drv)
 925             error("Unknown file format '%s'", fmt);
 926     } else {
 927         drv = NULL;
 928     }
 929     if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_NO_BACKING, drv) < 0) {
 930         error("Could not open '%s'", filename);
 931     }
 932     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
 933     bdrv_get_geometry(bs, &total_sectors);
 934     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
 935     allocated_size = get_allocated_file_size(filename);
 936     if (allocated_size < 0)
 937         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
 938     else
 939         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
 940                                 allocated_size);
 941     printf("image: %s\n"
 942            "file format: %s\n"
 943            "virtual size: %s (%" PRId64 " bytes)\n"
 944            "disk size: %s\n",
 945            filename, fmt_name, size_buf,
 946            (total_sectors * 512),
 947            dsize_buf);
 948     if (bdrv_is_encrypted(bs))
 949         printf("encrypted: yes\n");
 950     if (bdrv_get_info(bs, &bdi) >= 0) {
 951         if (bdi.cluster_size != 0)
 952             printf("cluster_size: %d\n", bdi.cluster_size);
 953     }
 954     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
 955     if (backing_filename[0] != '\0') {
 956         path_combine(backing_filename2, sizeof(backing_filename2),
 957                      filename, backing_filename);
 958         printf("backing file: %s (actual path: %s)\n",
 959                backing_filename,
 960                backing_filename2);
 961     }
 962     dump_snapshots(bs);
 963     bdrv_delete(bs);
 964     return 0;
 965 }
 966
 967 #define SNAPSHOT_LIST   1
 968 #define SNAPSHOT_CREATE 2
 969 #define SNAPSHOT_APPLY  3
 970 #define SNAPSHOT_DELETE 4
 971
 972 static int img_snapshot(int argc, char **argv)
 973 {
 974     BlockDriverState *bs;
 975     QEMUSnapshotInfo sn;
 976     char *filename, *snapshot_name = NULL;
 977     int c, ret, bdrv_oflags;
 978     int action = 0;
 979     qemu_timeval tv;
 980
 981     bdrv_oflags = BDRV_O_RDWR;
 982     /* Parse commandline parameters */
 983     for(;;) {
 984         c = getopt(argc, argv, "la:c:d:h");
 985         if (c == -1)
 986             break;
 987         switch(c) {
 988         case 'h':
 989             help();
 990             return 0;
 991         case 'l':
 992             if (action) {
 993                 help();
 994                 return 0;
 995             }
 996             action = SNAPSHOT_LIST;
 997             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
 998             break;
 999         case 'a':
1000             if (action) {
1001                 help();
1002                 return 0;
1003             }
1004             action = SNAPSHOT_APPLY;
1005             snapshot_name = optarg;
1006             break;
1007         case 'c':
1008             if (action) {
1009                 help();
1010                 return 0;
1011             }
1012             action = SNAPSHOT_CREATE;
1013             snapshot_name = optarg;
1014             break;
1015         case 'd':
1016             if (action) {
1017                 help();
1018                 return 0;
1019             }
1020             action = SNAPSHOT_DELETE;
1021             snapshot_name = optarg;
1022             break;
1023         }
1024     }
1025
1026     if (optind >= argc)
1027         help();
1028     filename = argv[optind++];
1029
1030     /* Open the image */
1031     bs = bdrv_new("");
1032     if (!bs)
1033         error("Not enough memory");
1034
1035     if (bdrv_open2(bs, filename, bdrv_oflags, NULL) < 0) {
1036         error("Could not open '%s'", filename);
1037     }
1038
1039     /* Perform the requested action */
1040     switch(action) {
1041     case SNAPSHOT_LIST:
1042         dump_snapshots(bs);
1043         break;
1044
1045     case SNAPSHOT_CREATE:
1046         memset(&sn, 0, sizeof(sn));
1047         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1048
1049         qemu_gettimeofday(&tv);
1050         sn.date_sec = tv.tv_sec;
1051         sn.date_nsec = tv.tv_usec * 1000;
1052
1053         ret = bdrv_snapshot_create(bs, &sn);
1054         if (ret)
1055             error("Could not create snapshot '%s': %d (%s)",
1056                 snapshot_name, ret, strerror(-ret));
1057         break;
1058
1059     case SNAPSHOT_APPLY:
1060         ret = bdrv_snapshot_goto(bs, snapshot_name);
1061         if (ret)
1062             error("Could not apply snapshot '%s': %d (%s)",
1063                 snapshot_name, ret, strerror(-ret));
1064         break;
1065
1066     case SNAPSHOT_DELETE:
1067         ret = bdrv_snapshot_delete(bs, snapshot_name);
1068         if (ret)
1069             error("Could not delete snapshot '%s': %d (%s)",
1070                 snapshot_name, ret, strerror(-ret));
1071         break;
1072     }
1073
1074     /* Cleanup */
1075     bdrv_delete(bs);
1076
1077     return 0;
1078 }
1079
1080 static int img_rebase(int argc, char **argv)
1081 {
1082     BlockDriverState *bs, *bs_old_backing, *bs_new_backing;
1083     BlockDriver *drv, *old_backing_drv, *new_backing_drv;
1084     char *filename;
1085     const char *fmt, *out_basefmt, *out_baseimg;
1086     int c, flags, ret;
1087     int unsafe = 0;
1088
1089     /* Parse commandline parameters */
1090     fmt = NULL;
1091     out_baseimg = NULL;
1092     out_basefmt = NULL;
1093
1094     for(;;) {
1095         c = getopt(argc, argv, "uhf:F:b:");
1096         if (c == -1)
1097             break;
1098         switch(c) {
1099         case 'h':
1100             help();
1101             return 0;
1102         case 'f':
1103             fmt = optarg;
1104             break;
1105         case 'F':
1106             out_basefmt = optarg;
1107             break;
1108         case 'b':
1109             out_baseimg = optarg;
1110             break;
1111         case 'u':
1112             unsafe = 1;
1113             break;
1114         }
1115     }
1116
1117     if ((optind >= argc) || !out_baseimg)
1118         help();
1119     filename = argv[optind++];
1120
1121     /*
1122      * Open the images.
1123      *
1124      * Ignore the old backing file for unsafe rebase in case we want to correct
1125      * the reference to a renamed or moved backing file.
1126      */
1127     bs = bdrv_new("");
1128     if (!bs)
1129         error("Not enough memory");
1130
1131     drv = NULL;
1132     if (fmt) {
1133         drv = bdrv_find_format(fmt);
1134         if (drv == NULL) {
1135             error("Invalid format name: '%s'", fmt);
1136         }
1137     }
1138
1139     flags = BRDV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1140     if (bdrv_open2(bs, filename, flags, drv) < 0) {
1141         error("Could not open '%s'", filename);
1142     }
1143
1144     /* Find the right drivers for the backing files */
1145     old_backing_drv = NULL;
1146     new_backing_drv = NULL;
1147
1148     if (!unsafe && bs->backing_format[0] != '\0') {
1149         old_backing_drv = bdrv_find_format(bs->backing_format);
1150         if (old_backing_drv == NULL) {
1151             error("Invalid format name: '%s'", bs->backing_format);
1152         }
1153     }
1154
1155     if (out_basefmt != NULL) {
1156         new_backing_drv = bdrv_find_format(out_basefmt);
1157         if (new_backing_drv == NULL) {
1158             error("Invalid format name: '%s'", out_basefmt);
1159         }
1160     }
1161
1162     /* For safe rebasing we need to compare old and new backing file */
1163     if (unsafe) {
1164         /* Make the compiler happy */
1165         bs_old_backing = NULL;
1166         bs_new_backing = NULL;
1167     } else {
1168         char backing_name[1024];
1169
1170         bs_old_backing = bdrv_new("old_backing");
1171         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1172         if (bdrv_open2(bs_old_backing, backing_name, BRDV_O_FLAGS,
1173             old_backing_drv))
1174         {
1175             error("Could not open old backing file '%s'", backing_name);
1176             return -1;
1177         }
1178
1179         bs_new_backing = bdrv_new("new_backing");
1180         if (bdrv_open2(bs_new_backing, out_baseimg, BRDV_O_FLAGS | BDRV_O_RDWR,
1181             new_backing_drv))
1182         {
1183             error("Could not open new backing file '%s'", out_baseimg);
1184             return -1;
1185         }
1186     }
1187
1188     /*
1189      * Check each unallocated cluster in the COW file. If it is unallocated,
1190      * accesses go to the backing file. We must therefore compare this cluster
1191      * in the old and new backing file, and if they differ we need to copy it
1192      * from the old backing file into the COW file.
1193      *
1194      * If qemu-img crashes during this step, no harm is done. The content of
1195      * the image is the same as the original one at any time.
1196      */
1197     if (!unsafe) {
1198         uint64_t num_sectors;
1199         uint64_t sector;
1200         int n, n1;
1201         uint8_t * buf_old;
1202         uint8_t * buf_new;
1203
1204         buf_old = qemu_malloc(IO_BUF_SIZE);
1205         buf_new = qemu_malloc(IO_BUF_SIZE);
1206
1207         bdrv_get_geometry(bs, &num_sectors);
1208
1209         for (sector = 0; sector < num_sectors; sector += n) {
1210
1211             /* How many sectors can we handle with the next read? */
1212             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1213                 n = (IO_BUF_SIZE / 512);
1214             } else {
1215                 n = num_sectors - sector;
1216             }
1217
1218             /* If the cluster is allocated, we don't need to take action */
1219             if (bdrv_is_allocated(bs, sector, n, &n1)) {
1220                 n = n1;
1221                 continue;
1222             }
1223
1224             /* Read old and new backing file */
1225             if (bdrv_read(bs_old_backing, sector, buf_old, n) < 0) {
1226                 error("error while reading from old backing file");
1227             }
1228             if (bdrv_read(bs_new_backing, sector, buf_new, n) < 0) {
1229                 error("error while reading from new backing file");
1230             }
1231
1232             /* If they differ, we need to write to the COW file */
1233             uint64_t written = 0;
1234
1235             while (written < n) {
1236                 int pnum;
1237
1238                 if (compare_sectors(buf_old + written * 512,
1239                     buf_new + written * 512, n - written, &pnum))
1240                 {
1241                     ret = bdrv_write(bs, sector + written,
1242                         buf_old + written * 512, pnum);
1243                     if (ret < 0) {
1244                         error("Error while writing to COW image: %s",
1245                             strerror(-ret));
1246                     }
1247                 }
1248
1249                 written += pnum;
1250             }
1251         }
1252
1253         qemu_free(buf_old);
1254         qemu_free(buf_new);
1255     }
1256
1257     /*
1258      * Change the backing file. All clusters that are different from the old
1259      * backing file are overwritten in the COW file now, so the visible content
1260      * doesn't change when we switch the backing file.
1261      */
1262     ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1263     if (ret == -ENOSPC) {
1264         error("Could not change the backing file to '%s': No space left in "
1265             "the file header", out_baseimg);
1266     } else if (ret < 0) {
1267         error("Could not change the backing file to '%s': %s",
1268             out_baseimg, strerror(-ret));
1269     }
1270
1271     /*
1272      * TODO At this point it is possible to check if any clusters that are
1273      * allocated in the COW file are the same in the backing file. If so, they
1274      * could be dropped from the COW file. Don't do this before switching the
1275      * backing file, in case of a crash this would lead to corruption.
1276      */
1277
1278     /* Cleanup */
1279     if (!unsafe) {
1280         bdrv_delete(bs_old_backing);
1281         bdrv_delete(bs_new_backing);
1282     }
1283
1284     bdrv_delete(bs);
1285
1286     return 0;
1287 }
1288
1289 static const img_cmd_t img_cmds[] = {
1290 #define DEF(option, callback, arg_string)        \
1291     { option, callback },
1292 #include "qemu-img-cmds.h"
1293 #undef DEF
1294 #undef GEN_DOCS
1295     { NULL, NULL, },
1296 };
1297
1298 int main(int argc, char **argv)
1299 {
1300     const img_cmd_t *cmd;
1301     const char *cmdname;
1302
1303     bdrv_init();
1304     if (argc < 2)
1305         help();
1306     cmdname = argv[1];
1307     argc--; argv++;
1308
1309     /* find the command */
1310     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1311         if (!strcmp(cmdname, cmd->name)) {
1312             return cmd->handler(argc, argv);
1313         }
1314     }
1315
1316     /* not found */
1317     help();
1318     return 0;
1319 }