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