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