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