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