2 * QEMU disk image utility
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 #include "qemu-common.h"
25 #include "qemu-option.h"
27 #include "block_int.h"
34 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
35 #define BRDV_O_FLAGS BDRV_O_CACHE_WB
37 static void QEMU_NORETURN
error(const char *fmt
, ...)
41 fprintf(stderr
, "qemu-img: ");
42 vfprintf(stderr
, fmt
, ap
);
43 fprintf(stderr
, "\n");
48 static void format_print(void *opaque
, const char *name
)
53 /* Please keep in synch with qemu-img.texi */
54 static void help(void)
56 printf("qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
57 "usage: qemu-img command [command options]\n"
58 "QEMU disk image utility\n"
61 " check [-f fmt] filename\n"
62 " create [-e] [-6] [-F fmt] [-b base_image] [-f fmt] filename [size]\n"
63 " commit [-f fmt] filename\n"
64 " convert [-c] [-e] [-6] [-f fmt] [-O output_fmt] [-B output_base_image] filename [filename2 [...]] output_filename\n"
65 " info [-f fmt] filename\n"
66 " snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\n"
68 "Command parameters:\n"
69 " 'filename' is a disk image filename\n"
70 " 'base_image' is the read-only disk image which is used as base for a copy on\n"
71 " write image; the copy on write image only stores the modified data\n"
72 " 'output_base_image' forces the output image to be created as a copy on write\n"
73 " image of the specified base image; 'output_base_image' should have the same\n"
74 " content as the input's base image, however the path, image format, etc may\n"
76 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
77 " 'size' is the disk image size in kilobytes. Optional suffixes\n"
78 " 'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\n"
79 " supported any 'k' or 'K' is ignored\n"
80 " 'output_filename' is the destination disk image filename\n"
81 " 'output_fmt' is the destination format\n"
82 " '-c' indicates that target image must be compressed (qcow format only)\n"
83 " '-e' indicates that the target image must be encrypted (qcow format only)\n"
84 " '-6' indicates that the target image must use compatibility level 6 (vmdk format only)\n"
85 " '-h' with or without a command shows this help and lists the supported formats\n"
87 "Parameters to snapshot subcommand:\n"
88 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
89 " '-a' applies a snapshot (revert disk to saved state)\n"
90 " '-c' creates a snapshot\n"
91 " '-d' deletes a snapshot\n"
92 " '-l' lists all snapshots in the given image\n"
94 printf("\nSupported formats:");
95 bdrv_iterate_format(format_print
, NULL
);
101 /* XXX: put correct support for win32 */
102 static int read_password(char *buf
, int buf_size
)
105 printf("Password: ");
112 if (i
< (buf_size
- 1))
123 static struct termios oldtty
;
125 static void term_exit(void)
127 tcsetattr (0, TCSANOW
, &oldtty
);
130 static void term_init(void)
137 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
138 |INLCR
|IGNCR
|ICRNL
|IXON
);
139 tty
.c_oflag
|= OPOST
;
140 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
141 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
146 tcsetattr (0, TCSANOW
, &tty
);
151 static int read_password(char *buf
, int buf_size
)
156 printf("password: ");
161 ret
= read(0, &ch
, 1);
163 if (errno
== EAGAIN
|| errno
== EINTR
) {
169 } else if (ret
== 0) {
177 if (i
< (buf_size
- 1))
188 static BlockDriverState
*bdrv_new_open(const char *filename
,
191 BlockDriverState
*bs
;
197 error("Not enough memory");
199 drv
= bdrv_find_format(fmt
);
201 error("Unknown file format '%s'", fmt
);
205 if (bdrv_open2(bs
, filename
, BRDV_O_FLAGS
, drv
) < 0) {
206 error("Could not open '%s'", filename
);
208 if (bdrv_is_encrypted(bs
)) {
209 printf("Disk image '%s' is encrypted.\n", filename
);
210 if (read_password(password
, sizeof(password
)) < 0)
211 error("No password given");
212 if (bdrv_set_key(bs
, password
) < 0)
213 error("invalid password");
218 static int img_create(int argc
, char **argv
)
221 const char *fmt
= "raw";
222 const char *base_fmt
= NULL
;
223 const char *filename
;
224 const char *base_filename
= NULL
;
226 QEMUOptionParameter
*param
= NULL
;
227 char *options
= NULL
;
231 c
= getopt(argc
, argv
, "F:b:f:he6o:");
242 base_filename
= optarg
;
248 flags
|= BLOCK_FLAG_ENCRYPT
;
251 flags
|= BLOCK_FLAG_COMPAT6
;
260 filename
= argv
[optind
++];
262 /* Find driver and parse its options */
263 drv
= bdrv_find_format(fmt
);
265 error("Unknown file format '%s'", fmt
);
268 param
= parse_option_parameters(options
, drv
->create_options
, param
);
270 error("Invalid options for file format '%s'.", fmt
);
273 param
= parse_option_parameters("", drv
->create_options
, param
);
276 /* Add size to parameters */
278 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
281 /* Add old-style options to parameters */
282 if (flags
& BLOCK_FLAG_ENCRYPT
) {
283 if (set_option_parameter(param
, BLOCK_OPT_ENCRYPT
, "on")) {
284 error("Encryption not supported for file format '%s'", fmt
);
287 if (flags
& BLOCK_FLAG_COMPAT6
) {
288 if (set_option_parameter(param
, BLOCK_OPT_COMPAT6
, "on")) {
289 error("VMDK version 6 not supported for file format '%s'", fmt
);
294 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
295 error("Backing file not supported for file format '%s'", fmt
);
299 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
300 error("Backing file format not supported for file format '%s'", fmt
);
304 // The size for the image must always be specified, with one exception:
305 // If we are using a backing file, we can obtain the size from there
306 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== 0) {
308 QEMUOptionParameter
*backing_file
=
309 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
310 QEMUOptionParameter
*backing_fmt
=
311 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
313 if (backing_file
&& backing_file
->value
.s
) {
314 BlockDriverState
*bs
;
316 const char *fmt
= NULL
;
319 if (backing_fmt
&& backing_fmt
->value
.s
) {
320 if (bdrv_find_format(backing_fmt
->value
.s
)) {
321 fmt
= backing_fmt
->value
.s
;
323 error("Unknown backing file format '%s'",
324 backing_fmt
->value
.s
);
328 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
);
329 bdrv_get_geometry(bs
, &size
);
333 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
334 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
336 error("Image creation needs a size parameter");
340 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
341 print_option_parameters(param
);
344 ret
= bdrv_create(drv
, filename
, param
);
345 free_option_parameters(param
);
348 if (ret
== -ENOTSUP
) {
349 error("Formatting or formatting option not supported for file format '%s'", fmt
);
350 } else if (ret
== -EFBIG
) {
351 error("The image size is too large for file format '%s'", fmt
);
353 error("Error while formatting");
359 static int img_check(int argc
, char **argv
)
362 const char *filename
, *fmt
;
364 BlockDriverState
*bs
;
368 c
= getopt(argc
, argv
, "f:h");
382 filename
= argv
[optind
++];
386 error("Not enough memory");
388 drv
= bdrv_find_format(fmt
);
390 error("Unknown file format '%s'", fmt
);
394 if (bdrv_open2(bs
, filename
, BRDV_O_FLAGS
, drv
) < 0) {
395 error("Could not open '%s'", filename
);
397 ret
= bdrv_check(bs
);
400 printf("No errors were found on the image.\n");
403 error("This image format does not support checks");
407 error("An error occurred during the check");
409 printf("%d errors were found on the image.\n", ret
);
418 static int img_commit(int argc
, char **argv
)
421 const char *filename
, *fmt
;
423 BlockDriverState
*bs
;
427 c
= getopt(argc
, argv
, "f:h");
441 filename
= argv
[optind
++];
445 error("Not enough memory");
447 drv
= bdrv_find_format(fmt
);
449 error("Unknown file format '%s'", fmt
);
453 if (bdrv_open2(bs
, filename
, BRDV_O_FLAGS
, drv
) < 0) {
454 error("Could not open '%s'", filename
);
456 ret
= bdrv_commit(bs
);
459 printf("Image committed.\n");
462 error("No disk inserted");
465 error("Image is read-only");
468 error("Image is already committed");
471 error("Error while committing image");
479 static int is_not_zero(const uint8_t *sector
, int len
)
483 for(i
= 0;i
< len
; i
++) {
484 if (((uint32_t *)sector
)[i
] != 0)
491 * Returns true iff the first sector pointed to by 'buf' contains at least
494 * 'pnum' is set to the number of sectors (including and immediately following
495 * the first one) that are known to be in the same allocated/unallocated state.
497 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
505 v
= is_not_zero(buf
, 512);
506 for(i
= 1; i
< n
; i
++) {
508 if (v
!= is_not_zero(buf
, 512))
515 #define IO_BUF_SIZE 65536
517 static int img_convert(int argc
, char **argv
)
519 int c
, ret
, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
520 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
522 BlockDriverState
**bs
, *out_bs
;
523 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
525 uint8_t buf
[IO_BUF_SIZE
];
534 c
= getopt(argc
, argv
, "f:O:B:hce6");
548 out_baseimg
= optarg
;
551 flags
|= BLOCK_FLAG_COMPRESS
;
554 flags
|= BLOCK_FLAG_ENCRYPT
;
557 flags
|= BLOCK_FLAG_COMPAT6
;
562 bs_n
= argc
- optind
- 1;
563 if (bs_n
< 1) help();
565 out_filename
= argv
[argc
- 1];
567 if (bs_n
> 1 && out_baseimg
)
568 error("-B makes no sense when concatenating multiple input images");
570 bs
= calloc(bs_n
, sizeof(BlockDriverState
*));
572 error("Out of memory");
575 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
576 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
);
578 error("Could not open '%s'", argv
[optind
+ bs_i
]);
579 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
580 total_sectors
+= bs_sectors
;
583 drv
= bdrv_find_format(out_fmt
);
585 error("Unknown file format '%s'", out_fmt
);
586 if (flags
& BLOCK_FLAG_COMPRESS
&& strcmp(drv
->format_name
, "qcow") && strcmp(drv
->format_name
, "qcow2"))
587 error("Compression not supported for this file format");
588 if (flags
& BLOCK_FLAG_ENCRYPT
&& strcmp(drv
->format_name
, "qcow") && strcmp(drv
->format_name
, "qcow2"))
589 error("Encryption not supported for this file format");
590 if (flags
& BLOCK_FLAG_COMPAT6
&& strcmp(drv
->format_name
, "vmdk"))
591 error("Alternative compatibility level not supported for this file format");
592 if (flags
& BLOCK_FLAG_ENCRYPT
&& flags
& BLOCK_FLAG_COMPRESS
)
593 error("Compression and encryption not supported at the same time");
595 ret
= bdrv_create2(drv
, out_filename
, total_sectors
, out_baseimg
, NULL
, flags
);
597 if (ret
== -ENOTSUP
) {
598 error("Formatting not supported for file format '%s'", out_fmt
);
599 } else if (ret
== -EFBIG
) {
600 error("The image size is too large for file format '%s'", out_fmt
);
602 error("Error while formatting '%s'", out_filename
);
606 out_bs
= bdrv_new_open(out_filename
, out_fmt
);
610 bdrv_get_geometry(bs
[0], &bs_sectors
);
612 if (flags
& BLOCK_FLAG_COMPRESS
) {
613 if (bdrv_get_info(out_bs
, &bdi
) < 0)
614 error("could not get block driver info");
615 cluster_size
= bdi
.cluster_size
;
616 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
)
617 error("invalid cluster size");
618 cluster_sectors
= cluster_size
>> 9;
625 nb_sectors
= total_sectors
- sector_num
;
628 if (nb_sectors
>= cluster_sectors
)
633 bs_num
= sector_num
- bs_offset
;
634 assert (bs_num
>= 0);
637 while (remainder
> 0) {
639 while (bs_num
== bs_sectors
) {
641 assert (bs_i
< bs_n
);
642 bs_offset
+= bs_sectors
;
643 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
645 /* printf("changing part: sector_num=%lld, "
646 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
647 sector_num, bs_i, bs_offset, bs_sectors); */
649 assert (bs_num
< bs_sectors
);
651 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
653 if (bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
) < 0)
654 error("error while reading");
661 assert (remainder
== 0);
663 if (n
< cluster_sectors
)
664 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
665 if (is_not_zero(buf
, cluster_size
)) {
666 if (bdrv_write_compressed(out_bs
, sector_num
, buf
,
667 cluster_sectors
) != 0)
668 error("error while compressing sector %" PRId64
,
673 /* signal EOF to align */
674 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
676 sector_num
= 0; // total number of sectors converted so far
678 nb_sectors
= total_sectors
- sector_num
;
681 if (nb_sectors
>= (IO_BUF_SIZE
/ 512))
682 n
= (IO_BUF_SIZE
/ 512);
686 while (sector_num
- bs_offset
>= bs_sectors
) {
688 assert (bs_i
< bs_n
);
689 bs_offset
+= bs_sectors
;
690 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
691 /* printf("changing part: sector_num=%lld, bs_i=%d, "
692 "bs_offset=%lld, bs_sectors=%lld\n",
693 sector_num, bs_i, bs_offset, bs_sectors); */
696 if (n
> bs_offset
+ bs_sectors
- sector_num
)
697 n
= bs_offset
+ bs_sectors
- sector_num
;
699 if (strcmp(drv
->format_name
, "host_device")) {
700 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
705 /* The next 'n1' sectors are allocated in the input image. Copy
706 only those as they may be followed by unallocated sectors. */
712 if (bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
) < 0)
713 error("error while reading");
714 /* NOTE: at the same time we convert, we do not write zero
715 sectors to have a chance to compress the image. Ideally, we
716 should add a specific call to have the info to go faster */
719 /* If the output image is being created as a copy on write image,
720 copy all sectors even the ones containing only NUL bytes,
721 because they may differ from the sectors in the base image.
723 If the output is to a host device, we also write out
724 sectors that are entirely 0, since whatever data was
725 already there is garbage, not 0s. */
726 if (strcmp(drv
->format_name
, "host_device") == 0 || out_baseimg
||
727 is_allocated_sectors(buf1
, n
, &n1
)) {
728 if (bdrv_write(out_bs
, sector_num
, buf1
, n1
) < 0)
729 error("error while writing");
738 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++)
739 bdrv_delete(bs
[bs_i
]);
745 static int64_t get_allocated_file_size(const char *filename
)
747 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
748 get_compressed_t get_compressed
;
751 /* WinNT support GetCompressedFileSize to determine allocate size */
752 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
753 if (get_compressed
) {
755 low
= get_compressed(filename
, &high
);
756 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
757 return (((int64_t) high
) << 32) + low
;
760 if (_stati64(filename
, &st
) < 0)
765 static int64_t get_allocated_file_size(const char *filename
)
768 if (stat(filename
, &st
) < 0)
770 return (int64_t)st
.st_blocks
* 512;
774 static void dump_snapshots(BlockDriverState
*bs
)
776 QEMUSnapshotInfo
*sn_tab
, *sn
;
780 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
783 printf("Snapshot list:\n");
784 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
785 for(i
= 0; i
< nb_sns
; i
++) {
787 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
792 static int img_info(int argc
, char **argv
)
795 const char *filename
, *fmt
;
797 BlockDriverState
*bs
;
798 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
799 uint64_t total_sectors
;
800 int64_t allocated_size
;
801 char backing_filename
[1024];
802 char backing_filename2
[1024];
807 c
= getopt(argc
, argv
, "f:h");
821 filename
= argv
[optind
++];
825 error("Not enough memory");
827 drv
= bdrv_find_format(fmt
);
829 error("Unknown file format '%s'", fmt
);
833 if (bdrv_open2(bs
, filename
, BRDV_O_FLAGS
, drv
) < 0) {
834 error("Could not open '%s'", filename
);
836 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
837 bdrv_get_geometry(bs
, &total_sectors
);
838 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
839 allocated_size
= get_allocated_file_size(filename
);
840 if (allocated_size
< 0)
841 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
843 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
847 "virtual size: %s (%" PRId64
" bytes)\n"
849 filename
, fmt_name
, size_buf
,
850 (total_sectors
* 512),
852 if (bdrv_is_encrypted(bs
))
853 printf("encrypted: yes\n");
854 if (bdrv_get_info(bs
, &bdi
) >= 0) {
855 if (bdi
.cluster_size
!= 0)
856 printf("cluster_size: %d\n", bdi
.cluster_size
);
858 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
859 if (backing_filename
[0] != '\0') {
860 path_combine(backing_filename2
, sizeof(backing_filename2
),
861 filename
, backing_filename
);
862 printf("backing file: %s (actual path: %s)\n",
871 #define SNAPSHOT_LIST 1
872 #define SNAPSHOT_CREATE 2
873 #define SNAPSHOT_APPLY 3
874 #define SNAPSHOT_DELETE 4
876 static void img_snapshot(int argc
, char **argv
)
878 BlockDriverState
*bs
;
880 char *filename
, *snapshot_name
= NULL
;
885 /* Parse commandline parameters */
887 c
= getopt(argc
, argv
, "la:c:d:h");
899 action
= SNAPSHOT_LIST
;
906 action
= SNAPSHOT_APPLY
;
907 snapshot_name
= optarg
;
914 action
= SNAPSHOT_CREATE
;
915 snapshot_name
= optarg
;
922 action
= SNAPSHOT_DELETE
;
923 snapshot_name
= optarg
;
930 filename
= argv
[optind
++];
935 error("Not enough memory");
937 if (bdrv_open2(bs
, filename
, 0, NULL
) < 0) {
938 error("Could not open '%s'", filename
);
941 /* Perform the requested action */
947 case SNAPSHOT_CREATE
:
948 memset(&sn
, 0, sizeof(sn
));
949 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
951 qemu_gettimeofday(&tv
);
952 sn
.date_sec
= tv
.tv_sec
;
953 sn
.date_nsec
= tv
.tv_usec
* 1000;
955 ret
= bdrv_snapshot_create(bs
, &sn
);
957 error("Could not create snapshot '%s': %d (%s)",
958 snapshot_name
, ret
, strerror(-ret
));
962 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
964 error("Could not apply snapshot '%s': %d (%s)",
965 snapshot_name
, ret
, strerror(-ret
));
968 case SNAPSHOT_DELETE
:
969 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
971 error("Could not delete snapshot '%s': %d (%s)",
972 snapshot_name
, ret
, strerror(-ret
));
980 int main(int argc
, char **argv
)
989 if (!strcmp(cmd
, "create")) {
990 img_create(argc
, argv
);
991 } else if (!strcmp(cmd
, "check")) {
992 img_check(argc
, argv
);
993 } else if (!strcmp(cmd
, "commit")) {
994 img_commit(argc
, argv
);
995 } else if (!strcmp(cmd
, "convert")) {
996 img_convert(argc
, argv
);
997 } else if (!strcmp(cmd
, "info")) {
998 img_info(argc
, argv
);
999 } else if (!strcmp(cmd
, "snapshot")) {
1000 img_snapshot(argc
, argv
);