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