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