1 /* 2 * QEMU disk image utility 3 * 4 * Copyright (c) 2003-2007 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 "block_int.h" 26 #include <assert.h> 27 28 #ifdef _WIN32 29 #include <windows.h> 30 #endif 31 32 void *get_mmap_addr(unsigned long size) 33 { 34 return NULL; 35 } 36 37 void qemu_free(void *ptr) 38 { 39 free(ptr); 40 } 41 42 void *qemu_malloc(size_t size) 43 { 44 return malloc(size); 45 } 46 47 void *qemu_mallocz(size_t size) 48 { 49 void *ptr; 50 ptr = qemu_malloc(size); 51 if (!ptr) 52 return NULL; 53 memset(ptr, 0, size); 54 return ptr; 55 } 56 57 char *qemu_strdup(const char *str) 58 { 59 char *ptr; 60 ptr = qemu_malloc(strlen(str) + 1); 61 if (!ptr) 62 return NULL; 63 strcpy(ptr, str); 64 return ptr; 65 } 66 67 static void __attribute__((noreturn)) error(const char *fmt, ...) 68 { 69 va_list ap; 70 va_start(ap, fmt); 71 fprintf(stderr, "qemu-img: "); 72 vfprintf(stderr, fmt, ap); 73 fprintf(stderr, "\n"); 74 exit(1); 75 va_end(ap); 76 } 77 78 static void format_print(void *opaque, const char *name) 79 { 80 printf(" %s", name); 81 } 82 83 static void help(void) 84 { 85 printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2007 Fabrice Bellard\n" 86 "usage: qemu-img command [command options]\n" 87 "QEMU disk image utility\n" 88 "\n" 89 "Command syntax:\n" 90 " create [-e] [-6] [-b base_image] [-f fmt] filename [size]\n" 91 " commit [-f fmt] filename\n" 92 " convert [-c] [-e] [-6] [-f fmt] filename [filename2 [...]] [-O output_fmt] output_filename\n" 93 " info [-f fmt] filename\n" 94 "\n" 95 "Command parameters:\n" 96 " 'filename' is a disk image filename\n" 97 " 'base_image' is the read-only disk image which is used as base for a copy on\n" 98 " write image; the copy on write image only stores the modified data\n" 99 " 'fmt' is the disk image format. It is guessed automatically in most cases\n" 100 " 'size' is the disk image size in kilobytes. Optional suffixes 'M' (megabyte)\n" 101 " and 'G' (gigabyte) are supported\n" 102 " 'output_filename' is the destination disk image filename\n" 103 " 'output_fmt' is the destination format\n" 104 " '-c' indicates that target image must be compressed (qcow format only)\n" 105 " '-e' indicates that the target image must be encrypted (qcow format only)\n" 106 " '-6' indicates that the target image must use compatibility level 6 (vmdk format only)\n" 107 ); 108 printf("\nSupported format:"); 109 bdrv_iterate_format(format_print, NULL); 110 printf("\n"); 111 exit(1); 112 } 113 114 #if defined(WIN32) 115 /* XXX: put correct support for win32 */ 116 static int read_password(char *buf, int buf_size) 117 { 118 int c, i; 119 printf("Password: "); 120 fflush(stdout); 121 i = 0; 122 for(;;) { 123 c = getchar(); 124 if (c == '\n') 125 break; 126 if (i < (buf_size - 1)) 127 buf[i++] = c; 128 } 129 buf[i] = '\0'; 130 return 0; 131 } 132 133 #else 134 135 #include <termios.h> 136 137 static struct termios oldtty; 138 139 static void term_exit(void) 140 { 141 tcsetattr (0, TCSANOW, &oldtty); 142 } 143 144 static void term_init(void) 145 { 146 struct termios tty; 147 148 tcgetattr (0, &tty); 149 oldtty = tty; 150 151 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 152 |INLCR|IGNCR|ICRNL|IXON); 153 tty.c_oflag |= OPOST; 154 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 155 tty.c_cflag &= ~(CSIZE|PARENB); 156 tty.c_cflag |= CS8; 157 tty.c_cc[VMIN] = 1; 158 tty.c_cc[VTIME] = 0; 159 160 tcsetattr (0, TCSANOW, &tty); 161 162 atexit(term_exit); 163 } 164 165 static int read_password(char *buf, int buf_size) 166 { 167 uint8_t ch; 168 int i, ret; 169 170 printf("password: "); 171 fflush(stdout); 172 term_init(); 173 i = 0; 174 for(;;) { 175 ret = read(0, &ch, 1); 176 if (ret == -1) { 177 if (errno == EAGAIN || errno == EINTR) { 178 continue; 179 } else { 180 ret = -1; 181 break; 182 } 183 } else if (ret == 0) { 184 ret = -1; 185 break; 186 } else { 187 if (ch == '\r') { 188 ret = 0; 189 break; 190 } 191 if (i < (buf_size - 1)) 192 buf[i++] = ch; 193 } 194 } 195 term_exit(); 196 buf[i] = '\0'; 197 printf("\n"); 198 return ret; 199 } 200 #endif 201 202 static BlockDriverState *bdrv_new_open(const char *filename, 203 const char *fmt) 204 { 205 BlockDriverState *bs; 206 BlockDriver *drv; 207 char password[256]; 208 209 bs = bdrv_new(""); 210 if (!bs) 211 error("Not enough memory"); 212 if (fmt) { 213 drv = bdrv_find_format(fmt); 214 if (!drv) 215 error("Unknown file format '%s'", fmt); 216 } else { 217 drv = NULL; 218 } 219 if (bdrv_open2(bs, filename, 0, drv) < 0) { 220 error("Could not open '%s'", filename); 221 } 222 if (bdrv_is_encrypted(bs)) { 223 printf("Disk image '%s' is encrypted.\n", filename); 224 if (read_password(password, sizeof(password)) < 0) 225 error("No password given"); 226 if (bdrv_set_key(bs, password) < 0) 227 error("invalid password"); 228 } 229 return bs; 230 } 231 232 static int img_create(int argc, char **argv) 233 { 234 int c, ret, flags; 235 const char *fmt = "raw"; 236 const char *filename; 237 const char *base_filename = NULL; 238 int64_t size; 239 const char *p; 240 BlockDriver *drv; 241 242 flags = 0; 243 for(;;) { 244 c = getopt(argc, argv, "b:f:he6"); 245 if (c == -1) 246 break; 247 switch(c) { 248 case 'h': 249 help(); 250 break; 251 case 'b': 252 base_filename = optarg; 253 break; 254 case 'f': 255 fmt = optarg; 256 break; 257 case 'e': 258 flags |= BLOCK_FLAG_ENCRYPT; 259 break; 260 case '6': 261 flags |= BLOCK_FLAG_COMPAT6; 262 break; 263 } 264 } 265 if (optind >= argc) 266 help(); 267 filename = argv[optind++]; 268 size = 0; 269 if (base_filename) { 270 BlockDriverState *bs; 271 bs = bdrv_new_open(base_filename, NULL); 272 bdrv_get_geometry(bs, &size); 273 size *= 512; 274 bdrv_delete(bs); 275 } else { 276 if (optind >= argc) 277 help(); 278 p = argv[optind]; 279 size = strtoul(p, (char **)&p, 0); 280 if (*p == 'M') { 281 size *= 1024 * 1024; 282 } else if (*p == 'G') { 283 size *= 1024 * 1024 * 1024; 284 } else if (*p == 'k' || *p == 'K' || *p == '\0') { 285 size *= 1024; 286 } else { 287 help(); 288 } 289 } 290 drv = bdrv_find_format(fmt); 291 if (!drv) 292 error("Unknown file format '%s'", fmt); 293 printf("Formatting '%s', fmt=%s", 294 filename, fmt); 295 if (flags & BLOCK_FLAG_ENCRYPT) 296 printf(", encrypted"); 297 if (flags & BLOCK_FLAG_COMPAT6) 298 printf(", compatibility level=6"); 299 if (base_filename) { 300 printf(", backing_file=%s", 301 base_filename); 302 } 303 printf(", size=%" PRId64 " kB\n", (int64_t) (size / 1024)); 304 ret = bdrv_create(drv, filename, size / 512, base_filename, flags); 305 if (ret < 0) { 306 if (ret == -ENOTSUP) { 307 error("Formatting or formatting option not supported for file format '%s'", fmt); 308 } else { 309 error("Error while formatting"); 310 } 311 } 312 return 0; 313 } 314 315 static int img_commit(int argc, char **argv) 316 { 317 int c, ret; 318 const char *filename, *fmt; 319 BlockDriver *drv; 320 BlockDriverState *bs; 321 322 fmt = NULL; 323 for(;;) { 324 c = getopt(argc, argv, "f:h"); 325 if (c == -1) 326 break; 327 switch(c) { 328 case 'h': 329 help(); 330 break; 331 case 'f': 332 fmt = optarg; 333 break; 334 } 335 } 336 if (optind >= argc) 337 help(); 338 filename = argv[optind++]; 339 340 bs = bdrv_new(""); 341 if (!bs) 342 error("Not enough memory"); 343 if (fmt) { 344 drv = bdrv_find_format(fmt); 345 if (!drv) 346 error("Unknown file format '%s'", fmt); 347 } else { 348 drv = NULL; 349 } 350 if (bdrv_open2(bs, filename, 0, drv) < 0) { 351 error("Could not open '%s'", filename); 352 } 353 ret = bdrv_commit(bs); 354 switch(ret) { 355 case 0: 356 printf("Image committed.\n"); 357 break; 358 case -ENOENT: 359 error("No disk inserted"); 360 break; 361 case -EACCES: 362 error("Image is read-only"); 363 break; 364 case -ENOTSUP: 365 error("Image is already committed"); 366 break; 367 default: 368 error("Error while committing image"); 369 break; 370 } 371 372 bdrv_delete(bs); 373 return 0; 374 } 375 376 static int is_not_zero(const uint8_t *sector, int len) 377 { 378 int i; 379 len >>= 2; 380 for(i = 0;i < len; i++) { 381 if (((uint32_t *)sector)[i] != 0) 382 return 1; 383 } 384 return 0; 385 } 386 387 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum) 388 { 389 int v, i; 390 391 if (n <= 0) { 392 *pnum = 0; 393 return 0; 394 } 395 v = is_not_zero(buf, 512); 396 for(i = 1; i < n; i++) { 397 buf += 512; 398 if (v != is_not_zero(buf, 512)) 399 break; 400 } 401 *pnum = i; 402 return v; 403 } 404 405 #define IO_BUF_SIZE 65536 406 407 static int img_convert(int argc, char **argv) 408 { 409 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors; 410 const char *fmt, *out_fmt, *out_filename; 411 BlockDriver *drv; 412 BlockDriverState **bs, *out_bs; 413 int64_t total_sectors, nb_sectors, sector_num, bs_offset, bs_sectors; 414 uint8_t buf[IO_BUF_SIZE]; 415 const uint8_t *buf1; 416 BlockDriverInfo bdi; 417 418 fmt = NULL; 419 out_fmt = "raw"; 420 flags = 0; 421 for(;;) { 422 c = getopt(argc, argv, "f:O:hce6"); 423 if (c == -1) 424 break; 425 switch(c) { 426 case 'h': 427 help(); 428 break; 429 case 'f': 430 fmt = optarg; 431 break; 432 case 'O': 433 out_fmt = optarg; 434 break; 435 case 'c': 436 flags |= BLOCK_FLAG_COMPRESS; 437 break; 438 case 'e': 439 flags |= BLOCK_FLAG_ENCRYPT; 440 break; 441 case '6': 442 flags |= BLOCK_FLAG_COMPAT6; 443 break; 444 } 445 } 446 447 bs_n = argc - optind - 1; 448 if (bs_n < 1) help(); 449 450 out_filename = argv[argc - 1]; 451 452 bs = calloc(bs_n, sizeof(BlockDriverState *)); 453 if (!bs) 454 error("Out of memory"); 455 456 total_sectors = 0; 457 for (bs_i = 0; bs_i < bs_n; bs_i++) { 458 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt); 459 if (!bs[bs_i]) 460 error("Could not open '%s'", argv[optind + bs_i]); 461 bdrv_get_geometry(bs[bs_i], &bs_sectors); 462 total_sectors += bs_sectors; 463 } 464 465 drv = bdrv_find_format(out_fmt); 466 if (!drv) 467 error("Unknown file format '%s'", out_fmt); 468 if (flags & BLOCK_FLAG_COMPRESS && drv != &bdrv_qcow && drv != &bdrv_qcow2) 469 error("Compression not supported for this file format"); 470 if (flags & BLOCK_FLAG_ENCRYPT && drv != &bdrv_qcow && drv != &bdrv_qcow2) 471 error("Encryption not supported for this file format"); 472 if (flags & BLOCK_FLAG_COMPAT6 && drv != &bdrv_vmdk) 473 error("Alternative compatibility level not supported for this file format"); 474 if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS) 475 error("Compression and encryption not supported at the same time"); 476 477 ret = bdrv_create(drv, out_filename, total_sectors, NULL, flags); 478 if (ret < 0) { 479 if (ret == -ENOTSUP) { 480 error("Formatting not supported for file format '%s'", fmt); 481 } else { 482 error("Error while formatting '%s'", out_filename); 483 } 484 } 485 486 out_bs = bdrv_new_open(out_filename, out_fmt); 487 488 bs_i = 0; 489 bs_offset = 0; 490 bdrv_get_geometry(bs[0], &bs_sectors); 491 492 if (flags & BLOCK_FLAG_COMPRESS) { 493 if (bdrv_get_info(out_bs, &bdi) < 0) 494 error("could not get block driver info"); 495 cluster_size = bdi.cluster_size; 496 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) 497 error("invalid cluster size"); 498 cluster_sectors = cluster_size >> 9; 499 sector_num = 0; 500 for(;;) { 501 int64_t bs_num; 502 int remainder; 503 uint8_t *buf2; 504 505 nb_sectors = total_sectors - sector_num; 506 if (nb_sectors <= 0) 507 break; 508 if (nb_sectors >= cluster_sectors) 509 n = cluster_sectors; 510 else 511 n = nb_sectors; 512 513 bs_num = sector_num - bs_offset; 514 assert (bs_num >= 0); 515 remainder = n; 516 buf2 = buf; 517 while (remainder > 0) { 518 int nlow; 519 while (bs_num == bs_sectors) { 520 bs_i++; 521 assert (bs_i < bs_n); 522 bs_offset += bs_sectors; 523 bdrv_get_geometry(bs[bs_i], &bs_sectors); 524 bs_num = 0; 525 /* printf("changing part: sector_num=%lld, " 526 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n", 527 sector_num, bs_i, bs_offset, bs_sectors); */ 528 } 529 assert (bs_num < bs_sectors); 530 531 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder; 532 533 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 534 error("error while reading"); 535 536 buf2 += nlow * 512; 537 bs_num += nlow; 538 539 remainder -= nlow; 540 } 541 assert (remainder == 0); 542 543 if (n < cluster_sectors) 544 memset(buf + n * 512, 0, cluster_size - n * 512); 545 if (is_not_zero(buf, cluster_size)) { 546 if (bdrv_write_compressed(out_bs, sector_num, buf, 547 cluster_sectors) != 0) 548 error("error while compressing sector %" PRId64, 549 sector_num); 550 } 551 sector_num += n; 552 } 553 /* signal EOF to align */ 554 bdrv_write_compressed(out_bs, 0, NULL, 0); 555 } else { 556 sector_num = 0; 557 for(;;) { 558 nb_sectors = total_sectors - sector_num; 559 if (nb_sectors <= 0) 560 break; 561 if (nb_sectors >= (IO_BUF_SIZE / 512)) 562 n = (IO_BUF_SIZE / 512); 563 else 564 n = nb_sectors; 565 566 while (sector_num - bs_offset >= bs_sectors) { 567 bs_i ++; 568 assert (bs_i < bs_n); 569 bs_offset += bs_sectors; 570 bdrv_get_geometry(bs[bs_i], &bs_sectors); 571 /* printf("changing part: sector_num=%lld, bs_i=%d, " 572 "bs_offset=%lld, bs_sectors=%lld\n", 573 sector_num, bs_i, bs_offset, bs_sectors); */ 574 } 575 576 if (n > bs_offset + bs_sectors - sector_num) 577 n = bs_offset + bs_sectors - sector_num; 578 579 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 580 error("error while reading"); 581 /* NOTE: at the same time we convert, we do not write zero 582 sectors to have a chance to compress the image. Ideally, we 583 should add a specific call to have the info to go faster */ 584 buf1 = buf; 585 while (n > 0) { 586 if (is_allocated_sectors(buf1, n, &n1)) { 587 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0) 588 error("error while writing"); 589 } 590 sector_num += n1; 591 n -= n1; 592 buf1 += n1 * 512; 593 } 594 } 595 } 596 bdrv_delete(out_bs); 597 for (bs_i = 0; bs_i < bs_n; bs_i++) 598 bdrv_delete(bs[bs_i]); 599 free(bs); 600 return 0; 601 } 602 603 #ifdef _WIN32 604 static int64_t get_allocated_file_size(const char *filename) 605 { 606 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high); 607 get_compressed_t get_compressed; 608 struct _stati64 st; 609 610 /* WinNT support GetCompressedFileSize to determine allocate size */ 611 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA"); 612 if (get_compressed) { 613 DWORD high, low; 614 low = get_compressed(filename, &high); 615 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) 616 return (((int64_t) high) << 32) + low; 617 } 618 619 if (_stati64(filename, &st) < 0) 620 return -1; 621 return st.st_size; 622 } 623 #else 624 static int64_t get_allocated_file_size(const char *filename) 625 { 626 struct stat st; 627 if (stat(filename, &st) < 0) 628 return -1; 629 return (int64_t)st.st_blocks * 512; 630 } 631 #endif 632 633 static void dump_snapshots(BlockDriverState *bs) 634 { 635 QEMUSnapshotInfo *sn_tab, *sn; 636 int nb_sns, i; 637 char buf[256]; 638 639 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 640 if (nb_sns <= 0) 641 return; 642 printf("Snapshot list:\n"); 643 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL)); 644 for(i = 0; i < nb_sns; i++) { 645 sn = &sn_tab[i]; 646 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn)); 647 } 648 qemu_free(sn_tab); 649 } 650 651 static int img_info(int argc, char **argv) 652 { 653 int c; 654 const char *filename, *fmt; 655 BlockDriver *drv; 656 BlockDriverState *bs; 657 char fmt_name[128], size_buf[128], dsize_buf[128]; 658 int64_t total_sectors, allocated_size; 659 char backing_filename[1024]; 660 char backing_filename2[1024]; 661 BlockDriverInfo bdi; 662 663 fmt = NULL; 664 for(;;) { 665 c = getopt(argc, argv, "f:h"); 666 if (c == -1) 667 break; 668 switch(c) { 669 case 'h': 670 help(); 671 break; 672 case 'f': 673 fmt = optarg; 674 break; 675 } 676 } 677 if (optind >= argc) 678 help(); 679 filename = argv[optind++]; 680 681 bs = bdrv_new(""); 682 if (!bs) 683 error("Not enough memory"); 684 if (fmt) { 685 drv = bdrv_find_format(fmt); 686 if (!drv) 687 error("Unknown file format '%s'", fmt); 688 } else { 689 drv = NULL; 690 } 691 if (bdrv_open2(bs, filename, 0, drv) < 0) { 692 error("Could not open '%s'", filename); 693 } 694 bdrv_get_format(bs, fmt_name, sizeof(fmt_name)); 695 bdrv_get_geometry(bs, &total_sectors); 696 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512); 697 allocated_size = get_allocated_file_size(filename); 698 if (allocated_size < 0) 699 sprintf(dsize_buf, "unavailable"); 700 else 701 get_human_readable_size(dsize_buf, sizeof(dsize_buf), 702 allocated_size); 703 printf("image: %s\n" 704 "file format: %s\n" 705 "virtual size: %s (%" PRId64 " bytes)\n" 706 "disk size: %s\n", 707 filename, fmt_name, size_buf, 708 (total_sectors * 512), 709 dsize_buf); 710 if (bdrv_is_encrypted(bs)) 711 printf("encrypted: yes\n"); 712 if (bdrv_get_info(bs, &bdi) >= 0) { 713 if (bdi.cluster_size != 0) 714 printf("cluster_size: %d\n", bdi.cluster_size); 715 } 716 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); 717 if (backing_filename[0] != '\0') { 718 path_combine(backing_filename2, sizeof(backing_filename2), 719 filename, backing_filename); 720 printf("backing file: %s (actual path: %s)\n", 721 backing_filename, 722 backing_filename2); 723 } 724 dump_snapshots(bs); 725 bdrv_delete(bs); 726 return 0; 727 } 728 729 int main(int argc, char **argv) 730 { 731 const char *cmd; 732 733 bdrv_init(); 734 if (argc < 2) 735 help(); 736 cmd = argv[1]; 737 optind++; 738 if (!strcmp(cmd, "create")) { 739 img_create(argc, argv); 740 } else if (!strcmp(cmd, "commit")) { 741 img_commit(argc, argv); 742 } else if (!strcmp(cmd, "convert")) { 743 img_convert(argc, argv); 744 } else if (!strcmp(cmd, "info")) { 745 img_info(argc, argv); 746 } else { 747 help(); 748 } 749 return 0; 750 } 751