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 "qapi-visit.h"
25 #include "qapi/qmp-output-visitor.h"
27 #include "qemu-common.h"
28 #include "qemu-option.h"
29 #include "qemu-error.h"
32 #include "block_int.h"
40 typedef struct img_cmd_t
{
42 int (*handler
)(int argc
, char **argv
);
45 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
46 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
47 #define BDRV_DEFAULT_CACHE "writeback"
49 static void format_print(void *opaque
, const char *name
)
54 /* Please keep in synch with qemu-img.texi */
55 static void help(void)
57 const char *help_msg
=
58 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
59 "usage: qemu-img command [command options]\n"
60 "QEMU disk image utility\n"
63 #define DEF(option, callback, arg_string) \
65 #include "qemu-img-cmds.h"
69 "Command parameters:\n"
70 " 'filename' is a disk image filename\n"
71 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
72 " 'cache' is the cache mode used to write the output disk image, the valid\n"
73 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
74 " 'directsync' and 'unsafe' (default for convert)\n"
75 " 'size' is the disk image size in bytes. Optional suffixes\n"
76 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
77 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
78 " 'output_filename' is the destination disk image filename\n"
79 " 'output_fmt' is the destination format\n"
80 " 'options' is a comma separated list of format specific options in a\n"
81 " name=value format. Use -o ? for an overview of the options supported by the\n"
83 " '-c' indicates that target image must be compressed (qcow format only)\n"
84 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
85 " match exactly. The image doesn't need a working backing file before\n"
86 " rebasing in this case (useful for renaming the backing file)\n"
87 " '-h' with or without a command shows this help and lists the supported formats\n"
88 " '-p' show progress of command (only certain commands)\n"
89 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
90 " for qemu-img to create a sparse image during conversion\n"
91 " '--output' takes the format in which the output must be done (human or json)\n"
93 "Parameters to check subcommand:\n"
94 " '-r' tries to repair any inconsistencies that are found during the check.\n"
95 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
96 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
97 " hiding corruption that has already occured.\n"
99 "Parameters to snapshot subcommand:\n"
100 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
101 " '-a' applies a snapshot (revert disk to saved state)\n"
102 " '-c' creates a snapshot\n"
103 " '-d' deletes a snapshot\n"
104 " '-l' lists all snapshots in the given image\n";
106 printf("%s\nSupported formats:", help_msg
);
107 bdrv_iterate_format(format_print
, NULL
);
113 /* XXX: put correct support for win32 */
114 static int read_password(char *buf
, int buf_size
)
117 printf("Password: ");
124 if (i
< (buf_size
- 1))
135 static struct termios oldtty
;
137 static void term_exit(void)
139 tcsetattr (0, TCSANOW
, &oldtty
);
142 static void term_init(void)
149 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
150 |INLCR
|IGNCR
|ICRNL
|IXON
);
151 tty
.c_oflag
|= OPOST
;
152 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
153 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
158 tcsetattr (0, TCSANOW
, &tty
);
163 static int read_password(char *buf
, int buf_size
)
168 printf("password: ");
173 ret
= read(0, &ch
, 1);
175 if (errno
== EAGAIN
|| errno
== EINTR
) {
181 } else if (ret
== 0) {
189 if (i
< (buf_size
- 1))
200 static int print_block_option_help(const char *filename
, const char *fmt
)
202 BlockDriver
*drv
, *proto_drv
;
203 QEMUOptionParameter
*create_options
= NULL
;
205 /* Find driver and parse its options */
206 drv
= bdrv_find_format(fmt
);
208 error_report("Unknown file format '%s'", fmt
);
212 proto_drv
= bdrv_find_protocol(filename
);
214 error_report("Unknown protocol '%s'", filename
);
218 create_options
= append_option_parameters(create_options
,
219 drv
->create_options
);
220 create_options
= append_option_parameters(create_options
,
221 proto_drv
->create_options
);
222 print_option_help(create_options
);
223 free_option_parameters(create_options
);
227 static BlockDriverState
*bdrv_new_open(const char *filename
,
231 BlockDriverState
*bs
;
236 bs
= bdrv_new("image");
239 drv
= bdrv_find_format(fmt
);
241 error_report("Unknown file format '%s'", fmt
);
248 ret
= bdrv_open(bs
, filename
, flags
, drv
);
250 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
254 if (bdrv_is_encrypted(bs
)) {
255 printf("Disk image '%s' is encrypted.\n", filename
);
256 if (read_password(password
, sizeof(password
)) < 0) {
257 error_report("No password given");
260 if (bdrv_set_key(bs
, password
) < 0) {
261 error_report("invalid password");
273 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
274 const char *base_filename
,
275 const char *base_fmt
)
278 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
279 error_report("Backing file not supported for file format '%s'",
285 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
286 error_report("Backing file format not supported for file "
294 static int img_create(int argc
, char **argv
)
297 uint64_t img_size
= -1;
298 const char *fmt
= "raw";
299 const char *base_fmt
= NULL
;
300 const char *filename
;
301 const char *base_filename
= NULL
;
302 char *options
= NULL
;
305 c
= getopt(argc
, argv
, "F:b:f:he6o:");
318 base_filename
= optarg
;
324 error_report("option -e is deprecated, please use \'-o "
325 "encryption\' instead!");
328 error_report("option -6 is deprecated, please use \'-o "
329 "compat6\' instead!");
337 /* Get the filename */
338 if (optind
>= argc
) {
341 filename
= argv
[optind
++];
343 /* Get image size, if specified */
347 sval
= strtosz_suffix(argv
[optind
++], &end
, STRTOSZ_DEFSUFFIX_B
);
348 if (sval
< 0 || *end
) {
349 error_report("Invalid image size specified! You may use k, M, G or "
351 error_report("kilobytes, megabytes, gigabytes and terabytes.");
355 img_size
= (uint64_t)sval
;
358 if (options
&& is_help_option(options
)) {
359 ret
= print_block_option_help(filename
, fmt
);
363 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
364 options
, img_size
, BDRV_O_FLAGS
);
373 * Checks an image for consistency. Exit codes:
375 * 0 - Check completed, image is good
376 * 1 - Check not completed because of internal errors
377 * 2 - Check completed, image is corrupted
378 * 3 - Check completed, image has leaked clusters, but is good otherwise
380 static int img_check(int argc
, char **argv
)
383 const char *filename
, *fmt
;
384 BlockDriverState
*bs
;
385 BdrvCheckResult result
;
387 int flags
= BDRV_O_FLAGS
| BDRV_O_CHECK
;
391 c
= getopt(argc
, argv
, "f:hr:");
404 flags
|= BDRV_O_RDWR
;
406 if (!strcmp(optarg
, "leaks")) {
407 fix
= BDRV_FIX_LEAKS
;
408 } else if (!strcmp(optarg
, "all")) {
409 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
416 if (optind
>= argc
) {
419 filename
= argv
[optind
++];
421 bs
= bdrv_new_open(filename
, fmt
, flags
);
425 ret
= bdrv_check(bs
, &result
, fix
);
427 if (ret
== -ENOTSUP
) {
428 error_report("This image format does not support checks");
433 if (result
.corruptions_fixed
|| result
.leaks_fixed
) {
434 printf("The following inconsistencies were found and repaired:\n\n"
435 " %d leaked clusters\n"
436 " %d corruptions\n\n"
437 "Double checking the fixed image now...\n",
439 result
.corruptions_fixed
);
440 ret
= bdrv_check(bs
, &result
, 0);
443 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
444 printf("No errors were found on the image.\n");
446 if (result
.corruptions
) {
447 printf("\n%d errors were found on the image.\n"
448 "Data may be corrupted, or further writes to the image "
454 printf("\n%d leaked clusters were found on the image.\n"
455 "This means waste of disk space, but no harm to data.\n",
459 if (result
.check_errors
) {
460 printf("\n%d internal errors have occurred during the check.\n",
461 result
.check_errors
);
465 if (result
.bfi
.total_clusters
!= 0 && result
.bfi
.allocated_clusters
!= 0) {
466 printf("%" PRId64
"/%" PRId64
"= %0.2f%% allocated, %0.2f%% fragmented\n",
467 result
.bfi
.allocated_clusters
, result
.bfi
.total_clusters
,
468 result
.bfi
.allocated_clusters
* 100.0 / result
.bfi
.total_clusters
,
469 result
.bfi
.fragmented_clusters
* 100.0 / result
.bfi
.allocated_clusters
);
474 if (ret
< 0 || result
.check_errors
) {
475 printf("\nAn error has occurred during the check: %s\n"
476 "The check is not complete and may have missed error.\n",
481 if (result
.corruptions
) {
483 } else if (result
.leaks
) {
490 static int img_commit(int argc
, char **argv
)
493 const char *filename
, *fmt
, *cache
;
494 BlockDriverState
*bs
;
497 cache
= BDRV_DEFAULT_CACHE
;
499 c
= getopt(argc
, argv
, "f:ht:");
516 if (optind
>= argc
) {
519 filename
= argv
[optind
++];
522 ret
= bdrv_parse_cache_flags(cache
, &flags
);
524 error_report("Invalid cache option: %s", cache
);
528 bs
= bdrv_new_open(filename
, fmt
, flags
);
532 ret
= bdrv_commit(bs
);
535 printf("Image committed.\n");
538 error_report("No disk inserted");
541 error_report("Image is read-only");
544 error_report("Image is already committed");
547 error_report("Error while committing image");
559 * Returns true iff the first sector pointed to by 'buf' contains at least
562 * 'pnum' is set to the number of sectors (including and immediately following
563 * the first one) that are known to be in the same allocated/unallocated state.
565 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
574 is_zero
= buffer_is_zero(buf
, 512);
575 for(i
= 1; i
< n
; i
++) {
577 if (is_zero
!= buffer_is_zero(buf
, 512)) {
586 * Like is_allocated_sectors, but if the buffer starts with a used sector,
587 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
588 * breaking up write requests for only small sparse areas.
590 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
594 int num_checked
, num_used
;
600 ret
= is_allocated_sectors(buf
, n
, pnum
);
606 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
608 num_checked
= num_used
;
611 ret
= is_allocated_sectors(buf
, n
, pnum
);
613 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
615 num_checked
+= *pnum
;
617 num_used
= num_checked
;
618 } else if (*pnum
>= min
) {
628 * Compares two buffers sector by sector. Returns 0 if the first sector of both
629 * buffers matches, non-zero otherwise.
631 * pnum is set to the number of sectors (including and immediately following
632 * the first one) that are known to have the same comparison result
634 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
644 res
= !!memcmp(buf1
, buf2
, 512);
645 for(i
= 1; i
< n
; i
++) {
649 if (!!memcmp(buf1
, buf2
, 512) != res
) {
658 #define IO_BUF_SIZE (2 * 1024 * 1024)
660 static int img_convert(int argc
, char **argv
)
662 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
663 int progress
= 0, flags
;
664 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
665 BlockDriver
*drv
, *proto_drv
;
666 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
667 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
669 uint8_t * buf
= NULL
;
672 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
673 QEMUOptionParameter
*out_baseimg_param
;
674 char *options
= NULL
;
675 const char *snapshot_name
= NULL
;
676 float local_progress
;
677 int min_sparse
= 8; /* Need at least 4k of zeros for sparse detection */
685 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pS:t:");
701 out_baseimg
= optarg
;
707 error_report("option -e is deprecated, please use \'-o "
708 "encryption\' instead!");
711 error_report("option -6 is deprecated, please use \'-o "
712 "compat6\' instead!");
718 snapshot_name
= optarg
;
724 sval
= strtosz_suffix(optarg
, &end
, STRTOSZ_DEFSUFFIX_B
);
725 if (sval
< 0 || *end
) {
726 error_report("Invalid minimum zero buffer size for sparse output specified");
730 min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
742 bs_n
= argc
- optind
- 1;
747 out_filename
= argv
[argc
- 1];
749 /* Initialize before goto out */
750 qemu_progress_init(progress
, 2.0);
752 if (options
&& is_help_option(options
)) {
753 ret
= print_block_option_help(out_filename
, out_fmt
);
757 if (bs_n
> 1 && out_baseimg
) {
758 error_report("-B makes no sense when concatenating multiple input "
764 qemu_progress_print(0, 100);
766 bs
= g_malloc0(bs_n
* sizeof(BlockDriverState
*));
769 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
770 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
772 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
776 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
777 total_sectors
+= bs_sectors
;
780 if (snapshot_name
!= NULL
) {
782 error_report("No support for concatenating multiple snapshot");
786 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
787 error_report("Failed to load snapshot");
793 /* Find driver and parse its options */
794 drv
= bdrv_find_format(out_fmt
);
796 error_report("Unknown file format '%s'", out_fmt
);
801 proto_drv
= bdrv_find_protocol(out_filename
);
803 error_report("Unknown protocol '%s'", out_filename
);
808 create_options
= append_option_parameters(create_options
,
809 drv
->create_options
);
810 create_options
= append_option_parameters(create_options
,
811 proto_drv
->create_options
);
814 param
= parse_option_parameters(options
, create_options
, param
);
816 error_report("Invalid options for file format '%s'.", out_fmt
);
821 param
= parse_option_parameters("", create_options
, param
);
824 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
825 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
830 /* Get backing file name if -o backing_file was used */
831 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
832 if (out_baseimg_param
) {
833 out_baseimg
= out_baseimg_param
->value
.s
;
836 /* Check if compression is supported */
838 QEMUOptionParameter
*encryption
=
839 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
840 QEMUOptionParameter
*preallocation
=
841 get_option_parameter(param
, BLOCK_OPT_PREALLOC
);
843 if (!drv
->bdrv_write_compressed
) {
844 error_report("Compression not supported for this file format");
849 if (encryption
&& encryption
->value
.n
) {
850 error_report("Compression and encryption not supported at "
856 if (preallocation
&& preallocation
->value
.s
857 && strcmp(preallocation
->value
.s
, "off"))
859 error_report("Compression and preallocation not supported at "
866 /* Create the new image */
867 ret
= bdrv_create(drv
, out_filename
, param
);
869 if (ret
== -ENOTSUP
) {
870 error_report("Formatting not supported for file format '%s'",
872 } else if (ret
== -EFBIG
) {
873 error_report("The image size is too large for file format '%s'",
876 error_report("%s: error while converting %s: %s",
877 out_filename
, out_fmt
, strerror(-ret
));
883 ret
= bdrv_parse_cache_flags(cache
, &flags
);
885 error_report("Invalid cache option: %s", cache
);
889 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
);
897 bdrv_get_geometry(bs
[0], &bs_sectors
);
898 buf
= qemu_blockalign(out_bs
, IO_BUF_SIZE
);
901 ret
= bdrv_get_info(out_bs
, &bdi
);
903 error_report("could not get block driver info");
906 cluster_size
= bdi
.cluster_size
;
907 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
908 error_report("invalid cluster size");
912 cluster_sectors
= cluster_size
>> 9;
915 nb_sectors
= total_sectors
;
916 local_progress
= (float)100 /
917 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
924 nb_sectors
= total_sectors
- sector_num
;
927 if (nb_sectors
>= cluster_sectors
)
932 bs_num
= sector_num
- bs_offset
;
933 assert (bs_num
>= 0);
936 while (remainder
> 0) {
938 while (bs_num
== bs_sectors
) {
940 assert (bs_i
< bs_n
);
941 bs_offset
+= bs_sectors
;
942 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
944 /* printf("changing part: sector_num=%" PRId64 ", "
945 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
946 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
948 assert (bs_num
< bs_sectors
);
950 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
952 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
954 error_report("error while reading sector %" PRId64
": %s",
955 bs_num
, strerror(-ret
));
964 assert (remainder
== 0);
966 if (n
< cluster_sectors
) {
967 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
969 if (!buffer_is_zero(buf
, cluster_size
)) {
970 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
973 error_report("error while compressing sector %" PRId64
974 ": %s", sector_num
, strerror(-ret
));
979 qemu_progress_print(local_progress
, 100);
981 /* signal EOF to align */
982 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
984 int has_zero_init
= bdrv_has_zero_init(out_bs
);
986 sector_num
= 0; // total number of sectors converted so far
987 nb_sectors
= total_sectors
- sector_num
;
988 local_progress
= (float)100 /
989 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
992 nb_sectors
= total_sectors
- sector_num
;
993 if (nb_sectors
<= 0) {
996 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
997 n
= (IO_BUF_SIZE
/ 512);
1002 while (sector_num
- bs_offset
>= bs_sectors
) {
1004 assert (bs_i
< bs_n
);
1005 bs_offset
+= bs_sectors
;
1006 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
1007 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1008 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1009 sector_num, bs_i, bs_offset, bs_sectors); */
1012 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
1013 n
= bs_offset
+ bs_sectors
- sector_num
;
1016 if (has_zero_init
) {
1017 /* If the output image is being created as a copy on write image,
1018 assume that sectors which are unallocated in the input image
1019 are present in both the output's and input's base images (no
1020 need to copy them). */
1022 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
1027 /* The next 'n1' sectors are allocated in the input image. Copy
1028 only those as they may be followed by unallocated sectors. */
1035 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
1037 error_report("error while reading sector %" PRId64
": %s",
1038 sector_num
- bs_offset
, strerror(-ret
));
1041 /* NOTE: at the same time we convert, we do not write zero
1042 sectors to have a chance to compress the image. Ideally, we
1043 should add a specific call to have the info to go faster */
1046 /* If the output image is being created as a copy on write image,
1047 copy all sectors even the ones containing only NUL bytes,
1048 because they may differ from the sectors in the base image.
1050 If the output is to a host device, we also write out
1051 sectors that are entirely 0, since whatever data was
1052 already there is garbage, not 0s. */
1053 if (!has_zero_init
|| out_baseimg
||
1054 is_allocated_sectors_min(buf1
, n
, &n1
, min_sparse
)) {
1055 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1057 error_report("error while writing sector %" PRId64
1058 ": %s", sector_num
, strerror(-ret
));
1066 qemu_progress_print(local_progress
, 100);
1070 qemu_progress_end();
1071 free_option_parameters(create_options
);
1072 free_option_parameters(param
);
1075 bdrv_delete(out_bs
);
1078 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1080 bdrv_delete(bs
[bs_i
]);
1092 static void dump_snapshots(BlockDriverState
*bs
)
1094 QEMUSnapshotInfo
*sn_tab
, *sn
;
1098 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1101 printf("Snapshot list:\n");
1102 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1103 for(i
= 0; i
< nb_sns
; i
++) {
1105 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1110 static void collect_snapshots(BlockDriverState
*bs
, ImageInfo
*info
)
1113 QEMUSnapshotInfo
*sn_tab
= NULL
;
1114 SnapshotInfoList
*info_list
, *cur_item
= NULL
;
1115 sn_count
= bdrv_snapshot_list(bs
, &sn_tab
);
1117 for (i
= 0; i
< sn_count
; i
++) {
1118 info
->has_snapshots
= true;
1119 info_list
= g_new0(SnapshotInfoList
, 1);
1121 info_list
->value
= g_new0(SnapshotInfo
, 1);
1122 info_list
->value
->id
= g_strdup(sn_tab
[i
].id_str
);
1123 info_list
->value
->name
= g_strdup(sn_tab
[i
].name
);
1124 info_list
->value
->vm_state_size
= sn_tab
[i
].vm_state_size
;
1125 info_list
->value
->date_sec
= sn_tab
[i
].date_sec
;
1126 info_list
->value
->date_nsec
= sn_tab
[i
].date_nsec
;
1127 info_list
->value
->vm_clock_sec
= sn_tab
[i
].vm_clock_nsec
/ 1000000000;
1128 info_list
->value
->vm_clock_nsec
= sn_tab
[i
].vm_clock_nsec
% 1000000000;
1130 /* XXX: waiting for the qapi to support qemu-queue.h types */
1132 info
->snapshots
= cur_item
= info_list
;
1134 cur_item
->next
= info_list
;
1135 cur_item
= info_list
;
1143 static void dump_json_image_info(ImageInfo
*info
)
1147 QmpOutputVisitor
*ov
= qmp_output_visitor_new();
1149 visit_type_ImageInfo(qmp_output_get_visitor(ov
),
1150 &info
, NULL
, &errp
);
1151 obj
= qmp_output_get_qobject(ov
);
1152 str
= qobject_to_json_pretty(obj
);
1153 assert(str
!= NULL
);
1154 printf("%s\n", qstring_get_str(str
));
1155 qobject_decref(obj
);
1156 qmp_output_visitor_cleanup(ov
);
1160 static void collect_image_info(BlockDriverState
*bs
,
1162 const char *filename
,
1165 uint64_t total_sectors
;
1166 char backing_filename
[1024];
1167 char backing_filename2
[1024];
1168 BlockDriverInfo bdi
;
1170 bdrv_get_geometry(bs
, &total_sectors
);
1172 info
->filename
= g_strdup(filename
);
1173 info
->format
= g_strdup(bdrv_get_format_name(bs
));
1174 info
->virtual_size
= total_sectors
* 512;
1175 info
->actual_size
= bdrv_get_allocated_file_size(bs
);
1176 info
->has_actual_size
= info
->actual_size
>= 0;
1177 if (bdrv_is_encrypted(bs
)) {
1178 info
->encrypted
= true;
1179 info
->has_encrypted
= true;
1181 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1182 if (bdi
.cluster_size
!= 0) {
1183 info
->cluster_size
= bdi
.cluster_size
;
1184 info
->has_cluster_size
= true;
1186 info
->dirty_flag
= bdi
.is_dirty
;
1187 info
->has_dirty_flag
= true;
1189 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1190 if (backing_filename
[0] != '\0') {
1191 info
->backing_filename
= g_strdup(backing_filename
);
1192 info
->has_backing_filename
= true;
1193 bdrv_get_full_backing_filename(bs
, backing_filename2
,
1194 sizeof(backing_filename2
));
1196 if (strcmp(backing_filename
, backing_filename2
) != 0) {
1197 info
->full_backing_filename
=
1198 g_strdup(backing_filename2
);
1199 info
->has_full_backing_filename
= true;
1202 if (bs
->backing_format
[0]) {
1203 info
->backing_filename_format
= g_strdup(bs
->backing_format
);
1204 info
->has_backing_filename_format
= true;
1209 static void dump_human_image_info(ImageInfo
*info
)
1211 char size_buf
[128], dsize_buf
[128];
1212 if (!info
->has_actual_size
) {
1213 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1215 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1218 get_human_readable_size(size_buf
, sizeof(size_buf
), info
->virtual_size
);
1219 printf("image: %s\n"
1221 "virtual size: %s (%" PRId64
" bytes)\n"
1223 info
->filename
, info
->format
, size_buf
,
1227 if (info
->has_encrypted
&& info
->encrypted
) {
1228 printf("encrypted: yes\n");
1231 if (info
->has_cluster_size
) {
1232 printf("cluster_size: %" PRId64
"\n", info
->cluster_size
);
1235 if (info
->has_dirty_flag
&& info
->dirty_flag
) {
1236 printf("cleanly shut down: no\n");
1239 if (info
->has_backing_filename
) {
1240 printf("backing file: %s", info
->backing_filename
);
1241 if (info
->has_full_backing_filename
) {
1242 printf(" (actual path: %s)", info
->full_backing_filename
);
1245 if (info
->has_backing_filename_format
) {
1246 printf("backing file format: %s\n", info
->backing_filename_format
);
1251 enum {OPTION_OUTPUT
= 256};
1253 typedef enum OutputFormat
{
1258 static int img_info(int argc
, char **argv
)
1261 OutputFormat output_format
= OFORMAT_HUMAN
;
1262 const char *filename
, *fmt
, *output
;
1263 BlockDriverState
*bs
;
1269 int option_index
= 0;
1270 static const struct option long_options
[] = {
1271 {"help", no_argument
, 0, 'h'},
1272 {"format", required_argument
, 0, 'f'},
1273 {"output", required_argument
, 0, OPTION_OUTPUT
},
1276 c
= getopt_long(argc
, argv
, "f:h",
1277 long_options
, &option_index
);
1294 if (optind
>= argc
) {
1297 filename
= argv
[optind
++];
1299 if (output
&& !strcmp(output
, "json")) {
1300 output_format
= OFORMAT_JSON
;
1301 } else if (output
&& !strcmp(output
, "human")) {
1302 output_format
= OFORMAT_HUMAN
;
1303 } else if (output
) {
1304 error_report("--output must be used with human or json as argument.");
1308 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1313 info
= g_new0(ImageInfo
, 1);
1314 collect_image_info(bs
, info
, filename
, fmt
);
1316 switch (output_format
) {
1318 dump_human_image_info(info
);
1322 collect_snapshots(bs
, info
);
1323 dump_json_image_info(info
);
1327 qapi_free_ImageInfo(info
);
1332 #define SNAPSHOT_LIST 1
1333 #define SNAPSHOT_CREATE 2
1334 #define SNAPSHOT_APPLY 3
1335 #define SNAPSHOT_DELETE 4
1337 static int img_snapshot(int argc
, char **argv
)
1339 BlockDriverState
*bs
;
1340 QEMUSnapshotInfo sn
;
1341 char *filename
, *snapshot_name
= NULL
;
1342 int c
, ret
= 0, bdrv_oflags
;
1346 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1347 /* Parse commandline parameters */
1349 c
= getopt(argc
, argv
, "la:c:d:h");
1363 action
= SNAPSHOT_LIST
;
1364 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1371 action
= SNAPSHOT_APPLY
;
1372 snapshot_name
= optarg
;
1379 action
= SNAPSHOT_CREATE
;
1380 snapshot_name
= optarg
;
1387 action
= SNAPSHOT_DELETE
;
1388 snapshot_name
= optarg
;
1393 if (optind
>= argc
) {
1396 filename
= argv
[optind
++];
1398 /* Open the image */
1399 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1404 /* Perform the requested action */
1410 case SNAPSHOT_CREATE
:
1411 memset(&sn
, 0, sizeof(sn
));
1412 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1414 qemu_gettimeofday(&tv
);
1415 sn
.date_sec
= tv
.tv_sec
;
1416 sn
.date_nsec
= tv
.tv_usec
* 1000;
1418 ret
= bdrv_snapshot_create(bs
, &sn
);
1420 error_report("Could not create snapshot '%s': %d (%s)",
1421 snapshot_name
, ret
, strerror(-ret
));
1425 case SNAPSHOT_APPLY
:
1426 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1428 error_report("Could not apply snapshot '%s': %d (%s)",
1429 snapshot_name
, ret
, strerror(-ret
));
1433 case SNAPSHOT_DELETE
:
1434 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1436 error_report("Could not delete snapshot '%s': %d (%s)",
1437 snapshot_name
, ret
, strerror(-ret
));
1450 static int img_rebase(int argc
, char **argv
)
1452 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1453 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1455 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1460 /* Parse commandline parameters */
1462 cache
= BDRV_DEFAULT_CACHE
;
1466 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1479 out_basefmt
= optarg
;
1482 out_baseimg
= optarg
;
1496 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1499 filename
= argv
[optind
++];
1501 qemu_progress_init(progress
, 2.0);
1502 qemu_progress_print(0, 100);
1504 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1505 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1507 error_report("Invalid cache option: %s", cache
);
1514 * Ignore the old backing file for unsafe rebase in case we want to correct
1515 * the reference to a renamed or moved backing file.
1517 bs
= bdrv_new_open(filename
, fmt
, flags
);
1522 /* Find the right drivers for the backing files */
1523 old_backing_drv
= NULL
;
1524 new_backing_drv
= NULL
;
1526 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1527 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1528 if (old_backing_drv
== NULL
) {
1529 error_report("Invalid format name: '%s'", bs
->backing_format
);
1535 if (out_basefmt
!= NULL
) {
1536 new_backing_drv
= bdrv_find_format(out_basefmt
);
1537 if (new_backing_drv
== NULL
) {
1538 error_report("Invalid format name: '%s'", out_basefmt
);
1544 /* For safe rebasing we need to compare old and new backing file */
1546 /* Make the compiler happy */
1547 bs_old_backing
= NULL
;
1548 bs_new_backing
= NULL
;
1550 char backing_name
[1024];
1552 bs_old_backing
= bdrv_new("old_backing");
1553 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1554 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1557 error_report("Could not open old backing file '%s'", backing_name
);
1561 bs_new_backing
= bdrv_new("new_backing");
1562 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1565 error_report("Could not open new backing file '%s'", out_baseimg
);
1571 * Check each unallocated cluster in the COW file. If it is unallocated,
1572 * accesses go to the backing file. We must therefore compare this cluster
1573 * in the old and new backing file, and if they differ we need to copy it
1574 * from the old backing file into the COW file.
1576 * If qemu-img crashes during this step, no harm is done. The content of
1577 * the image is the same as the original one at any time.
1580 uint64_t num_sectors
;
1581 uint64_t old_backing_num_sectors
;
1582 uint64_t new_backing_num_sectors
;
1587 float local_progress
;
1589 buf_old
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1590 buf_new
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1592 bdrv_get_geometry(bs
, &num_sectors
);
1593 bdrv_get_geometry(bs_old_backing
, &old_backing_num_sectors
);
1594 bdrv_get_geometry(bs_new_backing
, &new_backing_num_sectors
);
1596 local_progress
= (float)100 /
1597 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1598 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1600 /* How many sectors can we handle with the next read? */
1601 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1602 n
= (IO_BUF_SIZE
/ 512);
1604 n
= num_sectors
- sector
;
1607 /* If the cluster is allocated, we don't need to take action */
1608 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1614 * Read old and new backing file and take into consideration that
1615 * backing files may be smaller than the COW image.
1617 if (sector
>= old_backing_num_sectors
) {
1618 memset(buf_old
, 0, n
* BDRV_SECTOR_SIZE
);
1620 if (sector
+ n
> old_backing_num_sectors
) {
1621 n
= old_backing_num_sectors
- sector
;
1624 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1626 error_report("error while reading from old backing file");
1631 if (sector
>= new_backing_num_sectors
) {
1632 memset(buf_new
, 0, n
* BDRV_SECTOR_SIZE
);
1634 if (sector
+ n
> new_backing_num_sectors
) {
1635 n
= new_backing_num_sectors
- sector
;
1638 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1640 error_report("error while reading from new backing file");
1645 /* If they differ, we need to write to the COW file */
1646 uint64_t written
= 0;
1648 while (written
< n
) {
1651 if (compare_sectors(buf_old
+ written
* 512,
1652 buf_new
+ written
* 512, n
- written
, &pnum
))
1654 ret
= bdrv_write(bs
, sector
+ written
,
1655 buf_old
+ written
* 512, pnum
);
1657 error_report("Error while writing to COW image: %s",
1665 qemu_progress_print(local_progress
, 100);
1668 qemu_vfree(buf_old
);
1669 qemu_vfree(buf_new
);
1673 * Change the backing file. All clusters that are different from the old
1674 * backing file are overwritten in the COW file now, so the visible content
1675 * doesn't change when we switch the backing file.
1677 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1678 if (ret
== -ENOSPC
) {
1679 error_report("Could not change the backing file to '%s': No "
1680 "space left in the file header", out_baseimg
);
1681 } else if (ret
< 0) {
1682 error_report("Could not change the backing file to '%s': %s",
1683 out_baseimg
, strerror(-ret
));
1686 qemu_progress_print(100, 0);
1688 * TODO At this point it is possible to check if any clusters that are
1689 * allocated in the COW file are the same in the backing file. If so, they
1690 * could be dropped from the COW file. Don't do this before switching the
1691 * backing file, in case of a crash this would lead to corruption.
1694 qemu_progress_end();
1697 if (bs_old_backing
!= NULL
) {
1698 bdrv_delete(bs_old_backing
);
1700 if (bs_new_backing
!= NULL
) {
1701 bdrv_delete(bs_new_backing
);
1712 static int img_resize(int argc
, char **argv
)
1714 int c
, ret
, relative
;
1715 const char *filename
, *fmt
, *size
;
1716 int64_t n
, total_size
;
1717 BlockDriverState
*bs
= NULL
;
1719 static QemuOptsList resize_options
= {
1720 .name
= "resize_options",
1721 .head
= QTAILQ_HEAD_INITIALIZER(resize_options
.head
),
1724 .name
= BLOCK_OPT_SIZE
,
1725 .type
= QEMU_OPT_SIZE
,
1726 .help
= "Virtual disk size"
1733 /* Remove size from argv manually so that negative numbers are not treated
1734 * as options by getopt. */
1740 size
= argv
[--argc
];
1742 /* Parse getopt arguments */
1745 c
= getopt(argc
, argv
, "f:h");
1759 if (optind
>= argc
) {
1762 filename
= argv
[optind
++];
1764 /* Choose grow, shrink, or absolute resize mode */
1780 param
= qemu_opts_create(&resize_options
, NULL
, 0, NULL
);
1781 if (qemu_opt_set(param
, BLOCK_OPT_SIZE
, size
)) {
1782 /* Error message already printed when size parsing fails */
1784 qemu_opts_del(param
);
1787 n
= qemu_opt_get_size(param
, BLOCK_OPT_SIZE
, 0);
1788 qemu_opts_del(param
);
1790 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1797 total_size
= bdrv_getlength(bs
) + n
* relative
;
1801 if (total_size
<= 0) {
1802 error_report("New image size must be positive");
1807 ret
= bdrv_truncate(bs
, total_size
);
1810 printf("Image resized.\n");
1813 error_report("This image does not support resize");
1816 error_report("Image is read-only");
1819 error_report("Error resizing image (%d)", -ret
);
1832 static const img_cmd_t img_cmds
[] = {
1833 #define DEF(option, callback, arg_string) \
1834 { option, callback },
1835 #include "qemu-img-cmds.h"
1841 int main(int argc
, char **argv
)
1843 const img_cmd_t
*cmd
;
1844 const char *cmdname
;
1846 error_set_progname(argv
[0]);
1854 qemu_init_main_loop();
1856 /* find the command */
1857 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1858 if (!strcmp(cmdname
, cmd
->name
)) {
1859 return cmd
->handler(argc
, argv
);