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