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