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