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 QObject *obj; 495 Visitor *v = qmp_output_visitor_new(&obj); 496 497 visit_type_ImageCheck(v, NULL, &check, &error_abort); 498 visit_complete(v, &obj); 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(v); 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 = blk_make_zero(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 2088 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB) 2089 * as maximum. */ 2090 bufsectors = MIN(32768, 2091 MAX(bufsectors, 2092 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS, 2093 out_bs->bl.pdiscard_alignment >> 2094 BDRV_SECTOR_BITS))); 2095 2096 if (skip_create) { 2097 int64_t output_sectors = blk_nb_sectors(out_blk); 2098 if (output_sectors < 0) { 2099 error_report("unable to get output image length: %s", 2100 strerror(-output_sectors)); 2101 ret = -1; 2102 goto out; 2103 } else if (output_sectors < total_sectors) { 2104 error_report("output file is smaller than input file"); 2105 ret = -1; 2106 goto out; 2107 } 2108 } 2109 2110 cluster_sectors = 0; 2111 ret = bdrv_get_info(out_bs, &bdi); 2112 if (ret < 0) { 2113 if (compress) { 2114 error_report("could not get block driver info"); 2115 goto out; 2116 } 2117 } else { 2118 compress = compress || bdi.needs_compressed_writes; 2119 cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE; 2120 } 2121 2122 state = (ImgConvertState) { 2123 .src = blk, 2124 .src_sectors = bs_sectors, 2125 .src_num = bs_n, 2126 .total_sectors = total_sectors, 2127 .target = out_blk, 2128 .compressed = compress, 2129 .target_has_backing = (bool) out_baseimg, 2130 .min_sparse = min_sparse, 2131 .cluster_sectors = cluster_sectors, 2132 .buf_sectors = bufsectors, 2133 }; 2134 ret = convert_do_copy(&state); 2135 2136 out: 2137 if (!ret) { 2138 qemu_progress_print(100, 0); 2139 } 2140 qemu_progress_end(); 2141 qemu_opts_del(opts); 2142 qemu_opts_free(create_opts); 2143 qemu_opts_del(sn_opts); 2144 blk_unref(out_blk); 2145 g_free(bs); 2146 if (blk) { 2147 for (bs_i = 0; bs_i < bs_n; bs_i++) { 2148 blk_unref(blk[bs_i]); 2149 } 2150 g_free(blk); 2151 } 2152 g_free(bs_sectors); 2153 fail_getopt: 2154 g_free(options); 2155 2156 if (ret) { 2157 return 1; 2158 } 2159 return 0; 2160 } 2161 2162 2163 static void dump_snapshots(BlockDriverState *bs) 2164 { 2165 QEMUSnapshotInfo *sn_tab, *sn; 2166 int nb_sns, i; 2167 2168 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 2169 if (nb_sns <= 0) 2170 return; 2171 printf("Snapshot list:\n"); 2172 bdrv_snapshot_dump(fprintf, stdout, NULL); 2173 printf("\n"); 2174 for(i = 0; i < nb_sns; i++) { 2175 sn = &sn_tab[i]; 2176 bdrv_snapshot_dump(fprintf, stdout, sn); 2177 printf("\n"); 2178 } 2179 g_free(sn_tab); 2180 } 2181 2182 static void dump_json_image_info_list(ImageInfoList *list) 2183 { 2184 QString *str; 2185 QObject *obj; 2186 Visitor *v = qmp_output_visitor_new(&obj); 2187 2188 visit_type_ImageInfoList(v, NULL, &list, &error_abort); 2189 visit_complete(v, &obj); 2190 str = qobject_to_json_pretty(obj); 2191 assert(str != NULL); 2192 printf("%s\n", qstring_get_str(str)); 2193 qobject_decref(obj); 2194 visit_free(v); 2195 QDECREF(str); 2196 } 2197 2198 static void dump_json_image_info(ImageInfo *info) 2199 { 2200 QString *str; 2201 QObject *obj; 2202 Visitor *v = qmp_output_visitor_new(&obj); 2203 2204 visit_type_ImageInfo(v, NULL, &info, &error_abort); 2205 visit_complete(v, &obj); 2206 str = qobject_to_json_pretty(obj); 2207 assert(str != NULL); 2208 printf("%s\n", qstring_get_str(str)); 2209 qobject_decref(obj); 2210 visit_free(v); 2211 QDECREF(str); 2212 } 2213 2214 static void dump_human_image_info_list(ImageInfoList *list) 2215 { 2216 ImageInfoList *elem; 2217 bool delim = false; 2218 2219 for (elem = list; elem; elem = elem->next) { 2220 if (delim) { 2221 printf("\n"); 2222 } 2223 delim = true; 2224 2225 bdrv_image_info_dump(fprintf, stdout, elem->value); 2226 } 2227 } 2228 2229 static gboolean str_equal_func(gconstpointer a, gconstpointer b) 2230 { 2231 return strcmp(a, b) == 0; 2232 } 2233 2234 /** 2235 * Open an image file chain and return an ImageInfoList 2236 * 2237 * @filename: topmost image filename 2238 * @fmt: topmost image format (may be NULL to autodetect) 2239 * @chain: true - enumerate entire backing file chain 2240 * false - only topmost image file 2241 * 2242 * Returns a list of ImageInfo objects or NULL if there was an error opening an 2243 * image file. If there was an error a message will have been printed to 2244 * stderr. 2245 */ 2246 static ImageInfoList *collect_image_info_list(bool image_opts, 2247 const char *filename, 2248 const char *fmt, 2249 bool chain) 2250 { 2251 ImageInfoList *head = NULL; 2252 ImageInfoList **last = &head; 2253 GHashTable *filenames; 2254 Error *err = NULL; 2255 2256 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL); 2257 2258 while (filename) { 2259 BlockBackend *blk; 2260 BlockDriverState *bs; 2261 ImageInfo *info; 2262 ImageInfoList *elem; 2263 2264 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) { 2265 error_report("Backing file '%s' creates an infinite loop.", 2266 filename); 2267 goto err; 2268 } 2269 g_hash_table_insert(filenames, (gpointer)filename, NULL); 2270 2271 blk = img_open(image_opts, filename, fmt, 2272 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false); 2273 if (!blk) { 2274 goto err; 2275 } 2276 bs = blk_bs(blk); 2277 2278 bdrv_query_image_info(bs, &info, &err); 2279 if (err) { 2280 error_report_err(err); 2281 blk_unref(blk); 2282 goto err; 2283 } 2284 2285 elem = g_new0(ImageInfoList, 1); 2286 elem->value = info; 2287 *last = elem; 2288 last = &elem->next; 2289 2290 blk_unref(blk); 2291 2292 filename = fmt = NULL; 2293 if (chain) { 2294 if (info->has_full_backing_filename) { 2295 filename = info->full_backing_filename; 2296 } else if (info->has_backing_filename) { 2297 error_report("Could not determine absolute backing filename," 2298 " but backing filename '%s' present", 2299 info->backing_filename); 2300 goto err; 2301 } 2302 if (info->has_backing_filename_format) { 2303 fmt = info->backing_filename_format; 2304 } 2305 } 2306 } 2307 g_hash_table_destroy(filenames); 2308 return head; 2309 2310 err: 2311 qapi_free_ImageInfoList(head); 2312 g_hash_table_destroy(filenames); 2313 return NULL; 2314 } 2315 2316 static int img_info(int argc, char **argv) 2317 { 2318 int c; 2319 OutputFormat output_format = OFORMAT_HUMAN; 2320 bool chain = false; 2321 const char *filename, *fmt, *output; 2322 ImageInfoList *list; 2323 bool image_opts = false; 2324 2325 fmt = NULL; 2326 output = NULL; 2327 for(;;) { 2328 int option_index = 0; 2329 static const struct option long_options[] = { 2330 {"help", no_argument, 0, 'h'}, 2331 {"format", required_argument, 0, 'f'}, 2332 {"output", required_argument, 0, OPTION_OUTPUT}, 2333 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN}, 2334 {"object", required_argument, 0, OPTION_OBJECT}, 2335 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2336 {0, 0, 0, 0} 2337 }; 2338 c = getopt_long(argc, argv, "f:h", 2339 long_options, &option_index); 2340 if (c == -1) { 2341 break; 2342 } 2343 switch(c) { 2344 case '?': 2345 case 'h': 2346 help(); 2347 break; 2348 case 'f': 2349 fmt = optarg; 2350 break; 2351 case OPTION_OUTPUT: 2352 output = optarg; 2353 break; 2354 case OPTION_BACKING_CHAIN: 2355 chain = true; 2356 break; 2357 case OPTION_OBJECT: { 2358 QemuOpts *opts; 2359 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2360 optarg, true); 2361 if (!opts) { 2362 return 1; 2363 } 2364 } break; 2365 case OPTION_IMAGE_OPTS: 2366 image_opts = true; 2367 break; 2368 } 2369 } 2370 if (optind != argc - 1) { 2371 error_exit("Expecting one image file name"); 2372 } 2373 filename = argv[optind++]; 2374 2375 if (output && !strcmp(output, "json")) { 2376 output_format = OFORMAT_JSON; 2377 } else if (output && !strcmp(output, "human")) { 2378 output_format = OFORMAT_HUMAN; 2379 } else if (output) { 2380 error_report("--output must be used with human or json as argument."); 2381 return 1; 2382 } 2383 2384 if (qemu_opts_foreach(&qemu_object_opts, 2385 user_creatable_add_opts_foreach, 2386 NULL, NULL)) { 2387 return 1; 2388 } 2389 2390 list = collect_image_info_list(image_opts, filename, fmt, chain); 2391 if (!list) { 2392 return 1; 2393 } 2394 2395 switch (output_format) { 2396 case OFORMAT_HUMAN: 2397 dump_human_image_info_list(list); 2398 break; 2399 case OFORMAT_JSON: 2400 if (chain) { 2401 dump_json_image_info_list(list); 2402 } else { 2403 dump_json_image_info(list->value); 2404 } 2405 break; 2406 } 2407 2408 qapi_free_ImageInfoList(list); 2409 return 0; 2410 } 2411 2412 static void dump_map_entry(OutputFormat output_format, MapEntry *e, 2413 MapEntry *next) 2414 { 2415 switch (output_format) { 2416 case OFORMAT_HUMAN: 2417 if (e->data && !e->has_offset) { 2418 error_report("File contains external, encrypted or compressed clusters."); 2419 exit(1); 2420 } 2421 if (e->data && !e->zero) { 2422 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n", 2423 e->start, e->length, 2424 e->has_offset ? e->offset : 0, 2425 e->has_filename ? e->filename : ""); 2426 } 2427 /* This format ignores the distinction between 0, ZERO and ZERO|DATA. 2428 * Modify the flags here to allow more coalescing. 2429 */ 2430 if (next && (!next->data || next->zero)) { 2431 next->data = false; 2432 next->zero = true; 2433 } 2434 break; 2435 case OFORMAT_JSON: 2436 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64"," 2437 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s", 2438 (e->start == 0 ? "[" : ",\n"), 2439 e->start, e->length, e->depth, 2440 e->zero ? "true" : "false", 2441 e->data ? "true" : "false"); 2442 if (e->has_offset) { 2443 printf(", \"offset\": %"PRId64"", e->offset); 2444 } 2445 putchar('}'); 2446 2447 if (!next) { 2448 printf("]\n"); 2449 } 2450 break; 2451 } 2452 } 2453 2454 static int get_block_status(BlockDriverState *bs, int64_t sector_num, 2455 int nb_sectors, MapEntry *e) 2456 { 2457 int64_t ret; 2458 int depth; 2459 BlockDriverState *file; 2460 bool has_offset; 2461 2462 /* As an optimization, we could cache the current range of unallocated 2463 * clusters in each file of the chain, and avoid querying the same 2464 * range repeatedly. 2465 */ 2466 2467 depth = 0; 2468 for (;;) { 2469 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors, 2470 &file); 2471 if (ret < 0) { 2472 return ret; 2473 } 2474 assert(nb_sectors); 2475 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) { 2476 break; 2477 } 2478 bs = backing_bs(bs); 2479 if (bs == NULL) { 2480 ret = 0; 2481 break; 2482 } 2483 2484 depth++; 2485 } 2486 2487 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID); 2488 2489 *e = (MapEntry) { 2490 .start = sector_num * BDRV_SECTOR_SIZE, 2491 .length = nb_sectors * BDRV_SECTOR_SIZE, 2492 .data = !!(ret & BDRV_BLOCK_DATA), 2493 .zero = !!(ret & BDRV_BLOCK_ZERO), 2494 .offset = ret & BDRV_BLOCK_OFFSET_MASK, 2495 .has_offset = has_offset, 2496 .depth = depth, 2497 .has_filename = file && has_offset, 2498 .filename = file && has_offset ? file->filename : NULL, 2499 }; 2500 2501 return 0; 2502 } 2503 2504 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next) 2505 { 2506 if (curr->length == 0) { 2507 return false; 2508 } 2509 if (curr->zero != next->zero || 2510 curr->data != next->data || 2511 curr->depth != next->depth || 2512 curr->has_filename != next->has_filename || 2513 curr->has_offset != next->has_offset) { 2514 return false; 2515 } 2516 if (curr->has_filename && strcmp(curr->filename, next->filename)) { 2517 return false; 2518 } 2519 if (curr->has_offset && curr->offset + curr->length != next->offset) { 2520 return false; 2521 } 2522 return true; 2523 } 2524 2525 static int img_map(int argc, char **argv) 2526 { 2527 int c; 2528 OutputFormat output_format = OFORMAT_HUMAN; 2529 BlockBackend *blk; 2530 BlockDriverState *bs; 2531 const char *filename, *fmt, *output; 2532 int64_t length; 2533 MapEntry curr = { .length = 0 }, next; 2534 int ret = 0; 2535 bool image_opts = false; 2536 2537 fmt = NULL; 2538 output = NULL; 2539 for (;;) { 2540 int option_index = 0; 2541 static const struct option long_options[] = { 2542 {"help", no_argument, 0, 'h'}, 2543 {"format", required_argument, 0, 'f'}, 2544 {"output", required_argument, 0, OPTION_OUTPUT}, 2545 {"object", required_argument, 0, OPTION_OBJECT}, 2546 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2547 {0, 0, 0, 0} 2548 }; 2549 c = getopt_long(argc, argv, "f:h", 2550 long_options, &option_index); 2551 if (c == -1) { 2552 break; 2553 } 2554 switch (c) { 2555 case '?': 2556 case 'h': 2557 help(); 2558 break; 2559 case 'f': 2560 fmt = optarg; 2561 break; 2562 case OPTION_OUTPUT: 2563 output = optarg; 2564 break; 2565 case OPTION_OBJECT: { 2566 QemuOpts *opts; 2567 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2568 optarg, true); 2569 if (!opts) { 2570 return 1; 2571 } 2572 } break; 2573 case OPTION_IMAGE_OPTS: 2574 image_opts = true; 2575 break; 2576 } 2577 } 2578 if (optind != argc - 1) { 2579 error_exit("Expecting one image file name"); 2580 } 2581 filename = argv[optind]; 2582 2583 if (output && !strcmp(output, "json")) { 2584 output_format = OFORMAT_JSON; 2585 } else if (output && !strcmp(output, "human")) { 2586 output_format = OFORMAT_HUMAN; 2587 } else if (output) { 2588 error_report("--output must be used with human or json as argument."); 2589 return 1; 2590 } 2591 2592 if (qemu_opts_foreach(&qemu_object_opts, 2593 user_creatable_add_opts_foreach, 2594 NULL, NULL)) { 2595 return 1; 2596 } 2597 2598 blk = img_open(image_opts, filename, fmt, 0, false, false); 2599 if (!blk) { 2600 return 1; 2601 } 2602 bs = blk_bs(blk); 2603 2604 if (output_format == OFORMAT_HUMAN) { 2605 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File"); 2606 } 2607 2608 length = blk_getlength(blk); 2609 while (curr.start + curr.length < length) { 2610 int64_t nsectors_left; 2611 int64_t sector_num; 2612 int n; 2613 2614 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS; 2615 2616 /* Probe up to 1 GiB at a time. */ 2617 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num; 2618 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left); 2619 ret = get_block_status(bs, sector_num, n, &next); 2620 2621 if (ret < 0) { 2622 error_report("Could not read file metadata: %s", strerror(-ret)); 2623 goto out; 2624 } 2625 2626 if (entry_mergeable(&curr, &next)) { 2627 curr.length += next.length; 2628 continue; 2629 } 2630 2631 if (curr.length > 0) { 2632 dump_map_entry(output_format, &curr, &next); 2633 } 2634 curr = next; 2635 } 2636 2637 dump_map_entry(output_format, &curr, NULL); 2638 2639 out: 2640 blk_unref(blk); 2641 return ret < 0; 2642 } 2643 2644 #define SNAPSHOT_LIST 1 2645 #define SNAPSHOT_CREATE 2 2646 #define SNAPSHOT_APPLY 3 2647 #define SNAPSHOT_DELETE 4 2648 2649 static int img_snapshot(int argc, char **argv) 2650 { 2651 BlockBackend *blk; 2652 BlockDriverState *bs; 2653 QEMUSnapshotInfo sn; 2654 char *filename, *snapshot_name = NULL; 2655 int c, ret = 0, bdrv_oflags; 2656 int action = 0; 2657 qemu_timeval tv; 2658 bool quiet = false; 2659 Error *err = NULL; 2660 bool image_opts = false; 2661 2662 bdrv_oflags = BDRV_O_RDWR; 2663 /* Parse commandline parameters */ 2664 for(;;) { 2665 static const struct option long_options[] = { 2666 {"help", no_argument, 0, 'h'}, 2667 {"object", required_argument, 0, OPTION_OBJECT}, 2668 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2669 {0, 0, 0, 0} 2670 }; 2671 c = getopt_long(argc, argv, "la:c:d:hq", 2672 long_options, NULL); 2673 if (c == -1) { 2674 break; 2675 } 2676 switch(c) { 2677 case '?': 2678 case 'h': 2679 help(); 2680 return 0; 2681 case 'l': 2682 if (action) { 2683 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 2684 return 0; 2685 } 2686 action = SNAPSHOT_LIST; 2687 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 2688 break; 2689 case 'a': 2690 if (action) { 2691 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 2692 return 0; 2693 } 2694 action = SNAPSHOT_APPLY; 2695 snapshot_name = optarg; 2696 break; 2697 case 'c': 2698 if (action) { 2699 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 2700 return 0; 2701 } 2702 action = SNAPSHOT_CREATE; 2703 snapshot_name = optarg; 2704 break; 2705 case 'd': 2706 if (action) { 2707 error_exit("Cannot mix '-l', '-a', '-c', '-d'"); 2708 return 0; 2709 } 2710 action = SNAPSHOT_DELETE; 2711 snapshot_name = optarg; 2712 break; 2713 case 'q': 2714 quiet = true; 2715 break; 2716 case OPTION_OBJECT: { 2717 QemuOpts *opts; 2718 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2719 optarg, true); 2720 if (!opts) { 2721 return 1; 2722 } 2723 } break; 2724 case OPTION_IMAGE_OPTS: 2725 image_opts = true; 2726 break; 2727 } 2728 } 2729 2730 if (optind != argc - 1) { 2731 error_exit("Expecting one image file name"); 2732 } 2733 filename = argv[optind++]; 2734 2735 if (qemu_opts_foreach(&qemu_object_opts, 2736 user_creatable_add_opts_foreach, 2737 NULL, NULL)) { 2738 return 1; 2739 } 2740 2741 /* Open the image */ 2742 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet); 2743 if (!blk) { 2744 return 1; 2745 } 2746 bs = blk_bs(blk); 2747 2748 /* Perform the requested action */ 2749 switch(action) { 2750 case SNAPSHOT_LIST: 2751 dump_snapshots(bs); 2752 break; 2753 2754 case SNAPSHOT_CREATE: 2755 memset(&sn, 0, sizeof(sn)); 2756 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 2757 2758 qemu_gettimeofday(&tv); 2759 sn.date_sec = tv.tv_sec; 2760 sn.date_nsec = tv.tv_usec * 1000; 2761 2762 ret = bdrv_snapshot_create(bs, &sn); 2763 if (ret) { 2764 error_report("Could not create snapshot '%s': %d (%s)", 2765 snapshot_name, ret, strerror(-ret)); 2766 } 2767 break; 2768 2769 case SNAPSHOT_APPLY: 2770 ret = bdrv_snapshot_goto(bs, snapshot_name); 2771 if (ret) { 2772 error_report("Could not apply snapshot '%s': %d (%s)", 2773 snapshot_name, ret, strerror(-ret)); 2774 } 2775 break; 2776 2777 case SNAPSHOT_DELETE: 2778 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err); 2779 if (err) { 2780 error_reportf_err(err, "Could not delete snapshot '%s': ", 2781 snapshot_name); 2782 ret = 1; 2783 } 2784 break; 2785 } 2786 2787 /* Cleanup */ 2788 blk_unref(blk); 2789 if (ret) { 2790 return 1; 2791 } 2792 return 0; 2793 } 2794 2795 static int img_rebase(int argc, char **argv) 2796 { 2797 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL; 2798 uint8_t *buf_old = NULL; 2799 uint8_t *buf_new = NULL; 2800 BlockDriverState *bs = NULL; 2801 char *filename; 2802 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg; 2803 int c, flags, src_flags, ret; 2804 bool writethrough, src_writethrough; 2805 int unsafe = 0; 2806 int progress = 0; 2807 bool quiet = false; 2808 Error *local_err = NULL; 2809 bool image_opts = false; 2810 2811 /* Parse commandline parameters */ 2812 fmt = NULL; 2813 cache = BDRV_DEFAULT_CACHE; 2814 src_cache = BDRV_DEFAULT_CACHE; 2815 out_baseimg = NULL; 2816 out_basefmt = NULL; 2817 for(;;) { 2818 static const struct option long_options[] = { 2819 {"help", no_argument, 0, 'h'}, 2820 {"object", required_argument, 0, OPTION_OBJECT}, 2821 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 2822 {0, 0, 0, 0} 2823 }; 2824 c = getopt_long(argc, argv, "hf:F:b:upt:T:q", 2825 long_options, NULL); 2826 if (c == -1) { 2827 break; 2828 } 2829 switch(c) { 2830 case '?': 2831 case 'h': 2832 help(); 2833 return 0; 2834 case 'f': 2835 fmt = optarg; 2836 break; 2837 case 'F': 2838 out_basefmt = optarg; 2839 break; 2840 case 'b': 2841 out_baseimg = optarg; 2842 break; 2843 case 'u': 2844 unsafe = 1; 2845 break; 2846 case 'p': 2847 progress = 1; 2848 break; 2849 case 't': 2850 cache = optarg; 2851 break; 2852 case 'T': 2853 src_cache = optarg; 2854 break; 2855 case 'q': 2856 quiet = true; 2857 break; 2858 case OPTION_OBJECT: { 2859 QemuOpts *opts; 2860 opts = qemu_opts_parse_noisily(&qemu_object_opts, 2861 optarg, true); 2862 if (!opts) { 2863 return 1; 2864 } 2865 } break; 2866 case OPTION_IMAGE_OPTS: 2867 image_opts = true; 2868 break; 2869 } 2870 } 2871 2872 if (quiet) { 2873 progress = 0; 2874 } 2875 2876 if (optind != argc - 1) { 2877 error_exit("Expecting one image file name"); 2878 } 2879 if (!unsafe && !out_baseimg) { 2880 error_exit("Must specify backing file (-b) or use unsafe mode (-u)"); 2881 } 2882 filename = argv[optind++]; 2883 2884 if (qemu_opts_foreach(&qemu_object_opts, 2885 user_creatable_add_opts_foreach, 2886 NULL, NULL)) { 2887 return 1; 2888 } 2889 2890 qemu_progress_init(progress, 2.0); 2891 qemu_progress_print(0, 100); 2892 2893 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 2894 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 2895 if (ret < 0) { 2896 error_report("Invalid cache option: %s", cache); 2897 goto out; 2898 } 2899 2900 src_flags = 0; 2901 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough); 2902 if (ret < 0) { 2903 error_report("Invalid source cache option: %s", src_cache); 2904 goto out; 2905 } 2906 2907 /* The source files are opened read-only, don't care about WCE */ 2908 assert((src_flags & BDRV_O_RDWR) == 0); 2909 (void) src_writethrough; 2910 2911 /* 2912 * Open the images. 2913 * 2914 * Ignore the old backing file for unsafe rebase in case we want to correct 2915 * the reference to a renamed or moved backing file. 2916 */ 2917 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet); 2918 if (!blk) { 2919 ret = -1; 2920 goto out; 2921 } 2922 bs = blk_bs(blk); 2923 2924 if (out_basefmt != NULL) { 2925 if (bdrv_find_format(out_basefmt) == NULL) { 2926 error_report("Invalid format name: '%s'", out_basefmt); 2927 ret = -1; 2928 goto out; 2929 } 2930 } 2931 2932 /* For safe rebasing we need to compare old and new backing file */ 2933 if (!unsafe) { 2934 char backing_name[PATH_MAX]; 2935 QDict *options = NULL; 2936 2937 if (bs->backing_format[0] != '\0') { 2938 options = qdict_new(); 2939 qdict_put(options, "driver", qstring_from_str(bs->backing_format)); 2940 } 2941 2942 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 2943 blk_old_backing = blk_new_open(backing_name, NULL, 2944 options, src_flags, &local_err); 2945 if (!blk_old_backing) { 2946 error_reportf_err(local_err, 2947 "Could not open old backing file '%s': ", 2948 backing_name); 2949 goto out; 2950 } 2951 2952 if (out_baseimg[0]) { 2953 if (out_basefmt) { 2954 options = qdict_new(); 2955 qdict_put(options, "driver", qstring_from_str(out_basefmt)); 2956 } else { 2957 options = NULL; 2958 } 2959 2960 blk_new_backing = blk_new_open(out_baseimg, NULL, 2961 options, src_flags, &local_err); 2962 if (!blk_new_backing) { 2963 error_reportf_err(local_err, 2964 "Could not open new backing file '%s': ", 2965 out_baseimg); 2966 goto out; 2967 } 2968 } 2969 } 2970 2971 /* 2972 * Check each unallocated cluster in the COW file. If it is unallocated, 2973 * accesses go to the backing file. We must therefore compare this cluster 2974 * in the old and new backing file, and if they differ we need to copy it 2975 * from the old backing file into the COW file. 2976 * 2977 * If qemu-img crashes during this step, no harm is done. The content of 2978 * the image is the same as the original one at any time. 2979 */ 2980 if (!unsafe) { 2981 int64_t num_sectors; 2982 int64_t old_backing_num_sectors; 2983 int64_t new_backing_num_sectors = 0; 2984 uint64_t sector; 2985 int n; 2986 float local_progress = 0; 2987 2988 buf_old = blk_blockalign(blk, IO_BUF_SIZE); 2989 buf_new = blk_blockalign(blk, IO_BUF_SIZE); 2990 2991 num_sectors = blk_nb_sectors(blk); 2992 if (num_sectors < 0) { 2993 error_report("Could not get size of '%s': %s", 2994 filename, strerror(-num_sectors)); 2995 ret = -1; 2996 goto out; 2997 } 2998 old_backing_num_sectors = blk_nb_sectors(blk_old_backing); 2999 if (old_backing_num_sectors < 0) { 3000 char backing_name[PATH_MAX]; 3001 3002 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 3003 error_report("Could not get size of '%s': %s", 3004 backing_name, strerror(-old_backing_num_sectors)); 3005 ret = -1; 3006 goto out; 3007 } 3008 if (blk_new_backing) { 3009 new_backing_num_sectors = blk_nb_sectors(blk_new_backing); 3010 if (new_backing_num_sectors < 0) { 3011 error_report("Could not get size of '%s': %s", 3012 out_baseimg, strerror(-new_backing_num_sectors)); 3013 ret = -1; 3014 goto out; 3015 } 3016 } 3017 3018 if (num_sectors != 0) { 3019 local_progress = (float)100 / 3020 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512)); 3021 } 3022 3023 for (sector = 0; sector < num_sectors; sector += n) { 3024 3025 /* How many sectors can we handle with the next read? */ 3026 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 3027 n = (IO_BUF_SIZE / 512); 3028 } else { 3029 n = num_sectors - sector; 3030 } 3031 3032 /* If the cluster is allocated, we don't need to take action */ 3033 ret = bdrv_is_allocated(bs, sector, n, &n); 3034 if (ret < 0) { 3035 error_report("error while reading image metadata: %s", 3036 strerror(-ret)); 3037 goto out; 3038 } 3039 if (ret) { 3040 continue; 3041 } 3042 3043 /* 3044 * Read old and new backing file and take into consideration that 3045 * backing files may be smaller than the COW image. 3046 */ 3047 if (sector >= old_backing_num_sectors) { 3048 memset(buf_old, 0, n * BDRV_SECTOR_SIZE); 3049 } else { 3050 if (sector + n > old_backing_num_sectors) { 3051 n = old_backing_num_sectors - sector; 3052 } 3053 3054 ret = blk_pread(blk_old_backing, sector << BDRV_SECTOR_BITS, 3055 buf_old, n << BDRV_SECTOR_BITS); 3056 if (ret < 0) { 3057 error_report("error while reading from old backing file"); 3058 goto out; 3059 } 3060 } 3061 3062 if (sector >= new_backing_num_sectors || !blk_new_backing) { 3063 memset(buf_new, 0, n * BDRV_SECTOR_SIZE); 3064 } else { 3065 if (sector + n > new_backing_num_sectors) { 3066 n = new_backing_num_sectors - sector; 3067 } 3068 3069 ret = blk_pread(blk_new_backing, sector << BDRV_SECTOR_BITS, 3070 buf_new, n << BDRV_SECTOR_BITS); 3071 if (ret < 0) { 3072 error_report("error while reading from new backing file"); 3073 goto out; 3074 } 3075 } 3076 3077 /* If they differ, we need to write to the COW file */ 3078 uint64_t written = 0; 3079 3080 while (written < n) { 3081 int pnum; 3082 3083 if (compare_sectors(buf_old + written * 512, 3084 buf_new + written * 512, n - written, &pnum)) 3085 { 3086 ret = blk_pwrite(blk, 3087 (sector + written) << BDRV_SECTOR_BITS, 3088 buf_old + written * 512, 3089 pnum << BDRV_SECTOR_BITS, 0); 3090 if (ret < 0) { 3091 error_report("Error while writing to COW image: %s", 3092 strerror(-ret)); 3093 goto out; 3094 } 3095 } 3096 3097 written += pnum; 3098 } 3099 qemu_progress_print(local_progress, 100); 3100 } 3101 } 3102 3103 /* 3104 * Change the backing file. All clusters that are different from the old 3105 * backing file are overwritten in the COW file now, so the visible content 3106 * doesn't change when we switch the backing file. 3107 */ 3108 if (out_baseimg && *out_baseimg) { 3109 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 3110 } else { 3111 ret = bdrv_change_backing_file(bs, NULL, NULL); 3112 } 3113 3114 if (ret == -ENOSPC) { 3115 error_report("Could not change the backing file to '%s': No " 3116 "space left in the file header", out_baseimg); 3117 } else if (ret < 0) { 3118 error_report("Could not change the backing file to '%s': %s", 3119 out_baseimg, strerror(-ret)); 3120 } 3121 3122 qemu_progress_print(100, 0); 3123 /* 3124 * TODO At this point it is possible to check if any clusters that are 3125 * allocated in the COW file are the same in the backing file. If so, they 3126 * could be dropped from the COW file. Don't do this before switching the 3127 * backing file, in case of a crash this would lead to corruption. 3128 */ 3129 out: 3130 qemu_progress_end(); 3131 /* Cleanup */ 3132 if (!unsafe) { 3133 blk_unref(blk_old_backing); 3134 blk_unref(blk_new_backing); 3135 } 3136 qemu_vfree(buf_old); 3137 qemu_vfree(buf_new); 3138 3139 blk_unref(blk); 3140 if (ret) { 3141 return 1; 3142 } 3143 return 0; 3144 } 3145 3146 static int img_resize(int argc, char **argv) 3147 { 3148 Error *err = NULL; 3149 int c, ret, relative; 3150 const char *filename, *fmt, *size; 3151 int64_t n, total_size; 3152 bool quiet = false; 3153 BlockBackend *blk = NULL; 3154 QemuOpts *param; 3155 3156 static QemuOptsList resize_options = { 3157 .name = "resize_options", 3158 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head), 3159 .desc = { 3160 { 3161 .name = BLOCK_OPT_SIZE, 3162 .type = QEMU_OPT_SIZE, 3163 .help = "Virtual disk size" 3164 }, { 3165 /* end of list */ 3166 } 3167 }, 3168 }; 3169 bool image_opts = false; 3170 3171 /* Remove size from argv manually so that negative numbers are not treated 3172 * as options by getopt. */ 3173 if (argc < 3) { 3174 error_exit("Not enough arguments"); 3175 return 1; 3176 } 3177 3178 size = argv[--argc]; 3179 3180 /* Parse getopt arguments */ 3181 fmt = NULL; 3182 for(;;) { 3183 static const struct option long_options[] = { 3184 {"help", no_argument, 0, 'h'}, 3185 {"object", required_argument, 0, OPTION_OBJECT}, 3186 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3187 {0, 0, 0, 0} 3188 }; 3189 c = getopt_long(argc, argv, "f:hq", 3190 long_options, NULL); 3191 if (c == -1) { 3192 break; 3193 } 3194 switch(c) { 3195 case '?': 3196 case 'h': 3197 help(); 3198 break; 3199 case 'f': 3200 fmt = optarg; 3201 break; 3202 case 'q': 3203 quiet = true; 3204 break; 3205 case OPTION_OBJECT: { 3206 QemuOpts *opts; 3207 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3208 optarg, true); 3209 if (!opts) { 3210 return 1; 3211 } 3212 } break; 3213 case OPTION_IMAGE_OPTS: 3214 image_opts = true; 3215 break; 3216 } 3217 } 3218 if (optind != argc - 1) { 3219 error_exit("Expecting one image file name"); 3220 } 3221 filename = argv[optind++]; 3222 3223 if (qemu_opts_foreach(&qemu_object_opts, 3224 user_creatable_add_opts_foreach, 3225 NULL, NULL)) { 3226 return 1; 3227 } 3228 3229 /* Choose grow, shrink, or absolute resize mode */ 3230 switch (size[0]) { 3231 case '+': 3232 relative = 1; 3233 size++; 3234 break; 3235 case '-': 3236 relative = -1; 3237 size++; 3238 break; 3239 default: 3240 relative = 0; 3241 break; 3242 } 3243 3244 /* Parse size */ 3245 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort); 3246 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err); 3247 if (err) { 3248 error_report_err(err); 3249 ret = -1; 3250 qemu_opts_del(param); 3251 goto out; 3252 } 3253 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); 3254 qemu_opts_del(param); 3255 3256 blk = img_open(image_opts, filename, fmt, 3257 BDRV_O_RDWR, false, quiet); 3258 if (!blk) { 3259 ret = -1; 3260 goto out; 3261 } 3262 3263 if (relative) { 3264 total_size = blk_getlength(blk) + n * relative; 3265 } else { 3266 total_size = n; 3267 } 3268 if (total_size <= 0) { 3269 error_report("New image size must be positive"); 3270 ret = -1; 3271 goto out; 3272 } 3273 3274 ret = blk_truncate(blk, total_size); 3275 switch (ret) { 3276 case 0: 3277 qprintf(quiet, "Image resized.\n"); 3278 break; 3279 case -ENOTSUP: 3280 error_report("This image does not support resize"); 3281 break; 3282 case -EACCES: 3283 error_report("Image is read-only"); 3284 break; 3285 default: 3286 error_report("Error resizing image (%d)", -ret); 3287 break; 3288 } 3289 out: 3290 blk_unref(blk); 3291 if (ret) { 3292 return 1; 3293 } 3294 return 0; 3295 } 3296 3297 static void amend_status_cb(BlockDriverState *bs, 3298 int64_t offset, int64_t total_work_size, 3299 void *opaque) 3300 { 3301 qemu_progress_print(100.f * offset / total_work_size, 0); 3302 } 3303 3304 static int img_amend(int argc, char **argv) 3305 { 3306 Error *err = NULL; 3307 int c, ret = 0; 3308 char *options = NULL; 3309 QemuOptsList *create_opts = NULL; 3310 QemuOpts *opts = NULL; 3311 const char *fmt = NULL, *filename, *cache; 3312 int flags; 3313 bool writethrough; 3314 bool quiet = false, progress = false; 3315 BlockBackend *blk = NULL; 3316 BlockDriverState *bs = NULL; 3317 bool image_opts = false; 3318 3319 cache = BDRV_DEFAULT_CACHE; 3320 for (;;) { 3321 static const struct option long_options[] = { 3322 {"help", no_argument, 0, 'h'}, 3323 {"object", required_argument, 0, OPTION_OBJECT}, 3324 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3325 {0, 0, 0, 0} 3326 }; 3327 c = getopt_long(argc, argv, "ho:f:t:pq", 3328 long_options, NULL); 3329 if (c == -1) { 3330 break; 3331 } 3332 3333 switch (c) { 3334 case 'h': 3335 case '?': 3336 help(); 3337 break; 3338 case 'o': 3339 if (!is_valid_option_list(optarg)) { 3340 error_report("Invalid option list: %s", optarg); 3341 ret = -1; 3342 goto out_no_progress; 3343 } 3344 if (!options) { 3345 options = g_strdup(optarg); 3346 } else { 3347 char *old_options = options; 3348 options = g_strdup_printf("%s,%s", options, optarg); 3349 g_free(old_options); 3350 } 3351 break; 3352 case 'f': 3353 fmt = optarg; 3354 break; 3355 case 't': 3356 cache = optarg; 3357 break; 3358 case 'p': 3359 progress = true; 3360 break; 3361 case 'q': 3362 quiet = true; 3363 break; 3364 case OPTION_OBJECT: 3365 opts = qemu_opts_parse_noisily(&qemu_object_opts, 3366 optarg, true); 3367 if (!opts) { 3368 ret = -1; 3369 goto out_no_progress; 3370 } 3371 break; 3372 case OPTION_IMAGE_OPTS: 3373 image_opts = true; 3374 break; 3375 } 3376 } 3377 3378 if (!options) { 3379 error_exit("Must specify options (-o)"); 3380 } 3381 3382 if (qemu_opts_foreach(&qemu_object_opts, 3383 user_creatable_add_opts_foreach, 3384 NULL, NULL)) { 3385 ret = -1; 3386 goto out_no_progress; 3387 } 3388 3389 if (quiet) { 3390 progress = false; 3391 } 3392 qemu_progress_init(progress, 1.0); 3393 3394 filename = (optind == argc - 1) ? argv[argc - 1] : NULL; 3395 if (fmt && has_help_option(options)) { 3396 /* If a format is explicitly specified (and possibly no filename is 3397 * given), print option help here */ 3398 ret = print_block_option_help(filename, fmt); 3399 goto out; 3400 } 3401 3402 if (optind != argc - 1) { 3403 error_report("Expecting one image file name"); 3404 ret = -1; 3405 goto out; 3406 } 3407 3408 flags = BDRV_O_RDWR; 3409 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough); 3410 if (ret < 0) { 3411 error_report("Invalid cache option: %s", cache); 3412 goto out; 3413 } 3414 3415 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet); 3416 if (!blk) { 3417 ret = -1; 3418 goto out; 3419 } 3420 bs = blk_bs(blk); 3421 3422 fmt = bs->drv->format_name; 3423 3424 if (has_help_option(options)) { 3425 /* If the format was auto-detected, print option help here */ 3426 ret = print_block_option_help(filename, fmt); 3427 goto out; 3428 } 3429 3430 if (!bs->drv->create_opts) { 3431 error_report("Format driver '%s' does not support any options to amend", 3432 fmt); 3433 ret = -1; 3434 goto out; 3435 } 3436 3437 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts); 3438 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 3439 if (options) { 3440 qemu_opts_do_parse(opts, options, NULL, &err); 3441 if (err) { 3442 error_report_err(err); 3443 ret = -1; 3444 goto out; 3445 } 3446 } 3447 3448 /* In case the driver does not call amend_status_cb() */ 3449 qemu_progress_print(0.f, 0); 3450 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL); 3451 qemu_progress_print(100.f, 0); 3452 if (ret < 0) { 3453 error_report("Error while amending options: %s", strerror(-ret)); 3454 goto out; 3455 } 3456 3457 out: 3458 qemu_progress_end(); 3459 3460 out_no_progress: 3461 blk_unref(blk); 3462 qemu_opts_del(opts); 3463 qemu_opts_free(create_opts); 3464 g_free(options); 3465 3466 if (ret) { 3467 return 1; 3468 } 3469 return 0; 3470 } 3471 3472 typedef struct BenchData { 3473 BlockBackend *blk; 3474 uint64_t image_size; 3475 bool write; 3476 int bufsize; 3477 int step; 3478 int nrreq; 3479 int n; 3480 int flush_interval; 3481 bool drain_on_flush; 3482 uint8_t *buf; 3483 QEMUIOVector *qiov; 3484 3485 int in_flight; 3486 bool in_flush; 3487 uint64_t offset; 3488 } BenchData; 3489 3490 static void bench_undrained_flush_cb(void *opaque, int ret) 3491 { 3492 if (ret < 0) { 3493 error_report("Failed flush request: %s\n", strerror(-ret)); 3494 exit(EXIT_FAILURE); 3495 } 3496 } 3497 3498 static void bench_cb(void *opaque, int ret) 3499 { 3500 BenchData *b = opaque; 3501 BlockAIOCB *acb; 3502 3503 if (ret < 0) { 3504 error_report("Failed request: %s\n", strerror(-ret)); 3505 exit(EXIT_FAILURE); 3506 } 3507 3508 if (b->in_flush) { 3509 /* Just finished a flush with drained queue: Start next requests */ 3510 assert(b->in_flight == 0); 3511 b->in_flush = false; 3512 } else if (b->in_flight > 0) { 3513 int remaining = b->n - b->in_flight; 3514 3515 b->n--; 3516 b->in_flight--; 3517 3518 /* Time for flush? Drain queue if requested, then flush */ 3519 if (b->flush_interval && remaining % b->flush_interval == 0) { 3520 if (!b->in_flight || !b->drain_on_flush) { 3521 BlockCompletionFunc *cb; 3522 3523 if (b->drain_on_flush) { 3524 b->in_flush = true; 3525 cb = bench_cb; 3526 } else { 3527 cb = bench_undrained_flush_cb; 3528 } 3529 3530 acb = blk_aio_flush(b->blk, cb, b); 3531 if (!acb) { 3532 error_report("Failed to issue flush request"); 3533 exit(EXIT_FAILURE); 3534 } 3535 } 3536 if (b->drain_on_flush) { 3537 return; 3538 } 3539 } 3540 } 3541 3542 while (b->n > b->in_flight && b->in_flight < b->nrreq) { 3543 if (b->write) { 3544 acb = blk_aio_pwritev(b->blk, b->offset, b->qiov, 0, 3545 bench_cb, b); 3546 } else { 3547 acb = blk_aio_preadv(b->blk, b->offset, b->qiov, 0, 3548 bench_cb, b); 3549 } 3550 if (!acb) { 3551 error_report("Failed to issue request"); 3552 exit(EXIT_FAILURE); 3553 } 3554 b->in_flight++; 3555 b->offset += b->step; 3556 b->offset %= b->image_size; 3557 } 3558 } 3559 3560 static int img_bench(int argc, char **argv) 3561 { 3562 int c, ret = 0; 3563 const char *fmt = NULL, *filename; 3564 bool quiet = false; 3565 bool image_opts = false; 3566 bool is_write = false; 3567 int count = 75000; 3568 int depth = 64; 3569 int64_t offset = 0; 3570 size_t bufsize = 4096; 3571 int pattern = 0; 3572 size_t step = 0; 3573 int flush_interval = 0; 3574 bool drain_on_flush = true; 3575 int64_t image_size; 3576 BlockBackend *blk = NULL; 3577 BenchData data = {}; 3578 int flags = 0; 3579 bool writethrough = false; 3580 struct timeval t1, t2; 3581 int i; 3582 3583 for (;;) { 3584 static const struct option long_options[] = { 3585 {"help", no_argument, 0, 'h'}, 3586 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL}, 3587 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, 3588 {"pattern", required_argument, 0, OPTION_PATTERN}, 3589 {"no-drain", no_argument, 0, OPTION_NO_DRAIN}, 3590 {0, 0, 0, 0} 3591 }; 3592 c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL); 3593 if (c == -1) { 3594 break; 3595 } 3596 3597 switch (c) { 3598 case 'h': 3599 case '?': 3600 help(); 3601 break; 3602 case 'c': 3603 { 3604 char *end; 3605 errno = 0; 3606 count = strtoul(optarg, &end, 0); 3607 if (errno || *end || count > INT_MAX) { 3608 error_report("Invalid request count specified"); 3609 return 1; 3610 } 3611 break; 3612 } 3613 case 'd': 3614 { 3615 char *end; 3616 errno = 0; 3617 depth = strtoul(optarg, &end, 0); 3618 if (errno || *end || depth > INT_MAX) { 3619 error_report("Invalid queue depth specified"); 3620 return 1; 3621 } 3622 break; 3623 } 3624 case 'f': 3625 fmt = optarg; 3626 break; 3627 case 'n': 3628 flags |= BDRV_O_NATIVE_AIO; 3629 break; 3630 case 'o': 3631 { 3632 char *end; 3633 errno = 0; 3634 offset = qemu_strtosz_suffix(optarg, &end, 3635 QEMU_STRTOSZ_DEFSUFFIX_B); 3636 if (offset < 0|| *end) { 3637 error_report("Invalid offset specified"); 3638 return 1; 3639 } 3640 break; 3641 } 3642 break; 3643 case 'q': 3644 quiet = true; 3645 break; 3646 case 's': 3647 { 3648 int64_t sval; 3649 char *end; 3650 3651 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B); 3652 if (sval < 0 || sval > INT_MAX || *end) { 3653 error_report("Invalid buffer size specified"); 3654 return 1; 3655 } 3656 3657 bufsize = sval; 3658 break; 3659 } 3660 case 'S': 3661 { 3662 int64_t sval; 3663 char *end; 3664 3665 sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B); 3666 if (sval < 0 || sval > INT_MAX || *end) { 3667 error_report("Invalid step size specified"); 3668 return 1; 3669 } 3670 3671 step = sval; 3672 break; 3673 } 3674 case 't': 3675 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough); 3676 if (ret < 0) { 3677 error_report("Invalid cache mode"); 3678 ret = -1; 3679 goto out; 3680 } 3681 break; 3682 case 'w': 3683 flags |= BDRV_O_RDWR; 3684 is_write = true; 3685 break; 3686 case OPTION_PATTERN: 3687 { 3688 char *end; 3689 errno = 0; 3690 pattern = strtoul(optarg, &end, 0); 3691 if (errno || *end || pattern > 0xff) { 3692 error_report("Invalid pattern byte specified"); 3693 return 1; 3694 } 3695 break; 3696 } 3697 case OPTION_FLUSH_INTERVAL: 3698 { 3699 char *end; 3700 errno = 0; 3701 flush_interval = strtoul(optarg, &end, 0); 3702 if (errno || *end || flush_interval > INT_MAX) { 3703 error_report("Invalid flush interval specified"); 3704 return 1; 3705 } 3706 break; 3707 } 3708 case OPTION_NO_DRAIN: 3709 drain_on_flush = false; 3710 break; 3711 case OPTION_IMAGE_OPTS: 3712 image_opts = true; 3713 break; 3714 } 3715 } 3716 3717 if (optind != argc - 1) { 3718 error_exit("Expecting one image file name"); 3719 } 3720 filename = argv[argc - 1]; 3721 3722 if (!is_write && flush_interval) { 3723 error_report("--flush-interval is only available in write tests"); 3724 ret = -1; 3725 goto out; 3726 } 3727 if (flush_interval && flush_interval < depth) { 3728 error_report("Flush interval can't be smaller than depth"); 3729 ret = -1; 3730 goto out; 3731 } 3732 3733 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet); 3734 if (!blk) { 3735 ret = -1; 3736 goto out; 3737 } 3738 3739 image_size = blk_getlength(blk); 3740 if (image_size < 0) { 3741 ret = image_size; 3742 goto out; 3743 } 3744 3745 data = (BenchData) { 3746 .blk = blk, 3747 .image_size = image_size, 3748 .bufsize = bufsize, 3749 .step = step ?: bufsize, 3750 .nrreq = depth, 3751 .n = count, 3752 .offset = offset, 3753 .write = is_write, 3754 .flush_interval = flush_interval, 3755 .drain_on_flush = drain_on_flush, 3756 }; 3757 printf("Sending %d %s requests, %d bytes each, %d in parallel " 3758 "(starting at offset %" PRId64 ", step size %d)\n", 3759 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq, 3760 data.offset, data.step); 3761 if (flush_interval) { 3762 printf("Sending flush every %d requests\n", flush_interval); 3763 } 3764 3765 data.buf = blk_blockalign(blk, data.nrreq * data.bufsize); 3766 memset(data.buf, pattern, data.nrreq * data.bufsize); 3767 3768 data.qiov = g_new(QEMUIOVector, data.nrreq); 3769 for (i = 0; i < data.nrreq; i++) { 3770 qemu_iovec_init(&data.qiov[i], 1); 3771 qemu_iovec_add(&data.qiov[i], 3772 data.buf + i * data.bufsize, data.bufsize); 3773 } 3774 3775 gettimeofday(&t1, NULL); 3776 bench_cb(&data, 0); 3777 3778 while (data.n > 0) { 3779 main_loop_wait(false); 3780 } 3781 gettimeofday(&t2, NULL); 3782 3783 printf("Run completed in %3.3f seconds.\n", 3784 (t2.tv_sec - t1.tv_sec) 3785 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000)); 3786 3787 out: 3788 qemu_vfree(data.buf); 3789 blk_unref(blk); 3790 3791 if (ret) { 3792 return 1; 3793 } 3794 return 0; 3795 } 3796 3797 3798 static const img_cmd_t img_cmds[] = { 3799 #define DEF(option, callback, arg_string) \ 3800 { option, callback }, 3801 #include "qemu-img-cmds.h" 3802 #undef DEF 3803 #undef GEN_DOCS 3804 { NULL, NULL, }, 3805 }; 3806 3807 int main(int argc, char **argv) 3808 { 3809 const img_cmd_t *cmd; 3810 const char *cmdname; 3811 Error *local_error = NULL; 3812 char *trace_file = NULL; 3813 int c; 3814 static const struct option long_options[] = { 3815 {"help", no_argument, 0, 'h'}, 3816 {"version", no_argument, 0, 'V'}, 3817 {"trace", required_argument, NULL, 'T'}, 3818 {0, 0, 0, 0} 3819 }; 3820 3821 #ifdef CONFIG_POSIX 3822 signal(SIGPIPE, SIG_IGN); 3823 #endif 3824 3825 error_set_progname(argv[0]); 3826 qemu_init_exec_dir(argv[0]); 3827 3828 if (qemu_init_main_loop(&local_error)) { 3829 error_report_err(local_error); 3830 exit(EXIT_FAILURE); 3831 } 3832 3833 qcrypto_init(&error_fatal); 3834 3835 module_call_init(MODULE_INIT_QOM); 3836 bdrv_init(); 3837 if (argc < 2) { 3838 error_exit("Not enough arguments"); 3839 } 3840 3841 qemu_add_opts(&qemu_object_opts); 3842 qemu_add_opts(&qemu_source_opts); 3843 qemu_add_opts(&qemu_trace_opts); 3844 3845 while ((c = getopt_long(argc, argv, "+hVT:", long_options, NULL)) != -1) { 3846 switch (c) { 3847 case 'h': 3848 help(); 3849 return 0; 3850 case 'V': 3851 printf(QEMU_IMG_VERSION); 3852 return 0; 3853 case 'T': 3854 g_free(trace_file); 3855 trace_file = trace_opt_parse(optarg); 3856 break; 3857 } 3858 } 3859 3860 cmdname = argv[optind]; 3861 3862 /* reset getopt_long scanning */ 3863 argc -= optind; 3864 if (argc < 1) { 3865 return 0; 3866 } 3867 argv += optind; 3868 optind = 0; 3869 3870 if (!trace_init_backends()) { 3871 exit(1); 3872 } 3873 trace_init_file(trace_file); 3874 qemu_set_log(LOG_TRACE); 3875 3876 /* find the command */ 3877 for (cmd = img_cmds; cmd->name != NULL; cmd++) { 3878 if (!strcmp(cmdname, cmd->name)) { 3879 return cmd->handler(argc, argv); 3880 } 3881 } 3882 3883 /* not found */ 3884 error_exit("Command not found: %s", cmdname); 3885 } 3886