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