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