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