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 BDRV_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 const char *help_msg = 62 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n" 63 "usage: qemu-img command [command options]\n" 64 "QEMU disk image utility\n" 65 "\n" 66 "Command syntax:\n" 67 #define DEF(option, callback, arg_string) \ 68 " " arg_string "\n" 69 #include "qemu-img-cmds.h" 70 #undef DEF 71 #undef GEN_DOCS 72 "\n" 73 "Command parameters:\n" 74 " 'filename' is a disk image filename\n" 75 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 76 " 'size' is the disk image size in bytes. Optional suffixes\n" 77 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n" 78 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n" 79 " 'output_filename' is the destination disk image filename\n" 80 " 'output_fmt' is the destination format\n" 81 " 'options' is a comma separated list of format specific options in a\n" 82 " name=value format. Use -o ? for an overview of the options supported by the\n" 83 " used format\n" 84 " '-c' indicates that target image must be compressed (qcow format only)\n" 85 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n" 86 " match exactly. The image doesn't need a working backing file before\n" 87 " rebasing in this case (useful for renaming the backing file)\n" 88 " '-h' with or without a command shows this help and lists the supported formats\n" 89 "\n" 90 "Parameters to snapshot subcommand:\n" 91 " 'snapshot' is the name of the snapshot to create, apply or delete\n" 92 " '-a' applies a snapshot (revert disk to saved state)\n" 93 " '-c' creates a snapshot\n" 94 " '-d' deletes a snapshot\n" 95 " '-l' lists all snapshots in the given image\n"; 96 97 printf("%s\nSupported formats:", help_msg); 98 bdrv_iterate_format(format_print, NULL); 99 printf("\n"); 100 exit(1); 101 } 102 103 #if defined(WIN32) 104 /* XXX: put correct support for win32 */ 105 static int read_password(char *buf, int buf_size) 106 { 107 int c, i; 108 printf("Password: "); 109 fflush(stdout); 110 i = 0; 111 for(;;) { 112 c = getchar(); 113 if (c == '\n') 114 break; 115 if (i < (buf_size - 1)) 116 buf[i++] = c; 117 } 118 buf[i] = '\0'; 119 return 0; 120 } 121 122 #else 123 124 #include <termios.h> 125 126 static struct termios oldtty; 127 128 static void term_exit(void) 129 { 130 tcsetattr (0, TCSANOW, &oldtty); 131 } 132 133 static void term_init(void) 134 { 135 struct termios tty; 136 137 tcgetattr (0, &tty); 138 oldtty = tty; 139 140 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 141 |INLCR|IGNCR|ICRNL|IXON); 142 tty.c_oflag |= OPOST; 143 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 144 tty.c_cflag &= ~(CSIZE|PARENB); 145 tty.c_cflag |= CS8; 146 tty.c_cc[VMIN] = 1; 147 tty.c_cc[VTIME] = 0; 148 149 tcsetattr (0, TCSANOW, &tty); 150 151 atexit(term_exit); 152 } 153 154 static int read_password(char *buf, int buf_size) 155 { 156 uint8_t ch; 157 int i, ret; 158 159 printf("password: "); 160 fflush(stdout); 161 term_init(); 162 i = 0; 163 for(;;) { 164 ret = read(0, &ch, 1); 165 if (ret == -1) { 166 if (errno == EAGAIN || errno == EINTR) { 167 continue; 168 } else { 169 ret = -1; 170 break; 171 } 172 } else if (ret == 0) { 173 ret = -1; 174 break; 175 } else { 176 if (ch == '\r') { 177 ret = 0; 178 break; 179 } 180 if (i < (buf_size - 1)) 181 buf[i++] = ch; 182 } 183 } 184 term_exit(); 185 buf[i] = '\0'; 186 printf("\n"); 187 return ret; 188 } 189 #endif 190 191 static BlockDriverState *bdrv_new_open(const char *filename, 192 const char *fmt, 193 int flags) 194 { 195 BlockDriverState *bs; 196 BlockDriver *drv; 197 char password[256]; 198 199 bs = bdrv_new(""); 200 if (!bs) 201 error("Not enough memory"); 202 if (fmt) { 203 drv = bdrv_find_format(fmt); 204 if (!drv) 205 error("Unknown file format '%s'", fmt); 206 } else { 207 drv = NULL; 208 } 209 if (bdrv_open(bs, filename, flags, drv) < 0) { 210 error("Could not open '%s'", filename); 211 } 212 if (bdrv_is_encrypted(bs)) { 213 printf("Disk image '%s' is encrypted.\n", filename); 214 if (read_password(password, sizeof(password)) < 0) 215 error("No password given"); 216 if (bdrv_set_key(bs, password) < 0) 217 error("invalid password"); 218 } 219 return bs; 220 } 221 222 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list, 223 int flags, const char *base_filename, const char *base_fmt) 224 { 225 if (flags & BLOCK_FLAG_ENCRYPT) { 226 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) { 227 error("Encryption not supported for file format '%s'", fmt); 228 } 229 } 230 if (flags & BLOCK_FLAG_COMPAT6) { 231 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) { 232 error("VMDK version 6 not supported for file format '%s'", fmt); 233 } 234 } 235 236 if (base_filename) { 237 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) { 238 error("Backing file not supported for file format '%s'", fmt); 239 } 240 } 241 if (base_fmt) { 242 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) { 243 error("Backing file format not supported for file format '%s'", fmt); 244 } 245 } 246 } 247 248 static int img_create(int argc, char **argv) 249 { 250 int c, ret, flags; 251 const char *fmt = "raw"; 252 const char *base_fmt = NULL; 253 const char *filename; 254 const char *base_filename = NULL; 255 BlockDriver *drv; 256 QEMUOptionParameter *param = NULL; 257 char *options = NULL; 258 259 flags = 0; 260 for(;;) { 261 c = getopt(argc, argv, "F:b:f:he6o:"); 262 if (c == -1) 263 break; 264 switch(c) { 265 case 'h': 266 help(); 267 break; 268 case 'F': 269 base_fmt = optarg; 270 break; 271 case 'b': 272 base_filename = optarg; 273 break; 274 case 'f': 275 fmt = optarg; 276 break; 277 case 'e': 278 flags |= BLOCK_FLAG_ENCRYPT; 279 break; 280 case '6': 281 flags |= BLOCK_FLAG_COMPAT6; 282 break; 283 case 'o': 284 options = optarg; 285 break; 286 } 287 } 288 289 /* Find driver and parse its options */ 290 drv = bdrv_find_format(fmt); 291 if (!drv) 292 error("Unknown file format '%s'", fmt); 293 294 if (options && !strcmp(options, "?")) { 295 print_option_help(drv->create_options); 296 return 0; 297 } 298 299 /* Create parameter list with default values */ 300 param = parse_option_parameters("", drv->create_options, param); 301 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1); 302 303 /* Parse -o options */ 304 if (options) { 305 param = parse_option_parameters(options, drv->create_options, param); 306 if (param == NULL) { 307 error("Invalid options for file format '%s'.", fmt); 308 } 309 } 310 311 /* Get the filename */ 312 if (optind >= argc) 313 help(); 314 filename = argv[optind++]; 315 316 /* Add size to parameters */ 317 if (optind < argc) { 318 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]); 319 } 320 321 /* Add old-style options to parameters */ 322 add_old_style_options(fmt, param, flags, base_filename, base_fmt); 323 324 // The size for the image must always be specified, with one exception: 325 // If we are using a backing file, we can obtain the size from there 326 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) { 327 328 QEMUOptionParameter *backing_file = 329 get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 330 QEMUOptionParameter *backing_fmt = 331 get_option_parameter(param, BLOCK_OPT_BACKING_FMT); 332 333 if (backing_file && backing_file->value.s) { 334 BlockDriverState *bs; 335 uint64_t size; 336 const char *fmt = NULL; 337 char buf[32]; 338 339 if (backing_fmt && backing_fmt->value.s) { 340 if (bdrv_find_format(backing_fmt->value.s)) { 341 fmt = backing_fmt->value.s; 342 } else { 343 error("Unknown backing file format '%s'", 344 backing_fmt->value.s); 345 } 346 } 347 348 bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS); 349 bdrv_get_geometry(bs, &size); 350 size *= 512; 351 bdrv_delete(bs); 352 353 snprintf(buf, sizeof(buf), "%" PRId64, size); 354 set_option_parameter(param, BLOCK_OPT_SIZE, buf); 355 } else { 356 error("Image creation needs a size parameter"); 357 } 358 } 359 360 printf("Formatting '%s', fmt=%s ", filename, fmt); 361 print_option_parameters(param); 362 puts(""); 363 364 ret = bdrv_create(drv, filename, param); 365 free_option_parameters(param); 366 367 if (ret < 0) { 368 if (ret == -ENOTSUP) { 369 error("Formatting or formatting option not supported for file format '%s'", fmt); 370 } else if (ret == -EFBIG) { 371 error("The image size is too large for file format '%s'", fmt); 372 } else { 373 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret)); 374 } 375 } 376 return 0; 377 } 378 379 static int img_check(int argc, char **argv) 380 { 381 int c, ret; 382 const char *filename, *fmt; 383 BlockDriverState *bs; 384 385 fmt = NULL; 386 for(;;) { 387 c = getopt(argc, argv, "f:h"); 388 if (c == -1) 389 break; 390 switch(c) { 391 case 'h': 392 help(); 393 break; 394 case 'f': 395 fmt = optarg; 396 break; 397 } 398 } 399 if (optind >= argc) 400 help(); 401 filename = argv[optind++]; 402 403 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS); 404 ret = bdrv_check(bs); 405 switch(ret) { 406 case 0: 407 printf("No errors were found on the image.\n"); 408 break; 409 case -ENOTSUP: 410 error("This image format does not support checks"); 411 break; 412 default: 413 if (ret < 0) { 414 error("An error occurred during the check"); 415 } else { 416 printf("%d errors were found on the image.\n", ret); 417 } 418 break; 419 } 420 421 bdrv_delete(bs); 422 return 0; 423 } 424 425 static int img_commit(int argc, char **argv) 426 { 427 int c, ret; 428 const char *filename, *fmt; 429 BlockDriverState *bs; 430 431 fmt = NULL; 432 for(;;) { 433 c = getopt(argc, argv, "f:h"); 434 if (c == -1) 435 break; 436 switch(c) { 437 case 'h': 438 help(); 439 break; 440 case 'f': 441 fmt = optarg; 442 break; 443 } 444 } 445 if (optind >= argc) 446 help(); 447 filename = argv[optind++]; 448 449 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR); 450 ret = bdrv_commit(bs); 451 switch(ret) { 452 case 0: 453 printf("Image committed.\n"); 454 break; 455 case -ENOENT: 456 error("No disk inserted"); 457 break; 458 case -EACCES: 459 error("Image is read-only"); 460 break; 461 case -ENOTSUP: 462 error("Image is already committed"); 463 break; 464 default: 465 error("Error while committing image"); 466 break; 467 } 468 469 bdrv_delete(bs); 470 return 0; 471 } 472 473 static int is_not_zero(const uint8_t *sector, int len) 474 { 475 int i; 476 len >>= 2; 477 for(i = 0;i < len; i++) { 478 if (((uint32_t *)sector)[i] != 0) 479 return 1; 480 } 481 return 0; 482 } 483 484 /* 485 * Returns true iff the first sector pointed to by 'buf' contains at least 486 * a non-NUL byte. 487 * 488 * 'pnum' is set to the number of sectors (including and immediately following 489 * the first one) that are known to be in the same allocated/unallocated state. 490 */ 491 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 492 { 493 int v, i; 494 495 if (n <= 0) { 496 *pnum = 0; 497 return 0; 498 } 499 v = is_not_zero(buf, 512); 500 for(i = 1; i < n; i++) { 501 buf += 512; 502 if (v != is_not_zero(buf, 512)) 503 break; 504 } 505 *pnum = i; 506 return v; 507 } 508 509 /* 510 * Compares two buffers sector by sector. Returns 0 if the first sector of both 511 * buffers matches, non-zero otherwise. 512 * 513 * pnum is set to the number of sectors (including and immediately following 514 * the first one) that are known to have the same comparison result 515 */ 516 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n, 517 int *pnum) 518 { 519 int res, i; 520 521 if (n <= 0) { 522 *pnum = 0; 523 return 0; 524 } 525 526 res = !!memcmp(buf1, buf2, 512); 527 for(i = 1; i < n; i++) { 528 buf1 += 512; 529 buf2 += 512; 530 531 if (!!memcmp(buf1, buf2, 512) != res) { 532 break; 533 } 534 } 535 536 *pnum = i; 537 return res; 538 } 539 540 #define IO_BUF_SIZE (2 * 1024 * 1024) 541 542 static int img_convert(int argc, char **argv) 543 { 544 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors; 545 const char *fmt, *out_fmt, *out_baseimg, *out_filename; 546 BlockDriver *drv; 547 BlockDriverState **bs, *out_bs; 548 int64_t total_sectors, nb_sectors, sector_num, bs_offset; 549 uint64_t bs_sectors; 550 uint8_t * buf; 551 const uint8_t *buf1; 552 BlockDriverInfo bdi; 553 QEMUOptionParameter *param = NULL; 554 char *options = NULL; 555 556 fmt = NULL; 557 out_fmt = "raw"; 558 out_baseimg = NULL; 559 flags = 0; 560 for(;;) { 561 c = getopt(argc, argv, "f:O:B:hce6o:"); 562 if (c == -1) 563 break; 564 switch(c) { 565 case 'h': 566 help(); 567 break; 568 case 'f': 569 fmt = optarg; 570 break; 571 case 'O': 572 out_fmt = optarg; 573 break; 574 case 'B': 575 out_baseimg = optarg; 576 break; 577 case 'c': 578 flags |= BLOCK_FLAG_COMPRESS; 579 break; 580 case 'e': 581 flags |= BLOCK_FLAG_ENCRYPT; 582 break; 583 case '6': 584 flags |= BLOCK_FLAG_COMPAT6; 585 break; 586 case 'o': 587 options = optarg; 588 break; 589 } 590 } 591 592 bs_n = argc - optind - 1; 593 if (bs_n < 1) help(); 594 595 out_filename = argv[argc - 1]; 596 597 if (bs_n > 1 && out_baseimg) 598 error("-B makes no sense when concatenating multiple input images"); 599 600 bs = calloc(bs_n, sizeof(BlockDriverState *)); 601 if (!bs) 602 error("Out of memory"); 603 604 total_sectors = 0; 605 for (bs_i = 0; bs_i < bs_n; bs_i++) { 606 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS); 607 if (!bs[bs_i]) 608 error("Could not open '%s'", argv[optind + bs_i]); 609 bdrv_get_geometry(bs[bs_i], &bs_sectors); 610 total_sectors += bs_sectors; 611 } 612 613 /* Find driver and parse its options */ 614 drv = bdrv_find_format(out_fmt); 615 if (!drv) 616 error("Unknown file format '%s'", out_fmt); 617 618 if (options && !strcmp(options, "?")) { 619 print_option_help(drv->create_options); 620 free(bs); 621 return 0; 622 } 623 624 if (options) { 625 param = parse_option_parameters(options, drv->create_options, param); 626 if (param == NULL) { 627 error("Invalid options for file format '%s'.", out_fmt); 628 } 629 } else { 630 param = parse_option_parameters("", drv->create_options, param); 631 } 632 633 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512); 634 add_old_style_options(out_fmt, param, flags, out_baseimg, NULL); 635 636 /* Check if compression is supported */ 637 if (flags & BLOCK_FLAG_COMPRESS) { 638 QEMUOptionParameter *encryption = 639 get_option_parameter(param, BLOCK_OPT_ENCRYPT); 640 641 if (!drv->bdrv_write_compressed) { 642 error("Compression not supported for this file format"); 643 } 644 645 if (encryption && encryption->value.n) { 646 error("Compression and encryption not supported at the same time"); 647 } 648 } 649 650 /* Create the new image */ 651 ret = bdrv_create(drv, out_filename, param); 652 free_option_parameters(param); 653 654 if (ret < 0) { 655 if (ret == -ENOTSUP) { 656 error("Formatting not supported for file format '%s'", out_fmt); 657 } else if (ret == -EFBIG) { 658 error("The image size is too large for file format '%s'", out_fmt); 659 } else { 660 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret)); 661 } 662 } 663 664 out_bs = bdrv_new_open(out_filename, out_fmt, BDRV_O_FLAGS | BDRV_O_RDWR); 665 666 bs_i = 0; 667 bs_offset = 0; 668 bdrv_get_geometry(bs[0], &bs_sectors); 669 buf = qemu_malloc(IO_BUF_SIZE); 670 671 if (flags & BLOCK_FLAG_COMPRESS) { 672 if (bdrv_get_info(out_bs, &bdi) < 0) 673 error("could not get block driver info"); 674 cluster_size = bdi.cluster_size; 675 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) 676 error("invalid cluster size"); 677 cluster_sectors = cluster_size >> 9; 678 sector_num = 0; 679 for(;;) { 680 int64_t bs_num; 681 int remainder; 682 uint8_t *buf2; 683 684 nb_sectors = total_sectors - sector_num; 685 if (nb_sectors <= 0) 686 break; 687 if (nb_sectors >= cluster_sectors) 688 n = cluster_sectors; 689 else 690 n = nb_sectors; 691 692 bs_num = sector_num - bs_offset; 693 assert (bs_num >= 0); 694 remainder = n; 695 buf2 = buf; 696 while (remainder > 0) { 697 int nlow; 698 while (bs_num == bs_sectors) { 699 bs_i++; 700 assert (bs_i < bs_n); 701 bs_offset += bs_sectors; 702 bdrv_get_geometry(bs[bs_i], &bs_sectors); 703 bs_num = 0; 704 /* printf("changing part: sector_num=%lld, " 705 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n", 706 sector_num, bs_i, bs_offset, bs_sectors); */ 707 } 708 assert (bs_num < bs_sectors); 709 710 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 711 712 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 713 error("error while reading"); 714 715 buf2 += nlow * 512; 716 bs_num += nlow; 717 718 remainder -= nlow; 719 } 720 assert (remainder == 0); 721 722 if (n < cluster_sectors) 723 memset(buf + n * 512, 0, cluster_size - n * 512); 724 if (is_not_zero(buf, cluster_size)) { 725 if (bdrv_write_compressed(out_bs, sector_num, buf, 726 cluster_sectors) != 0) 727 error("error while compressing sector %" PRId64, 728 sector_num); 729 } 730 sector_num += n; 731 } 732 /* signal EOF to align */ 733 bdrv_write_compressed(out_bs, 0, NULL, 0); 734 } else { 735 int has_zero_init = bdrv_has_zero_init(out_bs); 736 737 sector_num = 0; // total number of sectors converted so far 738 for(;;) { 739 nb_sectors = total_sectors - sector_num; 740 if (nb_sectors <= 0) 741 break; 742 if (nb_sectors >= (IO_BUF_SIZE / 512)) 743 n = (IO_BUF_SIZE / 512); 744 else 745 n = nb_sectors; 746 747 while (sector_num - bs_offset >= bs_sectors) { 748 bs_i ++; 749 assert (bs_i < bs_n); 750 bs_offset += bs_sectors; 751 bdrv_get_geometry(bs[bs_i], &bs_sectors); 752 /* printf("changing part: sector_num=%lld, bs_i=%d, " 753 "bs_offset=%lld, bs_sectors=%lld\n", 754 sector_num, bs_i, bs_offset, bs_sectors); */ 755 } 756 757 if (n > bs_offset + bs_sectors - sector_num) 758 n = bs_offset + bs_sectors - sector_num; 759 760 if (has_zero_init) { 761 /* If the output image is being created as a copy on write image, 762 assume that sectors which are unallocated in the input image 763 are present in both the output's and input's base images (no 764 need to copy them). */ 765 if (out_baseimg) { 766 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, 767 n, &n1)) { 768 sector_num += n1; 769 continue; 770 } 771 /* The next 'n1' sectors are allocated in the input image. Copy 772 only those as they may be followed by unallocated sectors. */ 773 n = n1; 774 } 775 } else { 776 n1 = n; 777 } 778 779 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 780 error("error while reading"); 781 /* NOTE: at the same time we convert, we do not write zero 782 sectors to have a chance to compress the image. Ideally, we 783 should add a specific call to have the info to go faster */ 784 buf1 = buf; 785 while (n > 0) { 786 /* If the output image is being created as a copy on write image, 787 copy all sectors even the ones containing only NUL bytes, 788 because they may differ from the sectors in the base image. 789 790 If the output is to a host device, we also write out 791 sectors that are entirely 0, since whatever data was 792 already there is garbage, not 0s. */ 793 if (!has_zero_init || out_baseimg || 794 is_allocated_sectors(buf1, n, &n1)) { 795 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0) 796 error("error while writing"); 797 } 798 sector_num += n1; 799 n -= n1; 800 buf1 += n1 * 512; 801 } 802 } 803 } 804 qemu_free(buf); 805 bdrv_delete(out_bs); 806 for (bs_i = 0; bs_i < bs_n; bs_i++) 807 bdrv_delete(bs[bs_i]); 808 free(bs); 809 return 0; 810 } 811 812 #ifdef _WIN32 813 static int64_t get_allocated_file_size(const char *filename) 814 { 815 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high); 816 get_compressed_t get_compressed; 817 struct _stati64 st; 818 819 /* WinNT support GetCompressedFileSize to determine allocate size */ 820 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA"); 821 if (get_compressed) { 822 DWORD high, low; 823 low = get_compressed(filename, &high); 824 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) 825 return (((int64_t) high) << 32) + low; 826 } 827 828 if (_stati64(filename, &st) < 0) 829 return -1; 830 return st.st_size; 831 } 832 #else 833 static int64_t get_allocated_file_size(const char *filename) 834 { 835 struct stat st; 836 if (stat(filename, &st) < 0) 837 return -1; 838 return (int64_t)st.st_blocks * 512; 839 } 840 #endif 841 842 static void dump_snapshots(BlockDriverState *bs) 843 { 844 QEMUSnapshotInfo *sn_tab, *sn; 845 int nb_sns, i; 846 char buf[256]; 847 848 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 849 if (nb_sns <= 0) 850 return; 851 printf("Snapshot list:\n"); 852 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 853 for(i = 0; i < nb_sns; i++) { 854 sn = &sn_tab[i]; 855 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 856 } 857 qemu_free(sn_tab); 858 } 859 860 static int img_info(int argc, char **argv) 861 { 862 int c; 863 const char *filename, *fmt; 864 BlockDriverState *bs; 865 char fmt_name[128], size_buf[128], dsize_buf[128]; 866 uint64_t total_sectors; 867 int64_t allocated_size; 868 char backing_filename[1024]; 869 char backing_filename2[1024]; 870 BlockDriverInfo bdi; 871 872 fmt = NULL; 873 for(;;) { 874 c = getopt(argc, argv, "f:h"); 875 if (c == -1) 876 break; 877 switch(c) { 878 case 'h': 879 help(); 880 break; 881 case 'f': 882 fmt = optarg; 883 break; 884 } 885 } 886 if (optind >= argc) 887 help(); 888 filename = argv[optind++]; 889 890 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING); 891 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 892 bdrv_get_geometry(bs, &total_sectors); 893 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 894 allocated_size = get_allocated_file_size(filename); 895 if (allocated_size < 0) 896 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 897 else 898 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 899 allocated_size); 900 printf("image: %s\n" 901 "file format: %s\n" 902 "virtual size: %s (%" PRId64 " bytes)\n" 903 "disk size: %s\n", 904 filename, fmt_name, size_buf, 905 (total_sectors * 512), 906 dsize_buf); 907 if (bdrv_is_encrypted(bs)) 908 printf("encrypted: yes\n"); 909 if (bdrv_get_info(bs, &bdi) >= 0) { 910 if (bdi.cluster_size != 0) 911 printf("cluster_size: %d\n", bdi.cluster_size); 912 } 913 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 914 if (backing_filename[0] != '\0') { 915 path_combine(backing_filename2, sizeof(backing_filename2), 916 filename, backing_filename); 917 printf("backing file: %s (actual path: %s)\n", 918 backing_filename, 919 backing_filename2); 920 } 921 dump_snapshots(bs); 922 bdrv_delete(bs); 923 return 0; 924 } 925 926 #define SNAPSHOT_LIST 1 927 #define SNAPSHOT_CREATE 2 928 #define SNAPSHOT_APPLY 3 929 #define SNAPSHOT_DELETE 4 930 931 static int img_snapshot(int argc, char **argv) 932 { 933 BlockDriverState *bs; 934 QEMUSnapshotInfo sn; 935 char *filename, *snapshot_name = NULL; 936 int c, ret, bdrv_oflags; 937 int action = 0; 938 qemu_timeval tv; 939 940 bdrv_oflags = BDRV_O_RDWR; 941 /* Parse commandline parameters */ 942 for(;;) { 943 c = getopt(argc, argv, "la:c:d:h"); 944 if (c == -1) 945 break; 946 switch(c) { 947 case 'h': 948 help(); 949 return 0; 950 case 'l': 951 if (action) { 952 help(); 953 return 0; 954 } 955 action = SNAPSHOT_LIST; 956 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */ 957 break; 958 case 'a': 959 if (action) { 960 help(); 961 return 0; 962 } 963 action = SNAPSHOT_APPLY; 964 snapshot_name = optarg; 965 break; 966 case 'c': 967 if (action) { 968 help(); 969 return 0; 970 } 971 action = SNAPSHOT_CREATE; 972 snapshot_name = optarg; 973 break; 974 case 'd': 975 if (action) { 976 help(); 977 return 0; 978 } 979 action = SNAPSHOT_DELETE; 980 snapshot_name = optarg; 981 break; 982 } 983 } 984 985 if (optind >= argc) 986 help(); 987 filename = argv[optind++]; 988 989 /* Open the image */ 990 bs = bdrv_new_open(filename, NULL, bdrv_oflags); 991 992 /* Perform the requested action */ 993 switch(action) { 994 case SNAPSHOT_LIST: 995 dump_snapshots(bs); 996 break; 997 998 case SNAPSHOT_CREATE: 999 memset(&sn, 0, sizeof(sn)); 1000 pstrcpy(sn.name, sizeof(sn.name), snapshot_name); 1001 1002 qemu_gettimeofday(&tv); 1003 sn.date_sec = tv.tv_sec; 1004 sn.date_nsec = tv.tv_usec * 1000; 1005 1006 ret = bdrv_snapshot_create(bs, &sn); 1007 if (ret) 1008 error("Could not create snapshot '%s': %d (%s)", 1009 snapshot_name, ret, strerror(-ret)); 1010 break; 1011 1012 case SNAPSHOT_APPLY: 1013 ret = bdrv_snapshot_goto(bs, snapshot_name); 1014 if (ret) 1015 error("Could not apply snapshot '%s': %d (%s)", 1016 snapshot_name, ret, strerror(-ret)); 1017 break; 1018 1019 case SNAPSHOT_DELETE: 1020 ret = bdrv_snapshot_delete(bs, snapshot_name); 1021 if (ret) 1022 error("Could not delete snapshot '%s': %d (%s)", 1023 snapshot_name, ret, strerror(-ret)); 1024 break; 1025 } 1026 1027 /* Cleanup */ 1028 bdrv_delete(bs); 1029 1030 return 0; 1031 } 1032 1033 static int img_rebase(int argc, char **argv) 1034 { 1035 BlockDriverState *bs, *bs_old_backing, *bs_new_backing; 1036 BlockDriver *old_backing_drv, *new_backing_drv; 1037 char *filename; 1038 const char *fmt, *out_basefmt, *out_baseimg; 1039 int c, flags, ret; 1040 int unsafe = 0; 1041 1042 /* Parse commandline parameters */ 1043 fmt = NULL; 1044 out_baseimg = NULL; 1045 out_basefmt = NULL; 1046 1047 for(;;) { 1048 c = getopt(argc, argv, "uhf:F:b:"); 1049 if (c == -1) 1050 break; 1051 switch(c) { 1052 case 'h': 1053 help(); 1054 return 0; 1055 case 'f': 1056 fmt = optarg; 1057 break; 1058 case 'F': 1059 out_basefmt = optarg; 1060 break; 1061 case 'b': 1062 out_baseimg = optarg; 1063 break; 1064 case 'u': 1065 unsafe = 1; 1066 break; 1067 } 1068 } 1069 1070 if ((optind >= argc) || !out_baseimg) 1071 help(); 1072 filename = argv[optind++]; 1073 1074 /* 1075 * Open the images. 1076 * 1077 * Ignore the old backing file for unsafe rebase in case we want to correct 1078 * the reference to a renamed or moved backing file. 1079 */ 1080 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0); 1081 bs = bdrv_new_open(filename, fmt, flags); 1082 1083 /* Find the right drivers for the backing files */ 1084 old_backing_drv = NULL; 1085 new_backing_drv = NULL; 1086 1087 if (!unsafe && bs->backing_format[0] != '\0') { 1088 old_backing_drv = bdrv_find_format(bs->backing_format); 1089 if (old_backing_drv == NULL) { 1090 error("Invalid format name: '%s'", bs->backing_format); 1091 } 1092 } 1093 1094 if (out_basefmt != NULL) { 1095 new_backing_drv = bdrv_find_format(out_basefmt); 1096 if (new_backing_drv == NULL) { 1097 error("Invalid format name: '%s'", out_basefmt); 1098 } 1099 } 1100 1101 /* For safe rebasing we need to compare old and new backing file */ 1102 if (unsafe) { 1103 /* Make the compiler happy */ 1104 bs_old_backing = NULL; 1105 bs_new_backing = NULL; 1106 } else { 1107 char backing_name[1024]; 1108 1109 bs_old_backing = bdrv_new("old_backing"); 1110 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); 1111 if (bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS, 1112 old_backing_drv)) 1113 { 1114 error("Could not open old backing file '%s'", backing_name); 1115 return -1; 1116 } 1117 1118 bs_new_backing = bdrv_new("new_backing"); 1119 if (bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS | BDRV_O_RDWR, 1120 new_backing_drv)) 1121 { 1122 error("Could not open new backing file '%s'", out_baseimg); 1123 return -1; 1124 } 1125 } 1126 1127 /* 1128 * Check each unallocated cluster in the COW file. If it is unallocated, 1129 * accesses go to the backing file. We must therefore compare this cluster 1130 * in the old and new backing file, and if they differ we need to copy it 1131 * from the old backing file into the COW file. 1132 * 1133 * If qemu-img crashes during this step, no harm is done. The content of 1134 * the image is the same as the original one at any time. 1135 */ 1136 if (!unsafe) { 1137 uint64_t num_sectors; 1138 uint64_t sector; 1139 int n, n1; 1140 uint8_t * buf_old; 1141 uint8_t * buf_new; 1142 1143 buf_old = qemu_malloc(IO_BUF_SIZE); 1144 buf_new = qemu_malloc(IO_BUF_SIZE); 1145 1146 bdrv_get_geometry(bs, &num_sectors); 1147 1148 for (sector = 0; sector < num_sectors; sector += n) { 1149 1150 /* How many sectors can we handle with the next read? */ 1151 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) { 1152 n = (IO_BUF_SIZE / 512); 1153 } else { 1154 n = num_sectors - sector; 1155 } 1156 1157 /* If the cluster is allocated, we don't need to take action */ 1158 if (bdrv_is_allocated(bs, sector, n, &n1)) { 1159 n = n1; 1160 continue; 1161 } 1162 1163 /* Read old and new backing file */ 1164 if (bdrv_read(bs_old_backing, sector, buf_old, n) < 0) { 1165 error("error while reading from old backing file"); 1166 } 1167 if (bdrv_read(bs_new_backing, sector, buf_new, n) < 0) { 1168 error("error while reading from new backing file"); 1169 } 1170 1171 /* If they differ, we need to write to the COW file */ 1172 uint64_t written = 0; 1173 1174 while (written < n) { 1175 int pnum; 1176 1177 if (compare_sectors(buf_old + written * 512, 1178 buf_new + written * 512, n - written, &pnum)) 1179 { 1180 ret = bdrv_write(bs, sector + written, 1181 buf_old + written * 512, pnum); 1182 if (ret < 0) { 1183 error("Error while writing to COW image: %s", 1184 strerror(-ret)); 1185 } 1186 } 1187 1188 written += pnum; 1189 } 1190 } 1191 1192 qemu_free(buf_old); 1193 qemu_free(buf_new); 1194 } 1195 1196 /* 1197 * Change the backing file. All clusters that are different from the old 1198 * backing file are overwritten in the COW file now, so the visible content 1199 * doesn't change when we switch the backing file. 1200 */ 1201 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt); 1202 if (ret == -ENOSPC) { 1203 error("Could not change the backing file to '%s': No space left in " 1204 "the file header", out_baseimg); 1205 } else if (ret < 0) { 1206 error("Could not change the backing file to '%s': %s", 1207 out_baseimg, strerror(-ret)); 1208 } 1209 1210 /* 1211 * TODO At this point it is possible to check if any clusters that are 1212 * allocated in the COW file are the same in the backing file. If so, they 1213 * could be dropped from the COW file. Don't do this before switching the 1214 * backing file, in case of a crash this would lead to corruption. 1215 */ 1216 1217 /* Cleanup */ 1218 if (!unsafe) { 1219 bdrv_delete(bs_old_backing); 1220 bdrv_delete(bs_new_backing); 1221 } 1222 1223 bdrv_delete(bs); 1224 1225 return 0; 1226 } 1227 1228 static const img_cmd_t img_cmds[] = { 1229 #define DEF(option, callback, arg_string) \ 1230 { option, callback }, 1231 #include "qemu-img-cmds.h" 1232 #undef DEF 1233 #undef GEN_DOCS 1234 { NULL, NULL, }, 1235 }; 1236 1237 int main(int argc, char **argv) 1238 { 1239 const img_cmd_t *cmd; 1240 const char *cmdname; 1241 1242 bdrv_init(); 1243 if (argc < 2) 1244 help(); 1245 cmdname = argv[1]; 1246 argc--; argv++; 1247 1248 /* find the command */ 1249 for(cmd = img_cmds; cmd->name != NULL; cmd++) { 1250 if (!strcmp(cmdname, cmd->name)) { 1251 return cmd->handler(argc, argv); 1252 } 1253 } 1254 1255 /* not found */ 1256 help(); 1257 return 0; 1258 } 1259