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 25 #include "qemu/osdep.h" 26 #include <getopt.h> 27 28 #include "qemu-version.h" 29 #include "qapi/error.h" 30 #include "qapi/qapi-visit-block-core.h" 31 #include "qapi/qobject-output-visitor.h" 32 #include "qapi/qmp/qjson.h" 33 #include "qapi/qmp/qdict.h" 34 #include "qapi/qmp/qstring.h" 35 #include "qemu/cutils.h" 36 #include "qemu/config-file.h" 37 #include "qemu/option.h" 38 #include "qemu/error-report.h" 39 #include "qemu/log.h" 40 #include "qom/object_interfaces.h" 41 #include "sysemu/sysemu.h" 42 #include "sysemu/block-backend.h" 43 #include "block/block_int.h" 44 #include "block/blockjob.h" 45 #include "block/qapi.h" 46 #include "crypto/init.h" 47 #include "trace/control.h" 48 49 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \ 50 "\n" QEMU_COPYRIGHT "\n" 51 52 typedef struct img_cmd_t { 53 const char *name; 54 int (*handler)(int argc, char **argv); 55 } img_cmd_t; 56 57 enum { 58 OPTION_OUTPUT = 256, 59 OPTION_BACKING_CHAIN = 257, 60 OPTION_OBJECT = 258, 61 OPTION_IMAGE_OPTS = 259, 62 OPTION_PATTERN = 260, 63 OPTION_FLUSH_INTERVAL = 261, 64 OPTION_NO_DRAIN = 262, 65 OPTION_TARGET_IMAGE_OPTS = 263, 66 OPTION_SIZE = 264, 67 OPTION_PREALLOCATION = 265, 68 OPTION_SHRINK = 266, 69 }; 70 71 typedef enum OutputFormat { 72 OFORMAT_JSON, 73 OFORMAT_HUMAN, 74 } OutputFormat; 75 76 /* Default to cache=writeback as data integrity is not important for qemu-img */ 77 #define BDRV_DEFAULT_CACHE "writeback" 78 79 static void format_print(void *opaque, const char *name) 80 { 81 printf(" %s", name); 82 } 83 84 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...) 85 { 86 va_list ap; 87 88 va_start(ap, fmt); 89 error_vreport(fmt, ap); 90 va_end(ap); 91 92 error_printf("Try 'qemu-img --help' for more information\n"); 93 exit(EXIT_FAILURE); 94 } 95 96 static void QEMU_NORETURN missing_argument(const char *option) 97 { 98 error_exit("missing argument for option '%s'", option); 99 } 100 101 static void QEMU_NORETURN unrecognized_option(const char *option) 102 { 103 error_exit("unrecognized option '%s'", option); 104 } 105 106 /* Please keep in synch with qemu-img.texi */ 107 static void QEMU_NORETURN help(void) 108 { 109 const char *help_msg = 110 QEMU_IMG_VERSION 111 "usage: qemu-img [standard options] command [command options]\n" 112 "QEMU disk image utility\n" 113 "\n" 114 " '-h', '--help' display this help and exit\n" 115 " '-V', '--version' output version information and exit\n" 116 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n" 117 " specify tracing options\n" 118 "\n" 119 "Command syntax:\n" 120 #define DEF(option, callback, arg_string) \ 121 " " arg_string "\n" 122 #include "qemu-img-cmds.h" 123 #undef DEF 124 "\n" 125 "Command parameters:\n" 126 " 'filename' is a disk image filename\n" 127 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n" 128 " manual page for a description of the object properties. The most common\n" 129 " object type is a 'secret', which is used to supply passwords and/or\n" 130 " encryption keys.\n" 131 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 132 " 'cache' is the cache mode used to write the output disk image, the valid\n" 133 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n" 134 " 'directsync' and 'unsafe' (default for convert)\n" 135 " 'src_cache' is the cache mode used to read input disk images, the valid\n" 136 " options are the same as for the 'cache' option\n" 137 " 'size' is the disk image size in bytes. Optional suffixes\n" 138 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n" 139 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n" 140 " supported. 'b' is ignored.\n" 141 " 'output_filename' is the destination disk image filename\n" 142 " 'output_fmt' is the destination format\n" 143 " 'options' is a comma separated list of format specific options in a\n" 144 " name=value format. Use -o ? for an overview of the options supported by the\n" 145 " used format\n" 146 " 'snapshot_param' is param used for internal snapshot, format\n" 147 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n" 148 " '[ID_OR_NAME]'\n" 149 " '-c' indicates that target image must be compressed (qcow format only)\n" 150 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n" 151 " new backing file match exactly. The image doesn't need a working\n" 152 " backing file before rebasing in this case (useful for renaming the\n" 153 " backing file). For image creation, allow creating without attempting\n" 154 " to open the backing file.\n" 155 " '-h' with or without a command shows this help and lists the supported formats\n" 156 " '-p' show progress of command (only certain commands)\n" 157 " '-q' use Quiet mode - do not print any output (except errors)\n" 158 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n" 159 " contain only zeros for qemu-img to create a sparse image during\n" 160 " conversion. If the number of bytes is 0, the source will not be scanned for\n" 161 " unallocated or zero sectors, and the destination image will always be\n" 162 " fully allocated\n" 163 " '--output' takes the format in which the output must be done (human or json)\n" 164 " '-n' skips the target volume creation (useful if the volume is created\n" 165 " prior to running qemu-img)\n" 166 "\n" 167 "Parameters to check subcommand:\n" 168 " '-r' tries to repair any inconsistencies that are found during the check.\n" 169 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n" 170 " kinds of errors, with a higher risk of choosing the wrong fix or\n" 171 " hiding corruption that has already occurred.\n" 172 "\n" 173 "Parameters to convert subcommand:\n" 174 " '-m' specifies how many coroutines work in parallel during the convert\n" 175 " process (defaults to 8)\n" 176 " '-W' allow to write to the target out of order rather than sequential\n" 177 "\n" 178 "Parameters to snapshot subcommand:\n" 179 " 'snapshot' is the name of the snapshot to create, apply or delete\n" 180 " '-a' applies a snapshot (revert disk to saved state)\n" 181 " '-c' creates a snapshot\n" 182 " '-d' deletes a snapshot\n" 183 " '-l' lists all snapshots in the given image\n" 184 "\n" 185 "Parameters to compare subcommand:\n" 186 " '-f' first image format\n" 187 " '-F' second image format\n" 188 " '-s' run in Strict mode - fail on different image size or sector allocation\n" 189 "\n" 190 "Parameters to dd subcommand:\n" 191 " 'bs=BYTES' read and write up to BYTES bytes at a time " 192 "(default: 512)\n" 193 " 'count=N' copy only N input blocks\n" 194 " 'if=FILE' read from FILE\n" 195 " 'of=FILE' write to FILE\n" 196 " 'skip=N' skip N bs-sized blocks at the start of input\n"; 197 198 printf("%s\nSupported formats:", help_msg); 199 bdrv_iterate_format(format_print, NULL, false); 200 printf("\n\n" QEMU_HELP_BOTTOM "\n"); 201 exit(EXIT_SUCCESS); 202 } 203 204 static QemuOptsList qemu_object_opts = { 205 .name = "object", 206 .implied_opt_name = "qom-type", 207 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head), 208 .desc = { 209 { } 210 }, 211 }; 212 213 static QemuOptsList qemu_source_opts = { 214 .name = "source", 215 .implied_opt_name = "file", 216 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head), 217 .desc = { 218 { } 219 }, 220 }; 221 222 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...) 223 { 224 int ret = 0; 225 if (!quiet) { 226 va_list args; 227 va_start(args, fmt); 228 ret = vprintf(fmt, args); 229 va_end(args); 230 } 231 return ret; 232 } 233 234 235 static int print_block_option_help(const char *filename, const char *fmt) 236 { 237 BlockDriver *drv, *proto_drv; 238 QemuOptsList *create_opts = NULL; 239 Error *local_err = NULL; 240 241 /* Find driver and parse its options */ 242 drv = bdrv_find_format(fmt); 243 if (!drv) { 244 error_report("Unknown file format '%s'", fmt); 245 return 1; 246 } 247 248 if (!drv->create_opts) { 249 error_report("Format driver '%s' does not support image creation", fmt); 250 return 1; 251 } 252 253 create_opts = qemu_opts_append(create_opts, drv->create_opts); 254 if (filename) { 255 proto_drv = bdrv_find_protocol(filename, true, &local_err); 256 if (!proto_drv) { 257 error_report_err(local_err); 258 qemu_opts_free(create_opts); 259 return 1; 260 } 261 if (!proto_drv->create_opts) { 262 error_report("Protocol driver '%s' does not support image creation", 263 proto_drv->format_name); 264 qemu_opts_free(create_opts); 265 return 1; 266 } 267 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 268 } 269 270 printf("Supported options:\n"); 271 qemu_opts_print_help(create_opts, false); 272 qemu_opts_free(create_opts); 273 return 0; 274 } 275 276 277 static BlockBackend *img_open_opts(const char *optstr, 278 QemuOpts *opts, int flags, bool writethrough, 279 bool quiet, bool force_share) 280 { 281 QDict *options; 282 Error *local_err = NULL; 283 BlockBackend *blk; 284 options = qemu_opts_to_qdict(opts, NULL); 285 if (force_share) { 286 if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE) 287 && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) { 288 error_report("--force-share/-U conflicts with image options"); 289 qobject_unref(options); 290 return NULL; 291 } 292 qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on"); 293 } 294 blk = blk_new_open(NULL, NULL, options, flags, &local_err); 295 if (!blk) { 296 error_reportf_err(local_err, "Could not open '%s': ", optstr); 297 return NULL; 298 } 299 blk_set_enable_write_cache(blk, !writethrough); 300 301 return blk; 302 } 303 304 static BlockBackend *img_open_file(const char *filename, 305 QDict *options, 306 const char *fmt, int flags, 307 bool writethrough, bool quiet, 308 bool force_share) 309 { 310 BlockBackend *blk; 311 Error *local_err = NULL; 312 313 if (!options) { 314 options = qdict_new(); 315 } 316 if (fmt) { 317 qdict_put_str(options, "driver", fmt); 318 } 319 320 if (force_share) { 321 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true); 322 } 323 blk = blk_new_open(filename, NULL, options, flags, &local_err); 324 if (!blk) { 325 error_reportf_err(local_err, "Could not open '%s': ", filename); 326 return NULL; 327 } 328 blk_set_enable_write_cache(blk, !writethrough); 329 330 return blk; 331 } 332 333 334 static int img_add_key_secrets(void *opaque, 335 const char *name, const char *value, 336 Error **errp) 337 { 338 QDict *options = opaque; 339 340 if (g_str_has_suffix(name, "key-secret")) { 341 qdict_put_str(options, name, value); 342 } 343 344 return 0; 345 } 346 347 348 static BlockBackend *img_open(bool image_opts, 349 const char *filename, 350 const char *fmt, int flags, bool writethrough, 351 bool quiet, bool force_share) 352 { 353 BlockBackend *blk; 354 if (image_opts) { 355 QemuOpts *opts; 356 if (fmt) { 357 error_report("--image-opts and --format are mutually exclusive"); 358 return NULL; 359 } 360 opts = qemu_opts_parse_noisily(qemu_find_opts("source"), 361 filename, true); 362 if (!opts) { 363 return NULL; 364 } 365 blk = img_open_opts(filename, opts, flags, writethrough, quiet, 366 force_share); 367 } else { 368 blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet, 369 force_share); 370 } 371 return blk; 372 } 373 374 375 static int add_old_style_options(const char *fmt, QemuOpts *opts, 376 const char *base_filename, 377 const char *base_fmt) 378 { 379 Error *err = NULL; 380 381 if (base_filename) { 382 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err); 383 if (err) { 384 error_report("Backing file not supported for file format '%s'", 385 fmt); 386 error_free(err); 387 return -1; 388 } 389 } 390 if (base_fmt) { 391 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err); 392 if (err) { 393 error_report("Backing file format not supported for file " 394 "format '%s'", fmt); 395 error_free(err); 396 return -1; 397 } 398 } 399 return 0; 400 } 401 402 static int64_t cvtnum(const char *s) 403 { 404 int err; 405 uint64_t value; 406 407 err = qemu_strtosz(s, NULL, &value); 408 if (err < 0) { 409 return err; 410 } 411 if (value > INT64_MAX) { 412 return -ERANGE; 413 } 414 return value; 415 } 416 417 static int img_create(int argc, char **argv) 418 { 419 int c; 420 uint64_t img_size = -1; 421 const char *fmt = "raw"; 422 const char *base_fmt = NULL; 423 const char *filename; 424 const char *base_filename = NULL; 425 char *options = NULL; 426 Error *local_err = NULL; 427 bool quiet = false; 428 int flags = 0; 429 430 for(;;) { 431 static const struct option long_options[] = { 432 {"help", no_argument, 0, 'h'}, 433 {"object", required_argument, 0, OPTION_OBJECT}, 434 {0, 0, 0, 0} 435 }; 436 c = getopt_long(argc, argv, ":F:b:f:ho:qu", 437 long_options, NULL); 438 if (c == -1) { 439 break; 440 } 441 switch(c) { 442 case ':': 443 missing_argument(argv[optind - 1]); 444 break; 445 case '?': 446 unrecognized_option(argv[optind - 1]); 447 break; 448 case 'h': 449 help(); 450 break; 451 case 'F': 452 base_fmt = optarg; 453 break; 454 case 'b': 455 base_filename = optarg; 456 break; 457 case 'f': 458 fmt = optarg; 459 break; 460 case 'o': 461 if (!is_valid_option_list(optarg)) { 462 error_report("Invalid option list: %s", optarg); 463 goto fail; 464 } 465 if (!options) { 466 options = g_strdup(optarg); 467 } else { 468 char *old_options = options; 469 options = g_strdup_printf("%s,%s", options, optarg); 470 g_free(old_options); 471 } 472 break; 473 case 'q': 474 quiet = true; 475 break; 476 case 'u': 477 flags |= BDRV_O_NO_BACKING; 478 break; 479 case OPTION_OBJECT: { 480 QemuOpts *opts; 481 opts = qemu_opts_parse_noisily(&qemu_object_opts, 482 optarg, true); 483 if (!opts) { 484 goto fail; 485 } 486 } break; 487 } 488 } 489 490 /* Get the filename */ 491 filename = (optind < argc) ? argv[optind] : NULL; 492 if (options && has_help_option(options)) { 493 g_free(options); 494 return print_block_option_help(filename, fmt); 495 } 496 497 if (optind >= argc) { 498 error_exit("Expecting image file name"); 499 } 500 optind++; 501 502 if (qemu_opts_foreach(&qemu_object_opts, 503 user_creatable_add_opts_foreach, 504 NULL, &error_fatal)) { 505 goto fail; 506 } 507 508 /* Get image size, if specified */ 509 if (optind < argc) { 510 int64_t sval; 511 512 sval = cvtnum(argv[optind++]); 513 if (sval < 0) { 514 if (sval == -ERANGE) { 515 error_report("Image size must be less than 8 EiB!"); 516 } else { 517 error_report("Invalid image size specified! You may use k, M, " 518 "G, T, P or E suffixes for "); 519 error_report("kilobytes, megabytes, gigabytes, terabytes, " 520 "petabytes and exabytes."); 521 } 522 goto fail; 523 } 524 img_size = (uint64_t)sval; 525 } 526 if (optind != argc) { 527 error_exit("Unexpected argument: %s", argv[optind]); 528 } 529 530 bdrv_img_create(filename, fmt, base_filename, base_fmt, 531 options, img_size, flags, quiet, &local_err); 532 if (local_err) { 533 error_reportf_err(local_err, "%s: ", filename); 534 goto fail; 535 } 536 537 g_free(options); 538 return 0; 539 540 fail: 541 g_free(options); 542 return 1; 543 } 544 545 static void dump_json_image_check(ImageCheck *check, bool quiet) 546 { 547 QString *str; 548 QObject *obj; 549 Visitor *v = qobject_output_visitor_new(&obj); 550 551 visit_type_ImageCheck(v, NULL, &check, &error_abort); 552 visit_complete(v, &obj); 553 str = qobject_to_json_pretty(obj); 554 assert(str != NULL); 555 qprintf(quiet, "%s\n", qstring_get_str(str)); 556 qobject_unref(obj); 557 visit_free(v); 558 qobject_unref(str); 559 } 560 561 static void dump_human_image_check(ImageCheck *check, bool quiet) 562 { 563 if (!(check->corruptions || check->leaks || check->check_errors)) { 564 qprintf(quiet, "No errors were found on the image.\n"); 565 } else { 566 if (check->corruptions) { 567 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n" 568 "Data may be corrupted, or further writes to the image " 569 "may corrupt it.\n", 570 check->corruptions); 571 } 572 573 if (check->leaks) { 574 qprintf(quiet, 575 "\n%" PRId64 " leaked clusters were found on the image.\n" 576 "This means waste of disk space, but no harm to data.\n", 577 check->leaks); 578 } 579 580 if (check->check_errors) { 581 qprintf(quiet, 582 "\n%" PRId64 583 " internal errors have occurred during the check.\n", 584 check->check_errors); 585 } 586 } 587 588 if (check->total_clusters != 0 && check->allocated_clusters != 0) { 589 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, " 590 "%0.2f%% fragmented, %0.2f%% compressed clusters\n", 591 check->allocated_clusters, check->total_clusters, 592 check->allocated_clusters * 100.0 / check->total_clusters, 593 check->fragmented_clusters * 100.0 / check->allocated_clusters, 594 check->compressed_clusters * 100.0 / 595 check->allocated_clusters); 596 } 597 598 if (check->image_end_offset) { 599 qprintf(quiet, 600 "Image end offset: %" PRId64 "\n", check->image_end_offset); 601 } 602 } 603 604 static int collect_image_check(BlockDriverState *bs, 605 ImageCheck *check, 606 const char *filename, 607 const char *fmt, 608 int fix) 609 { 610 int ret; 611 BdrvCheckResult result; 612 613 ret = bdrv_check(bs, &result, fix); 614 if (ret < 0) { 615 return ret; 616 } 617 618 check->filename = g_strdup(filename); 619 check->format = g_strdup(bdrv_get_format_name(bs)); 620 check->check_errors = result.check_errors; 621 check->corruptions = result.corruptions; 622 check->has_corruptions = result.corruptions != 0; 623 check->leaks = result.leaks; 624 check->has_leaks = result.leaks != 0; 625 check->corruptions_fixed = result.corruptions_fixed; 626 check->has_corruptions_fixed = result.corruptions != 0; 627 check->leaks_fixed = result.leaks_fixed; 628 check->has_leaks_fixed = result.leaks != 0; 629 check->image_end_offset = result.image_end_offset; 630 check->has_image_end_offset = result.image_end_offset != 0; 631 check->total_clusters = result.bfi.total_clusters; 632 check->has_total_clusters = result.bfi.total_clusters != 0; 633 check->allocated_clusters = result.bfi.allocated_clusters; 634 check->has_allocated_clusters = result.bfi.allocated_clusters != 0; 635 check->fragmented_clusters = result.bfi.fragmented_clusters; 636 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0; 637 check->compressed_clusters = result.bfi.compressed_clusters; 638 check->has_compressed_clusters = result.bfi.compressed_clusters != 0; 639 640 return 0; 641 } 642 643 /* 644 * Checks an image for consistency. Exit codes: 645 * 646 * 0 - Check completed, image is good 647 * 1 - Check not completed because of internal errors 648 * 2 - Check completed, image is corrupted 649 * 3 - Check completed, image has leaked clusters, but is good otherwise 650 * 63 - Checks are not supported by the image format 651 */ 652 static int img_check(int argc, char **argv) 653 { 654 int c, ret; 655 OutputFormat output_format = OFORMAT_HUMAN; 656 const char *filename, *fmt, *output, *cache; 657 BlockBackend *blk; 658 BlockDriverState *bs; 659 int fix = 0; 660 int flags = BDRV_O_CHECK; 661 bool writethrough; 662 ImageCheck *check; 663 bool quiet = false; 664 bool image_opts = false; 665 bool force_share = false; 666 667 fmt = NULL; 668 output = NULL; 669 cache = BDRV_DEFAULT_CACHE; 670 671 for(;;) { 672 int option_index = 0; 673 static const struct option long_options[] = { 674 {"help", no_argument, 0, 'h'}, 675 {"format", required_argument, 0, 'f'}, 676 {"repair", required_argument, 0, 'r'}, 677 {"output", required_argument, 0, OPTION_OUTPUT}, 678 {"object", required_argument, 0, OPTION_OBJECT}, 679 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 680 {"force-share", no_argument, 0, 'U'}, 681 {0, 0, 0, 0} 682 }; 683 c = getopt_long(argc, argv, ":hf:r:T:qU", 684 long_options, &option_index); 685 if (c == -1) { 686 break; 687 } 688 switch(c) { 689 case ':': 690 missing_argument(argv[optind - 1]); 691 break; 692 case '?': 693 unrecognized_option(argv[optind - 1]); 694 break; 695 case 'h': 696 help(); 697 break; 698 case 'f': 699 fmt = optarg; 700 break; 701 case 'r': 702 flags |= BDRV_O_RDWR; 703 704 if (!strcmp(optarg, "leaks")) { 705 fix = BDRV_FIX_LEAKS; 706 } else if (!strcmp(optarg, "all")) { 707 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS; 708 } else { 709 error_exit("Unknown option value for -r " 710 "(expecting 'leaks' or 'all'): %s", optarg); 711 } 712 break; 713 case OPTION_OUTPUT: 714 output = optarg; 715 break; 716 case 'T': 717 cache = optarg; 718 break; 719 case 'q': 720 quiet = true; 721 break; 722 case 'U': 723 force_share = true; 724 break; 725 case OPTION_OBJECT: { 726 QemuOpts *opts; 727 opts = qemu_opts_parse_noisily(&qemu_object_opts, 728 optarg, true); 729 if (!opts) { 730 return 1; 731 } 732 } break; 733 case OPTION_IMAGE_OPTS: 734 image_opts = true; 735 break; 736 } 737 } 738 if (optind != argc - 1) { 739 error_exit("Expecting one image file name"); 740 } 741 filename = argv[optind++]; 742 743 if (output && !strcmp(output, "json")) { 744 output_format = OFORMAT_JSON; 745 } else if (output && !strcmp(output, "human")) { 746 output_format = OFORMAT_HUMAN; 747 } else if (output) { 748 error_report("--output must be used with human or json as argument."); 749 return 1; 750 } 751 752 if (qemu_opts_foreach(&qemu_object_opts, 753 user_creatable_add_opts_foreach, 754 NULL, &error_fatal)) { 755 return 1; 756 } 757 758 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 759 if (ret < 0) { 760 error_report("Invalid source cache option: %s", cache); 761 return 1; 762 } 763 764 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 765 force_share); 766 if (!blk) { 767 return 1; 768 } 769 bs = blk_bs(blk); 770 771 check = g_new0(ImageCheck, 1); 772 ret = collect_image_check(bs, check, filename, fmt, fix); 773 774 if (ret == -ENOTSUP) { 775 error_report("This image format does not support checks"); 776 ret = 63; 777 goto fail; 778 } 779 780 if (check->corruptions_fixed || check->leaks_fixed) { 781 int corruptions_fixed, leaks_fixed; 782 783 leaks_fixed = check->leaks_fixed; 784 corruptions_fixed = check->corruptions_fixed; 785 786 if (output_format == OFORMAT_HUMAN) { 787 qprintf(quiet, 788 "The following inconsistencies were found and repaired:\n\n" 789 " %" PRId64 " leaked clusters\n" 790 " %" PRId64 " corruptions\n\n" 791 "Double checking the fixed image now...\n", 792 check->leaks_fixed, 793 check->corruptions_fixed); 794 } 795 796 ret = collect_image_check(bs, check, filename, fmt, 0); 797 798 check->leaks_fixed = leaks_fixed; 799 check->corruptions_fixed = corruptions_fixed; 800 } 801 802 if (!ret) { 803 switch (output_format) { 804 case OFORMAT_HUMAN: 805 dump_human_image_check(check, quiet); 806 break; 807 case OFORMAT_JSON: 808 dump_json_image_check(check, quiet); 809 break; 810 } 811 } 812 813 if (ret || check->check_errors) { 814 if (ret) { 815 error_report("Check failed: %s", strerror(-ret)); 816 } else { 817 error_report("Check failed"); 818 } 819 ret = 1; 820 goto fail; 821 } 822 823 if (check->corruptions) { 824 ret = 2; 825 } else if (check->leaks) { 826 ret = 3; 827 } else { 828 ret = 0; 829 } 830 831 fail: 832 qapi_free_ImageCheck(check); 833 blk_unref(blk); 834 return ret; 835 } 836 837 typedef struct CommonBlockJobCBInfo { 838 BlockDriverState *bs; 839 Error **errp; 840 } CommonBlockJobCBInfo; 841 842 static void common_block_job_cb(void *opaque, int ret) 843 { 844 CommonBlockJobCBInfo *cbi = opaque; 845 846 if (ret < 0) { 847 error_setg_errno(cbi->errp, -ret, "Block job failed"); 848 } 849 } 850 851 static void run_block_job(BlockJob *job, Error **errp) 852 { 853 AioContext *aio_context = blk_get_aio_context(job->blk); 854 int ret = 0; 855 856 aio_context_acquire(aio_context); 857 job_ref(&job->job); 858 do { 859 float progress = 0.0f; 860 aio_poll(aio_context, true); 861 if (job->job.progress_total) { 862 progress = (float)job->job.progress_current / 863 job->job.progress_total * 100.f; 864 } 865 qemu_progress_print(progress, 0); 866 } while (!job_is_ready(&job->job) && !job_is_completed(&job->job)); 867 868 if (!job_is_completed(&job->job)) { 869 ret = job_complete_sync(&job->job, errp); 870 } else { 871 ret = job->job.ret; 872 } 873 job_unref(&job->job); 874 aio_context_release(aio_context); 875 876 /* publish completion progress only when success */ 877 if (!ret) { 878 qemu_progress_print(100.f, 0); 879 } 880 } 881 882 static int img_commit(int argc, char **argv) 883 { 884 int c, ret, flags; 885 const char *filename, *fmt, *cache, *base; 886 BlockBackend *blk; 887 BlockDriverState *bs, *base_bs; 888 BlockJob *job; 889 bool progress = false, quiet = false, drop = false; 890 bool writethrough; 891 Error *local_err = NULL; 892 CommonBlockJobCBInfo cbi; 893 bool image_opts = false; 894 AioContext *aio_context; 895 896 fmt = NULL; 897 cache = BDRV_DEFAULT_CACHE; 898 base = NULL; 899 for(;;) { 900 static const struct option long_options[] = { 901 {"help", no_argument, 0, 'h'}, 902 {"object", required_argument, 0, OPTION_OBJECT}, 903 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 904 {0, 0, 0, 0} 905 }; 906 c = getopt_long(argc, argv, ":f:ht:b:dpq", 907 long_options, NULL); 908 if (c == -1) { 909 break; 910 } 911 switch(c) { 912 case ':': 913 missing_argument(argv[optind - 1]); 914 break; 915 case '?': 916 unrecognized_option(argv[optind - 1]); 917 break; 918 case 'h': 919 help(); 920 break; 921 case 'f': 922 fmt = optarg; 923 break; 924 case 't': 925 cache = optarg; 926 break; 927 case 'b': 928 base = optarg; 929 /* -b implies -d */ 930 drop = true; 931 break; 932 case 'd': 933 drop = true; 934 break; 935 case 'p': 936 progress = true; 937 break; 938 case 'q': 939 quiet = true; 940 break; 941 case OPTION_OBJECT: { 942 QemuOpts *opts; 943 opts = qemu_opts_parse_noisily(&qemu_object_opts, 944 optarg, true); 945 if (!opts) { 946 return 1; 947 } 948 } break; 949 case OPTION_IMAGE_OPTS: 950 image_opts = true; 951 break; 952 } 953 } 954 955 /* Progress is not shown in Quiet mode */ 956 if (quiet) { 957 progress = false; 958 } 959 960 if (optind != argc - 1) { 961 error_exit("Expecting one image file name"); 962 } 963 filename = argv[optind++]; 964 965 if (qemu_opts_foreach(&qemu_object_opts, 966 user_creatable_add_opts_foreach, 967 NULL, &error_fatal)) { 968 return 1; 969 } 970 971 flags = BDRV_O_RDWR | BDRV_O_UNMAP; 972 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 973 if (ret < 0) { 974 error_report("Invalid cache option: %s", cache); 975 return 1; 976 } 977 978 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 979 false); 980 if (!blk) { 981 return 1; 982 } 983 bs = blk_bs(blk); 984 985 qemu_progress_init(progress, 1.f); 986 qemu_progress_print(0.f, 100); 987 988 if (base) { 989 base_bs = bdrv_find_backing_image(bs, base); 990 if (!base_bs) { 991 error_setg(&local_err, 992 "Did not find '%s' in the backing chain of '%s'", 993 base, filename); 994 goto done; 995 } 996 } else { 997 /* This is different from QMP, which by default uses the deepest file in 998 * the backing chain (i.e., the very base); however, the traditional 999 * behavior of qemu-img commit is using the immediate backing file. */ 1000 base_bs = backing_bs(bs); 1001 if (!base_bs) { 1002 error_setg(&local_err, "Image does not have a backing file"); 1003 goto done; 1004 } 1005 } 1006 1007 cbi = (CommonBlockJobCBInfo){ 1008 .errp = &local_err, 1009 .bs = bs, 1010 }; 1011 1012 aio_context = bdrv_get_aio_context(bs); 1013 aio_context_acquire(aio_context); 1014 commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0, 1015 BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb, 1016 &cbi, false, &local_err); 1017 aio_context_release(aio_context); 1018 if (local_err) { 1019 goto done; 1020 } 1021 1022 /* When the block job completes, the BlockBackend reference will point to 1023 * the old backing file. In order to avoid that the top image is already 1024 * deleted, so we can still empty it afterwards, increment the reference 1025 * counter here preemptively. */ 1026 if (!drop) { 1027 bdrv_ref(bs); 1028 } 1029 1030 job = block_job_get("commit"); 1031 assert(job); 1032 run_block_job(job, &local_err); 1033 if (local_err) { 1034 goto unref_backing; 1035 } 1036 1037 if (!drop && bs->drv->bdrv_make_empty) { 1038 ret = bs->drv->bdrv_make_empty(bs); 1039 if (ret) { 1040 error_setg_errno(&local_err, -ret, "Could not empty %s", 1041 filename); 1042 goto unref_backing; 1043 } 1044 } 1045 1046 unref_backing: 1047 if (!drop) { 1048 bdrv_unref(bs); 1049 } 1050 1051 done: 1052 qemu_progress_end(); 1053 1054 blk_unref(blk); 1055 1056 if (local_err) { 1057 error_report_err(local_err); 1058 return 1; 1059 } 1060 1061 qprintf(quiet, "Image committed.\n"); 1062 return 0; 1063 } 1064 1065 /* 1066 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index 1067 * of the first sector boundary within buf where the sector contains a 1068 * non-zero byte. This function is robust to a buffer that is not 1069 * sector-aligned. 1070 */ 1071 static int64_t find_nonzero(const uint8_t *buf, int64_t n) 1072 { 1073 int64_t i; 1074 int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE); 1075 1076 for (i = 0; i < end; i += BDRV_SECTOR_SIZE) { 1077 if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) { 1078 return i; 1079 } 1080 } 1081 if (i < n && !buffer_is_zero(buf + i, n - end)) { 1082 return i; 1083 } 1084 return -1; 1085 } 1086 1087 /* 1088 * Returns true iff the first sector pointed to by 'buf' contains at least 1089 * a non-NUL byte. 1090 * 1091 * 'pnum' is set to the number of sectors (including and immediately following 1092 * the first one) that are known to be in the same allocated/unallocated state. 1093 * The function will try to align the end offset to alignment boundaries so 1094 * that the request will at least end aligned and consequtive requests will 1095 * also start at an aligned offset. 1096 */ 1097 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum, 1098 int64_t sector_num, int alignment) 1099 { 1100 bool is_zero; 1101 int i, tail; 1102 1103 if (n <= 0) { 1104 *pnum = 0; 1105 return 0; 1106 } 1107 is_zero = buffer_is_zero(buf, 512); 1108 for(i = 1; i < n; i++) { 1109 buf += 512; 1110 if (is_zero != buffer_is_zero(buf, 512)) { 1111 break; 1112 } 1113 } 1114 1115 tail = (sector_num + i) & (alignment - 1); 1116 if (tail) { 1117 if (is_zero && i <= tail) { 1118 /* treat unallocated areas which only consist 1119 * of a small tail as allocated. */ 1120 is_zero = false; 1121 } 1122 if (!is_zero) { 1123 /* align up end offset of allocated areas. */ 1124 i += alignment - tail; 1125 i = MIN(i, n); 1126 } else { 1127 /* align down end offset of zero areas. */ 1128 i -= tail; 1129 } 1130 } 1131 *pnum = i; 1132 return !is_zero; 1133 } 1134 1135 /* 1136 * Like is_allocated_sectors, but if the buffer starts with a used sector, 1137 * up to 'min' consecutive sectors containing zeros are ignored. This avoids 1138 * breaking up write requests for only small sparse areas. 1139 */ 1140 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum, 1141 int min, int64_t sector_num, int alignment) 1142 { 1143 int ret; 1144 int num_checked, num_used; 1145 1146 if (n < min) { 1147 min = n; 1148 } 1149 1150 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment); 1151 if (!ret) { 1152 return ret; 1153 } 1154 1155 num_used = *pnum; 1156 buf += BDRV_SECTOR_SIZE * *pnum; 1157 n -= *pnum; 1158 sector_num += *pnum; 1159 num_checked = num_used; 1160 1161 while (n > 0) { 1162 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment); 1163 1164 buf += BDRV_SECTOR_SIZE * *pnum; 1165 n -= *pnum; 1166 sector_num += *pnum; 1167 num_checked += *pnum; 1168 if (ret) { 1169 num_used = num_checked; 1170 } else if (*pnum >= min) { 1171 break; 1172 } 1173 } 1174 1175 *pnum = num_used; 1176 return 1; 1177 } 1178 1179 /* 1180 * Compares two buffers sector by sector. Returns 0 if the first 1181 * sector of each buffer matches, non-zero otherwise. 1182 * 1183 * pnum is set to the sector-aligned size of the buffer prefix that 1184 * has the same matching status as the first sector. 1185 */ 1186 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2, 1187 int64_t bytes, int64_t *pnum) 1188 { 1189 bool res; 1190 int64_t i = MIN(bytes, BDRV_SECTOR_SIZE); 1191 1192 assert(bytes > 0); 1193 1194 res = !!memcmp(buf1, buf2, i); 1195 while (i < bytes) { 1196 int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE); 1197 1198 if (!!memcmp(buf1 + i, buf2 + i, len) != res) { 1199 break; 1200 } 1201 i += len; 1202 } 1203 1204 *pnum = i; 1205 return res; 1206 } 1207 1208 #define IO_BUF_SIZE (2 * 1024 * 1024) 1209 1210 /* 1211 * Check if passed sectors are empty (not allocated or contain only 0 bytes) 1212 * 1213 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are 1214 * filled with 0, 1 if sectors contain non-zero data (this is a comparison 1215 * failure), and 4 on error (the exit status for read errors), after emitting 1216 * an error message. 1217 * 1218 * @param blk: BlockBackend for the image 1219 * @param offset: Starting offset to check 1220 * @param bytes: Number of bytes to check 1221 * @param filename: Name of disk file we are checking (logging purpose) 1222 * @param buffer: Allocated buffer for storing read data 1223 * @param quiet: Flag for quiet mode 1224 */ 1225 static int check_empty_sectors(BlockBackend *blk, int64_t offset, 1226 int64_t bytes, const char *filename, 1227 uint8_t *buffer, bool quiet) 1228 { 1229 int ret = 0; 1230 int64_t idx; 1231 1232 ret = blk_pread(blk, offset, buffer, bytes); 1233 if (ret < 0) { 1234 error_report("Error while reading offset %" PRId64 " of %s: %s", 1235 offset, filename, strerror(-ret)); 1236 return 4; 1237 } 1238 idx = find_nonzero(buffer, bytes); 1239 if (idx >= 0) { 1240 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n", 1241 offset + idx); 1242 return 1; 1243 } 1244 1245 return 0; 1246 } 1247 1248 /* 1249 * Compares two images. Exit codes: 1250 * 1251 * 0 - Images are identical 1252 * 1 - Images differ 1253 * >1 - Error occurred 1254 */ 1255 static int img_compare(int argc, char **argv) 1256 { 1257 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2; 1258 BlockBackend *blk1, *blk2; 1259 BlockDriverState *bs1, *bs2; 1260 int64_t total_size1, total_size2; 1261 uint8_t *buf1 = NULL, *buf2 = NULL; 1262 int64_t pnum1, pnum2; 1263 int allocated1, allocated2; 1264 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */ 1265 bool progress = false, quiet = false, strict = false; 1266 int flags; 1267 bool writethrough; 1268 int64_t total_size; 1269 int64_t offset = 0; 1270 int64_t chunk; 1271 int c; 1272 uint64_t progress_base; 1273 bool image_opts = false; 1274 bool force_share = false; 1275 1276 cache = BDRV_DEFAULT_CACHE; 1277 for (;;) { 1278 static const struct option long_options[] = { 1279 {"help", no_argument, 0, 'h'}, 1280 {"object", required_argument, 0, OPTION_OBJECT}, 1281 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 1282 {"force-share", no_argument, 0, 'U'}, 1283 {0, 0, 0, 0} 1284 }; 1285 c = getopt_long(argc, argv, ":hf:F:T:pqsU", 1286 long_options, NULL); 1287 if (c == -1) { 1288 break; 1289 } 1290 switch (c) { 1291 case ':': 1292 missing_argument(argv[optind - 1]); 1293 break; 1294 case '?': 1295 unrecognized_option(argv[optind - 1]); 1296 break; 1297 case 'h': 1298 help(); 1299 break; 1300 case 'f': 1301 fmt1 = optarg; 1302 break; 1303 case 'F': 1304 fmt2 = optarg; 1305 break; 1306 case 'T': 1307 cache = optarg; 1308 break; 1309 case 'p': 1310 progress = true; 1311 break; 1312 case 'q': 1313 quiet = true; 1314 break; 1315 case 's': 1316 strict = true; 1317 break; 1318 case 'U': 1319 force_share = true; 1320 break; 1321 case OPTION_OBJECT: { 1322 QemuOpts *opts; 1323 opts = qemu_opts_parse_noisily(&qemu_object_opts, 1324 optarg, true); 1325 if (!opts) { 1326 ret = 2; 1327 goto out4; 1328 } 1329 } break; 1330 case OPTION_IMAGE_OPTS: 1331 image_opts = true; 1332 break; 1333 } 1334 } 1335 1336 /* Progress is not shown in Quiet mode */ 1337 if (quiet) { 1338 progress = false; 1339 } 1340 1341 1342 if (optind != argc - 2) { 1343 error_exit("Expecting two image file names"); 1344 } 1345 filename1 = argv[optind++]; 1346 filename2 = argv[optind++]; 1347 1348 if (qemu_opts_foreach(&qemu_object_opts, 1349 user_creatable_add_opts_foreach, 1350 NULL, &error_fatal)) { 1351 ret = 2; 1352 goto out4; 1353 } 1354 1355 /* Initialize before goto out */ 1356 qemu_progress_init(progress, 2.0); 1357 1358 flags = 0; 1359 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 1360 if (ret < 0) { 1361 error_report("Invalid source cache option: %s", cache); 1362 ret = 2; 1363 goto out3; 1364 } 1365 1366 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet, 1367 force_share); 1368 if (!blk1) { 1369 ret = 2; 1370 goto out3; 1371 } 1372 1373 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet, 1374 force_share); 1375 if (!blk2) { 1376 ret = 2; 1377 goto out2; 1378 } 1379 bs1 = blk_bs(blk1); 1380 bs2 = blk_bs(blk2); 1381 1382 buf1 = blk_blockalign(blk1, IO_BUF_SIZE); 1383 buf2 = blk_blockalign(blk2, IO_BUF_SIZE); 1384 total_size1 = blk_getlength(blk1); 1385 if (total_size1 < 0) { 1386 error_report("Can't get size of %s: %s", 1387 filename1, strerror(-total_size1)); 1388 ret = 4; 1389 goto out; 1390 } 1391 total_size2 = blk_getlength(blk2); 1392 if (total_size2 < 0) { 1393 error_report("Can't get size of %s: %s", 1394 filename2, strerror(-total_size2)); 1395 ret = 4; 1396 goto out; 1397 } 1398 total_size = MIN(total_size1, total_size2); 1399 progress_base = MAX(total_size1, total_size2); 1400 1401 qemu_progress_print(0, 100); 1402 1403 if (strict && total_size1 != total_size2) { 1404 ret = 1; 1405 qprintf(quiet, "Strict mode: Image size mismatch!\n"); 1406 goto out; 1407 } 1408 1409 while (offset < total_size) { 1410 int status1, status2; 1411 1412 status1 = bdrv_block_status_above(bs1, NULL, offset, 1413 total_size1 - offset, &pnum1, NULL, 1414 NULL); 1415 if (status1 < 0) { 1416 ret = 3; 1417 error_report("Sector allocation test failed for %s", filename1); 1418 goto out; 1419 } 1420 allocated1 = status1 & BDRV_BLOCK_ALLOCATED; 1421 1422 status2 = bdrv_block_status_above(bs2, NULL, offset, 1423 total_size2 - offset, &pnum2, NULL, 1424 NULL); 1425 if (status2 < 0) { 1426 ret = 3; 1427 error_report("Sector allocation test failed for %s", filename2); 1428 goto out; 1429 } 1430 allocated2 = status2 & BDRV_BLOCK_ALLOCATED; 1431 1432 assert(pnum1 && pnum2); 1433 chunk = MIN(pnum1, pnum2); 1434 1435 if (strict) { 1436 if (status1 != status2) { 1437 ret = 1; 1438 qprintf(quiet, "Strict mode: Offset %" PRId64 1439 " block status mismatch!\n", offset); 1440 goto out; 1441 } 1442 } 1443 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) { 1444 /* nothing to do */ 1445 } else if (allocated1 == allocated2) { 1446 if (allocated1) { 1447 int64_t pnum; 1448 1449 chunk = MIN(chunk, IO_BUF_SIZE); 1450 ret = blk_pread(blk1, offset, buf1, chunk); 1451 if (ret < 0) { 1452 error_report("Error while reading offset %" PRId64 1453 " of %s: %s", 1454 offset, filename1, strerror(-ret)); 1455 ret = 4; 1456 goto out; 1457 } 1458 ret = blk_pread(blk2, offset, buf2, chunk); 1459 if (ret < 0) { 1460 error_report("Error while reading offset %" PRId64 1461 " of %s: %s", 1462 offset, filename2, strerror(-ret)); 1463 ret = 4; 1464 goto out; 1465 } 1466 ret = compare_buffers(buf1, buf2, chunk, &pnum); 1467 if (ret || pnum != chunk) { 1468 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n", 1469 offset + (ret ? 0 : pnum)); 1470 ret = 1; 1471 goto out; 1472 } 1473 } 1474 } else { 1475 chunk = MIN(chunk, IO_BUF_SIZE); 1476 if (allocated1) { 1477 ret = check_empty_sectors(blk1, offset, chunk, 1478 filename1, buf1, quiet); 1479 } else { 1480 ret = check_empty_sectors(blk2, offset, chunk, 1481 filename2, buf1, quiet); 1482 } 1483 if (ret) { 1484 goto out; 1485 } 1486 } 1487 offset += chunk; 1488 qemu_progress_print(((float) chunk / progress_base) * 100, 100); 1489 } 1490 1491 if (total_size1 != total_size2) { 1492 BlockBackend *blk_over; 1493 const char *filename_over; 1494 1495 qprintf(quiet, "Warning: Image size mismatch!\n"); 1496 if (total_size1 > total_size2) { 1497 blk_over = blk1; 1498 filename_over = filename1; 1499 } else { 1500 blk_over = blk2; 1501 filename_over = filename2; 1502 } 1503 1504 while (offset < progress_base) { 1505 ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset, 1506 progress_base - offset, &chunk, 1507 NULL, NULL); 1508 if (ret < 0) { 1509 ret = 3; 1510 error_report("Sector allocation test failed for %s", 1511 filename_over); 1512 goto out; 1513 1514 } 1515 if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) { 1516 chunk = MIN(chunk, IO_BUF_SIZE); 1517 ret = check_empty_sectors(blk_over, offset, chunk, 1518 filename_over, buf1, quiet); 1519 if (ret) { 1520 goto out; 1521 } 1522 } 1523 offset += chunk; 1524 qemu_progress_print(((float) chunk / progress_base) * 100, 100); 1525 } 1526 } 1527 1528 qprintf(quiet, "Images are identical.\n"); 1529 ret = 0; 1530 1531 out: 1532 qemu_vfree(buf1); 1533 qemu_vfree(buf2); 1534 blk_unref(blk2); 1535 out2: 1536 blk_unref(blk1); 1537 out3: 1538 qemu_progress_end(); 1539 out4: 1540 return ret; 1541 } 1542 1543 enum ImgConvertBlockStatus { 1544 BLK_DATA, 1545 BLK_ZERO, 1546 BLK_BACKING_FILE, 1547 }; 1548 1549 #define MAX_COROUTINES 16 1550 1551 typedef struct ImgConvertState { 1552 BlockBackend **src; 1553 int64_t *src_sectors; 1554 int src_num; 1555 int64_t total_sectors; 1556 int64_t allocated_sectors; 1557 int64_t allocated_done; 1558 int64_t sector_num; 1559 int64_t wr_offs; 1560 enum ImgConvertBlockStatus status; 1561 int64_t sector_next_status; 1562 BlockBackend *target; 1563 bool has_zero_init; 1564 bool compressed; 1565 bool unallocated_blocks_are_zero; 1566 bool target_has_backing; 1567 int64_t target_backing_sectors; /* negative if unknown */ 1568 bool wr_in_order; 1569 bool copy_range; 1570 int min_sparse; 1571 int alignment; 1572 size_t cluster_sectors; 1573 size_t buf_sectors; 1574 long num_coroutines; 1575 int running_coroutines; 1576 Coroutine *co[MAX_COROUTINES]; 1577 int64_t wait_sector_num[MAX_COROUTINES]; 1578 CoMutex lock; 1579 int ret; 1580 } ImgConvertState; 1581 1582 static void convert_select_part(ImgConvertState *s, int64_t sector_num, 1583 int *src_cur, int64_t *src_cur_offset) 1584 { 1585 *src_cur = 0; 1586 *src_cur_offset = 0; 1587 while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) { 1588 *src_cur_offset += s->src_sectors[*src_cur]; 1589 (*src_cur)++; 1590 assert(*src_cur < s->src_num); 1591 } 1592 } 1593 1594 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num) 1595 { 1596 int64_t src_cur_offset; 1597 int ret, n, src_cur; 1598 bool post_backing_zero = false; 1599 1600 convert_select_part(s, sector_num, &src_cur, &src_cur_offset); 1601 1602 assert(s->total_sectors > sector_num); 1603 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS); 1604 1605 if (s->target_backing_sectors >= 0) { 1606 if (sector_num >= s->target_backing_sectors) { 1607 post_backing_zero = s->unallocated_blocks_are_zero; 1608 } else if (sector_num + n > s->target_backing_sectors) { 1609 /* Split requests around target_backing_sectors (because 1610 * starting from there, zeros are handled differently) */ 1611 n = s->target_backing_sectors - sector_num; 1612 } 1613 } 1614 1615 if (s->sector_next_status <= sector_num) { 1616 int64_t count = n * BDRV_SECTOR_SIZE; 1617 1618 if (s->target_has_backing) { 1619 1620 ret = bdrv_block_status(blk_bs(s->src[src_cur]), 1621 (sector_num - src_cur_offset) * 1622 BDRV_SECTOR_SIZE, 1623 count, &count, NULL, NULL); 1624 } else { 1625 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL, 1626 (sector_num - src_cur_offset) * 1627 BDRV_SECTOR_SIZE, 1628 count, &count, NULL, NULL); 1629 } 1630 if (ret < 0) { 1631 error_report("error while reading block status of sector %" PRId64 1632 ": %s", sector_num, strerror(-ret)); 1633 return ret; 1634 } 1635 n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE); 1636 1637 if (ret & BDRV_BLOCK_ZERO) { 1638 s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO; 1639 } else if (ret & BDRV_BLOCK_DATA) { 1640 s->status = BLK_DATA; 1641 } else { 1642 s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA; 1643 } 1644 1645 s->sector_next_status = sector_num + n; 1646 } 1647 1648 n = MIN(n, s->sector_next_status - sector_num); 1649 if (s->status == BLK_DATA) { 1650 n = MIN(n, s->buf_sectors); 1651 } 1652 1653 /* We need to write complete clusters for compressed images, so if an 1654 * unallocated area is shorter than that, we must consider the whole 1655 * cluster allocated. */ 1656 if (s->compressed) { 1657 if (n < s->cluster_sectors) { 1658 n = MIN(s->cluster_sectors, s->total_sectors - sector_num); 1659 s->status = BLK_DATA; 1660 } else { 1661 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors); 1662 } 1663 } 1664 1665 return n; 1666 } 1667 1668 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num, 1669 int nb_sectors, uint8_t *buf) 1670 { 1671 int n, ret; 1672 QEMUIOVector qiov; 1673 1674 assert(nb_sectors <= s->buf_sectors); 1675 while (nb_sectors > 0) { 1676 BlockBackend *blk; 1677 int src_cur; 1678 int64_t bs_sectors, src_cur_offset; 1679 1680 /* In the case of compression with multiple source files, we can get a 1681 * nb_sectors that spreads into the next part. So we must be able to 1682 * read across multiple BDSes for one convert_read() call. */ 1683 convert_select_part(s, sector_num, &src_cur, &src_cur_offset); 1684 blk = s->src[src_cur]; 1685 bs_sectors = s->src_sectors[src_cur]; 1686 1687 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset)); 1688 qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS); 1689 1690 ret = blk_co_preadv( 1691 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS, 1692 n << BDRV_SECTOR_BITS, &qiov, 0); 1693 if (ret < 0) { 1694 return ret; 1695 } 1696 1697 sector_num += n; 1698 nb_sectors -= n; 1699 buf += n * BDRV_SECTOR_SIZE; 1700 } 1701 1702 return 0; 1703 } 1704 1705 1706 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num, 1707 int nb_sectors, uint8_t *buf, 1708 enum ImgConvertBlockStatus status) 1709 { 1710 int ret; 1711 QEMUIOVector qiov; 1712 1713 while (nb_sectors > 0) { 1714 int n = nb_sectors; 1715 BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0; 1716 1717 switch (status) { 1718 case BLK_BACKING_FILE: 1719 /* If we have a backing file, leave clusters unallocated that are 1720 * unallocated in the source image, so that the backing file is 1721 * visible at the respective offset. */ 1722 assert(s->target_has_backing); 1723 break; 1724 1725 case BLK_DATA: 1726 /* If we're told to keep the target fully allocated (-S 0) or there 1727 * is real non-zero data, we must write it. Otherwise we can treat 1728 * it as zero sectors. 1729 * Compressed clusters need to be written as a whole, so in that 1730 * case we can only save the write if the buffer is completely 1731 * zeroed. */ 1732 if (!s->min_sparse || 1733 (!s->compressed && 1734 is_allocated_sectors_min(buf, n, &n, s->min_sparse, 1735 sector_num, s->alignment)) || 1736 (s->compressed && 1737 !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))) 1738 { 1739 qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS); 1740 1741 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS, 1742 n << BDRV_SECTOR_BITS, &qiov, flags); 1743 if (ret < 0) { 1744 return ret; 1745 } 1746 break; 1747 } 1748 /* fall-through */ 1749 1750 case BLK_ZERO: 1751 if (s->has_zero_init) { 1752 assert(!s->target_has_backing); 1753 break; 1754 } 1755 ret = blk_co_pwrite_zeroes(s->target, 1756 sector_num << BDRV_SECTOR_BITS, 1757 n << BDRV_SECTOR_BITS, 1758 BDRV_REQ_MAY_UNMAP); 1759 if (ret < 0) { 1760 return ret; 1761 } 1762 break; 1763 } 1764 1765 sector_num += n; 1766 nb_sectors -= n; 1767 buf += n * BDRV_SECTOR_SIZE; 1768 } 1769 1770 return 0; 1771 } 1772 1773 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num, 1774 int nb_sectors) 1775 { 1776 int n, ret; 1777 1778 while (nb_sectors > 0) { 1779 BlockBackend *blk; 1780 int src_cur; 1781 int64_t bs_sectors, src_cur_offset; 1782 int64_t offset; 1783 1784 convert_select_part(s, sector_num, &src_cur, &src_cur_offset); 1785 offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS; 1786 blk = s->src[src_cur]; 1787 bs_sectors = s->src_sectors[src_cur]; 1788 1789 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset)); 1790 1791 ret = blk_co_copy_range(blk, offset, s->target, 1792 sector_num << BDRV_SECTOR_BITS, 1793 n << BDRV_SECTOR_BITS, 0, 0); 1794 if (ret < 0) { 1795 return ret; 1796 } 1797 1798 sector_num += n; 1799 nb_sectors -= n; 1800 } 1801 return 0; 1802 } 1803 1804 static void coroutine_fn convert_co_do_copy(void *opaque) 1805 { 1806 ImgConvertState *s = opaque; 1807 uint8_t *buf = NULL; 1808 int ret, i; 1809 int index = -1; 1810 1811 for (i = 0; i < s->num_coroutines; i++) { 1812 if (s->co[i] == qemu_coroutine_self()) { 1813 index = i; 1814 break; 1815 } 1816 } 1817 assert(index >= 0); 1818 1819 s->running_coroutines++; 1820 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE); 1821 1822 while (1) { 1823 int n; 1824 int64_t sector_num; 1825 enum ImgConvertBlockStatus status; 1826 bool copy_range; 1827 1828 qemu_co_mutex_lock(&s->lock); 1829 if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) { 1830 qemu_co_mutex_unlock(&s->lock); 1831 break; 1832 } 1833 n = convert_iteration_sectors(s, s->sector_num); 1834 if (n < 0) { 1835 qemu_co_mutex_unlock(&s->lock); 1836 s->ret = n; 1837 break; 1838 } 1839 /* save current sector and allocation status to local variables */ 1840 sector_num = s->sector_num; 1841 status = s->status; 1842 if (!s->min_sparse && s->status == BLK_ZERO) { 1843 n = MIN(n, s->buf_sectors); 1844 } 1845 /* increment global sector counter so that other coroutines can 1846 * already continue reading beyond this request */ 1847 s->sector_num += n; 1848 qemu_co_mutex_unlock(&s->lock); 1849 1850 if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) { 1851 s->allocated_done += n; 1852 qemu_progress_print(100.0 * s->allocated_done / 1853 s->allocated_sectors, 0); 1854 } 1855 1856 retry: 1857 copy_range = s->copy_range && s->status == BLK_DATA; 1858 if (status == BLK_DATA && !copy_range) { 1859 ret = convert_co_read(s, sector_num, n, buf); 1860 if (ret < 0) { 1861 error_report("error while reading sector %" PRId64 1862 ": %s", sector_num, strerror(-ret)); 1863 s->ret = ret; 1864 } 1865 } else if (!s->min_sparse && status == BLK_ZERO) { 1866 status = BLK_DATA; 1867 memset(buf, 0x00, n * BDRV_SECTOR_SIZE); 1868 } 1869 1870 if (s->wr_in_order) { 1871 /* keep writes in order */ 1872 while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) { 1873 s->wait_sector_num[index] = sector_num; 1874 qemu_coroutine_yield(); 1875 } 1876 s->wait_sector_num[index] = -1; 1877 } 1878 1879 if (s->ret == -EINPROGRESS) { 1880 if (copy_range) { 1881 ret = convert_co_copy_range(s, sector_num, n); 1882 if (ret) { 1883 s->copy_range = false; 1884 goto retry; 1885 } 1886 } else { 1887 ret = convert_co_write(s, sector_num, n, buf, status); 1888 } 1889 if (ret < 0) { 1890 error_report("error while writing sector %" PRId64 1891 ": %s", sector_num, strerror(-ret)); 1892 s->ret = ret; 1893 } 1894 } 1895 1896 if (s->wr_in_order) { 1897 /* reenter the coroutine that might have waited 1898 * for this write to complete */ 1899 s->wr_offs = sector_num + n; 1900 for (i = 0; i < s->num_coroutines; i++) { 1901 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) { 1902 /* 1903 * A -> B -> A cannot occur because A has 1904 * s->wait_sector_num[i] == -1 during A -> B. Therefore 1905 * B will never enter A during this time window. 1906 */ 1907 qemu_coroutine_enter(s->co[i]); 1908 break; 1909 } 1910 } 1911 } 1912 } 1913 1914 qemu_vfree(buf); 1915 s->co[index] = NULL; 1916 s->running_coroutines--; 1917 if (!s->running_coroutines && s->ret == -EINPROGRESS) { 1918 /* the convert job finished successfully */ 1919 s->ret = 0; 1920 } 1921 } 1922 1923 static int convert_do_copy(ImgConvertState *s) 1924 { 1925 int ret, i, n; 1926 int64_t sector_num = 0; 1927 1928 /* Check whether we have zero initialisation or can get it efficiently */ 1929 s->has_zero_init = s->min_sparse && !s->target_has_backing 1930 ? bdrv_has_zero_init(blk_bs(s->target)) 1931 : false; 1932 1933 if (!s->has_zero_init && !s->target_has_backing && 1934 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target))) 1935 { 1936 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK); 1937 if (ret == 0) { 1938 s->has_zero_init = true; 1939 } 1940 } 1941 1942 /* Allocate buffer for copied data. For compressed images, only one cluster 1943 * can be copied at a time. */ 1944 if (s->compressed) { 1945 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) { 1946 error_report("invalid cluster size"); 1947 return -EINVAL; 1948 } 1949 s->buf_sectors = s->cluster_sectors; 1950 } 1951 1952 while (sector_num < s->total_sectors) { 1953 n = convert_iteration_sectors(s, sector_num); 1954 if (n < 0) { 1955 return n; 1956 } 1957 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO)) 1958 { 1959 s->allocated_sectors += n; 1960 } 1961 sector_num += n; 1962 } 1963 1964 /* Do the copy */ 1965 s->sector_next_status = 0; 1966 s->ret = -EINPROGRESS; 1967 1968 qemu_co_mutex_init(&s->lock); 1969 for (i = 0; i < s->num_coroutines; i++) { 1970 s->co[i] = qemu_coroutine_create(convert_co_do_copy, s); 1971 s->wait_sector_num[i] = -1; 1972 qemu_coroutine_enter(s->co[i]); 1973 } 1974 1975 while (s->running_coroutines) { 1976 main_loop_wait(false); 1977 } 1978 1979 if (s->compressed && !s->ret) { 1980 /* signal EOF to align */ 1981 ret = blk_pwrite_compressed(s->target, 0, NULL, 0); 1982 if (ret < 0) { 1983 return ret; 1984 } 1985 } 1986 1987 return s->ret; 1988 } 1989 1990 #define MAX_BUF_SECTORS 32768 1991 1992 static int img_convert(int argc, char **argv) 1993 { 1994 int c, bs_i, flags, src_flags = 0; 1995 const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe", 1996 *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL, 1997 *out_filename, *out_baseimg_param, *snapshot_name = NULL; 1998 BlockDriver *drv = NULL, *proto_drv = NULL; 1999 BlockDriverInfo bdi; 2000 BlockDriverState *out_bs; 2001 QemuOpts *opts = NULL, *sn_opts = NULL; 2002 QemuOptsList *create_opts = NULL; 2003 QDict *open_opts = NULL; 2004 char *options = NULL; 2005 Error *local_err = NULL; 2006 bool writethrough, src_writethrough, quiet = false, image_opts = false, 2007 skip_create = false, progress = false, tgt_image_opts = false; 2008 int64_t ret = -EINVAL; 2009 bool force_share = false; 2010 bool explict_min_sparse = false; 2011 2012 ImgConvertState s = (ImgConvertState) { 2013 /* Need at least 4k of zeros for sparse detection */ 2014 .min_sparse = 8, 2015 .copy_range = false, 2016 .buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE, 2017 .wr_in_order = true, 2018 .num_coroutines = 8, 2019 }; 2020 2021 for(;;) { 2022 static const struct option long_options[] = { 2023 {"help", no_argument, 0, 'h'}, 2024 {"object", required_argument, 0, OPTION_OBJECT}, 2025 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2026 {"force-share", no_argument, 0, 'U'}, 2027 {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS}, 2028 {0, 0, 0, 0} 2029 }; 2030 c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU", 2031 long_options, NULL); 2032 if (c == -1) { 2033 break; 2034 } 2035 switch(c) { 2036 case ':': 2037 missing_argument(argv[optind - 1]); 2038 break; 2039 case '?': 2040 unrecognized_option(argv[optind - 1]); 2041 break; 2042 case 'h': 2043 help(); 2044 break; 2045 case 'f': 2046 fmt = optarg; 2047 break; 2048 case 'O': 2049 out_fmt = optarg; 2050 break; 2051 case 'B': 2052 out_baseimg = optarg; 2053 break; 2054 case 'C': 2055 s.copy_range = true; 2056 break; 2057 case 'c': 2058 s.compressed = true; 2059 break; 2060 case 'o': 2061 if (!is_valid_option_list(optarg)) { 2062 error_report("Invalid option list: %s", optarg); 2063 goto fail_getopt; 2064 } 2065 if (!options) { 2066 options = g_strdup(optarg); 2067 } else { 2068 char *old_options = options; 2069 options = g_strdup_printf("%s,%s", options, optarg); 2070 g_free(old_options); 2071 } 2072 break; 2073 case 'l': 2074 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) { 2075 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts, 2076 optarg, false); 2077 if (!sn_opts) { 2078 error_report("Failed in parsing snapshot param '%s'", 2079 optarg); 2080 goto fail_getopt; 2081 } 2082 } else { 2083 snapshot_name = optarg; 2084 } 2085 break; 2086 case 'S': 2087 { 2088 int64_t sval; 2089 2090 sval = cvtnum(optarg); 2091 if (sval < 0 || sval & (BDRV_SECTOR_SIZE - 1) || 2092 sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) { 2093 error_report("Invalid buffer size for sparse output specified. " 2094 "Valid sizes are multiples of %llu up to %llu. Select " 2095 "0 to disable sparse detection (fully allocates output).", 2096 BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE); 2097 goto fail_getopt; 2098 } 2099 2100 s.min_sparse = sval / BDRV_SECTOR_SIZE; 2101 explict_min_sparse = true; 2102 break; 2103 } 2104 case 'p': 2105 progress = true; 2106 break; 2107 case 't': 2108 cache = optarg; 2109 break; 2110 case 'T': 2111 src_cache = optarg; 2112 break; 2113 case 'q': 2114 quiet = true; 2115 break; 2116 case 'n': 2117 skip_create = true; 2118 break; 2119 case 'm': 2120 if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) || 2121 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) { 2122 error_report("Invalid number of coroutines. Allowed number of" 2123 " coroutines is between 1 and %d", MAX_COROUTINES); 2124 goto fail_getopt; 2125 } 2126 break; 2127 case 'W': 2128 s.wr_in_order = false; 2129 break; 2130 case 'U': 2131 force_share = true; 2132 break; 2133 case OPTION_OBJECT: { 2134 QemuOpts *object_opts; 2135 object_opts = qemu_opts_parse_noisily(&qemu_object_opts, 2136 optarg, true); 2137 if (!object_opts) { 2138 goto fail_getopt; 2139 } 2140 break; 2141 } 2142 case OPTION_IMAGE_OPTS: 2143 image_opts = true; 2144 break; 2145 case OPTION_TARGET_IMAGE_OPTS: 2146 tgt_image_opts = true; 2147 break; 2148 } 2149 } 2150 2151 if (!out_fmt && !tgt_image_opts) { 2152 out_fmt = "raw"; 2153 } 2154 2155 if (qemu_opts_foreach(&qemu_object_opts, 2156 user_creatable_add_opts_foreach, 2157 NULL, &error_fatal)) { 2158 goto fail_getopt; 2159 } 2160 2161 if (s.compressed && s.copy_range) { 2162 error_report("Cannot enable copy offloading when -c is used"); 2163 goto fail_getopt; 2164 } 2165 2166 if (explict_min_sparse && s.copy_range) { 2167 error_report("Cannot enable copy offloading when -S is used"); 2168 goto fail_getopt; 2169 } 2170 2171 if (tgt_image_opts && !skip_create) { 2172 error_report("--target-image-opts requires use of -n flag"); 2173 goto fail_getopt; 2174 } 2175 2176 s.src_num = argc - optind - 1; 2177 out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL; 2178 2179 if (options && has_help_option(options)) { 2180 if (out_fmt) { 2181 ret = print_block_option_help(out_filename, out_fmt); 2182 goto fail_getopt; 2183 } else { 2184 error_report("Option help requires a format be specified"); 2185 goto fail_getopt; 2186 } 2187 } 2188 2189 if (s.src_num < 1) { 2190 error_report("Must specify image file name"); 2191 goto fail_getopt; 2192 } 2193 2194 2195 /* ret is still -EINVAL until here */ 2196 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough); 2197 if (ret < 0) { 2198 error_report("Invalid source cache option: %s", src_cache); 2199 goto fail_getopt; 2200 } 2201 2202 /* Initialize before goto out */ 2203 if (quiet) { 2204 progress = false; 2205 } 2206 qemu_progress_init(progress, 1.0); 2207 qemu_progress_print(0, 100); 2208 2209 s.src = g_new0(BlockBackend *, s.src_num); 2210 s.src_sectors = g_new(int64_t, s.src_num); 2211 2212 for (bs_i = 0; bs_i < s.src_num; bs_i++) { 2213 s.src[bs_i] = img_open(image_opts, argv[optind + bs_i], 2214 fmt, src_flags, src_writethrough, quiet, 2215 force_share); 2216 if (!s.src[bs_i]) { 2217 ret = -1; 2218 goto out; 2219 } 2220 s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]); 2221 if (s.src_sectors[bs_i] < 0) { 2222 error_report("Could not get size of %s: %s", 2223 argv[optind + bs_i], strerror(-s.src_sectors[bs_i])); 2224 ret = -1; 2225 goto out; 2226 } 2227 s.total_sectors += s.src_sectors[bs_i]; 2228 } 2229 2230 if (sn_opts) { 2231 bdrv_snapshot_load_tmp(blk_bs(s.src[0]), 2232 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID), 2233 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME), 2234 &local_err); 2235 } else if (snapshot_name != NULL) { 2236 if (s.src_num > 1) { 2237 error_report("No support for concatenating multiple snapshot"); 2238 ret = -1; 2239 goto out; 2240 } 2241 2242 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name, 2243 &local_err); 2244 } 2245 if (local_err) { 2246 error_reportf_err(local_err, "Failed to load snapshot: "); 2247 ret = -1; 2248 goto out; 2249 } 2250 2251 if (!skip_create) { 2252 /* Find driver and parse its options */ 2253 drv = bdrv_find_format(out_fmt); 2254 if (!drv) { 2255 error_report("Unknown file format '%s'", out_fmt); 2256 ret = -1; 2257 goto out; 2258 } 2259 2260 proto_drv = bdrv_find_protocol(out_filename, true, &local_err); 2261 if (!proto_drv) { 2262 error_report_err(local_err); 2263 ret = -1; 2264 goto out; 2265 } 2266 2267 if (!drv->create_opts) { 2268 error_report("Format driver '%s' does not support image creation", 2269 drv->format_name); 2270 ret = -1; 2271 goto out; 2272 } 2273 2274 if (!proto_drv->create_opts) { 2275 error_report("Protocol driver '%s' does not support image creation", 2276 proto_drv->format_name); 2277 ret = -1; 2278 goto out; 2279 } 2280 2281 create_opts = qemu_opts_append(create_opts, drv->create_opts); 2282 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 2283 2284 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 2285 if (options) { 2286 qemu_opts_do_parse(opts, options, NULL, &local_err); 2287 if (local_err) { 2288 error_report_err(local_err); 2289 ret = -1; 2290 goto out; 2291 } 2292 } 2293 2294 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512, 2295 &error_abort); 2296 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL); 2297 if (ret < 0) { 2298 goto out; 2299 } 2300 } 2301 2302 /* Get backing file name if -o backing_file was used */ 2303 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 2304 if (out_baseimg_param) { 2305 out_baseimg = out_baseimg_param; 2306 } 2307 s.target_has_backing = (bool) out_baseimg; 2308 2309 if (s.src_num > 1 && out_baseimg) { 2310 error_report("Having a backing file for the target makes no sense when " 2311 "concatenating multiple input images"); 2312 ret = -1; 2313 goto out; 2314 } 2315 2316 /* Check if compression is supported */ 2317 if (s.compressed) { 2318 bool encryption = 2319 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false); 2320 const char *encryptfmt = 2321 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT); 2322 const char *preallocation = 2323 qemu_opt_get(opts, BLOCK_OPT_PREALLOC); 2324 2325 if (drv && !drv->bdrv_co_pwritev_compressed) { 2326 error_report("Compression not supported for this file format"); 2327 ret = -1; 2328 goto out; 2329 } 2330 2331 if (encryption || encryptfmt) { 2332 error_report("Compression and encryption not supported at " 2333 "the same time"); 2334 ret = -1; 2335 goto out; 2336 } 2337 2338 if (preallocation 2339 && strcmp(preallocation, "off")) 2340 { 2341 error_report("Compression and preallocation not supported at " 2342 "the same time"); 2343 ret = -1; 2344 goto out; 2345 } 2346 } 2347 2348 /* 2349 * The later open call will need any decryption secrets, and 2350 * bdrv_create() will purge "opts", so extract them now before 2351 * they are lost. 2352 */ 2353 if (!skip_create) { 2354 open_opts = qdict_new(); 2355 qemu_opt_foreach(opts, img_add_key_secrets, open_opts, &error_abort); 2356 } 2357 2358 if (!skip_create) { 2359 /* Create the new image */ 2360 ret = bdrv_create(drv, out_filename, opts, &local_err); 2361 if (ret < 0) { 2362 error_reportf_err(local_err, "%s: error while converting %s: ", 2363 out_filename, out_fmt); 2364 goto out; 2365 } 2366 } 2367 2368 flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR; 2369 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 2370 if (ret < 0) { 2371 error_report("Invalid cache option: %s", cache); 2372 goto out; 2373 } 2374 2375 if (skip_create) { 2376 s.target = img_open(tgt_image_opts, out_filename, out_fmt, 2377 flags, writethrough, quiet, false); 2378 } else { 2379 /* TODO ultimately we should allow --target-image-opts 2380 * to be used even when -n is not given. 2381 * That has to wait for bdrv_create to be improved 2382 * to allow filenames in option syntax 2383 */ 2384 s.target = img_open_file(out_filename, open_opts, out_fmt, 2385 flags, writethrough, quiet, false); 2386 open_opts = NULL; /* blk_new_open will have freed it */ 2387 } 2388 if (!s.target) { 2389 ret = -1; 2390 goto out; 2391 } 2392 out_bs = blk_bs(s.target); 2393 2394 if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) { 2395 error_report("Compression not supported for this file format"); 2396 ret = -1; 2397 goto out; 2398 } 2399 2400 /* increase bufsectors from the default 4096 (2M) if opt_transfer 2401 * or discard_alignment of the out_bs is greater. Limit to 2402 * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */ 2403 s.buf_sectors = MIN(MAX_BUF_SECTORS, 2404 MAX(s.buf_sectors, 2405 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS, 2406 out_bs->bl.pdiscard_alignment >> 2407 BDRV_SECTOR_BITS))); 2408 2409 /* try to align the write requests to the destination to avoid unnecessary 2410 * RMW cycles. */ 2411 s.alignment = MAX(pow2floor(s.min_sparse), 2412 DIV_ROUND_UP(out_bs->bl.request_alignment, 2413 BDRV_SECTOR_SIZE)); 2414 assert(is_power_of_2(s.alignment)); 2415 2416 if (skip_create) { 2417 int64_t output_sectors = blk_nb_sectors(s.target); 2418 if (output_sectors < 0) { 2419 error_report("unable to get output image length: %s", 2420 strerror(-output_sectors)); 2421 ret = -1; 2422 goto out; 2423 } else if (output_sectors < s.total_sectors) { 2424 error_report("output file is smaller than input file"); 2425 ret = -1; 2426 goto out; 2427 } 2428 } 2429 2430 if (s.target_has_backing) { 2431 /* Errors are treated as "backing length unknown" (which means 2432 * s.target_backing_sectors has to be negative, which it will 2433 * be automatically). The backing file length is used only 2434 * for optimizations, so such a case is not fatal. */ 2435 s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs); 2436 } else { 2437 s.target_backing_sectors = -1; 2438 } 2439 2440 ret = bdrv_get_info(out_bs, &bdi); 2441 if (ret < 0) { 2442 if (s.compressed) { 2443 error_report("could not get block driver info"); 2444 goto out; 2445 } 2446 } else { 2447 s.compressed = s.compressed || bdi.needs_compressed_writes; 2448 s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE; 2449 s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero; 2450 } 2451 2452 ret = convert_do_copy(&s); 2453 out: 2454 if (!ret) { 2455 qemu_progress_print(100, 0); 2456 } 2457 qemu_progress_end(); 2458 qemu_opts_del(opts); 2459 qemu_opts_free(create_opts); 2460 qemu_opts_del(sn_opts); 2461 qobject_unref(open_opts); 2462 blk_unref(s.target); 2463 if (s.src) { 2464 for (bs_i = 0; bs_i < s.src_num; bs_i++) { 2465 blk_unref(s.src[bs_i]); 2466 } 2467 g_free(s.src); 2468 } 2469 g_free(s.src_sectors); 2470 fail_getopt: 2471 g_free(options); 2472 2473 return !!ret; 2474 } 2475 2476 2477 static void dump_snapshots(BlockDriverState *bs) 2478 { 2479 QEMUSnapshotInfo *sn_tab, *sn; 2480 int nb_sns, i; 2481 2482 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 2483 if (nb_sns <= 0) 2484 return; 2485 printf("Snapshot list:\n"); 2486 bdrv_snapshot_dump(NULL); 2487 printf("\n"); 2488 for(i = 0; i < nb_sns; i++) { 2489 sn = &sn_tab[i]; 2490 bdrv_snapshot_dump(sn); 2491 printf("\n"); 2492 } 2493 g_free(sn_tab); 2494 } 2495 2496 static void dump_json_image_info_list(ImageInfoList *list) 2497 { 2498 QString *str; 2499 QObject *obj; 2500 Visitor *v = qobject_output_visitor_new(&obj); 2501 2502 visit_type_ImageInfoList(v, NULL, &list, &error_abort); 2503 visit_complete(v, &obj); 2504 str = qobject_to_json_pretty(obj); 2505 assert(str != NULL); 2506 printf("%s\n", qstring_get_str(str)); 2507 qobject_unref(obj); 2508 visit_free(v); 2509 qobject_unref(str); 2510 } 2511 2512 static void dump_json_image_info(ImageInfo *info) 2513 { 2514 QString *str; 2515 QObject *obj; 2516 Visitor *v = qobject_output_visitor_new(&obj); 2517 2518 visit_type_ImageInfo(v, NULL, &info, &error_abort); 2519 visit_complete(v, &obj); 2520 str = qobject_to_json_pretty(obj); 2521 assert(str != NULL); 2522 printf("%s\n", qstring_get_str(str)); 2523 qobject_unref(obj); 2524 visit_free(v); 2525 qobject_unref(str); 2526 } 2527 2528 static void dump_human_image_info_list(ImageInfoList *list) 2529 { 2530 ImageInfoList *elem; 2531 bool delim = false; 2532 2533 for (elem = list; elem; elem = elem->next) { 2534 if (delim) { 2535 printf("\n"); 2536 } 2537 delim = true; 2538 2539 bdrv_image_info_dump(elem->value); 2540 } 2541 } 2542 2543 static gboolean str_equal_func(gconstpointer a, gconstpointer b) 2544 { 2545 return strcmp(a, b) == 0; 2546 } 2547 2548 /** 2549 * Open an image file chain and return an ImageInfoList 2550 * 2551 * @filename: topmost image filename 2552 * @fmt: topmost image format (may be NULL to autodetect) 2553 * @chain: true - enumerate entire backing file chain 2554 * false - only topmost image file 2555 * 2556 * Returns a list of ImageInfo objects or NULL if there was an error opening an 2557 * image file. If there was an error a message will have been printed to 2558 * stderr. 2559 */ 2560 static ImageInfoList *collect_image_info_list(bool image_opts, 2561 const char *filename, 2562 const char *fmt, 2563 bool chain, bool force_share) 2564 { 2565 ImageInfoList *head = NULL; 2566 ImageInfoList **last = &head; 2567 GHashTable *filenames; 2568 Error *err = NULL; 2569 2570 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL); 2571 2572 while (filename) { 2573 BlockBackend *blk; 2574 BlockDriverState *bs; 2575 ImageInfo *info; 2576 ImageInfoList *elem; 2577 2578 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) { 2579 error_report("Backing file '%s' creates an infinite loop.", 2580 filename); 2581 goto err; 2582 } 2583 g_hash_table_insert(filenames, (gpointer)filename, NULL); 2584 2585 blk = img_open(image_opts, filename, fmt, 2586 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false, 2587 force_share); 2588 if (!blk) { 2589 goto err; 2590 } 2591 bs = blk_bs(blk); 2592 2593 bdrv_query_image_info(bs, &info, &err); 2594 if (err) { 2595 error_report_err(err); 2596 blk_unref(blk); 2597 goto err; 2598 } 2599 2600 elem = g_new0(ImageInfoList, 1); 2601 elem->value = info; 2602 *last = elem; 2603 last = &elem->next; 2604 2605 blk_unref(blk); 2606 2607 filename = fmt = NULL; 2608 if (chain) { 2609 if (info->has_full_backing_filename) { 2610 filename = info->full_backing_filename; 2611 } else if (info->has_backing_filename) { 2612 error_report("Could not determine absolute backing filename," 2613 " but backing filename '%s' present", 2614 info->backing_filename); 2615 goto err; 2616 } 2617 if (info->has_backing_filename_format) { 2618 fmt = info->backing_filename_format; 2619 } 2620 } 2621 } 2622 g_hash_table_destroy(filenames); 2623 return head; 2624 2625 err: 2626 qapi_free_ImageInfoList(head); 2627 g_hash_table_destroy(filenames); 2628 return NULL; 2629 } 2630 2631 static int img_info(int argc, char **argv) 2632 { 2633 int c; 2634 OutputFormat output_format = OFORMAT_HUMAN; 2635 bool chain = false; 2636 const char *filename, *fmt, *output; 2637 ImageInfoList *list; 2638 bool image_opts = false; 2639 bool force_share = false; 2640 2641 fmt = NULL; 2642 output = NULL; 2643 for(;;) { 2644 int option_index = 0; 2645 static const struct option long_options[] = { 2646 {"help", no_argument, 0, 'h'}, 2647 {"format", required_argument, 0, 'f'}, 2648 {"output", required_argument, 0, OPTION_OUTPUT}, 2649 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN}, 2650 {"object", required_argument, 0, OPTION_OBJECT}, 2651 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2652 {"force-share", no_argument, 0, 'U'}, 2653 {0, 0, 0, 0} 2654 }; 2655 c = getopt_long(argc, argv, ":f:hU", 2656 long_options, &option_index); 2657 if (c == -1) { 2658 break; 2659 } 2660 switch(c) { 2661 case ':': 2662 missing_argument(argv[optind - 1]); 2663 break; 2664 case '?': 2665 unrecognized_option(argv[optind - 1]); 2666 break; 2667 case 'h': 2668 help(); 2669 break; 2670 case 'f': 2671 fmt = optarg; 2672 break; 2673 case 'U': 2674 force_share = true; 2675 break; 2676 case OPTION_OUTPUT: 2677 output = optarg; 2678 break; 2679 case OPTION_BACKING_CHAIN: 2680 chain = true; 2681 break; 2682 case OPTION_OBJECT: { 2683 QemuOpts *opts; 2684 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2685 optarg, true); 2686 if (!opts) { 2687 return 1; 2688 } 2689 } break; 2690 case OPTION_IMAGE_OPTS: 2691 image_opts = true; 2692 break; 2693 } 2694 } 2695 if (optind != argc - 1) { 2696 error_exit("Expecting one image file name"); 2697 } 2698 filename = argv[optind++]; 2699 2700 if (output && !strcmp(output, "json")) { 2701 output_format = OFORMAT_JSON; 2702 } else if (output && !strcmp(output, "human")) { 2703 output_format = OFORMAT_HUMAN; 2704 } else if (output) { 2705 error_report("--output must be used with human or json as argument."); 2706 return 1; 2707 } 2708 2709 if (qemu_opts_foreach(&qemu_object_opts, 2710 user_creatable_add_opts_foreach, 2711 NULL, &error_fatal)) { 2712 return 1; 2713 } 2714 2715 list = collect_image_info_list(image_opts, filename, fmt, chain, 2716 force_share); 2717 if (!list) { 2718 return 1; 2719 } 2720 2721 switch (output_format) { 2722 case OFORMAT_HUMAN: 2723 dump_human_image_info_list(list); 2724 break; 2725 case OFORMAT_JSON: 2726 if (chain) { 2727 dump_json_image_info_list(list); 2728 } else { 2729 dump_json_image_info(list->value); 2730 } 2731 break; 2732 } 2733 2734 qapi_free_ImageInfoList(list); 2735 return 0; 2736 } 2737 2738 static int dump_map_entry(OutputFormat output_format, MapEntry *e, 2739 MapEntry *next) 2740 { 2741 switch (output_format) { 2742 case OFORMAT_HUMAN: 2743 if (e->data && !e->has_offset) { 2744 error_report("File contains external, encrypted or compressed clusters."); 2745 return -1; 2746 } 2747 if (e->data && !e->zero) { 2748 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n", 2749 e->start, e->length, 2750 e->has_offset ? e->offset : 0, 2751 e->has_filename ? e->filename : ""); 2752 } 2753 /* This format ignores the distinction between 0, ZERO and ZERO|DATA. 2754 * Modify the flags here to allow more coalescing. 2755 */ 2756 if (next && (!next->data || next->zero)) { 2757 next->data = false; 2758 next->zero = true; 2759 } 2760 break; 2761 case OFORMAT_JSON: 2762 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64"," 2763 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s", 2764 (e->start == 0 ? "[" : ",\n"), 2765 e->start, e->length, e->depth, 2766 e->zero ? "true" : "false", 2767 e->data ? "true" : "false"); 2768 if (e->has_offset) { 2769 printf(", \"offset\": %"PRId64"", e->offset); 2770 } 2771 putchar('}'); 2772 2773 if (!next) { 2774 printf("]\n"); 2775 } 2776 break; 2777 } 2778 return 0; 2779 } 2780 2781 static int get_block_status(BlockDriverState *bs, int64_t offset, 2782 int64_t bytes, MapEntry *e) 2783 { 2784 int ret; 2785 int depth; 2786 BlockDriverState *file; 2787 bool has_offset; 2788 int64_t map; 2789 char *filename = NULL; 2790 2791 /* As an optimization, we could cache the current range of unallocated 2792 * clusters in each file of the chain, and avoid querying the same 2793 * range repeatedly. 2794 */ 2795 2796 depth = 0; 2797 for (;;) { 2798 ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file); 2799 if (ret < 0) { 2800 return ret; 2801 } 2802 assert(bytes); 2803 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) { 2804 break; 2805 } 2806 bs = backing_bs(bs); 2807 if (bs == NULL) { 2808 ret = 0; 2809 break; 2810 } 2811 2812 depth++; 2813 } 2814 2815 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID); 2816 2817 if (file && has_offset) { 2818 bdrv_refresh_filename(file); 2819 filename = file->filename; 2820 } 2821 2822 *e = (MapEntry) { 2823 .start = offset, 2824 .length = bytes, 2825 .data = !!(ret & BDRV_BLOCK_DATA), 2826 .zero = !!(ret & BDRV_BLOCK_ZERO), 2827 .offset = map, 2828 .has_offset = has_offset, 2829 .depth = depth, 2830 .has_filename = filename, 2831 .filename = filename, 2832 }; 2833 2834 return 0; 2835 } 2836 2837 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next) 2838 { 2839 if (curr->length == 0) { 2840 return false; 2841 } 2842 if (curr->zero != next->zero || 2843 curr->data != next->data || 2844 curr->depth != next->depth || 2845 curr->has_filename != next->has_filename || 2846 curr->has_offset != next->has_offset) { 2847 return false; 2848 } 2849 if (curr->has_filename && strcmp(curr->filename, next->filename)) { 2850 return false; 2851 } 2852 if (curr->has_offset && curr->offset + curr->length != next->offset) { 2853 return false; 2854 } 2855 return true; 2856 } 2857 2858 static int img_map(int argc, char **argv) 2859 { 2860 int c; 2861 OutputFormat output_format = OFORMAT_HUMAN; 2862 BlockBackend *blk; 2863 BlockDriverState *bs; 2864 const char *filename, *fmt, *output; 2865 int64_t length; 2866 MapEntry curr = { .length = 0 }, next; 2867 int ret = 0; 2868 bool image_opts = false; 2869 bool force_share = false; 2870 2871 fmt = NULL; 2872 output = NULL; 2873 for (;;) { 2874 int option_index = 0; 2875 static const struct option long_options[] = { 2876 {"help", no_argument, 0, 'h'}, 2877 {"format", required_argument, 0, 'f'}, 2878 {"output", required_argument, 0, OPTION_OUTPUT}, 2879 {"object", required_argument, 0, OPTION_OBJECT}, 2880 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2881 {"force-share", no_argument, 0, 'U'}, 2882 {0, 0, 0, 0} 2883 }; 2884 c = getopt_long(argc, argv, ":f:hU", 2885 long_options, &option_index); 2886 if (c == -1) { 2887 break; 2888 } 2889 switch (c) { 2890 case ':': 2891 missing_argument(argv[optind - 1]); 2892 break; 2893 case '?': 2894 unrecognized_option(argv[optind - 1]); 2895 break; 2896 case 'h': 2897 help(); 2898 break; 2899 case 'f': 2900 fmt = optarg; 2901 break; 2902 case 'U': 2903 force_share = true; 2904 break; 2905 case OPTION_OUTPUT: 2906 output = optarg; 2907 break; 2908 case OPTION_OBJECT: { 2909 QemuOpts *opts; 2910 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2911 optarg, true); 2912 if (!opts) { 2913 return 1; 2914 } 2915 } break; 2916 case OPTION_IMAGE_OPTS: 2917 image_opts = true; 2918 break; 2919 } 2920 } 2921 if (optind != argc - 1) { 2922 error_exit("Expecting one image file name"); 2923 } 2924 filename = argv[optind]; 2925 2926 if (output && !strcmp(output, "json")) { 2927 output_format = OFORMAT_JSON; 2928 } else if (output && !strcmp(output, "human")) { 2929 output_format = OFORMAT_HUMAN; 2930 } else if (output) { 2931 error_report("--output must be used with human or json as argument."); 2932 return 1; 2933 } 2934 2935 if (qemu_opts_foreach(&qemu_object_opts, 2936 user_creatable_add_opts_foreach, 2937 NULL, &error_fatal)) { 2938 return 1; 2939 } 2940 2941 blk = img_open(image_opts, filename, fmt, 0, false, false, force_share); 2942 if (!blk) { 2943 return 1; 2944 } 2945 bs = blk_bs(blk); 2946 2947 if (output_format == OFORMAT_HUMAN) { 2948 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File"); 2949 } 2950 2951 length = blk_getlength(blk); 2952 while (curr.start + curr.length < length) { 2953 int64_t offset = curr.start + curr.length; 2954 int64_t n; 2955 2956 /* Probe up to 1 GiB at a time. */ 2957 n = MIN(1 << 30, length - offset); 2958 ret = get_block_status(bs, offset, n, &next); 2959 2960 if (ret < 0) { 2961 error_report("Could not read file metadata: %s", strerror(-ret)); 2962 goto out; 2963 } 2964 2965 if (entry_mergeable(&curr, &next)) { 2966 curr.length += next.length; 2967 continue; 2968 } 2969 2970 if (curr.length > 0) { 2971 ret = dump_map_entry(output_format, &curr, &next); 2972 if (ret < 0) { 2973 goto out; 2974 } 2975 } 2976 curr = next; 2977 } 2978 2979 ret = dump_map_entry(output_format, &curr, NULL); 2980 2981 out: 2982 blk_unref(blk); 2983 return ret < 0; 2984 } 2985 2986 #define SNAPSHOT_LIST 1 2987 #define SNAPSHOT_CREATE 2 2988 #define SNAPSHOT_APPLY 3 2989 #define SNAPSHOT_DELETE 4 2990 2991 static int img_snapshot(int argc, char **argv) 2992 { 2993 BlockBackend *blk; 2994 BlockDriverState *bs; 2995 QEMUSnapshotInfo sn; 2996 char *filename, *snapshot_name = NULL; 2997 int c, ret = 0, bdrv_oflags; 2998 int action = 0; 2999 qemu_timeval tv; 3000 bool quiet = false; 3001 Error *err = NULL; 3002 bool image_opts = false; 3003 bool force_share = false; 3004 3005 bdrv_oflags = BDRV_O_RDWR; 3006 /* Parse commandline parameters */ 3007 for(;;) { 3008 static const struct option long_options[] = { 3009 {"help", no_argument, 0, 'h'}, 3010 {"object", required_argument, 0, OPTION_OBJECT}, 3011 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3012 {"force-share", no_argument, 0, 'U'}, 3013 {0, 0, 0, 0} 3014 }; 3015 c = getopt_long(argc, argv, ":la:c:d:hqU", 3016 long_options, NULL); 3017 if (c == -1) { 3018 break; 3019 } 3020 switch(c) { 3021 case ':': 3022 missing_argument(argv[optind - 1]); 3023 break; 3024 case '?': 3025 unrecognized_option(argv[optind - 1]); 3026 break; 3027 case 'h': 3028 help(); 3029 return 0; 3030 case 'l': 3031 if (action) { 3032 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 3033 return 0; 3034 } 3035 action = SNAPSHOT_LIST; 3036 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 3037 break; 3038 case 'a': 3039 if (action) { 3040 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 3041 return 0; 3042 } 3043 action = SNAPSHOT_APPLY; 3044 snapshot_name = optarg; 3045 break; 3046 case 'c': 3047 if (action) { 3048 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 3049 return 0; 3050 } 3051 action = SNAPSHOT_CREATE; 3052 snapshot_name = optarg; 3053 break; 3054 case 'd': 3055 if (action) { 3056 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 3057 return 0; 3058 } 3059 action = SNAPSHOT_DELETE; 3060 snapshot_name = optarg; 3061 break; 3062 case 'q': 3063 quiet = true; 3064 break; 3065 case 'U': 3066 force_share = true; 3067 break; 3068 case OPTION_OBJECT: { 3069 QemuOpts *opts; 3070 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3071 optarg, true); 3072 if (!opts) { 3073 return 1; 3074 } 3075 } break; 3076 case OPTION_IMAGE_OPTS: 3077 image_opts = true; 3078 break; 3079 } 3080 } 3081 3082 if (optind != argc - 1) { 3083 error_exit("Expecting one image file name"); 3084 } 3085 filename = argv[optind++]; 3086 3087 if (qemu_opts_foreach(&qemu_object_opts, 3088 user_creatable_add_opts_foreach, 3089 NULL, &error_fatal)) { 3090 return 1; 3091 } 3092 3093 /* Open the image */ 3094 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet, 3095 force_share); 3096 if (!blk) { 3097 return 1; 3098 } 3099 bs = blk_bs(blk); 3100 3101 /* Perform the requested action */ 3102 switch(action) { 3103 case SNAPSHOT_LIST: 3104 dump_snapshots(bs); 3105 break; 3106 3107 case SNAPSHOT_CREATE: 3108 memset(&sn, 0, sizeof(sn)); 3109 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 3110 3111 qemu_gettimeofday(&tv); 3112 sn.date_sec = tv.tv_sec; 3113 sn.date_nsec = tv.tv_usec * 1000; 3114 3115 ret = bdrv_snapshot_create(bs, &sn); 3116 if (ret) { 3117 error_report("Could not create snapshot '%s': %d (%s)", 3118 snapshot_name, ret, strerror(-ret)); 3119 } 3120 break; 3121 3122 case SNAPSHOT_APPLY: 3123 ret = bdrv_snapshot_goto(bs, snapshot_name, &err); 3124 if (ret) { 3125 error_reportf_err(err, "Could not apply snapshot '%s': ", 3126 snapshot_name); 3127 } 3128 break; 3129 3130 case SNAPSHOT_DELETE: 3131 ret = bdrv_snapshot_find(bs, &sn, snapshot_name); 3132 if (ret < 0) { 3133 error_report("Could not delete snapshot '%s': snapshot not " 3134 "found", snapshot_name); 3135 ret = 1; 3136 } else { 3137 ret = bdrv_snapshot_delete(bs, sn.id_str, sn.name, &err); 3138 if (ret < 0) { 3139 error_reportf_err(err, "Could not delete snapshot '%s': ", 3140 snapshot_name); 3141 ret = 1; 3142 } 3143 } 3144 break; 3145 } 3146 3147 /* Cleanup */ 3148 blk_unref(blk); 3149 if (ret) { 3150 return 1; 3151 } 3152 return 0; 3153 } 3154 3155 static int img_rebase(int argc, char **argv) 3156 { 3157 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL; 3158 uint8_t *buf_old = NULL; 3159 uint8_t *buf_new = NULL; 3160 BlockDriverState *bs = NULL; 3161 char *filename; 3162 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg; 3163 int c, flags, src_flags, ret; 3164 bool writethrough, src_writethrough; 3165 int unsafe = 0; 3166 bool force_share = false; 3167 int progress = 0; 3168 bool quiet = false; 3169 Error *local_err = NULL; 3170 bool image_opts = false; 3171 3172 /* Parse commandline parameters */ 3173 fmt = NULL; 3174 cache = BDRV_DEFAULT_CACHE; 3175 src_cache = BDRV_DEFAULT_CACHE; 3176 out_baseimg = NULL; 3177 out_basefmt = NULL; 3178 for(;;) { 3179 static const struct option long_options[] = { 3180 {"help", no_argument, 0, 'h'}, 3181 {"object", required_argument, 0, OPTION_OBJECT}, 3182 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3183 {"force-share", no_argument, 0, 'U'}, 3184 {0, 0, 0, 0} 3185 }; 3186 c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU", 3187 long_options, NULL); 3188 if (c == -1) { 3189 break; 3190 } 3191 switch(c) { 3192 case ':': 3193 missing_argument(argv[optind - 1]); 3194 break; 3195 case '?': 3196 unrecognized_option(argv[optind - 1]); 3197 break; 3198 case 'h': 3199 help(); 3200 return 0; 3201 case 'f': 3202 fmt = optarg; 3203 break; 3204 case 'F': 3205 out_basefmt = optarg; 3206 break; 3207 case 'b': 3208 out_baseimg = optarg; 3209 break; 3210 case 'u': 3211 unsafe = 1; 3212 break; 3213 case 'p': 3214 progress = 1; 3215 break; 3216 case 't': 3217 cache = optarg; 3218 break; 3219 case 'T': 3220 src_cache = optarg; 3221 break; 3222 case 'q': 3223 quiet = true; 3224 break; 3225 case OPTION_OBJECT: { 3226 QemuOpts *opts; 3227 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3228 optarg, true); 3229 if (!opts) { 3230 return 1; 3231 } 3232 } break; 3233 case OPTION_IMAGE_OPTS: 3234 image_opts = true; 3235 break; 3236 case 'U': 3237 force_share = true; 3238 break; 3239 } 3240 } 3241 3242 if (quiet) { 3243 progress = 0; 3244 } 3245 3246 if (optind != argc - 1) { 3247 error_exit("Expecting one image file name"); 3248 } 3249 if (!unsafe && !out_baseimg) { 3250 error_exit("Must specify backing file (-b) or use unsafe mode (-u)"); 3251 } 3252 filename = argv[optind++]; 3253 3254 if (qemu_opts_foreach(&qemu_object_opts, 3255 user_creatable_add_opts_foreach, 3256 NULL, &error_fatal)) { 3257 return 1; 3258 } 3259 3260 qemu_progress_init(progress, 2.0); 3261 qemu_progress_print(0, 100); 3262 3263 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 3264 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 3265 if (ret < 0) { 3266 error_report("Invalid cache option: %s", cache); 3267 goto out; 3268 } 3269 3270 src_flags = 0; 3271 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough); 3272 if (ret < 0) { 3273 error_report("Invalid source cache option: %s", src_cache); 3274 goto out; 3275 } 3276 3277 /* The source files are opened read-only, don't care about WCE */ 3278 assert((src_flags & BDRV_O_RDWR) == 0); 3279 (void) src_writethrough; 3280 3281 /* 3282 * Open the images. 3283 * 3284 * Ignore the old backing file for unsafe rebase in case we want to correct 3285 * the reference to a renamed or moved backing file. 3286 */ 3287 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 3288 false); 3289 if (!blk) { 3290 ret = -1; 3291 goto out; 3292 } 3293 bs = blk_bs(blk); 3294 3295 if (out_basefmt != NULL) { 3296 if (bdrv_find_format(out_basefmt) == NULL) { 3297 error_report("Invalid format name: '%s'", out_basefmt); 3298 ret = -1; 3299 goto out; 3300 } 3301 } 3302 3303 /* For safe rebasing we need to compare old and new backing file */ 3304 if (!unsafe) { 3305 char backing_name[PATH_MAX]; 3306 QDict *options = NULL; 3307 3308 if (bs->backing_format[0] != '\0') { 3309 options = qdict_new(); 3310 qdict_put_str(options, "driver", bs->backing_format); 3311 } 3312 3313 if (force_share) { 3314 if (!options) { 3315 options = qdict_new(); 3316 } 3317 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true); 3318 } 3319 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 3320 blk_old_backing = blk_new_open(backing_name, NULL, 3321 options, src_flags, &local_err); 3322 if (!blk_old_backing) { 3323 error_reportf_err(local_err, 3324 "Could not open old backing file '%s': ", 3325 backing_name); 3326 ret = -1; 3327 goto out; 3328 } 3329 3330 if (out_baseimg[0]) { 3331 const char *overlay_filename; 3332 char *out_real_path; 3333 3334 options = qdict_new(); 3335 if (out_basefmt) { 3336 qdict_put_str(options, "driver", out_basefmt); 3337 } 3338 if (force_share) { 3339 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true); 3340 } 3341 3342 bdrv_refresh_filename(bs); 3343 overlay_filename = bs->exact_filename[0] ? bs->exact_filename 3344 : bs->filename; 3345 out_real_path = 3346 bdrv_get_full_backing_filename_from_filename(overlay_filename, 3347 out_baseimg, 3348 &local_err); 3349 if (local_err) { 3350 error_reportf_err(local_err, 3351 "Could not resolve backing filename: "); 3352 ret = -1; 3353 goto out; 3354 } 3355 3356 blk_new_backing = blk_new_open(out_real_path, NULL, 3357 options, src_flags, &local_err); 3358 g_free(out_real_path); 3359 if (!blk_new_backing) { 3360 error_reportf_err(local_err, 3361 "Could not open new backing file '%s': ", 3362 out_baseimg); 3363 ret = -1; 3364 goto out; 3365 } 3366 } 3367 } 3368 3369 /* 3370 * Check each unallocated cluster in the COW file. If it is unallocated, 3371 * accesses go to the backing file. We must therefore compare this cluster 3372 * in the old and new backing file, and if they differ we need to copy it 3373 * from the old backing file into the COW file. 3374 * 3375 * If qemu-img crashes during this step, no harm is done. The content of 3376 * the image is the same as the original one at any time. 3377 */ 3378 if (!unsafe) { 3379 int64_t size; 3380 int64_t old_backing_size; 3381 int64_t new_backing_size = 0; 3382 uint64_t offset; 3383 int64_t n; 3384 float local_progress = 0; 3385 3386 buf_old = blk_blockalign(blk, IO_BUF_SIZE); 3387 buf_new = blk_blockalign(blk, IO_BUF_SIZE); 3388 3389 size = blk_getlength(blk); 3390 if (size < 0) { 3391 error_report("Could not get size of '%s': %s", 3392 filename, strerror(-size)); 3393 ret = -1; 3394 goto out; 3395 } 3396 old_backing_size = blk_getlength(blk_old_backing); 3397 if (old_backing_size < 0) { 3398 char backing_name[PATH_MAX]; 3399 3400 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 3401 error_report("Could not get size of '%s': %s", 3402 backing_name, strerror(-old_backing_size)); 3403 ret = -1; 3404 goto out; 3405 } 3406 if (blk_new_backing) { 3407 new_backing_size = blk_getlength(blk_new_backing); 3408 if (new_backing_size < 0) { 3409 error_report("Could not get size of '%s': %s", 3410 out_baseimg, strerror(-new_backing_size)); 3411 ret = -1; 3412 goto out; 3413 } 3414 } 3415 3416 if (size != 0) { 3417 local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE)); 3418 } 3419 3420 for (offset = 0; offset < size; offset += n) { 3421 /* How many bytes can we handle with the next read? */ 3422 n = MIN(IO_BUF_SIZE, size - offset); 3423 3424 /* If the cluster is allocated, we don't need to take action */ 3425 ret = bdrv_is_allocated(bs, offset, n, &n); 3426 if (ret < 0) { 3427 error_report("error while reading image metadata: %s", 3428 strerror(-ret)); 3429 goto out; 3430 } 3431 if (ret) { 3432 continue; 3433 } 3434 3435 /* 3436 * Read old and new backing file and take into consideration that 3437 * backing files may be smaller than the COW image. 3438 */ 3439 if (offset >= old_backing_size) { 3440 memset(buf_old, 0, n); 3441 } else { 3442 if (offset + n > old_backing_size) { 3443 n = old_backing_size - offset; 3444 } 3445 3446 ret = blk_pread(blk_old_backing, offset, buf_old, n); 3447 if (ret < 0) { 3448 error_report("error while reading from old backing file"); 3449 goto out; 3450 } 3451 } 3452 3453 if (offset >= new_backing_size || !blk_new_backing) { 3454 memset(buf_new, 0, n); 3455 } else { 3456 if (offset + n > new_backing_size) { 3457 n = new_backing_size - offset; 3458 } 3459 3460 ret = blk_pread(blk_new_backing, offset, buf_new, n); 3461 if (ret < 0) { 3462 error_report("error while reading from new backing file"); 3463 goto out; 3464 } 3465 } 3466 3467 /* If they differ, we need to write to the COW file */ 3468 uint64_t written = 0; 3469 3470 while (written < n) { 3471 int64_t pnum; 3472 3473 if (compare_buffers(buf_old + written, buf_new + written, 3474 n - written, &pnum)) 3475 { 3476 ret = blk_pwrite(blk, offset + written, 3477 buf_old + written, pnum, 0); 3478 if (ret < 0) { 3479 error_report("Error while writing to COW image: %s", 3480 strerror(-ret)); 3481 goto out; 3482 } 3483 } 3484 3485 written += pnum; 3486 } 3487 qemu_progress_print(local_progress, 100); 3488 } 3489 } 3490 3491 /* 3492 * Change the backing file. All clusters that are different from the old 3493 * backing file are overwritten in the COW file now, so the visible content 3494 * doesn't change when we switch the backing file. 3495 */ 3496 if (out_baseimg && *out_baseimg) { 3497 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 3498 } else { 3499 ret = bdrv_change_backing_file(bs, NULL, NULL); 3500 } 3501 3502 if (ret == -ENOSPC) { 3503 error_report("Could not change the backing file to '%s': No " 3504 "space left in the file header", out_baseimg); 3505 } else if (ret < 0) { 3506 error_report("Could not change the backing file to '%s': %s", 3507 out_baseimg, strerror(-ret)); 3508 } 3509 3510 qemu_progress_print(100, 0); 3511 /* 3512 * TODO At this point it is possible to check if any clusters that are 3513 * allocated in the COW file are the same in the backing file. If so, they 3514 * could be dropped from the COW file. Don't do this before switching the 3515 * backing file, in case of a crash this would lead to corruption. 3516 */ 3517 out: 3518 qemu_progress_end(); 3519 /* Cleanup */ 3520 if (!unsafe) { 3521 blk_unref(blk_old_backing); 3522 blk_unref(blk_new_backing); 3523 } 3524 qemu_vfree(buf_old); 3525 qemu_vfree(buf_new); 3526 3527 blk_unref(blk); 3528 if (ret) { 3529 return 1; 3530 } 3531 return 0; 3532 } 3533 3534 static int img_resize(int argc, char **argv) 3535 { 3536 Error *err = NULL; 3537 int c, ret, relative; 3538 const char *filename, *fmt, *size; 3539 int64_t n, total_size, current_size, new_size; 3540 bool quiet = false; 3541 BlockBackend *blk = NULL; 3542 PreallocMode prealloc = PREALLOC_MODE_OFF; 3543 QemuOpts *param; 3544 3545 static QemuOptsList resize_options = { 3546 .name = "resize_options", 3547 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head), 3548 .desc = { 3549 { 3550 .name = BLOCK_OPT_SIZE, 3551 .type = QEMU_OPT_SIZE, 3552 .help = "Virtual disk size" 3553 }, { 3554 /* end of list */ 3555 } 3556 }, 3557 }; 3558 bool image_opts = false; 3559 bool shrink = false; 3560 3561 /* Remove size from argv manually so that negative numbers are not treated 3562 * as options by getopt. */ 3563 if (argc < 3) { 3564 error_exit("Not enough arguments"); 3565 return 1; 3566 } 3567 3568 size = argv[--argc]; 3569 3570 /* Parse getopt arguments */ 3571 fmt = NULL; 3572 for(;;) { 3573 static const struct option long_options[] = { 3574 {"help", no_argument, 0, 'h'}, 3575 {"object", required_argument, 0, OPTION_OBJECT}, 3576 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3577 {"preallocation", required_argument, 0, OPTION_PREALLOCATION}, 3578 {"shrink", no_argument, 0, OPTION_SHRINK}, 3579 {0, 0, 0, 0} 3580 }; 3581 c = getopt_long(argc, argv, ":f:hq", 3582 long_options, NULL); 3583 if (c == -1) { 3584 break; 3585 } 3586 switch(c) { 3587 case ':': 3588 missing_argument(argv[optind - 1]); 3589 break; 3590 case '?': 3591 unrecognized_option(argv[optind - 1]); 3592 break; 3593 case 'h': 3594 help(); 3595 break; 3596 case 'f': 3597 fmt = optarg; 3598 break; 3599 case 'q': 3600 quiet = true; 3601 break; 3602 case OPTION_OBJECT: { 3603 QemuOpts *opts; 3604 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3605 optarg, true); 3606 if (!opts) { 3607 return 1; 3608 } 3609 } break; 3610 case OPTION_IMAGE_OPTS: 3611 image_opts = true; 3612 break; 3613 case OPTION_PREALLOCATION: 3614 prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg, 3615 PREALLOC_MODE__MAX, NULL); 3616 if (prealloc == PREALLOC_MODE__MAX) { 3617 error_report("Invalid preallocation mode '%s'", optarg); 3618 return 1; 3619 } 3620 break; 3621 case OPTION_SHRINK: 3622 shrink = true; 3623 break; 3624 } 3625 } 3626 if (optind != argc - 1) { 3627 error_exit("Expecting image file name and size"); 3628 } 3629 filename = argv[optind++]; 3630 3631 if (qemu_opts_foreach(&qemu_object_opts, 3632 user_creatable_add_opts_foreach, 3633 NULL, &error_fatal)) { 3634 return 1; 3635 } 3636 3637 /* Choose grow, shrink, or absolute resize mode */ 3638 switch (size[0]) { 3639 case '+': 3640 relative = 1; 3641 size++; 3642 break; 3643 case '-': 3644 relative = -1; 3645 size++; 3646 break; 3647 default: 3648 relative = 0; 3649 break; 3650 } 3651 3652 /* Parse size */ 3653 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort); 3654 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err); 3655 if (err) { 3656 error_report_err(err); 3657 ret = -1; 3658 qemu_opts_del(param); 3659 goto out; 3660 } 3661 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); 3662 qemu_opts_del(param); 3663 3664 blk = img_open(image_opts, filename, fmt, 3665 BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet, 3666 false); 3667 if (!blk) { 3668 ret = -1; 3669 goto out; 3670 } 3671 3672 current_size = blk_getlength(blk); 3673 if (current_size < 0) { 3674 error_report("Failed to inquire current image length: %s", 3675 strerror(-current_size)); 3676 ret = -1; 3677 goto out; 3678 } 3679 3680 if (relative) { 3681 total_size = current_size + n * relative; 3682 } else { 3683 total_size = n; 3684 } 3685 if (total_size <= 0) { 3686 error_report("New image size must be positive"); 3687 ret = -1; 3688 goto out; 3689 } 3690 3691 if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) { 3692 error_report("Preallocation can only be used for growing images"); 3693 ret = -1; 3694 goto out; 3695 } 3696 3697 if (total_size < current_size && !shrink) { 3698 warn_report("Shrinking an image will delete all data beyond the " 3699 "shrunken image's end. Before performing such an " 3700 "operation, make sure there is no important data there."); 3701 3702 if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) { 3703 error_report( 3704 "Use the --shrink option to perform a shrink operation."); 3705 ret = -1; 3706 goto out; 3707 } else { 3708 warn_report("Using the --shrink option will suppress this message. " 3709 "Note that future versions of qemu-img may refuse to " 3710 "shrink images without this option."); 3711 } 3712 } 3713 3714 ret = blk_truncate(blk, total_size, prealloc, &err); 3715 if (ret < 0) { 3716 error_report_err(err); 3717 goto out; 3718 } 3719 3720 new_size = blk_getlength(blk); 3721 if (new_size < 0) { 3722 error_report("Failed to verify truncated image length: %s", 3723 strerror(-new_size)); 3724 ret = -1; 3725 goto out; 3726 } 3727 3728 /* Some block drivers implement a truncation method, but only so 3729 * the user can cause qemu to refresh the image's size from disk. 3730 * The idea is that the user resizes the image outside of qemu and 3731 * then invokes block_resize to inform qemu about it. 3732 * (This includes iscsi and file-posix for device files.) 3733 * Of course, that is not the behavior someone invoking 3734 * qemu-img resize would find useful, so we catch that behavior 3735 * here and tell the user. */ 3736 if (new_size != total_size && new_size == current_size) { 3737 error_report("Image was not resized; resizing may not be supported " 3738 "for this image"); 3739 ret = -1; 3740 goto out; 3741 } 3742 3743 if (new_size != total_size) { 3744 warn_report("Image should have been resized to %" PRIi64 3745 " bytes, but was resized to %" PRIi64 " bytes", 3746 total_size, new_size); 3747 } 3748 3749 qprintf(quiet, "Image resized.\n"); 3750 3751 out: 3752 blk_unref(blk); 3753 if (ret) { 3754 return 1; 3755 } 3756 return 0; 3757 } 3758 3759 static void amend_status_cb(BlockDriverState *bs, 3760 int64_t offset, int64_t total_work_size, 3761 void *opaque) 3762 { 3763 qemu_progress_print(100.f * offset / total_work_size, 0); 3764 } 3765 3766 static int print_amend_option_help(const char *format) 3767 { 3768 BlockDriver *drv; 3769 3770 /* Find driver and parse its options */ 3771 drv = bdrv_find_format(format); 3772 if (!drv) { 3773 error_report("Unknown file format '%s'", format); 3774 return 1; 3775 } 3776 3777 if (!drv->bdrv_amend_options) { 3778 error_report("Format driver '%s' does not support option amendment", 3779 format); 3780 return 1; 3781 } 3782 3783 /* Every driver supporting amendment must have create_opts */ 3784 assert(drv->create_opts); 3785 3786 printf("Creation options for '%s':\n", format); 3787 qemu_opts_print_help(drv->create_opts, false); 3788 printf("\nNote that not all of these options may be amendable.\n"); 3789 return 0; 3790 } 3791 3792 static int img_amend(int argc, char **argv) 3793 { 3794 Error *err = NULL; 3795 int c, ret = 0; 3796 char *options = NULL; 3797 QemuOptsList *create_opts = NULL; 3798 QemuOpts *opts = NULL; 3799 const char *fmt = NULL, *filename, *cache; 3800 int flags; 3801 bool writethrough; 3802 bool quiet = false, progress = false; 3803 BlockBackend *blk = NULL; 3804 BlockDriverState *bs = NULL; 3805 bool image_opts = false; 3806 3807 cache = BDRV_DEFAULT_CACHE; 3808 for (;;) { 3809 static const struct option long_options[] = { 3810 {"help", no_argument, 0, 'h'}, 3811 {"object", required_argument, 0, OPTION_OBJECT}, 3812 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3813 {0, 0, 0, 0} 3814 }; 3815 c = getopt_long(argc, argv, ":ho:f:t:pq", 3816 long_options, NULL); 3817 if (c == -1) { 3818 break; 3819 } 3820 3821 switch (c) { 3822 case ':': 3823 missing_argument(argv[optind - 1]); 3824 break; 3825 case '?': 3826 unrecognized_option(argv[optind - 1]); 3827 break; 3828 case 'h': 3829 help(); 3830 break; 3831 case 'o': 3832 if (!is_valid_option_list(optarg)) { 3833 error_report("Invalid option list: %s", optarg); 3834 ret = -1; 3835 goto out_no_progress; 3836 } 3837 if (!options) { 3838 options = g_strdup(optarg); 3839 } else { 3840 char *old_options = options; 3841 options = g_strdup_printf("%s,%s", options, optarg); 3842 g_free(old_options); 3843 } 3844 break; 3845 case 'f': 3846 fmt = optarg; 3847 break; 3848 case 't': 3849 cache = optarg; 3850 break; 3851 case 'p': 3852 progress = true; 3853 break; 3854 case 'q': 3855 quiet = true; 3856 break; 3857 case OPTION_OBJECT: 3858 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3859 optarg, true); 3860 if (!opts) { 3861 ret = -1; 3862 goto out_no_progress; 3863 } 3864 break; 3865 case OPTION_IMAGE_OPTS: 3866 image_opts = true; 3867 break; 3868 } 3869 } 3870 3871 if (!options) { 3872 error_exit("Must specify options (-o)"); 3873 } 3874 3875 if (qemu_opts_foreach(&qemu_object_opts, 3876 user_creatable_add_opts_foreach, 3877 NULL, &error_fatal)) { 3878 ret = -1; 3879 goto out_no_progress; 3880 } 3881 3882 if (quiet) { 3883 progress = false; 3884 } 3885 qemu_progress_init(progress, 1.0); 3886 3887 filename = (optind == argc - 1) ? argv[argc - 1] : NULL; 3888 if (fmt && has_help_option(options)) { 3889 /* If a format is explicitly specified (and possibly no filename is 3890 * given), print option help here */ 3891 ret = print_amend_option_help(fmt); 3892 goto out; 3893 } 3894 3895 if (optind != argc - 1) { 3896 error_report("Expecting one image file name"); 3897 ret = -1; 3898 goto out; 3899 } 3900 3901 flags = BDRV_O_RDWR; 3902 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 3903 if (ret < 0) { 3904 error_report("Invalid cache option: %s", cache); 3905 goto out; 3906 } 3907 3908 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 3909 false); 3910 if (!blk) { 3911 ret = -1; 3912 goto out; 3913 } 3914 bs = blk_bs(blk); 3915 3916 fmt = bs->drv->format_name; 3917 3918 if (has_help_option(options)) { 3919 /* If the format was auto-detected, print option help here */ 3920 ret = print_amend_option_help(fmt); 3921 goto out; 3922 } 3923 3924 if (!bs->drv->bdrv_amend_options) { 3925 error_report("Format driver '%s' does not support option amendment", 3926 fmt); 3927 ret = -1; 3928 goto out; 3929 } 3930 3931 /* Every driver supporting amendment must have create_opts */ 3932 assert(bs->drv->create_opts); 3933 3934 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts); 3935 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 3936 qemu_opts_do_parse(opts, options, NULL, &err); 3937 if (err) { 3938 error_report_err(err); 3939 ret = -1; 3940 goto out; 3941 } 3942 3943 /* In case the driver does not call amend_status_cb() */ 3944 qemu_progress_print(0.f, 0); 3945 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err); 3946 qemu_progress_print(100.f, 0); 3947 if (ret < 0) { 3948 error_report_err(err); 3949 goto out; 3950 } 3951 3952 out: 3953 qemu_progress_end(); 3954 3955 out_no_progress: 3956 blk_unref(blk); 3957 qemu_opts_del(opts); 3958 qemu_opts_free(create_opts); 3959 g_free(options); 3960 3961 if (ret) { 3962 return 1; 3963 } 3964 return 0; 3965 } 3966 3967 typedef struct BenchData { 3968 BlockBackend *blk; 3969 uint64_t image_size; 3970 bool write; 3971 int bufsize; 3972 int step; 3973 int nrreq; 3974 int n; 3975 int flush_interval; 3976 bool drain_on_flush; 3977 uint8_t *buf; 3978 QEMUIOVector *qiov; 3979 3980 int in_flight; 3981 bool in_flush; 3982 uint64_t offset; 3983 } BenchData; 3984 3985 static void bench_undrained_flush_cb(void *opaque, int ret) 3986 { 3987 if (ret < 0) { 3988 error_report("Failed flush request: %s", strerror(-ret)); 3989 exit(EXIT_FAILURE); 3990 } 3991 } 3992 3993 static void bench_cb(void *opaque, int ret) 3994 { 3995 BenchData *b = opaque; 3996 BlockAIOCB *acb; 3997 3998 if (ret < 0) { 3999 error_report("Failed request: %s", strerror(-ret)); 4000 exit(EXIT_FAILURE); 4001 } 4002 4003 if (b->in_flush) { 4004 /* Just finished a flush with drained queue: Start next requests */ 4005 assert(b->in_flight == 0); 4006 b->in_flush = false; 4007 } else if (b->in_flight > 0) { 4008 int remaining = b->n - b->in_flight; 4009 4010 b->n--; 4011 b->in_flight--; 4012 4013 /* Time for flush? Drain queue if requested, then flush */ 4014 if (b->flush_interval && remaining % b->flush_interval == 0) { 4015 if (!b->in_flight || !b->drain_on_flush) { 4016 BlockCompletionFunc *cb; 4017 4018 if (b->drain_on_flush) { 4019 b->in_flush = true; 4020 cb = bench_cb; 4021 } else { 4022 cb = bench_undrained_flush_cb; 4023 } 4024 4025 acb = blk_aio_flush(b->blk, cb, b); 4026 if (!acb) { 4027 error_report("Failed to issue flush request"); 4028 exit(EXIT_FAILURE); 4029 } 4030 } 4031 if (b->drain_on_flush) { 4032 return; 4033 } 4034 } 4035 } 4036 4037 while (b->n > b->in_flight && b->in_flight < b->nrreq) { 4038 int64_t offset = b->offset; 4039 /* blk_aio_* might look for completed I/Os and kick bench_cb 4040 * again, so make sure this operation is counted by in_flight 4041 * and b->offset is ready for the next submission. 4042 */ 4043 b->in_flight++; 4044 b->offset += b->step; 4045 b->offset %= b->image_size; 4046 if (b->write) { 4047 acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b); 4048 } else { 4049 acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b); 4050 } 4051 if (!acb) { 4052 error_report("Failed to issue request"); 4053 exit(EXIT_FAILURE); 4054 } 4055 } 4056 } 4057 4058 static int img_bench(int argc, char **argv) 4059 { 4060 int c, ret = 0; 4061 const char *fmt = NULL, *filename; 4062 bool quiet = false; 4063 bool image_opts = false; 4064 bool is_write = false; 4065 int count = 75000; 4066 int depth = 64; 4067 int64_t offset = 0; 4068 size_t bufsize = 4096; 4069 int pattern = 0; 4070 size_t step = 0; 4071 int flush_interval = 0; 4072 bool drain_on_flush = true; 4073 int64_t image_size; 4074 BlockBackend *blk = NULL; 4075 BenchData data = {}; 4076 int flags = 0; 4077 bool writethrough = false; 4078 struct timeval t1, t2; 4079 int i; 4080 bool force_share = false; 4081 size_t buf_size; 4082 4083 for (;;) { 4084 static const struct option long_options[] = { 4085 {"help", no_argument, 0, 'h'}, 4086 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL}, 4087 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4088 {"pattern", required_argument, 0, OPTION_PATTERN}, 4089 {"no-drain", no_argument, 0, OPTION_NO_DRAIN}, 4090 {"force-share", no_argument, 0, 'U'}, 4091 {0, 0, 0, 0} 4092 }; 4093 c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL); 4094 if (c == -1) { 4095 break; 4096 } 4097 4098 switch (c) { 4099 case ':': 4100 missing_argument(argv[optind - 1]); 4101 break; 4102 case '?': 4103 unrecognized_option(argv[optind - 1]); 4104 break; 4105 case 'h': 4106 help(); 4107 break; 4108 case 'c': 4109 { 4110 unsigned long res; 4111 4112 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4113 error_report("Invalid request count specified"); 4114 return 1; 4115 } 4116 count = res; 4117 break; 4118 } 4119 case 'd': 4120 { 4121 unsigned long res; 4122 4123 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4124 error_report("Invalid queue depth specified"); 4125 return 1; 4126 } 4127 depth = res; 4128 break; 4129 } 4130 case 'f': 4131 fmt = optarg; 4132 break; 4133 case 'n': 4134 flags |= BDRV_O_NATIVE_AIO; 4135 break; 4136 case 'o': 4137 { 4138 offset = cvtnum(optarg); 4139 if (offset < 0) { 4140 error_report("Invalid offset specified"); 4141 return 1; 4142 } 4143 break; 4144 } 4145 break; 4146 case 'q': 4147 quiet = true; 4148 break; 4149 case 's': 4150 { 4151 int64_t sval; 4152 4153 sval = cvtnum(optarg); 4154 if (sval < 0 || sval > INT_MAX) { 4155 error_report("Invalid buffer size specified"); 4156 return 1; 4157 } 4158 4159 bufsize = sval; 4160 break; 4161 } 4162 case 'S': 4163 { 4164 int64_t sval; 4165 4166 sval = cvtnum(optarg); 4167 if (sval < 0 || sval > INT_MAX) { 4168 error_report("Invalid step size specified"); 4169 return 1; 4170 } 4171 4172 step = sval; 4173 break; 4174 } 4175 case 't': 4176 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough); 4177 if (ret < 0) { 4178 error_report("Invalid cache mode"); 4179 ret = -1; 4180 goto out; 4181 } 4182 break; 4183 case 'w': 4184 flags |= BDRV_O_RDWR; 4185 is_write = true; 4186 break; 4187 case 'U': 4188 force_share = true; 4189 break; 4190 case OPTION_PATTERN: 4191 { 4192 unsigned long res; 4193 4194 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) { 4195 error_report("Invalid pattern byte specified"); 4196 return 1; 4197 } 4198 pattern = res; 4199 break; 4200 } 4201 case OPTION_FLUSH_INTERVAL: 4202 { 4203 unsigned long res; 4204 4205 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4206 error_report("Invalid flush interval specified"); 4207 return 1; 4208 } 4209 flush_interval = res; 4210 break; 4211 } 4212 case OPTION_NO_DRAIN: 4213 drain_on_flush = false; 4214 break; 4215 case OPTION_IMAGE_OPTS: 4216 image_opts = true; 4217 break; 4218 } 4219 } 4220 4221 if (optind != argc - 1) { 4222 error_exit("Expecting one image file name"); 4223 } 4224 filename = argv[argc - 1]; 4225 4226 if (!is_write && flush_interval) { 4227 error_report("--flush-interval is only available in write tests"); 4228 ret = -1; 4229 goto out; 4230 } 4231 if (flush_interval && flush_interval < depth) { 4232 error_report("Flush interval can't be smaller than depth"); 4233 ret = -1; 4234 goto out; 4235 } 4236 4237 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 4238 force_share); 4239 if (!blk) { 4240 ret = -1; 4241 goto out; 4242 } 4243 4244 image_size = blk_getlength(blk); 4245 if (image_size < 0) { 4246 ret = image_size; 4247 goto out; 4248 } 4249 4250 data = (BenchData) { 4251 .blk = blk, 4252 .image_size = image_size, 4253 .bufsize = bufsize, 4254 .step = step ?: bufsize, 4255 .nrreq = depth, 4256 .n = count, 4257 .offset = offset, 4258 .write = is_write, 4259 .flush_interval = flush_interval, 4260 .drain_on_flush = drain_on_flush, 4261 }; 4262 printf("Sending %d %s requests, %d bytes each, %d in parallel " 4263 "(starting at offset %" PRId64 ", step size %d)\n", 4264 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq, 4265 data.offset, data.step); 4266 if (flush_interval) { 4267 printf("Sending flush every %d requests\n", flush_interval); 4268 } 4269 4270 buf_size = data.nrreq * data.bufsize; 4271 data.buf = blk_blockalign(blk, buf_size); 4272 memset(data.buf, pattern, data.nrreq * data.bufsize); 4273 4274 blk_register_buf(blk, data.buf, buf_size); 4275 4276 data.qiov = g_new(QEMUIOVector, data.nrreq); 4277 for (i = 0; i < data.nrreq; i++) { 4278 qemu_iovec_init(&data.qiov[i], 1); 4279 qemu_iovec_add(&data.qiov[i], 4280 data.buf + i * data.bufsize, data.bufsize); 4281 } 4282 4283 gettimeofday(&t1, NULL); 4284 bench_cb(&data, 0); 4285 4286 while (data.n > 0) { 4287 main_loop_wait(false); 4288 } 4289 gettimeofday(&t2, NULL); 4290 4291 printf("Run completed in %3.3f seconds.\n", 4292 (t2.tv_sec - t1.tv_sec) 4293 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000)); 4294 4295 out: 4296 if (data.buf) { 4297 blk_unregister_buf(blk, data.buf); 4298 } 4299 qemu_vfree(data.buf); 4300 blk_unref(blk); 4301 4302 if (ret) { 4303 return 1; 4304 } 4305 return 0; 4306 } 4307 4308 #define C_BS 01 4309 #define C_COUNT 02 4310 #define C_IF 04 4311 #define C_OF 010 4312 #define C_SKIP 020 4313 4314 struct DdInfo { 4315 unsigned int flags; 4316 int64_t count; 4317 }; 4318 4319 struct DdIo { 4320 int bsz; /* Block size */ 4321 char *filename; 4322 uint8_t *buf; 4323 int64_t offset; 4324 }; 4325 4326 struct DdOpts { 4327 const char *name; 4328 int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *); 4329 unsigned int flag; 4330 }; 4331 4332 static int img_dd_bs(const char *arg, 4333 struct DdIo *in, struct DdIo *out, 4334 struct DdInfo *dd) 4335 { 4336 int64_t res; 4337 4338 res = cvtnum(arg); 4339 4340 if (res <= 0 || res > INT_MAX) { 4341 error_report("invalid number: '%s'", arg); 4342 return 1; 4343 } 4344 in->bsz = out->bsz = res; 4345 4346 return 0; 4347 } 4348 4349 static int img_dd_count(const char *arg, 4350 struct DdIo *in, struct DdIo *out, 4351 struct DdInfo *dd) 4352 { 4353 dd->count = cvtnum(arg); 4354 4355 if (dd->count < 0) { 4356 error_report("invalid number: '%s'", arg); 4357 return 1; 4358 } 4359 4360 return 0; 4361 } 4362 4363 static int img_dd_if(const char *arg, 4364 struct DdIo *in, struct DdIo *out, 4365 struct DdInfo *dd) 4366 { 4367 in->filename = g_strdup(arg); 4368 4369 return 0; 4370 } 4371 4372 static int img_dd_of(const char *arg, 4373 struct DdIo *in, struct DdIo *out, 4374 struct DdInfo *dd) 4375 { 4376 out->filename = g_strdup(arg); 4377 4378 return 0; 4379 } 4380 4381 static int img_dd_skip(const char *arg, 4382 struct DdIo *in, struct DdIo *out, 4383 struct DdInfo *dd) 4384 { 4385 in->offset = cvtnum(arg); 4386 4387 if (in->offset < 0) { 4388 error_report("invalid number: '%s'", arg); 4389 return 1; 4390 } 4391 4392 return 0; 4393 } 4394 4395 static int img_dd(int argc, char **argv) 4396 { 4397 int ret = 0; 4398 char *arg = NULL; 4399 char *tmp; 4400 BlockDriver *drv = NULL, *proto_drv = NULL; 4401 BlockBackend *blk1 = NULL, *blk2 = NULL; 4402 QemuOpts *opts = NULL; 4403 QemuOptsList *create_opts = NULL; 4404 Error *local_err = NULL; 4405 bool image_opts = false; 4406 int c, i; 4407 const char *out_fmt = "raw"; 4408 const char *fmt = NULL; 4409 int64_t size = 0; 4410 int64_t block_count = 0, out_pos, in_pos; 4411 bool force_share = false; 4412 struct DdInfo dd = { 4413 .flags = 0, 4414 .count = 0, 4415 }; 4416 struct DdIo in = { 4417 .bsz = 512, /* Block size is by default 512 bytes */ 4418 .filename = NULL, 4419 .buf = NULL, 4420 .offset = 0 4421 }; 4422 struct DdIo out = { 4423 .bsz = 512, 4424 .filename = NULL, 4425 .buf = NULL, 4426 .offset = 0 4427 }; 4428 4429 const struct DdOpts options[] = { 4430 { "bs", img_dd_bs, C_BS }, 4431 { "count", img_dd_count, C_COUNT }, 4432 { "if", img_dd_if, C_IF }, 4433 { "of", img_dd_of, C_OF }, 4434 { "skip", img_dd_skip, C_SKIP }, 4435 { NULL, NULL, 0 } 4436 }; 4437 const struct option long_options[] = { 4438 { "help", no_argument, 0, 'h'}, 4439 { "object", required_argument, 0, OPTION_OBJECT}, 4440 { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4441 { "force-share", no_argument, 0, 'U'}, 4442 { 0, 0, 0, 0 } 4443 }; 4444 4445 while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) { 4446 if (c == EOF) { 4447 break; 4448 } 4449 switch (c) { 4450 case 'O': 4451 out_fmt = optarg; 4452 break; 4453 case 'f': 4454 fmt = optarg; 4455 break; 4456 case ':': 4457 missing_argument(argv[optind - 1]); 4458 break; 4459 case '?': 4460 unrecognized_option(argv[optind - 1]); 4461 break; 4462 case 'h': 4463 help(); 4464 break; 4465 case 'U': 4466 force_share = true; 4467 break; 4468 case OPTION_OBJECT: 4469 if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) { 4470 ret = -1; 4471 goto out; 4472 } 4473 break; 4474 case OPTION_IMAGE_OPTS: 4475 image_opts = true; 4476 break; 4477 } 4478 } 4479 4480 for (i = optind; i < argc; i++) { 4481 int j; 4482 arg = g_strdup(argv[i]); 4483 4484 tmp = strchr(arg, '='); 4485 if (tmp == NULL) { 4486 error_report("unrecognized operand %s", arg); 4487 ret = -1; 4488 goto out; 4489 } 4490 4491 *tmp++ = '\0'; 4492 4493 for (j = 0; options[j].name != NULL; j++) { 4494 if (!strcmp(arg, options[j].name)) { 4495 break; 4496 } 4497 } 4498 if (options[j].name == NULL) { 4499 error_report("unrecognized operand %s", arg); 4500 ret = -1; 4501 goto out; 4502 } 4503 4504 if (options[j].f(tmp, &in, &out, &dd) != 0) { 4505 ret = -1; 4506 goto out; 4507 } 4508 dd.flags |= options[j].flag; 4509 g_free(arg); 4510 arg = NULL; 4511 } 4512 4513 if (!(dd.flags & C_IF && dd.flags & C_OF)) { 4514 error_report("Must specify both input and output files"); 4515 ret = -1; 4516 goto out; 4517 } 4518 4519 if (qemu_opts_foreach(&qemu_object_opts, 4520 user_creatable_add_opts_foreach, 4521 NULL, &error_fatal)) { 4522 ret = -1; 4523 goto out; 4524 } 4525 4526 blk1 = img_open(image_opts, in.filename, fmt, 0, false, false, 4527 force_share); 4528 4529 if (!blk1) { 4530 ret = -1; 4531 goto out; 4532 } 4533 4534 drv = bdrv_find_format(out_fmt); 4535 if (!drv) { 4536 error_report("Unknown file format"); 4537 ret = -1; 4538 goto out; 4539 } 4540 proto_drv = bdrv_find_protocol(out.filename, true, &local_err); 4541 4542 if (!proto_drv) { 4543 error_report_err(local_err); 4544 ret = -1; 4545 goto out; 4546 } 4547 if (!drv->create_opts) { 4548 error_report("Format driver '%s' does not support image creation", 4549 drv->format_name); 4550 ret = -1; 4551 goto out; 4552 } 4553 if (!proto_drv->create_opts) { 4554 error_report("Protocol driver '%s' does not support image creation", 4555 proto_drv->format_name); 4556 ret = -1; 4557 goto out; 4558 } 4559 create_opts = qemu_opts_append(create_opts, drv->create_opts); 4560 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 4561 4562 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 4563 4564 size = blk_getlength(blk1); 4565 if (size < 0) { 4566 error_report("Failed to get size for '%s'", in.filename); 4567 ret = -1; 4568 goto out; 4569 } 4570 4571 if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz && 4572 dd.count * in.bsz < size) { 4573 size = dd.count * in.bsz; 4574 } 4575 4576 /* Overflow means the specified offset is beyond input image's size */ 4577 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz || 4578 size < in.bsz * in.offset)) { 4579 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort); 4580 } else { 4581 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 4582 size - in.bsz * in.offset, &error_abort); 4583 } 4584 4585 ret = bdrv_create(drv, out.filename, opts, &local_err); 4586 if (ret < 0) { 4587 error_reportf_err(local_err, 4588 "%s: error while creating output image: ", 4589 out.filename); 4590 ret = -1; 4591 goto out; 4592 } 4593 4594 /* TODO, we can't honour --image-opts for the target, 4595 * since it needs to be given in a format compatible 4596 * with the bdrv_create() call above which does not 4597 * support image-opts style. 4598 */ 4599 blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR, 4600 false, false, false); 4601 4602 if (!blk2) { 4603 ret = -1; 4604 goto out; 4605 } 4606 4607 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz || 4608 size < in.offset * in.bsz)) { 4609 /* We give a warning if the skip option is bigger than the input 4610 * size and create an empty output disk image (i.e. like dd(1)). 4611 */ 4612 error_report("%s: cannot skip to specified offset", in.filename); 4613 in_pos = size; 4614 } else { 4615 in_pos = in.offset * in.bsz; 4616 } 4617 4618 in.buf = g_new(uint8_t, in.bsz); 4619 4620 for (out_pos = 0; in_pos < size; block_count++) { 4621 int in_ret, out_ret; 4622 4623 if (in_pos + in.bsz > size) { 4624 in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos); 4625 } else { 4626 in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz); 4627 } 4628 if (in_ret < 0) { 4629 error_report("error while reading from input image file: %s", 4630 strerror(-in_ret)); 4631 ret = -1; 4632 goto out; 4633 } 4634 in_pos += in_ret; 4635 4636 out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0); 4637 4638 if (out_ret < 0) { 4639 error_report("error while writing to output image file: %s", 4640 strerror(-out_ret)); 4641 ret = -1; 4642 goto out; 4643 } 4644 out_pos += out_ret; 4645 } 4646 4647 out: 4648 g_free(arg); 4649 qemu_opts_del(opts); 4650 qemu_opts_free(create_opts); 4651 blk_unref(blk1); 4652 blk_unref(blk2); 4653 g_free(in.filename); 4654 g_free(out.filename); 4655 g_free(in.buf); 4656 g_free(out.buf); 4657 4658 if (ret) { 4659 return 1; 4660 } 4661 return 0; 4662 } 4663 4664 static void dump_json_block_measure_info(BlockMeasureInfo *info) 4665 { 4666 QString *str; 4667 QObject *obj; 4668 Visitor *v = qobject_output_visitor_new(&obj); 4669 4670 visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort); 4671 visit_complete(v, &obj); 4672 str = qobject_to_json_pretty(obj); 4673 assert(str != NULL); 4674 printf("%s\n", qstring_get_str(str)); 4675 qobject_unref(obj); 4676 visit_free(v); 4677 qobject_unref(str); 4678 } 4679 4680 static int img_measure(int argc, char **argv) 4681 { 4682 static const struct option long_options[] = { 4683 {"help", no_argument, 0, 'h'}, 4684 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4685 {"object", required_argument, 0, OPTION_OBJECT}, 4686 {"output", required_argument, 0, OPTION_OUTPUT}, 4687 {"size", required_argument, 0, OPTION_SIZE}, 4688 {"force-share", no_argument, 0, 'U'}, 4689 {0, 0, 0, 0} 4690 }; 4691 OutputFormat output_format = OFORMAT_HUMAN; 4692 BlockBackend *in_blk = NULL; 4693 BlockDriver *drv; 4694 const char *filename = NULL; 4695 const char *fmt = NULL; 4696 const char *out_fmt = "raw"; 4697 char *options = NULL; 4698 char *snapshot_name = NULL; 4699 bool force_share = false; 4700 QemuOpts *opts = NULL; 4701 QemuOpts *object_opts = NULL; 4702 QemuOpts *sn_opts = NULL; 4703 QemuOptsList *create_opts = NULL; 4704 bool image_opts = false; 4705 uint64_t img_size = UINT64_MAX; 4706 BlockMeasureInfo *info = NULL; 4707 Error *local_err = NULL; 4708 int ret = 1; 4709 int c; 4710 4711 while ((c = getopt_long(argc, argv, "hf:O:o:l:U", 4712 long_options, NULL)) != -1) { 4713 switch (c) { 4714 case '?': 4715 case 'h': 4716 help(); 4717 break; 4718 case 'f': 4719 fmt = optarg; 4720 break; 4721 case 'O': 4722 out_fmt = optarg; 4723 break; 4724 case 'o': 4725 if (!is_valid_option_list(optarg)) { 4726 error_report("Invalid option list: %s", optarg); 4727 goto out; 4728 } 4729 if (!options) { 4730 options = g_strdup(optarg); 4731 } else { 4732 char *old_options = options; 4733 options = g_strdup_printf("%s,%s", options, optarg); 4734 g_free(old_options); 4735 } 4736 break; 4737 case 'l': 4738 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) { 4739 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts, 4740 optarg, false); 4741 if (!sn_opts) { 4742 error_report("Failed in parsing snapshot param '%s'", 4743 optarg); 4744 goto out; 4745 } 4746 } else { 4747 snapshot_name = optarg; 4748 } 4749 break; 4750 case 'U': 4751 force_share = true; 4752 break; 4753 case OPTION_OBJECT: 4754 object_opts = qemu_opts_parse_noisily(&qemu_object_opts, 4755 optarg, true); 4756 if (!object_opts) { 4757 goto out; 4758 } 4759 break; 4760 case OPTION_IMAGE_OPTS: 4761 image_opts = true; 4762 break; 4763 case OPTION_OUTPUT: 4764 if (!strcmp(optarg, "json")) { 4765 output_format = OFORMAT_JSON; 4766 } else if (!strcmp(optarg, "human")) { 4767 output_format = OFORMAT_HUMAN; 4768 } else { 4769 error_report("--output must be used with human or json " 4770 "as argument."); 4771 goto out; 4772 } 4773 break; 4774 case OPTION_SIZE: 4775 { 4776 int64_t sval; 4777 4778 sval = cvtnum(optarg); 4779 if (sval < 0) { 4780 if (sval == -ERANGE) { 4781 error_report("Image size must be less than 8 EiB!"); 4782 } else { 4783 error_report("Invalid image size specified! You may use " 4784 "k, M, G, T, P or E suffixes for "); 4785 error_report("kilobytes, megabytes, gigabytes, terabytes, " 4786 "petabytes and exabytes."); 4787 } 4788 goto out; 4789 } 4790 img_size = (uint64_t)sval; 4791 } 4792 break; 4793 } 4794 } 4795 4796 if (qemu_opts_foreach(&qemu_object_opts, 4797 user_creatable_add_opts_foreach, 4798 NULL, &error_fatal)) { 4799 goto out; 4800 } 4801 4802 if (argc - optind > 1) { 4803 error_report("At most one filename argument is allowed."); 4804 goto out; 4805 } else if (argc - optind == 1) { 4806 filename = argv[optind]; 4807 } 4808 4809 if (!filename && 4810 (object_opts || image_opts || fmt || snapshot_name || sn_opts)) { 4811 error_report("--object, --image-opts, -f, and -l " 4812 "require a filename argument."); 4813 goto out; 4814 } 4815 if (filename && img_size != UINT64_MAX) { 4816 error_report("--size N cannot be used together with a filename."); 4817 goto out; 4818 } 4819 if (!filename && img_size == UINT64_MAX) { 4820 error_report("Either --size N or one filename must be specified."); 4821 goto out; 4822 } 4823 4824 if (filename) { 4825 in_blk = img_open(image_opts, filename, fmt, 0, 4826 false, false, force_share); 4827 if (!in_blk) { 4828 goto out; 4829 } 4830 4831 if (sn_opts) { 4832 bdrv_snapshot_load_tmp(blk_bs(in_blk), 4833 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID), 4834 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME), 4835 &local_err); 4836 } else if (snapshot_name != NULL) { 4837 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk), 4838 snapshot_name, &local_err); 4839 } 4840 if (local_err) { 4841 error_reportf_err(local_err, "Failed to load snapshot: "); 4842 goto out; 4843 } 4844 } 4845 4846 drv = bdrv_find_format(out_fmt); 4847 if (!drv) { 4848 error_report("Unknown file format '%s'", out_fmt); 4849 goto out; 4850 } 4851 if (!drv->create_opts) { 4852 error_report("Format driver '%s' does not support image creation", 4853 drv->format_name); 4854 goto out; 4855 } 4856 4857 create_opts = qemu_opts_append(create_opts, drv->create_opts); 4858 create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts); 4859 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 4860 if (options) { 4861 qemu_opts_do_parse(opts, options, NULL, &local_err); 4862 if (local_err) { 4863 error_report_err(local_err); 4864 error_report("Invalid options for file format '%s'", out_fmt); 4865 goto out; 4866 } 4867 } 4868 if (img_size != UINT64_MAX) { 4869 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort); 4870 } 4871 4872 info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err); 4873 if (local_err) { 4874 error_report_err(local_err); 4875 goto out; 4876 } 4877 4878 if (output_format == OFORMAT_HUMAN) { 4879 printf("required size: %" PRIu64 "\n", info->required); 4880 printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated); 4881 } else { 4882 dump_json_block_measure_info(info); 4883 } 4884 4885 ret = 0; 4886 4887 out: 4888 qapi_free_BlockMeasureInfo(info); 4889 qemu_opts_del(object_opts); 4890 qemu_opts_del(opts); 4891 qemu_opts_del(sn_opts); 4892 qemu_opts_free(create_opts); 4893 g_free(options); 4894 blk_unref(in_blk); 4895 return ret; 4896 } 4897 4898 static const img_cmd_t img_cmds[] = { 4899 #define DEF(option, callback, arg_string) \ 4900 { option, callback }, 4901 #include "qemu-img-cmds.h" 4902 #undef DEF 4903 { NULL, NULL, }, 4904 }; 4905 4906 int main(int argc, char **argv) 4907 { 4908 const img_cmd_t *cmd; 4909 const char *cmdname; 4910 Error *local_error = NULL; 4911 char *trace_file = NULL; 4912 int c; 4913 static const struct option long_options[] = { 4914 {"help", no_argument, 0, 'h'}, 4915 {"version", no_argument, 0, 'V'}, 4916 {"trace", required_argument, NULL, 'T'}, 4917 {0, 0, 0, 0} 4918 }; 4919 4920 #ifdef CONFIG_POSIX 4921 signal(SIGPIPE, SIG_IGN); 4922 #endif 4923 4924 error_init(argv[0]); 4925 module_call_init(MODULE_INIT_TRACE); 4926 qemu_init_exec_dir(argv[0]); 4927 4928 if (qemu_init_main_loop(&local_error)) { 4929 error_report_err(local_error); 4930 exit(EXIT_FAILURE); 4931 } 4932 4933 qcrypto_init(&error_fatal); 4934 4935 module_call_init(MODULE_INIT_QOM); 4936 bdrv_init(); 4937 if (argc < 2) { 4938 error_exit("Not enough arguments"); 4939 } 4940 4941 qemu_add_opts(&qemu_object_opts); 4942 qemu_add_opts(&qemu_source_opts); 4943 qemu_add_opts(&qemu_trace_opts); 4944 4945 while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) { 4946 switch (c) { 4947 case ':': 4948 missing_argument(argv[optind - 1]); 4949 return 0; 4950 case '?': 4951 unrecognized_option(argv[optind - 1]); 4952 return 0; 4953 case 'h': 4954 help(); 4955 return 0; 4956 case 'V': 4957 printf(QEMU_IMG_VERSION); 4958 return 0; 4959 case 'T': 4960 g_free(trace_file); 4961 trace_file = trace_opt_parse(optarg); 4962 break; 4963 } 4964 } 4965 4966 cmdname = argv[optind]; 4967 4968 /* reset getopt_long scanning */ 4969 argc -= optind; 4970 if (argc < 1) { 4971 return 0; 4972 } 4973 argv += optind; 4974 qemu_reset_optind(); 4975 4976 if (!trace_init_backends()) { 4977 exit(1); 4978 } 4979 trace_init_file(trace_file); 4980 qemu_set_log(LOG_TRACE); 4981 4982 /* find the command */ 4983 for (cmd = img_cmds; cmd->name != NULL; cmd++) { 4984 if (!strcmp(cmdname, cmd->name)) { 4985 return cmd->handler(argc, argv); 4986 } 4987 } 4988 4989 /* not found */ 4990 error_exit("Command not found: %s", cmdname); 4991 } 4992