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