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