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(BLK_PERM_CONSISTENT_READ, 3317 BLK_PERM_ALL); 3318 ret = blk_insert_bs(blk_old_backing, base_bs, 3319 &local_err); 3320 if (ret < 0) { 3321 error_reportf_err(local_err, 3322 "Could not reuse old backing file '%s': ", 3323 base_bs->filename); 3324 goto out; 3325 } 3326 } else { 3327 blk_old_backing = NULL; 3328 } 3329 3330 if (out_baseimg[0]) { 3331 const char *overlay_filename; 3332 char *out_real_path; 3333 3334 options = qdict_new(); 3335 if (out_basefmt) { 3336 qdict_put_str(options, "driver", out_basefmt); 3337 } 3338 if (force_share) { 3339 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true); 3340 } 3341 3342 bdrv_refresh_filename(bs); 3343 overlay_filename = bs->exact_filename[0] ? bs->exact_filename 3344 : bs->filename; 3345 out_real_path = 3346 bdrv_get_full_backing_filename_from_filename(overlay_filename, 3347 out_baseimg, 3348 &local_err); 3349 if (local_err) { 3350 error_reportf_err(local_err, 3351 "Could not resolve backing filename: "); 3352 ret = -1; 3353 goto out; 3354 } 3355 3356 /* 3357 * Find out whether we rebase an image on top of a previous image 3358 * in its chain. 3359 */ 3360 prefix_chain_bs = bdrv_find_backing_image(bs, out_real_path); 3361 if (prefix_chain_bs) { 3362 g_free(out_real_path); 3363 blk_new_backing = blk_new(BLK_PERM_CONSISTENT_READ, 3364 BLK_PERM_ALL); 3365 ret = blk_insert_bs(blk_new_backing, prefix_chain_bs, 3366 &local_err); 3367 if (ret < 0) { 3368 error_reportf_err(local_err, 3369 "Could not reuse backing file '%s': ", 3370 out_baseimg); 3371 goto out; 3372 } 3373 } else { 3374 blk_new_backing = blk_new_open(out_real_path, NULL, 3375 options, src_flags, &local_err); 3376 g_free(out_real_path); 3377 if (!blk_new_backing) { 3378 error_reportf_err(local_err, 3379 "Could not open new backing file '%s': ", 3380 out_baseimg); 3381 ret = -1; 3382 goto out; 3383 } 3384 } 3385 } 3386 } 3387 3388 /* 3389 * Check each unallocated cluster in the COW file. If it is unallocated, 3390 * accesses go to the backing file. We must therefore compare this cluster 3391 * in the old and new backing file, and if they differ we need to copy it 3392 * from the old backing file into the COW file. 3393 * 3394 * If qemu-img crashes during this step, no harm is done. The content of 3395 * the image is the same as the original one at any time. 3396 */ 3397 if (!unsafe) { 3398 int64_t size; 3399 int64_t old_backing_size = 0; 3400 int64_t new_backing_size = 0; 3401 uint64_t offset; 3402 int64_t n; 3403 float local_progress = 0; 3404 3405 buf_old = blk_blockalign(blk, IO_BUF_SIZE); 3406 buf_new = blk_blockalign(blk, IO_BUF_SIZE); 3407 3408 size = blk_getlength(blk); 3409 if (size < 0) { 3410 error_report("Could not get size of '%s': %s", 3411 filename, strerror(-size)); 3412 ret = -1; 3413 goto out; 3414 } 3415 if (blk_old_backing) { 3416 old_backing_size = blk_getlength(blk_old_backing); 3417 if (old_backing_size < 0) { 3418 char backing_name[PATH_MAX]; 3419 3420 bdrv_get_backing_filename(bs, backing_name, 3421 sizeof(backing_name)); 3422 error_report("Could not get size of '%s': %s", 3423 backing_name, strerror(-old_backing_size)); 3424 ret = -1; 3425 goto out; 3426 } 3427 } 3428 if (blk_new_backing) { 3429 new_backing_size = blk_getlength(blk_new_backing); 3430 if (new_backing_size < 0) { 3431 error_report("Could not get size of '%s': %s", 3432 out_baseimg, strerror(-new_backing_size)); 3433 ret = -1; 3434 goto out; 3435 } 3436 } 3437 3438 if (size != 0) { 3439 local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE)); 3440 } 3441 3442 for (offset = 0; offset < size; offset += n) { 3443 bool buf_old_is_zero = false; 3444 3445 /* How many bytes can we handle with the next read? */ 3446 n = MIN(IO_BUF_SIZE, size - offset); 3447 3448 /* If the cluster is allocated, we don't need to take action */ 3449 ret = bdrv_is_allocated(bs, offset, n, &n); 3450 if (ret < 0) { 3451 error_report("error while reading image metadata: %s", 3452 strerror(-ret)); 3453 goto out; 3454 } 3455 if (ret) { 3456 continue; 3457 } 3458 3459 if (prefix_chain_bs) { 3460 /* 3461 * If cluster wasn't changed since prefix_chain, we don't need 3462 * to take action 3463 */ 3464 ret = bdrv_is_allocated_above(backing_bs(bs), prefix_chain_bs, 3465 offset, n, &n); 3466 if (ret < 0) { 3467 error_report("error while reading image metadata: %s", 3468 strerror(-ret)); 3469 goto out; 3470 } 3471 if (!ret) { 3472 continue; 3473 } 3474 } 3475 3476 /* 3477 * Read old and new backing file and take into consideration that 3478 * backing files may be smaller than the COW image. 3479 */ 3480 if (offset >= old_backing_size) { 3481 memset(buf_old, 0, n); 3482 buf_old_is_zero = true; 3483 } else { 3484 if (offset + n > old_backing_size) { 3485 n = old_backing_size - offset; 3486 } 3487 3488 ret = blk_pread(blk_old_backing, offset, buf_old, n); 3489 if (ret < 0) { 3490 error_report("error while reading from old backing file"); 3491 goto out; 3492 } 3493 } 3494 3495 if (offset >= new_backing_size || !blk_new_backing) { 3496 memset(buf_new, 0, n); 3497 } else { 3498 if (offset + n > new_backing_size) { 3499 n = new_backing_size - offset; 3500 } 3501 3502 ret = blk_pread(blk_new_backing, offset, buf_new, n); 3503 if (ret < 0) { 3504 error_report("error while reading from new backing file"); 3505 goto out; 3506 } 3507 } 3508 3509 /* If they differ, we need to write to the COW file */ 3510 uint64_t written = 0; 3511 3512 while (written < n) { 3513 int64_t pnum; 3514 3515 if (compare_buffers(buf_old + written, buf_new + written, 3516 n - written, &pnum)) 3517 { 3518 if (buf_old_is_zero) { 3519 ret = blk_pwrite_zeroes(blk, offset + written, pnum, 0); 3520 } else { 3521 ret = blk_pwrite(blk, offset + written, 3522 buf_old + written, pnum, 0); 3523 } 3524 if (ret < 0) { 3525 error_report("Error while writing to COW image: %s", 3526 strerror(-ret)); 3527 goto out; 3528 } 3529 } 3530 3531 written += pnum; 3532 } 3533 qemu_progress_print(local_progress, 100); 3534 } 3535 } 3536 3537 /* 3538 * Change the backing file. All clusters that are different from the old 3539 * backing file are overwritten in the COW file now, so the visible content 3540 * doesn't change when we switch the backing file. 3541 */ 3542 if (out_baseimg && *out_baseimg) { 3543 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 3544 } else { 3545 ret = bdrv_change_backing_file(bs, NULL, NULL); 3546 } 3547 3548 if (ret == -ENOSPC) { 3549 error_report("Could not change the backing file to '%s': No " 3550 "space left in the file header", out_baseimg); 3551 } else if (ret < 0) { 3552 error_report("Could not change the backing file to '%s': %s", 3553 out_baseimg, strerror(-ret)); 3554 } 3555 3556 qemu_progress_print(100, 0); 3557 /* 3558 * TODO At this point it is possible to check if any clusters that are 3559 * allocated in the COW file are the same in the backing file. If so, they 3560 * could be dropped from the COW file. Don't do this before switching the 3561 * backing file, in case of a crash this would lead to corruption. 3562 */ 3563 out: 3564 qemu_progress_end(); 3565 /* Cleanup */ 3566 if (!unsafe) { 3567 blk_unref(blk_old_backing); 3568 blk_unref(blk_new_backing); 3569 } 3570 qemu_vfree(buf_old); 3571 qemu_vfree(buf_new); 3572 3573 blk_unref(blk); 3574 if (ret) { 3575 return 1; 3576 } 3577 return 0; 3578 } 3579 3580 static int img_resize(int argc, char **argv) 3581 { 3582 Error *err = NULL; 3583 int c, ret, relative; 3584 const char *filename, *fmt, *size; 3585 int64_t n, total_size, current_size, new_size; 3586 bool quiet = false; 3587 BlockBackend *blk = NULL; 3588 PreallocMode prealloc = PREALLOC_MODE_OFF; 3589 QemuOpts *param; 3590 3591 static QemuOptsList resize_options = { 3592 .name = "resize_options", 3593 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head), 3594 .desc = { 3595 { 3596 .name = BLOCK_OPT_SIZE, 3597 .type = QEMU_OPT_SIZE, 3598 .help = "Virtual disk size" 3599 }, { 3600 /* end of list */ 3601 } 3602 }, 3603 }; 3604 bool image_opts = false; 3605 bool shrink = false; 3606 3607 /* Remove size from argv manually so that negative numbers are not treated 3608 * as options by getopt. */ 3609 if (argc < 3) { 3610 error_exit("Not enough arguments"); 3611 return 1; 3612 } 3613 3614 size = argv[--argc]; 3615 3616 /* Parse getopt arguments */ 3617 fmt = NULL; 3618 for(;;) { 3619 static const struct option long_options[] = { 3620 {"help", no_argument, 0, 'h'}, 3621 {"object", required_argument, 0, OPTION_OBJECT}, 3622 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3623 {"preallocation", required_argument, 0, OPTION_PREALLOCATION}, 3624 {"shrink", no_argument, 0, OPTION_SHRINK}, 3625 {0, 0, 0, 0} 3626 }; 3627 c = getopt_long(argc, argv, ":f:hq", 3628 long_options, NULL); 3629 if (c == -1) { 3630 break; 3631 } 3632 switch(c) { 3633 case ':': 3634 missing_argument(argv[optind - 1]); 3635 break; 3636 case '?': 3637 unrecognized_option(argv[optind - 1]); 3638 break; 3639 case 'h': 3640 help(); 3641 break; 3642 case 'f': 3643 fmt = optarg; 3644 break; 3645 case 'q': 3646 quiet = true; 3647 break; 3648 case OPTION_OBJECT: { 3649 QemuOpts *opts; 3650 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3651 optarg, true); 3652 if (!opts) { 3653 return 1; 3654 } 3655 } break; 3656 case OPTION_IMAGE_OPTS: 3657 image_opts = true; 3658 break; 3659 case OPTION_PREALLOCATION: 3660 prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg, 3661 PREALLOC_MODE__MAX, NULL); 3662 if (prealloc == PREALLOC_MODE__MAX) { 3663 error_report("Invalid preallocation mode '%s'", optarg); 3664 return 1; 3665 } 3666 break; 3667 case OPTION_SHRINK: 3668 shrink = true; 3669 break; 3670 } 3671 } 3672 if (optind != argc - 1) { 3673 error_exit("Expecting image file name and size"); 3674 } 3675 filename = argv[optind++]; 3676 3677 if (qemu_opts_foreach(&qemu_object_opts, 3678 user_creatable_add_opts_foreach, 3679 NULL, &error_fatal)) { 3680 return 1; 3681 } 3682 3683 /* Choose grow, shrink, or absolute resize mode */ 3684 switch (size[0]) { 3685 case '+': 3686 relative = 1; 3687 size++; 3688 break; 3689 case '-': 3690 relative = -1; 3691 size++; 3692 break; 3693 default: 3694 relative = 0; 3695 break; 3696 } 3697 3698 /* Parse size */ 3699 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort); 3700 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err); 3701 if (err) { 3702 error_report_err(err); 3703 ret = -1; 3704 qemu_opts_del(param); 3705 goto out; 3706 } 3707 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); 3708 qemu_opts_del(param); 3709 3710 blk = img_open(image_opts, filename, fmt, 3711 BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet, 3712 false); 3713 if (!blk) { 3714 ret = -1; 3715 goto out; 3716 } 3717 3718 current_size = blk_getlength(blk); 3719 if (current_size < 0) { 3720 error_report("Failed to inquire current image length: %s", 3721 strerror(-current_size)); 3722 ret = -1; 3723 goto out; 3724 } 3725 3726 if (relative) { 3727 total_size = current_size + n * relative; 3728 } else { 3729 total_size = n; 3730 } 3731 if (total_size <= 0) { 3732 error_report("New image size must be positive"); 3733 ret = -1; 3734 goto out; 3735 } 3736 3737 if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) { 3738 error_report("Preallocation can only be used for growing images"); 3739 ret = -1; 3740 goto out; 3741 } 3742 3743 if (total_size < current_size && !shrink) { 3744 warn_report("Shrinking an image will delete all data beyond the " 3745 "shrunken image's end. Before performing such an " 3746 "operation, make sure there is no important data there."); 3747 3748 if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) { 3749 error_report( 3750 "Use the --shrink option to perform a shrink operation."); 3751 ret = -1; 3752 goto out; 3753 } else { 3754 warn_report("Using the --shrink option will suppress this message. " 3755 "Note that future versions of qemu-img may refuse to " 3756 "shrink images without this option."); 3757 } 3758 } 3759 3760 ret = blk_truncate(blk, total_size, prealloc, &err); 3761 if (ret < 0) { 3762 error_report_err(err); 3763 goto out; 3764 } 3765 3766 new_size = blk_getlength(blk); 3767 if (new_size < 0) { 3768 error_report("Failed to verify truncated image length: %s", 3769 strerror(-new_size)); 3770 ret = -1; 3771 goto out; 3772 } 3773 3774 /* Some block drivers implement a truncation method, but only so 3775 * the user can cause qemu to refresh the image's size from disk. 3776 * The idea is that the user resizes the image outside of qemu and 3777 * then invokes block_resize to inform qemu about it. 3778 * (This includes iscsi and file-posix for device files.) 3779 * Of course, that is not the behavior someone invoking 3780 * qemu-img resize would find useful, so we catch that behavior 3781 * here and tell the user. */ 3782 if (new_size != total_size && new_size == current_size) { 3783 error_report("Image was not resized; resizing may not be supported " 3784 "for this image"); 3785 ret = -1; 3786 goto out; 3787 } 3788 3789 if (new_size != total_size) { 3790 warn_report("Image should have been resized to %" PRIi64 3791 " bytes, but was resized to %" PRIi64 " bytes", 3792 total_size, new_size); 3793 } 3794 3795 qprintf(quiet, "Image resized.\n"); 3796 3797 out: 3798 blk_unref(blk); 3799 if (ret) { 3800 return 1; 3801 } 3802 return 0; 3803 } 3804 3805 static void amend_status_cb(BlockDriverState *bs, 3806 int64_t offset, int64_t total_work_size, 3807 void *opaque) 3808 { 3809 qemu_progress_print(100.f * offset / total_work_size, 0); 3810 } 3811 3812 static int print_amend_option_help(const char *format) 3813 { 3814 BlockDriver *drv; 3815 3816 /* Find driver and parse its options */ 3817 drv = bdrv_find_format(format); 3818 if (!drv) { 3819 error_report("Unknown file format '%s'", format); 3820 return 1; 3821 } 3822 3823 if (!drv->bdrv_amend_options) { 3824 error_report("Format driver '%s' does not support option amendment", 3825 format); 3826 return 1; 3827 } 3828 3829 /* Every driver supporting amendment must have create_opts */ 3830 assert(drv->create_opts); 3831 3832 printf("Creation options for '%s':\n", format); 3833 qemu_opts_print_help(drv->create_opts, false); 3834 printf("\nNote that not all of these options may be amendable.\n"); 3835 return 0; 3836 } 3837 3838 static int img_amend(int argc, char **argv) 3839 { 3840 Error *err = NULL; 3841 int c, ret = 0; 3842 char *options = NULL; 3843 QemuOptsList *create_opts = NULL; 3844 QemuOpts *opts = NULL; 3845 const char *fmt = NULL, *filename, *cache; 3846 int flags; 3847 bool writethrough; 3848 bool quiet = false, progress = false; 3849 BlockBackend *blk = NULL; 3850 BlockDriverState *bs = NULL; 3851 bool image_opts = false; 3852 3853 cache = BDRV_DEFAULT_CACHE; 3854 for (;;) { 3855 static const struct option long_options[] = { 3856 {"help", no_argument, 0, 'h'}, 3857 {"object", required_argument, 0, OPTION_OBJECT}, 3858 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3859 {0, 0, 0, 0} 3860 }; 3861 c = getopt_long(argc, argv, ":ho:f:t:pq", 3862 long_options, NULL); 3863 if (c == -1) { 3864 break; 3865 } 3866 3867 switch (c) { 3868 case ':': 3869 missing_argument(argv[optind - 1]); 3870 break; 3871 case '?': 3872 unrecognized_option(argv[optind - 1]); 3873 break; 3874 case 'h': 3875 help(); 3876 break; 3877 case 'o': 3878 if (!is_valid_option_list(optarg)) { 3879 error_report("Invalid option list: %s", optarg); 3880 ret = -1; 3881 goto out_no_progress; 3882 } 3883 if (!options) { 3884 options = g_strdup(optarg); 3885 } else { 3886 char *old_options = options; 3887 options = g_strdup_printf("%s,%s", options, optarg); 3888 g_free(old_options); 3889 } 3890 break; 3891 case 'f': 3892 fmt = optarg; 3893 break; 3894 case 't': 3895 cache = optarg; 3896 break; 3897 case 'p': 3898 progress = true; 3899 break; 3900 case 'q': 3901 quiet = true; 3902 break; 3903 case OPTION_OBJECT: 3904 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3905 optarg, true); 3906 if (!opts) { 3907 ret = -1; 3908 goto out_no_progress; 3909 } 3910 break; 3911 case OPTION_IMAGE_OPTS: 3912 image_opts = true; 3913 break; 3914 } 3915 } 3916 3917 if (!options) { 3918 error_exit("Must specify options (-o)"); 3919 } 3920 3921 if (qemu_opts_foreach(&qemu_object_opts, 3922 user_creatable_add_opts_foreach, 3923 NULL, &error_fatal)) { 3924 ret = -1; 3925 goto out_no_progress; 3926 } 3927 3928 if (quiet) { 3929 progress = false; 3930 } 3931 qemu_progress_init(progress, 1.0); 3932 3933 filename = (optind == argc - 1) ? argv[argc - 1] : NULL; 3934 if (fmt && has_help_option(options)) { 3935 /* If a format is explicitly specified (and possibly no filename is 3936 * given), print option help here */ 3937 ret = print_amend_option_help(fmt); 3938 goto out; 3939 } 3940 3941 if (optind != argc - 1) { 3942 error_report("Expecting one image file name"); 3943 ret = -1; 3944 goto out; 3945 } 3946 3947 flags = BDRV_O_RDWR; 3948 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 3949 if (ret < 0) { 3950 error_report("Invalid cache option: %s", cache); 3951 goto out; 3952 } 3953 3954 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 3955 false); 3956 if (!blk) { 3957 ret = -1; 3958 goto out; 3959 } 3960 bs = blk_bs(blk); 3961 3962 fmt = bs->drv->format_name; 3963 3964 if (has_help_option(options)) { 3965 /* If the format was auto-detected, print option help here */ 3966 ret = print_amend_option_help(fmt); 3967 goto out; 3968 } 3969 3970 if (!bs->drv->bdrv_amend_options) { 3971 error_report("Format driver '%s' does not support option amendment", 3972 fmt); 3973 ret = -1; 3974 goto out; 3975 } 3976 3977 /* Every driver supporting amendment must have create_opts */ 3978 assert(bs->drv->create_opts); 3979 3980 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts); 3981 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 3982 qemu_opts_do_parse(opts, options, NULL, &err); 3983 if (err) { 3984 error_report_err(err); 3985 ret = -1; 3986 goto out; 3987 } 3988 3989 /* In case the driver does not call amend_status_cb() */ 3990 qemu_progress_print(0.f, 0); 3991 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err); 3992 qemu_progress_print(100.f, 0); 3993 if (ret < 0) { 3994 error_report_err(err); 3995 goto out; 3996 } 3997 3998 out: 3999 qemu_progress_end(); 4000 4001 out_no_progress: 4002 blk_unref(blk); 4003 qemu_opts_del(opts); 4004 qemu_opts_free(create_opts); 4005 g_free(options); 4006 4007 if (ret) { 4008 return 1; 4009 } 4010 return 0; 4011 } 4012 4013 typedef struct BenchData { 4014 BlockBackend *blk; 4015 uint64_t image_size; 4016 bool write; 4017 int bufsize; 4018 int step; 4019 int nrreq; 4020 int n; 4021 int flush_interval; 4022 bool drain_on_flush; 4023 uint8_t *buf; 4024 QEMUIOVector *qiov; 4025 4026 int in_flight; 4027 bool in_flush; 4028 uint64_t offset; 4029 } BenchData; 4030 4031 static void bench_undrained_flush_cb(void *opaque, int ret) 4032 { 4033 if (ret < 0) { 4034 error_report("Failed flush request: %s", strerror(-ret)); 4035 exit(EXIT_FAILURE); 4036 } 4037 } 4038 4039 static void bench_cb(void *opaque, int ret) 4040 { 4041 BenchData *b = opaque; 4042 BlockAIOCB *acb; 4043 4044 if (ret < 0) { 4045 error_report("Failed request: %s", strerror(-ret)); 4046 exit(EXIT_FAILURE); 4047 } 4048 4049 if (b->in_flush) { 4050 /* Just finished a flush with drained queue: Start next requests */ 4051 assert(b->in_flight == 0); 4052 b->in_flush = false; 4053 } else if (b->in_flight > 0) { 4054 int remaining = b->n - b->in_flight; 4055 4056 b->n--; 4057 b->in_flight--; 4058 4059 /* Time for flush? Drain queue if requested, then flush */ 4060 if (b->flush_interval && remaining % b->flush_interval == 0) { 4061 if (!b->in_flight || !b->drain_on_flush) { 4062 BlockCompletionFunc *cb; 4063 4064 if (b->drain_on_flush) { 4065 b->in_flush = true; 4066 cb = bench_cb; 4067 } else { 4068 cb = bench_undrained_flush_cb; 4069 } 4070 4071 acb = blk_aio_flush(b->blk, cb, b); 4072 if (!acb) { 4073 error_report("Failed to issue flush request"); 4074 exit(EXIT_FAILURE); 4075 } 4076 } 4077 if (b->drain_on_flush) { 4078 return; 4079 } 4080 } 4081 } 4082 4083 while (b->n > b->in_flight && b->in_flight < b->nrreq) { 4084 int64_t offset = b->offset; 4085 /* blk_aio_* might look for completed I/Os and kick bench_cb 4086 * again, so make sure this operation is counted by in_flight 4087 * and b->offset is ready for the next submission. 4088 */ 4089 b->in_flight++; 4090 b->offset += b->step; 4091 b->offset %= b->image_size; 4092 if (b->write) { 4093 acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b); 4094 } else { 4095 acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b); 4096 } 4097 if (!acb) { 4098 error_report("Failed to issue request"); 4099 exit(EXIT_FAILURE); 4100 } 4101 } 4102 } 4103 4104 static int img_bench(int argc, char **argv) 4105 { 4106 int c, ret = 0; 4107 const char *fmt = NULL, *filename; 4108 bool quiet = false; 4109 bool image_opts = false; 4110 bool is_write = false; 4111 int count = 75000; 4112 int depth = 64; 4113 int64_t offset = 0; 4114 size_t bufsize = 4096; 4115 int pattern = 0; 4116 size_t step = 0; 4117 int flush_interval = 0; 4118 bool drain_on_flush = true; 4119 int64_t image_size; 4120 BlockBackend *blk = NULL; 4121 BenchData data = {}; 4122 int flags = 0; 4123 bool writethrough = false; 4124 struct timeval t1, t2; 4125 int i; 4126 bool force_share = false; 4127 size_t buf_size; 4128 4129 for (;;) { 4130 static const struct option long_options[] = { 4131 {"help", no_argument, 0, 'h'}, 4132 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL}, 4133 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4134 {"pattern", required_argument, 0, OPTION_PATTERN}, 4135 {"no-drain", no_argument, 0, OPTION_NO_DRAIN}, 4136 {"force-share", no_argument, 0, 'U'}, 4137 {0, 0, 0, 0} 4138 }; 4139 c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL); 4140 if (c == -1) { 4141 break; 4142 } 4143 4144 switch (c) { 4145 case ':': 4146 missing_argument(argv[optind - 1]); 4147 break; 4148 case '?': 4149 unrecognized_option(argv[optind - 1]); 4150 break; 4151 case 'h': 4152 help(); 4153 break; 4154 case 'c': 4155 { 4156 unsigned long res; 4157 4158 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4159 error_report("Invalid request count specified"); 4160 return 1; 4161 } 4162 count = res; 4163 break; 4164 } 4165 case 'd': 4166 { 4167 unsigned long res; 4168 4169 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4170 error_report("Invalid queue depth specified"); 4171 return 1; 4172 } 4173 depth = res; 4174 break; 4175 } 4176 case 'f': 4177 fmt = optarg; 4178 break; 4179 case 'n': 4180 flags |= BDRV_O_NATIVE_AIO; 4181 break; 4182 case 'o': 4183 { 4184 offset = cvtnum(optarg); 4185 if (offset < 0) { 4186 error_report("Invalid offset specified"); 4187 return 1; 4188 } 4189 break; 4190 } 4191 break; 4192 case 'q': 4193 quiet = true; 4194 break; 4195 case 's': 4196 { 4197 int64_t sval; 4198 4199 sval = cvtnum(optarg); 4200 if (sval < 0 || sval > INT_MAX) { 4201 error_report("Invalid buffer size specified"); 4202 return 1; 4203 } 4204 4205 bufsize = sval; 4206 break; 4207 } 4208 case 'S': 4209 { 4210 int64_t sval; 4211 4212 sval = cvtnum(optarg); 4213 if (sval < 0 || sval > INT_MAX) { 4214 error_report("Invalid step size specified"); 4215 return 1; 4216 } 4217 4218 step = sval; 4219 break; 4220 } 4221 case 't': 4222 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough); 4223 if (ret < 0) { 4224 error_report("Invalid cache mode"); 4225 ret = -1; 4226 goto out; 4227 } 4228 break; 4229 case 'w': 4230 flags |= BDRV_O_RDWR; 4231 is_write = true; 4232 break; 4233 case 'U': 4234 force_share = true; 4235 break; 4236 case OPTION_PATTERN: 4237 { 4238 unsigned long res; 4239 4240 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) { 4241 error_report("Invalid pattern byte specified"); 4242 return 1; 4243 } 4244 pattern = res; 4245 break; 4246 } 4247 case OPTION_FLUSH_INTERVAL: 4248 { 4249 unsigned long res; 4250 4251 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) { 4252 error_report("Invalid flush interval specified"); 4253 return 1; 4254 } 4255 flush_interval = res; 4256 break; 4257 } 4258 case OPTION_NO_DRAIN: 4259 drain_on_flush = false; 4260 break; 4261 case OPTION_IMAGE_OPTS: 4262 image_opts = true; 4263 break; 4264 } 4265 } 4266 4267 if (optind != argc - 1) { 4268 error_exit("Expecting one image file name"); 4269 } 4270 filename = argv[argc - 1]; 4271 4272 if (!is_write && flush_interval) { 4273 error_report("--flush-interval is only available in write tests"); 4274 ret = -1; 4275 goto out; 4276 } 4277 if (flush_interval && flush_interval < depth) { 4278 error_report("Flush interval can't be smaller than depth"); 4279 ret = -1; 4280 goto out; 4281 } 4282 4283 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet, 4284 force_share); 4285 if (!blk) { 4286 ret = -1; 4287 goto out; 4288 } 4289 4290 image_size = blk_getlength(blk); 4291 if (image_size < 0) { 4292 ret = image_size; 4293 goto out; 4294 } 4295 4296 data = (BenchData) { 4297 .blk = blk, 4298 .image_size = image_size, 4299 .bufsize = bufsize, 4300 .step = step ?: bufsize, 4301 .nrreq = depth, 4302 .n = count, 4303 .offset = offset, 4304 .write = is_write, 4305 .flush_interval = flush_interval, 4306 .drain_on_flush = drain_on_flush, 4307 }; 4308 printf("Sending %d %s requests, %d bytes each, %d in parallel " 4309 "(starting at offset %" PRId64 ", step size %d)\n", 4310 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq, 4311 data.offset, data.step); 4312 if (flush_interval) { 4313 printf("Sending flush every %d requests\n", flush_interval); 4314 } 4315 4316 buf_size = data.nrreq * data.bufsize; 4317 data.buf = blk_blockalign(blk, buf_size); 4318 memset(data.buf, pattern, data.nrreq * data.bufsize); 4319 4320 blk_register_buf(blk, data.buf, buf_size); 4321 4322 data.qiov = g_new(QEMUIOVector, data.nrreq); 4323 for (i = 0; i < data.nrreq; i++) { 4324 qemu_iovec_init(&data.qiov[i], 1); 4325 qemu_iovec_add(&data.qiov[i], 4326 data.buf + i * data.bufsize, data.bufsize); 4327 } 4328 4329 gettimeofday(&t1, NULL); 4330 bench_cb(&data, 0); 4331 4332 while (data.n > 0) { 4333 main_loop_wait(false); 4334 } 4335 gettimeofday(&t2, NULL); 4336 4337 printf("Run completed in %3.3f seconds.\n", 4338 (t2.tv_sec - t1.tv_sec) 4339 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000)); 4340 4341 out: 4342 if (data.buf) { 4343 blk_unregister_buf(blk, data.buf); 4344 } 4345 qemu_vfree(data.buf); 4346 blk_unref(blk); 4347 4348 if (ret) { 4349 return 1; 4350 } 4351 return 0; 4352 } 4353 4354 #define C_BS 01 4355 #define C_COUNT 02 4356 #define C_IF 04 4357 #define C_OF 010 4358 #define C_SKIP 020 4359 4360 struct DdInfo { 4361 unsigned int flags; 4362 int64_t count; 4363 }; 4364 4365 struct DdIo { 4366 int bsz; /* Block size */ 4367 char *filename; 4368 uint8_t *buf; 4369 int64_t offset; 4370 }; 4371 4372 struct DdOpts { 4373 const char *name; 4374 int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *); 4375 unsigned int flag; 4376 }; 4377 4378 static int img_dd_bs(const char *arg, 4379 struct DdIo *in, struct DdIo *out, 4380 struct DdInfo *dd) 4381 { 4382 int64_t res; 4383 4384 res = cvtnum(arg); 4385 4386 if (res <= 0 || res > INT_MAX) { 4387 error_report("invalid number: '%s'", arg); 4388 return 1; 4389 } 4390 in->bsz = out->bsz = res; 4391 4392 return 0; 4393 } 4394 4395 static int img_dd_count(const char *arg, 4396 struct DdIo *in, struct DdIo *out, 4397 struct DdInfo *dd) 4398 { 4399 dd->count = cvtnum(arg); 4400 4401 if (dd->count < 0) { 4402 error_report("invalid number: '%s'", arg); 4403 return 1; 4404 } 4405 4406 return 0; 4407 } 4408 4409 static int img_dd_if(const char *arg, 4410 struct DdIo *in, struct DdIo *out, 4411 struct DdInfo *dd) 4412 { 4413 in->filename = g_strdup(arg); 4414 4415 return 0; 4416 } 4417 4418 static int img_dd_of(const char *arg, 4419 struct DdIo *in, struct DdIo *out, 4420 struct DdInfo *dd) 4421 { 4422 out->filename = g_strdup(arg); 4423 4424 return 0; 4425 } 4426 4427 static int img_dd_skip(const char *arg, 4428 struct DdIo *in, struct DdIo *out, 4429 struct DdInfo *dd) 4430 { 4431 in->offset = cvtnum(arg); 4432 4433 if (in->offset < 0) { 4434 error_report("invalid number: '%s'", arg); 4435 return 1; 4436 } 4437 4438 return 0; 4439 } 4440 4441 static int img_dd(int argc, char **argv) 4442 { 4443 int ret = 0; 4444 char *arg = NULL; 4445 char *tmp; 4446 BlockDriver *drv = NULL, *proto_drv = NULL; 4447 BlockBackend *blk1 = NULL, *blk2 = NULL; 4448 QemuOpts *opts = NULL; 4449 QemuOptsList *create_opts = NULL; 4450 Error *local_err = NULL; 4451 bool image_opts = false; 4452 int c, i; 4453 const char *out_fmt = "raw"; 4454 const char *fmt = NULL; 4455 int64_t size = 0; 4456 int64_t block_count = 0, out_pos, in_pos; 4457 bool force_share = false; 4458 struct DdInfo dd = { 4459 .flags = 0, 4460 .count = 0, 4461 }; 4462 struct DdIo in = { 4463 .bsz = 512, /* Block size is by default 512 bytes */ 4464 .filename = NULL, 4465 .buf = NULL, 4466 .offset = 0 4467 }; 4468 struct DdIo out = { 4469 .bsz = 512, 4470 .filename = NULL, 4471 .buf = NULL, 4472 .offset = 0 4473 }; 4474 4475 const struct DdOpts options[] = { 4476 { "bs", img_dd_bs, C_BS }, 4477 { "count", img_dd_count, C_COUNT }, 4478 { "if", img_dd_if, C_IF }, 4479 { "of", img_dd_of, C_OF }, 4480 { "skip", img_dd_skip, C_SKIP }, 4481 { NULL, NULL, 0 } 4482 }; 4483 const struct option long_options[] = { 4484 { "help", no_argument, 0, 'h'}, 4485 { "object", required_argument, 0, OPTION_OBJECT}, 4486 { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4487 { "force-share", no_argument, 0, 'U'}, 4488 { 0, 0, 0, 0 } 4489 }; 4490 4491 while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) { 4492 if (c == EOF) { 4493 break; 4494 } 4495 switch (c) { 4496 case 'O': 4497 out_fmt = optarg; 4498 break; 4499 case 'f': 4500 fmt = optarg; 4501 break; 4502 case ':': 4503 missing_argument(argv[optind - 1]); 4504 break; 4505 case '?': 4506 unrecognized_option(argv[optind - 1]); 4507 break; 4508 case 'h': 4509 help(); 4510 break; 4511 case 'U': 4512 force_share = true; 4513 break; 4514 case OPTION_OBJECT: 4515 if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) { 4516 ret = -1; 4517 goto out; 4518 } 4519 break; 4520 case OPTION_IMAGE_OPTS: 4521 image_opts = true; 4522 break; 4523 } 4524 } 4525 4526 for (i = optind; i < argc; i++) { 4527 int j; 4528 arg = g_strdup(argv[i]); 4529 4530 tmp = strchr(arg, '='); 4531 if (tmp == NULL) { 4532 error_report("unrecognized operand %s", arg); 4533 ret = -1; 4534 goto out; 4535 } 4536 4537 *tmp++ = '\0'; 4538 4539 for (j = 0; options[j].name != NULL; j++) { 4540 if (!strcmp(arg, options[j].name)) { 4541 break; 4542 } 4543 } 4544 if (options[j].name == NULL) { 4545 error_report("unrecognized operand %s", arg); 4546 ret = -1; 4547 goto out; 4548 } 4549 4550 if (options[j].f(tmp, &in, &out, &dd) != 0) { 4551 ret = -1; 4552 goto out; 4553 } 4554 dd.flags |= options[j].flag; 4555 g_free(arg); 4556 arg = NULL; 4557 } 4558 4559 if (!(dd.flags & C_IF && dd.flags & C_OF)) { 4560 error_report("Must specify both input and output files"); 4561 ret = -1; 4562 goto out; 4563 } 4564 4565 if (qemu_opts_foreach(&qemu_object_opts, 4566 user_creatable_add_opts_foreach, 4567 NULL, &error_fatal)) { 4568 ret = -1; 4569 goto out; 4570 } 4571 4572 blk1 = img_open(image_opts, in.filename, fmt, 0, false, false, 4573 force_share); 4574 4575 if (!blk1) { 4576 ret = -1; 4577 goto out; 4578 } 4579 4580 drv = bdrv_find_format(out_fmt); 4581 if (!drv) { 4582 error_report("Unknown file format"); 4583 ret = -1; 4584 goto out; 4585 } 4586 proto_drv = bdrv_find_protocol(out.filename, true, &local_err); 4587 4588 if (!proto_drv) { 4589 error_report_err(local_err); 4590 ret = -1; 4591 goto out; 4592 } 4593 if (!drv->create_opts) { 4594 error_report("Format driver '%s' does not support image creation", 4595 drv->format_name); 4596 ret = -1; 4597 goto out; 4598 } 4599 if (!proto_drv->create_opts) { 4600 error_report("Protocol driver '%s' does not support image creation", 4601 proto_drv->format_name); 4602 ret = -1; 4603 goto out; 4604 } 4605 create_opts = qemu_opts_append(create_opts, drv->create_opts); 4606 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 4607 4608 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 4609 4610 size = blk_getlength(blk1); 4611 if (size < 0) { 4612 error_report("Failed to get size for '%s'", in.filename); 4613 ret = -1; 4614 goto out; 4615 } 4616 4617 if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz && 4618 dd.count * in.bsz < size) { 4619 size = dd.count * in.bsz; 4620 } 4621 4622 /* Overflow means the specified offset is beyond input image's size */ 4623 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz || 4624 size < in.bsz * in.offset)) { 4625 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort); 4626 } else { 4627 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 4628 size - in.bsz * in.offset, &error_abort); 4629 } 4630 4631 ret = bdrv_create(drv, out.filename, opts, &local_err); 4632 if (ret < 0) { 4633 error_reportf_err(local_err, 4634 "%s: error while creating output image: ", 4635 out.filename); 4636 ret = -1; 4637 goto out; 4638 } 4639 4640 /* TODO, we can't honour --image-opts for the target, 4641 * since it needs to be given in a format compatible 4642 * with the bdrv_create() call above which does not 4643 * support image-opts style. 4644 */ 4645 blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR, 4646 false, false, false); 4647 4648 if (!blk2) { 4649 ret = -1; 4650 goto out; 4651 } 4652 4653 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz || 4654 size < in.offset * in.bsz)) { 4655 /* We give a warning if the skip option is bigger than the input 4656 * size and create an empty output disk image (i.e. like dd(1)). 4657 */ 4658 error_report("%s: cannot skip to specified offset", in.filename); 4659 in_pos = size; 4660 } else { 4661 in_pos = in.offset * in.bsz; 4662 } 4663 4664 in.buf = g_new(uint8_t, in.bsz); 4665 4666 for (out_pos = 0; in_pos < size; block_count++) { 4667 int in_ret, out_ret; 4668 4669 if (in_pos + in.bsz > size) { 4670 in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos); 4671 } else { 4672 in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz); 4673 } 4674 if (in_ret < 0) { 4675 error_report("error while reading from input image file: %s", 4676 strerror(-in_ret)); 4677 ret = -1; 4678 goto out; 4679 } 4680 in_pos += in_ret; 4681 4682 out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0); 4683 4684 if (out_ret < 0) { 4685 error_report("error while writing to output image file: %s", 4686 strerror(-out_ret)); 4687 ret = -1; 4688 goto out; 4689 } 4690 out_pos += out_ret; 4691 } 4692 4693 out: 4694 g_free(arg); 4695 qemu_opts_del(opts); 4696 qemu_opts_free(create_opts); 4697 blk_unref(blk1); 4698 blk_unref(blk2); 4699 g_free(in.filename); 4700 g_free(out.filename); 4701 g_free(in.buf); 4702 g_free(out.buf); 4703 4704 if (ret) { 4705 return 1; 4706 } 4707 return 0; 4708 } 4709 4710 static void dump_json_block_measure_info(BlockMeasureInfo *info) 4711 { 4712 QString *str; 4713 QObject *obj; 4714 Visitor *v = qobject_output_visitor_new(&obj); 4715 4716 visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort); 4717 visit_complete(v, &obj); 4718 str = qobject_to_json_pretty(obj); 4719 assert(str != NULL); 4720 printf("%s\n", qstring_get_str(str)); 4721 qobject_unref(obj); 4722 visit_free(v); 4723 qobject_unref(str); 4724 } 4725 4726 static int img_measure(int argc, char **argv) 4727 { 4728 static const struct option long_options[] = { 4729 {"help", no_argument, 0, 'h'}, 4730 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 4731 {"object", required_argument, 0, OPTION_OBJECT}, 4732 {"output", required_argument, 0, OPTION_OUTPUT}, 4733 {"size", required_argument, 0, OPTION_SIZE}, 4734 {"force-share", no_argument, 0, 'U'}, 4735 {0, 0, 0, 0} 4736 }; 4737 OutputFormat output_format = OFORMAT_HUMAN; 4738 BlockBackend *in_blk = NULL; 4739 BlockDriver *drv; 4740 const char *filename = NULL; 4741 const char *fmt = NULL; 4742 const char *out_fmt = "raw"; 4743 char *options = NULL; 4744 char *snapshot_name = NULL; 4745 bool force_share = false; 4746 QemuOpts *opts = NULL; 4747 QemuOpts *object_opts = NULL; 4748 QemuOpts *sn_opts = NULL; 4749 QemuOptsList *create_opts = NULL; 4750 bool image_opts = false; 4751 uint64_t img_size = UINT64_MAX; 4752 BlockMeasureInfo *info = NULL; 4753 Error *local_err = NULL; 4754 int ret = 1; 4755 int c; 4756 4757 while ((c = getopt_long(argc, argv, "hf:O:o:l:U", 4758 long_options, NULL)) != -1) { 4759 switch (c) { 4760 case '?': 4761 case 'h': 4762 help(); 4763 break; 4764 case 'f': 4765 fmt = optarg; 4766 break; 4767 case 'O': 4768 out_fmt = optarg; 4769 break; 4770 case 'o': 4771 if (!is_valid_option_list(optarg)) { 4772 error_report("Invalid option list: %s", optarg); 4773 goto out; 4774 } 4775 if (!options) { 4776 options = g_strdup(optarg); 4777 } else { 4778 char *old_options = options; 4779 options = g_strdup_printf("%s,%s", options, optarg); 4780 g_free(old_options); 4781 } 4782 break; 4783 case 'l': 4784 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) { 4785 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts, 4786 optarg, false); 4787 if (!sn_opts) { 4788 error_report("Failed in parsing snapshot param '%s'", 4789 optarg); 4790 goto out; 4791 } 4792 } else { 4793 snapshot_name = optarg; 4794 } 4795 break; 4796 case 'U': 4797 force_share = true; 4798 break; 4799 case OPTION_OBJECT: 4800 object_opts = qemu_opts_parse_noisily(&qemu_object_opts, 4801 optarg, true); 4802 if (!object_opts) { 4803 goto out; 4804 } 4805 break; 4806 case OPTION_IMAGE_OPTS: 4807 image_opts = true; 4808 break; 4809 case OPTION_OUTPUT: 4810 if (!strcmp(optarg, "json")) { 4811 output_format = OFORMAT_JSON; 4812 } else if (!strcmp(optarg, "human")) { 4813 output_format = OFORMAT_HUMAN; 4814 } else { 4815 error_report("--output must be used with human or json " 4816 "as argument."); 4817 goto out; 4818 } 4819 break; 4820 case OPTION_SIZE: 4821 { 4822 int64_t sval; 4823 4824 sval = cvtnum(optarg); 4825 if (sval < 0) { 4826 if (sval == -ERANGE) { 4827 error_report("Image size must be less than 8 EiB!"); 4828 } else { 4829 error_report("Invalid image size specified! You may use " 4830 "k, M, G, T, P or E suffixes for "); 4831 error_report("kilobytes, megabytes, gigabytes, terabytes, " 4832 "petabytes and exabytes."); 4833 } 4834 goto out; 4835 } 4836 img_size = (uint64_t)sval; 4837 } 4838 break; 4839 } 4840 } 4841 4842 if (qemu_opts_foreach(&qemu_object_opts, 4843 user_creatable_add_opts_foreach, 4844 NULL, &error_fatal)) { 4845 goto out; 4846 } 4847 4848 if (argc - optind > 1) { 4849 error_report("At most one filename argument is allowed."); 4850 goto out; 4851 } else if (argc - optind == 1) { 4852 filename = argv[optind]; 4853 } 4854 4855 if (!filename && 4856 (object_opts || image_opts || fmt || snapshot_name || sn_opts)) { 4857 error_report("--object, --image-opts, -f, and -l " 4858 "require a filename argument."); 4859 goto out; 4860 } 4861 if (filename && img_size != UINT64_MAX) { 4862 error_report("--size N cannot be used together with a filename."); 4863 goto out; 4864 } 4865 if (!filename && img_size == UINT64_MAX) { 4866 error_report("Either --size N or one filename must be specified."); 4867 goto out; 4868 } 4869 4870 if (filename) { 4871 in_blk = img_open(image_opts, filename, fmt, 0, 4872 false, false, force_share); 4873 if (!in_blk) { 4874 goto out; 4875 } 4876 4877 if (sn_opts) { 4878 bdrv_snapshot_load_tmp(blk_bs(in_blk), 4879 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID), 4880 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME), 4881 &local_err); 4882 } else if (snapshot_name != NULL) { 4883 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk), 4884 snapshot_name, &local_err); 4885 } 4886 if (local_err) { 4887 error_reportf_err(local_err, "Failed to load snapshot: "); 4888 goto out; 4889 } 4890 } 4891 4892 drv = bdrv_find_format(out_fmt); 4893 if (!drv) { 4894 error_report("Unknown file format '%s'", out_fmt); 4895 goto out; 4896 } 4897 if (!drv->create_opts) { 4898 error_report("Format driver '%s' does not support image creation", 4899 drv->format_name); 4900 goto out; 4901 } 4902 4903 create_opts = qemu_opts_append(create_opts, drv->create_opts); 4904 create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts); 4905 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 4906 if (options) { 4907 qemu_opts_do_parse(opts, options, NULL, &local_err); 4908 if (local_err) { 4909 error_report_err(local_err); 4910 error_report("Invalid options for file format '%s'", out_fmt); 4911 goto out; 4912 } 4913 } 4914 if (img_size != UINT64_MAX) { 4915 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort); 4916 } 4917 4918 info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err); 4919 if (local_err) { 4920 error_report_err(local_err); 4921 goto out; 4922 } 4923 4924 if (output_format == OFORMAT_HUMAN) { 4925 printf("required size: %" PRIu64 "\n", info->required); 4926 printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated); 4927 } else { 4928 dump_json_block_measure_info(info); 4929 } 4930 4931 ret = 0; 4932 4933 out: 4934 qapi_free_BlockMeasureInfo(info); 4935 qemu_opts_del(object_opts); 4936 qemu_opts_del(opts); 4937 qemu_opts_del(sn_opts); 4938 qemu_opts_free(create_opts); 4939 g_free(options); 4940 blk_unref(in_blk); 4941 return ret; 4942 } 4943 4944 static const img_cmd_t img_cmds[] = { 4945 #define DEF(option, callback, arg_string) \ 4946 { option, callback }, 4947 #include "qemu-img-cmds.h" 4948 #undef DEF 4949 { NULL, NULL, }, 4950 }; 4951 4952 int main(int argc, char **argv) 4953 { 4954 const img_cmd_t *cmd; 4955 const char *cmdname; 4956 Error *local_error = NULL; 4957 char *trace_file = NULL; 4958 int c; 4959 static const struct option long_options[] = { 4960 {"help", no_argument, 0, 'h'}, 4961 {"version", no_argument, 0, 'V'}, 4962 {"trace", required_argument, NULL, 'T'}, 4963 {0, 0, 0, 0} 4964 }; 4965 4966 #ifdef CONFIG_POSIX 4967 signal(SIGPIPE, SIG_IGN); 4968 #endif 4969 4970 error_init(argv[0]); 4971 module_call_init(MODULE_INIT_TRACE); 4972 qemu_init_exec_dir(argv[0]); 4973 4974 if (qemu_init_main_loop(&local_error)) { 4975 error_report_err(local_error); 4976 exit(EXIT_FAILURE); 4977 } 4978 4979 qcrypto_init(&error_fatal); 4980 4981 module_call_init(MODULE_INIT_QOM); 4982 bdrv_init(); 4983 if (argc < 2) { 4984 error_exit("Not enough arguments"); 4985 } 4986 4987 qemu_add_opts(&qemu_object_opts); 4988 qemu_add_opts(&qemu_source_opts); 4989 qemu_add_opts(&qemu_trace_opts); 4990 4991 while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) { 4992 switch (c) { 4993 case ':': 4994 missing_argument(argv[optind - 1]); 4995 return 0; 4996 case '?': 4997 unrecognized_option(argv[optind - 1]); 4998 return 0; 4999 case 'h': 5000 help(); 5001 return 0; 5002 case 'V': 5003 printf(QEMU_IMG_VERSION); 5004 return 0; 5005 case 'T': 5006 g_free(trace_file); 5007 trace_file = trace_opt_parse(optarg); 5008 break; 5009 } 5010 } 5011 5012 cmdname = argv[optind]; 5013 5014 /* reset getopt_long scanning */ 5015 argc -= optind; 5016 if (argc < 1) { 5017 return 0; 5018 } 5019 argv += optind; 5020 qemu_reset_optind(); 5021 5022 if (!trace_init_backends()) { 5023 exit(1); 5024 } 5025 trace_init_file(trace_file); 5026 qemu_set_log(LOG_TRACE); 5027 5028 /* find the command */ 5029 for (cmd = img_cmds; cmd->name != NULL; cmd++) { 5030 if (!strcmp(cmdname, cmd->name)) { 5031 return cmd->handler(argc, argv); 5032 } 5033 } 5034 5035 /* not found */ 5036 error_exit("Command not found: %s", cmdname); 5037 } 5038