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