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