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