qemu-img.c

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