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