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