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