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