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"
26 #include "qemu-error.h"
29 #include "block_int.h"
36 typedef struct img_cmd_t
{
38 int (*handler
)(int argc
, char **argv
);
41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43 #define BDRV_DEFAULT_CACHE "writeback"
45 static void format_print(void *opaque
, const char *name
)
50 /* Please keep in synch with qemu-img.texi */
51 static void help(void)
53 const char *help_msg
=
54 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
55 "usage: qemu-img command [command options]\n"
56 "QEMU disk image utility\n"
59 #define DEF(option, callback, arg_string) \
61 #include "qemu-img-cmds.h"
65 "Command parameters:\n"
66 " 'filename' is a disk image filename\n"
67 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
68 " 'cache' is the cache mode used to write the output disk image, the valid\n"
69 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
70 " 'directsync' and 'unsafe' (default for convert)\n"
71 " 'size' is the disk image size in bytes. Optional suffixes\n"
72 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
73 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
74 " 'output_filename' is the destination disk image filename\n"
75 " 'output_fmt' is the destination format\n"
76 " 'options' is a comma separated list of format specific options in a\n"
77 " name=value format. Use -o ? for an overview of the options supported by the\n"
79 " '-c' indicates that target image must be compressed (qcow format only)\n"
80 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
81 " match exactly. The image doesn't need a working backing file before\n"
82 " rebasing in this case (useful for renaming the backing file)\n"
83 " '-h' with or without a command shows this help and lists the supported formats\n"
84 " '-p' show progress of command (only certain commands)\n"
85 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
86 " for qemu-img to create a sparse image during conversion\n"
88 "Parameters to check subcommand:\n"
89 " '-r' tries to repair any inconsistencies that are found during the check.\n"
90 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
91 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
92 " hiding corruption that has already occurred.\n"
94 "Parameters to snapshot subcommand:\n"
95 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
96 " '-a' applies a snapshot (revert disk to saved state)\n"
97 " '-c' creates a snapshot\n"
98 " '-d' deletes a snapshot\n"
99 " '-l' lists all snapshots in the given image\n";
101 printf("%s\nSupported formats:", help_msg
);
102 bdrv_iterate_format(format_print
, NULL
);
108 /* XXX: put correct support for win32 */
109 static int read_password(char *buf
, int buf_size
)
112 printf("Password: ");
119 if (i
< (buf_size
- 1))
130 static struct termios oldtty
;
132 static void term_exit(void)
134 tcsetattr (0, TCSANOW
, &oldtty
);
137 static void term_init(void)
144 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
145 |INLCR
|IGNCR
|ICRNL
|IXON
);
146 tty
.c_oflag
|= OPOST
;
147 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
148 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
153 tcsetattr (0, TCSANOW
, &tty
);
158 static int read_password(char *buf
, int buf_size
)
163 printf("password: ");
168 ret
= read(0, &ch
, 1);
170 if (errno
== EAGAIN
|| errno
== EINTR
) {
176 } else if (ret
== 0) {
184 if (i
< (buf_size
- 1))
195 static int print_block_option_help(const char *filename
, const char *fmt
)
197 BlockDriver
*drv
, *proto_drv
;
198 QEMUOptionParameter
*create_options
= NULL
;
200 /* Find driver and parse its options */
201 drv
= bdrv_find_format(fmt
);
203 error_report("Unknown file format '%s'", fmt
);
207 proto_drv
= bdrv_find_protocol(filename
);
209 error_report("Unknown protocol '%s'", filename
);
213 create_options
= append_option_parameters(create_options
,
214 drv
->create_options
);
215 create_options
= append_option_parameters(create_options
,
216 proto_drv
->create_options
);
217 print_option_help(create_options
);
218 free_option_parameters(create_options
);
222 static BlockDriverState
*bdrv_new_open(const char *filename
,
227 BlockDriverState
*bs
;
232 bs
= bdrv_new("image");
235 drv
= bdrv_find_format(fmt
);
237 error_report("Unknown file format '%s'", fmt
);
244 ret
= bdrv_open(bs
, filename
, flags
, drv
);
246 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
250 if (bdrv_is_encrypted(bs
) && require_io
) {
251 printf("Disk image '%s' is encrypted.\n", filename
);
252 if (read_password(password
, sizeof(password
)) < 0) {
253 error_report("No password given");
256 if (bdrv_set_key(bs
, password
) < 0) {
257 error_report("invalid password");
269 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
270 const char *base_filename
,
271 const char *base_fmt
)
274 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
275 error_report("Backing file not supported for file format '%s'",
281 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
282 error_report("Backing file format not supported for file "
290 static int img_create(int argc
, char **argv
)
293 uint64_t img_size
= -1;
294 const char *fmt
= "raw";
295 const char *base_fmt
= NULL
;
296 const char *filename
;
297 const char *base_filename
= NULL
;
298 char *options
= NULL
;
301 c
= getopt(argc
, argv
, "F:b:f:he6o:");
314 base_filename
= optarg
;
320 error_report("option -e is deprecated, please use \'-o "
321 "encryption\' instead!");
324 error_report("option -6 is deprecated, please use \'-o "
325 "compat6\' instead!");
333 /* Get the filename */
334 if (optind
>= argc
) {
337 filename
= argv
[optind
++];
339 /* Get image size, if specified */
343 sval
= strtosz_suffix(argv
[optind
++], &end
, STRTOSZ_DEFSUFFIX_B
);
344 if (sval
< 0 || *end
) {
345 error_report("Invalid image size specified! You may use k, M, G or "
347 error_report("kilobytes, megabytes, gigabytes and terabytes.");
351 img_size
= (uint64_t)sval
;
354 if (options
&& is_help_option(options
)) {
355 ret
= print_block_option_help(filename
, fmt
);
359 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
360 options
, img_size
, BDRV_O_FLAGS
);
369 * Checks an image for consistency. Exit codes:
371 * 0 - Check completed, image is good
372 * 1 - Check not completed because of internal errors
373 * 2 - Check completed, image is corrupted
374 * 3 - Check completed, image has leaked clusters, but is good otherwise
376 static int img_check(int argc
, char **argv
)
379 const char *filename
, *fmt
;
380 BlockDriverState
*bs
;
381 BdrvCheckResult result
;
383 int flags
= BDRV_O_FLAGS
| BDRV_O_CHECK
;
387 c
= getopt(argc
, argv
, "f:hr:");
400 flags
|= BDRV_O_RDWR
;
402 if (!strcmp(optarg
, "leaks")) {
403 fix
= BDRV_FIX_LEAKS
;
404 } else if (!strcmp(optarg
, "all")) {
405 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
412 if (optind
>= argc
) {
415 filename
= argv
[optind
++];
417 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
421 ret
= bdrv_check(bs
, &result
, fix
);
423 if (ret
== -ENOTSUP
) {
424 error_report("This image format does not support checks");
429 if (result
.corruptions_fixed
|| result
.leaks_fixed
) {
430 printf("The following inconsistencies were found and repaired:\n\n"
431 " %d leaked clusters\n"
432 " %d corruptions\n\n"
433 "Double checking the fixed image now...\n",
435 result
.corruptions_fixed
);
436 ret
= bdrv_check(bs
, &result
, 0);
439 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
440 printf("No errors were found on the image.\n");
442 if (result
.corruptions
) {
443 printf("\n%d errors were found on the image.\n"
444 "Data may be corrupted, or further writes to the image "
450 printf("\n%d leaked clusters were found on the image.\n"
451 "This means waste of disk space, but no harm to data.\n",
455 if (result
.check_errors
) {
456 printf("\n%d internal errors have occurred during the check.\n",
457 result
.check_errors
);
461 if (result
.bfi
.total_clusters
!= 0 && result
.bfi
.allocated_clusters
!= 0) {
462 printf("%" PRId64
"/%" PRId64
"= %0.2f%% allocated, %0.2f%% fragmented\n",
463 result
.bfi
.allocated_clusters
, result
.bfi
.total_clusters
,
464 result
.bfi
.allocated_clusters
* 100.0 / result
.bfi
.total_clusters
,
465 result
.bfi
.fragmented_clusters
* 100.0 / result
.bfi
.allocated_clusters
);
470 if (ret
< 0 || result
.check_errors
) {
471 printf("\nAn error has occurred during the check: %s\n"
472 "The check is not complete and may have missed error.\n",
477 if (result
.corruptions
) {
479 } else if (result
.leaks
) {
486 static int img_commit(int argc
, char **argv
)
489 const char *filename
, *fmt
, *cache
;
490 BlockDriverState
*bs
;
493 cache
= BDRV_DEFAULT_CACHE
;
495 c
= getopt(argc
, argv
, "f:ht:");
512 if (optind
>= argc
) {
515 filename
= argv
[optind
++];
518 ret
= bdrv_parse_cache_flags(cache
, &flags
);
520 error_report("Invalid cache option: %s", cache
);
524 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
528 ret
= bdrv_commit(bs
);
531 printf("Image committed.\n");
534 error_report("No disk inserted");
537 error_report("Image is read-only");
540 error_report("Image is already committed");
543 error_report("Error while committing image");
555 * Returns true iff the first sector pointed to by 'buf' contains at least
558 * 'pnum' is set to the number of sectors (including and immediately following
559 * the first one) that are known to be in the same allocated/unallocated state.
561 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
570 is_zero
= buffer_is_zero(buf
, 512);
571 for(i
= 1; i
< n
; i
++) {
573 if (is_zero
!= buffer_is_zero(buf
, 512)) {
582 * Like is_allocated_sectors, but if the buffer starts with a used sector,
583 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
584 * breaking up write requests for only small sparse areas.
586 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
590 int num_checked
, num_used
;
596 ret
= is_allocated_sectors(buf
, n
, pnum
);
602 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
604 num_checked
= num_used
;
607 ret
= is_allocated_sectors(buf
, n
, pnum
);
609 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
611 num_checked
+= *pnum
;
613 num_used
= num_checked
;
614 } else if (*pnum
>= min
) {
624 * Compares two buffers sector by sector. Returns 0 if the first sector of both
625 * buffers matches, non-zero otherwise.
627 * pnum is set to the number of sectors (including and immediately following
628 * the first one) that are known to have the same comparison result
630 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
640 res
= !!memcmp(buf1
, buf2
, 512);
641 for(i
= 1; i
< n
; i
++) {
645 if (!!memcmp(buf1
, buf2
, 512) != res
) {
654 #define IO_BUF_SIZE (2 * 1024 * 1024)
656 static int img_convert(int argc
, char **argv
)
658 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
659 int progress
= 0, flags
;
660 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
661 BlockDriver
*drv
, *proto_drv
;
662 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
663 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
665 uint8_t * buf
= NULL
;
668 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
669 QEMUOptionParameter
*out_baseimg_param
;
670 char *options
= NULL
;
671 const char *snapshot_name
= NULL
;
672 float local_progress
;
673 int min_sparse
= 8; /* Need at least 4k of zeros for sparse detection */
681 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pS:t:");
697 out_baseimg
= optarg
;
703 error_report("option -e is deprecated, please use \'-o "
704 "encryption\' instead!");
707 error_report("option -6 is deprecated, please use \'-o "
708 "compat6\' instead!");
714 snapshot_name
= optarg
;
720 sval
= strtosz_suffix(optarg
, &end
, STRTOSZ_DEFSUFFIX_B
);
721 if (sval
< 0 || *end
) {
722 error_report("Invalid minimum zero buffer size for sparse output specified");
726 min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
738 bs_n
= argc
- optind
- 1;
743 out_filename
= argv
[argc
- 1];
745 /* Initialize before goto out */
746 qemu_progress_init(progress
, 2.0);
748 if (options
&& is_help_option(options
)) {
749 ret
= print_block_option_help(out_filename
, out_fmt
);
753 if (bs_n
> 1 && out_baseimg
) {
754 error_report("-B makes no sense when concatenating multiple input "
760 qemu_progress_print(0, 100);
762 bs
= g_malloc0(bs_n
* sizeof(BlockDriverState
*));
765 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
766 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
, true);
768 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
772 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
773 total_sectors
+= bs_sectors
;
776 if (snapshot_name
!= NULL
) {
778 error_report("No support for concatenating multiple snapshot");
782 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
783 error_report("Failed to load snapshot");
789 /* Find driver and parse its options */
790 drv
= bdrv_find_format(out_fmt
);
792 error_report("Unknown file format '%s'", out_fmt
);
797 proto_drv
= bdrv_find_protocol(out_filename
);
799 error_report("Unknown protocol '%s'", out_filename
);
804 create_options
= append_option_parameters(create_options
,
805 drv
->create_options
);
806 create_options
= append_option_parameters(create_options
,
807 proto_drv
->create_options
);
810 param
= parse_option_parameters(options
, create_options
, param
);
812 error_report("Invalid options for file format '%s'.", out_fmt
);
817 param
= parse_option_parameters("", create_options
, param
);
820 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
821 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
826 /* Get backing file name if -o backing_file was used */
827 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
828 if (out_baseimg_param
) {
829 out_baseimg
= out_baseimg_param
->value
.s
;
832 /* Check if compression is supported */
834 QEMUOptionParameter
*encryption
=
835 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
836 QEMUOptionParameter
*preallocation
=
837 get_option_parameter(param
, BLOCK_OPT_PREALLOC
);
839 if (!drv
->bdrv_write_compressed
) {
840 error_report("Compression not supported for this file format");
845 if (encryption
&& encryption
->value
.n
) {
846 error_report("Compression and encryption not supported at "
852 if (preallocation
&& preallocation
->value
.s
853 && strcmp(preallocation
->value
.s
, "off"))
855 error_report("Compression and preallocation not supported at "
862 /* Create the new image */
863 ret
= bdrv_create(drv
, out_filename
, param
);
865 if (ret
== -ENOTSUP
) {
866 error_report("Formatting not supported for file format '%s'",
868 } else if (ret
== -EFBIG
) {
869 error_report("The image size is too large for file format '%s'",
872 error_report("%s: error while converting %s: %s",
873 out_filename
, out_fmt
, strerror(-ret
));
879 ret
= bdrv_parse_cache_flags(cache
, &flags
);
881 error_report("Invalid cache option: %s", cache
);
885 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
, true);
893 bdrv_get_geometry(bs
[0], &bs_sectors
);
894 buf
= qemu_blockalign(out_bs
, IO_BUF_SIZE
);
897 ret
= bdrv_get_info(out_bs
, &bdi
);
899 error_report("could not get block driver info");
902 cluster_size
= bdi
.cluster_size
;
903 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
904 error_report("invalid cluster size");
908 cluster_sectors
= cluster_size
>> 9;
911 nb_sectors
= total_sectors
;
912 local_progress
= (float)100 /
913 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
920 nb_sectors
= total_sectors
- sector_num
;
923 if (nb_sectors
>= cluster_sectors
)
928 bs_num
= sector_num
- bs_offset
;
929 assert (bs_num
>= 0);
932 while (remainder
> 0) {
934 while (bs_num
== bs_sectors
) {
936 assert (bs_i
< bs_n
);
937 bs_offset
+= bs_sectors
;
938 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
940 /* printf("changing part: sector_num=%" PRId64 ", "
941 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
942 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
944 assert (bs_num
< bs_sectors
);
946 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
948 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
950 error_report("error while reading sector %" PRId64
": %s",
951 bs_num
, strerror(-ret
));
960 assert (remainder
== 0);
962 if (n
< cluster_sectors
) {
963 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
965 if (!buffer_is_zero(buf
, cluster_size
)) {
966 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
969 error_report("error while compressing sector %" PRId64
970 ": %s", sector_num
, strerror(-ret
));
975 qemu_progress_print(local_progress
, 100);
977 /* signal EOF to align */
978 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
980 int has_zero_init
= bdrv_has_zero_init(out_bs
);
982 sector_num
= 0; // total number of sectors converted so far
983 nb_sectors
= total_sectors
- sector_num
;
984 local_progress
= (float)100 /
985 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
988 nb_sectors
= total_sectors
- sector_num
;
989 if (nb_sectors
<= 0) {
992 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
993 n
= (IO_BUF_SIZE
/ 512);
998 while (sector_num
- bs_offset
>= bs_sectors
) {
1000 assert (bs_i
< bs_n
);
1001 bs_offset
+= bs_sectors
;
1002 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
1003 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1004 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1005 sector_num, bs_i, bs_offset, bs_sectors); */
1008 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
1009 n
= bs_offset
+ bs_sectors
- sector_num
;
1012 if (has_zero_init
) {
1013 /* If the output image is being created as a copy on write image,
1014 assume that sectors which are unallocated in the input image
1015 are present in both the output's and input's base images (no
1016 need to copy them). */
1018 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
1023 /* The next 'n1' sectors are allocated in the input image. Copy
1024 only those as they may be followed by unallocated sectors. */
1031 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
1033 error_report("error while reading sector %" PRId64
": %s",
1034 sector_num
- bs_offset
, strerror(-ret
));
1037 /* NOTE: at the same time we convert, we do not write zero
1038 sectors to have a chance to compress the image. Ideally, we
1039 should add a specific call to have the info to go faster */
1042 /* If the output image is being created as a copy on write image,
1043 copy all sectors even the ones containing only NUL bytes,
1044 because they may differ from the sectors in the base image.
1046 If the output is to a host device, we also write out
1047 sectors that are entirely 0, since whatever data was
1048 already there is garbage, not 0s. */
1049 if (!has_zero_init
|| out_baseimg
||
1050 is_allocated_sectors_min(buf1
, n
, &n1
, min_sparse
)) {
1051 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1053 error_report("error while writing sector %" PRId64
1054 ": %s", sector_num
, strerror(-ret
));
1062 qemu_progress_print(local_progress
, 100);
1066 qemu_progress_end();
1067 free_option_parameters(create_options
);
1068 free_option_parameters(param
);
1071 bdrv_delete(out_bs
);
1074 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1076 bdrv_delete(bs
[bs_i
]);
1088 static void dump_snapshots(BlockDriverState
*bs
)
1090 QEMUSnapshotInfo
*sn_tab
, *sn
;
1094 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1097 printf("Snapshot list:\n");
1098 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1099 for(i
= 0; i
< nb_sns
; i
++) {
1101 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1106 static int img_info(int argc
, char **argv
)
1109 const char *filename
, *fmt
;
1110 BlockDriverState
*bs
;
1111 char size_buf
[128], dsize_buf
[128];
1112 uint64_t total_sectors
;
1113 int64_t allocated_size
;
1114 char backing_filename
[1024];
1115 char backing_filename2
[1024];
1116 BlockDriverInfo bdi
;
1120 c
= getopt(argc
, argv
, "f:h");
1134 if (optind
>= argc
) {
1137 filename
= argv
[optind
++];
1139 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
, false);
1143 bdrv_get_geometry(bs
, &total_sectors
);
1144 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1145 allocated_size
= bdrv_get_allocated_file_size(bs
);
1146 if (allocated_size
< 0) {
1147 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1149 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1152 printf("image: %s\n"
1154 "virtual size: %s (%" PRId64
" bytes)\n"
1156 filename
, bdrv_get_format_name(bs
), size_buf
,
1157 (total_sectors
* 512),
1159 if (bdrv_is_encrypted(bs
)) {
1160 printf("encrypted: yes\n");
1162 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1163 if (bdi
.cluster_size
!= 0) {
1164 printf("cluster_size: %d\n", bdi
.cluster_size
);
1167 printf("cleanly shut down: no\n");
1170 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1171 if (backing_filename
[0] != '\0') {
1172 bdrv_get_full_backing_filename(bs
, backing_filename2
,
1173 sizeof(backing_filename2
));
1174 printf("backing file: %s", backing_filename
);
1175 if (strcmp(backing_filename
, backing_filename2
) != 0) {
1176 printf(" (actual path: %s)", backing_filename2
);
1185 #define SNAPSHOT_LIST 1
1186 #define SNAPSHOT_CREATE 2
1187 #define SNAPSHOT_APPLY 3
1188 #define SNAPSHOT_DELETE 4
1190 static int img_snapshot(int argc
, char **argv
)
1192 BlockDriverState
*bs
;
1193 QEMUSnapshotInfo sn
;
1194 char *filename
, *snapshot_name
= NULL
;
1195 int c
, ret
= 0, bdrv_oflags
;
1199 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1200 /* Parse commandline parameters */
1202 c
= getopt(argc
, argv
, "la:c:d:h");
1216 action
= SNAPSHOT_LIST
;
1217 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1224 action
= SNAPSHOT_APPLY
;
1225 snapshot_name
= optarg
;
1232 action
= SNAPSHOT_CREATE
;
1233 snapshot_name
= optarg
;
1240 action
= SNAPSHOT_DELETE
;
1241 snapshot_name
= optarg
;
1246 if (optind
>= argc
) {
1249 filename
= argv
[optind
++];
1251 /* Open the image */
1252 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
, true);
1257 /* Perform the requested action */
1263 case SNAPSHOT_CREATE
:
1264 memset(&sn
, 0, sizeof(sn
));
1265 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1267 qemu_gettimeofday(&tv
);
1268 sn
.date_sec
= tv
.tv_sec
;
1269 sn
.date_nsec
= tv
.tv_usec
* 1000;
1271 ret
= bdrv_snapshot_create(bs
, &sn
);
1273 error_report("Could not create snapshot '%s': %d (%s)",
1274 snapshot_name
, ret
, strerror(-ret
));
1278 case SNAPSHOT_APPLY
:
1279 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1281 error_report("Could not apply snapshot '%s': %d (%s)",
1282 snapshot_name
, ret
, strerror(-ret
));
1286 case SNAPSHOT_DELETE
:
1287 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1289 error_report("Could not delete snapshot '%s': %d (%s)",
1290 snapshot_name
, ret
, strerror(-ret
));
1303 static int img_rebase(int argc
, char **argv
)
1305 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1306 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1308 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1313 /* Parse commandline parameters */
1315 cache
= BDRV_DEFAULT_CACHE
;
1319 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1332 out_basefmt
= optarg
;
1335 out_baseimg
= optarg
;
1349 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1352 filename
= argv
[optind
++];
1354 qemu_progress_init(progress
, 2.0);
1355 qemu_progress_print(0, 100);
1357 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1358 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1360 error_report("Invalid cache option: %s", cache
);
1367 * Ignore the old backing file for unsafe rebase in case we want to correct
1368 * the reference to a renamed or moved backing file.
1370 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
1375 /* Find the right drivers for the backing files */
1376 old_backing_drv
= NULL
;
1377 new_backing_drv
= NULL
;
1379 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1380 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1381 if (old_backing_drv
== NULL
) {
1382 error_report("Invalid format name: '%s'", bs
->backing_format
);
1388 if (out_basefmt
!= NULL
) {
1389 new_backing_drv
= bdrv_find_format(out_basefmt
);
1390 if (new_backing_drv
== NULL
) {
1391 error_report("Invalid format name: '%s'", out_basefmt
);
1397 /* For safe rebasing we need to compare old and new backing file */
1399 /* Make the compiler happy */
1400 bs_old_backing
= NULL
;
1401 bs_new_backing
= NULL
;
1403 char backing_name
[1024];
1405 bs_old_backing
= bdrv_new("old_backing");
1406 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1407 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1410 error_report("Could not open old backing file '%s'", backing_name
);
1414 bs_new_backing
= bdrv_new("new_backing");
1415 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1418 error_report("Could not open new backing file '%s'", out_baseimg
);
1424 * Check each unallocated cluster in the COW file. If it is unallocated,
1425 * accesses go to the backing file. We must therefore compare this cluster
1426 * in the old and new backing file, and if they differ we need to copy it
1427 * from the old backing file into the COW file.
1429 * If qemu-img crashes during this step, no harm is done. The content of
1430 * the image is the same as the original one at any time.
1433 uint64_t num_sectors
;
1434 uint64_t old_backing_num_sectors
;
1435 uint64_t new_backing_num_sectors
;
1440 float local_progress
;
1442 buf_old
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1443 buf_new
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1445 bdrv_get_geometry(bs
, &num_sectors
);
1446 bdrv_get_geometry(bs_old_backing
, &old_backing_num_sectors
);
1447 bdrv_get_geometry(bs_new_backing
, &new_backing_num_sectors
);
1449 local_progress
= (float)100 /
1450 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1451 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1453 /* How many sectors can we handle with the next read? */
1454 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1455 n
= (IO_BUF_SIZE
/ 512);
1457 n
= num_sectors
- sector
;
1460 /* If the cluster is allocated, we don't need to take action */
1461 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1467 * Read old and new backing file and take into consideration that
1468 * backing files may be smaller than the COW image.
1470 if (sector
>= old_backing_num_sectors
) {
1471 memset(buf_old
, 0, n
* BDRV_SECTOR_SIZE
);
1473 if (sector
+ n
> old_backing_num_sectors
) {
1474 n
= old_backing_num_sectors
- sector
;
1477 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1479 error_report("error while reading from old backing file");
1484 if (sector
>= new_backing_num_sectors
) {
1485 memset(buf_new
, 0, n
* BDRV_SECTOR_SIZE
);
1487 if (sector
+ n
> new_backing_num_sectors
) {
1488 n
= new_backing_num_sectors
- sector
;
1491 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1493 error_report("error while reading from new backing file");
1498 /* If they differ, we need to write to the COW file */
1499 uint64_t written
= 0;
1501 while (written
< n
) {
1504 if (compare_sectors(buf_old
+ written
* 512,
1505 buf_new
+ written
* 512, n
- written
, &pnum
))
1507 ret
= bdrv_write(bs
, sector
+ written
,
1508 buf_old
+ written
* 512, pnum
);
1510 error_report("Error while writing to COW image: %s",
1518 qemu_progress_print(local_progress
, 100);
1521 qemu_vfree(buf_old
);
1522 qemu_vfree(buf_new
);
1526 * Change the backing file. All clusters that are different from the old
1527 * backing file are overwritten in the COW file now, so the visible content
1528 * doesn't change when we switch the backing file.
1530 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1531 if (ret
== -ENOSPC
) {
1532 error_report("Could not change the backing file to '%s': No "
1533 "space left in the file header", out_baseimg
);
1534 } else if (ret
< 0) {
1535 error_report("Could not change the backing file to '%s': %s",
1536 out_baseimg
, strerror(-ret
));
1539 qemu_progress_print(100, 0);
1541 * TODO At this point it is possible to check if any clusters that are
1542 * allocated in the COW file are the same in the backing file. If so, they
1543 * could be dropped from the COW file. Don't do this before switching the
1544 * backing file, in case of a crash this would lead to corruption.
1547 qemu_progress_end();
1550 if (bs_old_backing
!= NULL
) {
1551 bdrv_delete(bs_old_backing
);
1553 if (bs_new_backing
!= NULL
) {
1554 bdrv_delete(bs_new_backing
);
1565 static int img_resize(int argc
, char **argv
)
1567 int c
, ret
, relative
;
1568 const char *filename
, *fmt
, *size
;
1569 int64_t n
, total_size
;
1570 BlockDriverState
*bs
= NULL
;
1572 static QemuOptsList resize_options
= {
1573 .name
= "resize_options",
1574 .head
= QTAILQ_HEAD_INITIALIZER(resize_options
.head
),
1577 .name
= BLOCK_OPT_SIZE
,
1578 .type
= QEMU_OPT_SIZE
,
1579 .help
= "Virtual disk size"
1586 /* Remove size from argv manually so that negative numbers are not treated
1587 * as options by getopt. */
1593 size
= argv
[--argc
];
1595 /* Parse getopt arguments */
1598 c
= getopt(argc
, argv
, "f:h");
1612 if (optind
>= argc
) {
1615 filename
= argv
[optind
++];
1617 /* Choose grow, shrink, or absolute resize mode */
1633 param
= qemu_opts_create(&resize_options
, NULL
, 0, NULL
);
1634 if (qemu_opt_set(param
, BLOCK_OPT_SIZE
, size
)) {
1635 /* Error message already printed when size parsing fails */
1637 qemu_opts_del(param
);
1640 n
= qemu_opt_get_size(param
, BLOCK_OPT_SIZE
, 0);
1641 qemu_opts_del(param
);
1643 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
, true);
1650 total_size
= bdrv_getlength(bs
) + n
* relative
;
1654 if (total_size
<= 0) {
1655 error_report("New image size must be positive");
1660 ret
= bdrv_truncate(bs
, total_size
);
1663 printf("Image resized.\n");
1666 error_report("This image does not support resize");
1669 error_report("Image is read-only");
1672 error_report("Error resizing image (%d)", -ret
);
1685 static const img_cmd_t img_cmds
[] = {
1686 #define DEF(option, callback, arg_string) \
1687 { option, callback },
1688 #include "qemu-img-cmds.h"
1694 int main(int argc
, char **argv
)
1696 const img_cmd_t
*cmd
;
1697 const char *cmdname
;
1699 error_set_progname(argv
[0]);
1707 qemu_init_main_loop();
1709 /* find the command */
1710 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1711 if (!strcmp(cmdname
, cmd
->name
)) {
1712 return cmd
->handler(argc
, argv
);