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 if (options && !strcmp(options, "?")) { 716 ret = print_block_option_help(out_filename, out_fmt); 717 goto out; 718 } 719 720 if (bs_n > 1 && out_baseimg) { 721 error_report("-B makes no sense when concatenating multiple input " 722 "images"); 723 ret = -1; 724 goto out; 725 } 726 727 qemu_progress_init(progress, 2.0); 728 qemu_progress_print(0, 100); 729 730 bs = g_malloc0(bs_n * sizeof(BlockDriverState *)); 731 732 total_sectors = 0; 733 for (bs_i = 0; bs_i < bs_n; bs_i++) { 734 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS); 735 if (!bs[bs_i]) { 736 error_report("Could not open '%s'", argv[optind + bs_i]); 737 ret = -1; 738 goto out; 739 } 740 bdrv_get_geometry(bs[bs_i], &bs_sectors); 741 total_sectors += bs_sectors; 742 } 743 744 if (snapshot_name != NULL) { 745 if (bs_n > 1) { 746 error_report("No support for concatenating multiple snapshot"); 747 ret = -1; 748 goto out; 749 } 750 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) { 751 error_report("Failed to load snapshot"); 752 ret = -1; 753 goto out; 754 } 755 } 756 757 /* Find driver and parse its options */ 758 drv = bdrv_find_format(out_fmt); 759 if (!drv) { 760 error_report("Unknown file format '%s'", out_fmt); 761 ret = -1; 762 goto out; 763 } 764 765 proto_drv = bdrv_find_protocol(out_filename); 766 if (!proto_drv) { 767 error_report("Unknown protocol '%s'", out_filename); 768 ret = -1; 769 goto out; 770 } 771 772 create_options = append_option_parameters(create_options, 773 drv->create_options); 774 create_options = append_option_parameters(create_options, 775 proto_drv->create_options); 776 777 if (options) { 778 param = parse_option_parameters(options, create_options, param); 779 if (param == NULL) { 780 error_report("Invalid options for file format '%s'.", out_fmt); 781 ret = -1; 782 goto out; 783 } 784 } else { 785 param = parse_option_parameters("", create_options, param); 786 } 787 788 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 789 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL); 790 if (ret < 0) { 791 goto out; 792 } 793 794 /* Get backing file name if -o backing_file was used */ 795 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 796 if (out_baseimg_param) { 797 out_baseimg = out_baseimg_param->value.s; 798 } 799 800 /* Check if compression is supported */ 801 if (compress) { 802 QEMUOptionParameter *encryption = 803 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 804 QEMUOptionParameter *preallocation = 805 get_option_parameter(param, BLOCK_OPT_PREALLOC); 806 807 if (!drv->bdrv_write_compressed) { 808 error_report("Compression not supported for this file format"); 809 ret = -1; 810 goto out; 811 } 812 813 if (encryption && encryption->value.n) { 814 error_report("Compression and encryption not supported at " 815 "the same time"); 816 ret = -1; 817 goto out; 818 } 819 820 if (preallocation && preallocation->value.s 821 && strcmp(preallocation->value.s, "off")) 822 { 823 error_report("Compression and preallocation not supported at " 824 "the same time"); 825 ret = -1; 826 goto out; 827 } 828 } 829 830 /* Create the new image */ 831 ret = bdrv_create(drv, out_filename, param); 832 if (ret < 0) { 833 if (ret == -ENOTSUP) { 834 error_report("Formatting not supported for file format '%s'", 835 out_fmt); 836 } else if (ret == -EFBIG) { 837 error_report("The image size is too large for file format '%s'", 838 out_fmt); 839 } else { 840 error_report("%s: error while converting %s: %s", 841 out_filename, out_fmt, strerror(-ret)); 842 } 843 goto out; 844 } 845 846 flags = BDRV_O_RDWR; 847 ret = bdrv_parse_cache_flags(cache, &flags); 848 if (ret < 0) { 849 error_report("Invalid cache option: %s", cache); 850 return -1; 851 } 852 853 out_bs = bdrv_new_open(out_filename, out_fmt, flags); 854 if (!out_bs) { 855 ret = -1; 856 goto out; 857 } 858 859 bs_i = 0; 860 bs_offset = 0; 861 bdrv_get_geometry(bs[0], &bs_sectors); 862 buf = qemu_blockalign(out_bs, IO_BUF_SIZE); 863 864 if (compress) { 865 ret = bdrv_get_info(out_bs, &bdi); 866 if (ret < 0) { 867 error_report("could not get block driver info"); 868 goto out; 869 } 870 cluster_size = bdi.cluster_size; 871 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) { 872 error_report("invalid cluster size"); 873 ret = -1; 874 goto out; 875 } 876 cluster_sectors = cluster_size >> 9; 877 sector_num = 0; 878 879 nb_sectors = total_sectors; 880 local_progress = (float)100 / 881 (nb_sectors / MIN(nb_sectors, cluster_sectors)); 882 883 for(;;) { 884 int64_t bs_num; 885 int remainder; 886 uint8_t *buf2; 887 888 nb_sectors = total_sectors - sector_num; 889 if (nb_sectors <= 0) 890 break; 891 if (nb_sectors >= cluster_sectors) 892 n = cluster_sectors; 893 else 894 n = nb_sectors; 895 896 bs_num = sector_num - bs_offset; 897 assert (bs_num >= 0); 898 remainder = n; 899 buf2 = buf; 900 while (remainder > 0) { 901 int nlow; 902 while (bs_num == bs_sectors) { 903 bs_i++; 904 assert (bs_i < bs_n); 905 bs_offset += bs_sectors; 906 bdrv_get_geometry(bs[bs_i], &bs_sectors); 907 bs_num = 0; 908 /* printf("changing part: sector_num=%" PRId64 ", " 909 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64 910 "\n", sector_num, bs_i, bs_offset, bs_sectors); */ 911 } 912 assert (bs_num < bs_sectors); 913 914 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 915 916 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow); 917 if (ret < 0) { 918 error_report("error while reading sector %" PRId64 ": %s", 919 bs_num, strerror(-ret)); 920 goto out; 921 } 922 923 buf2 += nlow * 512; 924 bs_num += nlow; 925 926 remainder -= nlow; 927 } 928 assert (remainder == 0); 929 930 if (n < cluster_sectors) { 931 memset(buf + n * 512, 0, cluster_size - n * 512); 932 } 933 if (!buffer_is_zero(buf, cluster_size)) { 934 ret = bdrv_write_compressed(out_bs, sector_num, buf, 935 cluster_sectors); 936 if (ret != 0) { 937 error_report("error while compressing sector %" PRId64 938 ": %s", sector_num, strerror(-ret)); 939 goto out; 940 } 941 } 942 sector_num += n; 943 qemu_progress_print(local_progress, 100); 944 } 945 /* signal EOF to align */ 946 bdrv_write_compressed(out_bs, 0, NULL, 0); 947 } else { 948 int has_zero_init = bdrv_has_zero_init(out_bs); 949 950 sector_num = 0; // total number of sectors converted so far 951 nb_sectors = total_sectors - sector_num; 952 local_progress = (float)100 / 953 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512)); 954 955 for(;;) { 956 nb_sectors = total_sectors - sector_num; 957 if (nb_sectors <= 0) { 958 break; 959 } 960 if (nb_sectors >= (IO_BUF_SIZE / 512)) { 961 n = (IO_BUF_SIZE / 512); 962 } else { 963 n = nb_sectors; 964 } 965 966 while (sector_num - bs_offset >= bs_sectors) { 967 bs_i ++; 968 assert (bs_i < bs_n); 969 bs_offset += bs_sectors; 970 bdrv_get_geometry(bs[bs_i], &bs_sectors); 971 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, " 972 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n", 973 sector_num, bs_i, bs_offset, bs_sectors); */ 974 } 975 976 if (n > bs_offset + bs_sectors - sector_num) { 977 n = bs_offset + bs_sectors - sector_num; 978 } 979 980 if (has_zero_init) { 981 /* If the output image is being created as a copy on write image, 982 assume that sectors which are unallocated in the input image 983 are present in both the output's and input's base images (no 984 need to copy them). */ 985 if (out_baseimg) { 986 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 987 n, &n1)) { 988 sector_num += n1; 989 continue; 990 } 991 /* The next 'n1' sectors are allocated in the input image. Copy 992 only those as they may be followed by unallocated sectors. */ 993 n = n1; 994 } 995 } else { 996 n1 = n; 997 } 998 999 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); 1000 if (ret < 0) { 1001 error_report("error while reading sector %" PRId64 ": %s", 1002 sector_num - bs_offset, strerror(-ret)); 1003 goto out; 1004 } 1005 /* NOTE: at the same time we convert, we do not write zero 1006 sectors to have a chance to compress the image. Ideally, we 1007 should add a specific call to have the info to go faster */ 1008 buf1 = buf; 1009 while (n > 0) { 1010 /* If the output image is being created as a copy on write image, 1011 copy all sectors even the ones containing only NUL bytes, 1012 because they may differ from the sectors in the base image. 1013 1014 If the output is to a host device, we also write out 1015 sectors that are entirely 0, since whatever data was 1016 already there is garbage, not 0s. */ 1017 if (!has_zero_init || out_baseimg || 1018 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) { 1019 ret = bdrv_write(out_bs, sector_num, buf1, n1); 1020 if (ret < 0) { 1021 error_report("error while writing sector %" PRId64 1022 ": %s", sector_num, strerror(-ret)); 1023 goto out; 1024 } 1025 } 1026 sector_num += n1; 1027 n -= n1; 1028 buf1 += n1 * 512; 1029 } 1030 qemu_progress_print(local_progress, 100); 1031 } 1032 } 1033 out: 1034 qemu_progress_end(); 1035 free_option_parameters(create_options); 1036 free_option_parameters(param); 1037 qemu_vfree(buf); 1038 if (out_bs) { 1039 bdrv_delete(out_bs); 1040 } 1041 if (bs) { 1042 for (bs_i = 0; bs_i < bs_n; bs_i++) { 1043 if (bs[bs_i]) { 1044 bdrv_delete(bs[bs_i]); 1045 } 1046 } 1047 g_free(bs); 1048 } 1049 if (ret) { 1050 return 1; 1051 } 1052 return 0; 1053 } 1054 1055 1056 static void dump_snapshots(BlockDriverState *bs) 1057 { 1058 QEMUSnapshotInfo *sn_tab, *sn; 1059 int nb_sns, i; 1060 char buf[256]; 1061 1062 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 1063 if (nb_sns <= 0) 1064 return; 1065 printf("Snapshot list:\n"); 1066 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 1067 for(i = 0; i < nb_sns; i++) { 1068 sn = &sn_tab[i]; 1069 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 1070 } 1071 g_free(sn_tab); 1072 } 1073 1074 static int img_info(int argc, char **argv) 1075 { 1076 int c; 1077 const char *filename, *fmt; 1078 BlockDriverState *bs; 1079 char fmt_name[128], size_buf[128], dsize_buf[128]; 1080 uint64_t total_sectors; 1081 int64_t allocated_size; 1082 char backing_filename[1024]; 1083 char backing_filename2[1024]; 1084 BlockDriverInfo bdi; 1085 1086 fmt = NULL; 1087 for(;;) { 1088 c = getopt(argc, argv, "f:h"); 1089 if (c == -1) { 1090 break; 1091 } 1092 switch(c) { 1093 case '?': 1094 case 'h': 1095 help(); 1096 break; 1097 case 'f': 1098 fmt = optarg; 1099 break; 1100 } 1101 } 1102 if (optind >= argc) { 1103 help(); 1104 } 1105 filename = argv[optind++]; 1106 1107 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING); 1108 if (!bs) { 1109 return 1; 1110 } 1111 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 1112 bdrv_get_geometry(bs, &total_sectors); 1113 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 1114 allocated_size = bdrv_get_allocated_file_size(bs); 1115 if (allocated_size < 0) { 1116 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 1117 } else { 1118 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 1119 allocated_size); 1120 } 1121 printf("image: %s\n" 1122 "file format: %s\n" 1123 "virtual size: %s (%" PRId64 " bytes)\n" 1124 "disk size: %s\n", 1125 filename, fmt_name, size_buf, 1126 (total_sectors * 512), 1127 dsize_buf); 1128 if (bdrv_is_encrypted(bs)) { 1129 printf("encrypted: yes\n"); 1130 } 1131 if (bdrv_get_info(bs, &bdi) >= 0) { 1132 if (bdi.cluster_size != 0) { 1133 printf("cluster_size: %d\n", bdi.cluster_size); 1134 } 1135 if (bdi.is_dirty) { 1136 printf("cleanly shut down: no\n"); 1137 } 1138 } 1139 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 1140 if (backing_filename[0] != '\0') { 1141 path_combine(backing_filename2, sizeof(backing_filename2), 1142 filename, backing_filename); 1143 printf("backing file: %s (actual path: %s)\n", 1144 backing_filename, 1145 backing_filename2); 1146 } 1147 dump_snapshots(bs); 1148 bdrv_delete(bs); 1149 return 0; 1150 } 1151 1152 #define SNAPSHOT_LIST 1 1153 #define SNAPSHOT_CREATE 2 1154 #define SNAPSHOT_APPLY 3 1155 #define SNAPSHOT_DELETE 4 1156 1157 static int img_snapshot(int argc, char **argv) 1158 { 1159 BlockDriverState *bs; 1160 QEMUSnapshotInfo sn; 1161 char *filename, *snapshot_name = NULL; 1162 int c, ret = 0, bdrv_oflags; 1163 int action = 0; 1164 qemu_timeval tv; 1165 1166 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR; 1167 /* Parse commandline parameters */ 1168 for(;;) { 1169 c = getopt(argc, argv, "la:c:d:h"); 1170 if (c == -1) { 1171 break; 1172 } 1173 switch(c) { 1174 case '?': 1175 case 'h': 1176 help(); 1177 return 0; 1178 case 'l': 1179 if (action) { 1180 help(); 1181 return 0; 1182 } 1183 action = SNAPSHOT_LIST; 1184 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 1185 break; 1186 case 'a': 1187 if (action) { 1188 help(); 1189 return 0; 1190 } 1191 action = SNAPSHOT_APPLY; 1192 snapshot_name = optarg; 1193 break; 1194 case 'c': 1195 if (action) { 1196 help(); 1197 return 0; 1198 } 1199 action = SNAPSHOT_CREATE; 1200 snapshot_name = optarg; 1201 break; 1202 case 'd': 1203 if (action) { 1204 help(); 1205 return 0; 1206 } 1207 action = SNAPSHOT_DELETE; 1208 snapshot_name = optarg; 1209 break; 1210 } 1211 } 1212 1213 if (optind >= argc) { 1214 help(); 1215 } 1216 filename = argv[optind++]; 1217 1218 /* Open the image */ 1219 bs = bdrv_new_open(filename, NULL, bdrv_oflags); 1220 if (!bs) { 1221 return 1; 1222 } 1223 1224 /* Perform the requested action */ 1225 switch(action) { 1226 case SNAPSHOT_LIST: 1227 dump_snapshots(bs); 1228 break; 1229 1230 case SNAPSHOT_CREATE: 1231 memset(&sn, 0, sizeof(sn)); 1232 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1233 1234 qemu_gettimeofday(&tv); 1235 sn.date_sec = tv.tv_sec; 1236 sn.date_nsec = tv.tv_usec * 1000; 1237 1238 ret = bdrv_snapshot_create(bs, &sn); 1239 if (ret) { 1240 error_report("Could not create snapshot '%s': %d (%s)", 1241 snapshot_name, ret, strerror(-ret)); 1242 } 1243 break; 1244 1245 case SNAPSHOT_APPLY: 1246 ret = bdrv_snapshot_goto(bs, snapshot_name); 1247 if (ret) { 1248 error_report("Could not apply snapshot '%s': %d (%s)", 1249 snapshot_name, ret, strerror(-ret)); 1250 } 1251 break; 1252 1253 case SNAPSHOT_DELETE: 1254 ret = bdrv_snapshot_delete(bs, snapshot_name); 1255 if (ret) { 1256 error_report("Could not delete snapshot '%s': %d (%s)", 1257 snapshot_name, ret, strerror(-ret)); 1258 } 1259 break; 1260 } 1261 1262 /* Cleanup */ 1263 bdrv_delete(bs); 1264 if (ret) { 1265 return 1; 1266 } 1267 return 0; 1268 } 1269 1270 static int img_rebase(int argc, char **argv) 1271 { 1272 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL; 1273 BlockDriver *old_backing_drv, *new_backing_drv; 1274 char *filename; 1275 const char *fmt, *cache, *out_basefmt, *out_baseimg; 1276 int c, flags, ret; 1277 int unsafe = 0; 1278 int progress = 0; 1279 1280 /* Parse commandline parameters */ 1281 fmt = NULL; 1282 cache = BDRV_DEFAULT_CACHE; 1283 out_baseimg = NULL; 1284 out_basefmt = NULL; 1285 for(;;) { 1286 c = getopt(argc, argv, "uhf:F:b:pt:"); 1287 if (c == -1) { 1288 break; 1289 } 1290 switch(c) { 1291 case '?': 1292 case 'h': 1293 help(); 1294 return 0; 1295 case 'f': 1296 fmt = optarg; 1297 break; 1298 case 'F': 1299 out_basefmt = optarg; 1300 break; 1301 case 'b': 1302 out_baseimg = optarg; 1303 break; 1304 case 'u': 1305 unsafe = 1; 1306 break; 1307 case 'p': 1308 progress = 1; 1309 break; 1310 case 't': 1311 cache = optarg; 1312 break; 1313 } 1314 } 1315 1316 if ((optind >= argc) || (!unsafe && !out_baseimg)) { 1317 help(); 1318 } 1319 filename = argv[optind++]; 1320 1321 qemu_progress_init(progress, 2.0); 1322 qemu_progress_print(0, 100); 1323 1324 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 1325 ret = bdrv_parse_cache_flags(cache, &flags); 1326 if (ret < 0) { 1327 error_report("Invalid cache option: %s", cache); 1328 return -1; 1329 } 1330 1331 /* 1332 * Open the images. 1333 * 1334 * Ignore the old backing file for unsafe rebase in case we want to correct 1335 * the reference to a renamed or moved backing file. 1336 */ 1337 bs = bdrv_new_open(filename, fmt, flags); 1338 if (!bs) { 1339 return 1; 1340 } 1341 1342 /* Find the right drivers for the backing files */ 1343 old_backing_drv = NULL; 1344 new_backing_drv = NULL; 1345 1346 if (!unsafe && bs->backing_format[0] != '\0') { 1347 old_backing_drv = bdrv_find_format(bs->backing_format); 1348 if (old_backing_drv == NULL) { 1349 error_report("Invalid format name: '%s'", bs->backing_format); 1350 ret = -1; 1351 goto out; 1352 } 1353 } 1354 1355 if (out_basefmt != NULL) { 1356 new_backing_drv = bdrv_find_format(out_basefmt); 1357 if (new_backing_drv == NULL) { 1358 error_report("Invalid format name: '%s'", out_basefmt); 1359 ret = -1; 1360 goto out; 1361 } 1362 } 1363 1364 /* For safe rebasing we need to compare old and new backing file */ 1365 if (unsafe) { 1366 /* Make the compiler happy */ 1367 bs_old_backing = NULL; 1368 bs_new_backing = NULL; 1369 } else { 1370 char backing_name[1024]; 1371 1372 bs_old_backing = bdrv_new("old_backing"); 1373 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 1374 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS, 1375 old_backing_drv); 1376 if (ret) { 1377 error_report("Could not open old backing file '%s'", backing_name); 1378 goto out; 1379 } 1380 1381 bs_new_backing = bdrv_new("new_backing"); 1382 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS, 1383 new_backing_drv); 1384 if (ret) { 1385 error_report("Could not open new backing file '%s'", out_baseimg); 1386 goto out; 1387 } 1388 } 1389 1390 /* 1391 * Check each unallocated cluster in the COW file. If it is unallocated, 1392 * accesses go to the backing file. We must therefore compare this cluster 1393 * in the old and new backing file, and if they differ we need to copy it 1394 * from the old backing file into the COW file. 1395 * 1396 * If qemu-img crashes during this step, no harm is done. The content of 1397 * the image is the same as the original one at any time. 1398 */ 1399 if (!unsafe) { 1400 uint64_t num_sectors; 1401 uint64_t old_backing_num_sectors; 1402 uint64_t new_backing_num_sectors; 1403 uint64_t sector; 1404 int n; 1405 uint8_t * buf_old; 1406 uint8_t * buf_new; 1407 float local_progress; 1408 1409 buf_old = qemu_blockalign(bs, IO_BUF_SIZE); 1410 buf_new = qemu_blockalign(bs, IO_BUF_SIZE); 1411 1412 bdrv_get_geometry(bs, &num_sectors); 1413 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors); 1414 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors); 1415 1416 local_progress = (float)100 / 1417 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512)); 1418 for (sector = 0; sector < num_sectors; sector += n) { 1419 1420 /* How many sectors can we handle with the next read? */ 1421 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 1422 n = (IO_BUF_SIZE / 512); 1423 } else { 1424 n = num_sectors - sector; 1425 } 1426 1427 /* If the cluster is allocated, we don't need to take action */ 1428 ret = bdrv_is_allocated(bs, sector, n, &n); 1429 if (ret) { 1430 continue; 1431 } 1432 1433 /* 1434 * Read old and new backing file and take into consideration that 1435 * backing files may be smaller than the COW image. 1436 */ 1437 if (sector >= old_backing_num_sectors) { 1438 memset(buf_old, 0, n * BDRV_SECTOR_SIZE); 1439 } else { 1440 if (sector + n > old_backing_num_sectors) { 1441 n = old_backing_num_sectors - sector; 1442 } 1443 1444 ret = bdrv_read(bs_old_backing, sector, buf_old, n); 1445 if (ret < 0) { 1446 error_report("error while reading from old backing file"); 1447 goto out; 1448 } 1449 } 1450 1451 if (sector >= new_backing_num_sectors) { 1452 memset(buf_new, 0, n * BDRV_SECTOR_SIZE); 1453 } else { 1454 if (sector + n > new_backing_num_sectors) { 1455 n = new_backing_num_sectors - sector; 1456 } 1457 1458 ret = bdrv_read(bs_new_backing, sector, buf_new, n); 1459 if (ret < 0) { 1460 error_report("error while reading from new backing file"); 1461 goto out; 1462 } 1463 } 1464 1465 /* If they differ, we need to write to the COW file */ 1466 uint64_t written = 0; 1467 1468 while (written < n) { 1469 int pnum; 1470 1471 if (compare_sectors(buf_old + written * 512, 1472 buf_new + written * 512, n - written, &pnum)) 1473 { 1474 ret = bdrv_write(bs, sector + written, 1475 buf_old + written * 512, pnum); 1476 if (ret < 0) { 1477 error_report("Error while writing to COW image: %s", 1478 strerror(-ret)); 1479 goto out; 1480 } 1481 } 1482 1483 written += pnum; 1484 } 1485 qemu_progress_print(local_progress, 100); 1486 } 1487 1488 qemu_vfree(buf_old); 1489 qemu_vfree(buf_new); 1490 } 1491 1492 /* 1493 * Change the backing file. All clusters that are different from the old 1494 * backing file are overwritten in the COW file now, so the visible content 1495 * doesn't change when we switch the backing file. 1496 */ 1497 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 1498 if (ret == -ENOSPC) { 1499 error_report("Could not change the backing file to '%s': No " 1500 "space left in the file header", out_baseimg); 1501 } else if (ret < 0) { 1502 error_report("Could not change the backing file to '%s': %s", 1503 out_baseimg, strerror(-ret)); 1504 } 1505 1506 qemu_progress_print(100, 0); 1507 /* 1508 * TODO At this point it is possible to check if any clusters that are 1509 * allocated in the COW file are the same in the backing file. If so, they 1510 * could be dropped from the COW file. Don't do this before switching the 1511 * backing file, in case of a crash this would lead to corruption. 1512 */ 1513 out: 1514 qemu_progress_end(); 1515 /* Cleanup */ 1516 if (!unsafe) { 1517 if (bs_old_backing != NULL) { 1518 bdrv_delete(bs_old_backing); 1519 } 1520 if (bs_new_backing != NULL) { 1521 bdrv_delete(bs_new_backing); 1522 } 1523 } 1524 1525 bdrv_delete(bs); 1526 if (ret) { 1527 return 1; 1528 } 1529 return 0; 1530 } 1531 1532 static int img_resize(int argc, char **argv) 1533 { 1534 int c, ret, relative; 1535 const char *filename, *fmt, *size; 1536 int64_t n, total_size; 1537 BlockDriverState *bs = NULL; 1538 QEMUOptionParameter *param; 1539 QEMUOptionParameter resize_options[] = { 1540 { 1541 .name = BLOCK_OPT_SIZE, 1542 .type = OPT_SIZE, 1543 .help = "Virtual disk size" 1544 }, 1545 { NULL } 1546 }; 1547 1548 /* Remove size from argv manually so that negative numbers are not treated 1549 * as options by getopt. */ 1550 if (argc < 3) { 1551 help(); 1552 return 1; 1553 } 1554 1555 size = argv[--argc]; 1556 1557 /* Parse getopt arguments */ 1558 fmt = NULL; 1559 for(;;) { 1560 c = getopt(argc, argv, "f:h"); 1561 if (c == -1) { 1562 break; 1563 } 1564 switch(c) { 1565 case '?': 1566 case 'h': 1567 help(); 1568 break; 1569 case 'f': 1570 fmt = optarg; 1571 break; 1572 } 1573 } 1574 if (optind >= argc) { 1575 help(); 1576 } 1577 filename = argv[optind++]; 1578 1579 /* Choose grow, shrink, or absolute resize mode */ 1580 switch (size[0]) { 1581 case '+': 1582 relative = 1; 1583 size++; 1584 break; 1585 case '-': 1586 relative = -1; 1587 size++; 1588 break; 1589 default: 1590 relative = 0; 1591 break; 1592 } 1593 1594 /* Parse size */ 1595 param = parse_option_parameters("", resize_options, NULL); 1596 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) { 1597 /* Error message already printed when size parsing fails */ 1598 ret = -1; 1599 goto out; 1600 } 1601 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n; 1602 free_option_parameters(param); 1603 1604 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR); 1605 if (!bs) { 1606 ret = -1; 1607 goto out; 1608 } 1609 1610 if (relative) { 1611 total_size = bdrv_getlength(bs) + n * relative; 1612 } else { 1613 total_size = n; 1614 } 1615 if (total_size <= 0) { 1616 error_report("New image size must be positive"); 1617 ret = -1; 1618 goto out; 1619 } 1620 1621 ret = bdrv_truncate(bs, total_size); 1622 switch (ret) { 1623 case 0: 1624 printf("Image resized.\n"); 1625 break; 1626 case -ENOTSUP: 1627 error_report("This image does not support resize"); 1628 break; 1629 case -EACCES: 1630 error_report("Image is read-only"); 1631 break; 1632 default: 1633 error_report("Error resizing image (%d)", -ret); 1634 break; 1635 } 1636 out: 1637 if (bs) { 1638 bdrv_delete(bs); 1639 } 1640 if (ret) { 1641 return 1; 1642 } 1643 return 0; 1644 } 1645 1646 static const img_cmd_t img_cmds[] = { 1647 #define DEF(option, callback, arg_string) \ 1648 { option, callback }, 1649 #include "qemu-img-cmds.h" 1650 #undef DEF 1651 #undef GEN_DOCS 1652 { NULL, NULL, }, 1653 }; 1654 1655 int main(int argc, char **argv) 1656 { 1657 const img_cmd_t *cmd; 1658 const char *cmdname; 1659 1660 error_set_progname(argv[0]); 1661 1662 bdrv_init(); 1663 if (argc < 2) 1664 help(); 1665 cmdname = argv[1]; 1666 argc--; argv++; 1667 1668 qemu_init_main_loop(); 1669 1670 /* find the command */ 1671 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 1672 if (!strcmp(cmdname, cmd->name)) { 1673 return cmd->handler(argc, argv); 1674 } 1675 } 1676 1677 /* not found */ 1678 help(); 1679 return 0; 1680 } 1681