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 "block/qapi.h"
  34 #include <getopt.h>
  35 #include <stdio.h>
  36 #include <stdarg.h>
  37
  38 #ifdef _WIN32
  39 #include <windows.h>
  40 #endif
  41
  42 typedef struct img_cmd_t {
  43     const char *name;
  44     int (*handler)(int argc, char **argv);
  45 } img_cmd_t;
  46
  47 enum {
  48     OPTION_OUTPUT = 256,
  49     OPTION_BACKING_CHAIN = 257,
  50 };
  51
  52 typedef enum OutputFormat {
  53     OFORMAT_JSON,
  54     OFORMAT_HUMAN,
  55 } OutputFormat;
  56
  57 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
  58 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
  59 #define BDRV_DEFAULT_CACHE "writeback"
  60
  61 static void format_print(void *opaque, const char *name)
  62 {
  63     printf(" %s", name);
  64 }
  65
  66 /* Please keep in synch with qemu-img.texi */
  67 static void help(void)
  68 {
  69     const char *help_msg =
  70            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
  71            "usage: qemu-img command [command options]\n"
  72            "QEMU disk image utility\n"
  73            "\n"
  74            "Command syntax:\n"
  75 #define DEF(option, callback, arg_string)        \
  76            "  " arg_string "\n"
  77 #include "qemu-img-cmds.h"
  78 #undef DEF
  79 #undef GEN_DOCS
  80            "\n"
  81            "Command parameters:\n"
  82            "  'filename' is a disk image filename\n"
  83            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  84            "  'cache' is the cache mode used to write the output disk image, the valid\n"
  85            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
  86            "    'directsync' and 'unsafe' (default for convert)\n"
  87            "  'size' is the disk image size in bytes. Optional suffixes\n"
  88            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
  89            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
  90            "    supported. 'b' is ignored.\n"
  91            "  'output_filename' is the destination disk image filename\n"
  92            "  'output_fmt' is the destination format\n"
  93            "  'options' is a comma separated list of format specific options in a\n"
  94            "    name=value format. Use -o ? for an overview of the options supported by the\n"
  95            "    used format\n"
  96            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  97            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
  98            "       match exactly. The image doesn't need a working backing file before\n"
  99            "       rebasing in this case (useful for renaming the backing file)\n"
 100            "  '-h' with or without a command shows this help and lists the supported formats\n"
 101            "  '-p' show progress of command (only certain commands)\n"
 102            "  '-q' use Quiet mode - do not print any output (except errors)\n"
 103            "  '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
 104            "       contain only zeros for qemu-img to create a sparse image during\n"
 105            "       conversion. If the number of bytes is 0, the source will not be scanned for\n"
 106            "       unallocated or zero sectors, and the destination image will always be\n"
 107            "       fully allocated\n"
 108            "       images will always be fully allocated\n"
 109            "  '--output' takes the format in which the output must be done (human or json)\n"
 110            "  '-n' skips the target volume creation (useful if the volume is created\n"
 111            "       prior to running qemu-img)\n"
 112            "\n"
 113            "Parameters to check subcommand:\n"
 114            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
 115            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
 116            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
 117            "       hiding corruption that has already occurred.\n"
 118            "\n"
 119            "Parameters to snapshot subcommand:\n"
 120            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
 121            "  '-a' applies a snapshot (revert disk to saved state)\n"
 122            "  '-c' creates a snapshot\n"
 123            "  '-d' deletes a snapshot\n"
 124            "  '-l' lists all snapshots in the given image\n"
 125            "\n"
 126            "Parameters to compare subcommand:\n"
 127            "  '-f' first image format\n"
 128            "  '-F' second image format\n"
 129            "  '-s' run in Strict mode - fail on different image size or sector allocation\n";
 130
 131     printf("%s\nSupported formats:", help_msg);
 132     bdrv_iterate_format(format_print, NULL);
 133     printf("\n");
 134     exit(1);
 135 }
 136
 137 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
 138 {
 139     int ret = 0;
 140     if (!quiet) {
 141         va_list args;
 142         va_start(args, fmt);
 143         ret = vprintf(fmt, args);
 144         va_end(args);
 145     }
 146     return ret;
 147 }
 148
 149 #if defined(WIN32)
 150 /* XXX: put correct support for win32 */
 151 static int read_password(char *buf, int buf_size)
 152 {
 153     int c, i;
 154     printf("Password: ");
 155     fflush(stdout);
 156     i = 0;
 157     for(;;) {
 158         c = getchar();
 159         if (c == '\n')
 160             break;
 161         if (i < (buf_size - 1))
 162             buf[i++] = c;
 163     }
 164     buf[i] = '\0';
 165     return 0;
 166 }
 167
 168 #else
 169
 170 #include <termios.h>
 171
 172 static struct termios oldtty;
 173
 174 static void term_exit(void)
 175 {
 176     tcsetattr (0, TCSANOW, &oldtty);
 177 }
 178
 179 static void term_init(void)
 180 {
 181     struct termios tty;
 182
 183     tcgetattr (0, &tty);
 184     oldtty = tty;
 185
 186     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 187                           |INLCR|IGNCR|ICRNL|IXON);
 188     tty.c_oflag |= OPOST;
 189     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 190     tty.c_cflag &= ~(CSIZE|PARENB);
 191     tty.c_cflag |= CS8;
 192     tty.c_cc[VMIN] = 1;
 193     tty.c_cc[VTIME] = 0;
 194
 195     tcsetattr (0, TCSANOW, &tty);
 196
 197     atexit(term_exit);
 198 }
 199
 200 static int read_password(char *buf, int buf_size)
 201 {
 202     uint8_t ch;
 203     int i, ret;
 204
 205     printf("password: ");
 206     fflush(stdout);
 207     term_init();
 208     i = 0;
 209     for(;;) {
 210         ret = read(0, &ch, 1);
 211         if (ret == -1) {
 212             if (errno == EAGAIN || errno == EINTR) {
 213                 continue;
 214             } else {
 215                 ret = -1;
 216                 break;
 217             }
 218         } else if (ret == 0) {
 219             ret = -1;
 220             break;
 221         } else {
 222             if (ch == '\r') {
 223                 ret = 0;
 224                 break;
 225             }
 226             if (i < (buf_size - 1))
 227                 buf[i++] = ch;
 228         }
 229     }
 230     term_exit();
 231     buf[i] = '\0';
 232     printf("\n");
 233     return ret;
 234 }
 235 #endif
 236
 237 static int print_block_option_help(const char *filename, const char *fmt)
 238 {
 239     BlockDriver *drv, *proto_drv;
 240     QEMUOptionParameter *create_options = NULL;
 241
 242     /* Find driver and parse its options */
 243     drv = bdrv_find_format(fmt);
 244     if (!drv) {
 245         error_report("Unknown file format '%s'", fmt);
 246         return 1;
 247     }
 248
 249     proto_drv = bdrv_find_protocol(filename, true);
 250     if (!proto_drv) {
 251         error_report("Unknown protocol '%s'", filename);
 252         return 1;
 253     }
 254
 255     create_options = append_option_parameters(create_options,
 256                                               drv->create_options);
 257     create_options = append_option_parameters(create_options,
 258                                               proto_drv->create_options);
 259     print_option_help(create_options);
 260     free_option_parameters(create_options);
 261     return 0;
 262 }
 263
 264 static BlockDriverState *bdrv_new_open(const char *filename,
 265                                        const char *fmt,
 266                                        int flags,
 267                                        bool require_io,
 268                                        bool quiet)
 269 {
 270     BlockDriverState *bs;
 271     BlockDriver *drv;
 272     char password[256];
 273     Error *local_err = NULL;
 274     int ret;
 275
 276     bs = bdrv_new("image");
 277
 278     if (fmt) {
 279         drv = bdrv_find_format(fmt);
 280         if (!drv) {
 281             error_report("Unknown file format '%s'", fmt);
 282             goto fail;
 283         }
 284     } else {
 285         drv = NULL;
 286     }
 287
 288     ret = bdrv_open(bs, filename, NULL, flags, drv, &local_err);
 289     if (ret < 0) {
 290         error_report("Could not open '%s': %s", filename,
 291                      error_get_pretty(local_err));
 292         error_free(local_err);
 293         goto fail;
 294     }
 295
 296     if (bdrv_is_encrypted(bs) && require_io) {
 297         qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
 298         if (read_password(password, sizeof(password)) < 0) {
 299             error_report("No password given");
 300             goto fail;
 301         }
 302         if (bdrv_set_key(bs, password) < 0) {
 303             error_report("invalid password");
 304             goto fail;
 305         }
 306     }
 307     return bs;
 308 fail:
 309     if (bs) {
 310         bdrv_unref(bs);
 311     }
 312     return NULL;
 313 }
 314
 315 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
 316                                  const char *base_filename,
 317                                  const char *base_fmt)
 318 {
 319     if (base_filename) {
 320         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
 321             error_report("Backing file not supported for file format '%s'",
 322                          fmt);
 323             return -1;
 324         }
 325     }
 326     if (base_fmt) {
 327         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
 328             error_report("Backing file format not supported for file "
 329                          "format '%s'", fmt);
 330             return -1;
 331         }
 332     }
 333     return 0;
 334 }
 335
 336 static int img_create(int argc, char **argv)
 337 {
 338     int c;
 339     uint64_t img_size = -1;
 340     const char *fmt = "raw";
 341     const char *base_fmt = NULL;
 342     const char *filename;
 343     const char *base_filename = NULL;
 344     char *options = NULL;
 345     Error *local_err = NULL;
 346     bool quiet = false;
 347
 348     for(;;) {
 349         c = getopt(argc, argv, "F:b:f:he6o:q");
 350         if (c == -1) {
 351             break;
 352         }
 353         switch(c) {
 354         case '?':
 355         case 'h':
 356             help();
 357             break;
 358         case 'F':
 359             base_fmt = optarg;
 360             break;
 361         case 'b':
 362             base_filename = optarg;
 363             break;
 364         case 'f':
 365             fmt = optarg;
 366             break;
 367         case 'e':
 368             error_report("option -e is deprecated, please use \'-o "
 369                   "encryption\' instead!");
 370             return 1;
 371         case '6':
 372             error_report("option -6 is deprecated, please use \'-o "
 373                   "compat6\' instead!");
 374             return 1;
 375         case 'o':
 376             options = optarg;
 377             break;
 378         case 'q':
 379             quiet = true;
 380             break;
 381         }
 382     }
 383
 384     /* Get the filename */
 385     if (optind >= argc) {
 386         help();
 387     }
 388     filename = argv[optind++];
 389
 390     /* Get image size, if specified */
 391     if (optind < argc) {
 392         int64_t sval;
 393         char *end;
 394         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
 395         if (sval < 0 || *end) {
 396             if (sval == -ERANGE) {
 397                 error_report("Image size must be less than 8 EiB!");
 398             } else {
 399                 error_report("Invalid image size specified! You may use k, M, "
 400                       "G, T, P or E suffixes for ");
 401                 error_report("kilobytes, megabytes, gigabytes, terabytes, "
 402                              "petabytes and exabytes.");
 403             }
 404             return 1;
 405         }
 406         img_size = (uint64_t)sval;
 407     }
 408     if (optind != argc) {
 409         help();
 410     }
 411
 412     if (options && is_help_option(options)) {
 413         return print_block_option_help(filename, fmt);
 414     }
 415
 416     bdrv_img_create(filename, fmt, base_filename, base_fmt,
 417                     options, img_size, BDRV_O_FLAGS, &local_err, quiet);
 418     if (error_is_set(&local_err)) {
 419         error_report("%s: %s", filename, error_get_pretty(local_err));
 420         error_free(local_err);
 421         return 1;
 422     }
 423
 424     return 0;
 425 }
 426
 427 static void dump_json_image_check(ImageCheck *check, bool quiet)
 428 {
 429     Error *errp = NULL;
 430     QString *str;
 431     QmpOutputVisitor *ov = qmp_output_visitor_new();
 432     QObject *obj;
 433     visit_type_ImageCheck(qmp_output_get_visitor(ov),
 434                           &check, NULL, &errp);
 435     obj = qmp_output_get_qobject(ov);
 436     str = qobject_to_json_pretty(obj);
 437     assert(str != NULL);
 438     qprintf(quiet, "%s\n", qstring_get_str(str));
 439     qobject_decref(obj);
 440     qmp_output_visitor_cleanup(ov);
 441     QDECREF(str);
 442 }
 443
 444 static void dump_human_image_check(ImageCheck *check, bool quiet)
 445 {
 446     if (!(check->corruptions || check->leaks || check->check_errors)) {
 447         qprintf(quiet, "No errors were found on the image.\n");
 448     } else {
 449         if (check->corruptions) {
 450             qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
 451                     "Data may be corrupted, or further writes to the image "
 452                     "may corrupt it.\n",
 453                     check->corruptions);
 454         }
 455
 456         if (check->leaks) {
 457             qprintf(quiet,
 458                     "\n%" PRId64 " leaked clusters were found on the image.\n"
 459                     "This means waste of disk space, but no harm to data.\n",
 460                     check->leaks);
 461         }
 462
 463         if (check->check_errors) {
 464             qprintf(quiet,
 465                     "\n%" PRId64
 466                     " internal errors have occurred during the check.\n",
 467                     check->check_errors);
 468         }
 469     }
 470
 471     if (check->total_clusters != 0 && check->allocated_clusters != 0) {
 472         qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
 473                 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
 474                 check->allocated_clusters, check->total_clusters,
 475                 check->allocated_clusters * 100.0 / check->total_clusters,
 476                 check->fragmented_clusters * 100.0 / check->allocated_clusters,
 477                 check->compressed_clusters * 100.0 /
 478                 check->allocated_clusters);
 479     }
 480
 481     if (check->image_end_offset) {
 482         qprintf(quiet,
 483                 "Image end offset: %" PRId64 "\n", check->image_end_offset);
 484     }
 485 }
 486
 487 static int collect_image_check(BlockDriverState *bs,
 488                    ImageCheck *check,
 489                    const char *filename,
 490                    const char *fmt,
 491                    int fix)
 492 {
 493     int ret;
 494     BdrvCheckResult result;
 495
 496     ret = bdrv_check(bs, &result, fix);
 497     if (ret < 0) {
 498         return ret;
 499     }
 500
 501     check->filename                 = g_strdup(filename);
 502     check->format                   = g_strdup(bdrv_get_format_name(bs));
 503     check->check_errors             = result.check_errors;
 504     check->corruptions              = result.corruptions;
 505     check->has_corruptions          = result.corruptions != 0;
 506     check->leaks                    = result.leaks;
 507     check->has_leaks                = result.leaks != 0;
 508     check->corruptions_fixed        = result.corruptions_fixed;
 509     check->has_corruptions_fixed    = result.corruptions != 0;
 510     check->leaks_fixed              = result.leaks_fixed;
 511     check->has_leaks_fixed          = result.leaks != 0;
 512     check->image_end_offset         = result.image_end_offset;
 513     check->has_image_end_offset     = result.image_end_offset != 0;
 514     check->total_clusters           = result.bfi.total_clusters;
 515     check->has_total_clusters       = result.bfi.total_clusters != 0;
 516     check->allocated_clusters       = result.bfi.allocated_clusters;
 517     check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
 518     check->fragmented_clusters      = result.bfi.fragmented_clusters;
 519     check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
 520     check->compressed_clusters      = result.bfi.compressed_clusters;
 521     check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
 522
 523     return 0;
 524 }
 525
 526 /*
 527  * Checks an image for consistency. Exit codes:
 528  *
 529  * 0 - Check completed, image is good
 530  * 1 - Check not completed because of internal errors
 531  * 2 - Check completed, image is corrupted
 532  * 3 - Check completed, image has leaked clusters, but is good otherwise
 533  */
 534 static int img_check(int argc, char **argv)
 535 {
 536     int c, ret;
 537     OutputFormat output_format = OFORMAT_HUMAN;
 538     const char *filename, *fmt, *output;
 539     BlockDriverState *bs;
 540     int fix = 0;
 541     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
 542     ImageCheck *check;
 543     bool quiet = false;
 544
 545     fmt = NULL;
 546     output = NULL;
 547     for(;;) {
 548         int option_index = 0;
 549         static const struct option long_options[] = {
 550             {"help", no_argument, 0, 'h'},
 551             {"format", required_argument, 0, 'f'},
 552             {"repair", no_argument, 0, 'r'},
 553             {"output", required_argument, 0, OPTION_OUTPUT},
 554             {0, 0, 0, 0}
 555         };
 556         c = getopt_long(argc, argv, "f:hr:q",
 557                         long_options, &option_index);
 558         if (c == -1) {
 559             break;
 560         }
 561         switch(c) {
 562         case '?':
 563         case 'h':
 564             help();
 565             break;
 566         case 'f':
 567             fmt = optarg;
 568             break;
 569         case 'r':
 570             flags |= BDRV_O_RDWR;
 571
 572             if (!strcmp(optarg, "leaks")) {
 573                 fix = BDRV_FIX_LEAKS;
 574             } else if (!strcmp(optarg, "all")) {
 575                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
 576             } else {
 577                 help();
 578             }
 579             break;
 580         case OPTION_OUTPUT:
 581             output = optarg;
 582             break;
 583         case 'q':
 584             quiet = true;
 585             break;
 586         }
 587     }
 588     if (optind != argc - 1) {
 589         help();
 590     }
 591     filename = argv[optind++];
 592
 593     if (output && !strcmp(output, "json")) {
 594         output_format = OFORMAT_JSON;
 595     } else if (output && !strcmp(output, "human")) {
 596         output_format = OFORMAT_HUMAN;
 597     } else if (output) {
 598         error_report("--output must be used with human or json as argument.");
 599         return 1;
 600     }
 601
 602     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
 603     if (!bs) {
 604         return 1;
 605     }
 606
 607     check = g_new0(ImageCheck, 1);
 608     ret = collect_image_check(bs, check, filename, fmt, fix);
 609
 610     if (ret == -ENOTSUP) {
 611         if (output_format == OFORMAT_HUMAN) {
 612             error_report("This image format does not support checks");
 613         }
 614         ret = 63;
 615         goto fail;
 616     }
 617
 618     if (check->corruptions_fixed || check->leaks_fixed) {
 619         int corruptions_fixed, leaks_fixed;
 620
 621         leaks_fixed         = check->leaks_fixed;
 622         corruptions_fixed   = check->corruptions_fixed;
 623
 624         if (output_format == OFORMAT_HUMAN) {
 625             qprintf(quiet,
 626                     "The following inconsistencies were found and repaired:\n\n"
 627                     "    %" PRId64 " leaked clusters\n"
 628                     "    %" PRId64 " corruptions\n\n"
 629                     "Double checking the fixed image now...\n",
 630                     check->leaks_fixed,
 631                     check->corruptions_fixed);
 632         }
 633
 634         ret = collect_image_check(bs, check, filename, fmt, 0);
 635
 636         check->leaks_fixed          = leaks_fixed;
 637         check->corruptions_fixed    = corruptions_fixed;
 638     }
 639
 640     switch (output_format) {
 641     case OFORMAT_HUMAN:
 642         dump_human_image_check(check, quiet);
 643         break;
 644     case OFORMAT_JSON:
 645         dump_json_image_check(check, quiet);
 646         break;
 647     }
 648
 649     if (ret || check->check_errors) {
 650         ret = 1;
 651         goto fail;
 652     }
 653
 654     if (check->corruptions) {
 655         ret = 2;
 656     } else if (check->leaks) {
 657         ret = 3;
 658     } else {
 659         ret = 0;
 660     }
 661
 662 fail:
 663     qapi_free_ImageCheck(check);
 664     bdrv_unref(bs);
 665
 666     return ret;
 667 }
 668
 669 static int img_commit(int argc, char **argv)
 670 {
 671     int c, ret, flags;
 672     const char *filename, *fmt, *cache;
 673     BlockDriverState *bs;
 674     bool quiet = false;
 675
 676     fmt = NULL;
 677     cache = BDRV_DEFAULT_CACHE;
 678     for(;;) {
 679         c = getopt(argc, argv, "f:ht:q");
 680         if (c == -1) {
 681             break;
 682         }
 683         switch(c) {
 684         case '?':
 685         case 'h':
 686             help();
 687             break;
 688         case 'f':
 689             fmt = optarg;
 690             break;
 691         case 't':
 692             cache = optarg;
 693             break;
 694         case 'q':
 695             quiet = true;
 696             break;
 697         }
 698     }
 699     if (optind != argc - 1) {
 700         help();
 701     }
 702     filename = argv[optind++];
 703
 704     flags = BDRV_O_RDWR;
 705     ret = bdrv_parse_cache_flags(cache, &flags);
 706     if (ret < 0) {
 707         error_report("Invalid cache option: %s", cache);
 708         return -1;
 709     }
 710
 711     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
 712     if (!bs) {
 713         return 1;
 714     }
 715     ret = bdrv_commit(bs);
 716     switch(ret) {
 717     case 0:
 718         qprintf(quiet, "Image committed.\n");
 719         break;
 720     case -ENOENT:
 721         error_report("No disk inserted");
 722         break;
 723     case -EACCES:
 724         error_report("Image is read-only");
 725         break;
 726     case -ENOTSUP:
 727         error_report("Image is already committed");
 728         break;
 729     default:
 730         error_report("Error while committing image");
 731         break;
 732     }
 733
 734     bdrv_unref(bs);
 735     if (ret) {
 736         return 1;
 737     }
 738     return 0;
 739 }
 740
 741 /*
 742  * Returns true iff the first sector pointed to by 'buf' contains at least
 743  * a non-NUL byte.
 744  *
 745  * 'pnum' is set to the number of sectors (including and immediately following
 746  * the first one) that are known to be in the same allocated/unallocated state.
 747  */
 748 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 749 {
 750     bool is_zero;
 751     int i;
 752
 753     if (n <= 0) {
 754         *pnum = 0;
 755         return 0;
 756     }
 757     is_zero = buffer_is_zero(buf, 512);
 758     for(i = 1; i < n; i++) {
 759         buf += 512;
 760         if (is_zero != buffer_is_zero(buf, 512)) {
 761             break;
 762         }
 763     }
 764     *pnum = i;
 765     return !is_zero;
 766 }
 767
 768 /*
 769  * Like is_allocated_sectors, but if the buffer starts with a used sector,
 770  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 771  * breaking up write requests for only small sparse areas.
 772  */
 773 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 774     int min)
 775 {
 776     int ret;
 777     int num_checked, num_used;
 778
 779     if (n < min) {
 780         min = n;
 781     }
 782
 783     ret = is_allocated_sectors(buf, n, pnum);
 784     if (!ret) {
 785         return ret;
 786     }
 787
 788     num_used = *pnum;
 789     buf += BDRV_SECTOR_SIZE * *pnum;
 790     n -= *pnum;
 791     num_checked = num_used;
 792
 793     while (n > 0) {
 794         ret = is_allocated_sectors(buf, n, pnum);
 795
 796         buf += BDRV_SECTOR_SIZE * *pnum;
 797         n -= *pnum;
 798         num_checked += *pnum;
 799         if (ret) {
 800             num_used = num_checked;
 801         } else if (*pnum >= min) {
 802             break;
 803         }
 804     }
 805
 806     *pnum = num_used;
 807     return 1;
 808 }
 809
 810 /*
 811  * Compares two buffers sector by sector. Returns 0 if the first sector of both
 812  * buffers matches, non-zero otherwise.
 813  *
 814  * pnum is set to the number of sectors (including and immediately following
 815  * the first one) that are known to have the same comparison result
 816  */
 817 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
 818     int *pnum)
 819 {
 820     int res, i;
 821
 822     if (n <= 0) {
 823         *pnum = 0;
 824         return 0;
 825     }
 826
 827     res = !!memcmp(buf1, buf2, 512);
 828     for(i = 1; i < n; i++) {
 829         buf1 += 512;
 830         buf2 += 512;
 831
 832         if (!!memcmp(buf1, buf2, 512) != res) {
 833             break;
 834         }
 835     }
 836
 837     *pnum = i;
 838     return res;
 839 }
 840
 841 #define IO_BUF_SIZE (2 * 1024 * 1024)
 842
 843 static int64_t sectors_to_bytes(int64_t sectors)
 844 {
 845     return sectors << BDRV_SECTOR_BITS;
 846 }
 847
 848 static int64_t sectors_to_process(int64_t total, int64_t from)
 849 {
 850     return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
 851 }
 852
 853 /*
 854  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
 855  *
 856  * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
 857  * data and negative value on error.
 858  *
 859  * @param bs:  Driver used for accessing file
 860  * @param sect_num: Number of first sector to check
 861  * @param sect_count: Number of sectors to check
 862  * @param filename: Name of disk file we are checking (logging purpose)
 863  * @param buffer: Allocated buffer for storing read data
 864  * @param quiet: Flag for quiet mode
 865  */
 866 static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
 867                                int sect_count, const char *filename,
 868                                uint8_t *buffer, bool quiet)
 869 {
 870     int pnum, ret = 0;
 871     ret = bdrv_read(bs, sect_num, buffer, sect_count);
 872     if (ret < 0) {
 873         error_report("Error while reading offset %" PRId64 " of %s: %s",
 874                      sectors_to_bytes(sect_num), filename, strerror(-ret));
 875         return ret;
 876     }
 877     ret = is_allocated_sectors(buffer, sect_count, &pnum);
 878     if (ret || pnum != sect_count) {
 879         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
 880                 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
 881         return 1;
 882     }
 883
 884     return 0;
 885 }
 886
 887 /*
 888  * Compares two images. Exit codes:
 889  *
 890  * 0 - Images are identical
 891  * 1 - Images differ
 892  * >1 - Error occurred
 893  */
 894 static int img_compare(int argc, char **argv)
 895 {
 896     const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
 897     BlockDriverState *bs1, *bs2;
 898     int64_t total_sectors1, total_sectors2;
 899     uint8_t *buf1 = NULL, *buf2 = NULL;
 900     int pnum1, pnum2;
 901     int allocated1, allocated2;
 902     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
 903     bool progress = false, quiet = false, strict = false;
 904     int64_t total_sectors;
 905     int64_t sector_num = 0;
 906     int64_t nb_sectors;
 907     int c, pnum;
 908     uint64_t bs_sectors;
 909     uint64_t progress_base;
 910
 911     for (;;) {
 912         c = getopt(argc, argv, "hpf:F:sq");
 913         if (c == -1) {
 914             break;
 915         }
 916         switch (c) {
 917         case '?':
 918         case 'h':
 919             help();
 920             break;
 921         case 'f':
 922             fmt1 = optarg;
 923             break;
 924         case 'F':
 925             fmt2 = optarg;
 926             break;
 927         case 'p':
 928             progress = true;
 929             break;
 930         case 'q':
 931             quiet = true;
 932             break;
 933         case 's':
 934             strict = true;
 935             break;
 936         }
 937     }
 938
 939     /* Progress is not shown in Quiet mode */
 940     if (quiet) {
 941         progress = false;
 942     }
 943
 944
 945     if (optind != argc - 2) {
 946         help();
 947     }
 948     filename1 = argv[optind++];
 949     filename2 = argv[optind++];
 950
 951     /* Initialize before goto out */
 952     qemu_progress_init(progress, 2.0);
 953
 954     bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
 955     if (!bs1) {
 956         error_report("Can't open file %s", filename1);
 957         ret = 2;
 958         goto out3;
 959     }
 960
 961     bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
 962     if (!bs2) {
 963         error_report("Can't open file %s", filename2);
 964         ret = 2;
 965         goto out2;
 966     }
 967
 968     buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
 969     buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
 970     bdrv_get_geometry(bs1, &bs_sectors);
 971     total_sectors1 = bs_sectors;
 972     bdrv_get_geometry(bs2, &bs_sectors);
 973     total_sectors2 = bs_sectors;
 974     total_sectors = MIN(total_sectors1, total_sectors2);
 975     progress_base = MAX(total_sectors1, total_sectors2);
 976
 977     qemu_progress_print(0, 100);
 978
 979     if (strict && total_sectors1 != total_sectors2) {
 980         ret = 1;
 981         qprintf(quiet, "Strict mode: Image size mismatch!\n");
 982         goto out;
 983     }
 984
 985     for (;;) {
 986         nb_sectors = sectors_to_process(total_sectors, sector_num);
 987         if (nb_sectors <= 0) {
 988             break;
 989         }
 990         allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
 991                                              &pnum1);
 992         if (allocated1 < 0) {
 993             ret = 3;
 994             error_report("Sector allocation test failed for %s", filename1);
 995             goto out;
 996         }
 997
 998         allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
 999                                              &pnum2);
