1 /* 2 * QEMU disk image utility 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu-common.h" 25 #include "qemu-option.h" 26 #include "qemu-error.h" 27 #include "osdep.h" 28 #include "sysemu.h" 29 #include "block_int.h" 30 #include <stdio.h> 31 32 #ifdef _WIN32 33 #include <windows.h> 34 #endif 35 36 typedef struct img_cmd_t { 37 const char *name; 38 int (*handler)(int argc, char **argv); 39 } img_cmd_t; 40 41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */ 42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB 43 #define BDRV_DEFAULT_CACHE "writeback" 44 45 static void format_print(void *opaque, const char *name) 46 { 47 printf(" %s", name); 48 } 49 50 /* Please keep in synch with qemu-img.texi */ 51 static void help(void) 52 { 53 const char *help_msg = 54 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n" 55 "usage: qemu-img command [command options]\n" 56 "QEMU disk image utility\n" 57 "\n" 58 "Command syntax:\n" 59 #define DEF(option, callback, arg_string) \ 60 " " arg_string "\n" 61 #include "qemu-img-cmds.h" 62 #undef DEF 63 #undef GEN_DOCS 64 "\n" 65 "Command parameters:\n" 66 " 'filename' is a disk image filename\n" 67 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 68 " 'cache' is the cache mode used to write the output disk image, the valid\n" 69 " options are: 'none', 'writeback' (default), 'writethrough', 'directsync'\n" 70 " and 'unsafe'\n" 71 " 'size' is the disk image size in bytes. Optional suffixes\n" 72 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n" 73 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n" 74 " 'output_filename' is the destination disk image filename\n" 75 " 'output_fmt' is the destination format\n" 76 " 'options' is a comma separated list of format specific options in a\n" 77 " name=value format. Use -o ? for an overview of the options supported by the\n" 78 " used format\n" 79 " '-c' indicates that target image must be compressed (qcow format only)\n" 80 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n" 81 " match exactly. The image doesn't need a working backing file before\n" 82 " rebasing in this case (useful for renaming the backing file)\n" 83 " '-h' with or without a command shows this help and lists the supported formats\n" 84 " '-p' show progress of command (only certain commands)\n" 85 "\n" 86 "Parameters to snapshot subcommand:\n" 87 " 'snapshot' is the name of the snapshot to create, apply or delete\n" 88 " '-a' applies a snapshot (revert disk to saved state)\n" 89 " '-c' creates a snapshot\n" 90 " '-d' deletes a snapshot\n" 91 " '-l' lists all snapshots in the given image\n"; 92 93 printf("%s\nSupported formats:", help_msg); 94 bdrv_iterate_format(format_print, NULL); 95 printf("\n"); 96 exit(1); 97 } 98 99 #if defined(WIN32) 100 /* XXX: put correct support for win32 */ 101 static int read_password(char *buf, int buf_size) 102 { 103 int c, i; 104 printf("Password: "); 105 fflush(stdout); 106 i = 0; 107 for(;;) { 108 c = getchar(); 109 if (c == '\n') 110 break; 111 if (i < (buf_size - 1)) 112 buf[i++] = c; 113 } 114 buf[i] = '\0'; 115 return 0; 116 } 117 118 #else 119 120 #include <termios.h> 121 122 static struct termios oldtty; 123 124 static void term_exit(void) 125 { 126 tcsetattr (0, TCSANOW, &oldtty); 127 } 128 129 static void term_init(void) 130 { 131 struct termios tty; 132 133 tcgetattr (0, &tty); 134 oldtty = tty; 135 136 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 137 |INLCR|IGNCR|ICRNL|IXON); 138 tty.c_oflag |= OPOST; 139 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 140 tty.c_cflag &= ~(CSIZE|PARENB); 141 tty.c_cflag |= CS8; 142 tty.c_cc[VMIN] = 1; 143 tty.c_cc[VTIME] = 0; 144 145 tcsetattr (0, TCSANOW, &tty); 146 147 atexit(term_exit); 148 } 149 150 static int read_password(char *buf, int buf_size) 151 { 152 uint8_t ch; 153 int i, ret; 154 155 printf("password: "); 156 fflush(stdout); 157 term_init(); 158 i = 0; 159 for(;;) { 160 ret = read(0, &ch, 1); 161 if (ret == -1) { 162 if (errno == EAGAIN || errno == EINTR) { 163 continue; 164 } else { 165 ret = -1; 166 break; 167 } 168 } else if (ret == 0) { 169 ret = -1; 170 break; 171 } else { 172 if (ch == '\r') { 173 ret = 0; 174 break; 175 } 176 if (i < (buf_size - 1)) 177 buf[i++] = ch; 178 } 179 } 180 term_exit(); 181 buf[i] = '\0'; 182 printf("\n"); 183 return ret; 184 } 185 #endif 186 187 static int print_block_option_help(const char *filename, const char *fmt) 188 { 189 BlockDriver *drv, *proto_drv; 190 QEMUOptionParameter *create_options = NULL; 191 192 /* Find driver and parse its options */ 193 drv = bdrv_find_format(fmt); 194 if (!drv) { 195 error_report("Unknown file format '%s'", fmt); 196 return 1; 197 } 198 199 proto_drv = bdrv_find_protocol(filename); 200 if (!proto_drv) { 201 error_report("Unknown protocol '%s'", filename); 202 return 1; 203 } 204 205 create_options = append_option_parameters(create_options, 206 drv->create_options); 207 create_options = append_option_parameters(create_options, 208 proto_drv->create_options); 209 print_option_help(create_options); 210 free_option_parameters(create_options); 211 return 0; 212 } 213 214 static BlockDriverState *bdrv_new_open(const char *filename, 215 const char *fmt, 216 int flags) 217 { 218 BlockDriverState *bs; 219 BlockDriver *drv; 220 char password[256]; 221 int ret; 222 223 bs = bdrv_new("image"); 224 225 if (fmt) { 226 drv = bdrv_find_format(fmt); 227 if (!drv) { 228 error_report("Unknown file format '%s'", fmt); 229 goto fail; 230 } 231 } else { 232 drv = NULL; 233 } 234 235 ret = bdrv_open(bs, filename, flags, drv); 236 if (ret < 0) { 237 error_report("Could not open '%s': %s", filename, strerror(-ret)); 238 goto fail; 239 } 240 241 if (bdrv_is_encrypted(bs)) { 242 printf("Disk image '%s' is encrypted.\n", filename); 243 if (read_password(password, sizeof(password)) < 0) { 244 error_report("No password given"); 245 goto fail; 246 } 247 if (bdrv_set_key(bs, password) < 0) { 248 error_report("invalid password"); 249 goto fail; 250 } 251 } 252 return bs; 253 fail: 254 if (bs) { 255 bdrv_delete(bs); 256 } 257 return NULL; 258 } 259 260 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list, 261 const char *base_filename, 262 const char *base_fmt) 263 { 264 if (base_filename) { 265 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) { 266 error_report("Backing file not supported for file format '%s'", 267 fmt); 268 return -1; 269 } 270 } 271 if (base_fmt) { 272 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) { 273 error_report("Backing file format not supported for file " 274 "format '%s'", fmt); 275 return -1; 276 } 277 } 278 return 0; 279 } 280 281 static int img_create(int argc, char **argv) 282 { 283 int c, ret = 0; 284 uint64_t img_size = -1; 285 const char *fmt = "raw"; 286 const char *base_fmt = NULL; 287 const char *filename; 288 const char *base_filename = NULL; 289 char *options = NULL; 290 291 for(;;) { 292 c = getopt(argc, argv, "F:b:f:he6o:"); 293 if (c == -1) { 294 break; 295 } 296 switch(c) { 297 case '?': 298 case 'h': 299 help(); 300 break; 301 case 'F': 302 base_fmt = optarg; 303 break; 304 case 'b': 305 base_filename = optarg; 306 break; 307 case 'f': 308 fmt = optarg; 309 break; 310 case 'e': 311 error_report("option -e is deprecated, please use \'-o " 312 "encryption\' instead!"); 313 return 1; 314 case '6': 315 error_report("option -6 is deprecated, please use \'-o " 316 "compat6\' instead!"); 317 return 1; 318 case 'o': 319 options = optarg; 320 break; 321 } 322 } 323 324 /* Get the filename */ 325 if (optind >= argc) { 326 help(); 327 } 328 filename = argv[optind++]; 329 330 /* Get image size, if specified */ 331 if (optind < argc) { 332 int64_t sval; 333 sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B); 334 if (sval < 0) { 335 error_report("Invalid image size specified! You may use k, M, G or " 336 "T suffixes for "); 337 error_report("kilobytes, megabytes, gigabytes and terabytes."); 338 ret = -1; 339 goto out; 340 } 341 img_size = (uint64_t)sval; 342 } 343 344 if (options && !strcmp(options, "?")) { 345 ret = print_block_option_help(filename, fmt); 346 goto out; 347 } 348 349 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt, 350 options, img_size, BDRV_O_FLAGS); 351 out: 352 if (ret) { 353 return 1; 354 } 355 return 0; 356 } 357 358 /* 359 * Checks an image for consistency. Exit codes: 360 * 361 * 0 - Check completed, image is good 362 * 1 - Check not completed because of internal errors 363 * 2 - Check completed, image is corrupted 364 * 3 - Check completed, image has leaked clusters, but is good otherwise 365 */ 366 static int img_check(int argc, char **argv) 367 { 368 int c, ret; 369 const char *filename, *fmt; 370 BlockDriverState *bs; 371 BdrvCheckResult result; 372 373 fmt = NULL; 374 for(;;) { 375 c = getopt(argc, argv, "f:h"); 376 if (c == -1) { 377 break; 378 } 379 switch(c) { 380 case '?': 381 case 'h': 382 help(); 383 break; 384 case 'f': 385 fmt = optarg; 386 break; 387 } 388 } 389 if (optind >= argc) { 390 help(); 391 } 392 filename = argv[optind++]; 393 394 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS); 395 if (!bs) { 396 return 1; 397 } 398 ret = bdrv_check(bs, &result); 399 400 if (ret == -ENOTSUP) { 401 error_report("This image format does not support checks"); 402 bdrv_delete(bs); 403 return 1; 404 } 405 406 if (!(result.corruptions || result.leaks || result.check_errors)) { 407 printf("No errors were found on the image.\n"); 408 } else { 409 if (result.corruptions) { 410 printf("\n%d errors were found on the image.\n" 411 "Data may be corrupted, or further writes to the image " 412 "may corrupt it.\n", 413 result.corruptions); 414 } 415 416 if (result.leaks) { 417 printf("\n%d leaked clusters were found on the image.\n" 418 "This means waste of disk space, but no harm to data.\n", 419 result.leaks); 420 } 421 422 if (result.check_errors) { 423 printf("\n%d internal errors have occurred during the check.\n", 424 result.check_errors); 425 } 426 } 427 428 bdrv_delete(bs); 429 430 if (ret < 0 || result.check_errors) { 431 printf("\nAn error has occurred during the check: %s\n" 432 "The check is not complete and may have missed error.\n", 433 strerror(-ret)); 434 return 1; 435 } 436 437 if (result.corruptions) { 438 return 2; 439 } else if (result.leaks) { 440 return 3; 441 } else { 442 return 0; 443 } 444 } 445 446 static int img_commit(int argc, char **argv) 447 { 448 int c, ret, flags; 449 const char *filename, *fmt, *cache; 450 BlockDriverState *bs; 451 452 fmt = NULL; 453 cache = BDRV_DEFAULT_CACHE; 454 for(;;) { 455 c = getopt(argc, argv, "f:ht:"); 456 if (c == -1) { 457 break; 458 } 459 switch(c) { 460 case '?': 461 case 'h': 462 help(); 463 break; 464 case 'f': 465 fmt = optarg; 466 break; 467 case 't': 468 cache = optarg; 469 break; 470 } 471 } 472 if (optind >= argc) { 473 help(); 474 } 475 filename = argv[optind++]; 476 477 flags = BDRV_O_RDWR; 478 ret = bdrv_parse_cache_flags(cache, &flags); 479 if (ret < 0) { 480 error_report("Invalid cache option: %s", cache); 481 return -1; 482 } 483 484 bs = bdrv_new_open(filename, fmt, flags); 485 if (!bs) { 486 return 1; 487 } 488 ret = bdrv_commit(bs); 489 switch(ret) { 490 case 0: 491 printf("Image committed.\n"); 492 break; 493 case -ENOENT: 494 error_report("No disk inserted"); 495 break; 496 case -EACCES: 497 error_report("Image is read-only"); 498 break; 499 case -ENOTSUP: 500 error_report("Image is already committed"); 501 break; 502 default: 503 error_report("Error while committing image"); 504 break; 505 } 506 507 bdrv_delete(bs); 508 if (ret) { 509 return 1; 510 } 511 return 0; 512 } 513 514 /* 515 * Checks whether the sector is not a zero sector. 516 * 517 * Attention! The len must be a multiple of 4 * sizeof(long) due to 518 * restriction of optimizations in this function. 519 */ 520 static int is_not_zero(const uint8_t *sector, int len) 521 { 522 /* 523 * Use long as the biggest available internal data type that fits into the 524 * CPU register and unroll the loop to smooth out the effect of memory 525 * latency. 526 */ 527 528 int i; 529 long d0, d1, d2, d3; 530 const long * const data = (const long *) sector; 531 532 len /= sizeof(long); 533 534 for(i = 0; i < len; i += 4) { 535 d0 = data[i + 0]; 536 d1 = data[i + 1]; 537 d2 = data[i + 2]; 538 d3 = data[i + 3]; 539 540 if (d0 || d1 || d2 || d3) { 541 return 1; 542 } 543 } 544 545 return 0; 546 } 547 548 /* 549 * Returns true iff the first sector pointed to by 'buf' contains at least 550 * a non-NUL byte. 551 * 552 * 'pnum' is set to the number of sectors (including and immediately following 553 * the first one) that are known to be in the same allocated/unallocated state. 554 */ 555 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 556 { 557 int v, i; 558 559 if (n <= 0) { 560 *pnum = 0; 561 return 0; 562 } 563 v = is_not_zero(buf, 512); 564 for(i = 1; i < n; i++) { 565 buf += 512; 566 if (v != is_not_zero(buf, 512)) 567 break; 568 } 569 *pnum = i; 570 return v; 571 } 572 573 /* 574 * Compares two buffers sector by sector. Returns 0 if the first sector of both 575 * buffers matches, non-zero otherwise. 576 * 577 * pnum is set to the number of sectors (including and immediately following 578 * the first one) that are known to have the same comparison result 579 */ 580 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n, 581 int *pnum) 582 { 583 int res, i; 584 585 if (n <= 0) { 586 *pnum = 0; 587 return 0; 588 } 589 590 res = !!memcmp(buf1, buf2, 512); 591 for(i = 1; i < n; i++) { 592 buf1 += 512; 593 buf2 += 512; 594 595 if (!!memcmp(buf1, buf2, 512) != res) { 596 break; 597 } 598 } 599 600 *pnum = i; 601 return res; 602 } 603 604 #define IO_BUF_SIZE (2 * 1024 * 1024) 605 606 static int img_convert(int argc, char **argv) 607 { 608 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors; 609 int progress = 0, flags; 610 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename; 611 BlockDriver *drv, *proto_drv; 612 BlockDriverState **bs = NULL, *out_bs = NULL; 613 int64_t total_sectors, nb_sectors, sector_num, bs_offset; 614 uint64_t bs_sectors; 615 uint8_t * buf = NULL; 616 const uint8_t *buf1; 617 BlockDriverInfo bdi; 618 QEMUOptionParameter *param = NULL, *create_options = NULL; 619 QEMUOptionParameter *out_baseimg_param; 620 char *options = NULL; 621 const char *snapshot_name = NULL; 622 float local_progress; 623 624 fmt = NULL; 625 out_fmt = "raw"; 626 cache = "unsafe"; 627 out_baseimg = NULL; 628 compress = 0; 629 for(;;) { 630 c = getopt(argc, argv, "f:O:B:s:hce6o:pt:"); 631 if (c == -1) { 632 break; 633 } 634 switch(c) { 635 case '?': 636 case 'h': 637 help(); 638 break; 639 case 'f': 640 fmt = optarg; 641 break; 642 case 'O': 643 out_fmt = optarg; 644 break; 645 case 'B': 646 out_baseimg = optarg; 647 break; 648 case 'c': 649 compress = 1; 650 break; 651 case 'e': 652 error_report("option -e is deprecated, please use \'-o " 653 "encryption\' instead!"); 654 return 1; 655 case '6': 656 error_report("option -6 is deprecated, please use \'-o " 657 "compat6\' instead!"); 658 return 1; 659 case 'o': 660 options = optarg; 661 break; 662 case 's': 663 snapshot_name = optarg; 664 break; 665 case 'p': 666 progress = 1; 667 break; 668 case 't': 669 cache = optarg; 670 break; 671 } 672 } 673 674 bs_n = argc - optind - 1; 675 if (bs_n < 1) { 676 help(); 677 } 678 679 out_filename = argv[argc - 1]; 680 681 if (options && !strcmp(options, "?")) { 682 ret = print_block_option_help(out_filename, out_fmt); 683 goto out; 684 } 685 686 if (bs_n > 1 && out_baseimg) { 687 error_report("-B makes no sense when concatenating multiple input " 688 "images"); 689 ret = -1; 690 goto out; 691 } 692 693 qemu_progress_init(progress, 2.0); 694 qemu_progress_print(0, 100); 695 696 bs = g_malloc0(bs_n * sizeof(BlockDriverState *)); 697 698 total_sectors = 0; 699 for (bs_i = 0; bs_i < bs_n; bs_i++) { 700 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS); 701 if (!bs[bs_i]) { 702 error_report("Could not open '%s'", argv[optind + bs_i]); 703 ret = -1; 704 goto out; 705 } 706 bdrv_get_geometry(bs[bs_i], &bs_sectors); 707 total_sectors += bs_sectors; 708 } 709 710 if (snapshot_name != NULL) { 711 if (bs_n > 1) { 712 error_report("No support for concatenating multiple snapshot"); 713 ret = -1; 714 goto out; 715 } 716 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) { 717 error_report("Failed to load snapshot"); 718 ret = -1; 719 goto out; 720 } 721 } 722 723 /* Find driver and parse its options */ 724 drv = bdrv_find_format(out_fmt); 725 if (!drv) { 726 error_report("Unknown file format '%s'", out_fmt); 727 ret = -1; 728 goto out; 729 } 730 731 proto_drv = bdrv_find_protocol(out_filename); 732 if (!proto_drv) { 733 error_report("Unknown protocol '%s'", out_filename); 734 ret = -1; 735 goto out; 736 } 737 738 create_options = append_option_parameters(create_options, 739 drv->create_options); 740 create_options = append_option_parameters(create_options, 741 proto_drv->create_options); 742 743 if (options) { 744 param = parse_option_parameters(options, create_options, param); 745 if (param == NULL) { 746 error_report("Invalid options for file format '%s'.", out_fmt); 747 ret = -1; 748 goto out; 749 } 750 } else { 751 param = parse_option_parameters("", create_options, param); 752 } 753 754 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 755 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL); 756 if (ret < 0) { 757 goto out; 758 } 759 760 /* Get backing file name if -o backing_file was used */ 761 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 762 if (out_baseimg_param) { 763 out_baseimg = out_baseimg_param->value.s; 764 } 765 766 /* Check if compression is supported */ 767 if (compress) { 768 QEMUOptionParameter *encryption = 769 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 770 771 if (!drv->bdrv_write_compressed) { 772 error_report("Compression not supported for this file format"); 773 ret = -1; 774 goto out; 775 } 776 777 if (encryption && encryption->value.n) { 778 error_report("Compression and encryption not supported at " 779 "the same time"); 780 ret = -1; 781 goto out; 782 } 783 } 784 785 /* Create the new image */ 786 ret = bdrv_create(drv, out_filename, param); 787 if (ret < 0) { 788 if (ret == -ENOTSUP) { 789 error_report("Formatting not supported for file format '%s'", 790 out_fmt); 791 } else if (ret == -EFBIG) { 792 error_report("The image size is too large for file format '%s'", 793 out_fmt); 794 } else { 795 error_report("%s: error while converting %s: %s", 796 out_filename, out_fmt, strerror(-ret)); 797 } 798 goto out; 799 } 800 801 flags = BDRV_O_RDWR; 802 ret = bdrv_parse_cache_flags(cache, &flags); 803 if (ret < 0) { 804 error_report("Invalid cache option: %s", cache); 805 return -1; 806 } 807 808 out_bs = bdrv_new_open(out_filename, out_fmt, flags); 809 if (!out_bs) { 810 ret = -1; 811 goto out; 812 } 813 814 bs_i = 0; 815 bs_offset = 0; 816 bdrv_get_geometry(bs[0], &bs_sectors); 817 buf = g_malloc(IO_BUF_SIZE); 818 819 if (compress) { 820 ret = bdrv_get_info(out_bs, &bdi); 821 if (ret < 0) { 822 error_report("could not get block driver info"); 823 goto out; 824 } 825 cluster_size = bdi.cluster_size; 826 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) { 827 error_report("invalid cluster size"); 828 ret = -1; 829 goto out; 830 } 831 cluster_sectors = cluster_size >> 9; 832 sector_num = 0; 833 834 nb_sectors = total_sectors; 835 local_progress = (float)100 / 836 (nb_sectors / MIN(nb_sectors, cluster_sectors)); 837 838 for(;;) { 839 int64_t bs_num; 840 int remainder; 841 uint8_t *buf2; 842 843 nb_sectors = total_sectors - sector_num; 844 if (nb_sectors <= 0) 845 break; 846 if (nb_sectors >= cluster_sectors) 847 n = cluster_sectors; 848 else 849 n = nb_sectors; 850 851 bs_num = sector_num - bs_offset; 852 assert (bs_num >= 0); 853 remainder = n; 854 buf2 = buf; 855 while (remainder > 0) { 856 int nlow; 857 while (bs_num == bs_sectors) { 858 bs_i++; 859 assert (bs_i < bs_n); 860 bs_offset += bs_sectors; 861 bdrv_get_geometry(bs[bs_i], &bs_sectors); 862 bs_num = 0; 863 /* printf("changing part: sector_num=%" PRId64 ", " 864 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64 865 "\n", sector_num, bs_i, bs_offset, bs_sectors); */ 866 } 867 assert (bs_num < bs_sectors); 868 869 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 870 871 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow); 872 if (ret < 0) { 873 error_report("error while reading"); 874 goto out; 875 } 876 877 buf2 += nlow * 512; 878 bs_num += nlow; 879 880 remainder -= nlow; 881 } 882 assert (remainder == 0); 883 884 if (n < cluster_sectors) { 885 memset(buf + n * 512, 0, cluster_size - n * 512); 886 } 887 if (is_not_zero(buf, cluster_size)) { 888 ret = bdrv_write_compressed(out_bs, sector_num, buf, 889 cluster_sectors); 890 if (ret != 0) { 891 error_report("error while compressing sector %" PRId64, 892 sector_num); 893 goto out; 894 } 895 } 896 sector_num += n; 897 qemu_progress_print(local_progress, 100); 898 } 899 /* signal EOF to align */ 900 bdrv_write_compressed(out_bs, 0, NULL, 0); 901 } else { 902 int has_zero_init = bdrv_has_zero_init(out_bs); 903 904 sector_num = 0; // total number of sectors converted so far 905 nb_sectors = total_sectors - sector_num; 906 local_progress = (float)100 / 907 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512)); 908 909 for(;;) { 910 nb_sectors = total_sectors - sector_num; 911 if (nb_sectors <= 0) { 912 break; 913 } 914 if (nb_sectors >= (IO_BUF_SIZE / 512)) { 915 n = (IO_BUF_SIZE / 512); 916 } else { 917 n = nb_sectors; 918 } 919 920 while (sector_num - bs_offset >= bs_sectors) { 921 bs_i ++; 922 assert (bs_i < bs_n); 923 bs_offset += bs_sectors; 924 bdrv_get_geometry(bs[bs_i], &bs_sectors); 925 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, " 926 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n", 927 sector_num, bs_i, bs_offset, bs_sectors); */ 928 } 929 930 if (n > bs_offset + bs_sectors - sector_num) { 931 n = bs_offset + bs_sectors - sector_num; 932 } 933 934 if (has_zero_init) { 935 /* If the output image is being created as a copy on write image, 936 assume that sectors which are unallocated in the input image 937 are present in both the output's and input's base images (no 938 need to copy them). */ 939 if (out_baseimg) { 940 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 941 n, &n1)) { 942 sector_num += n1; 943 continue; 944 } 945 /* The next 'n1' sectors are allocated in the input image. Copy 946 only those as they may be followed by unallocated sectors. */ 947 n = n1; 948 } 949 } else { 950 n1 = n; 951 } 952 953 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); 954 if (ret < 0) { 955 error_report("error while reading"); 956 goto out; 957 } 958 /* NOTE: at the same time we convert, we do not write zero 959 sectors to have a chance to compress the image. Ideally, we 960 should add a specific call to have the info to go faster */ 961 buf1 = buf; 962 while (n > 0) { 963 /* If the output image is being created as a copy on write image, 964 copy all sectors even the ones containing only NUL bytes, 965 because they may differ from the sectors in the base image. 966 967 If the output is to a host device, we also write out 968 sectors that are entirely 0, since whatever data was 969 already there is garbage, not 0s. */ 970 if (!has_zero_init || out_baseimg || 971 is_allocated_sectors(buf1, n, &n1)) { 972 ret = bdrv_write(out_bs, sector_num, buf1, n1); 973 if (ret < 0) { 974 error_report("error while writing"); 975 goto out; 976 } 977 } 978 sector_num += n1; 979 n -= n1; 980 buf1 += n1 * 512; 981 } 982 qemu_progress_print(local_progress, 100); 983 } 984 } 985 out: 986 qemu_progress_end(); 987 free_option_parameters(create_options); 988 free_option_parameters(param); 989 g_free(buf); 990 if (out_bs) { 991 bdrv_delete(out_bs); 992 } 993 if (bs) { 994 for (bs_i = 0; bs_i < bs_n; bs_i++) { 995 if (bs[bs_i]) { 996 bdrv_delete(bs[bs_i]); 997 } 998 } 999 g_free(bs); 1000 } 1001 if (ret) { 1002 return 1; 1003 } 1004 return 0; 1005 } 1006 1007 1008 static void dump_snapshots(BlockDriverState *bs) 1009 { 1010 QEMUSnapshotInfo *sn_tab, *sn; 1011 int nb_sns, i; 1012 char buf[256]; 1013 1014 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 1015 if (nb_sns <= 0) 1016 return; 1017 printf("Snapshot list:\n"); 1018 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 1019 for(i = 0; i < nb_sns; i++) { 1020 sn = &sn_tab[i]; 1021 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 1022 } 1023 g_free(sn_tab); 1024 } 1025 1026 static int img_info(int argc, char **argv) 1027 { 1028 int c; 1029 const char *filename, *fmt; 1030 BlockDriverState *bs; 1031 char fmt_name[128], size_buf[128], dsize_buf[128]; 1032 uint64_t total_sectors; 1033 int64_t allocated_size; 1034 char backing_filename[1024]; 1035 char backing_filename2[1024]; 1036 BlockDriverInfo bdi; 1037 1038 fmt = NULL; 1039 for(;;) { 1040 c = getopt(argc, argv, "f:h"); 1041 if (c == -1) { 1042 break; 1043 } 1044 switch(c) { 1045 case '?': 1046 case 'h': 1047 help(); 1048 break; 1049 case 'f': 1050 fmt = optarg; 1051 break; 1052 } 1053 } 1054 if (optind >= argc) { 1055 help(); 1056 } 1057 filename = argv[optind++]; 1058 1059 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING); 1060 if (!bs) { 1061 return 1; 1062 } 1063 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 1064 bdrv_get_geometry(bs, &total_sectors); 1065 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 1066 allocated_size = bdrv_get_allocated_file_size(bs); 1067 if (allocated_size < 0) { 1068 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 1069 } else { 1070 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 1071 allocated_size); 1072 } 1073 printf("image: %s\n" 1074 "file format: %s\n" 1075 "virtual size: %s (%" PRId64 " bytes)\n" 1076 "disk size: %s\n", 1077 filename, fmt_name, size_buf, 1078 (total_sectors * 512), 1079 dsize_buf); 1080 if (bdrv_is_encrypted(bs)) { 1081 printf("encrypted: yes\n"); 1082 } 1083 if (bdrv_get_info(bs, &bdi) >= 0) { 1084 if (bdi.cluster_size != 0) { 1085 printf("cluster_size: %d\n", bdi.cluster_size); 1086 } 1087 } 1088 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 1089 if (backing_filename[0] != '\0') { 1090 path_combine(backing_filename2, sizeof(backing_filename2), 1091 filename, backing_filename); 1092 printf("backing file: %s (actual path: %s)\n", 1093 backing_filename, 1094 backing_filename2); 1095 } 1096 dump_snapshots(bs); 1097 bdrv_delete(bs); 1098 return 0; 1099 } 1100 1101 #define SNAPSHOT_LIST 1 1102 #define SNAPSHOT_CREATE 2 1103 #define SNAPSHOT_APPLY 3 1104 #define SNAPSHOT_DELETE 4 1105 1106 static int img_snapshot(int argc, char **argv) 1107 { 1108 BlockDriverState *bs; 1109 QEMUSnapshotInfo sn; 1110 char *filename, *snapshot_name = NULL; 1111 int c, ret = 0, bdrv_oflags; 1112 int action = 0; 1113 qemu_timeval tv; 1114 1115 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR; 1116 /* Parse commandline parameters */ 1117 for(;;) { 1118 c = getopt(argc, argv, "la:c:d:h"); 1119 if (c == -1) { 1120 break; 1121 } 1122 switch(c) { 1123 case '?': 1124 case 'h': 1125 help(); 1126 return 0; 1127 case 'l': 1128 if (action) { 1129 help(); 1130 return 0; 1131 } 1132 action = SNAPSHOT_LIST; 1133 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 1134 break; 1135 case 'a': 1136 if (action) { 1137 help(); 1138 return 0; 1139 } 1140 action = SNAPSHOT_APPLY; 1141 snapshot_name = optarg; 1142 break; 1143 case 'c': 1144 if (action) { 1145 help(); 1146 return 0; 1147 } 1148 action = SNAPSHOT_CREATE; 1149 snapshot_name = optarg; 1150 break; 1151 case 'd': 1152 if (action) { 1153 help(); 1154 return 0; 1155 } 1156 action = SNAPSHOT_DELETE; 1157 snapshot_name = optarg; 1158 break; 1159 } 1160 } 1161 1162 if (optind >= argc) { 1163 help(); 1164 } 1165 filename = argv[optind++]; 1166 1167 /* Open the image */ 1168 bs = bdrv_new_open(filename, NULL, bdrv_oflags); 1169 if (!bs) { 1170 return 1; 1171 } 1172 1173 /* Perform the requested action */ 1174 switch(action) { 1175 case SNAPSHOT_LIST: 1176 dump_snapshots(bs); 1177 break; 1178 1179 case SNAPSHOT_CREATE: 1180 memset(&sn, 0, sizeof(sn)); 1181 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1182 1183 qemu_gettimeofday(&tv); 1184 sn.date_sec = tv.tv_sec; 1185 sn.date_nsec = tv.tv_usec * 1000; 1186 1187 ret = bdrv_snapshot_create(bs, &sn); 1188 if (ret) { 1189 error_report("Could not create snapshot '%s': %d (%s)", 1190 snapshot_name, ret, strerror(-ret)); 1191 } 1192 break; 1193 1194 case SNAPSHOT_APPLY: 1195 ret = bdrv_snapshot_goto(bs, snapshot_name); 1196 if (ret) { 1197 error_report("Could not apply snapshot '%s': %d (%s)", 1198 snapshot_name, ret, strerror(-ret)); 1199 } 1200 break; 1201 1202 case SNAPSHOT_DELETE: 1203 ret = bdrv_snapshot_delete(bs, snapshot_name); 1204 if (ret) { 1205 error_report("Could not delete snapshot '%s': %d (%s)", 1206 snapshot_name, ret, strerror(-ret)); 1207 } 1208 break; 1209 } 1210 1211 /* Cleanup */ 1212 bdrv_delete(bs); 1213 if (ret) { 1214 return 1; 1215 } 1216 return 0; 1217 } 1218 1219 static int img_rebase(int argc, char **argv) 1220 { 1221 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL; 1222 BlockDriver *old_backing_drv, *new_backing_drv; 1223 char *filename; 1224 const char *fmt, *cache, *out_basefmt, *out_baseimg; 1225 int c, flags, ret; 1226 int unsafe = 0; 1227 int progress = 0; 1228 1229 /* Parse commandline parameters */ 1230 fmt = NULL; 1231 cache = BDRV_DEFAULT_CACHE; 1232 out_baseimg = NULL; 1233 out_basefmt = NULL; 1234 for(;;) { 1235 c = getopt(argc, argv, "uhf:F:b:pt:"); 1236 if (c == -1) { 1237 break; 1238 } 1239 switch(c) { 1240 case '?': 1241 case 'h': 1242 help(); 1243 return 0; 1244 case 'f': 1245 fmt = optarg; 1246 break; 1247 case 'F': 1248 out_basefmt = optarg; 1249 break; 1250 case 'b': 1251 out_baseimg = optarg; 1252 break; 1253 case 'u': 1254 unsafe = 1; 1255 break; 1256 case 'p': 1257 progress = 1; 1258 break; 1259 case 't': 1260 cache = optarg; 1261 break; 1262 } 1263 } 1264 1265 if ((optind >= argc) || (!unsafe && !out_baseimg)) { 1266 help(); 1267 } 1268 filename = argv[optind++]; 1269 1270 qemu_progress_init(progress, 2.0); 1271 qemu_progress_print(0, 100); 1272 1273 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 1274 ret = bdrv_parse_cache_flags(cache, &flags); 1275 if (ret < 0) { 1276 error_report("Invalid cache option: %s", cache); 1277 return -1; 1278 } 1279 1280 /* 1281 * Open the images. 1282 * 1283 * Ignore the old backing file for unsafe rebase in case we want to correct 1284 * the reference to a renamed or moved backing file. 1285 */ 1286 bs = bdrv_new_open(filename, fmt, flags); 1287 if (!bs) { 1288 return 1; 1289 } 1290 1291 /* Find the right drivers for the backing files */ 1292 old_backing_drv = NULL; 1293 new_backing_drv = NULL; 1294 1295 if (!unsafe && bs->backing_format[0] != '\0') { 1296 old_backing_drv = bdrv_find_format(bs->backing_format); 1297 if (old_backing_drv == NULL) { 1298 error_report("Invalid format name: '%s'", bs->backing_format); 1299 ret = -1; 1300 goto out; 1301 } 1302 } 1303 1304 if (out_basefmt != NULL) { 1305 new_backing_drv = bdrv_find_format(out_basefmt); 1306 if (new_backing_drv == NULL) { 1307 error_report("Invalid format name: '%s'", out_basefmt); 1308 ret = -1; 1309 goto out; 1310 } 1311 } 1312 1313 /* For safe rebasing we need to compare old and new backing file */ 1314 if (unsafe) { 1315 /* Make the compiler happy */ 1316 bs_old_backing = NULL; 1317 bs_new_backing = NULL; 1318 } else { 1319 char backing_name[1024]; 1320 1321 bs_old_backing = bdrv_new("old_backing"); 1322 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 1323 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS, 1324 old_backing_drv); 1325 if (ret) { 1326 error_report("Could not open old backing file '%s'", backing_name); 1327 goto out; 1328 } 1329 1330 bs_new_backing = bdrv_new("new_backing"); 1331 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS, 1332 new_backing_drv); 1333 if (ret) { 1334 error_report("Could not open new backing file '%s'", out_baseimg); 1335 goto out; 1336 } 1337 } 1338 1339 /* 1340 * Check each unallocated cluster in the COW file. If it is unallocated, 1341 * accesses go to the backing file. We must therefore compare this cluster 1342 * in the old and new backing file, and if they differ we need to copy it 1343 * from the old backing file into the COW file. 1344 * 1345 * If qemu-img crashes during this step, no harm is done. The content of 1346 * the image is the same as the original one at any time. 1347 */ 1348 if (!unsafe) { 1349 uint64_t num_sectors; 1350 uint64_t sector; 1351 int n; 1352 uint8_t * buf_old; 1353 uint8_t * buf_new; 1354 float local_progress; 1355 1356 buf_old = g_malloc(IO_BUF_SIZE); 1357 buf_new = g_malloc(IO_BUF_SIZE); 1358 1359 bdrv_get_geometry(bs, &num_sectors); 1360 1361 local_progress = (float)100 / 1362 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512)); 1363 for (sector = 0; sector < num_sectors; sector += n) { 1364 1365 /* How many sectors can we handle with the next read? */ 1366 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 1367 n = (IO_BUF_SIZE / 512); 1368 } else { 1369 n = num_sectors - sector; 1370 } 1371 1372 /* If the cluster is allocated, we don't need to take action */ 1373 ret = bdrv_is_allocated(bs, sector, n, &n); 1374 if (ret) { 1375 continue; 1376 } 1377 1378 /* Read old and new backing file */ 1379 ret = bdrv_read(bs_old_backing, sector, buf_old, n); 1380 if (ret < 0) { 1381 error_report("error while reading from old backing file"); 1382 goto out; 1383 } 1384 ret = bdrv_read(bs_new_backing, sector, buf_new, n); 1385 if (ret < 0) { 1386 error_report("error while reading from new backing file"); 1387 goto out; 1388 } 1389 1390 /* If they differ, we need to write to the COW file */ 1391 uint64_t written = 0; 1392 1393 while (written < n) { 1394 int pnum; 1395 1396 if (compare_sectors(buf_old + written * 512, 1397 buf_new + written * 512, n - written, &pnum)) 1398 { 1399 ret = bdrv_write(bs, sector + written, 1400 buf_old + written * 512, pnum); 1401 if (ret < 0) { 1402 error_report("Error while writing to COW image: %s", 1403 strerror(-ret)); 1404 goto out; 1405 } 1406 } 1407 1408 written += pnum; 1409 } 1410 qemu_progress_print(local_progress, 100); 1411 } 1412 1413 g_free(buf_old); 1414 g_free(buf_new); 1415 } 1416 1417 /* 1418 * Change the backing file. All clusters that are different from the old 1419 * backing file are overwritten in the COW file now, so the visible content 1420 * doesn't change when we switch the backing file. 1421 */ 1422 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 1423 if (ret == -ENOSPC) { 1424 error_report("Could not change the backing file to '%s': No " 1425 "space left in the file header", out_baseimg); 1426 } else if (ret < 0) { 1427 error_report("Could not change the backing file to '%s': %s", 1428 out_baseimg, strerror(-ret)); 1429 } 1430 1431 qemu_progress_print(100, 0); 1432 /* 1433 * TODO At this point it is possible to check if any clusters that are 1434 * allocated in the COW file are the same in the backing file. If so, they 1435 * could be dropped from the COW file. Don't do this before switching the 1436 * backing file, in case of a crash this would lead to corruption. 1437 */ 1438 out: 1439 qemu_progress_end(); 1440 /* Cleanup */ 1441 if (!unsafe) { 1442 if (bs_old_backing != NULL) { 1443 bdrv_delete(bs_old_backing); 1444 } 1445 if (bs_new_backing != NULL) { 1446 bdrv_delete(bs_new_backing); 1447 } 1448 } 1449 1450 bdrv_delete(bs); 1451 if (ret) { 1452 return 1; 1453 } 1454 return 0; 1455 } 1456 1457 static int img_resize(int argc, char **argv) 1458 { 1459 int c, ret, relative; 1460 const char *filename, *fmt, *size; 1461 int64_t n, total_size; 1462 BlockDriverState *bs = NULL; 1463 QEMUOptionParameter *param; 1464 QEMUOptionParameter resize_options[] = { 1465 { 1466 .name = BLOCK_OPT_SIZE, 1467 .type = OPT_SIZE, 1468 .help = "Virtual disk size" 1469 }, 1470 { NULL } 1471 }; 1472 1473 /* Remove size from argv manually so that negative numbers are not treated 1474 * as options by getopt. */ 1475 if (argc < 3) { 1476 help(); 1477 return 1; 1478 } 1479 1480 size = argv[--argc]; 1481 1482 /* Parse getopt arguments */ 1483 fmt = NULL; 1484 for(;;) { 1485 c = getopt(argc, argv, "f:h"); 1486 if (c == -1) { 1487 break; 1488 } 1489 switch(c) { 1490 case '?': 1491 case 'h': 1492 help(); 1493 break; 1494 case 'f': 1495 fmt = optarg; 1496 break; 1497 } 1498 } 1499 if (optind >= argc) { 1500 help(); 1501 } 1502 filename = argv[optind++]; 1503 1504 /* Choose grow, shrink, or absolute resize mode */ 1505 switch (size[0]) { 1506 case '+': 1507 relative = 1; 1508 size++; 1509 break; 1510 case '-': 1511 relative = -1; 1512 size++; 1513 break; 1514 default: 1515 relative = 0; 1516 break; 1517 } 1518 1519 /* Parse size */ 1520 param = parse_option_parameters("", resize_options, NULL); 1521 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) { 1522 /* Error message already printed when size parsing fails */ 1523 ret = -1; 1524 goto out; 1525 } 1526 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n; 1527 free_option_parameters(param); 1528 1529 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR); 1530 if (!bs) { 1531 ret = -1; 1532 goto out; 1533 } 1534 1535 if (relative) { 1536 total_size = bdrv_getlength(bs) + n * relative; 1537 } else { 1538 total_size = n; 1539 } 1540 if (total_size <= 0) { 1541 error_report("New image size must be positive"); 1542 ret = -1; 1543 goto out; 1544 } 1545 1546 ret = bdrv_truncate(bs, total_size); 1547 switch (ret) { 1548 case 0: 1549 printf("Image resized.\n"); 1550 break; 1551 case -ENOTSUP: 1552 error_report("This image format does not support resize"); 1553 break; 1554 case -EACCES: 1555 error_report("Image is read-only"); 1556 break; 1557 default: 1558 error_report("Error resizing image (%d)", -ret); 1559 break; 1560 } 1561 out: 1562 if (bs) { 1563 bdrv_delete(bs); 1564 } 1565 if (ret) { 1566 return 1; 1567 } 1568 return 0; 1569 } 1570 1571 static const img_cmd_t img_cmds[] = { 1572 #define DEF(option, callback, arg_string) \ 1573 { option, callback }, 1574 #include "qemu-img-cmds.h" 1575 #undef DEF 1576 #undef GEN_DOCS 1577 { NULL, NULL, }, 1578 }; 1579 1580 int main(int argc, char **argv) 1581 { 1582 const img_cmd_t *cmd; 1583 const char *cmdname; 1584 1585 error_set_progname(argv[0]); 1586 1587 bdrv_init(); 1588 if (argc < 2) 1589 help(); 1590 cmdname = argv[1]; 1591 argc--; argv++; 1592 1593 /* find the command */ 1594 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 1595 if (!strcmp(cmdname, cmd->name)) { 1596 return cmd->handler(argc, argv); 1597 } 1598 } 1599 1600 /* not found */ 1601 help(); 1602 return 0; 1603 } 1604