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