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