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