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 occured.\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
,
226 BlockDriverState
*bs
;
231 bs
= bdrv_new("image");
234 drv
= bdrv_find_format(fmt
);
236 error_report("Unknown file format '%s'", fmt
);
243 ret
= bdrv_open(bs
, filename
, flags
, drv
);
245 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
249 if (bdrv_is_encrypted(bs
)) {
250 printf("Disk image '%s' is encrypted.\n", filename
);
251 if (read_password(password
, sizeof(password
)) < 0) {
252 error_report("No password given");
255 if (bdrv_set_key(bs
, password
) < 0) {
256 error_report("invalid password");
268 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
269 const char *base_filename
,
270 const char *base_fmt
)
273 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
274 error_report("Backing file not supported for file format '%s'",
280 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
281 error_report("Backing file format not supported for file "
289 static int img_create(int argc
, char **argv
)
292 uint64_t img_size
= -1;
293 const char *fmt
= "raw";
294 const char *base_fmt
= NULL
;
295 const char *filename
;
296 const char *base_filename
= NULL
;
297 char *options
= NULL
;
300 c
= getopt(argc
, argv
, "F:b:f:he6o:");
313 base_filename
= optarg
;
319 error_report("option -e is deprecated, please use \'-o "
320 "encryption\' instead!");
323 error_report("option -6 is deprecated, please use \'-o "
324 "compat6\' instead!");
332 /* Get the filename */
333 if (optind
>= argc
) {
336 filename
= argv
[optind
++];
338 /* Get image size, if specified */
342 sval
= strtosz_suffix(argv
[optind
++], &end
, STRTOSZ_DEFSUFFIX_B
);
343 if (sval
< 0 || *end
) {
344 error_report("Invalid image size specified! You may use k, M, G or "
346 error_report("kilobytes, megabytes, gigabytes and terabytes.");
350 img_size
= (uint64_t)sval
;
353 if (options
&& !strcmp(options
, "?")) {
354 ret
= print_block_option_help(filename
, fmt
);
358 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
359 options
, img_size
, BDRV_O_FLAGS
);
368 * Checks an image for consistency. Exit codes:
370 * 0 - Check completed, image is good
371 * 1 - Check not completed because of internal errors
372 * 2 - Check completed, image is corrupted
373 * 3 - Check completed, image has leaked clusters, but is good otherwise
375 static int img_check(int argc
, char **argv
)
378 const char *filename
, *fmt
;
379 BlockDriverState
*bs
;
380 BdrvCheckResult result
;
382 int flags
= BDRV_O_FLAGS
;
386 c
= getopt(argc
, argv
, "f:hr:");
399 flags
|= BDRV_O_RDWR
;
401 if (!strcmp(optarg
, "leaks")) {
402 fix
= BDRV_FIX_LEAKS
;
403 } else if (!strcmp(optarg
, "all")) {
404 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
411 if (optind
>= argc
) {
414 filename
= argv
[optind
++];
416 bs
= bdrv_new_open(filename
, fmt
, flags
);
420 ret
= bdrv_check(bs
, &result
, fix
);
422 if (ret
== -ENOTSUP
) {
423 error_report("This image format does not support checks");
428 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
429 printf("No errors were found on the image.\n");
431 if (result
.corruptions
) {
432 printf("\n%d errors were found on the image.\n"
433 "Data may be corrupted, or further writes to the image "
439 printf("\n%d leaked clusters were found on the image.\n"
440 "This means waste of disk space, but no harm to data.\n",
444 if (result
.check_errors
) {
445 printf("\n%d internal errors have occurred during the check.\n",
446 result
.check_errors
);
450 if (result
.bfi
.total_clusters
!= 0 && result
.bfi
.allocated_clusters
!= 0) {
451 printf("%" PRId64
"/%" PRId64
"= %0.2f%% allocated, %0.2f%% fragmented\n",
452 result
.bfi
.allocated_clusters
, result
.bfi
.total_clusters
,
453 result
.bfi
.allocated_clusters
* 100.0 / result
.bfi
.total_clusters
,
454 result
.bfi
.fragmented_clusters
* 100.0 / result
.bfi
.allocated_clusters
);
459 if (ret
< 0 || result
.check_errors
) {
460 printf("\nAn error has occurred during the check: %s\n"
461 "The check is not complete and may have missed error.\n",
466 if (result
.corruptions
) {
468 } else if (result
.leaks
) {
475 static int img_commit(int argc
, char **argv
)
478 const char *filename
, *fmt
, *cache
;
479 BlockDriverState
*bs
;
482 cache
= BDRV_DEFAULT_CACHE
;
484 c
= getopt(argc
, argv
, "f:ht:");
501 if (optind
>= argc
) {
504 filename
= argv
[optind
++];
507 ret
= bdrv_parse_cache_flags(cache
, &flags
);
509 error_report("Invalid cache option: %s", cache
);
513 bs
= bdrv_new_open(filename
, fmt
, flags
);
517 ret
= bdrv_commit(bs
);
520 printf("Image committed.\n");
523 error_report("No disk inserted");
526 error_report("Image is read-only");
529 error_report("Image is already committed");
532 error_report("Error while committing image");
544 * Returns true iff the first sector pointed to by 'buf' contains at least
547 * 'pnum' is set to the number of sectors (including and immediately following
548 * the first one) that are known to be in the same allocated/unallocated state.
550 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
559 is_zero
= buffer_is_zero(buf
, 512);
560 for(i
= 1; i
< n
; i
++) {
562 if (is_zero
!= buffer_is_zero(buf
, 512)) {
571 * Like is_allocated_sectors, but if the buffer starts with a used sector,
572 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
573 * breaking up write requests for only small sparse areas.
575 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
579 int num_checked
, num_used
;
585 ret
= is_allocated_sectors(buf
, n
, pnum
);
591 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
593 num_checked
= num_used
;
596 ret
= is_allocated_sectors(buf
, n
, pnum
);
598 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
600 num_checked
+= *pnum
;
602 num_used
= num_checked
;
603 } else if (*pnum
>= min
) {
613 * Compares two buffers sector by sector. Returns 0 if the first sector of both
614 * buffers matches, non-zero otherwise.
616 * pnum is set to the number of sectors (including and immediately following
617 * the first one) that are known to have the same comparison result
619 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
629 res
= !!memcmp(buf1
, buf2
, 512);
630 for(i
= 1; i
< n
; i
++) {
634 if (!!memcmp(buf1
, buf2
, 512) != res
) {
643 #define IO_BUF_SIZE (2 * 1024 * 1024)
645 static int img_convert(int argc
, char **argv
)
647 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
648 int progress
= 0, flags
;
649 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
650 BlockDriver
*drv
, *proto_drv
;
651 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
652 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
654 uint8_t * buf
= NULL
;
657 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
658 QEMUOptionParameter
*out_baseimg_param
;
659 char *options
= NULL
;
660 const char *snapshot_name
= NULL
;
661 float local_progress
;
662 int min_sparse
= 8; /* Need at least 4k of zeros for sparse detection */
670 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pS:t:");
686 out_baseimg
= optarg
;
692 error_report("option -e is deprecated, please use \'-o "
693 "encryption\' instead!");
696 error_report("option -6 is deprecated, please use \'-o "
697 "compat6\' instead!");
703 snapshot_name
= optarg
;
709 sval
= strtosz_suffix(optarg
, &end
, STRTOSZ_DEFSUFFIX_B
);
710 if (sval
< 0 || *end
) {
711 error_report("Invalid minimum zero buffer size for sparse output specified");
715 min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
727 bs_n
= argc
- optind
- 1;
732 out_filename
= argv
[argc
- 1];
734 /* Initialize before goto out */
735 qemu_progress_init(progress
, 2.0);
737 if (options
&& !strcmp(options
, "?")) {
738 ret
= print_block_option_help(out_filename
, out_fmt
);
742 if (bs_n
> 1 && out_baseimg
) {
743 error_report("-B makes no sense when concatenating multiple input "
749 qemu_progress_print(0, 100);
751 bs
= g_malloc0(bs_n
* sizeof(BlockDriverState
*));
754 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
755 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
757 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
761 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
762 total_sectors
+= bs_sectors
;
765 if (snapshot_name
!= NULL
) {
767 error_report("No support for concatenating multiple snapshot");
771 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
772 error_report("Failed to load snapshot");
778 /* Find driver and parse its options */
779 drv
= bdrv_find_format(out_fmt
);
781 error_report("Unknown file format '%s'", out_fmt
);
786 proto_drv
= bdrv_find_protocol(out_filename
);
788 error_report("Unknown protocol '%s'", out_filename
);
793 create_options
= append_option_parameters(create_options
,
794 drv
->create_options
);
795 create_options
= append_option_parameters(create_options
,
796 proto_drv
->create_options
);
799 param
= parse_option_parameters(options
, create_options
, param
);
801 error_report("Invalid options for file format '%s'.", out_fmt
);
806 param
= parse_option_parameters("", create_options
, param
);
809 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
810 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
815 /* Get backing file name if -o backing_file was used */
816 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
817 if (out_baseimg_param
) {
818 out_baseimg
= out_baseimg_param
->value
.s
;
821 /* Check if compression is supported */
823 QEMUOptionParameter
*encryption
=
824 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
825 QEMUOptionParameter
*preallocation
=
826 get_option_parameter(param
, BLOCK_OPT_PREALLOC
);
828 if (!drv
->bdrv_write_compressed
) {
829 error_report("Compression not supported for this file format");
834 if (encryption
&& encryption
->value
.n
) {
835 error_report("Compression and encryption not supported at "
841 if (preallocation
&& preallocation
->value
.s
842 && strcmp(preallocation
->value
.s
, "off"))
844 error_report("Compression and preallocation not supported at "
851 /* Create the new image */
852 ret
= bdrv_create(drv
, out_filename
, param
);
854 if (ret
== -ENOTSUP
) {
855 error_report("Formatting not supported for file format '%s'",
857 } else if (ret
== -EFBIG
) {
858 error_report("The image size is too large for file format '%s'",
861 error_report("%s: error while converting %s: %s",
862 out_filename
, out_fmt
, strerror(-ret
));
868 ret
= bdrv_parse_cache_flags(cache
, &flags
);
870 error_report("Invalid cache option: %s", cache
);
874 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
);
882 bdrv_get_geometry(bs
[0], &bs_sectors
);
883 buf
= qemu_blockalign(out_bs
, IO_BUF_SIZE
);
886 ret
= bdrv_get_info(out_bs
, &bdi
);
888 error_report("could not get block driver info");
891 cluster_size
= bdi
.cluster_size
;
892 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
893 error_report("invalid cluster size");
897 cluster_sectors
= cluster_size
>> 9;
900 nb_sectors
= total_sectors
;
901 local_progress
= (float)100 /
902 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
909 nb_sectors
= total_sectors
- sector_num
;
912 if (nb_sectors
>= cluster_sectors
)
917 bs_num
= sector_num
- bs_offset
;
918 assert (bs_num
>= 0);
921 while (remainder
> 0) {
923 while (bs_num
== bs_sectors
) {
925 assert (bs_i
< bs_n
);
926 bs_offset
+= bs_sectors
;
927 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
929 /* printf("changing part: sector_num=%" PRId64 ", "
930 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
931 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
933 assert (bs_num
< bs_sectors
);
935 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
937 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
939 error_report("error while reading sector %" PRId64
": %s",
940 bs_num
, strerror(-ret
));
949 assert (remainder
== 0);
951 if (n
< cluster_sectors
) {
952 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
954 if (!buffer_is_zero(buf
, cluster_size
)) {
955 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
958 error_report("error while compressing sector %" PRId64
959 ": %s", sector_num
, strerror(-ret
));
964 qemu_progress_print(local_progress
, 100);
966 /* signal EOF to align */
967 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
969 int has_zero_init
= bdrv_has_zero_init(out_bs
);
971 sector_num
= 0; // total number of sectors converted so far
972 nb_sectors
= total_sectors
- sector_num
;
973 local_progress
= (float)100 /
974 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
977 nb_sectors
= total_sectors
- sector_num
;
978 if (nb_sectors
<= 0) {
981 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
982 n
= (IO_BUF_SIZE
/ 512);
987 while (sector_num
- bs_offset
>= bs_sectors
) {
989 assert (bs_i
< bs_n
);
990 bs_offset
+= bs_sectors
;
991 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
992 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
993 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
994 sector_num, bs_i, bs_offset, bs_sectors); */
997 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
998 n
= bs_offset
+ bs_sectors
- sector_num
;
1001 if (has_zero_init
) {
1002 /* If the output image is being created as a copy on write image,
1003 assume that sectors which are unallocated in the input image
1004 are present in both the output's and input's base images (no
1005 need to copy them). */
1007 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
1012 /* The next 'n1' sectors are allocated in the input image. Copy
1013 only those as they may be followed by unallocated sectors. */
1020 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
1022 error_report("error while reading sector %" PRId64
": %s",
1023 sector_num
- bs_offset
, strerror(-ret
));
1026 /* NOTE: at the same time we convert, we do not write zero
1027 sectors to have a chance to compress the image. Ideally, we
1028 should add a specific call to have the info to go faster */
1031 /* If the output image is being created as a copy on write image,
1032 copy all sectors even the ones containing only NUL bytes,
1033 because they may differ from the sectors in the base image.
1035 If the output is to a host device, we also write out
1036 sectors that are entirely 0, since whatever data was
1037 already there is garbage, not 0s. */
1038 if (!has_zero_init
|| out_baseimg
||
1039 is_allocated_sectors_min(buf1
, n
, &n1
, min_sparse
)) {
1040 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1042 error_report("error while writing sector %" PRId64
1043 ": %s", sector_num
, strerror(-ret
));
1051 qemu_progress_print(local_progress
, 100);
1055 qemu_progress_end();
1056 free_option_parameters(create_options
);
1057 free_option_parameters(param
);
1060 bdrv_delete(out_bs
);
1063 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1065 bdrv_delete(bs
[bs_i
]);
1077 static void dump_snapshots(BlockDriverState
*bs
)
1079 QEMUSnapshotInfo
*sn_tab
, *sn
;
1083 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1086 printf("Snapshot list:\n");
1087 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1088 for(i
= 0; i
< nb_sns
; i
++) {
1090 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1095 static int img_info(int argc
, char **argv
)
1098 const char *filename
, *fmt
;
1099 BlockDriverState
*bs
;
1100 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1101 uint64_t total_sectors
;
1102 int64_t allocated_size
;
1103 char backing_filename
[1024];
1104 char backing_filename2
[1024];
1105 BlockDriverInfo bdi
;
1109 c
= getopt(argc
, argv
, "f:h");
1123 if (optind
>= argc
) {
1126 filename
= argv
[optind
++];
1128 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1132 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1133 bdrv_get_geometry(bs
, &total_sectors
);
1134 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1135 allocated_size
= bdrv_get_allocated_file_size(bs
);
1136 if (allocated_size
< 0) {
1137 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1139 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1142 printf("image: %s\n"
1144 "virtual size: %s (%" PRId64
" bytes)\n"
1146 filename
, fmt_name
, size_buf
,
1147 (total_sectors
* 512),
1149 if (bdrv_is_encrypted(bs
)) {
1150 printf("encrypted: yes\n");
1152 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1153 if (bdi
.cluster_size
!= 0) {
1154 printf("cluster_size: %d\n", bdi
.cluster_size
);
1157 printf("cleanly shut down: no\n");
1160 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1161 if (backing_filename
[0] != '\0') {
1162 bdrv_get_full_backing_filename(bs
, backing_filename2
,
1163 sizeof(backing_filename2
));
1164 printf("backing file: %s", backing_filename
);
1165 if (strcmp(backing_filename
, backing_filename2
) != 0) {
1166 printf(" (actual path: %s)", backing_filename2
);
1175 #define SNAPSHOT_LIST 1
1176 #define SNAPSHOT_CREATE 2
1177 #define SNAPSHOT_APPLY 3
1178 #define SNAPSHOT_DELETE 4
1180 static int img_snapshot(int argc
, char **argv
)
1182 BlockDriverState
*bs
;
1183 QEMUSnapshotInfo sn
;
1184 char *filename
, *snapshot_name
= NULL
;
1185 int c
, ret
= 0, bdrv_oflags
;
1189 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1190 /* Parse commandline parameters */
1192 c
= getopt(argc
, argv
, "la:c:d:h");
1206 action
= SNAPSHOT_LIST
;
1207 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1214 action
= SNAPSHOT_APPLY
;
1215 snapshot_name
= optarg
;
1222 action
= SNAPSHOT_CREATE
;
1223 snapshot_name
= optarg
;
1230 action
= SNAPSHOT_DELETE
;
1231 snapshot_name
= optarg
;
1236 if (optind
>= argc
) {
1239 filename
= argv
[optind
++];
1241 /* Open the image */
1242 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1247 /* Perform the requested action */
1253 case SNAPSHOT_CREATE
:
1254 memset(&sn
, 0, sizeof(sn
));
1255 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1257 qemu_gettimeofday(&tv
);
1258 sn
.date_sec
= tv
.tv_sec
;
1259 sn
.date_nsec
= tv
.tv_usec
* 1000;
1261 ret
= bdrv_snapshot_create(bs
, &sn
);
1263 error_report("Could not create snapshot '%s': %d (%s)",
1264 snapshot_name
, ret
, strerror(-ret
));
1268 case SNAPSHOT_APPLY
:
1269 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1271 error_report("Could not apply snapshot '%s': %d (%s)",
1272 snapshot_name
, ret
, strerror(-ret
));
1276 case SNAPSHOT_DELETE
:
1277 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1279 error_report("Could not delete snapshot '%s': %d (%s)",
1280 snapshot_name
, ret
, strerror(-ret
));
1293 static int img_rebase(int argc
, char **argv
)
1295 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1296 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1298 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1303 /* Parse commandline parameters */
1305 cache
= BDRV_DEFAULT_CACHE
;
1309 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1322 out_basefmt
= optarg
;
1325 out_baseimg
= optarg
;
1339 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1342 filename
= argv
[optind
++];
1344 qemu_progress_init(progress
, 2.0);
1345 qemu_progress_print(0, 100);
1347 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1348 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1350 error_report("Invalid cache option: %s", cache
);
1357 * Ignore the old backing file for unsafe rebase in case we want to correct
1358 * the reference to a renamed or moved backing file.
1360 bs
= bdrv_new_open(filename
, fmt
, flags
);
1365 /* Find the right drivers for the backing files */
1366 old_backing_drv
= NULL
;
1367 new_backing_drv
= NULL
;
1369 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1370 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1371 if (old_backing_drv
== NULL
) {
1372 error_report("Invalid format name: '%s'", bs
->backing_format
);
1378 if (out_basefmt
!= NULL
) {
1379 new_backing_drv
= bdrv_find_format(out_basefmt
);
1380 if (new_backing_drv
== NULL
) {
1381 error_report("Invalid format name: '%s'", out_basefmt
);
1387 /* For safe rebasing we need to compare old and new backing file */
1389 /* Make the compiler happy */
1390 bs_old_backing
= NULL
;
1391 bs_new_backing
= NULL
;
1393 char backing_name
[1024];
1395 bs_old_backing
= bdrv_new("old_backing");
1396 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1397 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1400 error_report("Could not open old backing file '%s'", backing_name
);
1404 bs_new_backing
= bdrv_new("new_backing");
1405 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1408 error_report("Could not open new backing file '%s'", out_baseimg
);
1414 * Check each unallocated cluster in the COW file. If it is unallocated,
1415 * accesses go to the backing file. We must therefore compare this cluster
1416 * in the old and new backing file, and if they differ we need to copy it
1417 * from the old backing file into the COW file.
1419 * If qemu-img crashes during this step, no harm is done. The content of
1420 * the image is the same as the original one at any time.
1423 uint64_t num_sectors
;
1424 uint64_t old_backing_num_sectors
;
1425 uint64_t new_backing_num_sectors
;
1430 float local_progress
;
1432 buf_old
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1433 buf_new
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1435 bdrv_get_geometry(bs
, &num_sectors
);
1436 bdrv_get_geometry(bs_old_backing
, &old_backing_num_sectors
);
1437 bdrv_get_geometry(bs_new_backing
, &new_backing_num_sectors
);
1439 local_progress
= (float)100 /
1440 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1441 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1443 /* How many sectors can we handle with the next read? */
1444 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1445 n
= (IO_BUF_SIZE
/ 512);
1447 n
= num_sectors
- sector
;
1450 /* If the cluster is allocated, we don't need to take action */
1451 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1457 * Read old and new backing file and take into consideration that
1458 * backing files may be smaller than the COW image.
1460 if (sector
>= old_backing_num_sectors
) {
1461 memset(buf_old
, 0, n
* BDRV_SECTOR_SIZE
);
1463 if (sector
+ n
> old_backing_num_sectors
) {
1464 n
= old_backing_num_sectors
- sector
;
1467 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1469 error_report("error while reading from old backing file");
1474 if (sector
>= new_backing_num_sectors
) {
1475 memset(buf_new
, 0, n
* BDRV_SECTOR_SIZE
);
1477 if (sector
+ n
> new_backing_num_sectors
) {
1478 n
= new_backing_num_sectors
- sector
;
1481 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1483 error_report("error while reading from new backing file");
1488 /* If they differ, we need to write to the COW file */
1489 uint64_t written
= 0;
1491 while (written
< n
) {
1494 if (compare_sectors(buf_old
+ written
* 512,
1495 buf_new
+ written
* 512, n
- written
, &pnum
))
1497 ret
= bdrv_write(bs
, sector
+ written
,
1498 buf_old
+ written
* 512, pnum
);
1500 error_report("Error while writing to COW image: %s",
1508 qemu_progress_print(local_progress
, 100);
1511 qemu_vfree(buf_old
);
1512 qemu_vfree(buf_new
);
1516 * Change the backing file. All clusters that are different from the old
1517 * backing file are overwritten in the COW file now, so the visible content
1518 * doesn't change when we switch the backing file.
1520 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1521 if (ret
== -ENOSPC
) {
1522 error_report("Could not change the backing file to '%s': No "
1523 "space left in the file header", out_baseimg
);
1524 } else if (ret
< 0) {
1525 error_report("Could not change the backing file to '%s': %s",
1526 out_baseimg
, strerror(-ret
));
1529 qemu_progress_print(100, 0);
1531 * TODO At this point it is possible to check if any clusters that are
1532 * allocated in the COW file are the same in the backing file. If so, they
1533 * could be dropped from the COW file. Don't do this before switching the
1534 * backing file, in case of a crash this would lead to corruption.
1537 qemu_progress_end();
1540 if (bs_old_backing
!= NULL
) {
1541 bdrv_delete(bs_old_backing
);
1543 if (bs_new_backing
!= NULL
) {
1544 bdrv_delete(bs_new_backing
);
1555 static int img_resize(int argc
, char **argv
)
1557 int c
, ret
, relative
;
1558 const char *filename
, *fmt
, *size
;
1559 int64_t n
, total_size
;
1560 BlockDriverState
*bs
= NULL
;
1561 QEMUOptionParameter
*param
;
1562 QEMUOptionParameter resize_options
[] = {
1564 .name
= BLOCK_OPT_SIZE
,
1566 .help
= "Virtual disk size"
1571 /* Remove size from argv manually so that negative numbers are not treated
1572 * as options by getopt. */
1578 size
= argv
[--argc
];
1580 /* Parse getopt arguments */
1583 c
= getopt(argc
, argv
, "f:h");
1597 if (optind
>= argc
) {
1600 filename
= argv
[optind
++];
1602 /* Choose grow, shrink, or absolute resize mode */
1618 param
= parse_option_parameters("", resize_options
, NULL
);
1619 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1620 /* Error message already printed when size parsing fails */
1624 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1625 free_option_parameters(param
);
1627 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1634 total_size
= bdrv_getlength(bs
) + n
* relative
;
1638 if (total_size
<= 0) {
1639 error_report("New image size must be positive");
1644 ret
= bdrv_truncate(bs
, total_size
);
1647 printf("Image resized.\n");
1650 error_report("This image does not support resize");
1653 error_report("Image is read-only");
1656 error_report("Error resizing image (%d)", -ret
);
1669 static const img_cmd_t img_cmds
[] = {
1670 #define DEF(option, callback, arg_string) \
1671 { option, callback },
1672 #include "qemu-img-cmds.h"
1678 int main(int argc
, char **argv
)
1680 const img_cmd_t
*cmd
;
1681 const char *cmdname
;
1683 error_set_progname(argv
[0]);
1691 qemu_init_main_loop();
1693 /* find the command */
1694 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1695 if (!strcmp(cmdname
, cmd
->name
)) {
1696 return cmd
->handler(argc
, argv
);