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 /*
 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, BDRV_O_FLAGS | BDRV_O_RDWR);
 787     if (!out_bs) {
 788         ret = -1;
 789         goto out;
 790     }
 791
 792     bs_i = 0;
 793     bs_offset = 0;
 794     bdrv_get_geometry(bs[0], &bs_sectors);
 795     buf = qemu_malloc(IO_BUF_SIZE);
 796
 797     if (flags & BLOCK_FLAG_COMPRESS) {
 798         ret = bdrv_get_info(out_bs, &bdi);
 799         if (ret < 0) {
 800             error("could not get block driver info");
 801             goto out;
 802         }
 803         cluster_size = bdi.cluster_size;
 804         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
 805             error("invalid cluster size");
 806             ret = -1;
 807             goto out;
 808         }
 809         cluster_sectors = cluster_size >> 9;
 810         sector_num = 0;
 811         for(;;) {
 812             int64_t bs_num;
 813             int remainder;
 814             uint8_t *buf2;
 815
 816             nb_sectors = total_sectors - sector_num;
 817             if (nb_sectors <= 0)
 818                 break;
 819             if (nb_sectors >= cluster_sectors)
 820                 n = cluster_sectors;
 821             else
 822                 n = nb_sectors;
 823
 824             bs_num = sector_num - bs_offset;
 825             assert (bs_num >= 0);
 826             remainder = n;
 827             buf2 = buf;
 828             while (remainder > 0) {
 829                 int nlow;
 830                 while (bs_num == bs_sectors) {
 831                     bs_i++;
 832                     assert (bs_i < bs_n);
 833                     bs_offset += bs_sectors;
 834                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 835                     bs_num = 0;
 836                     /* printf("changing part: sector_num=%" PRId64 ", "
 837                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
 838                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
 839                 }
 840                 assert (bs_num < bs_sectors);
 841
 842                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 843
 844                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
 845                 if (ret < 0) {
 846                     error("error while reading");
 847                     goto out;
 848                 }
 849
 850                 buf2 += nlow * 512;
 851                 bs_num += nlow;
 852
 853                 remainder -= nlow;
 854             }
 855             assert (remainder == 0);
 856
 857             if (n < cluster_sectors)
 858                 memset(buf + n * 512, 0, cluster_size - n * 512);
 859             if (is_not_zero(buf, cluster_size)) {
 860                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
 861                                             cluster_sectors);
 862                 if (ret != 0) {
 863                     error("error while compressing sector %" PRId64,
 864                           sector_num);
 865                     goto out;
 866                 }
 867             }
 868             sector_num += n;
 869         }
 870         /* signal EOF to align */
 871         bdrv_write_compressed(out_bs, 0, NULL, 0);
 872     } else {
 873         int has_zero_init = bdrv_has_zero_init(out_bs);
 874
 875         sector_num = 0; // total number of sectors converted so far
 876         for(;;) {
 877             nb_sectors = total_sectors - sector_num;
 878             if (nb_sectors <= 0)
 879                 break;
 880             if (nb_sectors >= (IO_BUF_SIZE / 512))
 881                 n = (IO_BUF_SIZE / 512);
 882             else
 883                 n = nb_sectors;
 884
 885             while (sector_num - bs_offset >= bs_sectors) {
 886                 bs_i ++;
 887                 assert (bs_i < bs_n);
 888                 bs_offset += bs_sectors;
 889                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
 890                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
 891                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
 892                    sector_num, bs_i, bs_offset, bs_sectors); */
 893             }
 894
 895             if (n > bs_offset + bs_sectors - sector_num)
 896                 n = bs_offset + bs_sectors - sector_num;
 897
 898             if (has_zero_init) {
 899                 /* If the output image is being created as a copy on write image,
 900                    assume that sectors which are unallocated in the input image
 901                    are present in both the output's and input's base images (no
 902                    need to copy them). */
 903                 if (out_baseimg) {
 904                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
 905                                            n, &n1)) {
 906                         sector_num += n1;
 907                         continue;
 908                     }
 909                     /* The next 'n1' sectors are allocated in the input image. Copy
 910                        only those as they may be followed by unallocated sectors. */
 911                     n = n1;
 912                 }
 913             } else {
 914                 n1 = n;
 915             }
 916
 917             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
 918             if (ret < 0) {
 919                 error("error while reading");
 920                 goto out;
 921             }
 922             /* NOTE: at the same time we convert, we do not write zero
 923                sectors to have a chance to compress the image. Ideally, we
 924                should add a specific call to have the info to go faster */
 925             buf1 = buf;
 926             while (n > 0) {
 927                 /* If the output image is being created as a copy on write image,
 928                    copy all sectors even the ones containing only NUL bytes,
 929                    because they may differ from the sectors in the base image.
 930
 931                    If the output is to a host device, we also write out
 932                    sectors that are entirely 0, since whatever data was
 933                    already there is garbage, not 0s. */
 934                 if (!has_zero_init || out_baseimg ||
 935                     is_allocated_sectors(buf1, n, &n1)) {
 936                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
 937                     if (ret < 0) {
 938                         error("error while writing");
 939                         goto out;
 940                     }
 941                 }
 942                 sector_num += n1;
 943                 n -= n1;
 944                 buf1 += n1 * 512;
 945             }
 946         }
 947     }
 948 out:
 949     free_option_parameters(create_options);
 950     free_option_parameters(param);
 951     qemu_free(buf);
 952     if (out_bs) {
 953         bdrv_delete(out_bs);
 954     }
 955     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 956         if (bs[bs_i]) {
 957             bdrv_delete(bs[bs_i]);
 958         }
 959     }
 960     free(bs);
 961     if (ret) {
 962         return 1;
 963     }
 964     return 0;
 965 }
 966
 967 #ifdef _WIN32
 968 static int64_t get_allocated_file_size(const char *filename)
 969 {
 970     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
 971     get_compressed_t get_compressed;
 972     struct _stati64 st;
 973
 974     /* WinNT support GetCompressedFileSize to determine allocate size */
 975     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
 976     if (get_compressed) {
 977         DWORD high, low;
 978         low = get_compressed(filename, &high);
 979         if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
 980             return (((int64_t) high) << 32) + low;
 981     }
 982
 983     if (_stati64(filename, &st) < 0)
 984         return -1;
 985     return st.st_size;
 986 }
 987 #else
 988 static int64_t get_allocated_file_size(const char *filename)
 989 {
 990     struct stat st;
 991     if (stat(filename, &st) < 0)
 992         return -1;
 993     return (int64_t)st.st_blocks * 512;
 994 }
 995 #endif
 996
 997 static void dump_snapshots(BlockDriverState *bs)
 998 {
 999     QEMUSnapshotInfo *sn_tab, *sn;
1000     int nb_sns, i;
1001     char buf[256];
1002
1003     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1004     if (nb_sns <= 0)
1005         return;
1006     printf("Snapshot list:\n");
1007     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1008     for(i = 0; i < nb_sns; i++) {
1009         sn = &sn_tab[i];
1010         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1011     }
1012     qemu_free(sn_tab);
1013 }
1014
1015 static int img_info(int argc, char **argv)
1016 {
1017     int c;
1018     const char *filename, *fmt;
1019     BlockDriverState *bs;
1020     char fmt_name[128], size_buf[128], dsize_buf[128];
1021     uint64_t total_sectors;
1022     int64_t allocated_size;
1023     char backing_filename[1024];
1024     char backing_filename2[1024];
1025     BlockDriverInfo bdi;
1026
1027     fmt = NULL;
1028     for(;;) {
1029         c = getopt(argc, argv, "f:h");
1030         if (c == -1)
1031             break;
1032         switch(c) {
1033         case 'h':
1034             help();
1035             break;
1036         case 'f':
1037             fmt = optarg;
1038             break;
1039         }
1040     }
1041     if (optind >= argc)
1042         help();
1043     filename = argv[optind++];
1044
1045     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1046     if (!bs) {
1047         return 1;
1048     }
1049     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1050     bdrv_get_geometry(bs, &total_sectors);
1051     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1052     allocated_size = get_allocated_file_size(filename);
1053     if (allocated_size < 0)
1054         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1055     else
1056         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1057                                 allocated_size);
1058     printf("image: %s\n"
1059            "file format: %s\n"
1060            "virtual size: %s (%" PRId64 " bytes)\n"
1061            "disk size: %s\n",
1062            filename, fmt_name, size_buf,
1063            (total_sectors * 512),
1064            dsize_buf);
1065     if (bdrv_is_encrypted(bs))
1066         printf("encrypted: yes\n");
1067     if (bdrv_get_info(bs, &bdi) >= 0) {
1068         if (bdi.cluster_size != 0)
1069             printf("cluster_size: %d\n", bdi.cluster_size);
1070     }
1071     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1072     if (backing_filename[0] != '\0') {
1073         path_combine(backing_filename2, sizeof(backing_filename2),
1074                      filename, backing_filename);
1075         printf("backing file: %s (actual path: %s)\n",
1076                backing_filename,
1077                backing_filename2);
1078     }
1079     dump_snapshots(bs);
1080     bdrv_delete(bs);
1081     return 0;
1082 }
1083
1084 #define SNAPSHOT_LIST   1
1085 #define SNAPSHOT_CREATE 2
1086 #define SNAPSHOT_APPLY  3
1087 #define SNAPSHOT_DELETE 4
1088
1089 static int img_snapshot(int argc, char **argv)
1090 {
1091     BlockDriverState *bs;
1092     QEMUSnapshotInfo sn;
1093     char *filename, *snapshot_name = NULL;
1094     int c, ret = 0, bdrv_oflags;
1095     int action = 0;
1096     qemu_timeval tv;
1097
1098     bdrv_oflags = BDRV_O_RDWR;
1099     /* Parse commandline parameters */
1100     for(;;) {
1101         c = getopt(argc, argv, "la:c:d:h");
1102         if (c == -1)
1103             break;
1104         switch(c) {
1105         case 'h':
1106             help();
1107             return 0;
1108         case 'l':
1109             if (action) {
1110                 help();
1111                 return 0;
1112             }
1113             action = SNAPSHOT_LIST;
1114             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1115             break;
1116         case 'a':
1117             if (action) {
1118                 help();
1119                 return 0;
1120             }
1121             action = SNAPSHOT_APPLY;
1122             snapshot_name = optarg;
1123             break;
1124         case 'c':
1125             if (action) {
1126                 help();
1127                 return 0;
1128             }
1129             action = SNAPSHOT_CREATE;
1130             snapshot_name = optarg;
1131             break;
1132         case 'd':
1133             if (action) {
1134                 help();
1135                 return 0;
1136             }
1137             action = SNAPSHOT_DELETE;
1138             snapshot_name = optarg;
1139             break;
1140         }
1141     }
1142
1143     if (optind >= argc)
1144         help();
1145     filename = argv[optind++];
1146
1147     /* Open the image */
1148     bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1149     if (!bs) {
1150         return 1;
1151     }
1152
1153     /* Perform the requested action */
1154     switch(action) {
1155     case SNAPSHOT_LIST:
1156         dump_snapshots(bs);
1157         break;
1158
1159     case SNAPSHOT_CREATE:
1160         memset(&sn, 0, sizeof(sn));
1161         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1162
1163         qemu_gettimeofday(&tv);
1164         sn.date_sec = tv.tv_sec;
1165         sn.date_nsec = tv.tv_usec * 1000;
1166
1167         ret = bdrv_snapshot_create(bs, &sn);
1168         if (ret)
1169             error("Could not create snapshot '%s': %d (%s)",
1170                 snapshot_name, ret, strerror(-ret));
1171         break;
1172
1173     case SNAPSHOT_APPLY:
1174         ret = bdrv_snapshot_goto(bs, snapshot_name);
1175         if (ret)
1176             error("Could not apply snapshot '%s': %d (%s)",
1177                 snapshot_name, ret, strerror(-ret));
1178         break;
1179
1180     case SNAPSHOT_DELETE:
1181         ret = bdrv_snapshot_delete(bs, snapshot_name);
1182         if (ret)
1183             error("Could not delete snapshot '%s': %d (%s)",
1184                 snapshot_name, ret, strerror(-ret));
1185         break;
1186     }
1187
1188     /* Cleanup */
1189     bdrv_delete(bs);
1190     if (ret) {
1191         return 1;
1192     }
1193     return 0;
1194 }
1195
1196 static int img_rebase(int argc, char **argv)
1197 {
1198     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1199     BlockDriver *old_backing_drv, *new_backing_drv;
1200     char *filename;
1201     const char *fmt, *out_basefmt, *out_baseimg;
1202     int c, flags, ret;
1203     int unsafe = 0;
1204
1205     /* Parse commandline parameters */
1206     fmt = NULL;
1207     out_baseimg = NULL;
1208     out_basefmt = NULL;
1209
1210     for(;;) {
1211         c = getopt(argc, argv, "uhf:F:b:");
1212         if (c == -1)
1213             break;
1214         switch(c) {
1215         case 'h':
1216             help();
1217             return 0;
1218         case 'f':
1219             fmt = optarg;
1220             break;
1221         case 'F':
1222             out_basefmt = optarg;
1223             break;
1224         case 'b':
1225             out_baseimg = optarg;
1226             break;
1227         case 'u':
1228             unsafe = 1;
1229             break;
1230         }
1231     }
1232
1233     if ((optind >= argc) || !out_baseimg)
1234         help();
1235     filename = argv[optind++];
1236
1237     /*
1238      * Open the images.
1239      *
1240      * Ignore the old backing file for unsafe rebase in case we want to correct
1241      * the reference to a renamed or moved backing file.
1242      */
1243     flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1244     bs = bdrv_new_open(filename, fmt, flags);
1245     if (!bs) {
1246         return 1;
1247     }
1248
1249     /* Find the right drivers for the backing files */
1250     old_backing_drv = NULL;
1251     new_backing_drv = NULL;
1252
1253     if (!unsafe && bs->backing_format[0] != '\0') {
1254         old_backing_drv = bdrv_find_format(bs->backing_format);
1255         if (old_backing_drv == NULL) {
1256             error("Invalid format name: '%s'", bs->backing_format);
1257             ret = -1;
1258             goto out;
1259         }
1260     }
1261
1262     if (out_basefmt != NULL) {
1263         new_backing_drv = bdrv_find_format(out_basefmt);
1264         if (new_backing_drv == NULL) {
1265             error("Invalid format name: '%s'", out_basefmt);
1266             ret = -1;
1267             goto out;
1268         }
1269     }
1270
1271     /* For safe rebasing we need to compare old and new backing file */
1272     if (unsafe) {
1273         /* Make the compiler happy */
1274         bs_old_backing = NULL;
1275         bs_new_backing = NULL;
1276     } else {
1277         char backing_name[1024];
1278
1279         bs_old_backing = bdrv_new("old_backing");
1280         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1281         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1282                         old_backing_drv);
1283         if (ret) {
1284             error("Could not open old backing file '%s'", backing_name);
1285             goto out;
1286         }
1287
1288         bs_new_backing = bdrv_new("new_backing");
1289         ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1290                         new_backing_drv);
1291         if (ret) {
1292             error("Could not open new backing file '%s'", out_baseimg);
1293             goto out;
1294         }
1295     }
1296
1297     /*
1298      * Check each unallocated cluster in the COW file. If it is unallocated,
1299      * accesses go to the backing file. We must therefore compare this cluster
1300      * in the old and new backing file, and if they differ we need to copy it
1301      * from the old backing file into the COW file.
1302      *
1303      * If qemu-img crashes during this step, no harm is done. The content of
1304      * the image is the same as the original one at any time.
1305      */
1306     if (!unsafe) {
1307         uint64_t num_sectors;
1308         uint64_t sector;
1309         int n;
1310         uint8_t * buf_old;
1311         uint8_t * buf_new;
1312
1313         buf_old = qemu_malloc(IO_BUF_SIZE);
1314         buf_new = qemu_malloc(IO_BUF_SIZE);
1315
1316         bdrv_get_geometry(bs, &num_sectors);
1317
1318         for (sector = 0; sector < num_sectors; sector += n) {
1319
1320             /* How many sectors can we handle with the next read? */
1321             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1322                 n = (IO_BUF_SIZE / 512);
1323             } else {
1324                 n = num_sectors - sector;
1325             }
1326
1327             /* If the cluster is allocated, we don't need to take action */
1328             ret = bdrv_is_allocated(bs, sector, n, &n);
1329             if (ret) {
1330                 continue;
1331             }
1332
1333             /* Read old and new backing file */
1334             ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1335             if (ret < 0) {
1336                 error("error while reading from old backing file");
1337                 goto out;
1338             }
1339             ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1340             if (ret < 0) {
1341                 error("error while reading from new backing file");
1342                 goto out;
1343             }
1344
1345             /* If they differ, we need to write to the COW file */
1346             uint64_t written = 0;
1347
1348             while (written < n) {
1349                 int pnum;
1350
1351                 if (compare_sectors(buf_old + written * 512,
1352                     buf_new + written * 512, n - written, &pnum))
1353                 {
1354                     ret = bdrv_write(bs, sector + written,
1355                         buf_old + written * 512, pnum);
1356                     if (ret < 0) {
1357                         error("Error while writing to COW image: %s",
1358                             strerror(-ret));
1359                         goto out;
1360                     }
1361                 }
1362
1363                 written += pnum;
1364             }
1365         }
1366
1367         qemu_free(buf_old);
1368         qemu_free(buf_new);
1369     }
1370
1371     /*
1372      * Change the backing file. All clusters that are different from the old
1373      * backing file are overwritten in the COW file now, so the visible content
1374      * doesn't change when we switch the backing file.
1375      */
1376     ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1377     if (ret == -ENOSPC) {
1378         error("Could not change the backing file to '%s': No space left in "
1379             "the file header", out_baseimg);
1380     } else if (ret < 0) {
1381         error("Could not change the backing file to '%s': %s",
1382             out_baseimg, strerror(-ret));
1383     }
1384
1385     /*
1386      * TODO At this point it is possible to check if any clusters that are
1387      * allocated in the COW file are the same in the backing file. If so, they
1388      * could be dropped from the COW file. Don't do this before switching the
1389      * backing file, in case of a crash this would lead to corruption.
1390      */
1391 out:
1392     /* Cleanup */
1393     if (!unsafe) {
1394         bdrv_delete(bs_old_backing);
1395         bdrv_delete(bs_new_backing);
1396     }
1397
1398     bdrv_delete(bs);
1399     if (ret) {
1400         return 1;
1401     }
1402     return 0;
1403 }
1404
1405 static int img_resize(int argc, char **argv)
1406 {
1407     int c, ret, relative;
1408     const char *filename, *fmt, *size;
1409     int64_t n, total_size;
1410     BlockDriverState *bs;
1411     QEMUOptionParameter *param;
1412     QEMUOptionParameter resize_options[] = {
1413         {
1414             .name = BLOCK_OPT_SIZE,
1415             .type = OPT_SIZE,
1416             .help = "Virtual disk size"
1417         },
1418         { NULL }
1419     };
1420
1421     fmt = NULL;
1422     for(;;) {
1423         c = getopt(argc, argv, "f:h");
1424         if (c == -1) {
1425             break;
1426         }
1427         switch(c) {
1428         case 'h':
1429             help();
1430             break;
1431         case 'f':
1432             fmt = optarg;
1433             break;
1434         }
1435     }
1436     if (optind + 1 >= argc) {
1437         help();
1438     }
1439     filename = argv[optind++];
1440     size = argv[optind++];
1441
1442     /* Choose grow, shrink, or absolute resize mode */
1443     switch (size[0]) {
1444     case '+':
1445         relative = 1;
1446         size++;
1447         break;
1448     case '-':
1449         relative = -1;
1450         size++;
1451         break;
1452     default:
1453         relative = 0;
1454         break;
1455     }
1456
1457     /* Parse size */
1458     param = parse_option_parameters("", resize_options, NULL);
1459     if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1460         /* Error message already printed when size parsing fails */
1461         exit(1);
1462     }
1463     n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1464     free_option_parameters(param);
1465
1466     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1467     if (!bs) {
1468         return 1;
1469     }
1470
1471     if (relative) {
1472         total_size = bdrv_getlength(bs) + n * relative;
1473     } else {
1474         total_size = n;
1475     }
1476     if (total_size <= 0) {
1477         error("New image size must be positive");
1478         ret = -1;
1479         goto out;
1480     }
1481
1482     ret = bdrv_truncate(bs, total_size);
1483     switch (ret) {
1484     case 0:
1485         printf("Image resized.\n");
1486         break;
1487     case -ENOTSUP:
1488         error("This image format does not support resize");
1489         break;
1490     case -EACCES:
1491         error("Image is read-only");
1492         break;
1493     default:
1494         error("Error resizing image (%d)", -ret);
1495         break;
1496     }
1497 out:
1498     bdrv_delete(bs);
1499     if (ret) {
1500         return 1;
1501     }
1502     return 0;
1503 }
1504
1505 static const img_cmd_t img_cmds[] = {
1506 #define DEF(option, callback, arg_string)        \
1507     { option, callback },
1508 #include "qemu-img-cmds.h"
1509 #undef DEF
1510 #undef GEN_DOCS
1511     { NULL, NULL, },
1512 };
1513
1514 int main(int argc, char **argv)
1515 {
1516     const img_cmd_t *cmd;
1517     const char *cmdname;
1518
1519     bdrv_init();
1520     if (argc < 2)
1521         help();
1522     cmdname = argv[1];
1523     argc--; argv++;
1524
1525     /* find the command */
1526     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1527         if (!strcmp(cmdname, cmd->name)) {
1528             return cmd->handler(argc, argv);
1529         }
1530     }
1531
1532     /* not found */
1533     help();
1534     return 0;
1535 }