1 /* 2 * QEMU disk image utility 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu-common.h" 25 #include "qemu-option.h" 26 #include "qemu-error.h" 27 #include "osdep.h" 28 #include "sysemu.h" 29 #include "block_int.h" 30 #include <stdio.h> 31 32 #ifdef _WIN32 33 #include <windows.h> 34 #endif 35 36 typedef struct img_cmd_t { 37 const char *name; 38 int (*handler)(int argc, char **argv); 39 } img_cmd_t; 40 41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */ 42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB 43 #define BDRV_DEFAULT_CACHE "writeback" 44 45 static void format_print(void *opaque, const char *name) 46 { 47 printf(" %s", name); 48 } 49 50 /* Please keep in synch with qemu-img.texi */ 51 static void help(void) 52 { 53 const char *help_msg = 54 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n" 55 "usage: qemu-img command [command options]\n" 56 "QEMU disk image utility\n" 57 "\n" 58 "Command syntax:\n" 59 #define DEF(option, callback, arg_string) \ 60 " " arg_string "\n" 61 #include "qemu-img-cmds.h" 62 #undef DEF 63 #undef GEN_DOCS 64 "\n" 65 "Command parameters:\n" 66 " 'filename' is a disk image filename\n" 67 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 68 " 'cache' is the cache mode used to write the output disk image, the valid\n" 69 " options are: 'none', 'writeback' (default), 'writethrough', 'directsync'\n" 70 " and 'unsafe'\n" 71 " 'size' is the disk image size in bytes. Optional suffixes\n" 72 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n" 73 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n" 74 " 'output_filename' is the destination disk image filename\n" 75 " 'output_fmt' is the destination format\n" 76 " 'options' is a comma separated list of format specific options in a\n" 77 " name=value format. Use -o ? for an overview of the options supported by the\n" 78 " used format\n" 79 " '-c' indicates that target image must be compressed (qcow format only)\n" 80 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n" 81 " match exactly. The image doesn't need a working backing file before\n" 82 " rebasing in this case (useful for renaming the backing file)\n" 83 " '-h' with or without a command shows this help and lists the supported formats\n" 84 " '-p' show progress of command (only certain commands)\n" 85 " '-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 sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B); 336 if (sval < 0) { 337 error_report("Invalid image size specified! You may use k, M, G or " 338 "T suffixes for "); 339 error_report("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_report("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, flags; 451 const char *filename, *fmt, *cache; 452 BlockDriverState *bs; 453 454 fmt = NULL; 455 cache = BDRV_DEFAULT_CACHE; 456 for(;;) { 457 c = getopt(argc, argv, "f:ht:"); 458 if (c == -1) { 459 break; 460 } 461 switch(c) { 462 case '?': 463 case 'h': 464 help(); 465 break; 466 case 'f': 467 fmt = optarg; 468 break; 469 case 't': 470 cache = optarg; 471 break; 472 } 473 } 474 if (optind >= argc) { 475 help(); 476 } 477 filename = argv[optind++]; 478 479 flags = BDRV_O_RDWR; 480 ret = bdrv_parse_cache_flags(cache, &flags); 481 if (ret < 0) { 482 error_report("Invalid cache option: %s", cache); 483 return -1; 484 } 485 486 bs = bdrv_new_open(filename, fmt, flags); 487 if (!bs) { 488 return 1; 489 } 490 ret = bdrv_commit(bs); 491 switch(ret) { 492 case 0: 493 printf("Image committed.\n"); 494 break; 495 case -ENOENT: 496 error_report("No disk inserted"); 497 break; 498 case -EACCES: 499 error_report("Image is read-only"); 500 break; 501 case -ENOTSUP: 502 error_report("Image is already committed"); 503 break; 504 default: 505 error_report("Error while committing image"); 506 break; 507 } 508 509 bdrv_delete(bs); 510 if (ret) { 511 return 1; 512 } 513 return 0; 514 } 515 516 /* 517 * Checks whether the sector is not a zero sector. 518 * 519 * Attention! The len must be a multiple of 4 * sizeof(long) due to 520 * restriction of optimizations in this function. 521 */ 522 static int is_not_zero(const uint8_t *sector, int len) 523 { 524 /* 525 * Use long as the biggest available internal data type that fits into the 526 * CPU register and unroll the loop to smooth out the effect of memory 527 * latency. 528 */ 529 530 int i; 531 long d0, d1, d2, d3; 532 const long * const data = (const long *) sector; 533 534 len /= sizeof(long); 535 536 for(i = 0; i < len; i += 4) { 537 d0 = data[i + 0]; 538 d1 = data[i + 1]; 539 d2 = data[i + 2]; 540 d3 = data[i + 3]; 541 542 if (d0 || d1 || d2 || d3) { 543 return 1; 544 } 545 } 546 547 return 0; 548 } 549 550 /* 551 * Returns true iff the first sector pointed to by 'buf' contains at least 552 * a non-NUL byte. 553 * 554 * 'pnum' is set to the number of sectors (including and immediately following 555 * the first one) that are known to be in the same allocated/unallocated state. 556 */ 557 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 558 { 559 int v, i; 560 561 if (n <= 0) { 562 *pnum = 0; 563 return 0; 564 } 565 v = is_not_zero(buf, 512); 566 for(i = 1; i < n; i++) { 567 buf += 512; 568 if (v != is_not_zero(buf, 512)) 569 break; 570 } 571 *pnum = i; 572 return v; 573 } 574 575 /* 576 * Like is_allocated_sectors, but if the buffer starts with a used sector, 577 * up to 'min' consecutive sectors containing zeros are ignored. This avoids 578 * breaking up write requests for only small sparse areas. 579 */ 580 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum, 581 int min) 582 { 583 int ret; 584 int num_checked, num_used; 585 586 if (n < min) { 587 min = n; 588 } 589 590 ret = is_allocated_sectors(buf, n, pnum); 591 if (!ret) { 592 return ret; 593 } 594 595 num_used = *pnum; 596 buf += BDRV_SECTOR_SIZE * *pnum; 597 n -= *pnum; 598 num_checked = num_used; 599 600 while (n > 0) { 601 ret = is_allocated_sectors(buf, n, pnum); 602 603 buf += BDRV_SECTOR_SIZE * *pnum; 604 n -= *pnum; 605 num_checked += *pnum; 606 if (ret) { 607 num_used = num_checked; 608 } else if (*pnum >= min) { 609 break; 610 } 611 } 612 613 *pnum = num_used; 614 return 1; 615 } 616 617 /* 618 * Compares two buffers sector by sector. Returns 0 if the first sector of both 619 * buffers matches, non-zero otherwise. 620 * 621 * pnum is set to the number of sectors (including and immediately following 622 * the first one) that are known to have the same comparison result 623 */ 624 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n, 625 int *pnum) 626 { 627 int res, i; 628 629 if (n <= 0) { 630 *pnum = 0; 631 return 0; 632 } 633 634 res = !!memcmp(buf1, buf2, 512); 635 for(i = 1; i < n; i++) { 636 buf1 += 512; 637 buf2 += 512; 638 639 if (!!memcmp(buf1, buf2, 512) != res) { 640 break; 641 } 642 } 643 644 *pnum = i; 645 return res; 646 } 647 648 #define IO_BUF_SIZE (2 * 1024 * 1024) 649 650 static int img_convert(int argc, char **argv) 651 { 652 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors; 653 int progress = 0, flags; 654 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename; 655 BlockDriver *drv, *proto_drv; 656 BlockDriverState **bs = NULL, *out_bs = NULL; 657 int64_t total_sectors, nb_sectors, sector_num, bs_offset; 658 uint64_t bs_sectors; 659 uint8_t * buf = NULL; 660 const uint8_t *buf1; 661 BlockDriverInfo bdi; 662 QEMUOptionParameter *param = NULL, *create_options = NULL; 663 QEMUOptionParameter *out_baseimg_param; 664 char *options = NULL; 665 const char *snapshot_name = NULL; 666 float local_progress; 667 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */ 668 669 fmt = NULL; 670 out_fmt = "raw"; 671 cache = "unsafe"; 672 out_baseimg = NULL; 673 compress = 0; 674 for(;;) { 675 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:"); 676 if (c == -1) { 677 break; 678 } 679 switch(c) { 680 case '?': 681 case 'h': 682 help(); 683 break; 684 case 'f': 685 fmt = optarg; 686 break; 687 case 'O': 688 out_fmt = optarg; 689 break; 690 case 'B': 691 out_baseimg = optarg; 692 break; 693 case 'c': 694 compress = 1; 695 break; 696 case 'e': 697 error_report("option -e is deprecated, please use \'-o " 698 "encryption\' instead!"); 699 return 1; 700 case '6': 701 error_report("option -6 is deprecated, please use \'-o " 702 "compat6\' instead!"); 703 return 1; 704 case 'o': 705 options = optarg; 706 break; 707 case 's': 708 snapshot_name = optarg; 709 break; 710 case 'S': 711 { 712 int64_t sval; 713 sval = strtosz_suffix(optarg, NULL, STRTOSZ_DEFSUFFIX_B); 714 if (sval < 0) { 715 error_report("Invalid minimum zero buffer size for sparse output specified"); 716 return 1; 717 } 718 719 min_sparse = sval / BDRV_SECTOR_SIZE; 720 break; 721 } 722 case 'p': 723 progress = 1; 724 break; 725 case 't': 726 cache = optarg; 727 break; 728 } 729 } 730 731 bs_n = argc - optind - 1; 732 if (bs_n < 1) { 733 help(); 734 } 735 736 out_filename = argv[argc - 1]; 737 738 if (options && !strcmp(options, "?")) { 739 ret = print_block_option_help(out_filename, out_fmt); 740 goto out; 741 } 742 743 if (bs_n > 1 && out_baseimg) { 744 error_report("-B makes no sense when concatenating multiple input " 745 "images"); 746 ret = -1; 747 goto out; 748 } 749 750 qemu_progress_init(progress, 2.0); 751 qemu_progress_print(0, 100); 752 753 bs = g_malloc0(bs_n * sizeof(BlockDriverState *)); 754 755 total_sectors = 0; 756 for (bs_i = 0; bs_i < bs_n; bs_i++) { 757 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS); 758 if (!bs[bs_i]) { 759 error_report("Could not open '%s'", argv[optind + bs_i]); 760 ret = -1; 761 goto out; 762 } 763 bdrv_get_geometry(bs[bs_i], &bs_sectors); 764 total_sectors += bs_sectors; 765 } 766 767 if (snapshot_name != NULL) { 768 if (bs_n > 1) { 769 error_report("No support for concatenating multiple snapshot"); 770 ret = -1; 771 goto out; 772 } 773 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) { 774 error_report("Failed to load snapshot"); 775 ret = -1; 776 goto out; 777 } 778 } 779 780 /* Find driver and parse its options */ 781 drv = bdrv_find_format(out_fmt); 782 if (!drv) { 783 error_report("Unknown file format '%s'", out_fmt); 784 ret = -1; 785 goto out; 786 } 787 788 proto_drv = bdrv_find_protocol(out_filename); 789 if (!proto_drv) { 790 error_report("Unknown protocol '%s'", out_filename); 791 ret = -1; 792 goto out; 793 } 794 795 create_options = append_option_parameters(create_options, 796 drv->create_options); 797 create_options = append_option_parameters(create_options, 798 proto_drv->create_options); 799 800 if (options) { 801 param = parse_option_parameters(options, create_options, param); 802 if (param == NULL) { 803 error_report("Invalid options for file format '%s'.", out_fmt); 804 ret = -1; 805 goto out; 806 } 807 } else { 808 param = parse_option_parameters("", create_options, param); 809 } 810 811 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 812 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL); 813 if (ret < 0) { 814 goto out; 815 } 816 817 /* Get backing file name if -o backing_file was used */ 818 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 819 if (out_baseimg_param) { 820 out_baseimg = out_baseimg_param->value.s; 821 } 822 823 /* Check if compression is supported */ 824 if (compress) { 825 QEMUOptionParameter *encryption = 826 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 827 828 if (!drv->bdrv_write_compressed) { 829 error_report("Compression not supported for this file format"); 830 ret = -1; 831 goto out; 832 } 833 834 if (encryption && encryption->value.n) { 835 error_report("Compression and encryption not supported at " 836 "the same time"); 837 ret = -1; 838 goto out; 839 } 840 } 841 842 /* Create the new image */ 843 ret = bdrv_create(drv, out_filename, param); 844 if (ret < 0) { 845 if (ret == -ENOTSUP) { 846 error_report("Formatting not supported for file format '%s'", 847 out_fmt); 848 } else if (ret == -EFBIG) { 849 error_report("The image size is too large for file format '%s'", 850 out_fmt); 851 } else { 852 error_report("%s: error while converting %s: %s", 853 out_filename, out_fmt, strerror(-ret)); 854 } 855 goto out; 856 } 857 858 flags = BDRV_O_RDWR; 859 ret = bdrv_parse_cache_flags(cache, &flags); 860 if (ret < 0) { 861 error_report("Invalid cache option: %s", cache); 862 return -1; 863 } 864 865 out_bs = bdrv_new_open(out_filename, out_fmt, flags); 866 if (!out_bs) { 867 ret = -1; 868 goto out; 869 } 870 871 bs_i = 0; 872 bs_offset = 0; 873 bdrv_get_geometry(bs[0], &bs_sectors); 874 buf = qemu_blockalign(out_bs, IO_BUF_SIZE); 875 876 if (compress) { 877 ret = bdrv_get_info(out_bs, &bdi); 878 if (ret < 0) { 879 error_report("could not get block driver info"); 880 goto out; 881 } 882 cluster_size = bdi.cluster_size; 883 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) { 884 error_report("invalid cluster size"); 885 ret = -1; 886 goto out; 887 } 888 cluster_sectors = cluster_size >> 9; 889 sector_num = 0; 890 891 nb_sectors = total_sectors; 892 local_progress = (float)100 / 893 (nb_sectors / MIN(nb_sectors, cluster_sectors)); 894 895 for(;;) { 896 int64_t bs_num; 897 int remainder; 898 uint8_t *buf2; 899 900 nb_sectors = total_sectors - sector_num; 901 if (nb_sectors <= 0) 902 break; 903 if (nb_sectors >= cluster_sectors) 904 n = cluster_sectors; 905 else 906 n = nb_sectors; 907 908 bs_num = sector_num - bs_offset; 909 assert (bs_num >= 0); 910 remainder = n; 911 buf2 = buf; 912 while (remainder > 0) { 913 int nlow; 914 while (bs_num == bs_sectors) { 915 bs_i++; 916 assert (bs_i < bs_n); 917 bs_offset += bs_sectors; 918 bdrv_get_geometry(bs[bs_i], &bs_sectors); 919 bs_num = 0; 920 /* printf("changing part: sector_num=%" PRId64 ", " 921 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64 922 "\n", sector_num, bs_i, bs_offset, bs_sectors); */ 923 } 924 assert (bs_num < bs_sectors); 925 926 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 927 928 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow); 929 if (ret < 0) { 930 error_report("error while reading sector %" PRId64 ": %s", 931 bs_num, strerror(-ret)); 932 goto out; 933 } 934 935 buf2 += nlow * 512; 936 bs_num += nlow; 937 938 remainder -= nlow; 939 } 940 assert (remainder == 0); 941 942 if (n < cluster_sectors) { 943 memset(buf + n * 512, 0, cluster_size - n * 512); 944 } 945 if (is_not_zero(buf, cluster_size)) { 946 ret = bdrv_write_compressed(out_bs, sector_num, buf, 947 cluster_sectors); 948 if (ret != 0) { 949 error_report("error while compressing sector %" PRId64 950 ": %s", sector_num, strerror(-ret)); 951 goto out; 952 } 953 } 954 sector_num += n; 955 qemu_progress_print(local_progress, 100); 956 } 957 /* signal EOF to align */ 958 bdrv_write_compressed(out_bs, 0, NULL, 0); 959 } else { 960 int has_zero_init = bdrv_has_zero_init(out_bs); 961 962 sector_num = 0; // total number of sectors converted so far 963 nb_sectors = total_sectors - sector_num; 964 local_progress = (float)100 / 965 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512)); 966 967 for(;;) { 968 nb_sectors = total_sectors - sector_num; 969 if (nb_sectors <= 0) { 970 break; 971 } 972 if (nb_sectors >= (IO_BUF_SIZE / 512)) { 973 n = (IO_BUF_SIZE / 512); 974 } else { 975 n = nb_sectors; 976 } 977 978 while (sector_num - bs_offset >= bs_sectors) { 979 bs_i ++; 980 assert (bs_i < bs_n); 981 bs_offset += bs_sectors; 982 bdrv_get_geometry(bs[bs_i], &bs_sectors); 983 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, " 984 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n", 985 sector_num, bs_i, bs_offset, bs_sectors); */ 986 } 987 988 if (n > bs_offset + bs_sectors - sector_num) { 989 n = bs_offset + bs_sectors - sector_num; 990 } 991 992 if (has_zero_init) { 993 /* If the output image is being created as a copy on write image, 994 assume that sectors which are unallocated in the input image 995 are present in both the output's and input's base images (no 996 need to copy them). */ 997 if (out_baseimg) { 998 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 999 n, &n1)) { 1000 sector_num += n1; 1001 continue; 1002 } 1003 /* The next 'n1' sectors are allocated in the input image. Copy 1004 only those as they may be followed by unallocated sectors. */ 1005 n = n1; 1006 } 1007 } else { 1008 n1 = n; 1009 } 1010 1011 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); 1012 if (ret < 0) { 1013 error_report("error while reading sector %" PRId64 ": %s", 1014 sector_num - bs_offset, strerror(-ret)); 1015 goto out; 1016 } 1017 /* NOTE: at the same time we convert, we do not write zero 1018 sectors to have a chance to compress the image. Ideally, we 1019 should add a specific call to have the info to go faster */ 1020 buf1 = buf; 1021 while (n > 0) { 1022 /* If the output image is being created as a copy on write image, 1023 copy all sectors even the ones containing only NUL bytes, 1024 because they may differ from the sectors in the base image. 1025 1026 If the output is to a host device, we also write out 1027 sectors that are entirely 0, since whatever data was 1028 already there is garbage, not 0s. */ 1029 if (!has_zero_init || out_baseimg || 1030 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) { 1031 ret = bdrv_write(out_bs, sector_num, buf1, n1); 1032 if (ret < 0) { 1033 error_report("error while writing sector %" PRId64 1034 ": %s", sector_num, strerror(-ret)); 1035 goto out; 1036 } 1037 } 1038 sector_num += n1; 1039 n -= n1; 1040 buf1 += n1 * 512; 1041 } 1042 qemu_progress_print(local_progress, 100); 1043 } 1044 } 1045 out: 1046 qemu_progress_end(); 1047 free_option_parameters(create_options); 1048 free_option_parameters(param); 1049 qemu_vfree(buf); 1050 if (out_bs) { 1051 bdrv_delete(out_bs); 1052 } 1053 if (bs) { 1054 for (bs_i = 0; bs_i < bs_n; bs_i++) { 1055 if (bs[bs_i]) { 1056 bdrv_delete(bs[bs_i]); 1057 } 1058 } 1059 g_free(bs); 1060 } 1061 if (ret) { 1062 return 1; 1063 } 1064 return 0; 1065 } 1066 1067 1068 static void dump_snapshots(BlockDriverState *bs) 1069 { 1070 QEMUSnapshotInfo *sn_tab, *sn; 1071 int nb_sns, i; 1072 char buf[256]; 1073 1074 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 1075 if (nb_sns <= 0) 1076 return; 1077 printf("Snapshot list:\n"); 1078 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 1079 for(i = 0; i < nb_sns; i++) { 1080 sn = &sn_tab[i]; 1081 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 1082 } 1083 g_free(sn_tab); 1084 } 1085 1086 static int img_info(int argc, char **argv) 1087 { 1088 int c; 1089 const char *filename, *fmt; 1090 BlockDriverState *bs; 1091 char fmt_name[128], size_buf[128], dsize_buf[128]; 1092 uint64_t total_sectors; 1093 int64_t allocated_size; 1094 char backing_filename[1024]; 1095 char backing_filename2[1024]; 1096 BlockDriverInfo bdi; 1097 1098 fmt = NULL; 1099 for(;;) { 1100 c = getopt(argc, argv, "f:h"); 1101 if (c == -1) { 1102 break; 1103 } 1104 switch(c) { 1105 case '?': 1106 case 'h': 1107 help(); 1108 break; 1109 case 'f': 1110 fmt = optarg; 1111 break; 1112 } 1113 } 1114 if (optind >= argc) { 1115 help(); 1116 } 1117 filename = argv[optind++]; 1118 1119 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING); 1120 if (!bs) { 1121 return 1; 1122 } 1123 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 1124 bdrv_get_geometry(bs, &total_sectors); 1125 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 1126 allocated_size = bdrv_get_allocated_file_size(bs); 1127 if (allocated_size < 0) { 1128 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 1129 } else { 1130 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 1131 allocated_size); 1132 } 1133 printf("image: %s\n" 1134 "file format: %s\n" 1135 "virtual size: %s (%" PRId64 " bytes)\n" 1136 "disk size: %s\n", 1137 filename, fmt_name, size_buf, 1138 (total_sectors * 512), 1139 dsize_buf); 1140 if (bdrv_is_encrypted(bs)) { 1141 printf("encrypted: yes\n"); 1142 } 1143 if (bdrv_get_info(bs, &bdi) >= 0) { 1144 if (bdi.cluster_size != 0) { 1145 printf("cluster_size: %d\n", bdi.cluster_size); 1146 } 1147 } 1148 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 1149 if (backing_filename[0] != '\0') { 1150 path_combine(backing_filename2, sizeof(backing_filename2), 1151 filename, backing_filename); 1152 printf("backing file: %s (actual path: %s)\n", 1153 backing_filename, 1154 backing_filename2); 1155 } 1156 dump_snapshots(bs); 1157 bdrv_delete(bs); 1158 return 0; 1159 } 1160 1161 #define SNAPSHOT_LIST 1 1162 #define SNAPSHOT_CREATE 2 1163 #define SNAPSHOT_APPLY 3 1164 #define SNAPSHOT_DELETE 4 1165 1166 static int img_snapshot(int argc, char **argv) 1167 { 1168 BlockDriverState *bs; 1169 QEMUSnapshotInfo sn; 1170 char *filename, *snapshot_name = NULL; 1171 int c, ret = 0, bdrv_oflags; 1172 int action = 0; 1173 qemu_timeval tv; 1174 1175 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR; 1176 /* Parse commandline parameters */ 1177 for(;;) { 1178 c = getopt(argc, argv, "la:c:d:h"); 1179 if (c == -1) { 1180 break; 1181 } 1182 switch(c) { 1183 case '?': 1184 case 'h': 1185 help(); 1186 return 0; 1187 case 'l': 1188 if (action) { 1189 help(); 1190 return 0; 1191 } 1192 action = SNAPSHOT_LIST; 1193 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 1194 break; 1195 case 'a': 1196 if (action) { 1197 help(); 1198 return 0; 1199 } 1200 action = SNAPSHOT_APPLY; 1201 snapshot_name = optarg; 1202 break; 1203 case 'c': 1204 if (action) { 1205 help(); 1206 return 0; 1207 } 1208 action = SNAPSHOT_CREATE; 1209 snapshot_name = optarg; 1210 break; 1211 case 'd': 1212 if (action) { 1213 help(); 1214 return 0; 1215 } 1216 action = SNAPSHOT_DELETE; 1217 snapshot_name = optarg; 1218 break; 1219 } 1220 } 1221 1222 if (optind >= argc) { 1223 help(); 1224 } 1225 filename = argv[optind++]; 1226 1227 /* Open the image */ 1228 bs = bdrv_new_open(filename, NULL, bdrv_oflags); 1229 if (!bs) { 1230 return 1; 1231 } 1232 1233 /* Perform the requested action */ 1234 switch(action) { 1235 case SNAPSHOT_LIST: 1236 dump_snapshots(bs); 1237 break; 1238 1239 case SNAPSHOT_CREATE: 1240 memset(&sn, 0, sizeof(sn)); 1241 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1242 1243 qemu_gettimeofday(&tv); 1244 sn.date_sec = tv.tv_sec; 1245 sn.date_nsec = tv.tv_usec * 1000; 1246 1247 ret = bdrv_snapshot_create(bs, &sn); 1248 if (ret) { 1249 error_report("Could not create snapshot '%s': %d (%s)", 1250 snapshot_name, ret, strerror(-ret)); 1251 } 1252 break; 1253 1254 case SNAPSHOT_APPLY: 1255 ret = bdrv_snapshot_goto(bs, snapshot_name); 1256 if (ret) { 1257 error_report("Could not apply snapshot '%s': %d (%s)", 1258 snapshot_name, ret, strerror(-ret)); 1259 } 1260 break; 1261 1262 case SNAPSHOT_DELETE: 1263 ret = bdrv_snapshot_delete(bs, snapshot_name); 1264 if (ret) { 1265 error_report("Could not delete snapshot '%s': %d (%s)", 1266 snapshot_name, ret, strerror(-ret)); 1267 } 1268 break; 1269 } 1270 1271 /* Cleanup */ 1272 bdrv_delete(bs); 1273 if (ret) { 1274 return 1; 1275 } 1276 return 0; 1277 } 1278 1279 static int img_rebase(int argc, char **argv) 1280 { 1281 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL; 1282 BlockDriver *old_backing_drv, *new_backing_drv; 1283 char *filename; 1284 const char *fmt, *cache, *out_basefmt, *out_baseimg; 1285 int c, flags, ret; 1286 int unsafe = 0; 1287 int progress = 0; 1288 1289 /* Parse commandline parameters */ 1290 fmt = NULL; 1291 cache = BDRV_DEFAULT_CACHE; 1292 out_baseimg = NULL; 1293 out_basefmt = NULL; 1294 for(;;) { 1295 c = getopt(argc, argv, "uhf:F:b:pt:"); 1296 if (c == -1) { 1297 break; 1298 } 1299 switch(c) { 1300 case '?': 1301 case 'h': 1302 help(); 1303 return 0; 1304 case 'f': 1305 fmt = optarg; 1306 break; 1307 case 'F': 1308 out_basefmt = optarg; 1309 break; 1310 case 'b': 1311 out_baseimg = optarg; 1312 break; 1313 case 'u': 1314 unsafe = 1; 1315 break; 1316 case 'p': 1317 progress = 1; 1318 break; 1319 case 't': 1320 cache = optarg; 1321 break; 1322 } 1323 } 1324 1325 if ((optind >= argc) || (!unsafe && !out_baseimg)) { 1326 help(); 1327 } 1328 filename = argv[optind++]; 1329 1330 qemu_progress_init(progress, 2.0); 1331 qemu_progress_print(0, 100); 1332 1333 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 1334 ret = bdrv_parse_cache_flags(cache, &flags); 1335 if (ret < 0) { 1336 error_report("Invalid cache option: %s", cache); 1337 return -1; 1338 } 1339 1340 /* 1341 * Open the images. 1342 * 1343 * Ignore the old backing file for unsafe rebase in case we want to correct 1344 * the reference to a renamed or moved backing file. 1345 */ 1346 bs = bdrv_new_open(filename, fmt, flags); 1347 if (!bs) { 1348 return 1; 1349 } 1350 1351 /* Find the right drivers for the backing files */ 1352 old_backing_drv = NULL; 1353 new_backing_drv = NULL; 1354 1355 if (!unsafe && bs->backing_format[0] != '\0') { 1356 old_backing_drv = bdrv_find_format(bs->backing_format); 1357 if (old_backing_drv == NULL) { 1358 error_report("Invalid format name: '%s'", bs->backing_format); 1359 ret = -1; 1360 goto out; 1361 } 1362 } 1363 1364 if (out_basefmt != NULL) { 1365 new_backing_drv = bdrv_find_format(out_basefmt); 1366 if (new_backing_drv == NULL) { 1367 error_report("Invalid format name: '%s'", out_basefmt); 1368 ret = -1; 1369 goto out; 1370 } 1371 } 1372 1373 /* For safe rebasing we need to compare old and new backing file */ 1374 if (unsafe) { 1375 /* Make the compiler happy */ 1376 bs_old_backing = NULL; 1377 bs_new_backing = NULL; 1378 } else { 1379 char backing_name[1024]; 1380 1381 bs_old_backing = bdrv_new("old_backing"); 1382 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 1383 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS, 1384 old_backing_drv); 1385 if (ret) { 1386 error_report("Could not open old backing file '%s'", backing_name); 1387 goto out; 1388 } 1389 1390 bs_new_backing = bdrv_new("new_backing"); 1391 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS, 1392 new_backing_drv); 1393 if (ret) { 1394 error_report("Could not open new backing file '%s'", out_baseimg); 1395 goto out; 1396 } 1397 } 1398 1399 /* 1400 * Check each unallocated cluster in the COW file. If it is unallocated, 1401 * accesses go to the backing file. We must therefore compare this cluster 1402 * in the old and new backing file, and if they differ we need to copy it 1403 * from the old backing file into the COW file. 1404 * 1405 * If qemu-img crashes during this step, no harm is done. The content of 1406 * the image is the same as the original one at any time. 1407 */ 1408 if (!unsafe) { 1409 uint64_t num_sectors; 1410 uint64_t sector; 1411 int n; 1412 uint8_t * buf_old; 1413 uint8_t * buf_new; 1414 float local_progress; 1415 1416 buf_old = qemu_blockalign(bs, IO_BUF_SIZE); 1417 buf_new = qemu_blockalign(bs, IO_BUF_SIZE); 1418 1419 bdrv_get_geometry(bs, &num_sectors); 1420 1421 local_progress = (float)100 / 1422 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512)); 1423 for (sector = 0; sector < num_sectors; sector += n) { 1424 1425 /* How many sectors can we handle with the next read? */ 1426 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 1427 n = (IO_BUF_SIZE / 512); 1428 } else { 1429 n = num_sectors - sector; 1430 } 1431 1432 /* If the cluster is allocated, we don't need to take action */ 1433 ret = bdrv_is_allocated(bs, sector, n, &n); 1434 if (ret) { 1435 continue; 1436 } 1437 1438 /* Read old and new backing file */ 1439 ret = bdrv_read(bs_old_backing, sector, buf_old, n); 1440 if (ret < 0) { 1441 error_report("error while reading from old backing file"); 1442 goto out; 1443 } 1444 ret = bdrv_read(bs_new_backing, sector, buf_new, n); 1445 if (ret < 0) { 1446 error_report("error while reading from new backing file"); 1447 goto out; 1448 } 1449 1450 /* If they differ, we need to write to the COW file */ 1451 uint64_t written = 0; 1452 1453 while (written < n) { 1454 int pnum; 1455 1456 if (compare_sectors(buf_old + written * 512, 1457 buf_new + written * 512, n - written, &pnum)) 1458 { 1459 ret = bdrv_write(bs, sector + written, 1460 buf_old + written * 512, pnum); 1461 if (ret < 0) { 1462 error_report("Error while writing to COW image: %s", 1463 strerror(-ret)); 1464 goto out; 1465 } 1466 } 1467 1468 written += pnum; 1469 } 1470 qemu_progress_print(local_progress, 100); 1471 } 1472 1473 qemu_vfree(buf_old); 1474 qemu_vfree(buf_new); 1475 } 1476 1477 /* 1478 * Change the backing file. All clusters that are different from the old 1479 * backing file are overwritten in the COW file now, so the visible content 1480 * doesn't change when we switch the backing file. 1481 */ 1482 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 1483 if (ret == -ENOSPC) { 1484 error_report("Could not change the backing file to '%s': No " 1485 "space left in the file header", out_baseimg); 1486 } else if (ret < 0) { 1487 error_report("Could not change the backing file to '%s': %s", 1488 out_baseimg, strerror(-ret)); 1489 } 1490 1491 qemu_progress_print(100, 0); 1492 /* 1493 * TODO At this point it is possible to check if any clusters that are 1494 * allocated in the COW file are the same in the backing file. If so, they 1495 * could be dropped from the COW file. Don't do this before switching the 1496 * backing file, in case of a crash this would lead to corruption. 1497 */ 1498 out: 1499 qemu_progress_end(); 1500 /* Cleanup */ 1501 if (!unsafe) { 1502 if (bs_old_backing != NULL) { 1503 bdrv_delete(bs_old_backing); 1504 } 1505 if (bs_new_backing != NULL) { 1506 bdrv_delete(bs_new_backing); 1507 } 1508 } 1509 1510 bdrv_delete(bs); 1511 if (ret) { 1512 return 1; 1513 } 1514 return 0; 1515 } 1516 1517 static int img_resize(int argc, char **argv) 1518 { 1519 int c, ret, relative; 1520 const char *filename, *fmt, *size; 1521 int64_t n, total_size; 1522 BlockDriverState *bs = NULL; 1523 QEMUOptionParameter *param; 1524 QEMUOptionParameter resize_options[] = { 1525 { 1526 .name = BLOCK_OPT_SIZE, 1527 .type = OPT_SIZE, 1528 .help = "Virtual disk size" 1529 }, 1530 { NULL } 1531 }; 1532 1533 /* Remove size from argv manually so that negative numbers are not treated 1534 * as options by getopt. */ 1535 if (argc < 3) { 1536 help(); 1537 return 1; 1538 } 1539 1540 size = argv[--argc]; 1541 1542 /* Parse getopt arguments */ 1543 fmt = NULL; 1544 for(;;) { 1545 c = getopt(argc, argv, "f:h"); 1546 if (c == -1) { 1547 break; 1548 } 1549 switch(c) { 1550 case '?': 1551 case 'h': 1552 help(); 1553 break; 1554 case 'f': 1555 fmt = optarg; 1556 break; 1557 } 1558 } 1559 if (optind >= argc) { 1560 help(); 1561 } 1562 filename = argv[optind++]; 1563 1564 /* Choose grow, shrink, or absolute resize mode */ 1565 switch (size[0]) { 1566 case '+': 1567 relative = 1; 1568 size++; 1569 break; 1570 case '-': 1571 relative = -1; 1572 size++; 1573 break; 1574 default: 1575 relative = 0; 1576 break; 1577 } 1578 1579 /* Parse size */ 1580 param = parse_option_parameters("", resize_options, NULL); 1581 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) { 1582 /* Error message already printed when size parsing fails */ 1583 ret = -1; 1584 goto out; 1585 } 1586 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n; 1587 free_option_parameters(param); 1588 1589 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR); 1590 if (!bs) { 1591 ret = -1; 1592 goto out; 1593 } 1594 1595 if (relative) { 1596 total_size = bdrv_getlength(bs) + n * relative; 1597 } else { 1598 total_size = n; 1599 } 1600 if (total_size <= 0) { 1601 error_report("New image size must be positive"); 1602 ret = -1; 1603 goto out; 1604 } 1605 1606 ret = bdrv_truncate(bs, total_size); 1607 switch (ret) { 1608 case 0: 1609 printf("Image resized.\n"); 1610 break; 1611 case -ENOTSUP: 1612 error_report("This image format does not support resize"); 1613 break; 1614 case -EACCES: 1615 error_report("Image is read-only"); 1616 break; 1617 default: 1618 error_report("Error resizing image (%d)", -ret); 1619 break; 1620 } 1621 out: 1622 if (bs) { 1623 bdrv_delete(bs); 1624 } 1625 if (ret) { 1626 return 1; 1627 } 1628 return 0; 1629 } 1630 1631 static const img_cmd_t img_cmds[] = { 1632 #define DEF(option, callback, arg_string) \ 1633 { option, callback }, 1634 #include "qemu-img-cmds.h" 1635 #undef DEF 1636 #undef GEN_DOCS 1637 { NULL, NULL, }, 1638 }; 1639 1640 int main(int argc, char **argv) 1641 { 1642 const img_cmd_t *cmd; 1643 const char *cmdname; 1644 1645 error_set_progname(argv[0]); 1646 1647 bdrv_init(); 1648 if (argc < 2) 1649 help(); 1650 cmdname = argv[1]; 1651 argc--; argv++; 1652 1653 /* find the command */ 1654 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 1655 if (!strcmp(cmdname, cmd->name)) { 1656 return cmd->handler(argc, argv); 1657 } 1658 } 1659 1660 /* not found */ 1661 help(); 1662 return 0; 1663 } 1664