1 /* 2 * QEMU disk image utility 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu-common.h" 25 #include "qemu-option.h" 26 #include "osdep.h" 27 #include "block_int.h" 28 #include <stdio.h> 29 30 #ifdef _WIN32 31 #include <windows.h> 32 #endif 33 34 typedef struct img_cmd_t { 35 const char *name; 36 int (*handler)(int argc, char **argv); 37 } img_cmd_t; 38 39 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */ 40 #define BRDV_O_FLAGS BDRV_O_CACHE_WB 41 42 static void QEMU_NORETURN error(const char *fmt, ...) 43 { 44 va_list ap; 45 va_start(ap, fmt); 46 fprintf(stderr, "qemu-img: "); 47 vfprintf(stderr, fmt, ap); 48 fprintf(stderr, "\n"); 49 exit(1); 50 va_end(ap); 51 } 52 53 static void format_print(void *opaque, const char *name) 54 { 55 printf(" %s", name); 56 } 57 58 /* Please keep in synch with qemu-img.texi */ 59 static void help(void) 60 { 61 printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n" 62 "usage: qemu-img command [command options]\n" 63 "QEMU disk image utility\n" 64 "\n" 65 "Command syntax:\n" 66 #define DEF(option, callback, arg_string) \ 67 " " arg_string "\n" 68 #include "qemu-img-cmds.h" 69 #undef DEF 70 #undef GEN_DOCS 71 "\n" 72 "Command parameters:\n" 73 " 'filename' is a disk image filename\n" 74 " 'fmt' is the disk image format. It is guessed automatically in most cases\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 " '-h' with or without a command shows this help and lists the supported formats\n" 85 "\n" 86 "Parameters to snapshot subcommand:\n" 87 " 'snapshot' is the name of the snapshot to create, apply or delete\n" 88 " '-a' applies a snapshot (revert disk to saved state)\n" 89 " '-c' creates a snapshot\n" 90 " '-d' deletes a snapshot\n" 91 " '-l' lists all snapshots in the given image\n" 92 ); 93 printf("\nSupported formats:"); 94 bdrv_iterate_format(format_print, NULL); 95 printf("\n"); 96 exit(1); 97 } 98 99 #if defined(WIN32) 100 /* XXX: put correct support for win32 */ 101 static int read_password(char *buf, int buf_size) 102 { 103 int c, i; 104 printf("Password: "); 105 fflush(stdout); 106 i = 0; 107 for(;;) { 108 c = getchar(); 109 if (c == '\n') 110 break; 111 if (i < (buf_size - 1)) 112 buf[i++] = c; 113 } 114 buf[i] = '\0'; 115 return 0; 116 } 117 118 #else 119 120 #include <termios.h> 121 122 static struct termios oldtty; 123 124 static void term_exit(void) 125 { 126 tcsetattr (0, TCSANOW, &oldtty); 127 } 128 129 static void term_init(void) 130 { 131 struct termios tty; 132 133 tcgetattr (0, &tty); 134 oldtty = tty; 135 136 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 137 |INLCR|IGNCR|ICRNL|IXON); 138 tty.c_oflag |= OPOST; 139 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 140 tty.c_cflag &= ~(CSIZE|PARENB); 141 tty.c_cflag |= CS8; 142 tty.c_cc[VMIN] = 1; 143 tty.c_cc[VTIME] = 0; 144 145 tcsetattr (0, TCSANOW, &tty); 146 147 atexit(term_exit); 148 } 149 150 static int read_password(char *buf, int buf_size) 151 { 152 uint8_t ch; 153 int i, ret; 154 155 printf("password: "); 156 fflush(stdout); 157 term_init(); 158 i = 0; 159 for(;;) { 160 ret = read(0, &ch, 1); 161 if (ret == -1) { 162 if (errno == EAGAIN || errno == EINTR) { 163 continue; 164 } else { 165 ret = -1; 166 break; 167 } 168 } else if (ret == 0) { 169 ret = -1; 170 break; 171 } else { 172 if (ch == '\r') { 173 ret = 0; 174 break; 175 } 176 if (i < (buf_size - 1)) 177 buf[i++] = ch; 178 } 179 } 180 term_exit(); 181 buf[i] = '\0'; 182 printf("\n"); 183 return ret; 184 } 185 #endif 186 187 static BlockDriverState *bdrv_new_open(const char *filename, 188 const char *fmt) 189 { 190 BlockDriverState *bs; 191 BlockDriver *drv; 192 char password[256]; 193 194 bs = bdrv_new(""); 195 if (!bs) 196 error("Not enough memory"); 197 if (fmt) { 198 drv = bdrv_find_format(fmt); 199 if (!drv) 200 error("Unknown file format '%s'", fmt); 201 } else { 202 drv = NULL; 203 } 204 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) { 205 error("Could not open '%s'", filename); 206 } 207 if (bdrv_is_encrypted(bs)) { 208 printf("Disk image '%s' is encrypted.\n", filename); 209 if (read_password(password, sizeof(password)) < 0) 210 error("No password given"); 211 if (bdrv_set_key(bs, password) < 0) 212 error("invalid password"); 213 } 214 return bs; 215 } 216 217 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list, 218 int flags, const char *base_filename, const char *base_fmt) 219 { 220 if (flags & BLOCK_FLAG_ENCRYPT) { 221 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) { 222 error("Encryption not supported for file format '%s'", fmt); 223 } 224 } 225 if (flags & BLOCK_FLAG_COMPAT6) { 226 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) { 227 error("VMDK version 6 not supported for file format '%s'", fmt); 228 } 229 } 230 231 if (base_filename) { 232 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) { 233 error("Backing file not supported for file format '%s'", fmt); 234 } 235 } 236 if (base_fmt) { 237 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) { 238 error("Backing file format not supported for file format '%s'", fmt); 239 } 240 } 241 } 242 243 static int img_create(int argc, char **argv) 244 { 245 int c, ret, flags; 246 const char *fmt = "raw"; 247 const char *base_fmt = NULL; 248 const char *filename; 249 const char *base_filename = NULL; 250 BlockDriver *drv; 251 QEMUOptionParameter *param = NULL; 252 char *options = NULL; 253 254 flags = 0; 255 for(;;) { 256 c = getopt(argc, argv, "F:b:f:he6o:"); 257 if (c == -1) 258 break; 259 switch(c) { 260 case 'h': 261 help(); 262 break; 263 case 'F': 264 base_fmt = optarg; 265 break; 266 case 'b': 267 base_filename = optarg; 268 break; 269 case 'f': 270 fmt = optarg; 271 break; 272 case 'e': 273 flags |= BLOCK_FLAG_ENCRYPT; 274 break; 275 case '6': 276 flags |= BLOCK_FLAG_COMPAT6; 277 break; 278 case 'o': 279 options = optarg; 280 break; 281 } 282 } 283 284 /* Find driver and parse its options */ 285 drv = bdrv_find_format(fmt); 286 if (!drv) 287 error("Unknown file format '%s'", fmt); 288 289 if (options && !strcmp(options, "?")) { 290 print_option_help(drv->create_options); 291 return 0; 292 } 293 294 /* Create parameter list with default values */ 295 param = parse_option_parameters("", drv->create_options, param); 296 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1); 297 298 /* Parse -o options */ 299 if (options) { 300 param = parse_option_parameters(options, drv->create_options, param); 301 if (param == NULL) { 302 error("Invalid options for file format '%s'.", fmt); 303 } 304 } 305 306 /* Get the filename */ 307 if (optind >= argc) 308 help(); 309 filename = argv[optind++]; 310 311 /* Add size to parameters */ 312 if (optind < argc) { 313 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]); 314 } 315 316 /* Add old-style options to parameters */ 317 add_old_style_options(fmt, param, flags, base_filename, base_fmt); 318 319 // The size for the image must always be specified, with one exception: 320 // If we are using a backing file, we can obtain the size from there 321 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) { 322 323 QEMUOptionParameter *backing_file = 324 get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 325 QEMUOptionParameter *backing_fmt = 326 get_option_parameter(param, BLOCK_OPT_BACKING_FMT); 327 328 if (backing_file && backing_file->value.s) { 329 BlockDriverState *bs; 330 uint64_t size; 331 const char *fmt = NULL; 332 char buf[32]; 333 334 if (backing_fmt && backing_fmt->value.s) { 335 if (bdrv_find_format(backing_fmt->value.s)) { 336 fmt = backing_fmt->value.s; 337 } else { 338 error("Unknown backing file format '%s'", 339 backing_fmt->value.s); 340 } 341 } 342 343 bs = bdrv_new_open(backing_file->value.s, fmt); 344 bdrv_get_geometry(bs, &size); 345 size *= 512; 346 bdrv_delete(bs); 347 348 snprintf(buf, sizeof(buf), "%" PRId64, size); 349 set_option_parameter(param, BLOCK_OPT_SIZE, buf); 350 } else { 351 error("Image creation needs a size parameter"); 352 } 353 } 354 355 printf("Formatting '%s', fmt=%s ", filename, fmt); 356 print_option_parameters(param); 357 puts(""); 358 359 ret = bdrv_create(drv, filename, param); 360 free_option_parameters(param); 361 362 if (ret < 0) { 363 if (ret == -ENOTSUP) { 364 error("Formatting or formatting option not supported for file format '%s'", fmt); 365 } else if (ret == -EFBIG) { 366 error("The image size is too large for file format '%s'", fmt); 367 } else { 368 error("Error while formatting"); 369 } 370 } 371 return 0; 372 } 373 374 static int img_check(int argc, char **argv) 375 { 376 int c, ret; 377 const char *filename, *fmt; 378 BlockDriver *drv; 379 BlockDriverState *bs; 380 381 fmt = NULL; 382 for(;;) { 383 c = getopt(argc, argv, "f:h"); 384 if (c == -1) 385 break; 386 switch(c) { 387 case 'h': 388 help(); 389 break; 390 case 'f': 391 fmt = optarg; 392 break; 393 } 394 } 395 if (optind >= argc) 396 help(); 397 filename = argv[optind++]; 398 399 bs = bdrv_new(""); 400 if (!bs) 401 error("Not enough memory"); 402 if (fmt) { 403 drv = bdrv_find_format(fmt); 404 if (!drv) 405 error("Unknown file format '%s'", fmt); 406 } else { 407 drv = NULL; 408 } 409 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) { 410 error("Could not open '%s'", filename); 411 } 412 ret = bdrv_check(bs); 413 switch(ret) { 414 case 0: 415 printf("No errors were found on the image.\n"); 416 break; 417 case -ENOTSUP: 418 error("This image format does not support checks"); 419 break; 420 default: 421 if (ret < 0) { 422 error("An error occurred during the check"); 423 } else { 424 printf("%d errors were found on the image.\n", ret); 425 } 426 break; 427 } 428 429 bdrv_delete(bs); 430 return 0; 431 } 432 433 static int img_commit(int argc, char **argv) 434 { 435 int c, ret; 436 const char *filename, *fmt; 437 BlockDriver *drv; 438 BlockDriverState *bs; 439 440 fmt = NULL; 441 for(;;) { 442 c = getopt(argc, argv, "f:h"); 443 if (c == -1) 444 break; 445 switch(c) { 446 case 'h': 447 help(); 448 break; 449 case 'f': 450 fmt = optarg; 451 break; 452 } 453 } 454 if (optind >= argc) 455 help(); 456 filename = argv[optind++]; 457 458 bs = bdrv_new(""); 459 if (!bs) 460 error("Not enough memory"); 461 if (fmt) { 462 drv = bdrv_find_format(fmt); 463 if (!drv) 464 error("Unknown file format '%s'", fmt); 465 } else { 466 drv = NULL; 467 } 468 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) { 469 error("Could not open '%s'", filename); 470 } 471 ret = bdrv_commit(bs); 472 switch(ret) { 473 case 0: 474 printf("Image committed.\n"); 475 break; 476 case -ENOENT: 477 error("No disk inserted"); 478 break; 479 case -EACCES: 480 error("Image is read-only"); 481 break; 482 case -ENOTSUP: 483 error("Image is already committed"); 484 break; 485 default: 486 error("Error while committing image"); 487 break; 488 } 489 490 bdrv_delete(bs); 491 return 0; 492 } 493 494 static int is_not_zero(const uint8_t *sector, int len) 495 { 496 int i; 497 len >>= 2; 498 for(i = 0;i < len; i++) { 499 if (((uint32_t *)sector)[i] != 0) 500 return 1; 501 } 502 return 0; 503 } 504 505 /* 506 * Returns true iff the first sector pointed to by 'buf' contains at least 507 * a non-NUL byte. 508 * 509 * 'pnum' is set to the number of sectors (including and immediately following 510 * the first one) that are known to be in the same allocated/unallocated state. 511 */ 512 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 513 { 514 int v, i; 515 516 if (n <= 0) { 517 *pnum = 0; 518 return 0; 519 } 520 v = is_not_zero(buf, 512); 521 for(i = 1; i < n; i++) { 522 buf += 512; 523 if (v != is_not_zero(buf, 512)) 524 break; 525 } 526 *pnum = i; 527 return v; 528 } 529 530 #define IO_BUF_SIZE (2 * 1024 * 1024) 531 532 static int img_convert(int argc, char **argv) 533 { 534 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors; 535 const char *fmt, *out_fmt, *out_baseimg, *out_filename; 536 BlockDriver *drv; 537 BlockDriverState **bs, *out_bs; 538 int64_t total_sectors, nb_sectors, sector_num, bs_offset; 539 uint64_t bs_sectors; 540 uint8_t buf[IO_BUF_SIZE]; 541 const uint8_t *buf1; 542 BlockDriverInfo bdi; 543 QEMUOptionParameter *param = NULL; 544 char *options = NULL; 545 546 fmt = NULL; 547 out_fmt = "raw"; 548 out_baseimg = NULL; 549 flags = 0; 550 for(;;) { 551 c = getopt(argc, argv, "f:O:B:hce6o:"); 552 if (c == -1) 553 break; 554 switch(c) { 555 case 'h': 556 help(); 557 break; 558 case 'f': 559 fmt = optarg; 560 break; 561 case 'O': 562 out_fmt = optarg; 563 break; 564 case 'B': 565 out_baseimg = optarg; 566 break; 567 case 'c': 568 flags |= BLOCK_FLAG_COMPRESS; 569 break; 570 case 'e': 571 flags |= BLOCK_FLAG_ENCRYPT; 572 break; 573 case '6': 574 flags |= BLOCK_FLAG_COMPAT6; 575 break; 576 case 'o': 577 options = optarg; 578 break; 579 } 580 } 581 582 bs_n = argc - optind - 1; 583 if (bs_n < 1) help(); 584 585 out_filename = argv[argc - 1]; 586 587 if (bs_n > 1 && out_baseimg) 588 error("-B makes no sense when concatenating multiple input images"); 589 590 bs = calloc(bs_n, sizeof(BlockDriverState *)); 591 if (!bs) 592 error("Out of memory"); 593 594 total_sectors = 0; 595 for (bs_i = 0; bs_i < bs_n; bs_i++) { 596 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt); 597 if (!bs[bs_i]) 598 error("Could not open '%s'", argv[optind + bs_i]); 599 bdrv_get_geometry(bs[bs_i], &bs_sectors); 600 total_sectors += bs_sectors; 601 } 602 603 /* Find driver and parse its options */ 604 drv = bdrv_find_format(out_fmt); 605 if (!drv) 606 error("Unknown file format '%s'", out_fmt); 607 608 if (options && !strcmp(options, "?")) { 609 print_option_help(drv->create_options); 610 free(bs); 611 return 0; 612 } 613 614 if (options) { 615 param = parse_option_parameters(options, drv->create_options, param); 616 if (param == NULL) { 617 error("Invalid options for file format '%s'.", out_fmt); 618 } 619 } else { 620 param = parse_option_parameters("", drv->create_options, param); 621 } 622 623 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 624 add_old_style_options(out_fmt, param, flags, out_baseimg, NULL); 625 626 /* Check if compression is supported */ 627 if (flags & BLOCK_FLAG_COMPRESS) { 628 QEMUOptionParameter *encryption = 629 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 630 631 if (!drv->bdrv_write_compressed) { 632 error("Compression not supported for this file format"); 633 } 634 635 if (encryption && encryption->value.n) { 636 error("Compression and encryption not supported at the same time"); 637 } 638 } 639 640 /* Create the new image */ 641 ret = bdrv_create(drv, out_filename, param); 642 free_option_parameters(param); 643 644 if (ret < 0) { 645 if (ret == -ENOTSUP) { 646 error("Formatting not supported for file format '%s'", out_fmt); 647 } else if (ret == -EFBIG) { 648 error("The image size is too large for file format '%s'", out_fmt); 649 } else { 650 error("Error while formatting '%s'", out_filename); 651 } 652 } 653 654 out_bs = bdrv_new_open(out_filename, out_fmt); 655 656 bs_i = 0; 657 bs_offset = 0; 658 bdrv_get_geometry(bs[0], &bs_sectors); 659 660 if (flags & BLOCK_FLAG_COMPRESS) { 661 if (bdrv_get_info(out_bs, &bdi) < 0) 662 error("could not get block driver info"); 663 cluster_size = bdi.cluster_size; 664 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) 665 error("invalid cluster size"); 666 cluster_sectors = cluster_size >> 9; 667 sector_num = 0; 668 for(;;) { 669 int64_t bs_num; 670 int remainder; 671 uint8_t *buf2; 672 673 nb_sectors = total_sectors - sector_num; 674 if (nb_sectors <= 0) 675 break; 676 if (nb_sectors >= cluster_sectors) 677 n = cluster_sectors; 678 else 679 n = nb_sectors; 680 681 bs_num = sector_num - bs_offset; 682 assert (bs_num >= 0); 683 remainder = n; 684 buf2 = buf; 685 while (remainder > 0) { 686 int nlow; 687 while (bs_num == bs_sectors) { 688 bs_i++; 689 assert (bs_i < bs_n); 690 bs_offset += bs_sectors; 691 bdrv_get_geometry(bs[bs_i], &bs_sectors); 692 bs_num = 0; 693 /* printf("changing part: sector_num=%lld, " 694 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n", 695 sector_num, bs_i, bs_offset, bs_sectors); */ 696 } 697 assert (bs_num < bs_sectors); 698 699 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 700 701 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 702 error("error while reading"); 703 704 buf2 += nlow * 512; 705 bs_num += nlow; 706 707 remainder -= nlow; 708 } 709 assert (remainder == 0); 710 711 if (n < cluster_sectors) 712 memset(buf + n * 512, 0, cluster_size - n * 512); 713 if (is_not_zero(buf, cluster_size)) { 714 if (bdrv_write_compressed(out_bs, sector_num, buf, 715 cluster_sectors) != 0) 716 error("error while compressing sector %" PRId64, 717 sector_num); 718 } 719 sector_num += n; 720 } 721 /* signal EOF to align */ 722 bdrv_write_compressed(out_bs, 0, NULL, 0); 723 } else { 724 sector_num = 0; // total number of sectors converted so far 725 for(;;) { 726 nb_sectors = total_sectors - sector_num; 727 if (nb_sectors <= 0) 728 break; 729 if (nb_sectors >= (IO_BUF_SIZE / 512)) 730 n = (IO_BUF_SIZE / 512); 731 else 732 n = nb_sectors; 733 734 while (sector_num - bs_offset >= bs_sectors) { 735 bs_i ++; 736 assert (bs_i < bs_n); 737 bs_offset += bs_sectors; 738 bdrv_get_geometry(bs[bs_i], &bs_sectors); 739 /* printf("changing part: sector_num=%lld, bs_i=%d, " 740 "bs_offset=%lld, bs_sectors=%lld\n", 741 sector_num, bs_i, bs_offset, bs_sectors); */ 742 } 743 744 if (n > bs_offset + bs_sectors - sector_num) 745 n = bs_offset + bs_sectors - sector_num; 746 747 if (!drv->no_zero_init) { 748 /* If the output image is being created as a copy on write image, 749 assume that sectors which are unallocated in the input image 750 are present in both the output's and input's base images (no 751 need to copy them). */ 752 if (out_baseimg) { 753 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 754 n, &n1)) { 755 sector_num += n1; 756 continue; 757 } 758 /* The next 'n1' sectors are allocated in the input image. Copy 759 only those as they may be followed by unallocated sectors. */ 760 n = n1; 761 } 762 } else { 763 n1 = n; 764 } 765 766 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 767 error("error while reading"); 768 /* NOTE: at the same time we convert, we do not write zero 769 sectors to have a chance to compress the image. Ideally, we 770 should add a specific call to have the info to go faster */ 771 buf1 = buf; 772 while (n > 0) { 773 /* If the output image is being created as a copy on write image, 774 copy all sectors even the ones containing only NUL bytes, 775 because they may differ from the sectors in the base image. 776 777 If the output is to a host device, we also write out 778 sectors that are entirely 0, since whatever data was 779 already there is garbage, not 0s. */ 780 if (drv->no_zero_init || out_baseimg || 781 is_allocated_sectors(buf1, n, &n1)) { 782 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0) 783 error("error while writing"); 784 } 785 sector_num += n1; 786 n -= n1; 787 buf1 += n1 * 512; 788 } 789 } 790 } 791 bdrv_delete(out_bs); 792 for (bs_i = 0; bs_i < bs_n; bs_i++) 793 bdrv_delete(bs[bs_i]); 794 free(bs); 795 return 0; 796 } 797 798 #ifdef _WIN32 799 static int64_t get_allocated_file_size(const char *filename) 800 { 801 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high); 802 get_compressed_t get_compressed; 803 struct _stati64 st; 804 805 /* WinNT support GetCompressedFileSize to determine allocate size */ 806 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA"); 807 if (get_compressed) { 808 DWORD high, low; 809 low = get_compressed(filename, &high); 810 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) 811 return (((int64_t) high) << 32) + low; 812 } 813 814 if (_stati64(filename, &st) < 0) 815 return -1; 816 return st.st_size; 817 } 818 #else 819 static int64_t get_allocated_file_size(const char *filename) 820 { 821 struct stat st; 822 if (stat(filename, &st) < 0) 823 return -1; 824 return (int64_t)st.st_blocks * 512; 825 } 826 #endif 827 828 static void dump_snapshots(BlockDriverState *bs) 829 { 830 QEMUSnapshotInfo *sn_tab, *sn; 831 int nb_sns, i; 832 char buf[256]; 833 834 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 835 if (nb_sns <= 0) 836 return; 837 printf("Snapshot list:\n"); 838 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 839 for(i = 0; i < nb_sns; i++) { 840 sn = &sn_tab[i]; 841 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 842 } 843 qemu_free(sn_tab); 844 } 845 846 static int img_info(int argc, char **argv) 847 { 848 int c; 849 const char *filename, *fmt; 850 BlockDriver *drv; 851 BlockDriverState *bs; 852 char fmt_name[128], size_buf[128], dsize_buf[128]; 853 uint64_t total_sectors; 854 int64_t allocated_size; 855 char backing_filename[1024]; 856 char backing_filename2[1024]; 857 BlockDriverInfo bdi; 858 859 fmt = NULL; 860 for(;;) { 861 c = getopt(argc, argv, "f:h"); 862 if (c == -1) 863 break; 864 switch(c) { 865 case 'h': 866 help(); 867 break; 868 case 'f': 869 fmt = optarg; 870 break; 871 } 872 } 873 if (optind >= argc) 874 help(); 875 filename = argv[optind++]; 876 877 bs = bdrv_new(""); 878 if (!bs) 879 error("Not enough memory"); 880 if (fmt) { 881 drv = bdrv_find_format(fmt); 882 if (!drv) 883 error("Unknown file format '%s'", fmt); 884 } else { 885 drv = NULL; 886 } 887 if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_NO_BACKING, drv) < 0) { 888 error("Could not open '%s'", filename); 889 } 890 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 891 bdrv_get_geometry(bs, &total_sectors); 892 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 893 allocated_size = get_allocated_file_size(filename); 894 if (allocated_size < 0) 895 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 896 else 897 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 898 allocated_size); 899 printf("image: %s\n" 900 "file format: %s\n" 901 "virtual size: %s (%" PRId64 " bytes)\n" 902 "disk size: %s\n", 903 filename, fmt_name, size_buf, 904 (total_sectors * 512), 905 dsize_buf); 906 if (bdrv_is_encrypted(bs)) 907 printf("encrypted: yes\n"); 908 if (bdrv_get_info(bs, &bdi) >= 0) { 909 if (bdi.cluster_size != 0) 910 printf("cluster_size: %d\n", bdi.cluster_size); 911 } 912 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 913 if (backing_filename[0] != '\0') { 914 path_combine(backing_filename2, sizeof(backing_filename2), 915 filename, backing_filename); 916 printf("backing file: %s (actual path: %s)\n", 917 backing_filename, 918 backing_filename2); 919 } 920 dump_snapshots(bs); 921 bdrv_delete(bs); 922 return 0; 923 } 924 925 #define SNAPSHOT_LIST 1 926 #define SNAPSHOT_CREATE 2 927 #define SNAPSHOT_APPLY 3 928 #define SNAPSHOT_DELETE 4 929 930 static int img_snapshot(int argc, char **argv) 931 { 932 BlockDriverState *bs; 933 QEMUSnapshotInfo sn; 934 char *filename, *snapshot_name = NULL; 935 int c, ret; 936 int action = 0; 937 qemu_timeval tv; 938 939 /* Parse commandline parameters */ 940 for(;;) { 941 c = getopt(argc, argv, "la:c:d:h"); 942 if (c == -1) 943 break; 944 switch(c) { 945 case 'h': 946 help(); 947 return 0; 948 case 'l': 949 if (action) { 950 help(); 951 return 0; 952 } 953 action = SNAPSHOT_LIST; 954 break; 955 case 'a': 956 if (action) { 957 help(); 958 return 0; 959 } 960 action = SNAPSHOT_APPLY; 961 snapshot_name = optarg; 962 break; 963 case 'c': 964 if (action) { 965 help(); 966 return 0; 967 } 968 action = SNAPSHOT_CREATE; 969 snapshot_name = optarg; 970 break; 971 case 'd': 972 if (action) { 973 help(); 974 return 0; 975 } 976 action = SNAPSHOT_DELETE; 977 snapshot_name = optarg; 978 break; 979 } 980 } 981 982 if (optind >= argc) 983 help(); 984 filename = argv[optind++]; 985 986 /* Open the image */ 987 bs = bdrv_new(""); 988 if (!bs) 989 error("Not enough memory"); 990 991 if (bdrv_open2(bs, filename, 0, NULL) < 0) { 992 error("Could not open '%s'", filename); 993 } 994 995 /* Perform the requested action */ 996 switch(action) { 997 case SNAPSHOT_LIST: 998 dump_snapshots(bs); 999 break; 1000 1001 case SNAPSHOT_CREATE: 1002 memset(&sn, 0, sizeof(sn)); 1003 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1004 1005 qemu_gettimeofday(&tv); 1006 sn.date_sec = tv.tv_sec; 1007 sn.date_nsec = tv.tv_usec * 1000; 1008 1009 ret = bdrv_snapshot_create(bs, &sn); 1010 if (ret) 1011 error("Could not create snapshot '%s': %d (%s)", 1012 snapshot_name, ret, strerror(-ret)); 1013 break; 1014 1015 case SNAPSHOT_APPLY: 1016 ret = bdrv_snapshot_goto(bs, snapshot_name); 1017 if (ret) 1018 error("Could not apply snapshot '%s': %d (%s)", 1019 snapshot_name, ret, strerror(-ret)); 1020 break; 1021 1022 case SNAPSHOT_DELETE: 1023 ret = bdrv_snapshot_delete(bs, snapshot_name); 1024 if (ret) 1025 error("Could not delete snapshot '%s': %d (%s)", 1026 snapshot_name, ret, strerror(-ret)); 1027 break; 1028 } 1029 1030 /* Cleanup */ 1031 bdrv_delete(bs); 1032 1033 return 0; 1034 } 1035 1036 static const img_cmd_t img_cmds[] = { 1037 #define DEF(option, callback, arg_string) \ 1038 { option, callback }, 1039 #include "qemu-img-cmds.h" 1040 #undef DEF 1041 #undef GEN_DOCS 1042 { NULL, NULL, }, 1043 }; 1044 1045 int main(int argc, char **argv) 1046 { 1047 const img_cmd_t *cmd; 1048 const char *cmdname; 1049 1050 bdrv_init(); 1051 if (argc < 2) 1052 help(); 1053 cmdname = argv[1]; 1054 argc--; argv++; 1055 1056 /* find the command */ 1057 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 1058 if (!strcmp(cmdname, cmd->name)) { 1059 return cmd->handler(argc, argv); 1060 } 1061 } 1062 1063 /* not found */ 1064 help(); 1065 return 0; 1066 } 1067