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 "qapi-visit.h" 25 #include "qapi/qmp-output-visitor.h" 26 #include "qjson.h" 27 #include "qemu-common.h" 28 #include "qemu-option.h" 29 #include "qemu-error.h" 30 #include "osdep.h" 31 #include "sysemu.h" 32 #include "block_int.h" 33 #include <getopt.h> 34 #include <stdio.h> 35 36 #ifdef _WIN32 37 #include <windows.h> 38 #endif 39 40 typedef struct img_cmd_t { 41 const char *name; 42 int (*handler)(int argc, char **argv); 43 } img_cmd_t; 44 45 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */ 46 #define BDRV_O_FLAGS BDRV_O_CACHE_WB 47 #define BDRV_DEFAULT_CACHE "writeback" 48 49 static void format_print(void *opaque, const char *name) 50 { 51 printf(" %s", name); 52 } 53 54 /* Please keep in synch with qemu-img.texi */ 55 static void help(void) 56 { 57 const char *help_msg = 58 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n" 59 "usage: qemu-img command [command options]\n" 60 "QEMU disk image utility\n" 61 "\n" 62 "Command syntax:\n" 63 #define DEF(option, callback, arg_string) \ 64 " " arg_string "\n" 65 #include "qemu-img-cmds.h" 66 #undef DEF 67 #undef GEN_DOCS 68 "\n" 69 "Command parameters:\n" 70 " 'filename' is a disk image filename\n" 71 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 72 " 'cache' is the cache mode used to write the output disk image, the valid\n" 73 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n" 74 " 'directsync' and 'unsafe' (default for convert)\n" 75 " 'size' is the disk image size in bytes. Optional suffixes\n" 76 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n" 77 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n" 78 " 'output_filename' is the destination disk image filename\n" 79 " 'output_fmt' is the destination format\n" 80 " 'options' is a comma separated list of format specific options in a\n" 81 " name=value format. Use -o ? for an overview of the options supported by the\n" 82 " used format\n" 83 " '-c' indicates that target image must be compressed (qcow format only)\n" 84 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n" 85 " match exactly. The image doesn't need a working backing file before\n" 86 " rebasing in this case (useful for renaming the backing file)\n" 87 " '-h' with or without a command shows this help and lists the supported formats\n" 88 " '-p' show progress of command (only certain commands)\n" 89 " '-S' indicates the consecutive number of bytes that must contain only zeros\n" 90 " for qemu-img to create a sparse image during conversion\n" 91 " '--output' takes the format in which the output must be done (human or json)\n" 92 "\n" 93 "Parameters to check subcommand:\n" 94 " '-r' tries to repair any inconsistencies that are found during the check.\n" 95 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n" 96 " kinds of errors, with a higher risk of choosing the wrong fix or\n" 97 " hiding corruption that has already occurred.\n" 98 "\n" 99 "Parameters to snapshot subcommand:\n" 100 " 'snapshot' is the name of the snapshot to create, apply or delete\n" 101 " '-a' applies a snapshot (revert disk to saved state)\n" 102 " '-c' creates a snapshot\n" 103 " '-d' deletes a snapshot\n" 104 " '-l' lists all snapshots in the given image\n"; 105 106 printf("%s\nSupported formats:", help_msg); 107 bdrv_iterate_format(format_print, NULL); 108 printf("\n"); 109 exit(1); 110 } 111 112 #if defined(WIN32) 113 /* XXX: put correct support for win32 */ 114 static int read_password(char *buf, int buf_size) 115 { 116 int c, i; 117 printf("Password: "); 118 fflush(stdout); 119 i = 0; 120 for(;;) { 121 c = getchar(); 122 if (c == '\n') 123 break; 124 if (i < (buf_size - 1)) 125 buf[i++] = c; 126 } 127 buf[i] = '\0'; 128 return 0; 129 } 130 131 #else 132 133 #include <termios.h> 134 135 static struct termios oldtty; 136 137 static void term_exit(void) 138 { 139 tcsetattr (0, TCSANOW, &oldtty); 140 } 141 142 static void term_init(void) 143 { 144 struct termios tty; 145 146 tcgetattr (0, &tty); 147 oldtty = tty; 148 149 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 150 |INLCR|IGNCR|ICRNL|IXON); 151 tty.c_oflag |= OPOST; 152 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 153 tty.c_cflag &= ~(CSIZE|PARENB); 154 tty.c_cflag |= CS8; 155 tty.c_cc[VMIN] = 1; 156 tty.c_cc[VTIME] = 0; 157 158 tcsetattr (0, TCSANOW, &tty); 159 160 atexit(term_exit); 161 } 162 163 static int read_password(char *buf, int buf_size) 164 { 165 uint8_t ch; 166 int i, ret; 167 168 printf("password: "); 169 fflush(stdout); 170 term_init(); 171 i = 0; 172 for(;;) { 173 ret = read(0, &ch, 1); 174 if (ret == -1) { 175 if (errno == EAGAIN || errno == EINTR) { 176 continue; 177 } else { 178 ret = -1; 179 break; 180 } 181 } else if (ret == 0) { 182 ret = -1; 183 break; 184 } else { 185 if (ch == '\r') { 186 ret = 0; 187 break; 188 } 189 if (i < (buf_size - 1)) 190 buf[i++] = ch; 191 } 192 } 193 term_exit(); 194 buf[i] = '\0'; 195 printf("\n"); 196 return ret; 197 } 198 #endif 199 200 static int print_block_option_help(const char *filename, const char *fmt) 201 { 202 BlockDriver *drv, *proto_drv; 203 QEMUOptionParameter *create_options = NULL; 204 205 /* Find driver and parse its options */ 206 drv = bdrv_find_format(fmt); 207 if (!drv) { 208 error_report("Unknown file format '%s'", fmt); 209 return 1; 210 } 211 212 proto_drv = bdrv_find_protocol(filename); 213 if (!proto_drv) { 214 error_report("Unknown protocol '%s'", filename); 215 return 1; 216 } 217 218 create_options = append_option_parameters(create_options, 219 drv->create_options); 220 create_options = append_option_parameters(create_options, 221 proto_drv->create_options); 222 print_option_help(create_options); 223 free_option_parameters(create_options); 224 return 0; 225 } 226 227 static BlockDriverState *bdrv_new_open(const char *filename, 228 const char *fmt, 229 int flags, 230 bool require_io) 231 { 232 BlockDriverState *bs; 233 BlockDriver *drv; 234 char password[256]; 235 int ret; 236 237 bs = bdrv_new("image"); 238 239 if (fmt) { 240 drv = bdrv_find_format(fmt); 241 if (!drv) { 242 error_report("Unknown file format '%s'", fmt); 243 goto fail; 244 } 245 } else { 246 drv = NULL; 247 } 248 249 ret = bdrv_open(bs, filename, flags, drv); 250 if (ret < 0) { 251 error_report("Could not open '%s': %s", filename, strerror(-ret)); 252 goto fail; 253 } 254 255 if (bdrv_is_encrypted(bs) && require_io) { 256 printf("Disk image '%s' is encrypted.\n", filename); 257 if (read_password(password, sizeof(password)) < 0) { 258 error_report("No password given"); 259 goto fail; 260 } 261 if (bdrv_set_key(bs, password) < 0) { 262 error_report("invalid password"); 263 goto fail; 264 } 265 } 266 return bs; 267 fail: 268 if (bs) { 269 bdrv_delete(bs); 270 } 271 return NULL; 272 } 273 274 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list, 275 const char *base_filename, 276 const char *base_fmt) 277 { 278 if (base_filename) { 279 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) { 280 error_report("Backing file not supported for file format '%s'", 281 fmt); 282 return -1; 283 } 284 } 285 if (base_fmt) { 286 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) { 287 error_report("Backing file format not supported for file " 288 "format '%s'", fmt); 289 return -1; 290 } 291 } 292 return 0; 293 } 294 295 static int img_create(int argc, char **argv) 296 { 297 int c, ret = 0; 298 uint64_t img_size = -1; 299 const char *fmt = "raw"; 300 const char *base_fmt = NULL; 301 const char *filename; 302 const char *base_filename = NULL; 303 char *options = NULL; 304 305 for(;;) { 306 c = getopt(argc, argv, "F:b:f:he6o:"); 307 if (c == -1) { 308 break; 309 } 310 switch(c) { 311 case '?': 312 case 'h': 313 help(); 314 break; 315 case 'F': 316 base_fmt = optarg; 317 break; 318 case 'b': 319 base_filename = optarg; 320 break; 321 case 'f': 322 fmt = optarg; 323 break; 324 case 'e': 325 error_report("option -e is deprecated, please use \'-o " 326 "encryption\' instead!"); 327 return 1; 328 case '6': 329 error_report("option -6 is deprecated, please use \'-o " 330 "compat6\' instead!"); 331 return 1; 332 case 'o': 333 options = optarg; 334 break; 335 } 336 } 337 338 /* Get the filename */ 339 if (optind >= argc) { 340 help(); 341 } 342 filename = argv[optind++]; 343 344 /* Get image size, if specified */ 345 if (optind < argc) { 346 int64_t sval; 347 char *end; 348 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B); 349 if (sval < 0 || *end) { 350 error_report("Invalid image size specified! You may use k, M, G or " 351 "T suffixes for "); 352 error_report("kilobytes, megabytes, gigabytes and terabytes."); 353 ret = -1; 354 goto out; 355 } 356 img_size = (uint64_t)sval; 357 } 358 359 if (options && is_help_option(options)) { 360 ret = print_block_option_help(filename, fmt); 361 goto out; 362 } 363 364 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt, 365 options, img_size, BDRV_O_FLAGS); 366 out: 367 if (ret) { 368 return 1; 369 } 370 return 0; 371 } 372 373 /* 374 * Checks an image for consistency. Exit codes: 375 * 376 * 0 - Check completed, image is good 377 * 1 - Check not completed because of internal errors 378 * 2 - Check completed, image is corrupted 379 * 3 - Check completed, image has leaked clusters, but is good otherwise 380 */ 381 static int img_check(int argc, char **argv) 382 { 383 int c, ret; 384 const char *filename, *fmt; 385 BlockDriverState *bs; 386 BdrvCheckResult result; 387 int fix = 0; 388 int flags = BDRV_O_FLAGS | BDRV_O_CHECK; 389 390 fmt = NULL; 391 for(;;) { 392 c = getopt(argc, argv, "f:hr:"); 393 if (c == -1) { 394 break; 395 } 396 switch(c) { 397 case '?': 398 case 'h': 399 help(); 400 break; 401 case 'f': 402 fmt = optarg; 403 break; 404 case 'r': 405 flags |= BDRV_O_RDWR; 406 407 if (!strcmp(optarg, "leaks")) { 408 fix = BDRV_FIX_LEAKS; 409 } else if (!strcmp(optarg, "all")) { 410 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS; 411 } else { 412 help(); 413 } 414 break; 415 } 416 } 417 if (optind >= argc) { 418 help(); 419 } 420 filename = argv[optind++]; 421 422 bs = bdrv_new_open(filename, fmt, flags, true); 423 if (!bs) { 424 return 1; 425 } 426 ret = bdrv_check(bs, &result, fix); 427 428 if (ret == -ENOTSUP) { 429 error_report("This image format does not support checks"); 430 bdrv_delete(bs); 431 return 1; 432 } 433 434 if (result.corruptions_fixed || result.leaks_fixed) { 435 printf("The following inconsistencies were found and repaired:\n\n" 436 " %d leaked clusters\n" 437 " %d corruptions\n\n" 438 "Double checking the fixed image now...\n", 439 result.leaks_fixed, 440 result.corruptions_fixed); 441 ret = bdrv_check(bs, &result, 0); 442 } 443 444 if (!(result.corruptions || result.leaks || result.check_errors)) { 445 printf("No errors were found on the image.\n"); 446 } else { 447 if (result.corruptions) { 448 printf("\n%d errors were found on the image.\n" 449 "Data may be corrupted, or further writes to the image " 450 "may corrupt it.\n", 451 result.corruptions); 452 } 453 454 if (result.leaks) { 455 printf("\n%d leaked clusters were found on the image.\n" 456 "This means waste of disk space, but no harm to data.\n", 457 result.leaks); 458 } 459 460 if (result.check_errors) { 461 printf("\n%d internal errors have occurred during the check.\n", 462 result.check_errors); 463 } 464 } 465 466 if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) { 467 printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n", 468 result.bfi.allocated_clusters, result.bfi.total_clusters, 469 result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters, 470 result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters); 471 } 472 473 bdrv_delete(bs); 474 475 if (ret < 0 || result.check_errors) { 476 printf("\nAn error has occurred during the check: %s\n" 477 "The check is not complete and may have missed error.\n", 478 strerror(-ret)); 479 return 1; 480 } 481 482 if (result.corruptions) { 483 return 2; 484 } else if (result.leaks) { 485 return 3; 486 } else { 487 return 0; 488 } 489 } 490 491 static int img_commit(int argc, char **argv) 492 { 493 int c, ret, flags; 494 const char *filename, *fmt, *cache; 495 BlockDriverState *bs; 496 497 fmt = NULL; 498 cache = BDRV_DEFAULT_CACHE; 499 for(;;) { 500 c = getopt(argc, argv, "f:ht:"); 501 if (c == -1) { 502 break; 503 } 504 switch(c) { 505 case '?': 506 case 'h': 507 help(); 508 break; 509 case 'f': 510 fmt = optarg; 511 break; 512 case 't': 513 cache = optarg; 514 break; 515 } 516 } 517 if (optind >= argc) { 518 help(); 519 } 520 filename = argv[optind++]; 521 522 flags = BDRV_O_RDWR; 523 ret = bdrv_parse_cache_flags(cache, &flags); 524 if (ret < 0) { 525 error_report("Invalid cache option: %s", cache); 526 return -1; 527 } 528 529 bs = bdrv_new_open(filename, fmt, flags, true); 530 if (!bs) { 531 return 1; 532 } 533 ret = bdrv_commit(bs); 534 switch(ret) { 535 case 0: 536 printf("Image committed.\n"); 537 break; 538 case -ENOENT: 539 error_report("No disk inserted"); 540 break; 541 case -EACCES: 542 error_report("Image is read-only"); 543 break; 544 case -ENOTSUP: 545 error_report("Image is already committed"); 546 break; 547 default: 548 error_report("Error while committing image"); 549 break; 550 } 551 552 bdrv_delete(bs); 553 if (ret) { 554 return 1; 555 } 556 return 0; 557 } 558 559 /* 560 * Returns true iff the first sector pointed to by 'buf' contains at least 561 * a non-NUL byte. 562 * 563 * 'pnum' is set to the number of sectors (including and immediately following 564 * the first one) that are known to be in the same allocated/unallocated state. 565 */ 566 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 567 { 568 bool is_zero; 569 int i; 570 571 if (n <= 0) { 572 *pnum = 0; 573 return 0; 574 } 575 is_zero = buffer_is_zero(buf, 512); 576 for(i = 1; i < n; i++) { 577 buf += 512; 578 if (is_zero != buffer_is_zero(buf, 512)) { 579 break; 580 } 581 } 582 *pnum = i; 583 return !is_zero; 584 } 585 586 /* 587 * Like is_allocated_sectors, but if the buffer starts with a used sector, 588 * up to 'min' consecutive sectors containing zeros are ignored. This avoids 589 * breaking up write requests for only small sparse areas. 590 */ 591 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum, 592 int min) 593 { 594 int ret; 595 int num_checked, num_used; 596 597 if (n < min) { 598 min = n; 599 } 600 601 ret = is_allocated_sectors(buf, n, pnum); 602 if (!ret) { 603 return ret; 604 } 605 606 num_used = *pnum; 607 buf += BDRV_SECTOR_SIZE * *pnum; 608 n -= *pnum; 609 num_checked = num_used; 610 611 while (n > 0) { 612 ret = is_allocated_sectors(buf, n, pnum); 613 614 buf += BDRV_SECTOR_SIZE * *pnum; 615 n -= *pnum; 616 num_checked += *pnum; 617 if (ret) { 618 num_used = num_checked; 619 } else if (*pnum >= min) { 620 break; 621 } 622 } 623 624 *pnum = num_used; 625 return 1; 626 } 627 628 /* 629 * Compares two buffers sector by sector. Returns 0 if the first sector of both 630 * buffers matches, non-zero otherwise. 631 * 632 * pnum is set to the number of sectors (including and immediately following 633 * the first one) that are known to have the same comparison result 634 */ 635 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n, 636 int *pnum) 637 { 638 int res, i; 639 640 if (n <= 0) { 641 *pnum = 0; 642 return 0; 643 } 644 645 res = !!memcmp(buf1, buf2, 512); 646 for(i = 1; i < n; i++) { 647 buf1 += 512; 648 buf2 += 512; 649 650 if (!!memcmp(buf1, buf2, 512) != res) { 651 break; 652 } 653 } 654 655 *pnum = i; 656 return res; 657 } 658 659 #define IO_BUF_SIZE (2 * 1024 * 1024) 660 661 static int img_convert(int argc, char **argv) 662 { 663 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors; 664 int progress = 0, flags; 665 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename; 666 BlockDriver *drv, *proto_drv; 667 BlockDriverState **bs = NULL, *out_bs = NULL; 668 int64_t total_sectors, nb_sectors, sector_num, bs_offset; 669 uint64_t bs_sectors; 670 uint8_t * buf = NULL; 671 const uint8_t *buf1; 672 BlockDriverInfo bdi; 673 QEMUOptionParameter *param = NULL, *create_options = NULL; 674 QEMUOptionParameter *out_baseimg_param; 675 char *options = NULL; 676 const char *snapshot_name = NULL; 677 float local_progress = 0; 678 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */ 679 680 fmt = NULL; 681 out_fmt = "raw"; 682 cache = "unsafe"; 683 out_baseimg = NULL; 684 compress = 0; 685 for(;;) { 686 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:"); 687 if (c == -1) { 688 break; 689 } 690 switch(c) { 691 case '?': 692 case 'h': 693 help(); 694 break; 695 case 'f': 696 fmt = optarg; 697 break; 698 case 'O': 699 out_fmt = optarg; 700 break; 701 case 'B': 702 out_baseimg = optarg; 703 break; 704 case 'c': 705 compress = 1; 706 break; 707 case 'e': 708 error_report("option -e is deprecated, please use \'-o " 709 "encryption\' instead!"); 710 return 1; 711 case '6': 712 error_report("option -6 is deprecated, please use \'-o " 713 "compat6\' instead!"); 714 return 1; 715 case 'o': 716 options = optarg; 717 break; 718 case 's': 719 snapshot_name = optarg; 720 break; 721 case 'S': 722 { 723 int64_t sval; 724 char *end; 725 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B); 726 if (sval < 0 || *end) { 727 error_report("Invalid minimum zero buffer size for sparse output specified"); 728 return 1; 729 } 730 731 min_sparse = sval / BDRV_SECTOR_SIZE; 732 break; 733 } 734 case 'p': 735 progress = 1; 736 break; 737 case 't': 738 cache = optarg; 739 break; 740 } 741 } 742 743 bs_n = argc - optind - 1; 744 if (bs_n < 1) { 745 help(); 746 } 747 748 out_filename = argv[argc - 1]; 749 750 /* Initialize before goto out */ 751 qemu_progress_init(progress, 2.0); 752 753 if (options && is_help_option(options)) { 754 ret = print_block_option_help(out_filename, out_fmt); 755 goto out; 756 } 757 758 if (bs_n > 1 && out_baseimg) { 759 error_report("-B makes no sense when concatenating multiple input " 760 "images"); 761 ret = -1; 762 goto out; 763 } 764 765 qemu_progress_print(0, 100); 766 767 bs = g_malloc0(bs_n * sizeof(BlockDriverState *)); 768 769 total_sectors = 0; 770 for (bs_i = 0; bs_i < bs_n; bs_i++) { 771 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true); 772 if (!bs[bs_i]) { 773 error_report("Could not open '%s'", argv[optind + bs_i]); 774 ret = -1; 775 goto out; 776 } 777 bdrv_get_geometry(bs[bs_i], &bs_sectors); 778 total_sectors += bs_sectors; 779 } 780 781 if (snapshot_name != NULL) { 782 if (bs_n > 1) { 783 error_report("No support for concatenating multiple snapshot"); 784 ret = -1; 785 goto out; 786 } 787 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) { 788 error_report("Failed to load snapshot"); 789 ret = -1; 790 goto out; 791 } 792 } 793 794 /* Find driver and parse its options */ 795 drv = bdrv_find_format(out_fmt); 796 if (!drv) { 797 error_report("Unknown file format '%s'", out_fmt); 798 ret = -1; 799 goto out; 800 } 801 802 proto_drv = bdrv_find_protocol(out_filename); 803 if (!proto_drv) { 804 error_report("Unknown protocol '%s'", out_filename); 805 ret = -1; 806 goto out; 807 } 808 809 create_options = append_option_parameters(create_options, 810 drv->create_options); 811 create_options = append_option_parameters(create_options, 812 proto_drv->create_options); 813 814 if (options) { 815 param = parse_option_parameters(options, create_options, param); 816 if (param == NULL) { 817 error_report("Invalid options for file format '%s'.", out_fmt); 818 ret = -1; 819 goto out; 820 } 821 } else { 822 param = parse_option_parameters("", create_options, param); 823 } 824 825 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 826 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL); 827 if (ret < 0) { 828 goto out; 829 } 830 831 /* Get backing file name if -o backing_file was used */ 832 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 833 if (out_baseimg_param) { 834 out_baseimg = out_baseimg_param->value.s; 835 } 836 837 /* Check if compression is supported */ 838 if (compress) { 839 QEMUOptionParameter *encryption = 840 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 841 QEMUOptionParameter *preallocation = 842 get_option_parameter(param, BLOCK_OPT_PREALLOC); 843 844 if (!drv->bdrv_write_compressed) { 845 error_report("Compression not supported for this file format"); 846 ret = -1; 847 goto out; 848 } 849 850 if (encryption && encryption->value.n) { 851 error_report("Compression and encryption not supported at " 852 "the same time"); 853 ret = -1; 854 goto out; 855 } 856 857 if (preallocation && preallocation->value.s 858 && strcmp(preallocation->value.s, "off")) 859 { 860 error_report("Compression and preallocation not supported at " 861 "the same time"); 862 ret = -1; 863 goto out; 864 } 865 } 866 867 /* Create the new image */ 868 ret = bdrv_create(drv, out_filename, param); 869 if (ret < 0) { 870 if (ret == -ENOTSUP) { 871 error_report("Formatting not supported for file format '%s'", 872 out_fmt); 873 } else if (ret == -EFBIG) { 874 error_report("The image size is too large for file format '%s'", 875 out_fmt); 876 } else { 877 error_report("%s: error while converting %s: %s", 878 out_filename, out_fmt, strerror(-ret)); 879 } 880 goto out; 881 } 882 883 flags = BDRV_O_RDWR; 884 ret = bdrv_parse_cache_flags(cache, &flags); 885 if (ret < 0) { 886 error_report("Invalid cache option: %s", cache); 887 return -1; 888 } 889 890 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true); 891 if (!out_bs) { 892 ret = -1; 893 goto out; 894 } 895 896 bs_i = 0; 897 bs_offset = 0; 898 bdrv_get_geometry(bs[0], &bs_sectors); 899 buf = qemu_blockalign(out_bs, IO_BUF_SIZE); 900 901 if (compress) { 902 ret = bdrv_get_info(out_bs, &bdi); 903 if (ret < 0) { 904 error_report("could not get block driver info"); 905 goto out; 906 } 907 cluster_size = bdi.cluster_size; 908 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) { 909 error_report("invalid cluster size"); 910 ret = -1; 911 goto out; 912 } 913 cluster_sectors = cluster_size >> 9; 914 sector_num = 0; 915 916 nb_sectors = total_sectors; 917 if (nb_sectors != 0) { 918 local_progress = (float)100 / 919 (nb_sectors / MIN(nb_sectors, cluster_sectors)); 920 } 921 922 for(;;) { 923 int64_t bs_num; 924 int remainder; 925 uint8_t *buf2; 926 927 nb_sectors = total_sectors - sector_num; 928 if (nb_sectors <= 0) 929 break; 930 if (nb_sectors >= cluster_sectors) 931 n = cluster_sectors; 932 else 933 n = nb_sectors; 934 935 bs_num = sector_num - bs_offset; 936 assert (bs_num >= 0); 937 remainder = n; 938 buf2 = buf; 939 while (remainder > 0) { 940 int nlow; 941 while (bs_num == bs_sectors) { 942 bs_i++; 943 assert (bs_i < bs_n); 944 bs_offset += bs_sectors; 945 bdrv_get_geometry(bs[bs_i], &bs_sectors); 946 bs_num = 0; 947 /* printf("changing part: sector_num=%" PRId64 ", " 948 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64 949 "\n", sector_num, bs_i, bs_offset, bs_sectors); */ 950 } 951 assert (bs_num < bs_sectors); 952 953 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 954 955 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow); 956 if (ret < 0) { 957 error_report("error while reading sector %" PRId64 ": %s", 958 bs_num, strerror(-ret)); 959 goto out; 960 } 961 962 buf2 += nlow * 512; 963 bs_num += nlow; 964 965 remainder -= nlow; 966 } 967 assert (remainder == 0); 968 969 if (n < cluster_sectors) { 970 memset(buf + n * 512, 0, cluster_size - n * 512); 971 } 972 if (!buffer_is_zero(buf, cluster_size)) { 973 ret = bdrv_write_compressed(out_bs, sector_num, buf, 974 cluster_sectors); 975 if (ret != 0) { 976 error_report("error while compressing sector %" PRId64 977 ": %s", sector_num, strerror(-ret)); 978 goto out; 979 } 980 } 981 sector_num += n; 982 qemu_progress_print(local_progress, 100); 983 } 984 /* signal EOF to align */ 985 bdrv_write_compressed(out_bs, 0, NULL, 0); 986 } else { 987 int has_zero_init = bdrv_has_zero_init(out_bs); 988 989 sector_num = 0; // total number of sectors converted so far 990 nb_sectors = total_sectors - sector_num; 991 if (nb_sectors != 0) { 992 local_progress = (float)100 / 993 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512)); 994 } 995 996 for(;;) { 997 nb_sectors = total_sectors - sector_num; 998 if (nb_sectors <= 0) { 999 break; 1000 } 1001 if (nb_sectors >= (IO_BUF_SIZE / 512)) { 1002 n = (IO_BUF_SIZE / 512); 1003 } else { 1004 n = nb_sectors; 1005 } 1006 1007 while (sector_num - bs_offset >= bs_sectors) { 1008 bs_i ++; 1009 assert (bs_i < bs_n); 1010 bs_offset += bs_sectors; 1011 bdrv_get_geometry(bs[bs_i], &bs_sectors); 1012 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, " 1013 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n", 1014 sector_num, bs_i, bs_offset, bs_sectors); */ 1015 } 1016 1017 if (n > bs_offset + bs_sectors - sector_num) { 1018 n = bs_offset + bs_sectors - sector_num; 1019 } 1020 1021 if (has_zero_init) { 1022 /* If the output image is being created as a copy on write image, 1023 assume that sectors which are unallocated in the input image 1024 are present in both the output's and input's base images (no 1025 need to copy them). */ 1026 if (out_baseimg) { 1027 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 1028 n, &n1)) { 1029 sector_num += n1; 1030 continue; 1031 } 1032 /* The next 'n1' sectors are allocated in the input image. Copy 1033 only those as they may be followed by unallocated sectors. */ 1034 n = n1; 1035 } 1036 } else { 1037 n1 = n; 1038 } 1039 1040 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); 1041 if (ret < 0) { 1042 error_report("error while reading sector %" PRId64 ": %s", 1043 sector_num - bs_offset, strerror(-ret)); 1044 goto out; 1045 } 1046 /* NOTE: at the same time we convert, we do not write zero 1047 sectors to have a chance to compress the image. Ideally, we 1048 should add a specific call to have the info to go faster */ 1049 buf1 = buf; 1050 while (n > 0) { 1051 /* If the output image is being created as a copy on write image, 1052 copy all sectors even the ones containing only NUL bytes, 1053 because they may differ from the sectors in the base image. 1054 1055 If the output is to a host device, we also write out 1056 sectors that are entirely 0, since whatever data was 1057 already there is garbage, not 0s. */ 1058 if (!has_zero_init || out_baseimg || 1059 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) { 1060 ret = bdrv_write(out_bs, sector_num, buf1, n1); 1061 if (ret < 0) { 1062 error_report("error while writing sector %" PRId64 1063 ": %s", sector_num, strerror(-ret)); 1064 goto out; 1065 } 1066 } 1067 sector_num += n1; 1068 n -= n1; 1069 buf1 += n1 * 512; 1070 } 1071 qemu_progress_print(local_progress, 100); 1072 } 1073 } 1074 out: 1075 qemu_progress_end(); 1076 free_option_parameters(create_options); 1077 free_option_parameters(param); 1078 qemu_vfree(buf); 1079 if (out_bs) { 1080 bdrv_delete(out_bs); 1081 } 1082 if (bs) { 1083 for (bs_i = 0; bs_i < bs_n; bs_i++) { 1084 if (bs[bs_i]) { 1085 bdrv_delete(bs[bs_i]); 1086 } 1087 } 1088 g_free(bs); 1089 } 1090 if (ret) { 1091 return 1; 1092 } 1093 return 0; 1094 } 1095 1096 1097 static void dump_snapshots(BlockDriverState *bs) 1098 { 1099 QEMUSnapshotInfo *sn_tab, *sn; 1100 int nb_sns, i; 1101 char buf[256]; 1102 1103 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 1104 if (nb_sns <= 0) 1105 return; 1106 printf("Snapshot list:\n"); 1107 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 1108 for(i = 0; i < nb_sns; i++) { 1109 sn = &sn_tab[i]; 1110 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 1111 } 1112 g_free(sn_tab); 1113 } 1114 1115 static void dump_json_image_info_list(ImageInfoList *list) 1116 { 1117 Error *errp = NULL; 1118 QString *str; 1119 QmpOutputVisitor *ov = qmp_output_visitor_new(); 1120 QObject *obj; 1121 visit_type_ImageInfoList(qmp_output_get_visitor(ov), 1122 &list, NULL, &errp); 1123 obj = qmp_output_get_qobject(ov); 1124 str = qobject_to_json_pretty(obj); 1125 assert(str != NULL); 1126 printf("%s\n", qstring_get_str(str)); 1127 qobject_decref(obj); 1128 qmp_output_visitor_cleanup(ov); 1129 QDECREF(str); 1130 } 1131 1132 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info) 1133 { 1134 int i, sn_count; 1135 QEMUSnapshotInfo *sn_tab = NULL; 1136 SnapshotInfoList *info_list, *cur_item = NULL; 1137 sn_count = bdrv_snapshot_list(bs, &sn_tab); 1138 1139 for (i = 0; i < sn_count; i++) { 1140 info->has_snapshots = true; 1141 info_list = g_new0(SnapshotInfoList, 1); 1142 1143 info_list->value = g_new0(SnapshotInfo, 1); 1144 info_list->value->id = g_strdup(sn_tab[i].id_str); 1145 info_list->value->name = g_strdup(sn_tab[i].name); 1146 info_list->value->vm_state_size = sn_tab[i].vm_state_size; 1147 info_list->value->date_sec = sn_tab[i].date_sec; 1148 info_list->value->date_nsec = sn_tab[i].date_nsec; 1149 info_list->value->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000; 1150 info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000; 1151 1152 /* XXX: waiting for the qapi to support qemu-queue.h types */ 1153 if (!cur_item) { 1154 info->snapshots = cur_item = info_list; 1155 } else { 1156 cur_item->next = info_list; 1157 cur_item = info_list; 1158 } 1159 1160 } 1161 1162 g_free(sn_tab); 1163 } 1164 1165 static void dump_json_image_info(ImageInfo *info) 1166 { 1167 Error *errp = NULL; 1168 QString *str; 1169 QmpOutputVisitor *ov = qmp_output_visitor_new(); 1170 QObject *obj; 1171 visit_type_ImageInfo(qmp_output_get_visitor(ov), 1172 &info, NULL, &errp); 1173 obj = qmp_output_get_qobject(ov); 1174 str = qobject_to_json_pretty(obj); 1175 assert(str != NULL); 1176 printf("%s\n", qstring_get_str(str)); 1177 qobject_decref(obj); 1178 qmp_output_visitor_cleanup(ov); 1179 QDECREF(str); 1180 } 1181 1182 static void collect_image_info(BlockDriverState *bs, 1183 ImageInfo *info, 1184 const char *filename, 1185 const char *fmt) 1186 { 1187 uint64_t total_sectors; 1188 char backing_filename[1024]; 1189 char backing_filename2[1024]; 1190 BlockDriverInfo bdi; 1191 1192 bdrv_get_geometry(bs, &total_sectors); 1193 1194 info->filename = g_strdup(filename); 1195 info->format = g_strdup(bdrv_get_format_name(bs)); 1196 info->virtual_size = total_sectors * 512; 1197 info->actual_size = bdrv_get_allocated_file_size(bs); 1198 info->has_actual_size = info->actual_size >= 0; 1199 if (bdrv_is_encrypted(bs)) { 1200 info->encrypted = true; 1201 info->has_encrypted = true; 1202 } 1203 if (bdrv_get_info(bs, &bdi) >= 0) { 1204 if (bdi.cluster_size != 0) { 1205 info->cluster_size = bdi.cluster_size; 1206 info->has_cluster_size = true; 1207 } 1208 info->dirty_flag = bdi.is_dirty; 1209 info->has_dirty_flag = true; 1210 } 1211 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 1212 if (backing_filename[0] != '\0') { 1213 info->backing_filename = g_strdup(backing_filename); 1214 info->has_backing_filename = true; 1215 bdrv_get_full_backing_filename(bs, backing_filename2, 1216 sizeof(backing_filename2)); 1217 1218 if (strcmp(backing_filename, backing_filename2) != 0) { 1219 info->full_backing_filename = 1220 g_strdup(backing_filename2); 1221 info->has_full_backing_filename = true; 1222 } 1223 1224 if (bs->backing_format[0]) { 1225 info->backing_filename_format = g_strdup(bs->backing_format); 1226 info->has_backing_filename_format = true; 1227 } 1228 } 1229 } 1230 1231 static void dump_human_image_info(ImageInfo *info) 1232 { 1233 char size_buf[128], dsize_buf[128]; 1234 if (!info->has_actual_size) { 1235 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 1236 } else { 1237 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 1238 info->actual_size); 1239 } 1240 get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); 1241 printf("image: %s\n" 1242 "file format: %s\n" 1243 "virtual size: %s (%" PRId64 " bytes)\n" 1244 "disk size: %s\n", 1245 info->filename, info->format, size_buf, 1246 info->virtual_size, 1247 dsize_buf); 1248 1249 if (info->has_encrypted && info->encrypted) { 1250 printf("encrypted: yes\n"); 1251 } 1252 1253 if (info->has_cluster_size) { 1254 printf("cluster_size: %" PRId64 "\n", info->cluster_size); 1255 } 1256 1257 if (info->has_dirty_flag && info->dirty_flag) { 1258 printf("cleanly shut down: no\n"); 1259 } 1260 1261 if (info->has_backing_filename) { 1262 printf("backing file: %s", info->backing_filename); 1263 if (info->has_full_backing_filename) { 1264 printf(" (actual path: %s)", info->full_backing_filename); 1265 } 1266 putchar('\n'); 1267 if (info->has_backing_filename_format) { 1268 printf("backing file format: %s\n", info->backing_filename_format); 1269 } 1270 } 1271 1272 if (info->has_snapshots) { 1273 SnapshotInfoList *elem; 1274 char buf[256]; 1275 1276 printf("Snapshot list:\n"); 1277 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 1278 1279 /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but 1280 * we convert to the block layer's native QEMUSnapshotInfo for now. 1281 */ 1282 for (elem = info->snapshots; elem; elem = elem->next) { 1283 QEMUSnapshotInfo sn = { 1284 .vm_state_size = elem->value->vm_state_size, 1285 .date_sec = elem->value->date_sec, 1286 .date_nsec = elem->value->date_nsec, 1287 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL + 1288 elem->value->vm_clock_nsec, 1289 }; 1290 1291 pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id); 1292 pstrcpy(sn.name, sizeof(sn.name), elem->value->name); 1293 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn)); 1294 } 1295 } 1296 } 1297 1298 static void dump_human_image_info_list(ImageInfoList *list) 1299 { 1300 ImageInfoList *elem; 1301 bool delim = false; 1302 1303 for (elem = list; elem; elem = elem->next) { 1304 if (delim) { 1305 printf("\n"); 1306 } 1307 delim = true; 1308 1309 dump_human_image_info(elem->value); 1310 } 1311 } 1312 1313 static gboolean str_equal_func(gconstpointer a, gconstpointer b) 1314 { 1315 return strcmp(a, b) == 0; 1316 } 1317 1318 /** 1319 * Open an image file chain and return an ImageInfoList 1320 * 1321 * @filename: topmost image filename 1322 * @fmt: topmost image format (may be NULL to autodetect) 1323 * @chain: true - enumerate entire backing file chain 1324 * false - only topmost image file 1325 * 1326 * Returns a list of ImageInfo objects or NULL if there was an error opening an 1327 * image file. If there was an error a message will have been printed to 1328 * stderr. 1329 */ 1330 static ImageInfoList *collect_image_info_list(const char *filename, 1331 const char *fmt, 1332 bool chain) 1333 { 1334 ImageInfoList *head = NULL; 1335 ImageInfoList **last = &head; 1336 GHashTable *filenames; 1337 1338 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL); 1339 1340 while (filename) { 1341 BlockDriverState *bs; 1342 ImageInfo *info; 1343 ImageInfoList *elem; 1344 1345 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) { 1346 error_report("Backing file '%s' creates an infinite loop.", 1347 filename); 1348 goto err; 1349 } 1350 g_hash_table_insert(filenames, (gpointer)filename, NULL); 1351 1352 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING, 1353 false); 1354 if (!bs) { 1355 goto err; 1356 } 1357 1358 info = g_new0(ImageInfo, 1); 1359 collect_image_info(bs, info, filename, fmt); 1360 collect_snapshots(bs, info); 1361 1362 elem = g_new0(ImageInfoList, 1); 1363 elem->value = info; 1364 *last = elem; 1365 last = &elem->next; 1366 1367 bdrv_delete(bs); 1368 1369 filename = fmt = NULL; 1370 if (chain) { 1371 if (info->has_full_backing_filename) { 1372 filename = info->full_backing_filename; 1373 } else if (info->has_backing_filename) { 1374 filename = info->backing_filename; 1375 } 1376 if (info->has_backing_filename_format) { 1377 fmt = info->backing_filename_format; 1378 } 1379 } 1380 } 1381 g_hash_table_destroy(filenames); 1382 return head; 1383 1384 err: 1385 qapi_free_ImageInfoList(head); 1386 g_hash_table_destroy(filenames); 1387 return NULL; 1388 } 1389 1390 enum { 1391 OPTION_OUTPUT = 256, 1392 OPTION_BACKING_CHAIN = 257, 1393 }; 1394 1395 typedef enum OutputFormat { 1396 OFORMAT_JSON, 1397 OFORMAT_HUMAN, 1398 } OutputFormat; 1399 1400 static int img_info(int argc, char **argv) 1401 { 1402 int c; 1403 OutputFormat output_format = OFORMAT_HUMAN; 1404 bool chain = false; 1405 const char *filename, *fmt, *output; 1406 ImageInfoList *list; 1407 1408 fmt = NULL; 1409 output = NULL; 1410 for(;;) { 1411 int option_index = 0; 1412 static const struct option long_options[] = { 1413 {"help", no_argument, 0, 'h'}, 1414 {"format", required_argument, 0, 'f'}, 1415 {"output", required_argument, 0, OPTION_OUTPUT}, 1416 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN}, 1417 {0, 0, 0, 0} 1418 }; 1419 c = getopt_long(argc, argv, "f:h", 1420 long_options, &option_index); 1421 if (c == -1) { 1422 break; 1423 } 1424 switch(c) { 1425 case '?': 1426 case 'h': 1427 help(); 1428 break; 1429 case 'f': 1430 fmt = optarg; 1431 break; 1432 case OPTION_OUTPUT: 1433 output = optarg; 1434 break; 1435 case OPTION_BACKING_CHAIN: 1436 chain = true; 1437 break; 1438 } 1439 } 1440 if (optind >= argc) { 1441 help(); 1442 } 1443 filename = argv[optind++]; 1444 1445 if (output && !strcmp(output, "json")) { 1446 output_format = OFORMAT_JSON; 1447 } else if (output && !strcmp(output, "human")) { 1448 output_format = OFORMAT_HUMAN; 1449 } else if (output) { 1450 error_report("--output must be used with human or json as argument."); 1451 return 1; 1452 } 1453 1454 list = collect_image_info_list(filename, fmt, chain); 1455 if (!list) { 1456 return 1; 1457 } 1458 1459 switch (output_format) { 1460 case OFORMAT_HUMAN: 1461 dump_human_image_info_list(list); 1462 break; 1463 case OFORMAT_JSON: 1464 if (chain) { 1465 dump_json_image_info_list(list); 1466 } else { 1467 dump_json_image_info(list->value); 1468 } 1469 break; 1470 } 1471 1472 qapi_free_ImageInfoList(list); 1473 return 0; 1474 } 1475 1476 #define SNAPSHOT_LIST 1 1477 #define SNAPSHOT_CREATE 2 1478 #define SNAPSHOT_APPLY 3 1479 #define SNAPSHOT_DELETE 4 1480 1481 static int img_snapshot(int argc, char **argv) 1482 { 1483 BlockDriverState *bs; 1484 QEMUSnapshotInfo sn; 1485 char *filename, *snapshot_name = NULL; 1486 int c, ret = 0, bdrv_oflags; 1487 int action = 0; 1488 qemu_timeval tv; 1489 1490 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR; 1491 /* Parse commandline parameters */ 1492 for(;;) { 1493 c = getopt(argc, argv, "la:c:d:h"); 1494 if (c == -1) { 1495 break; 1496 } 1497 switch(c) { 1498 case '?': 1499 case 'h': 1500 help(); 1501 return 0; 1502 case 'l': 1503 if (action) { 1504 help(); 1505 return 0; 1506 } 1507 action = SNAPSHOT_LIST; 1508 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 1509 break; 1510 case 'a': 1511 if (action) { 1512 help(); 1513 return 0; 1514 } 1515 action = SNAPSHOT_APPLY; 1516 snapshot_name = optarg; 1517 break; 1518 case 'c': 1519 if (action) { 1520 help(); 1521 return 0; 1522 } 1523 action = SNAPSHOT_CREATE; 1524 snapshot_name = optarg; 1525 break; 1526 case 'd': 1527 if (action) { 1528 help(); 1529 return 0; 1530 } 1531 action = SNAPSHOT_DELETE; 1532 snapshot_name = optarg; 1533 break; 1534 } 1535 } 1536 1537 if (optind >= argc) { 1538 help(); 1539 } 1540 filename = argv[optind++]; 1541 1542 /* Open the image */ 1543 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true); 1544 if (!bs) { 1545 return 1; 1546 } 1547 1548 /* Perform the requested action */ 1549 switch(action) { 1550 case SNAPSHOT_LIST: 1551 dump_snapshots(bs); 1552 break; 1553 1554 case SNAPSHOT_CREATE: 1555 memset(&sn, 0, sizeof(sn)); 1556 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1557 1558 qemu_gettimeofday(&tv); 1559 sn.date_sec = tv.tv_sec; 1560 sn.date_nsec = tv.tv_usec * 1000; 1561 1562 ret = bdrv_snapshot_create(bs, &sn); 1563 if (ret) { 1564 error_report("Could not create snapshot '%s': %d (%s)", 1565 snapshot_name, ret, strerror(-ret)); 1566 } 1567 break; 1568 1569 case SNAPSHOT_APPLY: 1570 ret = bdrv_snapshot_goto(bs, snapshot_name); 1571 if (ret) { 1572 error_report("Could not apply snapshot '%s': %d (%s)", 1573 snapshot_name, ret, strerror(-ret)); 1574 } 1575 break; 1576 1577 case SNAPSHOT_DELETE: 1578 ret = bdrv_snapshot_delete(bs, snapshot_name); 1579 if (ret) { 1580 error_report("Could not delete snapshot '%s': %d (%s)", 1581 snapshot_name, ret, strerror(-ret)); 1582 } 1583 break; 1584 } 1585 1586 /* Cleanup */ 1587 bdrv_delete(bs); 1588 if (ret) { 1589 return 1; 1590 } 1591 return 0; 1592 } 1593 1594 static int img_rebase(int argc, char **argv) 1595 { 1596 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL; 1597 BlockDriver *old_backing_drv, *new_backing_drv; 1598 char *filename; 1599 const char *fmt, *cache, *out_basefmt, *out_baseimg; 1600 int c, flags, ret; 1601 int unsafe = 0; 1602 int progress = 0; 1603 1604 /* Parse commandline parameters */ 1605 fmt = NULL; 1606 cache = BDRV_DEFAULT_CACHE; 1607 out_baseimg = NULL; 1608 out_basefmt = NULL; 1609 for(;;) { 1610 c = getopt(argc, argv, "uhf:F:b:pt:"); 1611 if (c == -1) { 1612 break; 1613 } 1614 switch(c) { 1615 case '?': 1616 case 'h': 1617 help(); 1618 return 0; 1619 case 'f': 1620 fmt = optarg; 1621 break; 1622 case 'F': 1623 out_basefmt = optarg; 1624 break; 1625 case 'b': 1626 out_baseimg = optarg; 1627 break; 1628 case 'u': 1629 unsafe = 1; 1630 break; 1631 case 'p': 1632 progress = 1; 1633 break; 1634 case 't': 1635 cache = optarg; 1636 break; 1637 } 1638 } 1639 1640 if ((optind >= argc) || (!unsafe && !out_baseimg)) { 1641 help(); 1642 } 1643 filename = argv[optind++]; 1644 1645 qemu_progress_init(progress, 2.0); 1646 qemu_progress_print(0, 100); 1647 1648 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 1649 ret = bdrv_parse_cache_flags(cache, &flags); 1650 if (ret < 0) { 1651 error_report("Invalid cache option: %s", cache); 1652 return -1; 1653 } 1654 1655 /* 1656 * Open the images. 1657 * 1658 * Ignore the old backing file for unsafe rebase in case we want to correct 1659 * the reference to a renamed or moved backing file. 1660 */ 1661 bs = bdrv_new_open(filename, fmt, flags, true); 1662 if (!bs) { 1663 return 1; 1664 } 1665 1666 /* Find the right drivers for the backing files */ 1667 old_backing_drv = NULL; 1668 new_backing_drv = NULL; 1669 1670 if (!unsafe && bs->backing_format[0] != '\0') { 1671 old_backing_drv = bdrv_find_format(bs->backing_format); 1672 if (old_backing_drv == NULL) { 1673 error_report("Invalid format name: '%s'", bs->backing_format); 1674 ret = -1; 1675 goto out; 1676 } 1677 } 1678 1679 if (out_basefmt != NULL) { 1680 new_backing_drv = bdrv_find_format(out_basefmt); 1681 if (new_backing_drv == NULL) { 1682 error_report("Invalid format name: '%s'", out_basefmt); 1683 ret = -1; 1684 goto out; 1685 } 1686 } 1687 1688 /* For safe rebasing we need to compare old and new backing file */ 1689 if (unsafe) { 1690 /* Make the compiler happy */ 1691 bs_old_backing = NULL; 1692 bs_new_backing = NULL; 1693 } else { 1694 char backing_name[1024]; 1695 1696 bs_old_backing = bdrv_new("old_backing"); 1697 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 1698 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS, 1699 old_backing_drv); 1700 if (ret) { 1701 error_report("Could not open old backing file '%s'", backing_name); 1702 goto out; 1703 } 1704 if (out_baseimg[0]) { 1705 bs_new_backing = bdrv_new("new_backing"); 1706 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS, 1707 new_backing_drv); 1708 if (ret) { 1709 error_report("Could not open new backing file '%s'", 1710 out_baseimg); 1711 goto out; 1712 } 1713 } 1714 } 1715 1716 /* 1717 * Check each unallocated cluster in the COW file. If it is unallocated, 1718 * accesses go to the backing file. We must therefore compare this cluster 1719 * in the old and new backing file, and if they differ we need to copy it 1720 * from the old backing file into the COW file. 1721 * 1722 * If qemu-img crashes during this step, no harm is done. The content of 1723 * the image is the same as the original one at any time. 1724 */ 1725 if (!unsafe) { 1726 uint64_t num_sectors; 1727 uint64_t old_backing_num_sectors; 1728 uint64_t new_backing_num_sectors = 0; 1729 uint64_t sector; 1730 int n; 1731 uint8_t * buf_old; 1732 uint8_t * buf_new; 1733 float local_progress = 0; 1734 1735 buf_old = qemu_blockalign(bs, IO_BUF_SIZE); 1736 buf_new = qemu_blockalign(bs, IO_BUF_SIZE); 1737 1738 bdrv_get_geometry(bs, &num_sectors); 1739 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors); 1740 if (bs_new_backing) { 1741 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors); 1742 } 1743 1744 if (num_sectors != 0) { 1745 local_progress = (float)100 / 1746 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512)); 1747 } 1748 1749 for (sector = 0; sector < num_sectors; sector += n) { 1750 1751 /* How many sectors can we handle with the next read? */ 1752 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 1753 n = (IO_BUF_SIZE / 512); 1754 } else { 1755 n = num_sectors - sector; 1756 } 1757 1758 /* If the cluster is allocated, we don't need to take action */ 1759 ret = bdrv_is_allocated(bs, sector, n, &n); 1760 if (ret) { 1761 continue; 1762 } 1763 1764 /* 1765 * Read old and new backing file and take into consideration that 1766 * backing files may be smaller than the COW image. 1767 */ 1768 if (sector >= old_backing_num_sectors) { 1769 memset(buf_old, 0, n * BDRV_SECTOR_SIZE); 1770 } else { 1771 if (sector + n > old_backing_num_sectors) { 1772 n = old_backing_num_sectors - sector; 1773 } 1774 1775 ret = bdrv_read(bs_old_backing, sector, buf_old, n); 1776 if (ret < 0) { 1777 error_report("error while reading from old backing file"); 1778 goto out; 1779 } 1780 } 1781 1782 if (sector >= new_backing_num_sectors || !bs_new_backing) { 1783 memset(buf_new, 0, n * BDRV_SECTOR_SIZE); 1784 } else { 1785 if (sector + n > new_backing_num_sectors) { 1786 n = new_backing_num_sectors - sector; 1787 } 1788 1789 ret = bdrv_read(bs_new_backing, sector, buf_new, n); 1790 if (ret < 0) { 1791 error_report("error while reading from new backing file"); 1792 goto out; 1793 } 1794 } 1795 1796 /* If they differ, we need to write to the COW file */ 1797 uint64_t written = 0; 1798 1799 while (written < n) { 1800 int pnum; 1801 1802 if (compare_sectors(buf_old + written * 512, 1803 buf_new + written * 512, n - written, &pnum)) 1804 { 1805 ret = bdrv_write(bs, sector + written, 1806 buf_old + written * 512, pnum); 1807 if (ret < 0) { 1808 error_report("Error while writing to COW image: %s", 1809 strerror(-ret)); 1810 goto out; 1811 } 1812 } 1813 1814 written += pnum; 1815 } 1816 qemu_progress_print(local_progress, 100); 1817 } 1818 1819 qemu_vfree(buf_old); 1820 qemu_vfree(buf_new); 1821 } 1822 1823 /* 1824 * Change the backing file. All clusters that are different from the old 1825 * backing file are overwritten in the COW file now, so the visible content 1826 * doesn't change when we switch the backing file. 1827 */ 1828 if (out_baseimg && *out_baseimg) { 1829 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 1830 } else { 1831 ret = bdrv_change_backing_file(bs, NULL, NULL); 1832 } 1833 1834 if (ret == -ENOSPC) { 1835 error_report("Could not change the backing file to '%s': No " 1836 "space left in the file header", out_baseimg); 1837 } else if (ret < 0) { 1838 error_report("Could not change the backing file to '%s': %s", 1839 out_baseimg, strerror(-ret)); 1840 } 1841 1842 qemu_progress_print(100, 0); 1843 /* 1844 * TODO At this point it is possible to check if any clusters that are 1845 * allocated in the COW file are the same in the backing file. If so, they 1846 * could be dropped from the COW file. Don't do this before switching the 1847 * backing file, in case of a crash this would lead to corruption. 1848 */ 1849 out: 1850 qemu_progress_end(); 1851 /* Cleanup */ 1852 if (!unsafe) { 1853 if (bs_old_backing != NULL) { 1854 bdrv_delete(bs_old_backing); 1855 } 1856 if (bs_new_backing != NULL) { 1857 bdrv_delete(bs_new_backing); 1858 } 1859 } 1860 1861 bdrv_delete(bs); 1862 if (ret) { 1863 return 1; 1864 } 1865 return 0; 1866 } 1867 1868 static int img_resize(int argc, char **argv) 1869 { 1870 int c, ret, relative; 1871 const char *filename, *fmt, *size; 1872 int64_t n, total_size; 1873 BlockDriverState *bs = NULL; 1874 QemuOpts *param; 1875 static QemuOptsList resize_options = { 1876 .name = "resize_options", 1877 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head), 1878 .desc = { 1879 { 1880 .name = BLOCK_OPT_SIZE, 1881 .type = QEMU_OPT_SIZE, 1882 .help = "Virtual disk size" 1883 }, { 1884 /* end of list */ 1885 } 1886 }, 1887 }; 1888 1889 /* Remove size from argv manually so that negative numbers are not treated 1890 * as options by getopt. */ 1891 if (argc < 3) { 1892 help(); 1893 return 1; 1894 } 1895 1896 size = argv[--argc]; 1897 1898 /* Parse getopt arguments */ 1899 fmt = NULL; 1900 for(;;) { 1901 c = getopt(argc, argv, "f:h"); 1902 if (c == -1) { 1903 break; 1904 } 1905 switch(c) { 1906 case '?': 1907 case 'h': 1908 help(); 1909 break; 1910 case 'f': 1911 fmt = optarg; 1912 break; 1913 } 1914 } 1915 if (optind >= argc) { 1916 help(); 1917 } 1918 filename = argv[optind++]; 1919 1920 /* Choose grow, shrink, or absolute resize mode */ 1921 switch (size[0]) { 1922 case '+': 1923 relative = 1; 1924 size++; 1925 break; 1926 case '-': 1927 relative = -1; 1928 size++; 1929 break; 1930 default: 1931 relative = 0; 1932 break; 1933 } 1934 1935 /* Parse size */ 1936 param = qemu_opts_create(&resize_options, NULL, 0, NULL); 1937 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) { 1938 /* Error message already printed when size parsing fails */ 1939 ret = -1; 1940 qemu_opts_del(param); 1941 goto out; 1942 } 1943 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); 1944 qemu_opts_del(param); 1945 1946 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true); 1947 if (!bs) { 1948 ret = -1; 1949 goto out; 1950 } 1951 1952 if (relative) { 1953 total_size = bdrv_getlength(bs) + n * relative; 1954 } else { 1955 total_size = n; 1956 } 1957 if (total_size <= 0) { 1958 error_report("New image size must be positive"); 1959 ret = -1; 1960 goto out; 1961 } 1962 1963 ret = bdrv_truncate(bs, total_size); 1964 switch (ret) { 1965 case 0: 1966 printf("Image resized.\n"); 1967 break; 1968 case -ENOTSUP: 1969 error_report("This image does not support resize"); 1970 break; 1971 case -EACCES: 1972 error_report("Image is read-only"); 1973 break; 1974 default: 1975 error_report("Error resizing image (%d)", -ret); 1976 break; 1977 } 1978 out: 1979 if (bs) { 1980 bdrv_delete(bs); 1981 } 1982 if (ret) { 1983 return 1; 1984 } 1985 return 0; 1986 } 1987 1988 static const img_cmd_t img_cmds[] = { 1989 #define DEF(option, callback, arg_string) \ 1990 { option, callback }, 1991 #include "qemu-img-cmds.h" 1992 #undef DEF 1993 #undef GEN_DOCS 1994 { NULL, NULL, }, 1995 }; 1996 1997 int main(int argc, char **argv) 1998 { 1999 const img_cmd_t *cmd; 2000 const char *cmdname; 2001 2002 error_set_progname(argv[0]); 2003 2004 qemu_init_main_loop(); 2005 bdrv_init(); 2006 if (argc < 2) 2007 help(); 2008 cmdname = argv[1]; 2009 argc--; argv++; 2010 2011 /* find the command */ 2012 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 2013 if (!strcmp(cmdname, cmd->name)) { 2014 return cmd->handler(argc, argv); 2015 } 2016 } 2017 2018 /* not found */ 2019 help(); 2020 return 0; 2021 } 2022