1000         if (allocated2 < 0) {
1001             ret = 3;
1002             error_report("Sector allocation test failed for %s", filename2);
1003             goto out;
1004         }
1005         nb_sectors = MIN(pnum1, pnum2);
1006
1007         if (allocated1 == allocated2) {
1008             if (allocated1) {
1009                 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
1010                 if (ret < 0) {
1011                     error_report("Error while reading offset %" PRId64 " of %s:"
1012                                  " %s", sectors_to_bytes(sector_num), filename1,
1013                                  strerror(-ret));
1014                     ret = 4;
1015                     goto out;
1016                 }
1017                 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1018                 if (ret < 0) {
1019                     error_report("Error while reading offset %" PRId64
1020                                  " of %s: %s", sectors_to_bytes(sector_num),
1021                                  filename2, strerror(-ret));
1022                     ret = 4;
1023                     goto out;
1024                 }
1025                 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1026                 if (ret || pnum != nb_sectors) {
1027                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1028                             sectors_to_bytes(
1029                                 ret ? sector_num : sector_num + pnum));
1030                     ret = 1;
1031                     goto out;
1032                 }
1033             }
1034         } else {
1035             if (strict) {
1036                 ret = 1;
1037                 qprintf(quiet, "Strict mode: Offset %" PRId64
1038                         " allocation mismatch!\n",
1039                         sectors_to_bytes(sector_num));
1040                 goto out;
1041             }
1042
1043             if (allocated1) {
1044                 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1045                                           filename1, buf1, quiet);
1046             } else {
1047                 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1048                                           filename2, buf1, quiet);
1049             }
1050             if (ret) {
1051                 if (ret < 0) {
1052                     error_report("Error while reading offset %" PRId64 ": %s",
1053                                  sectors_to_bytes(sector_num), strerror(-ret));
1054                     ret = 4;
1055                 }
1056                 goto out;
1057             }
1058         }
1059         sector_num += nb_sectors;
1060         qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1061     }
1062
1063     if (total_sectors1 != total_sectors2) {
1064         BlockDriverState *bs_over;
1065         int64_t total_sectors_over;
1066         const char *filename_over;
1067
1068         qprintf(quiet, "Warning: Image size mismatch!\n");
1069         if (total_sectors1 > total_sectors2) {
1070             total_sectors_over = total_sectors1;
1071             bs_over = bs1;
1072             filename_over = filename1;
1073         } else {
1074             total_sectors_over = total_sectors2;
1075             bs_over = bs2;
1076             filename_over = filename2;
1077         }
1078
1079         for (;;) {
1080             nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1081             if (nb_sectors <= 0) {
1082                 break;
1083             }
1084             ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1085                                           nb_sectors, &pnum);
1086             if (ret < 0) {
1087                 ret = 3;
1088                 error_report("Sector allocation test failed for %s",
1089                              filename_over);
1090                 goto out;
1091
1092             }
1093             nb_sectors = pnum;
1094             if (ret) {
1095                 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1096                                           filename_over, buf1, quiet);
1097                 if (ret) {
1098                     if (ret < 0) {
1099                         error_report("Error while reading offset %" PRId64
1100                                      " of %s: %s", sectors_to_bytes(sector_num),
1101                                      filename_over, strerror(-ret));
1102                         ret = 4;
1103                     }
1104                     goto out;
1105                 }
1106             }
1107             sector_num += nb_sectors;
1108             qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1109         }
1110     }
1111
1112     qprintf(quiet, "Images are identical.\n");
1113     ret = 0;
1114
1115 out:
1116     bdrv_unref(bs2);
1117     qemu_vfree(buf1);
1118     qemu_vfree(buf2);
1119 out2:
1120     bdrv_unref(bs1);
1121 out3:
1122     qemu_progress_end();
1123     return ret;
1124 }
1125
1126 static int img_convert(int argc, char **argv)
1127 {
1128     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size,
1129         cluster_sectors, skip_create;
1130     int progress = 0, flags;
1131     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1132     BlockDriver *drv, *proto_drv;
1133     BlockDriverState **bs = NULL, *out_bs = NULL;
1134     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1135     uint64_t bs_sectors;
1136     uint8_t * buf = NULL;
1137     const uint8_t *buf1;
1138     BlockDriverInfo bdi;
1139     QEMUOptionParameter *param = NULL, *create_options = NULL;
1140     QEMUOptionParameter *out_baseimg_param;
1141     char *options = NULL;
1142     const char *snapshot_name = NULL;
1143     float local_progress = 0;
1144     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1145     bool quiet = false;
1146     Error *local_err = NULL;
1147
1148     fmt = NULL;
1149     out_fmt = "raw";
1150     cache = "unsafe";
1151     out_baseimg = NULL;
1152     compress = 0;
1153     skip_create = 0;
1154     for(;;) {
1155         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:qn");
1156         if (c == -1) {
1157             break;
1158         }
1159         switch(c) {
1160         case '?':
1161         case 'h':
1162             help();
1163             break;
1164         case 'f':
1165             fmt = optarg;
1166             break;
1167         case 'O':
1168             out_fmt = optarg;
1169             break;
1170         case 'B':
1171             out_baseimg = optarg;
1172             break;
1173         case 'c':
1174             compress = 1;
1175             break;
1176         case 'e':
1177             error_report("option -e is deprecated, please use \'-o "
1178                   "encryption\' instead!");
1179             return 1;
1180         case '6':
1181             error_report("option -6 is deprecated, please use \'-o "
1182                   "compat6\' instead!");
1183             return 1;
1184         case 'o':
1185             options = optarg;
1186             break;
1187         case 's':
1188             snapshot_name = optarg;
1189             break;
1190         case 'S':
1191         {
1192             int64_t sval;
1193             char *end;
1194             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1195             if (sval < 0 || *end) {
1196                 error_report("Invalid minimum zero buffer size for sparse output specified");
1197                 return 1;
1198             }
1199
1200             min_sparse = sval / BDRV_SECTOR_SIZE;
1201             break;
1202         }
1203         case 'p':
1204             progress = 1;
1205             break;
1206         case 't':
1207             cache = optarg;
1208             break;
1209         case 'q':
1210             quiet = true;
1211             break;
1212         case 'n':
1213             skip_create = 1;
1214             break;
1215         }
1216     }
1217
1218     if (quiet) {
1219         progress = 0;
1220     }
1221
1222     bs_n = argc - optind - 1;
1223     if (bs_n < 1) {
1224         help();
1225     }
1226
1227     out_filename = argv[argc - 1];
1228
1229     /* Initialize before goto out */
1230     qemu_progress_init(progress, 2.0);
1231
1232     if (options && is_help_option(options)) {
1233         ret = print_block_option_help(out_filename, out_fmt);
1234         goto out;
1235     }
1236
1237     if (bs_n > 1 && out_baseimg) {
1238         error_report("-B makes no sense when concatenating multiple input "
1239                      "images");
1240         ret = -1;
1241         goto out;
1242     }
1243
1244     qemu_progress_print(0, 100);
1245
1246     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
1247
1248     total_sectors = 0;
1249     for (bs_i = 0; bs_i < bs_n; bs_i++) {
1250         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1251                                  quiet);
1252         if (!bs[bs_i]) {
1253             error_report("Could not open '%s'", argv[optind + bs_i]);
1254             ret = -1;
1255             goto out;
1256         }
1257         bdrv_get_geometry(bs[bs_i], &bs_sectors);
1258         total_sectors += bs_sectors;
1259     }
1260
1261     if (snapshot_name != NULL) {
1262         if (bs_n > 1) {
1263             error_report("No support for concatenating multiple snapshot");
1264             ret = -1;
1265             goto out;
1266         }
1267         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1268             error_report("Failed to load snapshot");
1269             ret = -1;
1270             goto out;
1271         }
1272     }
1273
1274     /* Find driver and parse its options */
1275     drv = bdrv_find_format(out_fmt);
1276     if (!drv) {
1277         error_report("Unknown file format '%s'", out_fmt);
1278         ret = -1;
1279         goto out;
1280     }
1281
1282     proto_drv = bdrv_find_protocol(out_filename, true);
1283     if (!proto_drv) {
1284         error_report("Unknown protocol '%s'", out_filename);
1285         ret = -1;
1286         goto out;
1287     }
1288
1289     create_options = append_option_parameters(create_options,
1290                                               drv->create_options);
1291     create_options = append_option_parameters(create_options,
1292                                               proto_drv->create_options);
1293
1294     if (options) {
1295         param = parse_option_parameters(options, create_options, param);
1296         if (param == NULL) {
1297             error_report("Invalid options for file format '%s'.", out_fmt);
1298             ret = -1;
1299             goto out;
1300         }
1301     } else {
1302         param = parse_option_parameters("", create_options, param);
1303     }
1304
1305     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1306     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1307     if (ret < 0) {
1308         goto out;
1309     }
1310
1311     /* Get backing file name if -o backing_file was used */
1312     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1313     if (out_baseimg_param) {
1314         out_baseimg = out_baseimg_param->value.s;
1315     }
1316
1317     /* Check if compression is supported */
1318     if (compress) {
1319         QEMUOptionParameter *encryption =
1320             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1321         QEMUOptionParameter *preallocation =
1322             get_option_parameter(param, BLOCK_OPT_PREALLOC);
1323
1324         if (!drv->bdrv_write_compressed) {
1325             error_report("Compression not supported for this file format");
1326             ret = -1;
1327             goto out;
1328         }
1329
1330         if (encryption && encryption->value.n) {
1331             error_report("Compression and encryption not supported at "
1332                          "the same time");
1333             ret = -1;
1334             goto out;
1335         }
1336
1337         if (preallocation && preallocation->value.s
1338             && strcmp(preallocation->value.s, "off"))
1339         {
1340             error_report("Compression and preallocation not supported at "
1341                          "the same time");
1342             ret = -1;
1343             goto out;
1344         }
1345     }
1346
1347     if (!skip_create) {
1348         /* Create the new image */
1349         ret = bdrv_create(drv, out_filename, param, &local_err);
1350         if (ret < 0) {
1351             error_report("%s: error while converting %s: %s",
1352                          out_filename, out_fmt, error_get_pretty(local_err));
1353             error_free(local_err);
1354             goto out;
1355         }
1356     }
1357
1358     flags = BDRV_O_RDWR;
1359     ret = bdrv_parse_cache_flags(cache, &flags);
1360     if (ret < 0) {
1361         error_report("Invalid cache option: %s", cache);
1362         return -1;
1363     }
1364
1365     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1366     if (!out_bs) {
1367         ret = -1;
1368         goto out;
1369     }
1370
1371     bs_i = 0;
1372     bs_offset = 0;
1373     bdrv_get_geometry(bs[0], &bs_sectors);
1374     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1375
1376     if (skip_create) {
1377         int64_t output_length = bdrv_getlength(out_bs);
1378         if (output_length < 0) {
1379             error_report("unable to get output image length: %s\n",
1380                          strerror(-output_length));
1381             ret = -1;
1382             goto out;
1383         } else if (output_length < total_sectors << BDRV_SECTOR_BITS) {
1384             error_report("output file is smaller than input file");
1385             ret = -1;
1386             goto out;
1387         }
1388     }
1389
1390     if (compress) {
1391         ret = bdrv_get_info(out_bs, &bdi);
1392         if (ret < 0) {
1393             error_report("could not get block driver info");
1394             goto out;
1395         }
1396         cluster_size = bdi.cluster_size;
1397         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1398             error_report("invalid cluster size");
1399             ret = -1;
1400             goto out;
1401         }
1402         cluster_sectors = cluster_size >> 9;
1403         sector_num = 0;
1404
1405         nb_sectors = total_sectors;
1406         if (nb_sectors != 0) {
1407             local_progress = (float)100 /
1408                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1409         }
1410
1411         for(;;) {
1412             int64_t bs_num;
1413             int remainder;
1414             uint8_t *buf2;
1415
1416             nb_sectors = total_sectors - sector_num;
1417             if (nb_sectors <= 0)
1418                 break;
1419             if (nb_sectors >= cluster_sectors)
1420                 n = cluster_sectors;
1421             else
1422                 n = nb_sectors;
1423
1424             bs_num = sector_num - bs_offset;
1425             assert (bs_num >= 0);
1426             remainder = n;
1427             buf2 = buf;
1428             while (remainder > 0) {
1429                 int nlow;
1430                 while (bs_num == bs_sectors) {
1431                     bs_i++;
1432                     assert (bs_i < bs_n);
1433                     bs_offset += bs_sectors;
1434                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
1435                     bs_num = 0;
1436                     /* printf("changing part: sector_num=%" PRId64 ", "
1437                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1438                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1439                 }
1440                 assert (bs_num < bs_sectors);
1441
1442                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1443
1444                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1445                 if (ret < 0) {
1446                     error_report("error while reading sector %" PRId64 ": %s",
1447                                  bs_num, strerror(-ret));
1448                     goto out;
1449                 }
1450
1451                 buf2 += nlow * 512;
1452                 bs_num += nlow;
1453
1454                 remainder -= nlow;
1455             }
1456             assert (remainder == 0);
1457
1458             if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1459                 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1460                 if (ret != 0) {
1461                     error_report("error while compressing sector %" PRId64
1462                                  ": %s", sector_num, strerror(-ret));
1463                     goto out;
1464                 }
1465             }
1466             sector_num += n;
1467             qemu_progress_print(local_progress, 100);
1468         }
1469         /* signal EOF to align */
1470         bdrv_write_compressed(out_bs, 0, NULL, 0);
1471     } else {
1472         int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0;
1473
1474         sector_num = 0; // total number of sectors converted so far
1475         nb_sectors = total_sectors - sector_num;
1476         if (nb_sectors != 0) {
1477             local_progress = (float)100 /
1478                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1479         }
1480
1481         for(;;) {
1482             nb_sectors = total_sectors - sector_num;
1483             if (nb_sectors <= 0) {
1484                 break;
1485             }
1486             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1487                 n = (IO_BUF_SIZE / 512);
1488             } else {
1489                 n = nb_sectors;
1490             }
1491
1492             while (sector_num - bs_offset >= bs_sectors) {
1493                 bs_i ++;
1494                 assert (bs_i < bs_n);
1495                 bs_offset += bs_sectors;
1496                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1497                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1498                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1499                    sector_num, bs_i, bs_offset, bs_sectors); */
1500             }
1501
1502             if (n > bs_offset + bs_sectors - sector_num) {
1503                 n = bs_offset + bs_sectors - sector_num;
1504             }
1505
1506             /* If the output image is being created as a copy on write image,
1507                assume that sectors which are unallocated in the input image
1508                are present in both the output's and input's base images (no
1509                need to copy them). */
1510             if (out_baseimg) {
1511                 ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1512                                         n, &n1);
1513                 if (ret < 0) {
1514                     error_report("error while reading metadata for sector "
1515                                  "%" PRId64 ": %s",
1516                                  sector_num - bs_offset, strerror(-ret));
1517                     goto out;
1518                 }
1519                 if (!ret) {
1520                     sector_num += n1;
1521                     continue;
1522                 }
1523                 /* The next 'n1' sectors are allocated in the input image. Copy
1524                    only those as they may be followed by unallocated sectors. */
1525                 n = n1;
1526             } else {
1527                 n1 = n;
1528             }
1529
1530             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1531             if (ret < 0) {
1532                 error_report("error while reading sector %" PRId64 ": %s",
1533                              sector_num - bs_offset, strerror(-ret));
1534                 goto out;
1535             }
1536             /* NOTE: at the same time we convert, we do not write zero
1537                sectors to have a chance to compress the image. Ideally, we
1538                should add a specific call to have the info to go faster */
1539             buf1 = buf;
1540             while (n > 0) {
1541                 if (!has_zero_init ||
1542                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1543                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1544                     if (ret < 0) {
1545                         error_report("error while writing sector %" PRId64
1546                                      ": %s", sector_num, strerror(-ret));
1547                         goto out;
1548                     }
1549                 }
1550                 sector_num += n1;
1551                 n -= n1;
1552                 buf1 += n1 * 512;
1553             }
1554             qemu_progress_print(local_progress, 100);
1555         }
1556     }
1557 out:
1558     qemu_progress_end();
1559     free_option_parameters(create_options);
1560     free_option_parameters(param);
1561     qemu_vfree(buf);
1562     if (out_bs) {
1563         bdrv_unref(out_bs);
1564     }
1565     if (bs) {
1566         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1567             if (bs[bs_i]) {
1568                 bdrv_unref(bs[bs_i]);
1569             }
1570         }
1571         g_free(bs);
1572     }
1573     if (ret) {
1574         return 1;
1575     }
1576     return 0;
1577 }
1578
1579
1580 static void dump_snapshots(BlockDriverState *bs)
1581 {
1582     QEMUSnapshotInfo *sn_tab, *sn;
1583     int nb_sns, i;
1584
1585     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1586     if (nb_sns <= 0)
1587         return;
1588     printf("Snapshot list:\n");
1589     bdrv_snapshot_dump(fprintf, stdout, NULL);
1590     printf("\n");
1591     for(i = 0; i < nb_sns; i++) {
1592         sn = &sn_tab[i];
1593         bdrv_snapshot_dump(fprintf, stdout, sn);
1594         printf("\n");
1595     }
1596     g_free(sn_tab);
1597 }
1598
1599 static void dump_json_image_info_list(ImageInfoList *list)
1600 {
1601     Error *errp = NULL;
1602     QString *str;
1603     QmpOutputVisitor *ov = qmp_output_visitor_new();
1604     QObject *obj;
1605     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1606                              &list, NULL, &errp);
1607     obj = qmp_output_get_qobject(ov);
1608     str = qobject_to_json_pretty(obj);
1609     assert(str != NULL);
1610     printf("%s\n", qstring_get_str(str));
1611     qobject_decref(obj);
1612     qmp_output_visitor_cleanup(ov);
1613     QDECREF(str);
1614 }
1615
1616 static void dump_json_image_info(ImageInfo *info)
1617 {
1618     Error *errp = NULL;
1619     QString *str;
1620     QmpOutputVisitor *ov = qmp_output_visitor_new();
1621     QObject *obj;
1622     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1623                          &info, NULL, &errp);
1624     obj = qmp_output_get_qobject(ov);
1625     str = qobject_to_json_pretty(obj);
1626     assert(str != NULL);
1627     printf("%s\n", qstring_get_str(str));
1628     qobject_decref(obj);
1629     qmp_output_visitor_cleanup(ov);
1630     QDECREF(str);
1631 }
1632
1633 static void dump_human_image_info_list(ImageInfoList *list)
1634 {
1635     ImageInfoList *elem;
1636     bool delim = false;
1637
1638     for (elem = list; elem; elem = elem->next) {
1639         if (delim) {
1640             printf("\n");
1641         }
1642         delim = true;
1643
1644         bdrv_image_info_dump(fprintf, stdout, elem->value);
1645     }
1646 }
1647
1648 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1649 {
1650     return strcmp(a, b) == 0;
1651 }
1652
1653 /**
1654  * Open an image file chain and return an ImageInfoList
1655  *
1656  * @filename: topmost image filename
1657  * @fmt: topmost image format (may be NULL to autodetect)
1658  * @chain: true  - enumerate entire backing file chain
1659  *         false - only topmost image file
1660  *
1661  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1662  * image file.  If there was an error a message will have been printed to
1663  * stderr.
1664  */
1665 static ImageInfoList *collect_image_info_list(const char *filename,
1666                                               const char *fmt,
1667                                               bool chain)
1668 {
1669     ImageInfoList *head = NULL;
1670     ImageInfoList **last = &head;
1671     GHashTable *filenames;
1672     Error *err = NULL;
1673
1674     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1675
1676     while (filename) {
1677         BlockDriverState *bs;
1678         ImageInfo *info;
1679         ImageInfoList *elem;
1680
1681         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1682             error_report("Backing file '%s' creates an infinite loop.",
1683                          filename);
1684             goto err;
1685         }
1686         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1687
1688         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1689                            false, false);
1690         if (!bs) {
1691             goto err;
1692         }
1693
1694         bdrv_query_image_info(bs, &info, &err);
1695         if (error_is_set(&err)) {
1696             error_report("%s", error_get_pretty(err));
1697             error_free(err);
1698             goto err;
1699         }
1700
1701         elem = g_new0(ImageInfoList, 1);
1702         elem->value = info;
1703         *last = elem;
1704         last = &elem->next;
1705
1706         bdrv_unref(bs);
1707
1708         filename = fmt = NULL;
1709         if (chain) {
1710             if (info->has_full_backing_filename) {
1711                 filename = info->full_backing_filename;
1712             } else if (info->has_backing_filename) {
1713                 filename = info->backing_filename;
1714             }
1715             if (info->has_backing_filename_format) {
1716                 fmt = info->backing_filename_format;
1717             }
1718         }
1719     }
1720     g_hash_table_destroy(filenames);
1721     return head;
1722
1723 err:
1724     qapi_free_ImageInfoList(head);
1725     g_hash_table_destroy(filenames);
1726     return NULL;
1727 }
1728
1729 static int img_info(int argc, char **argv)
1730 {
1731     int c;
1732     OutputFormat output_format = OFORMAT_HUMAN;
1733     bool chain = false;
1734     const char *filename, *fmt, *output;
1735     ImageInfoList *list;
1736
1737     fmt = NULL;
1738     output = NULL;
1739     for(;;) {
1740         int option_index = 0;
1741         static const struct option long_options[] = {
1742             {"help", no_argument, 0, 'h'},
1743             {"format", required_argument, 0, 'f'},
1744             {"output", required_argument, 0, OPTION_OUTPUT},
1745             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1746             {0, 0, 0, 0}
1747         };
1748         c = getopt_long(argc, argv, "f:h",
1749                         long_options, &option_index);
1750         if (c == -1) {
1751             break;
1752         }
1753         switch(c) {
1754         case '?':
1755         case 'h':
1756             help();
1757             break;
1758         case 'f':
1759             fmt = optarg;
1760             break;
1761         case OPTION_OUTPUT:
1762             output = optarg;
1763             break;
1764         case OPTION_BACKING_CHAIN:
1765             chain = true;
1766             break;
1767         }
1768     }
1769     if (optind != argc - 1) {
1770         help();
1771     }
1772     filename = argv[optind++];
1773
1774     if (output && !strcmp(output, "json")) {
1775         output_format = OFORMAT_JSON;
1776     } else if (output && !strcmp(output, "human")) {
1777         output_format = OFORMAT_HUMAN;
1778     } else if (output) {
1779         error_report("--output must be used with human or json as argument.");
1780         return 1;
1781     }
1782
1783     list = collect_image_info_list(filename, fmt, chain);
1784     if (!list) {
1785         return 1;
1786     }
1787
1788     switch (output_format) {
1789     case OFORMAT_HUMAN:
1790         dump_human_image_info_list(list);
1791         break;
1792     case OFORMAT_JSON:
1793         if (chain) {
1794             dump_json_image_info_list(list);
1795         } else {
1796             dump_json_image_info(list->value);
1797         }
1798         break;
1799     }
1800
1801     qapi_free_ImageInfoList(list);
1802     return 0;
1803 }
1804
1805
1806 typedef struct MapEntry {
1807     int flags;
1808     int depth;
1809     int64_t start;
1810     int64_t length;
1811     int64_t offset;
1812     BlockDriverState *bs;
1813 } MapEntry;
1814
1815 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
1816                            MapEntry *next)
1817 {
1818     switch (output_format) {
1819     case OFORMAT_HUMAN:
1820         if ((e->flags & BDRV_BLOCK_DATA) &&
1821             !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
1822             error_report("File contains external, encrypted or compressed clusters.");
1823             exit(1);
1824         }
1825         if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
1826             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
1827                    e->start, e->length, e->offset, e->bs->filename);
1828         }
1829         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
1830          * Modify the flags here to allow more coalescing.
1831          */
1832         if (next &&
1833             (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
1834             next->flags &= ~BDRV_BLOCK_DATA;
1835             next->flags |= BDRV_BLOCK_ZERO;
1836         }
1837         break;
1838     case OFORMAT_JSON:
1839         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
1840                " \"zero\": %s, \"data\": %s",
1841                (e->start == 0 ? "[" : ",\n"),
1842                e->start, e->length, e->depth,
1843                (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
1844                (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
1845         if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
1846             printf(", \"offset\": %"PRId64"", e->offset);
1847         }
1848         putchar('}');
1849
1850         if (!next) {
1851             printf("]\n");
1852         }
1853         break;
1854     }
1855 }
1856
1857 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
1858                             int nb_sectors, MapEntry *e)
1859 {
1860     int64_t ret;
1861     int depth;
1862
1863     /* As an optimization, we could cache the current range of unallocated
1864      * clusters in each file of the chain, and avoid querying the same
1865      * range repeatedly.
1866      */
1867
1868     depth = 0;
1869     for (;;) {
1870         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
1871         if (ret < 0) {
1872             return ret;
1873         }
1874         assert(nb_sectors);
1875         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
1876             break;
1877         }
1878         bs = bs->backing_hd;
1879         if (bs == NULL) {
1880             ret = 0;
1881             break;
1882         }
1883
1884         depth++;
1885     }
1886
1887     e->start = sector_num * BDRV_SECTOR_SIZE;
1888     e->length = nb_sectors * BDRV_SECTOR_SIZE;
1889     e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
1890     e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
1891     e->depth = depth;
1892     e->bs = bs;
1893     return 0;
1894 }
1895
1896 static int img_map(int argc, char **argv)
1897 {
1898     int c;
1899     OutputFormat output_format = OFORMAT_HUMAN;
1900     BlockDriverState *bs;
1901     const char *filename, *fmt, *output;
1902     int64_t length;
1903     MapEntry curr = { .length = 0 }, next;
1904     int ret = 0;
1905
1906     fmt = NULL;
1907     output = NULL;
1908     for (;;) {
1909         int option_index = 0;
1910         static const struct option long_options[] = {
1911             {"help", no_argument, 0, 'h'},
1912             {"format", required_argument, 0, 'f'},
1913             {"output", required_argument, 0, OPTION_OUTPUT},
1914             {0, 0, 0, 0}
1915         };
1916         c = getopt_long(argc, argv, "f:h",
1917                         long_options, &option_index);
1918         if (c == -1) {
1919             break;
1920         }
1921         switch (c) {
1922         case '?':
1923         case 'h':
1924             help();
1925             break;
1926         case 'f':
1927             fmt = optarg;
1928             break;
1929         case OPTION_OUTPUT:
1930             output = optarg;
1931             break;
1932         }
1933     }
1934     if (optind >= argc) {
1935         help();
1936     }
1937     filename = argv[optind++];
1938
1939     if (output && !strcmp(output, "json")) {
1940         output_format = OFORMAT_JSON;
1941     } else if (output && !strcmp(output, "human")) {
1942         output_format = OFORMAT_HUMAN;
1943     } else if (output) {
1944         error_report("--output must be used with human or json as argument.");
1945         return 1;
1946     }
1947
1948     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS, true, false);
1949     if (!bs) {
1950         return 1;
1951     }
1952
1953     if (output_format == OFORMAT_HUMAN) {
1954         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
1955     }
1956
1957     length = bdrv_getlength(bs);
1958     while (curr.start + curr.length < length) {
1959         int64_t nsectors_left;
1960         int64_t sector_num;
1961         int n;
1962
1963         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
1964
1965         /* Probe up to 1 GiB at a time.  */
1966         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
1967         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
1968         ret = get_block_status(bs, sector_num, n, &next);
1969
1970         if (ret < 0) {
1971             error_report("Could not read file metadata: %s", strerror(-ret));
1972             goto out;
1973         }
1974
1975         if (curr.length != 0 && curr.flags == next.flags &&
1976             curr.depth == next.depth &&
1977             ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
1978              curr.offset + curr.length == next.offset)) {
1979             curr.length += next.length;
1980             continue;
1981         }
1982
1983         if (curr.length > 0) {
1984             dump_map_entry(output_format, &curr, &next);
1985         }
1986         curr = next;
1987     }
1988
1989     dump_map_entry(output_format, &curr, NULL);
1990
1991 out:
1992     bdrv_unref(bs);
1993     return ret < 0;
1994 }
1995
1996 #define SNAPSHOT_LIST   1
1997 #define SNAPSHOT_CREATE 2
1998 #define SNAPSHOT_APPLY  3
1999 #define SNAPSHOT_DELETE 4
2000
2001 static int img_snapshot(int argc, char **argv)
2002 {
2003     BlockDriverState *bs;
2004     QEMUSnapshotInfo sn;
2005     char *filename, *snapshot_name = NULL;
2006     int c, ret = 0, bdrv_oflags;
2007     int action = 0;
2008     qemu_timeval tv;
2009     bool quiet = false;
2010     Error *err = NULL;
2011
2012     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2013     /* Parse commandline parameters */
2014     for(;;) {
2015         c = getopt(argc, argv, "la:c:d:hq");
2016         if (c == -1) {
2017             break;
2018         }
2019         switch(c) {
2020         case '?':
2021         case 'h':
2022             help();
2023             return 0;
2024         case 'l':
2025             if (action) {
2026                 help();
2027                 return 0;
2028             }
2029             action = SNAPSHOT_LIST;
2030             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2031             break;
2032         case 'a':
2033             if (action) {
2034                 help();
2035                 return 0;
2036             }
2037             action = SNAPSHOT_APPLY;
2038             snapshot_name = optarg;
2039             break;
2040         case 'c':
2041             if (action) {
2042                 help();
2043                 return 0;
2044             }
2045             action = SNAPSHOT_CREATE;
2046             snapshot_name = optarg;
2047             break;
2048         case 'd':
2049             if (action) {
2050                 help();
2051                 return 0;
2052             }
2053             action = SNAPSHOT_DELETE;
2054             snapshot_name = optarg;
2055             break;
2056         case 'q':
2057             quiet = true;
2058             break;
2059         }
2060     }
2061
2062     if (optind != argc - 1) {
2063         help();
2064     }
2065     filename = argv[optind++];
2066
2067     /* Open the image */
2068     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
2069     if (!bs) {
2070         return 1;
2071     }
2072
2073     /* Perform the requested action */
2074     switch(action) {
2075     case SNAPSHOT_LIST:
2076         dump_snapshots(bs);
2077         break;
2078
2079     case SNAPSHOT_CREATE:
2080         memset(&sn, 0, sizeof(sn));
2081         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2082
2083         qemu_gettimeofday(&tv);
2084         sn.date_sec = tv.tv_sec;
2085         sn.date_nsec = tv.tv_usec * 1000;
2086
2087         ret = bdrv_snapshot_create(bs, &sn);
2088         if (ret) {
2089             error_report("Could not create snapshot '%s': %d (%s)",
2090                 snapshot_name, ret, strerror(-ret));
2091         }
2092         break;
2093
2094     case SNAPSHOT_APPLY:
2095         ret = bdrv_snapshot_goto(bs, snapshot_name);
2096         if (ret) {
2097             error_report("Could not apply snapshot '%s': %d (%s)",
2098                 snapshot_name, ret, strerror(-ret));
2099         }
2100         break;
2101
2102     case SNAPSHOT_DELETE:
2103         bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2104         if (error_is_set(&err)) {
2105             error_report("Could not delete snapshot '%s': (%s)",
2106                          snapshot_name, error_get_pretty(err));
2107             error_free(err);
2108             ret = 1;
2109         }
2110         break;
2111     }
2112
2113     /* Cleanup */
2114     bdrv_unref(bs);
2115     if (ret) {
2116         return 1;
2117     }
2118     return 0;
2119 }
2120
2121 static int img_rebase(int argc, char **argv)
2122 {
2123     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2124     BlockDriver *old_backing_drv, *new_backing_drv;
2125     char *filename;
2126     const char *fmt, *cache, *out_basefmt, *out_baseimg;
2127     int c, flags, ret;
2128     int unsafe = 0;
2129     int progress = 0;
2130     bool quiet = false;
2131     Error *local_err = NULL;
2132
2133     /* Parse commandline parameters */
2134     fmt = NULL;
2135     cache = BDRV_DEFAULT_CACHE;
2136     out_baseimg = NULL;
2137     out_basefmt = NULL;
2138     for(;;) {
2139         c = getopt(argc, argv, "uhf:F:b:pt:q");
2140         if (c == -1) {
2141             break;
2142         }
2143         switch(c) {
2144         case '?':
2145         case 'h':
2146             help();
2147             return 0;
2148         case 'f':
2149             fmt = optarg;
2150             break;
2151         case 'F':
2152             out_basefmt = optarg;
2153             break;
2154         case 'b':
2155             out_baseimg = optarg;
2156             break;
2157         case 'u':
2158             unsafe = 1;
2159             break;
2160         case 'p':
2161             progress = 1;
2162             break;
2163         case 't':
2164             cache = optarg;
2165             break;
2166         case 'q':
2167             quiet = true;
2168             break;
2169         }
2170     }
2171
2172     if (quiet) {
2173         progress = 0;
2174     }
2175
2176     if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
2177         help();
2178     }
2179     filename = argv[optind++];
2180
2181     qemu_progress_init(progress, 2.0);
2182     qemu_progress_print(0, 100);
2183
2184     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2185     ret = bdrv_parse_cache_flags(cache, &flags);
2186     if (ret < 0) {
2187         error_report("Invalid cache option: %s", cache);
2188         return -1;
2189     }
2190
2191     /*
2192      * Open the images.
2193      *
2194      * Ignore the old backing file for unsafe rebase in case we want to correct
2195      * the reference to a renamed or moved backing file.
2196      */
2197     bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2198     if (!bs) {
2199         return 1;
2200     }
2201
2202     /* Find the right drivers for the backing files */
2203     old_backing_drv = NULL;
2204     new_backing_drv = NULL;
2205
2206     if (!unsafe && bs->backing_format[0] != '\0') {
2207         old_backing_drv = bdrv_find_format(bs->backing_format);
2208         if (old_backing_drv == NULL) {
2209             error_report("Invalid format name: '%s'", bs->backing_format);
2210             ret = -1;
2211             goto out;
2212         }
2213     }
2214
2215     if (out_basefmt != NULL) {
2216         new_backing_drv = bdrv_find_format(out_basefmt);
2217         if (new_backing_drv == NULL) {
2218             error_report("Invalid format name: '%s'", out_basefmt);
2219             ret = -1;
2220             goto out;
2221         }
2222     }
2223
2224     /* For safe rebasing we need to compare old and new backing file */
2225     if (unsafe) {
2226         /* Make the compiler happy */
2227         bs_old_backing = NULL;
2228         bs_new_backing = NULL;
2229     } else {
2230         char backing_name[1024];
2231
2232         bs_old_backing = bdrv_new("old_backing");
2233         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2234         ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2235                         old_backing_drv, &local_err);
2236         if (ret) {
2237             error_report("Could not open old backing file '%s': %s",
2238                          backing_name, error_get_pretty(local_err));
2239             error_free(local_err);
2240             goto out;
2241         }
2242         if (out_baseimg[0]) {
2243             bs_new_backing = bdrv_new("new_backing");
2244             ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2245                         new_backing_drv, &local_err);
2246             if (ret) {
2247                 error_report("Could not open new backing file '%s': %s",
2248                              out_baseimg, error_get_pretty(local_err));
2249                 error_free(local_err);
2250                 goto out;
2251             }
2252         }
2253     }
2254
2255     /*
2256      * Check each unallocated cluster in the COW file. If it is unallocated,
2257      * accesses go to the backing file. We must therefore compare this cluster
2258      * in the old and new backing file, and if they differ we need to copy it
2259      * from the old backing file into the COW file.
2260      *
2261      * If qemu-img crashes during this step, no harm is done. The content of
2262      * the image is the same as the original one at any time.
2263      */
2264     if (!unsafe) {
2265         uint64_t num_sectors;
2266         uint64_t old_backing_num_sectors;
2267         uint64_t new_backing_num_sectors = 0;
2268         uint64_t sector;
2269         int n;
2270         uint8_t * buf_old;
2271         uint8_t * buf_new;
2272         float local_progress = 0;
2273
2274         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2275         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2276
2277         bdrv_get_geometry(bs, &num_sectors);
2278         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2279         if (bs_new_backing) {
2280             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2281         }
2282
2283         if (num_sectors != 0) {
2284             local_progress = (float)100 /
2285                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2286         }
2287
2288         for (sector = 0; sector < num_sectors; sector += n) {
2289
2290             /* How many sectors can we handle with the next read? */
2291             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2292                 n = (IO_BUF_SIZE / 512);
2293             } else {
2294                 n = num_sectors - sector;
2295             }
2296
2297             /* If the cluster is allocated, we don't need to take action */
2298             ret = bdrv_is_allocated(bs, sector, n, &n);
2299             if (ret < 0) {
2300                 error_report("error while reading image metadata: %s",
2301                              strerror(-ret));
2302                 goto out;
2303             }
2304             if (ret) {
2305                 continue;
2306             }
2307
2308             /*
2309              * Read old and new backing file and take into consideration that
2310              * backing files may be smaller than the COW image.
2311              */
2312             if (sector >= old_backing_num_sectors) {
2313                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2314             } else {
2315                 if (sector + n > old_backing_num_sectors) {
2316                     n = old_backing_num_sectors - sector;
2317                 }
2318
2319                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2320                 if (ret < 0) {
2321                     error_report("error while reading from old backing file");
2322                     goto out;
2323                 }
2324             }
2325
2326             if (sector >= new_backing_num_sectors || !bs_new_backing) {
2327                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2328             } else {
2329                 if (sector + n > new_backing_num_sectors) {
2330                     n = new_backing_num_sectors - sector;
2331                 }
2332
2333                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2334                 if (ret < 0) {
2335                     error_report("error while reading from new backing file");
2336                     goto out;
2337                 }
2338             }
2339
2340             /* If they differ, we need to write to the COW file */
2341             uint64_t written = 0;
2342
2343             while (written < n) {
2344                 int pnum;
2345
2346                 if (compare_sectors(buf_old + written * 512,
2347                     buf_new + written * 512, n - written, &pnum))
2348                 {
2349                     ret = bdrv_write(bs, sector + written,
2350                         buf_old + written * 512, pnum);
2351                     if (ret < 0) {
2352                         error_report("Error while writing to COW image: %s",
2353                             strerror(-ret));
2354                         goto out;
2355                     }
2356                 }
2357
2358                 written += pnum;
2359             }
2360             qemu_progress_print(local_progress, 100);
2361         }
2362
2363         qemu_vfree(buf_old);
2364         qemu_vfree(buf_new);
2365     }
2366
2367     /*
2368      * Change the backing file. All clusters that are different from the old
2369      * backing file are overwritten in the COW file now, so the visible content
2370      * doesn't change when we switch the backing file.
2371      */
2372     if (out_baseimg && *out_baseimg) {
2373         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2374     } else {
2375         ret = bdrv_change_backing_file(bs, NULL, NULL);
2376     }
2377
2378     if (ret == -ENOSPC) {
2379         error_report("Could not change the backing file to '%s': No "
2380                      "space left in the file header", out_baseimg);
2381     } else if (ret < 0) {
2382         error_report("Could not change the backing file to '%s': %s",
2383             out_baseimg, strerror(-ret));
2384     }
2385
2386     qemu_progress_print(100, 0);
2387     /*
2388      * TODO At this point it is possible to check if any clusters that are
2389      * allocated in the COW file are the same in the backing file. If so, they
2390      * could be dropped from the COW file. Don't do this before switching the
2391      * backing file, in case of a crash this would lead to corruption.
2392      */
2393 out:
2394     qemu_progress_end();
2395     /* Cleanup */
2396     if (!unsafe) {
2397         if (bs_old_backing != NULL) {
2398             bdrv_unref(bs_old_backing);
2399         }
2400         if (bs_new_backing != NULL) {
2401             bdrv_unref(bs_new_backing);
2402         }
2403     }
2404
2405     bdrv_unref(bs);
2406     if (ret) {
2407         return 1;
2408     }
2409     return 0;
2410 }
2411
2412 static int img_resize(int argc, char **argv)
2413 {
2414     int c, ret, relative;
2415     const char *filename, *fmt, *size;
2416     int64_t n, total_size;
2417     bool quiet = false;
2418     BlockDriverState *bs = NULL;
2419     QemuOpts *param;
2420     static QemuOptsList resize_options = {
2421         .name = "resize_options",
2422         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2423         .desc = {
2424             {
2425                 .name = BLOCK_OPT_SIZE,
2426                 .type = QEMU_OPT_SIZE,
2427                 .help = "Virtual disk size"
2428             }, {
2429                 /* end of list */
2430             }
2431         },
2432     };
2433
2434     /* Remove size from argv manually so that negative numbers are not treated
2435      * as options by getopt. */
2436     if (argc < 3) {
2437         help();
2438         return 1;
2439     }
2440
2441     size = argv[--argc];
2442
2443     /* Parse getopt arguments */
2444     fmt = NULL;
2445     for(;;) {
2446         c = getopt(argc, argv, "f:hq");
2447         if (c == -1) {
2448             break;
2449         }
2450         switch(c) {
2451         case '?':
2452         case 'h':
2453             help();
2454             break;
2455         case 'f':
2456             fmt = optarg;
2457             break;
2458         case 'q':
2459             quiet = true;
2460             break;
2461         }
2462     }
2463     if (optind != argc - 1) {
2464         help();
2465     }
2466     filename = argv[optind++];
2467
2468     /* Choose grow, shrink, or absolute resize mode */
2469     switch (size[0]) {
2470     case '+':
2471         relative = 1;
2472         size++;
2473         break;
2474     case '-':
2475         relative = -1;
2476         size++;
2477         break;
2478     default:
2479         relative = 0;
2480         break;
2481     }
2482
2483     /* Parse size */
2484     param = qemu_opts_create_nofail(&resize_options);
2485     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2486         /* Error message already printed when size parsing fails */
2487         ret = -1;
2488         qemu_opts_del(param);
2489         goto out;
2490     }
2491     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2492     qemu_opts_del(param);
2493
2494     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2495     if (!bs) {
2496         ret = -1;
2497         goto out;
2498     }
2499
2500     if (relative) {
2501         total_size = bdrv_getlength(bs) + n * relative;
2502     } else {
2503         total_size = n;
2504     }
2505     if (total_size <= 0) {
2506         error_report("New image size must be positive");
2507         ret = -1;
2508         goto out;
2509     }
2510
2511     ret = bdrv_truncate(bs, total_size);
2512     switch (ret) {
2513     case 0:
2514         qprintf(quiet, "Image resized.\n");
2515         break;
2516     case -ENOTSUP:
2517         error_report("This image does not support resize");
2518         break;
2519     case -EACCES:
2520         error_report("Image is read-only");
2521         break;
2522     default:
2523         error_report("Error resizing image (%d)", -ret);
2524         break;
2525     }
2526 out:
2527     if (bs) {
2528         bdrv_unref(bs);
2529     }
2530     if (ret) {
2531         return 1;
2532     }
2533     return 0;
2534 }
2535
2536 static int img_amend(int argc, char **argv)
2537 {
2538     int c, ret = 0;
2539     char *options = NULL;
2540     QEMUOptionParameter *create_options = NULL, *options_param = NULL;
2541     const char *fmt = NULL, *filename;
2542     bool quiet = false;
2543     BlockDriverState *bs = NULL;
2544
2545     for (;;) {
2546         c = getopt(argc, argv, "hqf:o:");
2547         if (c == -1) {
2548             break;
2549         }
2550
2551         switch (c) {
2552             case 'h':
2553             case '?':
2554                 help();
2555                 break;
2556             case 'o':
2557                 options = optarg;
2558                 break;
2559             case 'f':
2560                 fmt = optarg;
2561                 break;
2562             case 'q':
2563                 quiet = true;
2564                 break;
2565         }
2566     }
2567
2568     if (optind != argc - 1) {
2569         help();
2570     }
2571
2572     if (!options) {
2573         help();
2574     }
2575
2576     filename = argv[argc - 1];
2577
2578     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2579     if (!bs) {
2580         error_report("Could not open image '%s'", filename);
2581         ret = -1;
2582         goto out;
2583     }
2584
2585     fmt = bs->drv->format_name;
2586
2587     if (is_help_option(options)) {
2588         ret = print_block_option_help(filename, fmt);
2589         goto out;
2590     }
2591
2592     create_options = append_option_parameters(create_options,
2593             bs->drv->create_options);
2594     options_param = parse_option_parameters(options, create_options,
2595             options_param);
2596     if (options_param == NULL) {
2597         error_report("Invalid options for file format '%s'", fmt);
2598         ret = -1;
2599         goto out;
2600     }
2601
2602     ret = bdrv_amend_options(bs, options_param);
2603     if (ret < 0) {
2604         error_report("Error while amending options: %s", strerror(-ret));
2605         goto out;
2606     }
2607
2608 out:
2609     if (bs) {
2610         bdrv_unref(bs);
2611     }
2612     free_option_parameters(create_options);
2613     free_option_parameters(options_param);
2614     if (ret) {
2615         return 1;
2616     }
2617     return 0;
2618 }
2619
2620 static const img_cmd_t img_cmds[] = {
2621 #define DEF(option, callback, arg_string)        \
2622     { option, callback },
2623 #include "qemu-img-cmds.h"
2624 #undef DEF
2625 #undef GEN_DOCS
2626     { NULL, NULL, },
2627 };
2628
2629 int main(int argc, char **argv)
2630 {
2631     const img_cmd_t *cmd;
2632     const char *cmdname;
2633
2634 #ifdef CONFIG_POSIX
2635     signal(SIGPIPE, SIG_IGN);
2636 #endif
2637
2638     error_set_progname(argv[0]);
2639
2640     qemu_init_main_loop();
2641     bdrv_init();
2642     if (argc < 2)
2643         help();
2644     cmdname = argv[1];
2645     argc--; argv++;
2646
2647     /* find the command */
2648     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2649         if (!strcmp(cmdname, cmd->name)) {
2650             return cmd->handler(argc, argv);
2651         }
2652     }
2653
2654     /* not found */
2655     help();
2656     return 0;
2657 }