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     bdrv_delete(bs);
 479
 480     if (ret < 0 || result.check_errors) {
 481         printf("\nAn error has occurred during the check: %s\n"
 482             "The check is not complete and may have missed error.\n",
 483             strerror(-ret));
 484         return 1;
 485     }
 486
 487     if (result.corruptions) {
 488         return 2;
 489     } else if (result.leaks) {
 490         return 3;
 491     } else {
 492         return 0;
 493     }
 494 }
 495
 496 static int img_commit(int argc, char **argv)
 497 {
 498     int c, ret, flags;
 499     const char *filename, *fmt, *cache;
 500     BlockDriverState *bs;
 501
 502     fmt = NULL;
 503     cache = BDRV_DEFAULT_CACHE;
 504     for(;;) {
 505         c = getopt(argc, argv, "f:ht:");
 506         if (c == -1) {
 507             break;
 508         }
 509         switch(c) {
 510         case '?':
 511         case 'h':
 512             help();
 513             break;
 514         case 'f':
 515             fmt = optarg;
 516             break;
 517         case 't':
 518             cache = optarg;
 519             break;
 520         }
 521     }
 522     if (optind >= argc) {
 523         help();
 524     }
 525     filename = argv[optind++];
 526
 527     flags = BDRV_O_RDWR;
 528     ret = bdrv_parse_cache_flags(cache, &flags);
 529     if (ret < 0) {
 530         error_report("Invalid cache option: %s", cache);
 531         return -1;
 532     }
 533
 534     bs = bdrv_new_open(filename, fmt, flags, true);
 535     if (!bs) {
 536         return 1;
 537     }
 538     ret = bdrv_commit(bs);
 539     switch(ret) {
 540     case 0:
 541         printf("Image committed.\n");
 542         break;
 543     case -ENOENT:
 544         error_report("No disk inserted");
 545         break;
 546     case -EACCES:
 547         error_report("Image is read-only");
 548         break;
 549     case -ENOTSUP:
 550         error_report("Image is already committed");
 551         break;
 552     default:
 553         error_report("Error while committing image");
 554         break;
 555     }
 556
 557     bdrv_delete(bs);
 558     if (ret) {
 559         return 1;
 560     }
 561     return 0;
 562 }
 563
 564 /*
 565  * Returns true iff the first sector pointed to by 'buf' contains at least
 566  * a non-NUL byte.
 567  *
 568  * 'pnum' is set to the number of sectors (including and immediately following
 569  * the first one) that are known to be in the same allocated/unallocated state.
 570  */
 571 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 572 {
 573     bool is_zero;
 574     int i;
 575
 576     if (n <= 0) {
 577         *pnum = 0;
 578         return 0;
 579     }
 580     is_zero = buffer_is_zero(buf, 512);
 581     for(i = 1; i < n; i++) {
 582         buf += 512;
 583         if (is_zero != buffer_is_zero(buf, 512)) {
 584             break;
 585         }
 586     }
 587     *pnum = i;
 588     return !is_zero;
 589 }
 590
 591 /*
 592  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 593  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 594  * breaking up write requests for only small sparse areas.
 595  */
 596 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 597     int min)
 598 {
 599     int ret;
 600     int num_checked, num_used;
 601
 602     if (n < min) {
 603         min = n;
 604     }
 605
 606     ret = is_allocated_sectors(buf, n, pnum);
 607     if (!ret) {
 608         return ret;
 609     }
 610
 611     num_used = *pnum;
 612     buf += BDRV_SECTOR_SIZE * *pnum;
 613     n -= *pnum;
 614     num_checked = num_used;
 615
 616     while (n > 0) {
 617         ret = is_allocated_sectors(buf, n, pnum);
 618
 619         buf += BDRV_SECTOR_SIZE * *pnum;
 620         n -= *pnum;
 621         num_checked += *pnum;
 622         if (ret) {
 623             num_used = num_checked;
 624         } else if (*pnum >= min) {
 625             break;
 626         }
 627     }
 628
 629     *pnum = num_used;
 630     return 1;
 631 }
 632
 633 /*
 634  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 635  * buffers matches, non-zero otherwise.
 636  *
 637  * pnum is set to the number of sectors (including and immediately following
 638  * the first one) that are known to have the same comparison result
 639  */
 640 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 641     int *pnum)
 642 {
 643     int res, i;
 644
 645     if (n <= 0) {
 646         *pnum = 0;
 647         return 0;
 648     }
 649
 650     res = !!memcmp(buf1, buf2, 512);
 651     for(i = 1; i < n; i++) {
 652         buf1 += 512;
 653         buf2 += 512;
 654
 655         if (!!memcmp(buf1, buf2, 512) != res) {
 656             break;
 657         }
 658     }
 659
 660     *pnum = i;
 661     return res;
 662 }
 663
 664 #define IO_BUF_SIZE (2 * 1024 * 1024)
 665
 666 static int img_convert(int argc, char **argv)
 667 {
 668     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
 669     int progress = 0, flags;
 670     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
 671     BlockDriver *drv, *proto_drv;
 672     BlockDriverState **bs = NULL, *out_bs = NULL;
 673     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
 674     uint64_t bs_sectors;
 675     uint8_t * buf = NULL;
 676     const uint8_t *buf1;
 677     BlockDriverInfo bdi;
 678     QEMUOptionParameter *param = NULL, *create_options = NULL;
 679     QEMUOptionParameter *out_baseimg_param;
 680     char *options = NULL;
 681     const char *snapshot_name = NULL;
 682     float local_progress = 0;
 683     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
 684
 685     fmt = NULL;
 686     out_fmt = "raw";
 687     cache = "unsafe";
 688     out_baseimg = NULL;
 689     compress = 0;
 690     for(;;) {
 691         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
 692         if (c == -1) {
 693             break;
 694         }
 695         switch(c) {
 696         case '?':
 697         case 'h':
 698             help();
 699             break;
 700         case 'f':
 701             fmt = optarg;
 702             break;
 703         case 'O':
 704             out_fmt = optarg;
 705             break;
 706         case 'B':
 707             out_baseimg = optarg;
 708             break;
 709         case 'c':
 710             compress = 1;
 711             break;
 712         case 'e':
 713             error_report("option -e is deprecated, please use \'-o "
 714                   "encryption\' instead!");
 715             return 1;
 716         case '6':
 717             error_report("option -6 is deprecated, please use \'-o "
 718                   "compat6\' instead!");
 719             return 1;
 720         case 'o':
 721             options = optarg;
 722             break;
 723         case 's':
 724             snapshot_name = optarg;
 725             break;
 726         case 'S':
 727         {
 728             int64_t sval;
 729             char *end;
 730             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
 731             if (sval < 0 || *end) {
 732                 error_report("Invalid minimum zero buffer size for sparse output specified");
 733                 return 1;
 734             }
 735
 736             min_sparse = sval / BDRV_SECTOR_SIZE;
 737             break;
 738         }
 739         case 'p':
 740             progress = 1;
 741             break;
 742         case 't':
 743             cache = optarg;
 744             break;
 745         }
 746     }
 747
 748     bs_n = argc - optind - 1;
 749     if (bs_n < 1) {
 750         help();
 751     }
 752
 753     out_filename = argv[argc - 1];
 754
 755     /* Initialize before goto out */
 756     qemu_progress_init(progress, 2.0);
 757
 758     if (options && is_help_option(options)) {
 759         ret = print_block_option_help(out_filename, out_fmt);
 760         goto out;
 761     }
 762
 763     if (bs_n > 1 && out_baseimg) {
 764         error_report("-B makes no sense when concatenating multiple input "
 765                      "images");
 766         ret = -1;
 767         goto out;
 768     }
 769
 770     qemu_progress_print(0, 100);
 771
 772     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
 773
 774     total_sectors = 0;
 775     for (bs_i = 0; bs_i < bs_n; bs_i++) {
 776         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
 777         if (!bs[bs_i]) {
 778             error_report("Could not open '%s'", argv[optind + bs_i]);
 779             ret = -1;
 780             goto out;
 781         }
 782         bdrv_get_geometry(bs[bs_i], &bs_sectors);
 783         total_sectors += bs_sectors;
 784     }
 785
 786     if (snapshot_name != NULL) {
 787         if (bs_n > 1) {
 788             error_report("No support for concatenating multiple snapshot");
 789             ret = -1;
 790             goto out;
 791         }
 792         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
 793             error_report("Failed to load snapshot");
 794             ret = -1;
 795             goto out;
 796         }
 797     }
 798
 799     /* Find driver and parse its options */
 800     drv = bdrv_find_format(out_fmt);
 801     if (!drv) {
 802         error_report("Unknown file format '%s'", out_fmt);
 803         ret = -1;
 804         goto out;
 805     }
 806
 807     proto_drv = bdrv_find_protocol(out_filename);
 808     if (!proto_drv) {
 809         error_report("Unknown protocol '%s'", out_filename);
 810         ret = -1;
 811         goto out;
 812     }
 813
 814     create_options = append_option_parameters(create_options,
 815                                               drv->create_options);
 816     create_options = append_option_parameters(create_options,
 817                                               proto_drv->create_options);
 818
 819     if (options) {
 820         param = parse_option_parameters(options, create_options, param);
 821         if (param == NULL) {
 822             error_report("Invalid options for file format '%s'.", out_fmt);
 823             ret = -1;
 824             goto out;
 825         }
 826     } else {
 827         param = parse_option_parameters("", create_options, param);
 828     }
 829
 830     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
 831     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
 832     if (ret < 0) {
 833         goto out;
 834     }
 835
 836     /* Get backing file name if -o backing_file was used */
 837     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
 838     if (out_baseimg_param) {
 839         out_baseimg = out_baseimg_param->value.s;
 840     }
 841
 842     /* Check if compression is supported */
 843     if (compress) {
 844         QEMUOptionParameter *encryption =
 845             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
 846         QEMUOptionParameter *preallocation =
 847             get_option_parameter(param, BLOCK_OPT_PREALLOC);
 848
 849         if (!drv->bdrv_write_compressed) {
 850             error_report("Compression not supported for this file format");
 851             ret = -1;
 852             goto out;
 853         }
 854
 855         if (encryption && encryption->value.n) {
 856             error_report("Compression and encryption not supported at "
 857                          "the same time");
 858             ret = -1;
 859             goto out;
 860         }
 861
 862         if (preallocation && preallocation->value.s
 863             && strcmp(preallocation->value.s, "off"))
 864         {
 865             error_report("Compression and preallocation not supported at "
 866                          "the same time");
 867             ret = -1;
 868             goto out;
 869         }
 870     }
 871
 872     /* Create the new image */
 873     ret = bdrv_create(drv, out_filename, param);
 874     if (ret < 0) {
 875         if (ret == -ENOTSUP) {
 876             error_report("Formatting not supported for file format '%s'",
 877                          out_fmt);
 878         } else if (ret == -EFBIG) {
 879             error_report("The image size is too large for file format '%s'",
 880                          out_fmt);
 881         } else {
 882             error_report("%s: error while converting %s: %s",
 883                          out_filename, out_fmt, strerror(-ret));
 884         }
 885         goto out;
 886     }
 887
 888     flags = BDRV_O_RDWR;
 889     ret = bdrv_parse_cache_flags(cache, &flags);
 890     if (ret < 0) {
 891         error_report("Invalid cache option: %s", cache);
 892         return -1;
 893     }
 894
 895     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
 896     if (!out_bs) {
 897         ret = -1;
 898         goto out;
 899     }
 900
 901     bs_i = 0;
 902     bs_offset = 0;
 903     bdrv_get_geometry(bs[0], &bs_sectors);
 904     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
 905
 906     if (compress) {
 907         ret = bdrv_get_info(out_bs, &bdi);
 908         if (ret < 0) {
 909             error_report("could not get block driver info");
 910             goto out;
 911         }
 912         cluster_size = bdi.cluster_size;
 913         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
 914             error_report("invalid cluster size");
 915             ret = -1;
 916             goto out;
 917         }
 918         cluster_sectors = cluster_size >> 9;
 919         sector_num = 0;
 920
 921         nb_sectors = total_sectors;
 922         if (nb_sectors != 0) {
 923             local_progress = (float)100 /
 924                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
 925         }
 926
 927         for(;;) {
 928             int64_t bs_num;
 929             int remainder;
 930             uint8_t *buf2;
 931
 932             nb_sectors = total_sectors - sector_num;
 933             if (nb_sectors <= 0)
 934                 break;
 935             if (nb_sectors >= cluster_sectors)
 936                 n = cluster_sectors;
 937             else
 938                 n = nb_sectors;
 939
 940             bs_num = sector_num - bs_offset;
 941             assert (bs_num >= 0);
 942             remainder = n;
 943             buf2 = buf;
 944             while (remainder > 0) {
 945                 int nlow;
 946                 while (bs_num == bs_sectors) {
 947                     bs_i++;
 948                     assert (bs_i < bs_n);
 949                     bs_offset += bs_sectors;
 950                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
 951                     bs_num = 0;
 952                     /* printf("changing part: sector_num=%" PRId64 ", "
 953                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
 954                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
 955                 }
 956                 assert (bs_num < bs_sectors);
 957
 958                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
 959
 960                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
 961                 if (ret < 0) {
 962                     error_report("error while reading sector %" PRId64 ": %s",
 963                                  bs_num, strerror(-ret));
 964                     goto out;
 965                 }
 966
 967                 buf2 += nlow * 512;
 968                 bs_num += nlow;
 969
 970                 remainder -= nlow;
 971             }
 972             assert (remainder == 0);
 973
 974             if (n < cluster_sectors) {
 975                 memset(buf + n * 512, 0, cluster_size - n * 512);
 976             }
 977             if (!buffer_is_zero(buf, cluster_size)) {
 978                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
 979                                             cluster_sectors);
 980                 if (ret != 0) {
 981                     error_report("error while compressing sector %" PRId64
 982                                  ": %s", sector_num, strerror(-ret));
 983                     goto out;
 984                 }
 985             }
 986             sector_num += n;
 987             qemu_progress_print(local_progress, 100);
 988         }
 989         /* signal EOF to align */
 990         bdrv_write_compressed(out_bs, 0, NULL, 0);
 991     } else {
 992         int has_zero_init = bdrv_has_zero_init(out_bs);
 993
 994         sector_num = 0; // total number of sectors converted so far
 995         nb_sectors = total_sectors - sector_num;
 996         if (nb_sectors != 0) {
 997             local_progress = (float)100 /
 998                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
 999         }
1000
1001         for(;;) {
1002             nb_sectors = total_sectors - sector_num;
1003             if (nb_sectors <= 0) {
1004                 break;
1005             }
1006             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1007                 n = (IO_BUF_SIZE / 512);
1008             } else {
1009                 n = nb_sectors;
1010             }
1011
1012             while (sector_num - bs_offset >= bs_sectors) {
1013                 bs_i ++;
1014                 assert (bs_i < bs_n);
1015                 bs_offset += bs_sectors;
1016                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1017                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1018                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1019                    sector_num, bs_i, bs_offset, bs_sectors); */
1020             }
1021
1022             if (n > bs_offset + bs_sectors - sector_num) {
1023                 n = bs_offset + bs_sectors - sector_num;
1024             }
1025
1026             if (has_zero_init) {
1027                 /* If the output image is being created as a copy on write image,
1028                    assume that sectors which are unallocated in the input image
1029                    are present in both the output's and input's base images (no
1030                    need to copy them). */
1031                 if (out_baseimg) {
1032                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1033                                            n, &n1)) {
1034                         sector_num += n1;
1035                         continue;
1036                     }
1037                     /* The next 'n1' sectors are allocated in the input image. Copy
1038                        only those as they may be followed by unallocated sectors. */
1039                     n = n1;
1040                 }
1041             } else {
1042                 n1 = n;
1043             }
1044
1045             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1046             if (ret < 0) {
1047                 error_report("error while reading sector %" PRId64 ": %s",
1048                              sector_num - bs_offset, strerror(-ret));
1049                 goto out;
1050             }
1051             /* NOTE: at the same time we convert, we do not write zero
1052                sectors to have a chance to compress the image. Ideally, we
1053                should add a specific call to have the info to go faster */
1054             buf1 = buf;
1055             while (n > 0) {
1056                 /* If the output image is being created as a copy on write image,
1057                    copy all sectors even the ones containing only NUL bytes,
1058                    because they may differ from the sectors in the base image.
1059
1060                    If the output is to a host device, we also write out
1061                    sectors that are entirely 0, since whatever data was
1062                    already there is garbage, not 0s. */
1063                 if (!has_zero_init || out_baseimg ||
1064                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1065                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1066                     if (ret < 0) {
1067                         error_report("error while writing sector %" PRId64
1068                                      ": %s", sector_num, strerror(-ret));
1069                         goto out;
1070                     }
1071                 }
1072                 sector_num += n1;
1073                 n -= n1;
1074                 buf1 += n1 * 512;
1075             }
1076             qemu_progress_print(local_progress, 100);
1077         }
1078     }
1079 out:
1080     qemu_progress_end();
1081     free_option_parameters(create_options);
1082     free_option_parameters(param);
1083     qemu_vfree(buf);
1084     if (out_bs) {
1085         bdrv_delete(out_bs);
1086     }
1087     if (bs) {
1088         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1089             if (bs[bs_i]) {
1090                 bdrv_delete(bs[bs_i]);
1091             }
1092         }
1093         g_free(bs);
1094     }
1095     if (ret) {
1096         return 1;
1097     }
1098     return 0;
1099 }
1100
1101
1102 static void dump_snapshots(BlockDriverState *bs)
1103 {
1104     QEMUSnapshotInfo *sn_tab, *sn;
1105     int nb_sns, i;
1106     char buf[256];
1107
1108     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1109     if (nb_sns <= 0)
1110         return;
1111     printf("Snapshot list:\n");
1112     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1113     for(i = 0; i < nb_sns; i++) {
1114         sn = &sn_tab[i];
1115         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1116     }
1117     g_free(sn_tab);
1118 }
1119
1120 static void dump_json_image_info_list(ImageInfoList *list)
1121 {
1122     Error *errp = NULL;
1123     QString *str;
1124     QmpOutputVisitor *ov = qmp_output_visitor_new();
1125     QObject *obj;
1126     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1127                              &list, NULL, &errp);
1128     obj = qmp_output_get_qobject(ov);
1129     str = qobject_to_json_pretty(obj);
1130     assert(str != NULL);
1131     printf("%s\n", qstring_get_str(str));
1132     qobject_decref(obj);
1133     qmp_output_visitor_cleanup(ov);
1134     QDECREF(str);
1135 }
1136
1137 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1138 {
1139     int i, sn_count;
1140     QEMUSnapshotInfo *sn_tab = NULL;
1141     SnapshotInfoList *info_list, *cur_item = NULL;
1142     sn_count = bdrv_snapshot_list(bs, &sn_tab);
1143
1144     for (i = 0; i < sn_count; i++) {
1145         info->has_snapshots = true;
1146         info_list = g_new0(SnapshotInfoList, 1);
1147
1148         info_list->value                = g_new0(SnapshotInfo, 1);
1149         info_list->value->id            = g_strdup(sn_tab[i].id_str);
1150         info_list->value->name          = g_strdup(sn_tab[i].name);
1151         info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1152         info_list->value->date_sec      = sn_tab[i].date_sec;
1153         info_list->value->date_nsec     = sn_tab[i].date_nsec;
1154         info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
1155         info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1156
1157         /* XXX: waiting for the qapi to support qemu-queue.h types */
1158         if (!cur_item) {
1159             info->snapshots = cur_item = info_list;
1160         } else {
1161             cur_item->next = info_list;
1162             cur_item = info_list;
1163         }
1164
1165     }
1166
1167     g_free(sn_tab);
1168 }
1169
1170 static void dump_json_image_info(ImageInfo *info)
1171 {
1172     Error *errp = NULL;
1173     QString *str;
1174     QmpOutputVisitor *ov = qmp_output_visitor_new();
1175     QObject *obj;
1176     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1177                          &info, NULL, &errp);
1178     obj = qmp_output_get_qobject(ov);
1179     str = qobject_to_json_pretty(obj);
1180     assert(str != NULL);
1181     printf("%s\n", qstring_get_str(str));
1182     qobject_decref(obj);
1183     qmp_output_visitor_cleanup(ov);
1184     QDECREF(str);
1185 }
1186
1187 static void collect_image_info(BlockDriverState *bs,
1188                    ImageInfo *info,
1189                    const char *filename,
1190                    const char *fmt)
1191 {
1192     uint64_t total_sectors;
1193     char backing_filename[1024];
1194     char backing_filename2[1024];
1195     BlockDriverInfo bdi;
1196
1197     bdrv_get_geometry(bs, &total_sectors);
1198
1199     info->filename        = g_strdup(filename);
1200     info->format          = g_strdup(bdrv_get_format_name(bs));
1201     info->virtual_size    = total_sectors * 512;
1202     info->actual_size     = bdrv_get_allocated_file_size(bs);
1203     info->has_actual_size = info->actual_size >= 0;
1204     if (bdrv_is_encrypted(bs)) {
1205         info->encrypted = true;
1206         info->has_encrypted = true;
1207     }
1208     if (bdrv_get_info(bs, &bdi) >= 0) {
1209         if (bdi.cluster_size != 0) {
1210             info->cluster_size = bdi.cluster_size;
1211             info->has_cluster_size = true;
1212         }
1213         info->dirty_flag = bdi.is_dirty;
1214         info->has_dirty_flag = true;
1215     }
1216     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1217     if (backing_filename[0] != '\0') {
1218         info->backing_filename = g_strdup(backing_filename);
1219         info->has_backing_filename = true;
1220         bdrv_get_full_backing_filename(bs, backing_filename2,
1221                                        sizeof(backing_filename2));
1222
1223         if (strcmp(backing_filename, backing_filename2) != 0) {
1224             info->full_backing_filename =
1225                         g_strdup(backing_filename2);
1226             info->has_full_backing_filename = true;
1227         }
1228
1229         if (bs->backing_format[0]) {
1230             info->backing_filename_format = g_strdup(bs->backing_format);
1231             info->has_backing_filename_format = true;
1232         }
1233     }
1234 }
1235
1236 static void dump_human_image_info(ImageInfo *info)
1237 {
1238     char size_buf[128], dsize_buf[128];
1239     if (!info->has_actual_size) {
1240         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1241     } else {
1242         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1243                                 info->actual_size);
1244     }
1245     get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1246     printf("image: %s\n"
1247            "file format: %s\n"
1248            "virtual size: %s (%" PRId64 " bytes)\n"
1249            "disk size: %s\n",
1250            info->filename, info->format, size_buf,
1251            info->virtual_size,
1252            dsize_buf);
1253
1254     if (info->has_encrypted && info->encrypted) {
1255         printf("encrypted: yes\n");
1256     }
1257
1258     if (info->has_cluster_size) {
1259         printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1260     }
1261
1262     if (info->has_dirty_flag && info->dirty_flag) {
1263         printf("cleanly shut down: no\n");
1264     }
1265
1266     if (info->has_backing_filename) {
1267         printf("backing file: %s", info->backing_filename);
1268         if (info->has_full_backing_filename) {
1269             printf(" (actual path: %s)", info->full_backing_filename);
1270         }
1271         putchar('\n');
1272         if (info->has_backing_filename_format) {
1273             printf("backing file format: %s\n", info->backing_filename_format);
1274         }
1275     }
1276
1277     if (info->has_snapshots) {
1278         SnapshotInfoList *elem;
1279         char buf[256];
1280
1281         printf("Snapshot list:\n");
1282         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1283
1284         /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1285          * we convert to the block layer's native QEMUSnapshotInfo for now.
1286          */
1287         for (elem = info->snapshots; elem; elem = elem->next) {
1288             QEMUSnapshotInfo sn = {
1289                 .vm_state_size = elem->value->vm_state_size,
1290                 .date_sec = elem->value->date_sec,
1291                 .date_nsec = elem->value->date_nsec,
1292                 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1293                                  elem->value->vm_clock_nsec,
1294             };
1295
1296             pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1297             pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1298             printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1299         }
1300     }
1301 }
1302
1303 static void dump_human_image_info_list(ImageInfoList *list)
1304 {
1305     ImageInfoList *elem;
1306     bool delim = false;
1307
1308     for (elem = list; elem; elem = elem->next) {
1309         if (delim) {
1310             printf("\n");
1311         }
1312         delim = true;
1313
1314         dump_human_image_info(elem->value);
1315     }
1316 }
1317
1318 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1319 {
1320     return strcmp(a, b) == 0;
1321 }
1322
1323 /**
1324  * Open an image file chain and return an ImageInfoList
1325  *
1326  * @filename: topmost image filename
1327  * @fmt: topmost image format (may be NULL to autodetect)
1328  * @chain: true  - enumerate entire backing file chain
1329  *         false - only topmost image file
1330  *
1331  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1332  * image file.  If there was an error a message will have been printed to
1333  * stderr.
1334  */
1335 static ImageInfoList *collect_image_info_list(const char *filename,
1336                                               const char *fmt,
1337                                               bool chain)
1338 {
1339     ImageInfoList *head = NULL;
1340     ImageInfoList **last = &head;
1341     GHashTable *filenames;
1342
1343     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1344
1345     while (filename) {
1346         BlockDriverState *bs;
1347         ImageInfo *info;
1348         ImageInfoList *elem;
1349
1350         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1351             error_report("Backing file '%s' creates an infinite loop.",
1352                          filename);
1353             goto err;
1354         }
1355         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1356
1357         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1358                            false);
1359         if (!bs) {
1360             goto err;
1361         }
1362
1363         info = g_new0(ImageInfo, 1);
1364         collect_image_info(bs, info, filename, fmt);
1365         collect_snapshots(bs, info);
1366
1367         elem = g_new0(ImageInfoList, 1);
1368         elem->value = info;
1369         *last = elem;
1370         last = &elem->next;
1371
1372         bdrv_delete(bs);
1373
1374         filename = fmt = NULL;
1375         if (chain) {
1376             if (info->has_full_backing_filename) {
1377                 filename = info->full_backing_filename;
1378             } else if (info->has_backing_filename) {
1379                 filename = info->backing_filename;
1380             }
1381             if (info->has_backing_filename_format) {
1382                 fmt = info->backing_filename_format;
1383             }
1384         }
1385     }
1386     g_hash_table_destroy(filenames);
1387     return head;
1388
1389 err:
1390     qapi_free_ImageInfoList(head);
1391     g_hash_table_destroy(filenames);
1392     return NULL;
1393 }
1394
1395 enum {
1396     OPTION_OUTPUT = 256,
1397     OPTION_BACKING_CHAIN = 257,
1398 };
1399
1400 typedef enum OutputFormat {
1401     OFORMAT_JSON,
1402     OFORMAT_HUMAN,
1403 } OutputFormat;
1404
1405 static int img_info(int argc, char **argv)
1406 {
1407     int c;
1408     OutputFormat output_format = OFORMAT_HUMAN;
1409     bool chain = false;
1410     const char *filename, *fmt, *output;
1411     ImageInfoList *list;
1412
1413     fmt = NULL;
1414     output = NULL;
1415     for(;;) {
1416         int option_index = 0;
1417         static const struct option long_options[] = {
1418             {"help", no_argument, 0, 'h'},
1419             {"format", required_argument, 0, 'f'},
1420             {"output", required_argument, 0, OPTION_OUTPUT},
1421             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1422             {0, 0, 0, 0}
1423         };
1424         c = getopt_long(argc, argv, "f:h",
1425                         long_options, &option_index);
1426         if (c == -1) {
1427             break;
1428         }
1429         switch(c) {
1430         case '?':
1431         case 'h':
1432             help();
1433             break;
1434         case 'f':
1435             fmt = optarg;
1436             break;
1437         case OPTION_OUTPUT:
1438             output = optarg;
1439             break;
1440         case OPTION_BACKING_CHAIN:
1441             chain = true;
1442             break;
1443         }
1444     }
1445     if (optind >= argc) {
1446         help();
1447     }
1448     filename = argv[optind++];
1449
1450     if (output && !strcmp(output, "json")) {
1451         output_format = OFORMAT_JSON;
1452     } else if (output && !strcmp(output, "human")) {
1453         output_format = OFORMAT_HUMAN;
1454     } else if (output) {
1455         error_report("--output must be used with human or json as argument.");
1456         return 1;
1457     }
1458
1459     list = collect_image_info_list(filename, fmt, chain);
1460     if (!list) {
1461         return 1;
1462     }
1463
1464     switch (output_format) {
1465     case OFORMAT_HUMAN:
1466         dump_human_image_info_list(list);
1467         break;
1468     case OFORMAT_JSON:
1469         if (chain) {
1470             dump_json_image_info_list(list);
1471         } else {
1472             dump_json_image_info(list->value);
1473         }
1474         break;
1475     }
1476
1477     qapi_free_ImageInfoList(list);
1478     return 0;
1479 }
1480
1481 #define SNAPSHOT_LIST   1
1482 #define SNAPSHOT_CREATE 2
1483 #define SNAPSHOT_APPLY  3
1484 #define SNAPSHOT_DELETE 4
1485
1486 static int img_snapshot(int argc, char **argv)
1487 {
1488     BlockDriverState *bs;
1489     QEMUSnapshotInfo sn;
1490     char *filename, *snapshot_name = NULL;
1491     int c, ret = 0, bdrv_oflags;
1492     int action = 0;
1493     qemu_timeval tv;
1494
1495     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1496     /* Parse commandline parameters */
1497     for(;;) {
1498         c = getopt(argc, argv, "la:c:d:h");
1499         if (c == -1) {
1500             break;
1501         }
1502         switch(c) {
1503         case '?':
1504         case 'h':
1505             help();
1506             return 0;
1507         case 'l':
1508             if (action) {
1509                 help();
1510                 return 0;
1511             }
1512             action = SNAPSHOT_LIST;
1513             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1514             break;
1515         case 'a':
1516             if (action) {
1517                 help();
1518                 return 0;
1519             }
1520             action = SNAPSHOT_APPLY;
1521             snapshot_name = optarg;
1522             break;
1523         case 'c':
1524             if (action) {
1525                 help();
1526                 return 0;
1527             }
1528             action = SNAPSHOT_CREATE;
1529             snapshot_name = optarg;
1530             break;
1531         case 'd':
1532             if (action) {
1533                 help();
1534                 return 0;
1535             }
1536             action = SNAPSHOT_DELETE;
1537             snapshot_name = optarg;
1538             break;
1539         }
1540     }
1541
1542     if (optind >= argc) {
1543         help();
1544     }
1545     filename = argv[optind++];
1546
1547     /* Open the image */
1548     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1549     if (!bs) {
1550         return 1;
1551     }
1552
1553     /* Perform the requested action */
1554     switch(action) {
1555     case SNAPSHOT_LIST:
1556         dump_snapshots(bs);
1557         break;
1558
1559     case SNAPSHOT_CREATE:
1560         memset(&sn, 0, sizeof(sn));
1561         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1562
1563         qemu_gettimeofday(&tv);
1564         sn.date_sec = tv.tv_sec;
1565         sn.date_nsec = tv.tv_usec * 1000;
1566
1567         ret = bdrv_snapshot_create(bs, &sn);
1568         if (ret) {
1569             error_report("Could not create snapshot '%s': %d (%s)",
1570                 snapshot_name, ret, strerror(-ret));
1571         }
1572         break;
1573
1574     case SNAPSHOT_APPLY:
1575         ret = bdrv_snapshot_goto(bs, snapshot_name);
1576         if (ret) {
1577             error_report("Could not apply snapshot '%s': %d (%s)",
1578                 snapshot_name, ret, strerror(-ret));
1579         }
1580         break;
1581
1582     case SNAPSHOT_DELETE:
1583         ret = bdrv_snapshot_delete(bs, snapshot_name);
1584         if (ret) {
1585             error_report("Could not delete snapshot '%s': %d (%s)",
1586                 snapshot_name, ret, strerror(-ret));
1587         }
1588         break;
1589     }
1590
1591     /* Cleanup */
1592     bdrv_delete(bs);
1593     if (ret) {
1594         return 1;
1595     }
1596     return 0;
1597 }
1598
1599 static int img_rebase(int argc, char **argv)
1600 {
1601     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1602     BlockDriver *old_backing_drv, *new_backing_drv;
1603     char *filename;
1604     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1605     int c, flags, ret;
1606     int unsafe = 0;
1607     int progress = 0;
1608
1609     /* Parse commandline parameters */
1610     fmt = NULL;
1611     cache = BDRV_DEFAULT_CACHE;
1612     out_baseimg = NULL;
1613     out_basefmt = NULL;
1614     for(;;) {
1615         c = getopt(argc, argv, "uhf:F:b:pt:");
1616         if (c == -1) {
1617             break;
1618         }
1619         switch(c) {
1620         case '?':
1621         case 'h':
1622             help();
1623             return 0;
1624         case 'f':
1625             fmt = optarg;
1626             break;
1627         case 'F':
1628             out_basefmt = optarg;
1629             break;
1630         case 'b':
1631             out_baseimg = optarg;
1632             break;
1633         case 'u':
1634             unsafe = 1;
1635             break;
1636         case 'p':
1637             progress = 1;
1638             break;
1639         case 't':
1640             cache = optarg;
1641             break;
1642         }
1643     }
1644
1645     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1646         help();
1647     }
1648     filename = argv[optind++];
1649
1650     qemu_progress_init(progress, 2.0);
1651     qemu_progress_print(0, 100);
1652
1653     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1654     ret = bdrv_parse_cache_flags(cache, &flags);
1655     if (ret < 0) {
1656         error_report("Invalid cache option: %s", cache);
1657         return -1;
1658     }
1659
1660     /*
1661      * Open the images.
1662      *
1663      * Ignore the old backing file for unsafe rebase in case we want to correct
1664      * the reference to a renamed or moved backing file.
1665      */
1666     bs = bdrv_new_open(filename, fmt, flags, true);
1667     if (!bs) {
1668         return 1;
1669     }
1670
1671     /* Find the right drivers for the backing files */
1672     old_backing_drv = NULL;
1673     new_backing_drv = NULL;
1674
1675     if (!unsafe && bs->backing_format[0] != '\0') {
1676         old_backing_drv = bdrv_find_format(bs->backing_format);
1677         if (old_backing_drv == NULL) {
1678             error_report("Invalid format name: '%s'", bs->backing_format);
1679             ret = -1;
1680             goto out;
1681         }
1682     }
1683
1684     if (out_basefmt != NULL) {
1685         new_backing_drv = bdrv_find_format(out_basefmt);
1686         if (new_backing_drv == NULL) {
1687             error_report("Invalid format name: '%s'", out_basefmt);
1688             ret = -1;
1689             goto out;
1690         }
1691     }
1692
1693     /* For safe rebasing we need to compare old and new backing file */
1694     if (unsafe) {
1695         /* Make the compiler happy */
1696         bs_old_backing = NULL;
1697         bs_new_backing = NULL;
1698     } else {
1699         char backing_name[1024];
1700
1701         bs_old_backing = bdrv_new("old_backing");
1702         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1703         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1704                         old_backing_drv);
1705         if (ret) {
1706             error_report("Could not open old backing file '%s'", backing_name);
1707             goto out;
1708         }
1709         if (out_baseimg[0]) {
1710             bs_new_backing = bdrv_new("new_backing");
1711             ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1712                         new_backing_drv);
1713             if (ret) {
1714                 error_report("Could not open new backing file '%s'",
1715                              out_baseimg);
1716                 goto out;
1717             }
1718         }
1719     }
1720
1721     /*
1722      * Check each unallocated cluster in the COW file. If it is unallocated,
1723      * accesses go to the backing file. We must therefore compare this cluster
1724      * in the old and new backing file, and if they differ we need to copy it
1725      * from the old backing file into the COW file.
1726      *
1727      * If qemu-img crashes during this step, no harm is done. The content of
1728      * the image is the same as the original one at any time.
1729      */
1730     if (!unsafe) {
1731         uint64_t num_sectors;
1732         uint64_t old_backing_num_sectors;
1733         uint64_t new_backing_num_sectors = 0;
1734         uint64_t sector;
1735         int n;
1736         uint8_t * buf_old;
1737         uint8_t * buf_new;
1738         float local_progress = 0;
1739
1740         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1741         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
1742
1743         bdrv_get_geometry(bs, &num_sectors);
1744         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1745         if (bs_new_backing) {
1746             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
1747         }
1748
1749         if (num_sectors != 0) {
1750             local_progress = (float)100 /
1751                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1752         }
1753
1754         for (sector = 0; sector < num_sectors; sector += n) {
1755
1756             /* How many sectors can we handle with the next read? */
1757             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1758                 n = (IO_BUF_SIZE / 512);
1759             } else {
1760                 n = num_sectors - sector;
1761             }
1762
1763             /* If the cluster is allocated, we don't need to take action */
1764             ret = bdrv_is_allocated(bs, sector, n, &n);
1765             if (ret) {
1766                 continue;
1767             }
1768
1769             /*
1770              * Read old and new backing file and take into consideration that
1771              * backing files may be smaller than the COW image.
1772              */
1773             if (sector >= old_backing_num_sectors) {
1774                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1775             } else {
1776                 if (sector + n > old_backing_num_sectors) {
1777                     n = old_backing_num_sectors - sector;
1778                 }
1779
1780                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1781                 if (ret < 0) {
1782                     error_report("error while reading from old backing file");
1783                     goto out;
1784                 }
1785             }
1786
1787             if (sector >= new_backing_num_sectors || !bs_new_backing) {
1788                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1789             } else {
1790                 if (sector + n > new_backing_num_sectors) {
1791                     n = new_backing_num_sectors - sector;
1792                 }
1793
1794                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1795                 if (ret < 0) {
1796                     error_report("error while reading from new backing file");
1797                     goto out;
1798                 }
1799             }
1800
1801             /* If they differ, we need to write to the COW file */
1802             uint64_t written = 0;
1803
1804             while (written < n) {
1805                 int pnum;
1806
1807                 if (compare_sectors(buf_old + written * 512,
1808                     buf_new + written * 512, n - written, &pnum))
1809                 {
1810                     ret = bdrv_write(bs, sector + written,
1811                         buf_old + written * 512, pnum);
1812                     if (ret < 0) {
1813                         error_report("Error while writing to COW image: %s",
1814                             strerror(-ret));
1815                         goto out;
1816                     }
1817                 }
1818
1819                 written += pnum;
1820             }
1821             qemu_progress_print(local_progress, 100);
1822         }
1823
1824         qemu_vfree(buf_old);
1825         qemu_vfree(buf_new);
1826     }
1827
1828     /*
1829      * Change the backing file. All clusters that are different from the old
1830      * backing file are overwritten in the COW file now, so the visible content
1831      * doesn't change when we switch the backing file.
1832      */
1833     if (out_baseimg && *out_baseimg) {
1834         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1835     } else {
1836         ret = bdrv_change_backing_file(bs, NULL, NULL);
1837     }
1838
1839     if (ret == -ENOSPC) {
1840         error_report("Could not change the backing file to '%s': No "
1841                      "space left in the file header", out_baseimg);
1842     } else if (ret < 0) {
1843         error_report("Could not change the backing file to '%s': %s",
1844             out_baseimg, strerror(-ret));
1845     }
1846
1847     qemu_progress_print(100, 0);
1848     /*
1849      * TODO At this point it is possible to check if any clusters that are
1850      * allocated in the COW file are the same in the backing file. If so, they
1851      * could be dropped from the COW file. Don't do this before switching the
1852      * backing file, in case of a crash this would lead to corruption.
1853      */
1854 out:
1855     qemu_progress_end();
1856     /* Cleanup */
1857     if (!unsafe) {
1858         if (bs_old_backing != NULL) {
1859             bdrv_delete(bs_old_backing);
1860         }
1861         if (bs_new_backing != NULL) {
1862             bdrv_delete(bs_new_backing);
1863         }
1864     }
1865
1866     bdrv_delete(bs);
1867     if (ret) {
1868         return 1;
1869     }
1870     return 0;
1871 }
1872
1873 static int img_resize(int argc, char **argv)
1874 {
1875     int c, ret, relative;
1876     const char *filename, *fmt, *size;
1877     int64_t n, total_size;
1878     BlockDriverState *bs = NULL;
1879     QemuOpts *param;
1880     static QemuOptsList resize_options = {
1881         .name = "resize_options",
1882         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
1883         .desc = {
1884             {
1885                 .name = BLOCK_OPT_SIZE,
1886                 .type = QEMU_OPT_SIZE,
1887                 .help = "Virtual disk size"
1888             }, {
1889                 /* end of list */
1890             }
1891         },
1892     };
1893
1894     /* Remove size from argv manually so that negative numbers are not treated
1895      * as options by getopt. */
1896     if (argc < 3) {
1897         help();
1898         return 1;
1899     }
1900
1901     size = argv[--argc];
1902
1903     /* Parse getopt arguments */
1904     fmt = NULL;
1905     for(;;) {
1906         c = getopt(argc, argv, "f:h");
1907         if (c == -1) {
1908             break;
1909         }
1910         switch(c) {
1911         case '?':
1912         case 'h':
1913             help();
1914             break;
1915         case 'f':
1916             fmt = optarg;
1917             break;
1918         }
1919     }
1920     if (optind >= argc) {
1921         help();
1922     }
1923     filename = argv[optind++];
1924
1925     /* Choose grow, shrink, or absolute resize mode */
1926     switch (size[0]) {
1927     case '+':
1928         relative = 1;
1929         size++;
1930         break;
1931     case '-':
1932         relative = -1;
1933         size++;
1934         break;
1935     default:
1936         relative = 0;
1937         break;
1938     }
1939
1940     /* Parse size */
1941     param = qemu_opts_create_nofail(&resize_options);
1942     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1943         /* Error message already printed when size parsing fails */
1944         ret = -1;
1945         qemu_opts_del(param);
1946         goto out;
1947     }
1948     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
1949     qemu_opts_del(param);
1950
1951     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1952     if (!bs) {
1953         ret = -1;
1954         goto out;
1955     }
1956
1957     if (relative) {
1958         total_size = bdrv_getlength(bs) + n * relative;
1959     } else {
1960         total_size = n;
1961     }
1962     if (total_size <= 0) {
1963         error_report("New image size must be positive");
1964         ret = -1;
1965         goto out;
1966     }
1967
1968     ret = bdrv_truncate(bs, total_size);
1969     switch (ret) {
1970     case 0:
1971         printf("Image resized.\n");
1972         break;
1973     case -ENOTSUP:
1974         error_report("This image does not support resize");
1975         break;
1976     case -EACCES:
1977         error_report("Image is read-only");
1978         break;
1979     default:
1980         error_report("Error resizing image (%d)", -ret);
1981         break;
1982     }
1983 out:
1984     if (bs) {
1985         bdrv_delete(bs);
1986     }
1987     if (ret) {
1988         return 1;
1989     }
1990     return 0;
1991 }
1992
1993 static const img_cmd_t img_cmds[] = {
1994 #define DEF(option, callback, arg_string)        \
1995     { option, callback },
1996 #include "qemu-img-cmds.h"
1997 #undef DEF
1998 #undef GEN_DOCS
1999     { NULL, NULL, },
2000 };
2001
2002 int main(int argc, char **argv)
2003 {
2004     const img_cmd_t *cmd;
2005     const char *cmdname;
2006
2007     error_set_progname(argv[0]);
2008
2009     qemu_init_main_loop();
2010     bdrv_init();
2011     if (argc < 2)
2012         help();
2013     cmdname = argv[1];
2014     argc--; argv++;
2015
2016     /* find the command */
2017     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2018         if (!strcmp(cmdname, cmd->name)) {
2019             return cmd->handler(argc, argv);
2020         }
2021     }
2022
2023     /* not found */
2024     help();
2025     return 0;
2026 }