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"
28 #include "block_int.h"
35 typedef struct img_cmd_t
{
37 int (*handler
)(int argc
, char **argv
);
40 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
41 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43 static void GCC_FMT_ATTR(1, 2) error(const char *fmt
, ...)
47 fprintf(stderr
, "qemu-img: ");
48 vfprintf(stderr
, fmt
, ap
);
49 fprintf(stderr
, "\n");
53 static void format_print(void *opaque
, const char *name
)
58 /* Please keep in synch with qemu-img.texi */
59 static void help(void)
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"
67 #define DEF(option, callback, arg_string) \
69 #include "qemu-img-cmds.h"
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"
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"
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";
97 printf("%s\nSupported formats:", help_msg
);
98 bdrv_iterate_format(format_print
, NULL
);
104 /* XXX: put correct support for win32 */
105 static int read_password(char *buf
, int buf_size
)
108 printf("Password: ");
115 if (i
< (buf_size
- 1))
126 static struct termios oldtty
;
128 static void term_exit(void)
130 tcsetattr (0, TCSANOW
, &oldtty
);
133 static void term_init(void)
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
);
149 tcsetattr (0, TCSANOW
, &tty
);
154 static int read_password(char *buf
, int buf_size
)
159 printf("password: ");
164 ret
= read(0, &ch
, 1);
166 if (errno
== EAGAIN
|| errno
== EINTR
) {
172 } else if (ret
== 0) {
180 if (i
< (buf_size
- 1))
191 static BlockDriverState
*bdrv_new_open(const char *filename
,
195 BlockDriverState
*bs
;
201 error("Not enough memory");
205 drv
= bdrv_find_format(fmt
);
207 error("Unknown file format '%s'", fmt
);
213 if (bdrv_open(bs
, filename
, flags
, drv
) < 0) {
214 error("Could not open '%s'", filename
);
217 if (bdrv_is_encrypted(bs
)) {
218 printf("Disk image '%s' is encrypted.\n", filename
);
219 if (read_password(password
, sizeof(password
)) < 0) {
220 error("No password given");
223 if (bdrv_set_key(bs
, password
) < 0) {
224 error("invalid password");
236 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
237 int flags
, const char *base_filename
, const char *base_fmt
)
239 if (flags
& BLOCK_FLAG_ENCRYPT
) {
240 if (set_option_parameter(list
, BLOCK_OPT_ENCRYPT
, "on")) {
241 error("Encryption not supported for file format '%s'", fmt
);
245 if (flags
& BLOCK_FLAG_COMPAT6
) {
246 if (set_option_parameter(list
, BLOCK_OPT_COMPAT6
, "on")) {
247 error("VMDK version 6 not supported for file format '%s'", fmt
);
253 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
254 error("Backing file not supported for file format '%s'", fmt
);
259 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
260 error("Backing file format not supported for file format '%s'", fmt
);
267 static int img_create(int argc
, char **argv
)
269 int c
, ret
= 0, flags
;
270 const char *fmt
= "raw";
271 const char *base_fmt
= NULL
;
272 const char *filename
;
273 const char *base_filename
= NULL
;
274 BlockDriver
*drv
, *proto_drv
;
275 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
276 char *options
= NULL
;
280 c
= getopt(argc
, argv
, "F:b:f:he6o:");
291 base_filename
= optarg
;
297 flags
|= BLOCK_FLAG_ENCRYPT
;
300 flags
|= BLOCK_FLAG_COMPAT6
;
308 /* Get the filename */
311 filename
= argv
[optind
++];
313 /* Find driver and parse its options */
314 drv
= bdrv_find_format(fmt
);
316 error("Unknown file format '%s'", fmt
);
320 proto_drv
= bdrv_find_protocol(filename
);
322 error("Unknown protocol '%s'", filename
);
326 create_options
= append_option_parameters(create_options
,
327 drv
->create_options
);
328 create_options
= append_option_parameters(create_options
,
329 proto_drv
->create_options
);
331 if (options
&& !strcmp(options
, "?")) {
332 print_option_help(create_options
);
336 /* Create parameter list with default values */
337 param
= parse_option_parameters("", create_options
, param
);
338 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
340 /* Parse -o options */
342 param
= parse_option_parameters(options
, create_options
, param
);
344 error("Invalid options for file format '%s'.", fmt
);
350 /* Add size to parameters */
352 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
355 /* Add old-style options to parameters */
356 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
361 // The size for the image must always be specified, with one exception:
362 // If we are using a backing file, we can obtain the size from there
363 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
365 QEMUOptionParameter
*backing_file
=
366 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
367 QEMUOptionParameter
*backing_fmt
=
368 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
370 if (backing_file
&& backing_file
->value
.s
) {
371 BlockDriverState
*bs
;
373 const char *fmt
= NULL
;
376 if (backing_fmt
&& backing_fmt
->value
.s
) {
377 if (bdrv_find_format(backing_fmt
->value
.s
)) {
378 fmt
= backing_fmt
->value
.s
;
380 error("Unknown backing file format '%s'",
381 backing_fmt
->value
.s
);
387 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
392 bdrv_get_geometry(bs
, &size
);
396 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
397 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
399 error("Image creation needs a size parameter");
405 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
406 print_option_parameters(param
);
409 ret
= bdrv_create(drv
, filename
, param
);
410 free_option_parameters(create_options
);
411 free_option_parameters(param
);
414 if (ret
== -ENOTSUP
) {
415 error("Formatting or formatting option not supported for file format '%s'", fmt
);
416 } else if (ret
== -EFBIG
) {
417 error("The image size is too large for file format '%s'", fmt
);
419 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
430 * Checks an image for consistency. Exit codes:
432 * 0 - Check completed, image is good
433 * 1 - Check not completed because of internal errors
434 * 2 - Check completed, image is corrupted
435 * 3 - Check completed, image has leaked clusters, but is good otherwise
437 static int img_check(int argc
, char **argv
)
440 const char *filename
, *fmt
;
441 BlockDriverState
*bs
;
442 BdrvCheckResult result
;
446 c
= getopt(argc
, argv
, "f:h");
460 filename
= argv
[optind
++];
462 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
466 ret
= bdrv_check(bs
, &result
);
468 if (ret
== -ENOTSUP
) {
469 error("This image format does not support checks");
474 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
475 printf("No errors were found on the image.\n");
477 if (result
.corruptions
) {
478 printf("\n%d errors were found on the image.\n"
479 "Data may be corrupted, or further writes to the image "
485 printf("\n%d leaked clusters were found on the image.\n"
486 "This means waste of disk space, but no harm to data.\n",
490 if (result
.check_errors
) {
491 printf("\n%d internal errors have occurred during the check.\n",
492 result
.check_errors
);
498 if (ret
< 0 || result
.check_errors
) {
499 printf("\nAn error has occurred during the check: %s\n"
500 "The check is not complete and may have missed error.\n",
505 if (result
.corruptions
) {
507 } else if (result
.leaks
) {
514 static int img_commit(int argc
, char **argv
)
517 const char *filename
, *fmt
;
518 BlockDriverState
*bs
;
522 c
= getopt(argc
, argv
, "f:h");
536 filename
= argv
[optind
++];
538 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
542 ret
= bdrv_commit(bs
);
545 printf("Image committed.\n");
548 error("No disk inserted");
551 error("Image is read-only");
554 error("Image is already committed");
557 error("Error while committing image");
568 static int is_not_zero(const uint8_t *sector
, int len
)
572 for(i
= 0;i
< len
; i
++) {
573 if (((uint32_t *)sector
)[i
] != 0)
580 * Returns true iff the first sector pointed to by 'buf' contains at least
583 * 'pnum' is set to the number of sectors (including and immediately following
584 * the first one) that are known to be in the same allocated/unallocated state.
586 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
594 v
= is_not_zero(buf
, 512);
595 for(i
= 1; i
< n
; i
++) {
597 if (v
!= is_not_zero(buf
, 512))
605 * Compares two buffers sector by sector. Returns 0 if the first sector of both
606 * buffers matches, non-zero otherwise.
608 * pnum is set to the number of sectors (including and immediately following
609 * the first one) that are known to have the same comparison result
611 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
621 res
= !!memcmp(buf1
, buf2
, 512);
622 for(i
= 1; i
< n
; i
++) {
626 if (!!memcmp(buf1
, buf2
, 512) != res
) {
635 #define IO_BUF_SIZE (2 * 1024 * 1024)
637 static int img_convert(int argc
, char **argv
)
639 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
640 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
641 BlockDriver
*drv
, *proto_drv
;
642 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
643 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
645 uint8_t * buf
= NULL
;
648 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
649 QEMUOptionParameter
*out_baseimg_param
;
650 char *options
= NULL
;
651 const char *snapshot_name
= NULL
;
658 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
672 out_baseimg
= optarg
;
675 flags
|= BLOCK_FLAG_COMPRESS
;
678 flags
|= BLOCK_FLAG_ENCRYPT
;
681 flags
|= BLOCK_FLAG_COMPAT6
;
687 snapshot_name
= optarg
;
692 bs_n
= argc
- optind
- 1;
693 if (bs_n
< 1) help();
695 out_filename
= argv
[argc
- 1];
697 if (bs_n
> 1 && out_baseimg
) {
698 error("-B makes no sense when concatenating multiple input images");
702 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
705 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
706 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
708 error("Could not open '%s'", argv
[optind
+ bs_i
]);
712 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
713 total_sectors
+= bs_sectors
;
716 if (snapshot_name
!= NULL
) {
718 error("No support for concatenating multiple snapshot\n");
722 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
723 error("Failed to load snapshot\n");
729 /* Find driver and parse its options */
730 drv
= bdrv_find_format(out_fmt
);
732 error("Unknown file format '%s'", out_fmt
);
737 proto_drv
= bdrv_find_protocol(out_filename
);
739 error("Unknown protocol '%s'", out_filename
);
744 create_options
= append_option_parameters(create_options
,
745 drv
->create_options
);
746 create_options
= append_option_parameters(create_options
,
747 proto_drv
->create_options
);
748 if (options
&& !strcmp(options
, "?")) {
749 print_option_help(create_options
);
754 param
= parse_option_parameters(options
, create_options
, param
);
756 error("Invalid options for file format '%s'.", out_fmt
);
761 param
= parse_option_parameters("", create_options
, param
);
764 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
765 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
770 /* Get backing file name if -o backing_file was used */
771 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
772 if (out_baseimg_param
) {
773 out_baseimg
= out_baseimg_param
->value
.s
;
776 /* Check if compression is supported */
777 if (flags
& BLOCK_FLAG_COMPRESS
) {
778 QEMUOptionParameter
*encryption
=
779 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
781 if (!drv
->bdrv_write_compressed
) {
782 error("Compression not supported for this file format");
787 if (encryption
&& encryption
->value
.n
) {
788 error("Compression and encryption not supported at the same time");
794 /* Create the new image */
795 ret
= bdrv_create(drv
, out_filename
, param
);
797 if (ret
== -ENOTSUP
) {
798 error("Formatting not supported for file format '%s'", out_fmt
);
799 } else if (ret
== -EFBIG
) {
800 error("The image size is too large for file format '%s'", out_fmt
);
802 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
807 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
808 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
816 bdrv_get_geometry(bs
[0], &bs_sectors
);
817 buf
= qemu_malloc(IO_BUF_SIZE
);
819 if (flags
& BLOCK_FLAG_COMPRESS
) {
820 ret
= bdrv_get_info(out_bs
, &bdi
);
822 error("could not get block driver info");
825 cluster_size
= bdi
.cluster_size
;
826 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
827 error("invalid cluster size");
831 cluster_sectors
= cluster_size
>> 9;
838 nb_sectors
= total_sectors
- sector_num
;
841 if (nb_sectors
>= cluster_sectors
)
846 bs_num
= sector_num
- bs_offset
;
847 assert (bs_num
>= 0);
850 while (remainder
> 0) {
852 while (bs_num
== bs_sectors
) {
854 assert (bs_i
< bs_n
);
855 bs_offset
+= bs_sectors
;
856 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
858 /* printf("changing part: sector_num=%" PRId64 ", "
859 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
860 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
862 assert (bs_num
< bs_sectors
);
864 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
866 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
868 error("error while reading");
877 assert (remainder
== 0);
879 if (n
< cluster_sectors
)
880 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
881 if (is_not_zero(buf
, cluster_size
)) {
882 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
885 error("error while compressing sector %" PRId64
,
892 /* signal EOF to align */
893 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
895 int has_zero_init
= bdrv_has_zero_init(out_bs
);
897 sector_num
= 0; // total number of sectors converted so far
899 nb_sectors
= total_sectors
- sector_num
;
902 if (nb_sectors
>= (IO_BUF_SIZE
/ 512))
903 n
= (IO_BUF_SIZE
/ 512);
907 while (sector_num
- bs_offset
>= bs_sectors
) {
909 assert (bs_i
< bs_n
);
910 bs_offset
+= bs_sectors
;
911 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
912 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
913 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
914 sector_num, bs_i, bs_offset, bs_sectors); */
917 if (n
> bs_offset
+ bs_sectors
- sector_num
)
918 n
= bs_offset
+ bs_sectors
- sector_num
;
921 /* If the output image is being created as a copy on write image,
922 assume that sectors which are unallocated in the input image
923 are present in both the output's and input's base images (no
924 need to copy them). */
926 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
931 /* The next 'n1' sectors are allocated in the input image. Copy
932 only those as they may be followed by unallocated sectors. */
939 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
941 error("error while reading");
944 /* NOTE: at the same time we convert, we do not write zero
945 sectors to have a chance to compress the image. Ideally, we
946 should add a specific call to have the info to go faster */
949 /* If the output image is being created as a copy on write image,
950 copy all sectors even the ones containing only NUL bytes,
951 because they may differ from the sectors in the base image.
953 If the output is to a host device, we also write out
954 sectors that are entirely 0, since whatever data was
955 already there is garbage, not 0s. */
956 if (!has_zero_init
|| out_baseimg
||
957 is_allocated_sectors(buf1
, n
, &n1
)) {
958 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
960 error("error while writing");
971 free_option_parameters(create_options
);
972 free_option_parameters(param
);
977 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
979 bdrv_delete(bs
[bs_i
]);
990 static int64_t get_allocated_file_size(const char *filename
)
992 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
993 get_compressed_t get_compressed
;
996 /* WinNT support GetCompressedFileSize to determine allocate size */
997 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
998 if (get_compressed
) {
1000 low
= get_compressed(filename
, &high
);
1001 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1002 return (((int64_t) high
) << 32) + low
;
1005 if (_stati64(filename
, &st
) < 0)
1010 static int64_t get_allocated_file_size(const char *filename
)
1013 if (stat(filename
, &st
) < 0)
1015 return (int64_t)st
.st_blocks
* 512;
1019 static void dump_snapshots(BlockDriverState
*bs
)
1021 QEMUSnapshotInfo
*sn_tab
, *sn
;
1025 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1028 printf("Snapshot list:\n");
1029 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1030 for(i
= 0; i
< nb_sns
; i
++) {
1032 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1037 static int img_info(int argc
, char **argv
)
1040 const char *filename
, *fmt
;
1041 BlockDriverState
*bs
;
1042 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1043 uint64_t total_sectors
;
1044 int64_t allocated_size
;
1045 char backing_filename
[1024];
1046 char backing_filename2
[1024];
1047 BlockDriverInfo bdi
;
1051 c
= getopt(argc
, argv
, "f:h");
1065 filename
= argv
[optind
++];
1067 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1071 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1072 bdrv_get_geometry(bs
, &total_sectors
);
1073 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1074 allocated_size
= get_allocated_file_size(filename
);
1075 if (allocated_size
< 0)
1076 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1078 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1080 printf("image: %s\n"
1082 "virtual size: %s (%" PRId64
" bytes)\n"
1084 filename
, fmt_name
, size_buf
,
1085 (total_sectors
* 512),
1087 if (bdrv_is_encrypted(bs
))
1088 printf("encrypted: yes\n");
1089 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1090 if (bdi
.cluster_size
!= 0)
1091 printf("cluster_size: %d\n", bdi
.cluster_size
);
1093 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1094 if (backing_filename
[0] != '\0') {
1095 path_combine(backing_filename2
, sizeof(backing_filename2
),
1096 filename
, backing_filename
);
1097 printf("backing file: %s (actual path: %s)\n",
1106 #define SNAPSHOT_LIST 1
1107 #define SNAPSHOT_CREATE 2
1108 #define SNAPSHOT_APPLY 3
1109 #define SNAPSHOT_DELETE 4
1111 static int img_snapshot(int argc
, char **argv
)
1113 BlockDriverState
*bs
;
1114 QEMUSnapshotInfo sn
;
1115 char *filename
, *snapshot_name
= NULL
;
1116 int c
, ret
= 0, bdrv_oflags
;
1120 bdrv_oflags
= BDRV_O_RDWR
;
1121 /* Parse commandline parameters */
1123 c
= getopt(argc
, argv
, "la:c:d:h");
1135 action
= SNAPSHOT_LIST
;
1136 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1143 action
= SNAPSHOT_APPLY
;
1144 snapshot_name
= optarg
;
1151 action
= SNAPSHOT_CREATE
;
1152 snapshot_name
= optarg
;
1159 action
= SNAPSHOT_DELETE
;
1160 snapshot_name
= optarg
;
1167 filename
= argv
[optind
++];
1169 /* Open the image */
1170 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1175 /* Perform the requested action */
1181 case SNAPSHOT_CREATE
:
1182 memset(&sn
, 0, sizeof(sn
));
1183 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1185 qemu_gettimeofday(&tv
);
1186 sn
.date_sec
= tv
.tv_sec
;
1187 sn
.date_nsec
= tv
.tv_usec
* 1000;
1189 ret
= bdrv_snapshot_create(bs
, &sn
);
1191 error("Could not create snapshot '%s': %d (%s)",
1192 snapshot_name
, ret
, strerror(-ret
));
1195 case SNAPSHOT_APPLY
:
1196 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1198 error("Could not apply snapshot '%s': %d (%s)",
1199 snapshot_name
, ret
, strerror(-ret
));
1202 case SNAPSHOT_DELETE
:
1203 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1205 error("Could not delete snapshot '%s': %d (%s)",
1206 snapshot_name
, ret
, strerror(-ret
));
1218 static int img_rebase(int argc
, char **argv
)
1220 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1221 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1223 const char *fmt
, *out_basefmt
, *out_baseimg
;
1227 /* Parse commandline parameters */
1233 c
= getopt(argc
, argv
, "uhf:F:b:");
1244 out_basefmt
= optarg
;
1247 out_baseimg
= optarg
;
1255 if ((optind
>= argc
) || !out_baseimg
)
1257 filename
= argv
[optind
++];
1262 * Ignore the old backing file for unsafe rebase in case we want to correct
1263 * the reference to a renamed or moved backing file.
1265 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1266 bs
= bdrv_new_open(filename
, fmt
, flags
);
1271 /* Find the right drivers for the backing files */
1272 old_backing_drv
= NULL
;
1273 new_backing_drv
= NULL
;
1275 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1276 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1277 if (old_backing_drv
== NULL
) {
1278 error("Invalid format name: '%s'", bs
->backing_format
);
1284 if (out_basefmt
!= NULL
) {
1285 new_backing_drv
= bdrv_find_format(out_basefmt
);
1286 if (new_backing_drv
== NULL
) {
1287 error("Invalid format name: '%s'", out_basefmt
);
1293 /* For safe rebasing we need to compare old and new backing file */
1295 /* Make the compiler happy */
1296 bs_old_backing
= NULL
;
1297 bs_new_backing
= NULL
;
1299 char backing_name
[1024];
1301 bs_old_backing
= bdrv_new("old_backing");
1302 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1303 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1306 error("Could not open old backing file '%s'", backing_name
);
1310 bs_new_backing
= bdrv_new("new_backing");
1311 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1314 error("Could not open new backing file '%s'", out_baseimg
);
1320 * Check each unallocated cluster in the COW file. If it is unallocated,
1321 * accesses go to the backing file. We must therefore compare this cluster
1322 * in the old and new backing file, and if they differ we need to copy it
1323 * from the old backing file into the COW file.
1325 * If qemu-img crashes during this step, no harm is done. The content of
1326 * the image is the same as the original one at any time.
1329 uint64_t num_sectors
;
1335 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1336 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1338 bdrv_get_geometry(bs
, &num_sectors
);
1340 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1342 /* How many sectors can we handle with the next read? */
1343 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1344 n
= (IO_BUF_SIZE
/ 512);
1346 n
= num_sectors
- sector
;
1349 /* If the cluster is allocated, we don't need to take action */
1350 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1355 /* Read old and new backing file */
1356 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1358 error("error while reading from old backing file");
1361 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1363 error("error while reading from new backing file");
1367 /* If they differ, we need to write to the COW file */
1368 uint64_t written
= 0;
1370 while (written
< n
) {
1373 if (compare_sectors(buf_old
+ written
* 512,
1374 buf_new
+ written
* 512, n
- written
, &pnum
))
1376 ret
= bdrv_write(bs
, sector
+ written
,
1377 buf_old
+ written
* 512, pnum
);
1379 error("Error while writing to COW image: %s",
1394 * Change the backing file. All clusters that are different from the old
1395 * backing file are overwritten in the COW file now, so the visible content
1396 * doesn't change when we switch the backing file.
1398 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1399 if (ret
== -ENOSPC
) {
1400 error("Could not change the backing file to '%s': No space left in "
1401 "the file header", out_baseimg
);
1402 } else if (ret
< 0) {
1403 error("Could not change the backing file to '%s': %s",
1404 out_baseimg
, strerror(-ret
));
1408 * TODO At this point it is possible to check if any clusters that are
1409 * allocated in the COW file are the same in the backing file. If so, they
1410 * could be dropped from the COW file. Don't do this before switching the
1411 * backing file, in case of a crash this would lead to corruption.
1416 bdrv_delete(bs_old_backing
);
1417 bdrv_delete(bs_new_backing
);
1427 static int img_resize(int argc
, char **argv
)
1429 int c
, ret
, relative
;
1430 const char *filename
, *fmt
, *size
;
1431 int64_t n
, total_size
;
1432 BlockDriverState
*bs
;
1433 QEMUOptionParameter
*param
;
1434 QEMUOptionParameter resize_options
[] = {
1436 .name
= BLOCK_OPT_SIZE
,
1438 .help
= "Virtual disk size"
1445 c
= getopt(argc
, argv
, "f:h");
1458 if (optind
+ 1 >= argc
) {
1461 filename
= argv
[optind
++];
1462 size
= argv
[optind
++];
1464 /* Choose grow, shrink, or absolute resize mode */
1480 param
= parse_option_parameters("", resize_options
, NULL
);
1481 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1482 /* Error message already printed when size parsing fails */
1485 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1486 free_option_parameters(param
);
1488 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1494 total_size
= bdrv_getlength(bs
) + n
* relative
;
1498 if (total_size
<= 0) {
1499 error("New image size must be positive");
1504 ret
= bdrv_truncate(bs
, total_size
);
1507 printf("Image resized.\n");
1510 error("This image format does not support resize");
1513 error("Image is read-only");
1516 error("Error resizing image (%d)", -ret
);
1527 static const img_cmd_t img_cmds
[] = {
1528 #define DEF(option, callback, arg_string) \
1529 { option, callback },
1530 #include "qemu-img-cmds.h"
1536 int main(int argc
, char **argv
)
1538 const img_cmd_t
*cmd
;
1539 const char *cmdname
;
1547 /* find the command */
1548 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1549 if (!strcmp(cmdname
, cmd
->name
)) {
1550 return cmd
->handler(argc
, argv
);