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 "qapi-visit.h"
  25 #include "qapi/qmp-output-visitor.h"
  26 #include "qapi/qmp/qjson.h"
  27 #include "qemu-common.h"
  28 #include "qemu/option.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/osdep.h"
  31 #include "sysemu/sysemu.h"
  32 #include "block/block_int.h"
  33 #include <getopt.h>
  34 #include <stdio.h>
  35
  36 #ifdef _WIN32
  37 #include <windows.h>
  38 #endif
  39
  40 typedef struct img_cmd_t {
  41     const char *name;
  42     int (*handler)(int argc, char **argv);
  43 } img_cmd_t;
  44
  45 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  46 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  47 #define BDRV_DEFAULT_CACHE "writeback"
  48
  49 static void format_print(void *opaque, const char *name)
  50 {
  51     printf(" %s", name);
  52 }
  53
  54 /* Please keep in synch with qemu-img.texi */
  55 static void help(void)
  56 {
  57     const char *help_msg =
  58            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  59            "usage: qemu-img command [command options]\n"
  60            "QEMU disk image utility\n"
  61            "\n"
  62            "Command syntax:\n"
  63 #define DEF(option, callback, arg_string)        \
  64            "  " arg_string "\n"
  65 #include "qemu-img-cmds.h"
  66 #undef DEF
  67 #undef GEN_DOCS
  68            "\n"
  69            "Command parameters:\n"
  70            "  'filename' is a disk image filename\n"
  71            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  72            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  73            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
  74            "    'directsync' and 'unsafe' (default for convert)\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            "  '-p' show progress of command (only certain commands)\n"
  89            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
  90            "       for qemu-img to create a sparse image during conversion\n"
  91            "  '--output' takes the format in which the output must be done (human or json)\n"
  92            "\n"
  93            "Parameters to check subcommand:\n"
  94            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
  95            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
  96            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
  97            "       hiding corruption that has already occurred.\n"
  98            "\n"
  99            "Parameters to snapshot subcommand:\n"
 100            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 101            "  '-a' applies a snapshot (revert disk to saved state)\n"
 102            "  '-c' creates a snapshot\n"
 103            "  '-d' deletes a snapshot\n"
 104            "  '-l' lists all snapshots in the given image\n";
 105
 106     printf("%s\nSupported formats:", help_msg);
 107     bdrv_iterate_format(format_print, NULL);
 108     printf("\n");
 109     exit(1);
 110 }
 111
 112 #if defined(WIN32)
 113 /* XXX: put correct support for win32 */
 114 static int read_password(char *buf, int buf_size)
 115 {
 116     int c, i;
 117     printf("Password: ");
 118     fflush(stdout);
 119     i = 0;
 120     for(;;) {
 121         c = getchar();
 122         if (c == '\n')
 123             break;
 124         if (i < (buf_size - 1))
 125             buf[i++] = c;
 126     }
 127     buf[i] = '\0';
 128     return 0;
 129 }
 130
 131 #else
 132
 133 #include <termios.h>
 134
 135 static struct termios oldtty;
 136
 137 static void term_exit(void)
 138 {
 139     tcsetattr (0, TCSANOW, &oldtty);
 140 }
 141
 142 static void term_init(void)
 143 {
 144     struct termios tty;
 145
 146     tcgetattr (0, &tty);
 147     oldtty = tty;
 148
 149     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 150                           |INLCR|IGNCR|ICRNL|IXON);
 151     tty.c_oflag |= OPOST;
 152     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 153     tty.c_cflag &= ~(CSIZE|PARENB);
 154     tty.c_cflag |= CS8;
 155     tty.c_cc[VMIN] = 1;
 156     tty.c_cc[VTIME] = 0;
 157
 158     tcsetattr (0, TCSANOW, &tty);
 159
 160     atexit(term_exit);
 161 }
 162
 163 static int read_password(char *buf, int buf_size)
 164 {
 165     uint8_t ch;
 166     int i, ret;
 167
 168     printf("password: ");
 169     fflush(stdout);
 170     term_init();
 171     i = 0;
 172     for(;;) {
 173         ret = read(0, &ch, 1);
 174         if (ret == -1) {
 175             if (errno == EAGAIN || errno == EINTR) {
 176                 continue;
 177             } else {
 178                 ret = -1;
 179                 break;
 180             }
 181         } else if (ret == 0) {
 182             ret = -1;
 183             break;
 184         } else {
 185             if (ch == '\r') {
 186                 ret = 0;
 187                 break;
 188             }
 189             if (i < (buf_size - 1))
 190                 buf[i++] = ch;
 191         }
 192     }
 193     term_exit();
 194     buf[i] = '\0';
 195     printf("\n");
 196     return ret;
 197 }
 198 #endif
 199
 200 static int print_block_option_help(const char *filename, const char *fmt)
 201 {
 202     BlockDriver *drv, *proto_drv;
 203     QEMUOptionParameter *create_options = NULL;
 204
 205     /* Find driver and parse its options */
 206     drv = bdrv_find_format(fmt);
 207     if (!drv) {
 208         error_report("Unknown file format '%s'", fmt);
 209         return 1;
 210     }
 211
 212     proto_drv = bdrv_find_protocol(filename);
 213     if (!proto_drv) {
 214         error_report("Unknown protocol '%s'", filename);
 215         return 1;
 216     }
 217
 218     create_options = append_option_parameters(create_options,
 219                                               drv->create_options);
 220     create_options = append_option_parameters(create_options,
 221                                               proto_drv->create_options);
 222     print_option_help(create_options);
 223     free_option_parameters(create_options);
 224     return 0;
 225 }
 226
 227 static BlockDriverState *bdrv_new_open(const char *filename,
 228                                        const char *fmt,
 229                                        int flags,
 230                                        bool require_io)
 231 {
 232     BlockDriverState *bs;
 233     BlockDriver *drv;
 234     char password[256];
 235     int ret;
 236
 237     bs = bdrv_new("image");
 238
 239     if (fmt) {
 240         drv = bdrv_find_format(fmt);
 241         if (!drv) {
 242             error_report("Unknown file format '%s'", fmt);
 243             goto fail;
 244         }
 245     } else {
 246         drv = NULL;
 247     }
 248
 249     ret = bdrv_open(bs, filename, flags, drv);
 250     if (ret < 0) {
 251         error_report("Could not open '%s': %s", filename, strerror(-ret));
 252         goto fail;
 253     }
 254
 255     if (bdrv_is_encrypted(bs) && require_io) {
 256         printf("Disk image '%s' is encrypted.\n", filename);
 257         if (read_password(password, sizeof(password)) < 0) {
 258             error_report("No password given");
 259             goto fail;
 260         }
 261         if (bdrv_set_key(bs, password) < 0) {
 262             error_report("invalid password");
 263             goto fail;
 264         }
 265     }
 266     return bs;
 267 fail:
 268     if (bs) {
 269         bdrv_delete(bs);
 270     }
 271     return NULL;
 272 }
 273
 274 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 275                                  const char *base_filename,
 276                                  const char *base_fmt)
 277 {
 278     if (base_filename) {
 279         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 280             error_report("Backing file not supported for file format '%s'",
 281                          fmt);
 282             return -1;
 283         }
 284     }
 285     if (base_fmt) {
 286         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 287             error_report("Backing file format not supported for file "
 288                          "format '%s'", fmt);
 289             return -1;
 290         }
 291     }
 292     return 0;
 293 }
 294
 295 static int img_create(int argc, char **argv)
 296 {
 297     int c;
 298     uint64_t img_size = -1;
 299     const char *fmt = "raw";
 300     const char *base_fmt = NULL;
 301     const char *filename;
 302     const char *base_filename = NULL;
 303     char *options = NULL;
 304     Error *local_err = NULL;
 305
 306     for(;;) {
 307         c = getopt(argc, argv, "F:b:f:he6o:");
 308         if (c == -1) {
 309             break;
 310         }
 311         switch(c) {
 312         case '?':
 313         case 'h':
 314             help();
 315             break;
 316         case 'F':
 317             base_fmt = optarg;
 318             break;
 319         case 'b':
 320             base_filename = optarg;
 321             break;
 322         case 'f':
 323             fmt = optarg;
 324             break;
 325         case 'e':
 326             error_report("option -e is deprecated, please use \'-o "
 327                   "encryption\' instead!");
 328             return 1;
 329         case '6':
 330             error_report("option -6 is deprecated, please use \'-o "
 331                   "compat6\' instead!");
 332             return 1;
 333         case 'o':
 334             options = optarg;
 335             break;
 336         }
 337     }
 338
 339     /* Get the filename */
 340     if (optind >= argc) {
 341         help();
 342     }
 343     filename = argv[optind++];
 344
 345     /* Get image size, if specified */
 346     if (optind < argc) {
 347         int64_t sval;
 348         char *end;
 349         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 350         if (sval < 0 || *end) {
 351             if (sval == -ERANGE) {
 352                 error_report("Image size must be less than 8 EiB!");
 353             } else {
 354                 error_report("Invalid image size specified! You may use k, M, "
 355                       "G or T suffixes for ");
 356                 error_report("kilobytes, megabytes, gigabytes and terabytes.");
 357             }
 358             return 1;
 359         }
 360         img_size = (uint64_t)sval;
 361     }
 362
 363     if (options && is_help_option(options)) {
 364         return print_block_option_help(filename, fmt);
 365     }
 366
 367     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 368                     options, img_size, BDRV_O_FLAGS, &local_err);
 369     if (error_is_set(&local_err)) {
 370         error_report("%s", error_get_pretty(local_err));
 371         error_free(local_err);
 372         return 1;
 373     }
 374
 375     return 0;
 376 }
 377
 378 /*
 379  * Checks an image for consistency. Exit codes:
 380  *
 381  * 0 - Check completed, image is good
 382  * 1 - Check not completed because of internal errors
 383  * 2 - Check completed, image is corrupted
 384  * 3 - Check completed, image has leaked clusters, but is good otherwise
 385  */
 386 static int img_check(int argc, char **argv)
 387 {
 388     int c, ret;
 389     const char *filename, *fmt;
 390     BlockDriverState *bs;
 391     BdrvCheckResult result;
 392     int fix = 0;
 393     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 394
 395     fmt = NULL;
 396     for(;;) {
 397         c = getopt(argc, argv, "f:hr:");
 398         if (c == -1) {
 399             break;
 400         }
 401         switch(c) {
 402         case '?':
 403         case 'h':
 404             help();
 405             break;
 406         case 'f':
 407             fmt = optarg;
 408             break;
 409         case 'r':
 410             flags |= BDRV_O_RDWR;
 411
 412             if (!strcmp(optarg, "leaks")) {
 413                 fix = BDRV_FIX_LEAKS;
 414             } else if (!strcmp(optarg, "all")) {
 415                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 416             } else {
 417                 help();
 418             }
 419             break;
 420         }
 421     }
 422     if (optind >= argc) {
 423         help();
 424     }
 425     filename = argv[optind++];
 426
 427     bs = bdrv_new_open(filename, fmt, flags, true);
 428     if (!bs) {
 429         return 1;
 430     }
 431     ret = bdrv_check(bs, &result, fix);
 432
 433     if (ret == -ENOTSUP) {
 434         error_report("This image format does not support checks");
 435         bdrv_delete(bs);
 436         return 1;
 437     }
 438
 439     if (result.corruptions_fixed || result.leaks_fixed) {
 440         printf("The following inconsistencies were found and repaired:\n\n"
 441                "    %d leaked clusters\n"
 442                "    %d corruptions\n\n"
 443                "Double checking the fixed image now...\n",
 444                result.leaks_fixed,
 445                result.corruptions_fixed);
 446         ret = bdrv_check(bs, &result, 0);
 447     }
 448
 449     if (!(result.corruptions || result.leaks || result.check_errors)) {
 450         printf("No errors were found on the image.\n");
 451     } else {
 452         if (result.corruptions) {
 453             printf("\n%d errors were found on the image.\n"
 454                 "Data may be corrupted, or further writes to the image "
 455                 "may corrupt it.\n",
 456                 result.corruptions);
 457         }
 458
 459         if (result.leaks) {
 460             printf("\n%d leaked clusters were found on the image.\n"
 461                 "This means waste of disk space, but no harm to data.\n",
 462                 result.leaks);
 463         }
 464
 465         if (result.check_errors) {
 466             printf("\n%d internal errors have occurred during the check.\n",
 467                 result.check_errors);
 468         }
 469     }
 470
 471     if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
 472         printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
 473         result.bfi.allocated_clusters, result.bfi.total_clusters,
 474         result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
 475         result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
 476     }
 477
 478     if (result.image_end_offset > 0) {
 479         printf("Image end offset: %" PRId64 "\n", result.image_end_offset);
 480     }
 481
 482     bdrv_delete(bs);
 483
 484     if (ret < 0 || result.check_errors) {
 485         printf("\nAn error has occurred during the check: %s\n"
 486             "The check is not complete and may have missed error.\n",
 487             strerror(-ret));
 488         return 1;
 489     }
 490
 491     if (result.corruptions) {
 492         return 2;
 493     } else if (result.leaks) {
 494         return 3;
 495     } else {
 496         return 0;
 497     }
 498 }
 499
 500 static int img_commit(int argc, char **argv)
 501 {
 502     int c, ret, flags;
 503     const char *filename, *fmt, *cache;
 504     BlockDriverState *bs;
 505
 506     fmt = NULL;
 507     cache = BDRV_DEFAULT_CACHE;
 508     for(;;) {
 509         c = getopt(argc, argv, "f:ht:");
 510         if (c == -1) {
 511             break;
 512         }
 513         switch(c) {
 514         case '?':
 515         case 'h':
 516             help();
 517             break;
 518         case 'f':
 519             fmt = optarg;
 520             break;
 521         case 't':
 522             cache = optarg;
 523             break;
 524         }
 525     }
 526     if (optind >= argc) {
 527         help();
 528     }
 529     filename = argv[optind++];
 530
 531     flags = BDRV_O_RDWR;
 532     ret = bdrv_parse_cache_flags(cache, &flags);
 533     if (ret < 0) {
 534         error_report("Invalid cache option: %s", cache);
 535         return -1;
 536     }
 537
 538     bs = bdrv_new_open(filename, fmt, flags, true);
 539     if (!bs) {
 540         return 1;
 541     }
 542     ret = bdrv_commit(bs);
 543     switch(ret) {
 544     case 0:
 545         printf("Image committed.\n");
 546         break;
 547     case -ENOENT:
 548         error_report("No disk inserted");
 549         break;
 550     case -EACCES:
 551         error_report("Image is read-only");
 552         break;
 553     case -ENOTSUP:
 554         error_report("Image is already committed");
 555         break;
 556     default:
 557         error_report("Error while committing image");
 558         break;
 559     }
 560
 561     bdrv_delete(bs);
 562     if (ret) {
 563         return 1;
 564     }
 565     return 0;
 566 }
 567
 568 /*
 569  * Returns true iff the first sector pointed to by 'buf' contains at least
 570  * a non-NUL byte.
 571  *
 572  * 'pnum' is set to the number of sectors (including and immediately following
 573  * the first one) that are known to be in the same allocated/unallocated state.
 574  */
 575 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 576 {
 577     bool is_zero;
 578     int i;
 579
 580     if (n <= 0) {
 581         *pnum = 0;
 582         return 0;
 583     }
 584     is_zero = buffer_is_zero(buf, 512);
 585     for(i = 1; i < n; i++) {
 586         buf += 512;
 587         if (is_zero != buffer_is_zero(buf, 512)) {
 588             break;
 589         }
 590     }
 591     *pnum = i;
 592     return !is_zero;
 593 }
 594
 595 /*
 596  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 597  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 598  * breaking up write requests for only small sparse areas.
 599  */
 600 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 601     int min)
 602 {
 603     int ret;
 604     int num_checked, num_used;
 605
 606     if (n < min) {
 607         min = n;
 608     }
 609
 610     ret = is_allocated_sectors(buf, n, pnum);
 611     if (!ret) {
 612         return ret;
 613     }
 614
 615     num_used = *pnum;
 616     buf += BDRV_SECTOR_SIZE * *pnum;
 617     n -= *pnum;
 618     num_checked = num_used;
 619
 620     while (n > 0) {
 621         ret = is_allocated_sectors(buf, n, pnum);
 622
 623         buf += BDRV_SECTOR_SIZE * *pnum;
 624         n -= *pnum;
 625         num_checked += *pnum;
 626         if (ret) {
 627             num_used = num_checked;
 628         } else if (*pnum >= min) {
 629             break;
 630         }
 631     }
 632
 633     *pnum = num_used;
 634     return 1;
 635 }
 636
 637 /*
 638  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 639  * buffers matches, non-zero otherwise.
 640  *
 641  * pnum is set to the number of sectors (including and immediately following
 642  * the first one) that are known to have the same comparison result
 643  */
 644 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 645     int *pnum)
 646 {
 647     int res, i;
 648
 649     if (n <= 0) {
 650         *pnum = 0;
 651         return 0;
 652     }
 653
 654     res = !!memcmp(buf1, buf2, 512);
 655     for(i = 1; i < n; i++) {
 656         buf1 += 512;
 657         buf2 += 512;
 658
 659         if (!!memcmp(buf1, buf2, 512) != res) {
 660             break;
 661         }
 662     }
 663
 664     *pnum = i;
 665     return res;
 666 }
 667
 668 #define IO_BUF_SIZE (2 * 1024 * 1024)
 669
 670 static int img_convert(int argc, char **argv)
 671 {
 672     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
 673     int progress = 0, flags;
 674     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
 675     BlockDriver *drv, *proto_drv;
 676     BlockDriverState **bs = NULL, *out_bs = NULL;
 677     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 678     uint64_t bs_sectors;
 679     uint8_t * buf = NULL;
 680     const uint8_t *buf1;
 681     BlockDriverInfo bdi;
 682     QEMUOptionParameter *param = NULL, *create_options = NULL;
 683     QEMUOptionParameter *out_baseimg_param;
 684     char *options = NULL;
 685     const char *snapshot_name = NULL;
 686     float local_progress = 0;
 687     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
 688
 689     fmt = NULL;
 690     out_fmt = "raw";
 691     cache = "unsafe";
 692     out_baseimg = NULL;
 693     compress = 0;
 694     for(;;) {
 695         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
 696         if (c == -1) {
 697             break;
 698         }
 699         switch(c) {
 700         case '?':
 701         case 'h':
 702             help();
 703             break;
 704         case 'f':
 705             fmt = optarg;
 706             break;
 707         case 'O':
 708             out_fmt = optarg;
 709             break;
 710         case 'B':
 711             out_baseimg = optarg;
 712             break;
 713         case 'c':
 714             compress = 1;
 715             break;
 716         case 'e':
 717             error_report("option -e is deprecated, please use \'-o "
 718                   "encryption\' instead!");
 719             return 1;
 720         case '6':
 721             error_report("option -6 is deprecated, please use \'-o "
 722                   "compat6\' instead!");
 723             return 1;
 724         case 'o':
 725             options = optarg;
 726             break;
 727         case 's':
 728             snapshot_name = optarg;
 729             break;
 730         case 'S':
 731         {
 732             int64_t sval;
 733             char *end;
 734             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
 735             if (sval < 0 || *end) {
 736                 error_report("Invalid minimum zero buffer size for sparse output specified");
 737                 return 1;
 738             }
 739
 740             min_sparse = sval / BDRV_SECTOR_SIZE;
 741             break;
 742         }
 743         case 'p':
 744             progress = 1;
 745             break;
 746         case 't':
 747             cache = optarg;
 748             break;
 749         }
 750     }
 751
 752     bs_n = argc - optind - 1;
 753     if (bs_n < 1) {
 754         help();
 755     }
 756
 757     out_filename = argv[argc - 1];
 758
 759     /* Initialize before goto out */
 760     qemu_progress_init(progress, 2.0);
 761
 762     if (options && is_help_option(options)) {
 763         ret = print_block_option_help(out_filename, out_fmt);
 764         goto out;
 765     }
 766
 767     if (bs_n > 1 && out_baseimg) {
 768         error_report("-B makes no sense when concatenating multiple input "
 769                      "images");
 770         ret = -1;
 771         goto out;
 772     }
 773
 774     qemu_progress_print(0, 100);
 775
 776     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
 777
 778     total_sectors = 0;
 779     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 780         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
 781         if (!bs[bs_i]) {
 782             error_report("Could not open '%s'", argv[optind + bs_i]);
 783             ret = -1;
 784             goto out;
 785         }
 786         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 787         total_sectors += bs_sectors;
 788     }
 789
 790     if (snapshot_name != NULL) {
 791         if (bs_n > 1) {
 792             error_report("No support for concatenating multiple snapshot");
 793             ret = -1;
 794             goto out;
 795         }
 796         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
 797             error_report("Failed to load snapshot");
 798             ret = -1;
 799             goto out;
 800         }
 801     }
 802
 803     /* Find driver and parse its options */
 804     drv = bdrv_find_format(out_fmt);
 805     if (!drv) {
 806         error_report("Unknown file format '%s'", out_fmt);
 807         ret = -1;
 808         goto out;
 809     }
 810
 811     proto_drv = bdrv_find_protocol(out_filename);
 812     if (!proto_drv) {
 813         error_report("Unknown protocol '%s'", out_filename);
 814         ret = -1;
 815         goto out;
 816     }
 817
 818     create_options = append_option_parameters(create_options,
 819                                               drv->create_options);
 820     create_options = append_option_parameters(create_options,
 821                                               proto_drv->create_options);
 822
 823     if (options) {
 824         param = parse_option_parameters(options, create_options, param);
 825         if (param == NULL) {
 826             error_report("Invalid options for file format '%s'.", out_fmt);
 827             ret = -1;
 828             goto out;
 829         }
 830     } else {
 831         param = parse_option_parameters("", create_options, param);
 832     }
 833
 834     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 835     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
 836     if (ret < 0) {
 837         goto out;
 838     }
 839
 840     /* Get backing file name if -o backing_file was used */
 841     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 842     if (out_baseimg_param) {
 843         out_baseimg = out_baseimg_param->value.s;
 844     }
 845
 846     /* Check if compression is supported */
 847     if (compress) {
 848         QEMUOptionParameter *encryption =
 849             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 850         QEMUOptionParameter *preallocation =
 851             get_option_parameter(param, BLOCK_OPT_PREALLOC);
 852
 853         if (!drv->bdrv_write_compressed) {
 854             error_report("Compression not supported for this file format");
 855             ret = -1;
 856             goto out;
 857         }
 858
 859         if (encryption && encryption->value.n) {
 860             error_report("Compression and encryption not supported at "
 861                          "the same time");
 862             ret = -1;
 863             goto out;
 864         }
 865
 866         if (preallocation && preallocation->value.s
 867             && strcmp(preallocation->value.s, "off"))
 868         {
 869             error_report("Compression and preallocation not supported at "
 870                          "the same time");
 871             ret = -1;
 872             goto out;
 873         }
 874     }
 875
 876     /* Create the new image */
 877     ret = bdrv_create(drv, out_filename, param);
 878     if (ret < 0) {
 879         if (ret == -ENOTSUP) {
 880             error_report("Formatting not supported for file format '%s'",
 881                          out_fmt);
 882         } else if (ret == -EFBIG) {
 883             error_report("The image size is too large for file format '%s'",
 884                          out_fmt);
 885         } else {
 886             error_report("%s: error while converting %s: %s",
 887                          out_filename, out_fmt, strerror(-ret));
 888         }
 889         goto out;
 890     }
 891
 892     flags = BDRV_O_RDWR;
 893     ret = bdrv_parse_cache_flags(cache, &flags);
 894     if (ret < 0) {
 895         error_report("Invalid cache option: %s", cache);
 896         return -1;
 897     }
 898
 899     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
 900     if (!out_bs) {
 901         ret = -1;
 902         goto out;
 903     }
 904
 905     bs_i = 0;
 906     bs_offset = 0;
 907     bdrv_get_geometry(bs[0], &bs_sectors);
 908     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
 909
 910     if (compress) {
 911         ret = bdrv_get_info(out_bs, &bdi);
 912         if (ret < 0) {
 913             error_report("could not get block driver info");
 914             goto out;
 915         }
 916         cluster_size = bdi.cluster_size;
 917         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
 918             error_report("invalid cluster size");
 919             ret = -1;
 920             goto out;
 921         }
 922         cluster_sectors = cluster_size >> 9;
 923         sector_num = 0;
 924
 925         nb_sectors = total_sectors;
 926         if (nb_sectors != 0) {
 927             local_progress = (float)100 /
 928                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
 929         }
 930
 931         for(;;) {
 932             int64_t bs_num;
 933             int remainder;
 934             uint8_t *buf2;
 935
 936             nb_sectors = total_sectors - sector_num;
 937             if (nb_sectors <= 0)
 938                 break;
 939             if (nb_sectors >= cluster_sectors)
 940                 n = cluster_sectors;
 941             else
 942                 n = nb_sectors;
 943
 944             bs_num = sector_num - bs_offset;
 945             assert (bs_num >= 0);
 946             remainder = n;
 947             buf2 = buf;
 948             while (remainder > 0) {
 949                 int nlow;
 950                 while (bs_num == bs_sectors) {
 951                     bs_i++;
 952                     assert (bs_i < bs_n);
 953                     bs_offset += bs_sectors;
 954                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 955                     bs_num = 0;
 956                     /* printf("changing part: sector_num=%" PRId64 ", "
 957                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
 958                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
 959                 }
 960                 assert (bs_num < bs_sectors);
 961
 962                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 963
 964                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
 965                 if (ret < 0) {
 966                     error_report("error while reading sector %" PRId64 ": %s",
 967                                  bs_num, strerror(-ret));
 968                     goto out;
 969                 }
 970
 971                 buf2 += nlow * 512;
 972                 bs_num += nlow;
 973
 974                 remainder -= nlow;
 975             }
 976             assert (remainder == 0);
 977
 978             if (n < cluster_sectors) {
 979                 memset(buf + n * 512, 0, cluster_size - n * 512);
 980             }
 981             if (!buffer_is_zero(buf, cluster_size)) {
 982                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
 983                                             cluster_sectors);
 984                 if (ret != 0) {
 985                     error_report("error while compressing sector %" PRId64
 986                                  ": %s", sector_num, strerror(-ret));
 987                     goto out;
 988                 }
 989             }
 990             sector_num += n;
 991             qemu_progress_print(local_progress, 100);
 992         }
 993         /* signal EOF to align */
 994         bdrv_write_compressed(out_bs, 0, NULL, 0);
 995     } else {
 996         int has_zero_init = bdrv_has_zero_init(out_bs);
 997
 998         sector_num = 0; // total number of sectors converted so far
 999         nb_sectors = total_sectors - sector_num;
1000         if (nb_sectors != 0) {
1001             local_progress = (float)100 /
1002                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1003         }
1004
1005         for(;;) {
1006             nb_sectors = total_sectors - sector_num;
1007             if (nb_sectors <= 0) {
1008                 break;
1009             }
1010             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1011                 n = (IO_BUF_SIZE / 512);
1012             } else {
1013                 n = nb_sectors;
1014             }
1015
1016             while (sector_num - bs_offset >= bs_sectors) {
1017                 bs_i ++;
1018                 assert (bs_i < bs_n);
1019                 bs_offset += bs_sectors;
1020                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1021                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1022                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1023                    sector_num, bs_i, bs_offset, bs_sectors); */
1024             }
1025
1026             if (n > bs_offset + bs_sectors - sector_num) {
1027                 n = bs_offset + bs_sectors - sector_num;
1028             }
1029
1030             if (has_zero_init) {
1031                 /* If the output image is being created as a copy on write image,
1032                    assume that sectors which are unallocated in the input image
1033                    are present in both the output's and input's base images (no
1034                    need to copy them). */
1035                 if (out_baseimg) {
1036                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1037                                            n, &n1)) {
1038                         sector_num += n1;
1039                         continue;
1040                     }
1041                     /* The next 'n1' sectors are allocated in the input image. Copy
1042                        only those as they may be followed by unallocated sectors. */
1043                     n = n1;
1044                 }
1045             } else {
1046                 n1 = n;
1047             }
1048
1049             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1050             if (ret < 0) {
1051                 error_report("error while reading sector %" PRId64 ": %s",
1052                              sector_num - bs_offset, strerror(-ret));
1053                 goto out;
1054             }
1055             /* NOTE: at the same time we convert, we do not write zero
1056                sectors to have a chance to compress the image. Ideally, we
1057                should add a specific call to have the info to go faster */
1058             buf1 = buf;
1059             while (n > 0) {
1060                 /* If the output image is being created as a copy on write image,
1061                    copy all sectors even the ones containing only NUL bytes,
1062                    because they may differ from the sectors in the base image.
1063
1064                    If the output is to a host device, we also write out
1065                    sectors that are entirely 0, since whatever data was
1066                    already there is garbage, not 0s. */
1067                 if (!has_zero_init || out_baseimg ||
1068                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1069                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1070                     if (ret < 0) {
1071                         error_report("error while writing sector %" PRId64
1072                                      ": %s", sector_num, strerror(-ret));
1073                         goto out;
1074                     }
1075                 }
1076                 sector_num += n1;
1077                 n -= n1;
1078                 buf1 += n1 * 512;
1079             }
1080             qemu_progress_print(local_progress, 100);
1081         }
1082     }
1083 out:
1084     qemu_progress_end();
1085     free_option_parameters(create_options);
1086     free_option_parameters(param);
1087     qemu_vfree(buf);
1088     if (out_bs) {
1089         bdrv_delete(out_bs);
1090     }
1091     if (bs) {
1092         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1093             if (bs[bs_i]) {
1094                 bdrv_delete(bs[bs_i]);
1095             }
1096         }
1097         g_free(bs);
1098     }
1099     if (ret) {
1100         return 1;
1101     }
1102     return 0;
1103 }
1104
1105
1106 static void dump_snapshots(BlockDriverState *bs)
1107 {
1108     QEMUSnapshotInfo *sn_tab, *sn;
1109     int nb_sns, i;
1110     char buf[256];
1111
1112     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1113     if (nb_sns <= 0)
1114         return;
1115     printf("Snapshot list:\n");
1116     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1117     for(i = 0; i < nb_sns; i++) {
1118         sn = &sn_tab[i];
1119         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1120     }
1121     g_free(sn_tab);
1122 }
1123
1124 static void dump_json_image_info_list(ImageInfoList *list)
1125 {
1126     Error *errp = NULL;
1127     QString *str;
1128     QmpOutputVisitor *ov = qmp_output_visitor_new();
1129     QObject *obj;
1130     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1131                              &list, NULL, &errp);
1132     obj = qmp_output_get_qobject(ov);
1133     str = qobject_to_json_pretty(obj);
1134     assert(str != NULL);
1135     printf("%s\n", qstring_get_str(str));
1136     qobject_decref(obj);
1137     qmp_output_visitor_cleanup(ov);
1138     QDECREF(str);
1139 }
1140
1141 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1142 {
1143     int i, sn_count;
1144     QEMUSnapshotInfo *sn_tab = NULL;
1145     SnapshotInfoList *info_list, *cur_item = NULL;
1146     sn_count = bdrv_snapshot_list(bs, &sn_tab);
1147
1148     for (i = 0; i < sn_count; i++) {
1149         info->has_snapshots = true;
1150         info_list = g_new0(SnapshotInfoList, 1);
1151
1152         info_list->value                = g_new0(SnapshotInfo, 1);
1153         info_list->value->id            = g_strdup(sn_tab[i].id_str);
1154         info_list->value->name          = g_strdup(sn_tab[i].name);
1155         info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1156         info_list->value->date_sec      = sn_tab[i].date_sec;
1157         info_list->value->date_nsec     = sn_tab[i].date_nsec;
1158         info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
1159         info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1160
1161         /* XXX: waiting for the qapi to support qemu-queue.h types */
1162         if (!cur_item) {
1163             info->snapshots = cur_item = info_list;
1164         } else {
1165             cur_item->next = info_list;
1166             cur_item = info_list;
1167         }
1168
1169     }
1170
1171     g_free(sn_tab);
1172 }
1173
1174 static void dump_json_image_info(ImageInfo *info)
1175 {
1176     Error *errp = NULL;
1177     QString *str;
1178     QmpOutputVisitor *ov = qmp_output_visitor_new();
1179     QObject *obj;
1180     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1181                          &info, NULL, &errp);
1182     obj = qmp_output_get_qobject(ov);
1183     str = qobject_to_json_pretty(obj);
1184     assert(str != NULL);
1185     printf("%s\n", qstring_get_str(str));
1186     qobject_decref(obj);
1187     qmp_output_visitor_cleanup(ov);
1188     QDECREF(str);
1189 }
1190
1191 static void collect_image_info(BlockDriverState *bs,
1192                    ImageInfo *info,
1193                    const char *filename,
1194                    const char *fmt)
1195 {
1196     uint64_t total_sectors;
1197     char backing_filename[1024];
1198     char backing_filename2[1024];
1199     BlockDriverInfo bdi;
1200
1201     bdrv_get_geometry(bs, &total_sectors);
1202
1203     info->filename        = g_strdup(filename);
1204     info->format          = g_strdup(bdrv_get_format_name(bs));
1205     info->virtual_size    = total_sectors * 512;
1206     info->actual_size     = bdrv_get_allocated_file_size(bs);
1207     info->has_actual_size = info->actual_size >= 0;
1208     if (bdrv_is_encrypted(bs)) {
1209         info->encrypted = true;
1210         info->has_encrypted = true;
1211     }
1212     if (bdrv_get_info(bs, &bdi) >= 0) {
1213         if (bdi.cluster_size != 0) {
1214             info->cluster_size = bdi.cluster_size;
1215             info->has_cluster_size = true;
1216         }
1217         info->dirty_flag = bdi.is_dirty;
1218         info->has_dirty_flag = true;
1219     }
1220     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1221     if (backing_filename[0] != '\0') {
1222         info->backing_filename = g_strdup(backing_filename);
1223         info->has_backing_filename = true;
1224         bdrv_get_full_backing_filename(bs, backing_filename2,
1225                                        sizeof(backing_filename2));
1226
1227         if (strcmp(backing_filename, backing_filename2) != 0) {
1228             info->full_backing_filename =
1229                         g_strdup(backing_filename2);
1230             info->has_full_backing_filename = true;
1231         }
1232
1233         if (bs->backing_format[0]) {
1234             info->backing_filename_format = g_strdup(bs->backing_format);
1235             info->has_backing_filename_format = true;
1236         }
1237     }
1238 }
1239
1240 static void dump_human_image_info(ImageInfo *info)
1241 {
1242     char size_buf[128], dsize_buf[128];
1243     if (!info->has_actual_size) {
1244         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1245     } else {
1246         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1247                                 info->actual_size);
1248     }
1249     get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1250     printf("image: %s\n"
1251            "file format: %s\n"
1252            "virtual size: %s (%" PRId64 " bytes)\n"
1253            "disk size: %s\n",
1254            info->filename, info->format, size_buf,
1255            info->virtual_size,
1256            dsize_buf);
1257
1258     if (info->has_encrypted && info->encrypted) {
1259         printf("encrypted: yes\n");
1260     }
1261
1262     if (info->has_cluster_size) {
1263         printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1264     }
1265
1266     if (info->has_dirty_flag && info->dirty_flag) {
1267         printf("cleanly shut down: no\n");
1268     }
1269
1270     if (info->has_backing_filename) {
1271         printf("backing file: %s", info->backing_filename);
1272         if (info->has_full_backing_filename) {
1273             printf(" (actual path: %s)", info->full_backing_filename);
1274         }
1275         putchar('\n');
1276         if (info->has_backing_filename_format) {
1277             printf("backing file format: %s\n", info->backing_filename_format);
1278         }
1279     }
1280
1281     if (info->has_snapshots) {
1282         SnapshotInfoList *elem;
1283         char buf[256];
1284
1285         printf("Snapshot list:\n");
1286         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1287
1288         /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1289          * we convert to the block layer's native QEMUSnapshotInfo for now.
1290          */
1291         for (elem = info->snapshots; elem; elem = elem->next) {
1292             QEMUSnapshotInfo sn = {
1293                 .vm_state_size = elem->value->vm_state_size,
1294                 .date_sec = elem->value->date_sec,
1295                 .date_nsec = elem->value->date_nsec,
1296                 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1297                                  elem->value->vm_clock_nsec,
1298             };
1299
1300             pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1301             pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1302             printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1303         }
1304     }
1305 }
1306
1307 static void dump_human_image_info_list(ImageInfoList *list)
1308 {
1309     ImageInfoList *elem;
1310     bool delim = false;
1311
1312     for (elem = list; elem; elem = elem->next) {
1313         if (delim) {
1314             printf("\n");
1315         }
1316         delim = true;
1317
1318         dump_human_image_info(elem->value);
1319     }
1320 }
1321
1322 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1323 {
1324     return strcmp(a, b) == 0;
1325 }
1326
1327 /**
1328  * Open an image file chain and return an ImageInfoList
1329  *
1330  * @filename: topmost image filename
1331  * @fmt: topmost image format (may be NULL to autodetect)
1332  * @chain: true  - enumerate entire backing file chain
1333  *         false - only topmost image file
1334  *
1335  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1336  * image file.  If there was an error a message will have been printed to
1337  * stderr.
1338  */
1339 static ImageInfoList *collect_image_info_list(const char *filename,
1340                                               const char *fmt,
1341                                               bool chain)
1342 {
1343     ImageInfoList *head = NULL;
1344     ImageInfoList **last = &head;
1345     GHashTable *filenames;
1346
1347     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1348
1349     while (filename) {
1350         BlockDriverState *bs;
1351         ImageInfo *info;
1352         ImageInfoList *elem;
1353
1354         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1355             error_report("Backing file '%s' creates an infinite loop.",
1356                          filename);
1357             goto err;
1358         }
1359         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1360
1361         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1362                            false);
1363         if (!bs) {
1364             goto err;
1365         }
1366
1367         info = g_new0(ImageInfo, 1);
1368         collect_image_info(bs, info, filename, fmt);
1369         collect_snapshots(bs, info);
1370
1371         elem = g_new0(ImageInfoList, 1);
1372         elem->value = info;
1373         *last = elem;
1374         last = &elem->next;
1375
1376         bdrv_delete(bs);
1377
1378         filename = fmt = NULL;
1379         if (chain) {
1380             if (info->has_full_backing_filename) {
1381                 filename = info->full_backing_filename;
1382             } else if (info->has_backing_filename) {
1383                 filename = info->backing_filename;
1384             }
1385             if (info->has_backing_filename_format) {
1386                 fmt = info->backing_filename_format;
1387             }
1388         }
1389     }
1390     g_hash_table_destroy(filenames);
1391     return head;
1392
1393 err:
1394     qapi_free_ImageInfoList(head);
1395     g_hash_table_destroy(filenames);
1396     return NULL;
1397 }
1398
1399 enum {
1400     OPTION_OUTPUT = 256,
1401     OPTION_BACKING_CHAIN = 257,
1402 };
1403
1404 typedef enum OutputFormat {
1405     OFORMAT_JSON,
1406     OFORMAT_HUMAN,
1407 } OutputFormat;
1408
1409 static int img_info(int argc, char **argv)
1410 {
1411     int c;
1412     OutputFormat output_format = OFORMAT_HUMAN;
1413     bool chain = false;
1414     const char *filename, *fmt, *output;
1415     ImageInfoList *list;
1416
1417     fmt = NULL;
1418     output = NULL;
1419     for(;;) {
1420         int option_index = 0;
1421         static const struct option long_options[] = {
1422             {"help", no_argument, 0, 'h'},
1423             {"format", required_argument, 0, 'f'},
1424             {"output", required_argument, 0, OPTION_OUTPUT},
1425             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1426             {0, 0, 0, 0}
1427         };
1428         c = getopt_long(argc, argv, "f:h",
1429                         long_options, &option_index);
1430         if (c == -1) {
1431             break;
1432         }
1433         switch(c) {
1434         case '?':
1435         case 'h':
1436             help();
1437             break;
1438         case 'f':
1439             fmt = optarg;
1440             break;
1441         case OPTION_OUTPUT:
1442             output = optarg;
1443             break;
1444         case OPTION_BACKING_CHAIN:
1445             chain = true;
1446             break;
1447         }
1448     }
1449     if (optind >= argc) {
1450         help();
1451     }
1452     filename = argv[optind++];
1453
1454     if (output && !strcmp(output, "json")) {
1455         output_format = OFORMAT_JSON;
1456     } else if (output && !strcmp(output, "human")) {
1457         output_format = OFORMAT_HUMAN;
1458     } else if (output) {
1459         error_report("--output must be used with human or json as argument.");
1460         return 1;
1461     }
1462
1463     list = collect_image_info_list(filename, fmt, chain);
1464     if (!list) {
1465         return 1;
1466     }
1467
1468     switch (output_format) {
1469     case OFORMAT_HUMAN:
1470         dump_human_image_info_list(list);
1471         break;
1472     case OFORMAT_JSON:
1473         if (chain) {
1474             dump_json_image_info_list(list);
1475         } else {
1476             dump_json_image_info(list->value);
1477         }
1478         break;
1479     }
1480
1481     qapi_free_ImageInfoList(list);
1482     return 0;
1483 }
1484
1485 #define SNAPSHOT_LIST   1
1486 #define SNAPSHOT_CREATE 2
1487 #define SNAPSHOT_APPLY  3
1488 #define SNAPSHOT_DELETE 4
1489
1490 static int img_snapshot(int argc, char **argv)
1491 {
1492     BlockDriverState *bs;
1493     QEMUSnapshotInfo sn;
1494     char *filename, *snapshot_name = NULL;
1495     int c, ret = 0, bdrv_oflags;
1496     int action = 0;
1497     qemu_timeval tv;
1498
1499     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1500     /* Parse commandline parameters */
1501     for(;;) {
1502         c = getopt(argc, argv, "la:c:d:h");
1503         if (c == -1) {
1504             break;
1505         }
1506         switch(c) {
1507         case '?':
1508         case 'h':
1509             help();
1510             return 0;
1511         case 'l':
1512             if (action) {
1513                 help();
1514                 return 0;
1515             }
1516             action = SNAPSHOT_LIST;
1517             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1518             break;
1519         case 'a':
1520             if (action) {
1521                 help();
1522                 return 0;
1523             }
1524             action = SNAPSHOT_APPLY;
1525             snapshot_name = optarg;
1526             break;
1527         case 'c':
1528             if (action) {
1529                 help();
1530                 return 0;
1531             }
1532             action = SNAPSHOT_CREATE;
1533             snapshot_name = optarg;
1534             break;
1535         case 'd':
1536             if (action) {
1537                 help();
1538                 return 0;
1539             }
1540             action = SNAPSHOT_DELETE;
1541             snapshot_name = optarg;
1542             break;
1543         }
1544     }
1545
1546     if (optind >= argc) {
1547         help();
1548     }
1549     filename = argv[optind++];
1550
1551     /* Open the image */
1552     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1553     if (!bs) {
1554         return 1;
1555     }
1556
1557     /* Perform the requested action */
1558     switch(action) {
1559     case SNAPSHOT_LIST:
1560         dump_snapshots(bs);
1561         break;
1562
1563     case SNAPSHOT_CREATE:
1564         memset(&sn, 0, sizeof(sn));
1565         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1566
1567         qemu_gettimeofday(&tv);
1568         sn.date_sec = tv.tv_sec;
1569         sn.date_nsec = tv.tv_usec * 1000;
1570
1571         ret = bdrv_snapshot_create(bs, &sn);
1572         if (ret) {
1573             error_report("Could not create snapshot '%s': %d (%s)",
1574                 snapshot_name, ret, strerror(-ret));
1575         }
1576         break;
1577
1578     case SNAPSHOT_APPLY:
1579         ret = bdrv_snapshot_goto(bs, snapshot_name);
1580         if (ret) {
1581             error_report("Could not apply snapshot '%s': %d (%s)",
1582                 snapshot_name, ret, strerror(-ret));
1583         }
1584         break;
1585
1586     case SNAPSHOT_DELETE:
1587         ret = bdrv_snapshot_delete(bs, snapshot_name);
1588         if (ret) {
1589             error_report("Could not delete snapshot '%s': %d (%s)",
1590                 snapshot_name, ret, strerror(-ret));
1591         }
1592         break;
1593     }
1594
1595     /* Cleanup */
1596     bdrv_delete(bs);
1597     if (ret) {
1598         return 1;
1599     }
1600     return 0;
1601 }
1602
1603 static int img_rebase(int argc, char **argv)
1604 {
1605     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1606     BlockDriver *old_backing_drv, *new_backing_drv;
1607     char *filename;
1608     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1609     int c, flags, ret;
1610     int unsafe = 0;
1611     int progress = 0;
1612
1613     /* Parse commandline parameters */
1614     fmt = NULL;
1615     cache = BDRV_DEFAULT_CACHE;
1616     out_baseimg = NULL;
1617     out_basefmt = NULL;
1618     for(;;) {
1619         c = getopt(argc, argv, "uhf:F:b:pt:");
1620         if (c == -1) {
1621             break;
1622         }
1623         switch(c) {
1624         case '?':
1625         case 'h':
1626             help();
1627             return 0;
1628         case 'f':
1629             fmt = optarg;
1630             break;
1631         case 'F':
1632             out_basefmt = optarg;
1633             break;
1634         case 'b':
1635             out_baseimg = optarg;
1636             break;
1637         case 'u':
1638             unsafe = 1;
1639             break;
1640         case 'p':
1641             progress = 1;
1642             break;
1643         case 't':
1644             cache = optarg;
1645             break;
1646         }
1647     }
1648
1649     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1650         help();
1651     }
1652     filename = argv[optind++];
1653
1654     qemu_progress_init(progress, 2.0);
1655     qemu_progress_print(0, 100);
1656
1657     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1658     ret = bdrv_parse_cache_flags(cache, &flags);
1659     if (ret < 0) {
1660         error_report("Invalid cache option: %s", cache);
1661         return -1;
1662     }
1663
1664     /*
1665      * Open the images.
1666      *
1667      * Ignore the old backing file for unsafe rebase in case we want to correct
1668      * the reference to a renamed or moved backing file.
1669      */
1670     bs = bdrv_new_open(filename, fmt, flags, true);
1671     if (!bs) {
1672         return 1;
1673     }
1674
1675     /* Find the right drivers for the backing files */
1676     old_backing_drv = NULL;
1677     new_backing_drv = NULL;
1678
1679     if (!unsafe && bs->backing_format[0] != '\0') {
1680         old_backing_drv = bdrv_find_format(bs->backing_format);
1681         if (old_backing_drv == NULL) {
1682             error_report("Invalid format name: '%s'", bs->backing_format);
1683             ret = -1;
1684             goto out;
1685         }
1686     }
1687
1688     if (out_basefmt != NULL) {
1689         new_backing_drv = bdrv_find_format(out_basefmt);
1690         if (new_backing_drv == NULL) {
1691             error_report("Invalid format name: '%s'", out_basefmt);
1692             ret = -1;
1693             goto out;
1694         }
1695     }
1696
1697     /* For safe rebasing we need to compare old and new backing file */
1698     if (unsafe) {
1699         /* Make the compiler happy */
1700         bs_old_backing = NULL;
1701         bs_new_backing = NULL;
1702     } else {
1703         char backing_name[1024];
1704
1705         bs_old_backing = bdrv_new("old_backing");
1706         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1707         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1708                         old_backing_drv);
1709         if (ret) {
1710             error_report("Could not open old backing file '%s'", backing_name);
1711             goto out;
1712         }
1713         if (out_baseimg[0]) {
1714             bs_new_backing = bdrv_new("new_backing");
1715             ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1716                         new_backing_drv);
1717             if (ret) {
1718                 error_report("Could not open new backing file '%s'",
1719                              out_baseimg);
1720                 goto out;
1721             }
1722         }
1723     }
1724
1725     /*
1726      * Check each unallocated cluster in the COW file. If it is unallocated,
1727      * accesses go to the backing file. We must therefore compare this cluster
1728      * in the old and new backing file, and if they differ we need to copy it
1729      * from the old backing file into the COW file.
1730      *
1731      * If qemu-img crashes during this step, no harm is done. The content of
1732      * the image is the same as the original one at any time.
1733      */
1734     if (!unsafe) {
1735         uint64_t num_sectors;
1736         uint64_t old_backing_num_sectors;
1737         uint64_t new_backing_num_sectors = 0;
1738         uint64_t sector;
1739         int n;
1740         uint8_t * buf_old;
1741         uint8_t * buf_new;
1742         float local_progress = 0;
1743
1744         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1745         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
1746
1747         bdrv_get_geometry(bs, &num_sectors);
1748         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1749         if (bs_new_backing) {
1750             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
1751         }
1752
1753         if (num_sectors != 0) {
1754             local_progress = (float)100 /
1755                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1756         }
1757
1758         for (sector = 0; sector < num_sectors; sector += n) {
1759
1760             /* How many sectors can we handle with the next read? */
1761             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1762                 n = (IO_BUF_SIZE / 512);
1763             } else {
1764                 n = num_sectors - sector;
1765             }
1766
1767             /* If the cluster is allocated, we don't need to take action */
1768             ret = bdrv_is_allocated(bs, sector, n, &n);
1769             if (ret) {
1770                 continue;
1771             }
1772
1773             /*
1774              * Read old and new backing file and take into consideration that
1775              * backing files may be smaller than the COW image.
1776              */
1777             if (sector >= old_backing_num_sectors) {
1778                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1779             } else {
1780                 if (sector + n > old_backing_num_sectors) {
1781                     n = old_backing_num_sectors - sector;
1782                 }
1783
1784                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1785                 if (ret < 0) {
1786                     error_report("error while reading from old backing file");
1787                     goto out;
1788                 }
1789             }
1790
1791             if (sector >= new_backing_num_sectors || !bs_new_backing) {
1792                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1793             } else {
1794                 if (sector + n > new_backing_num_sectors) {
1795                     n = new_backing_num_sectors - sector;
1796                 }
1797
1798                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1799                 if (ret < 0) {
1800                     error_report("error while reading from new backing file");
1801                     goto out;
1802                 }
1803             }
1804
1805             /* If they differ, we need to write to the COW file */
1806             uint64_t written = 0;
1807
1808             while (written < n) {
1809                 int pnum;
1810
1811                 if (compare_sectors(buf_old + written * 512,
1812                     buf_new + written * 512, n - written, &pnum))
1813                 {
1814                     ret = bdrv_write(bs, sector + written,
1815                         buf_old + written * 512, pnum);
1816                     if (ret < 0) {
1817                         error_report("Error while writing to COW image: %s",
1818                             strerror(-ret));
1819                         goto out;
1820                     }
1821                 }
1822
1823                 written += pnum;
1824             }
1825             qemu_progress_print(local_progress, 100);
1826         }
1827
1828         qemu_vfree(buf_old);
1829         qemu_vfree(buf_new);
1830     }
1831
1832     /*
1833      * Change the backing file. All clusters that are different from the old
1834      * backing file are overwritten in the COW file now, so the visible content
1835      * doesn't change when we switch the backing file.
1836      */
1837     if (out_baseimg && *out_baseimg) {
1838         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1839     } else {
1840         ret = bdrv_change_backing_file(bs, NULL, NULL);
1841     }
1842
1843     if (ret == -ENOSPC) {
1844         error_report("Could not change the backing file to '%s': No "
1845                      "space left in the file header", out_baseimg);
1846     } else if (ret < 0) {
1847         error_report("Could not change the backing file to '%s': %s",
1848             out_baseimg, strerror(-ret));
1849     }
1850
1851     qemu_progress_print(100, 0);
1852     /*
1853      * TODO At this point it is possible to check if any clusters that are
1854      * allocated in the COW file are the same in the backing file. If so, they
1855      * could be dropped from the COW file. Don't do this before switching the
1856      * backing file, in case of a crash this would lead to corruption.
1857      */
1858 out:
1859     qemu_progress_end();
1860     /* Cleanup */
1861     if (!unsafe) {
1862         if (bs_old_backing != NULL) {
1863             bdrv_delete(bs_old_backing);
1864         }
1865         if (bs_new_backing != NULL) {
1866             bdrv_delete(bs_new_backing);
1867         }
1868     }
1869
1870     bdrv_delete(bs);
1871     if (ret) {
1872         return 1;
1873     }
1874     return 0;
1875 }
1876
1877 static int img_resize(int argc, char **argv)
1878 {
1879     int c, ret, relative;
1880     const char *filename, *fmt, *size;
1881     int64_t n, total_size;
1882     BlockDriverState *bs = NULL;
1883     QemuOpts *param;
1884     static QemuOptsList resize_options = {
1885         .name = "resize_options",
1886         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
1887         .desc = {
1888             {
1889                 .name = BLOCK_OPT_SIZE,
1890                 .type = QEMU_OPT_SIZE,
1891                 .help = "Virtual disk size"
1892             }, {
1893                 /* end of list */
1894             }
1895         },
1896     };
1897
1898     /* Remove size from argv manually so that negative numbers are not treated
1899      * as options by getopt. */
1900     if (argc < 3) {
1901         help();
1902         return 1;
1903     }
1904
1905     size = argv[--argc];
1906
1907     /* Parse getopt arguments */
1908     fmt = NULL;
1909     for(;;) {
1910         c = getopt(argc, argv, "f:h");
1911         if (c == -1) {
1912             break;
1913         }
1914         switch(c) {
1915         case '?':
1916         case 'h':
1917             help();
1918             break;
1919         case 'f':
1920             fmt = optarg;
1921             break;
1922         }
1923     }
1924     if (optind >= argc) {
1925         help();
1926     }
1927     filename = argv[optind++];
1928
1929     /* Choose grow, shrink, or absolute resize mode */
1930     switch (size[0]) {
1931     case '+':
1932         relative = 1;
1933         size++;
1934         break;
1935     case '-':
1936         relative = -1;
1937         size++;
1938         break;
1939     default:
1940         relative = 0;
1941         break;
1942     }
1943
1944     /* Parse size */
1945     param = qemu_opts_create_nofail(&resize_options);
1946     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1947         /* Error message already printed when size parsing fails */
1948         ret = -1;
1949         qemu_opts_del(param);
1950         goto out;
1951     }
1952     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
1953     qemu_opts_del(param);
1954
1955     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1956     if (!bs) {
1957         ret = -1;
1958         goto out;
1959     }
1960
1961     if (relative) {
1962         total_size = bdrv_getlength(bs) + n * relative;
1963     } else {
1964         total_size = n;
1965     }
1966     if (total_size <= 0) {
1967         error_report("New image size must be positive");
1968         ret = -1;
1969         goto out;
1970     }
1971
1972     ret = bdrv_truncate(bs, total_size);
1973     switch (ret) {
1974     case 0:
1975         printf("Image resized.\n");
1976         break;
1977     case -ENOTSUP:
1978         error_report("This image does not support resize");
1979         break;
1980     case -EACCES:
1981         error_report("Image is read-only");
1982         break;
1983     default:
1984         error_report("Error resizing image (%d)", -ret);
1985         break;
1986     }
1987 out:
1988     if (bs) {
1989         bdrv_delete(bs);
1990     }
1991     if (ret) {
1992         return 1;
1993     }
1994     return 0;
1995 }
1996
1997 static const img_cmd_t img_cmds[] = {
1998 #define DEF(option, callback, arg_string)        \
1999     { option, callback },
2000 #include "qemu-img-cmds.h"
2001 #undef DEF
2002 #undef GEN_DOCS
2003     { NULL, NULL, },
2004 };
2005
2006 int main(int argc, char **argv)
2007 {
2008     const img_cmd_t *cmd;
2009     const char *cmdname;
2010
2011     error_set_progname(argv[0]);
2012
2013     qemu_init_main_loop();
2014     bdrv_init();
2015     if (argc < 2)
2016         help();
2017     cmdname = argv[1];
2018     argc--; argv++;
2019
2020     /* find the command */
2021     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2022         if (!strcmp(cmdname, cmd->name)) {
2023             return cmd->handler(argc, argv);
2024         }
2025     }
2026
2027     /* not found */
2028     help();
2029     return 0;
2030 }