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