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