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' and 'unsafe'\n"
70 " 'size' is the disk image size in bytes. Optional suffixes\n"
71 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
72 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
73 " 'output_filename' is the destination disk image filename\n"
74 " 'output_fmt' is the destination format\n"
75 " 'options' is a comma separated list of format specific options in a\n"
76 " name=value format. Use -o ? for an overview of the options supported by the\n"
78 " '-c' indicates that target image must be compressed (qcow format only)\n"
79 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
80 " match exactly. The image doesn't need a working backing file before\n"
81 " rebasing in this case (useful for renaming the backing file)\n"
82 " '-h' with or without a command shows this help and lists the supported formats\n"
83 " '-p' show progress of command (only certain commands)\n"
85 "Parameters to snapshot subcommand:\n"
86 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
87 " '-a' applies a snapshot (revert disk to saved state)\n"
88 " '-c' creates a snapshot\n"
89 " '-d' deletes a snapshot\n"
90 " '-l' lists all snapshots in the given image\n";
92 printf("%s\nSupported formats:", help_msg
);
93 bdrv_iterate_format(format_print
, NULL
);
99 /* XXX: put correct support for win32 */
100 static int read_password(char *buf
, int buf_size
)
103 printf("Password: ");
110 if (i
< (buf_size
- 1))
121 static struct termios oldtty
;
123 static void term_exit(void)
125 tcsetattr (0, TCSANOW
, &oldtty
);
128 static void term_init(void)
135 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
136 |INLCR
|IGNCR
|ICRNL
|IXON
);
137 tty
.c_oflag
|= OPOST
;
138 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
139 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
144 tcsetattr (0, TCSANOW
, &tty
);
149 static int read_password(char *buf
, int buf_size
)
154 printf("password: ");
159 ret
= read(0, &ch
, 1);
161 if (errno
== EAGAIN
|| errno
== EINTR
) {
167 } else if (ret
== 0) {
175 if (i
< (buf_size
- 1))
186 static int set_cache_flag(const char *mode
, int *flags
)
188 *flags
&= ~BDRV_O_CACHE_MASK
;
190 if (!strcmp(mode
, "none") || !strcmp(mode
, "off")) {
191 *flags
|= BDRV_O_CACHE_WB
;
192 *flags
|= BDRV_O_NOCACHE
;
193 } else if (!strcmp(mode
, "writeback")) {
194 *flags
|= BDRV_O_CACHE_WB
;
195 } else if (!strcmp(mode
, "unsafe")) {
196 *flags
|= BDRV_O_CACHE_WB
;
197 *flags
|= BDRV_O_NO_FLUSH
;
198 } else if (!strcmp(mode
, "writethrough")) {
199 /* this is the default */
207 static int print_block_option_help(const char *filename
, const char *fmt
)
209 BlockDriver
*drv
, *proto_drv
;
210 QEMUOptionParameter
*create_options
= NULL
;
212 /* Find driver and parse its options */
213 drv
= bdrv_find_format(fmt
);
215 error_report("Unknown file format '%s'", fmt
);
219 proto_drv
= bdrv_find_protocol(filename
);
221 error_report("Unknown protocol '%s'", filename
);
225 create_options
= append_option_parameters(create_options
,
226 drv
->create_options
);
227 create_options
= append_option_parameters(create_options
,
228 proto_drv
->create_options
);
229 print_option_help(create_options
);
230 free_option_parameters(create_options
);
234 static BlockDriverState
*bdrv_new_open(const char *filename
,
238 BlockDriverState
*bs
;
243 bs
= bdrv_new("image");
246 drv
= bdrv_find_format(fmt
);
248 error_report("Unknown file format '%s'", fmt
);
255 ret
= bdrv_open(bs
, filename
, flags
, drv
);
257 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
261 if (bdrv_is_encrypted(bs
)) {
262 printf("Disk image '%s' is encrypted.\n", filename
);
263 if (read_password(password
, sizeof(password
)) < 0) {
264 error_report("No password given");
267 if (bdrv_set_key(bs
, password
) < 0) {
268 error_report("invalid password");
280 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
281 const char *base_filename
,
282 const char *base_fmt
)
285 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
286 error_report("Backing file not supported for file format '%s'",
292 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
293 error_report("Backing file format not supported for file "
301 static int img_create(int argc
, char **argv
)
304 uint64_t img_size
= -1;
305 const char *fmt
= "raw";
306 const char *base_fmt
= NULL
;
307 const char *filename
;
308 const char *base_filename
= NULL
;
309 char *options
= NULL
;
312 c
= getopt(argc
, argv
, "F:b:f:he6o:");
325 base_filename
= optarg
;
331 error_report("option -e is deprecated, please use \'-o "
332 "encryption\' instead!");
335 error_report("option -6 is deprecated, please use \'-o "
336 "compat6\' instead!");
344 /* Get the filename */
345 if (optind
>= argc
) {
348 filename
= argv
[optind
++];
350 /* Get image size, if specified */
353 sval
= strtosz_suffix(argv
[optind
++], NULL
, STRTOSZ_DEFSUFFIX_B
);
355 error_report("Invalid image size specified! You may use k, M, G or "
357 error_report("kilobytes, megabytes, gigabytes and terabytes.");
361 img_size
= (uint64_t)sval
;
364 if (options
&& !strcmp(options
, "?")) {
365 ret
= print_block_option_help(filename
, fmt
);
369 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
370 options
, img_size
, BDRV_O_FLAGS
);
379 * Checks an image for consistency. Exit codes:
381 * 0 - Check completed, image is good
382 * 1 - Check not completed because of internal errors
383 * 2 - Check completed, image is corrupted
384 * 3 - Check completed, image has leaked clusters, but is good otherwise
386 static int img_check(int argc
, char **argv
)
389 const char *filename
, *fmt
;
390 BlockDriverState
*bs
;
391 BdrvCheckResult result
;
395 c
= getopt(argc
, argv
, "f:h");
409 if (optind
>= argc
) {
412 filename
= argv
[optind
++];
414 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
418 ret
= bdrv_check(bs
, &result
);
420 if (ret
== -ENOTSUP
) {
421 error_report("This image format does not support checks");
426 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
427 printf("No errors were found on the image.\n");
429 if (result
.corruptions
) {
430 printf("\n%d errors were found on the image.\n"
431 "Data may be corrupted, or further writes to the image "
437 printf("\n%d leaked clusters were found on the image.\n"
438 "This means waste of disk space, but no harm to data.\n",
442 if (result
.check_errors
) {
443 printf("\n%d internal errors have occurred during the check.\n",
444 result
.check_errors
);
450 if (ret
< 0 || result
.check_errors
) {
451 printf("\nAn error has occurred during the check: %s\n"
452 "The check is not complete and may have missed error.\n",
457 if (result
.corruptions
) {
459 } else if (result
.leaks
) {
466 static int img_commit(int argc
, char **argv
)
469 const char *filename
, *fmt
, *cache
;
470 BlockDriverState
*bs
;
473 cache
= BDRV_DEFAULT_CACHE
;
475 c
= getopt(argc
, argv
, "f:ht:");
492 if (optind
>= argc
) {
495 filename
= argv
[optind
++];
498 ret
= set_cache_flag(cache
, &flags
);
500 error_report("Invalid cache option: %s", cache
);
504 bs
= bdrv_new_open(filename
, fmt
, flags
);
508 ret
= bdrv_commit(bs
);
511 printf("Image committed.\n");
514 error_report("No disk inserted");
517 error_report("Image is read-only");
520 error_report("Image is already committed");
523 error_report("Error while committing image");
535 * Checks whether the sector is not a zero sector.
537 * Attention! The len must be a multiple of 4 * sizeof(long) due to
538 * restriction of optimizations in this function.
540 static int is_not_zero(const uint8_t *sector
, int len
)
543 * Use long as the biggest available internal data type that fits into the
544 * CPU register and unroll the loop to smooth out the effect of memory
550 const long * const data
= (const long *) sector
;
554 for(i
= 0; i
< len
; i
+= 4) {
560 if (d0
|| d1
|| d2
|| d3
) {
569 * Returns true iff the first sector pointed to by 'buf' contains at least
572 * 'pnum' is set to the number of sectors (including and immediately following
573 * the first one) that are known to be in the same allocated/unallocated state.
575 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
583 v
= is_not_zero(buf
, 512);
584 for(i
= 1; i
< n
; i
++) {
586 if (v
!= is_not_zero(buf
, 512))
594 * Compares two buffers sector by sector. Returns 0 if the first sector of both
595 * buffers matches, non-zero otherwise.
597 * pnum is set to the number of sectors (including and immediately following
598 * the first one) that are known to have the same comparison result
600 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
610 res
= !!memcmp(buf1
, buf2
, 512);
611 for(i
= 1; i
< n
; i
++) {
615 if (!!memcmp(buf1
, buf2
, 512) != res
) {
624 #define IO_BUF_SIZE (2 * 1024 * 1024)
626 static int img_convert(int argc
, char **argv
)
628 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
629 int progress
= 0, flags
;
630 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
631 BlockDriver
*drv
, *proto_drv
;
632 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
633 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
635 uint8_t * buf
= NULL
;
638 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
639 QEMUOptionParameter
*out_baseimg_param
;
640 char *options
= NULL
;
641 const char *snapshot_name
= NULL
;
642 float local_progress
;
650 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pt:");
666 out_baseimg
= optarg
;
672 error_report("option -e is deprecated, please use \'-o "
673 "encryption\' instead!");
676 error_report("option -6 is deprecated, please use \'-o "
677 "compat6\' instead!");
683 snapshot_name
= optarg
;
694 bs_n
= argc
- optind
- 1;
699 out_filename
= argv
[argc
- 1];
701 if (options
&& !strcmp(options
, "?")) {
702 ret
= print_block_option_help(out_filename
, out_fmt
);
706 if (bs_n
> 1 && out_baseimg
) {
707 error_report("-B makes no sense when concatenating multiple input "
713 qemu_progress_init(progress
, 2.0);
714 qemu_progress_print(0, 100);
716 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
719 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
720 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
722 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
726 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
727 total_sectors
+= bs_sectors
;
730 if (snapshot_name
!= NULL
) {
732 error_report("No support for concatenating multiple snapshot");
736 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
737 error_report("Failed to load snapshot");
743 /* Find driver and parse its options */
744 drv
= bdrv_find_format(out_fmt
);
746 error_report("Unknown file format '%s'", out_fmt
);
751 proto_drv
= bdrv_find_protocol(out_filename
);
753 error_report("Unknown protocol '%s'", out_filename
);
758 create_options
= append_option_parameters(create_options
,
759 drv
->create_options
);
760 create_options
= append_option_parameters(create_options
,
761 proto_drv
->create_options
);
764 param
= parse_option_parameters(options
, create_options
, param
);
766 error_report("Invalid options for file format '%s'.", out_fmt
);
771 param
= parse_option_parameters("", create_options
, param
);
774 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
775 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
780 /* Get backing file name if -o backing_file was used */
781 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
782 if (out_baseimg_param
) {
783 out_baseimg
= out_baseimg_param
->value
.s
;
786 /* Check if compression is supported */
788 QEMUOptionParameter
*encryption
=
789 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
791 if (!drv
->bdrv_write_compressed
) {
792 error_report("Compression not supported for this file format");
797 if (encryption
&& encryption
->value
.n
) {
798 error_report("Compression and encryption not supported at "
805 /* Create the new image */
806 ret
= bdrv_create(drv
, out_filename
, param
);
808 if (ret
== -ENOTSUP
) {
809 error_report("Formatting not supported for file format '%s'",
811 } else if (ret
== -EFBIG
) {
812 error_report("The image size is too large for file format '%s'",
815 error_report("%s: error while converting %s: %s",
816 out_filename
, out_fmt
, strerror(-ret
));
822 ret
= set_cache_flag(cache
, &flags
);
824 error_report("Invalid cache option: %s", cache
);
828 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
);
836 bdrv_get_geometry(bs
[0], &bs_sectors
);
837 buf
= qemu_malloc(IO_BUF_SIZE
);
840 ret
= bdrv_get_info(out_bs
, &bdi
);
842 error_report("could not get block driver info");
845 cluster_size
= bdi
.cluster_size
;
846 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
847 error_report("invalid cluster size");
851 cluster_sectors
= cluster_size
>> 9;
854 nb_sectors
= total_sectors
;
855 local_progress
= (float)100 /
856 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
863 nb_sectors
= total_sectors
- sector_num
;
866 if (nb_sectors
>= cluster_sectors
)
871 bs_num
= sector_num
- bs_offset
;
872 assert (bs_num
>= 0);
875 while (remainder
> 0) {
877 while (bs_num
== bs_sectors
) {
879 assert (bs_i
< bs_n
);
880 bs_offset
+= bs_sectors
;
881 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
883 /* printf("changing part: sector_num=%" PRId64 ", "
884 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
885 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
887 assert (bs_num
< bs_sectors
);
889 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
891 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
893 error_report("error while reading");
902 assert (remainder
== 0);
904 if (n
< cluster_sectors
) {
905 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
907 if (is_not_zero(buf
, cluster_size
)) {
908 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
911 error_report("error while compressing sector %" PRId64
,
917 qemu_progress_print(local_progress
, 100);
919 /* signal EOF to align */
920 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
922 int has_zero_init
= bdrv_has_zero_init(out_bs
);
924 sector_num
= 0; // total number of sectors converted so far
925 nb_sectors
= total_sectors
- sector_num
;
926 local_progress
= (float)100 /
927 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
930 nb_sectors
= total_sectors
- sector_num
;
931 if (nb_sectors
<= 0) {
934 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
935 n
= (IO_BUF_SIZE
/ 512);
940 while (sector_num
- bs_offset
>= bs_sectors
) {
942 assert (bs_i
< bs_n
);
943 bs_offset
+= bs_sectors
;
944 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
945 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
946 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
947 sector_num, bs_i, bs_offset, bs_sectors); */
950 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
951 n
= bs_offset
+ bs_sectors
- sector_num
;
955 /* If the output image is being created as a copy on write image,
956 assume that sectors which are unallocated in the input image
957 are present in both the output's and input's base images (no
958 need to copy them). */
960 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
965 /* The next 'n1' sectors are allocated in the input image. Copy
966 only those as they may be followed by unallocated sectors. */
973 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
975 error_report("error while reading");
978 /* NOTE: at the same time we convert, we do not write zero
979 sectors to have a chance to compress the image. Ideally, we
980 should add a specific call to have the info to go faster */
983 /* If the output image is being created as a copy on write image,
984 copy all sectors even the ones containing only NUL bytes,
985 because they may differ from the sectors in the base image.
987 If the output is to a host device, we also write out
988 sectors that are entirely 0, since whatever data was
989 already there is garbage, not 0s. */
990 if (!has_zero_init
|| out_baseimg
||
991 is_allocated_sectors(buf1
, n
, &n1
)) {
992 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
994 error_report("error while writing");
1002 qemu_progress_print(local_progress
, 100);
1006 qemu_progress_end();
1007 free_option_parameters(create_options
);
1008 free_option_parameters(param
);
1011 bdrv_delete(out_bs
);
1014 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1016 bdrv_delete(bs
[bs_i
]);
1028 static void dump_snapshots(BlockDriverState
*bs
)
1030 QEMUSnapshotInfo
*sn_tab
, *sn
;
1034 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1037 printf("Snapshot list:\n");
1038 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1039 for(i
= 0; i
< nb_sns
; i
++) {
1041 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1046 static int img_info(int argc
, char **argv
)
1049 const char *filename
, *fmt
;
1050 BlockDriverState
*bs
;
1051 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1052 uint64_t total_sectors
;
1053 int64_t allocated_size
;
1054 char backing_filename
[1024];
1055 char backing_filename2
[1024];
1056 char image_filename
[1024];
1057 char image_filename2
[1024];
1058 BlockDriverInfo bdi
;
1062 c
= getopt(argc
, argv
, "f:h");
1076 if (optind
>= argc
) {
1079 filename
= argv
[optind
++];
1081 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1085 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1086 bdrv_get_geometry(bs
, &total_sectors
);
1087 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1088 allocated_size
= bdrv_get_allocated_file_size(bs
);
1089 if (allocated_size
< 0) {
1090 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1092 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1095 printf("image: %s\n"
1097 "virtual size: %s (%" PRId64
" bytes)\n"
1099 filename
, fmt_name
, size_buf
,
1100 (total_sectors
* 512),
1102 if (bdrv_is_encrypted(bs
)) {
1103 printf("encrypted: yes\n");
1105 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1106 if (bdi
.cluster_size
!= 0) {
1107 printf("cluster_size: %d\n", bdi
.cluster_size
);
1111 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1112 if (backing_filename
[0] != '\0') {
1113 path_combine(backing_filename2
, sizeof(backing_filename2
),
1114 filename
, backing_filename
);
1115 printf("backing file: %s (actual path: %s)\n",
1119 bdrv_get_image_filename(bs
, image_filename
, sizeof(image_filename
));
1120 if (image_filename
[0] != '\0') {
1121 path_combine(image_filename2
, sizeof(image_filename2
),
1122 filename
, image_filename
);
1123 printf("image file: %s (actual path: %s)\n",
1133 #define SNAPSHOT_LIST 1
1134 #define SNAPSHOT_CREATE 2
1135 #define SNAPSHOT_APPLY 3
1136 #define SNAPSHOT_DELETE 4
1138 static int img_snapshot(int argc
, char **argv
)
1140 BlockDriverState
*bs
;
1141 QEMUSnapshotInfo sn
;
1142 char *filename
, *snapshot_name
= NULL
;
1143 int c
, ret
= 0, bdrv_oflags
;
1147 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1148 /* Parse commandline parameters */
1150 c
= getopt(argc
, argv
, "la:c:d:h");
1164 action
= SNAPSHOT_LIST
;
1165 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1172 action
= SNAPSHOT_APPLY
;
1173 snapshot_name
= optarg
;
1180 action
= SNAPSHOT_CREATE
;
1181 snapshot_name
= optarg
;
1188 action
= SNAPSHOT_DELETE
;
1189 snapshot_name
= optarg
;
1194 if (optind
>= argc
) {
1197 filename
= argv
[optind
++];
1199 /* Open the image */
1200 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1205 /* Perform the requested action */
1211 case SNAPSHOT_CREATE
:
1212 memset(&sn
, 0, sizeof(sn
));
1213 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1215 qemu_gettimeofday(&tv
);
1216 sn
.date_sec
= tv
.tv_sec
;
1217 sn
.date_nsec
= tv
.tv_usec
* 1000;
1219 ret
= bdrv_snapshot_create(bs
, &sn
);
1221 error_report("Could not create snapshot '%s': %d (%s)",
1222 snapshot_name
, ret
, strerror(-ret
));
1226 case SNAPSHOT_APPLY
:
1227 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1229 error_report("Could not apply snapshot '%s': %d (%s)",
1230 snapshot_name
, ret
, strerror(-ret
));
1234 case SNAPSHOT_DELETE
:
1235 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1237 error_report("Could not delete snapshot '%s': %d (%s)",
1238 snapshot_name
, ret
, strerror(-ret
));
1251 static int img_rebase(int argc
, char **argv
)
1253 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1254 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1256 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1261 /* Parse commandline parameters */
1263 cache
= BDRV_DEFAULT_CACHE
;
1267 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1280 out_basefmt
= optarg
;
1283 out_baseimg
= optarg
;
1297 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1300 filename
= argv
[optind
++];
1302 qemu_progress_init(progress
, 2.0);
1303 qemu_progress_print(0, 100);
1305 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1306 ret
= set_cache_flag(cache
, &flags
);
1308 error_report("Invalid cache option: %s", cache
);
1315 * Ignore the old backing file for unsafe rebase in case we want to correct
1316 * the reference to a renamed or moved backing file.
1318 bs
= bdrv_new_open(filename
, fmt
, flags
);
1323 /* Find the right drivers for the backing files */
1324 old_backing_drv
= NULL
;
1325 new_backing_drv
= NULL
;
1327 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1328 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1329 if (old_backing_drv
== NULL
) {
1330 error_report("Invalid format name: '%s'", bs
->backing_format
);
1336 if (out_basefmt
!= NULL
) {
1337 new_backing_drv
= bdrv_find_format(out_basefmt
);
1338 if (new_backing_drv
== NULL
) {
1339 error_report("Invalid format name: '%s'", out_basefmt
);
1345 /* For safe rebasing we need to compare old and new backing file */
1347 /* Make the compiler happy */
1348 bs_old_backing
= NULL
;
1349 bs_new_backing
= NULL
;
1351 char backing_name
[1024];
1353 bs_old_backing
= bdrv_new("old_backing");
1354 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1355 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1358 error_report("Could not open old backing file '%s'", backing_name
);
1362 bs_new_backing
= bdrv_new("new_backing");
1363 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1366 error_report("Could not open new backing file '%s'", out_baseimg
);
1372 * Check each unallocated cluster in the COW file. If it is unallocated,
1373 * accesses go to the backing file. We must therefore compare this cluster
1374 * in the old and new backing file, and if they differ we need to copy it
1375 * from the old backing file into the COW file.
1377 * If qemu-img crashes during this step, no harm is done. The content of
1378 * the image is the same as the original one at any time.
1381 uint64_t num_sectors
;
1386 float local_progress
;
1388 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1389 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1391 bdrv_get_geometry(bs
, &num_sectors
);
1393 local_progress
= (float)100 /
1394 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1395 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1397 /* How many sectors can we handle with the next read? */
1398 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1399 n
= (IO_BUF_SIZE
/ 512);
1401 n
= num_sectors
- sector
;
1404 /* If the cluster is allocated, we don't need to take action */
1405 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1410 /* Read old and new backing file */
1411 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1413 error_report("error while reading from old backing file");
1416 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1418 error_report("error while reading from new backing file");
1422 /* If they differ, we need to write to the COW file */
1423 uint64_t written
= 0;
1425 while (written
< n
) {
1428 if (compare_sectors(buf_old
+ written
* 512,
1429 buf_new
+ written
* 512, n
- written
, &pnum
))
1431 ret
= bdrv_write(bs
, sector
+ written
,
1432 buf_old
+ written
* 512, pnum
);
1434 error_report("Error while writing to COW image: %s",
1442 qemu_progress_print(local_progress
, 100);
1450 * Change the backing file. All clusters that are different from the old
1451 * backing file are overwritten in the COW file now, so the visible content
1452 * doesn't change when we switch the backing file.
1454 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1455 if (ret
== -ENOSPC
) {
1456 error_report("Could not change the backing file to '%s': No "
1457 "space left in the file header", out_baseimg
);
1458 } else if (ret
< 0) {
1459 error_report("Could not change the backing file to '%s': %s",
1460 out_baseimg
, strerror(-ret
));
1463 qemu_progress_print(100, 0);
1465 * TODO At this point it is possible to check if any clusters that are
1466 * allocated in the COW file are the same in the backing file. If so, they
1467 * could be dropped from the COW file. Don't do this before switching the
1468 * backing file, in case of a crash this would lead to corruption.
1471 qemu_progress_end();
1474 if (bs_old_backing
!= NULL
) {
1475 bdrv_delete(bs_old_backing
);
1477 if (bs_new_backing
!= NULL
) {
1478 bdrv_delete(bs_new_backing
);
1489 static int img_resize(int argc
, char **argv
)
1491 int c
, ret
, relative
;
1492 const char *filename
, *fmt
, *size
;
1493 int64_t n
, total_size
;
1494 BlockDriverState
*bs
= NULL
;
1495 QEMUOptionParameter
*param
;
1496 QEMUOptionParameter resize_options
[] = {
1498 .name
= BLOCK_OPT_SIZE
,
1500 .help
= "Virtual disk size"
1505 /* Remove size from argv manually so that negative numbers are not treated
1506 * as options by getopt. */
1512 size
= argv
[--argc
];
1514 /* Parse getopt arguments */
1517 c
= getopt(argc
, argv
, "f:h");
1531 if (optind
>= argc
) {
1534 filename
= argv
[optind
++];
1536 /* Choose grow, shrink, or absolute resize mode */
1552 param
= parse_option_parameters("", resize_options
, NULL
);
1553 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1554 /* Error message already printed when size parsing fails */
1558 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1559 free_option_parameters(param
);
1561 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1568 total_size
= bdrv_getlength(bs
) + n
* relative
;
1572 if (total_size
<= 0) {
1573 error_report("New image size must be positive");
1578 ret
= bdrv_truncate(bs
, total_size
);
1581 printf("Image resized.\n");
1584 error_report("This image format does not support resize");
1587 error_report("Image is read-only");
1590 error_report("Error resizing image (%d)", -ret
);
1603 static const img_cmd_t img_cmds
[] = {
1604 #define DEF(option, callback, arg_string) \
1605 { option, callback },
1606 #include "qemu-img-cmds.h"
1612 int main(int argc
, char **argv
)
1614 const img_cmd_t
*cmd
;
1615 const char *cmdname
;
1617 error_set_progname(argv
[0]);
1625 /* find the command */
1626 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1627 if (!strcmp(cmdname
, cmd
->name
)) {
1628 return cmd
->handler(argc
, argv
);