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), 'writethrough', 'directsync'\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"
86 "Parameters to snapshot subcommand:\n"
87 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
88 " '-a' applies a snapshot (revert disk to saved state)\n"
89 " '-c' creates a snapshot\n"
90 " '-d' deletes a snapshot\n"
91 " '-l' lists all snapshots in the given image\n";
93 printf("%s\nSupported formats:", help_msg
);
94 bdrv_iterate_format(format_print
, NULL
);
100 /* XXX: put correct support for win32 */
101 static int read_password(char *buf
, int buf_size
)
104 printf("Password: ");
111 if (i
< (buf_size
- 1))
122 static struct termios oldtty
;
124 static void term_exit(void)
126 tcsetattr (0, TCSANOW
, &oldtty
);
129 static void term_init(void)
136 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
137 |INLCR
|IGNCR
|ICRNL
|IXON
);
138 tty
.c_oflag
|= OPOST
;
139 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
140 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
145 tcsetattr (0, TCSANOW
, &tty
);
150 static int read_password(char *buf
, int buf_size
)
155 printf("password: ");
160 ret
= read(0, &ch
, 1);
162 if (errno
== EAGAIN
|| errno
== EINTR
) {
168 } else if (ret
== 0) {
176 if (i
< (buf_size
- 1))
187 static int print_block_option_help(const char *filename
, const char *fmt
)
189 BlockDriver
*drv
, *proto_drv
;
190 QEMUOptionParameter
*create_options
= NULL
;
192 /* Find driver and parse its options */
193 drv
= bdrv_find_format(fmt
);
195 error_report("Unknown file format '%s'", fmt
);
199 proto_drv
= bdrv_find_protocol(filename
);
201 error_report("Unknown protocol '%s'", filename
);
205 create_options
= append_option_parameters(create_options
,
206 drv
->create_options
);
207 create_options
= append_option_parameters(create_options
,
208 proto_drv
->create_options
);
209 print_option_help(create_options
);
210 free_option_parameters(create_options
);
214 static BlockDriverState
*bdrv_new_open(const char *filename
,
218 BlockDriverState
*bs
;
223 bs
= bdrv_new("image");
226 drv
= bdrv_find_format(fmt
);
228 error_report("Unknown file format '%s'", fmt
);
235 ret
= bdrv_open(bs
, filename
, flags
, drv
);
237 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
241 if (bdrv_is_encrypted(bs
)) {
242 printf("Disk image '%s' is encrypted.\n", filename
);
243 if (read_password(password
, sizeof(password
)) < 0) {
244 error_report("No password given");
247 if (bdrv_set_key(bs
, password
) < 0) {
248 error_report("invalid password");
260 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
261 const char *base_filename
,
262 const char *base_fmt
)
265 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
266 error_report("Backing file not supported for file format '%s'",
272 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
273 error_report("Backing file format not supported for file "
281 static int img_create(int argc
, char **argv
)
284 uint64_t img_size
= -1;
285 const char *fmt
= "raw";
286 const char *base_fmt
= NULL
;
287 const char *filename
;
288 const char *base_filename
= NULL
;
289 char *options
= NULL
;
292 c
= getopt(argc
, argv
, "F:b:f:he6o:");
305 base_filename
= optarg
;
311 error_report("option -e is deprecated, please use \'-o "
312 "encryption\' instead!");
315 error_report("option -6 is deprecated, please use \'-o "
316 "compat6\' instead!");
324 /* Get the filename */
325 if (optind
>= argc
) {
328 filename
= argv
[optind
++];
330 /* Get image size, if specified */
333 sval
= strtosz_suffix(argv
[optind
++], NULL
, STRTOSZ_DEFSUFFIX_B
);
335 error_report("Invalid image size specified! You may use k, M, G or "
337 error_report("kilobytes, megabytes, gigabytes and terabytes.");
341 img_size
= (uint64_t)sval
;
344 if (options
&& !strcmp(options
, "?")) {
345 ret
= print_block_option_help(filename
, fmt
);
349 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
350 options
, img_size
, BDRV_O_FLAGS
);
359 * Checks an image for consistency. Exit codes:
361 * 0 - Check completed, image is good
362 * 1 - Check not completed because of internal errors
363 * 2 - Check completed, image is corrupted
364 * 3 - Check completed, image has leaked clusters, but is good otherwise
366 static int img_check(int argc
, char **argv
)
369 const char *filename
, *fmt
;
370 BlockDriverState
*bs
;
371 BdrvCheckResult result
;
375 c
= getopt(argc
, argv
, "f:h");
389 if (optind
>= argc
) {
392 filename
= argv
[optind
++];
394 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
398 ret
= bdrv_check(bs
, &result
);
400 if (ret
== -ENOTSUP
) {
401 error_report("This image format does not support checks");
406 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
407 printf("No errors were found on the image.\n");
409 if (result
.corruptions
) {
410 printf("\n%d errors were found on the image.\n"
411 "Data may be corrupted, or further writes to the image "
417 printf("\n%d leaked clusters were found on the image.\n"
418 "This means waste of disk space, but no harm to data.\n",
422 if (result
.check_errors
) {
423 printf("\n%d internal errors have occurred during the check.\n",
424 result
.check_errors
);
430 if (ret
< 0 || result
.check_errors
) {
431 printf("\nAn error has occurred during the check: %s\n"
432 "The check is not complete and may have missed error.\n",
437 if (result
.corruptions
) {
439 } else if (result
.leaks
) {
446 static int img_commit(int argc
, char **argv
)
449 const char *filename
, *fmt
, *cache
;
450 BlockDriverState
*bs
;
453 cache
= BDRV_DEFAULT_CACHE
;
455 c
= getopt(argc
, argv
, "f:ht:");
472 if (optind
>= argc
) {
475 filename
= argv
[optind
++];
478 ret
= bdrv_parse_cache_flags(cache
, &flags
);
480 error_report("Invalid cache option: %s", cache
);
484 bs
= bdrv_new_open(filename
, fmt
, flags
);
488 ret
= bdrv_commit(bs
);
491 printf("Image committed.\n");
494 error_report("No disk inserted");
497 error_report("Image is read-only");
500 error_report("Image is already committed");
503 error_report("Error while committing image");
515 * Checks whether the sector is not a zero sector.
517 * Attention! The len must be a multiple of 4 * sizeof(long) due to
518 * restriction of optimizations in this function.
520 static int is_not_zero(const uint8_t *sector
, int len
)
523 * Use long as the biggest available internal data type that fits into the
524 * CPU register and unroll the loop to smooth out the effect of memory
530 const long * const data
= (const long *) sector
;
534 for(i
= 0; i
< len
; i
+= 4) {
540 if (d0
|| d1
|| d2
|| d3
) {
549 * Returns true iff the first sector pointed to by 'buf' contains at least
552 * 'pnum' is set to the number of sectors (including and immediately following
553 * the first one) that are known to be in the same allocated/unallocated state.
555 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
563 v
= is_not_zero(buf
, 512);
564 for(i
= 1; i
< n
; i
++) {
566 if (v
!= is_not_zero(buf
, 512))
574 * Compares two buffers sector by sector. Returns 0 if the first sector of both
575 * buffers matches, non-zero otherwise.
577 * pnum is set to the number of sectors (including and immediately following
578 * the first one) that are known to have the same comparison result
580 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
590 res
= !!memcmp(buf1
, buf2
, 512);
591 for(i
= 1; i
< n
; i
++) {
595 if (!!memcmp(buf1
, buf2
, 512) != res
) {
604 #define IO_BUF_SIZE (2 * 1024 * 1024)
606 static int img_convert(int argc
, char **argv
)
608 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
609 int progress
= 0, flags
;
610 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
611 BlockDriver
*drv
, *proto_drv
;
612 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
613 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
615 uint8_t * buf
= NULL
;
618 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
619 QEMUOptionParameter
*out_baseimg_param
;
620 char *options
= NULL
;
621 const char *snapshot_name
= NULL
;
622 float local_progress
;
630 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pt:");
646 out_baseimg
= optarg
;
652 error_report("option -e is deprecated, please use \'-o "
653 "encryption\' instead!");
656 error_report("option -6 is deprecated, please use \'-o "
657 "compat6\' instead!");
663 snapshot_name
= optarg
;
674 bs_n
= argc
- optind
- 1;
679 out_filename
= argv
[argc
- 1];
681 if (options
&& !strcmp(options
, "?")) {
682 ret
= print_block_option_help(out_filename
, out_fmt
);
686 if (bs_n
> 1 && out_baseimg
) {
687 error_report("-B makes no sense when concatenating multiple input "
693 qemu_progress_init(progress
, 2.0);
694 qemu_progress_print(0, 100);
696 bs
= g_malloc0(bs_n
* sizeof(BlockDriverState
*));
699 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
700 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
702 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
706 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
707 total_sectors
+= bs_sectors
;
710 if (snapshot_name
!= NULL
) {
712 error_report("No support for concatenating multiple snapshot");
716 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
717 error_report("Failed to load snapshot");
723 /* Find driver and parse its options */
724 drv
= bdrv_find_format(out_fmt
);
726 error_report("Unknown file format '%s'", out_fmt
);
731 proto_drv
= bdrv_find_protocol(out_filename
);
733 error_report("Unknown protocol '%s'", out_filename
);
738 create_options
= append_option_parameters(create_options
,
739 drv
->create_options
);
740 create_options
= append_option_parameters(create_options
,
741 proto_drv
->create_options
);
744 param
= parse_option_parameters(options
, create_options
, param
);
746 error_report("Invalid options for file format '%s'.", out_fmt
);
751 param
= parse_option_parameters("", create_options
, param
);
754 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
755 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
760 /* Get backing file name if -o backing_file was used */
761 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
762 if (out_baseimg_param
) {
763 out_baseimg
= out_baseimg_param
->value
.s
;
766 /* Check if compression is supported */
768 QEMUOptionParameter
*encryption
=
769 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
771 if (!drv
->bdrv_write_compressed
) {
772 error_report("Compression not supported for this file format");
777 if (encryption
&& encryption
->value
.n
) {
778 error_report("Compression and encryption not supported at "
785 /* Create the new image */
786 ret
= bdrv_create(drv
, out_filename
, param
);
788 if (ret
== -ENOTSUP
) {
789 error_report("Formatting not supported for file format '%s'",
791 } else if (ret
== -EFBIG
) {
792 error_report("The image size is too large for file format '%s'",
795 error_report("%s: error while converting %s: %s",
796 out_filename
, out_fmt
, strerror(-ret
));
802 ret
= bdrv_parse_cache_flags(cache
, &flags
);
804 error_report("Invalid cache option: %s", cache
);
808 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
);
816 bdrv_get_geometry(bs
[0], &bs_sectors
);
817 buf
= qemu_blockalign(out_bs
, IO_BUF_SIZE
);
820 ret
= bdrv_get_info(out_bs
, &bdi
);
822 error_report("could not get block driver info");
825 cluster_size
= bdi
.cluster_size
;
826 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
827 error_report("invalid cluster size");
831 cluster_sectors
= cluster_size
>> 9;
834 nb_sectors
= total_sectors
;
835 local_progress
= (float)100 /
836 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
843 nb_sectors
= total_sectors
- sector_num
;
846 if (nb_sectors
>= cluster_sectors
)
851 bs_num
= sector_num
- bs_offset
;
852 assert (bs_num
>= 0);
855 while (remainder
> 0) {
857 while (bs_num
== bs_sectors
) {
859 assert (bs_i
< bs_n
);
860 bs_offset
+= bs_sectors
;
861 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
863 /* printf("changing part: sector_num=%" PRId64 ", "
864 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
865 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
867 assert (bs_num
< bs_sectors
);
869 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
871 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
873 error_report("error while reading sector %" PRId64
": %s",
874 bs_num
, strerror(-ret
));
883 assert (remainder
== 0);
885 if (n
< cluster_sectors
) {
886 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
888 if (is_not_zero(buf
, cluster_size
)) {
889 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
892 error_report("error while compressing sector %" PRId64
893 ": %s", sector_num
, strerror(-ret
));
898 qemu_progress_print(local_progress
, 100);
900 /* signal EOF to align */
901 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
903 int has_zero_init
= bdrv_has_zero_init(out_bs
);
905 sector_num
= 0; // total number of sectors converted so far
906 nb_sectors
= total_sectors
- sector_num
;
907 local_progress
= (float)100 /
908 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
911 nb_sectors
= total_sectors
- sector_num
;
912 if (nb_sectors
<= 0) {
915 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
916 n
= (IO_BUF_SIZE
/ 512);
921 while (sector_num
- bs_offset
>= bs_sectors
) {
923 assert (bs_i
< bs_n
);
924 bs_offset
+= bs_sectors
;
925 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
926 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
927 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
928 sector_num, bs_i, bs_offset, bs_sectors); */
931 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
932 n
= bs_offset
+ bs_sectors
- sector_num
;
936 /* If the output image is being created as a copy on write image,
937 assume that sectors which are unallocated in the input image
938 are present in both the output's and input's base images (no
939 need to copy them). */
941 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
946 /* The next 'n1' sectors are allocated in the input image. Copy
947 only those as they may be followed by unallocated sectors. */
954 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
956 error_report("error while reading sector %" PRId64
": %s",
957 sector_num
- bs_offset
, strerror(-ret
));
960 /* NOTE: at the same time we convert, we do not write zero
961 sectors to have a chance to compress the image. Ideally, we
962 should add a specific call to have the info to go faster */
965 /* If the output image is being created as a copy on write image,
966 copy all sectors even the ones containing only NUL bytes,
967 because they may differ from the sectors in the base image.
969 If the output is to a host device, we also write out
970 sectors that are entirely 0, since whatever data was
971 already there is garbage, not 0s. */
972 if (!has_zero_init
|| out_baseimg
||
973 is_allocated_sectors(buf1
, n
, &n1
)) {
974 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
976 error_report("error while writing sector %" PRId64
977 ": %s", sector_num
, strerror(-ret
));
985 qemu_progress_print(local_progress
, 100);
990 free_option_parameters(create_options
);
991 free_option_parameters(param
);
997 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
999 bdrv_delete(bs
[bs_i
]);
1011 static void dump_snapshots(BlockDriverState
*bs
)
1013 QEMUSnapshotInfo
*sn_tab
, *sn
;
1017 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1020 printf("Snapshot list:\n");
1021 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1022 for(i
= 0; i
< nb_sns
; i
++) {
1024 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1029 static int img_info(int argc
, char **argv
)
1032 const char *filename
, *fmt
;
1033 BlockDriverState
*bs
;
1034 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1035 uint64_t total_sectors
;
1036 int64_t allocated_size
;
1037 char backing_filename
[1024];
1038 char backing_filename2
[1024];
1039 BlockDriverInfo bdi
;
1043 c
= getopt(argc
, argv
, "f:h");
1057 if (optind
>= argc
) {
1060 filename
= argv
[optind
++];
1062 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1066 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1067 bdrv_get_geometry(bs
, &total_sectors
);
1068 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1069 allocated_size
= bdrv_get_allocated_file_size(bs
);
1070 if (allocated_size
< 0) {
1071 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1073 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1076 printf("image: %s\n"
1078 "virtual size: %s (%" PRId64
" bytes)\n"
1080 filename
, fmt_name
, size_buf
,
1081 (total_sectors
* 512),
1083 if (bdrv_is_encrypted(bs
)) {
1084 printf("encrypted: yes\n");
1086 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1087 if (bdi
.cluster_size
!= 0) {
1088 printf("cluster_size: %d\n", bdi
.cluster_size
);
1091 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1092 if (backing_filename
[0] != '\0') {
1093 path_combine(backing_filename2
, sizeof(backing_filename2
),
1094 filename
, backing_filename
);
1095 printf("backing file: %s (actual path: %s)\n",
1104 #define SNAPSHOT_LIST 1
1105 #define SNAPSHOT_CREATE 2
1106 #define SNAPSHOT_APPLY 3
1107 #define SNAPSHOT_DELETE 4
1109 static int img_snapshot(int argc
, char **argv
)
1111 BlockDriverState
*bs
;
1112 QEMUSnapshotInfo sn
;
1113 char *filename
, *snapshot_name
= NULL
;
1114 int c
, ret
= 0, bdrv_oflags
;
1118 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1119 /* Parse commandline parameters */
1121 c
= getopt(argc
, argv
, "la:c:d:h");
1135 action
= SNAPSHOT_LIST
;
1136 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1143 action
= SNAPSHOT_APPLY
;
1144 snapshot_name
= optarg
;
1151 action
= SNAPSHOT_CREATE
;
1152 snapshot_name
= optarg
;
1159 action
= SNAPSHOT_DELETE
;
1160 snapshot_name
= optarg
;
1165 if (optind
>= argc
) {
1168 filename
= argv
[optind
++];
1170 /* Open the image */
1171 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1176 /* Perform the requested action */
1182 case SNAPSHOT_CREATE
:
1183 memset(&sn
, 0, sizeof(sn
));
1184 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1186 qemu_gettimeofday(&tv
);
1187 sn
.date_sec
= tv
.tv_sec
;
1188 sn
.date_nsec
= tv
.tv_usec
* 1000;
1190 ret
= bdrv_snapshot_create(bs
, &sn
);
1192 error_report("Could not create snapshot '%s': %d (%s)",
1193 snapshot_name
, ret
, strerror(-ret
));
1197 case SNAPSHOT_APPLY
:
1198 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1200 error_report("Could not apply snapshot '%s': %d (%s)",
1201 snapshot_name
, ret
, strerror(-ret
));
1205 case SNAPSHOT_DELETE
:
1206 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1208 error_report("Could not delete snapshot '%s': %d (%s)",
1209 snapshot_name
, ret
, strerror(-ret
));
1222 static int img_rebase(int argc
, char **argv
)
1224 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1225 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1227 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1232 /* Parse commandline parameters */
1234 cache
= BDRV_DEFAULT_CACHE
;
1238 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1251 out_basefmt
= optarg
;
1254 out_baseimg
= optarg
;
1268 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1271 filename
= argv
[optind
++];
1273 qemu_progress_init(progress
, 2.0);
1274 qemu_progress_print(0, 100);
1276 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1277 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1279 error_report("Invalid cache option: %s", cache
);
1286 * Ignore the old backing file for unsafe rebase in case we want to correct
1287 * the reference to a renamed or moved backing file.
1289 bs
= bdrv_new_open(filename
, fmt
, flags
);
1294 /* Find the right drivers for the backing files */
1295 old_backing_drv
= NULL
;
1296 new_backing_drv
= NULL
;
1298 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1299 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1300 if (old_backing_drv
== NULL
) {
1301 error_report("Invalid format name: '%s'", bs
->backing_format
);
1307 if (out_basefmt
!= NULL
) {
1308 new_backing_drv
= bdrv_find_format(out_basefmt
);
1309 if (new_backing_drv
== NULL
) {
1310 error_report("Invalid format name: '%s'", out_basefmt
);
1316 /* For safe rebasing we need to compare old and new backing file */
1318 /* Make the compiler happy */
1319 bs_old_backing
= NULL
;
1320 bs_new_backing
= NULL
;
1322 char backing_name
[1024];
1324 bs_old_backing
= bdrv_new("old_backing");
1325 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1326 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1329 error_report("Could not open old backing file '%s'", backing_name
);
1333 bs_new_backing
= bdrv_new("new_backing");
1334 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1337 error_report("Could not open new backing file '%s'", out_baseimg
);
1343 * Check each unallocated cluster in the COW file. If it is unallocated,
1344 * accesses go to the backing file. We must therefore compare this cluster
1345 * in the old and new backing file, and if they differ we need to copy it
1346 * from the old backing file into the COW file.
1348 * If qemu-img crashes during this step, no harm is done. The content of
1349 * the image is the same as the original one at any time.
1352 uint64_t num_sectors
;
1357 float local_progress
;
1359 buf_old
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1360 buf_new
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1362 bdrv_get_geometry(bs
, &num_sectors
);
1364 local_progress
= (float)100 /
1365 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1366 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1368 /* How many sectors can we handle with the next read? */
1369 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1370 n
= (IO_BUF_SIZE
/ 512);
1372 n
= num_sectors
- sector
;
1375 /* If the cluster is allocated, we don't need to take action */
1376 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1381 /* Read old and new backing file */
1382 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1384 error_report("error while reading from old backing file");
1387 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1389 error_report("error while reading from new backing file");
1393 /* If they differ, we need to write to the COW file */
1394 uint64_t written
= 0;
1396 while (written
< n
) {
1399 if (compare_sectors(buf_old
+ written
* 512,
1400 buf_new
+ written
* 512, n
- written
, &pnum
))
1402 ret
= bdrv_write(bs
, sector
+ written
,
1403 buf_old
+ written
* 512, pnum
);
1405 error_report("Error while writing to COW image: %s",
1413 qemu_progress_print(local_progress
, 100);
1416 qemu_vfree(buf_old
);
1417 qemu_vfree(buf_new
);
1421 * Change the backing file. All clusters that are different from the old
1422 * backing file are overwritten in the COW file now, so the visible content
1423 * doesn't change when we switch the backing file.
1425 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1426 if (ret
== -ENOSPC
) {
1427 error_report("Could not change the backing file to '%s': No "
1428 "space left in the file header", out_baseimg
);
1429 } else if (ret
< 0) {
1430 error_report("Could not change the backing file to '%s': %s",
1431 out_baseimg
, strerror(-ret
));
1434 qemu_progress_print(100, 0);
1436 * TODO At this point it is possible to check if any clusters that are
1437 * allocated in the COW file are the same in the backing file. If so, they
1438 * could be dropped from the COW file. Don't do this before switching the
1439 * backing file, in case of a crash this would lead to corruption.
1442 qemu_progress_end();
1445 if (bs_old_backing
!= NULL
) {
1446 bdrv_delete(bs_old_backing
);
1448 if (bs_new_backing
!= NULL
) {
1449 bdrv_delete(bs_new_backing
);
1460 static int img_resize(int argc
, char **argv
)
1462 int c
, ret
, relative
;
1463 const char *filename
, *fmt
, *size
;
1464 int64_t n
, total_size
;
1465 BlockDriverState
*bs
= NULL
;
1466 QEMUOptionParameter
*param
;
1467 QEMUOptionParameter resize_options
[] = {
1469 .name
= BLOCK_OPT_SIZE
,
1471 .help
= "Virtual disk size"
1476 /* Remove size from argv manually so that negative numbers are not treated
1477 * as options by getopt. */
1483 size
= argv
[--argc
];
1485 /* Parse getopt arguments */
1488 c
= getopt(argc
, argv
, "f:h");
1502 if (optind
>= argc
) {
1505 filename
= argv
[optind
++];
1507 /* Choose grow, shrink, or absolute resize mode */
1523 param
= parse_option_parameters("", resize_options
, NULL
);
1524 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1525 /* Error message already printed when size parsing fails */
1529 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1530 free_option_parameters(param
);
1532 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1539 total_size
= bdrv_getlength(bs
) + n
* relative
;
1543 if (total_size
<= 0) {
1544 error_report("New image size must be positive");
1549 ret
= bdrv_truncate(bs
, total_size
);
1552 printf("Image resized.\n");
1555 error_report("This image format does not support resize");
1558 error_report("Image is read-only");
1561 error_report("Error resizing image (%d)", -ret
);
1574 static const img_cmd_t img_cmds
[] = {
1575 #define DEF(option, callback, arg_string) \
1576 { option, callback },
1577 #include "qemu-img-cmds.h"
1583 int main(int argc
, char **argv
)
1585 const img_cmd_t
*cmd
;
1586 const char *cmdname
;
1588 error_set_progname(argv
[0]);
1596 /* find the command */
1597 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1598 if (!strcmp(cmdname
, cmd
->name
)) {
1599 return cmd
->handler(argc
, argv
);