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"
28 #include "block_int.h"
35 typedef struct img_cmd_t
{
37 int (*handler
)(int argc
, char **argv
);
40 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
41 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43 static void GCC_FMT_ATTR(1, 2) error(const char *fmt
, ...)
47 fprintf(stderr
, "qemu-img: ");
48 vfprintf(stderr
, fmt
, ap
);
49 fprintf(stderr
, "\n");
53 static void format_print(void *opaque
, const char *name
)
58 /* Please keep in synch with qemu-img.texi */
59 static void help(void)
61 const char *help_msg
=
62 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
63 "usage: qemu-img command [command options]\n"
64 "QEMU disk image utility\n"
67 #define DEF(option, callback, arg_string) \
69 #include "qemu-img-cmds.h"
73 "Command parameters:\n"
74 " 'filename' is a disk image filename\n"
75 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
76 " 'size' is the disk image size in bytes. Optional suffixes\n"
77 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
78 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
79 " 'output_filename' is the destination disk image filename\n"
80 " 'output_fmt' is the destination format\n"
81 " 'options' is a comma separated list of format specific options in a\n"
82 " name=value format. Use -o ? for an overview of the options supported by the\n"
84 " '-c' indicates that target image must be compressed (qcow format only)\n"
85 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
86 " match exactly. The image doesn't need a working backing file before\n"
87 " rebasing in this case (useful for renaming the backing file)\n"
88 " '-h' with or without a command shows this help and lists the supported formats\n"
90 "Parameters to snapshot subcommand:\n"
91 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
92 " '-a' applies a snapshot (revert disk to saved state)\n"
93 " '-c' creates a snapshot\n"
94 " '-d' deletes a snapshot\n"
95 " '-l' lists all snapshots in the given image\n";
97 printf("%s\nSupported formats:", help_msg
);
98 bdrv_iterate_format(format_print
, NULL
);
104 /* XXX: put correct support for win32 */
105 static int read_password(char *buf
, int buf_size
)
108 printf("Password: ");
115 if (i
< (buf_size
- 1))
126 static struct termios oldtty
;
128 static void term_exit(void)
130 tcsetattr (0, TCSANOW
, &oldtty
);
133 static void term_init(void)
140 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
141 |INLCR
|IGNCR
|ICRNL
|IXON
);
142 tty
.c_oflag
|= OPOST
;
143 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
144 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
149 tcsetattr (0, TCSANOW
, &tty
);
154 static int read_password(char *buf
, int buf_size
)
159 printf("password: ");
164 ret
= read(0, &ch
, 1);
166 if (errno
== EAGAIN
|| errno
== EINTR
) {
172 } else if (ret
== 0) {
180 if (i
< (buf_size
- 1))
191 static int print_block_option_help(const char *filename
, const char *fmt
)
193 BlockDriver
*drv
, *proto_drv
;
194 QEMUOptionParameter
*create_options
= NULL
;
196 /* Find driver and parse its options */
197 drv
= bdrv_find_format(fmt
);
199 error("Unknown file format '%s'", fmt
);
203 proto_drv
= bdrv_find_protocol(filename
);
205 error("Unknown protocol '%s'", filename
);
209 create_options
= append_option_parameters(create_options
,
210 drv
->create_options
);
211 create_options
= append_option_parameters(create_options
,
212 proto_drv
->create_options
);
213 print_option_help(create_options
);
214 free_option_parameters(create_options
);
218 static BlockDriverState
*bdrv_new_open(const char *filename
,
222 BlockDriverState
*bs
;
228 error("Not enough memory");
232 drv
= bdrv_find_format(fmt
);
234 error("Unknown file format '%s'", fmt
);
240 if (bdrv_open(bs
, filename
, flags
, drv
) < 0) {
241 error("Could not open '%s'", filename
);
244 if (bdrv_is_encrypted(bs
)) {
245 printf("Disk image '%s' is encrypted.\n", filename
);
246 if (read_password(password
, sizeof(password
)) < 0) {
247 error("No password given");
250 if (bdrv_set_key(bs
, password
) < 0) {
251 error("invalid password");
263 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
264 int flags
, const char *base_filename
, const char *base_fmt
)
266 if (flags
& BLOCK_FLAG_ENCRYPT
) {
267 if (set_option_parameter(list
, BLOCK_OPT_ENCRYPT
, "on")) {
268 error("Encryption not supported for file format '%s'", fmt
);
272 if (flags
& BLOCK_FLAG_COMPAT6
) {
273 if (set_option_parameter(list
, BLOCK_OPT_COMPAT6
, "on")) {
274 error("VMDK version 6 not supported for file format '%s'", fmt
);
280 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
281 error("Backing file not supported for file format '%s'", fmt
);
286 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
287 error("Backing file format not supported for file format '%s'", fmt
);
294 static int img_create(int argc
, char **argv
)
296 int c
, ret
= 0, flags
;
297 const char *fmt
= "raw";
298 const char *base_fmt
= NULL
;
299 const char *filename
;
300 const char *base_filename
= NULL
;
301 BlockDriver
*drv
, *proto_drv
;
302 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
303 char *options
= NULL
;
307 c
= getopt(argc
, argv
, "F:b:f:he6o:");
320 base_filename
= optarg
;
326 flags
|= BLOCK_FLAG_ENCRYPT
;
329 flags
|= BLOCK_FLAG_COMPAT6
;
337 /* Get the filename */
338 if (optind
>= argc
) {
341 filename
= argv
[optind
++];
343 if (options
&& !strcmp(options
, "?")) {
344 ret
= print_block_option_help(filename
, fmt
);
348 /* Find driver and parse its options */
349 drv
= bdrv_find_format(fmt
);
351 error("Unknown file format '%s'", fmt
);
355 proto_drv
= bdrv_find_protocol(filename
);
357 error("Unknown protocol '%s'", filename
);
361 create_options
= append_option_parameters(create_options
,
362 drv
->create_options
);
363 create_options
= append_option_parameters(create_options
,
364 proto_drv
->create_options
);
366 /* Create parameter list with default values */
367 param
= parse_option_parameters("", create_options
, param
);
368 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
370 /* Parse -o options */
372 param
= parse_option_parameters(options
, create_options
, param
);
374 error("Invalid options for file format '%s'.", fmt
);
380 /* Add size to parameters */
382 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
385 /* Add old-style options to parameters */
386 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
391 // The size for the image must always be specified, with one exception:
392 // If we are using a backing file, we can obtain the size from there
393 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
395 QEMUOptionParameter
*backing_file
=
396 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
397 QEMUOptionParameter
*backing_fmt
=
398 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
400 if (backing_file
&& backing_file
->value
.s
) {
401 BlockDriverState
*bs
;
403 const char *fmt
= NULL
;
406 if (backing_fmt
&& backing_fmt
->value
.s
) {
407 if (bdrv_find_format(backing_fmt
->value
.s
)) {
408 fmt
= backing_fmt
->value
.s
;
410 error("Unknown backing file format '%s'",
411 backing_fmt
->value
.s
);
417 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
422 bdrv_get_geometry(bs
, &size
);
426 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
427 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
429 error("Image creation needs a size parameter");
435 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
436 print_option_parameters(param
);
439 ret
= bdrv_create(drv
, filename
, param
);
440 free_option_parameters(create_options
);
441 free_option_parameters(param
);
444 if (ret
== -ENOTSUP
) {
445 error("Formatting or formatting option not supported for file format '%s'", fmt
);
446 } else if (ret
== -EFBIG
) {
447 error("The image size is too large for file format '%s'", fmt
);
449 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
460 * Checks an image for consistency. Exit codes:
462 * 0 - Check completed, image is good
463 * 1 - Check not completed because of internal errors
464 * 2 - Check completed, image is corrupted
465 * 3 - Check completed, image has leaked clusters, but is good otherwise
467 static int img_check(int argc
, char **argv
)
470 const char *filename
, *fmt
;
471 BlockDriverState
*bs
;
472 BdrvCheckResult result
;
476 c
= getopt(argc
, argv
, "f:h");
490 if (optind
>= argc
) {
493 filename
= argv
[optind
++];
495 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
499 ret
= bdrv_check(bs
, &result
);
501 if (ret
== -ENOTSUP
) {
502 error("This image format does not support checks");
507 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
508 printf("No errors were found on the image.\n");
510 if (result
.corruptions
) {
511 printf("\n%d errors were found on the image.\n"
512 "Data may be corrupted, or further writes to the image "
518 printf("\n%d leaked clusters were found on the image.\n"
519 "This means waste of disk space, but no harm to data.\n",
523 if (result
.check_errors
) {
524 printf("\n%d internal errors have occurred during the check.\n",
525 result
.check_errors
);
531 if (ret
< 0 || result
.check_errors
) {
532 printf("\nAn error has occurred during the check: %s\n"
533 "The check is not complete and may have missed error.\n",
538 if (result
.corruptions
) {
540 } else if (result
.leaks
) {
547 static int img_commit(int argc
, char **argv
)
550 const char *filename
, *fmt
;
551 BlockDriverState
*bs
;
555 c
= getopt(argc
, argv
, "f:h");
569 if (optind
>= argc
) {
572 filename
= argv
[optind
++];
574 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
578 ret
= bdrv_commit(bs
);
581 printf("Image committed.\n");
584 error("No disk inserted");
587 error("Image is read-only");
590 error("Image is already committed");
593 error("Error while committing image");
604 static int is_not_zero(const uint8_t *sector
, int len
)
608 for(i
= 0;i
< len
; i
++) {
609 if (((uint32_t *)sector
)[i
] != 0)
616 * Returns true iff the first sector pointed to by 'buf' contains at least
619 * 'pnum' is set to the number of sectors (including and immediately following
620 * the first one) that are known to be in the same allocated/unallocated state.
622 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
630 v
= is_not_zero(buf
, 512);
631 for(i
= 1; i
< n
; i
++) {
633 if (v
!= is_not_zero(buf
, 512))
641 * Compares two buffers sector by sector. Returns 0 if the first sector of both
642 * buffers matches, non-zero otherwise.
644 * pnum is set to the number of sectors (including and immediately following
645 * the first one) that are known to have the same comparison result
647 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
657 res
= !!memcmp(buf1
, buf2
, 512);
658 for(i
= 1; i
< n
; i
++) {
662 if (!!memcmp(buf1
, buf2
, 512) != res
) {
671 #define IO_BUF_SIZE (2 * 1024 * 1024)
673 static int img_convert(int argc
, char **argv
)
675 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
676 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
677 BlockDriver
*drv
, *proto_drv
;
678 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
679 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
681 uint8_t * buf
= NULL
;
684 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
685 QEMUOptionParameter
*out_baseimg_param
;
686 char *options
= NULL
;
687 const char *snapshot_name
= NULL
;
694 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
710 out_baseimg
= optarg
;
713 flags
|= BLOCK_FLAG_COMPRESS
;
716 flags
|= BLOCK_FLAG_ENCRYPT
;
719 flags
|= BLOCK_FLAG_COMPAT6
;
725 snapshot_name
= optarg
;
730 bs_n
= argc
- optind
- 1;
735 out_filename
= argv
[argc
- 1];
737 if (options
&& !strcmp(options
, "?")) {
738 ret
= print_block_option_help(out_filename
, out_fmt
);
742 if (bs_n
> 1 && out_baseimg
) {
743 error("-B makes no sense when concatenating multiple input images");
748 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
751 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
752 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
754 error("Could not open '%s'", argv
[optind
+ bs_i
]);
758 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
759 total_sectors
+= bs_sectors
;
762 if (snapshot_name
!= NULL
) {
764 error("No support for concatenating multiple snapshot\n");
768 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
769 error("Failed to load snapshot\n");
775 /* Find driver and parse its options */
776 drv
= bdrv_find_format(out_fmt
);
778 error("Unknown file format '%s'", out_fmt
);
783 proto_drv
= bdrv_find_protocol(out_filename
);
785 error("Unknown protocol '%s'", out_filename
);
790 create_options
= append_option_parameters(create_options
,
791 drv
->create_options
);
792 create_options
= append_option_parameters(create_options
,
793 proto_drv
->create_options
);
796 param
= parse_option_parameters(options
, create_options
, param
);
798 error("Invalid options for file format '%s'.", out_fmt
);
803 param
= parse_option_parameters("", create_options
, param
);
806 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
807 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
812 /* Get backing file name if -o backing_file was used */
813 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
814 if (out_baseimg_param
) {
815 out_baseimg
= out_baseimg_param
->value
.s
;
818 /* Check if compression is supported */
819 if (flags
& BLOCK_FLAG_COMPRESS
) {
820 QEMUOptionParameter
*encryption
=
821 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
823 if (!drv
->bdrv_write_compressed
) {
824 error("Compression not supported for this file format");
829 if (encryption
&& encryption
->value
.n
) {
830 error("Compression and encryption not supported at the same time");
836 /* Create the new image */
837 ret
= bdrv_create(drv
, out_filename
, param
);
839 if (ret
== -ENOTSUP
) {
840 error("Formatting not supported for file format '%s'", out_fmt
);
841 } else if (ret
== -EFBIG
) {
842 error("The image size is too large for file format '%s'", out_fmt
);
844 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
849 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
850 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
858 bdrv_get_geometry(bs
[0], &bs_sectors
);
859 buf
= qemu_malloc(IO_BUF_SIZE
);
861 if (flags
& BLOCK_FLAG_COMPRESS
) {
862 ret
= bdrv_get_info(out_bs
, &bdi
);
864 error("could not get block driver info");
867 cluster_size
= bdi
.cluster_size
;
868 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
869 error("invalid cluster size");
873 cluster_sectors
= cluster_size
>> 9;
880 nb_sectors
= total_sectors
- sector_num
;
883 if (nb_sectors
>= cluster_sectors
)
888 bs_num
= sector_num
- bs_offset
;
889 assert (bs_num
>= 0);
892 while (remainder
> 0) {
894 while (bs_num
== bs_sectors
) {
896 assert (bs_i
< bs_n
);
897 bs_offset
+= bs_sectors
;
898 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
900 /* printf("changing part: sector_num=%" PRId64 ", "
901 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
902 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
904 assert (bs_num
< bs_sectors
);
906 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
908 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
910 error("error while reading");
919 assert (remainder
== 0);
921 if (n
< cluster_sectors
) {
922 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
924 if (is_not_zero(buf
, cluster_size
)) {
925 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
928 error("error while compressing sector %" PRId64
,
935 /* signal EOF to align */
936 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
938 int has_zero_init
= bdrv_has_zero_init(out_bs
);
940 sector_num
= 0; // total number of sectors converted so far
942 nb_sectors
= total_sectors
- sector_num
;
943 if (nb_sectors
<= 0) {
946 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
947 n
= (IO_BUF_SIZE
/ 512);
952 while (sector_num
- bs_offset
>= bs_sectors
) {
954 assert (bs_i
< bs_n
);
955 bs_offset
+= bs_sectors
;
956 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
957 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
958 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
959 sector_num, bs_i, bs_offset, bs_sectors); */
962 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
963 n
= bs_offset
+ bs_sectors
- sector_num
;
967 /* If the output image is being created as a copy on write image,
968 assume that sectors which are unallocated in the input image
969 are present in both the output's and input's base images (no
970 need to copy them). */
972 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
977 /* The next 'n1' sectors are allocated in the input image. Copy
978 only those as they may be followed by unallocated sectors. */
985 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
987 error("error while reading");
990 /* NOTE: at the same time we convert, we do not write zero
991 sectors to have a chance to compress the image. Ideally, we
992 should add a specific call to have the info to go faster */
995 /* If the output image is being created as a copy on write image,
996 copy all sectors even the ones containing only NUL bytes,
997 because they may differ from the sectors in the base image.
999 If the output is to a host device, we also write out
1000 sectors that are entirely 0, since whatever data was
1001 already there is garbage, not 0s. */
1002 if (!has_zero_init
|| out_baseimg
||
1003 is_allocated_sectors(buf1
, n
, &n1
)) {
1004 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1006 error("error while writing");
1017 free_option_parameters(create_options
);
1018 free_option_parameters(param
);
1021 bdrv_delete(out_bs
);
1024 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1026 bdrv_delete(bs
[bs_i
]);
1038 static int64_t get_allocated_file_size(const char *filename
)
1040 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1041 get_compressed_t get_compressed
;
1044 /* WinNT support GetCompressedFileSize to determine allocate size */
1045 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1046 if (get_compressed
) {
1048 low
= get_compressed(filename
, &high
);
1049 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1050 return (((int64_t) high
) << 32) + low
;
1053 if (_stati64(filename
, &st
) < 0)
1058 static int64_t get_allocated_file_size(const char *filename
)
1061 if (stat(filename
, &st
) < 0)
1063 return (int64_t)st
.st_blocks
* 512;
1067 static void dump_snapshots(BlockDriverState
*bs
)
1069 QEMUSnapshotInfo
*sn_tab
, *sn
;
1073 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1076 printf("Snapshot list:\n");
1077 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1078 for(i
= 0; i
< nb_sns
; i
++) {
1080 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1085 static int img_info(int argc
, char **argv
)
1088 const char *filename
, *fmt
;
1089 BlockDriverState
*bs
;
1090 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1091 uint64_t total_sectors
;
1092 int64_t allocated_size
;
1093 char backing_filename
[1024];
1094 char backing_filename2
[1024];
1095 BlockDriverInfo bdi
;
1099 c
= getopt(argc
, argv
, "f:h");
1113 if (optind
>= argc
) {
1116 filename
= argv
[optind
++];
1118 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1122 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1123 bdrv_get_geometry(bs
, &total_sectors
);
1124 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1125 allocated_size
= get_allocated_file_size(filename
);
1126 if (allocated_size
< 0) {
1127 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1129 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1132 printf("image: %s\n"
1134 "virtual size: %s (%" PRId64
" bytes)\n"
1136 filename
, fmt_name
, size_buf
,
1137 (total_sectors
* 512),
1139 if (bdrv_is_encrypted(bs
)) {
1140 printf("encrypted: yes\n");
1142 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1143 if (bdi
.cluster_size
!= 0) {
1144 printf("cluster_size: %d\n", bdi
.cluster_size
);
1147 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1148 if (backing_filename
[0] != '\0') {
1149 path_combine(backing_filename2
, sizeof(backing_filename2
),
1150 filename
, backing_filename
);
1151 printf("backing file: %s (actual path: %s)\n",
1160 #define SNAPSHOT_LIST 1
1161 #define SNAPSHOT_CREATE 2
1162 #define SNAPSHOT_APPLY 3
1163 #define SNAPSHOT_DELETE 4
1165 static int img_snapshot(int argc
, char **argv
)
1167 BlockDriverState
*bs
;
1168 QEMUSnapshotInfo sn
;
1169 char *filename
, *snapshot_name
= NULL
;
1170 int c
, ret
= 0, bdrv_oflags
;
1174 bdrv_oflags
= BDRV_O_RDWR
;
1175 /* Parse commandline parameters */
1177 c
= getopt(argc
, argv
, "la:c:d:h");
1191 action
= SNAPSHOT_LIST
;
1192 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1199 action
= SNAPSHOT_APPLY
;
1200 snapshot_name
= optarg
;
1207 action
= SNAPSHOT_CREATE
;
1208 snapshot_name
= optarg
;
1215 action
= SNAPSHOT_DELETE
;
1216 snapshot_name
= optarg
;
1221 if (optind
>= argc
) {
1224 filename
= argv
[optind
++];
1226 /* Open the image */
1227 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1232 /* Perform the requested action */
1238 case SNAPSHOT_CREATE
:
1239 memset(&sn
, 0, sizeof(sn
));
1240 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1242 qemu_gettimeofday(&tv
);
1243 sn
.date_sec
= tv
.tv_sec
;
1244 sn
.date_nsec
= tv
.tv_usec
* 1000;
1246 ret
= bdrv_snapshot_create(bs
, &sn
);
1248 error("Could not create snapshot '%s': %d (%s)",
1249 snapshot_name
, ret
, strerror(-ret
));
1253 case SNAPSHOT_APPLY
:
1254 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1256 error("Could not apply snapshot '%s': %d (%s)",
1257 snapshot_name
, ret
, strerror(-ret
));
1261 case SNAPSHOT_DELETE
:
1262 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1264 error("Could not delete snapshot '%s': %d (%s)",
1265 snapshot_name
, ret
, strerror(-ret
));
1278 static int img_rebase(int argc
, char **argv
)
1280 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1281 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1283 const char *fmt
, *out_basefmt
, *out_baseimg
;
1287 /* Parse commandline parameters */
1293 c
= getopt(argc
, argv
, "uhf:F:b:");
1306 out_basefmt
= optarg
;
1309 out_baseimg
= optarg
;
1317 if ((optind
>= argc
) || !out_baseimg
) {
1320 filename
= argv
[optind
++];
1325 * Ignore the old backing file for unsafe rebase in case we want to correct
1326 * the reference to a renamed or moved backing file.
1328 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1329 bs
= bdrv_new_open(filename
, fmt
, flags
);
1334 /* Find the right drivers for the backing files */
1335 old_backing_drv
= NULL
;
1336 new_backing_drv
= NULL
;
1338 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1339 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1340 if (old_backing_drv
== NULL
) {
1341 error("Invalid format name: '%s'", bs
->backing_format
);
1347 if (out_basefmt
!= NULL
) {
1348 new_backing_drv
= bdrv_find_format(out_basefmt
);
1349 if (new_backing_drv
== NULL
) {
1350 error("Invalid format name: '%s'", out_basefmt
);
1356 /* For safe rebasing we need to compare old and new backing file */
1358 /* Make the compiler happy */
1359 bs_old_backing
= NULL
;
1360 bs_new_backing
= NULL
;
1362 char backing_name
[1024];
1364 bs_old_backing
= bdrv_new("old_backing");
1365 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1366 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1369 error("Could not open old backing file '%s'", backing_name
);
1373 bs_new_backing
= bdrv_new("new_backing");
1374 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1377 error("Could not open new backing file '%s'", out_baseimg
);
1383 * Check each unallocated cluster in the COW file. If it is unallocated,
1384 * accesses go to the backing file. We must therefore compare this cluster
1385 * in the old and new backing file, and if they differ we need to copy it
1386 * from the old backing file into the COW file.
1388 * If qemu-img crashes during this step, no harm is done. The content of
1389 * the image is the same as the original one at any time.
1392 uint64_t num_sectors
;
1398 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1399 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1401 bdrv_get_geometry(bs
, &num_sectors
);
1403 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1405 /* How many sectors can we handle with the next read? */
1406 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1407 n
= (IO_BUF_SIZE
/ 512);
1409 n
= num_sectors
- sector
;
1412 /* If the cluster is allocated, we don't need to take action */
1413 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1418 /* Read old and new backing file */
1419 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1421 error("error while reading from old backing file");
1424 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1426 error("error while reading from new backing file");
1430 /* If they differ, we need to write to the COW file */
1431 uint64_t written
= 0;
1433 while (written
< n
) {
1436 if (compare_sectors(buf_old
+ written
* 512,
1437 buf_new
+ written
* 512, n
- written
, &pnum
))
1439 ret
= bdrv_write(bs
, sector
+ written
,
1440 buf_old
+ written
* 512, pnum
);
1442 error("Error while writing to COW image: %s",
1457 * Change the backing file. All clusters that are different from the old
1458 * backing file are overwritten in the COW file now, so the visible content
1459 * doesn't change when we switch the backing file.
1461 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1462 if (ret
== -ENOSPC
) {
1463 error("Could not change the backing file to '%s': No space left in "
1464 "the file header", out_baseimg
);
1465 } else if (ret
< 0) {
1466 error("Could not change the backing file to '%s': %s",
1467 out_baseimg
, strerror(-ret
));
1471 * TODO At this point it is possible to check if any clusters that are
1472 * allocated in the COW file are the same in the backing file. If so, they
1473 * could be dropped from the COW file. Don't do this before switching the
1474 * backing file, in case of a crash this would lead to corruption.
1479 bdrv_delete(bs_old_backing
);
1480 bdrv_delete(bs_new_backing
);
1490 static int img_resize(int argc
, char **argv
)
1492 int c
, ret
, relative
;
1493 const char *filename
, *fmt
, *size
;
1494 int64_t n
, total_size
;
1495 BlockDriverState
*bs
;
1496 QEMUOptionParameter
*param
;
1497 QEMUOptionParameter resize_options
[] = {
1499 .name
= BLOCK_OPT_SIZE
,
1501 .help
= "Virtual disk size"
1508 c
= getopt(argc
, argv
, "f:h");
1522 if (optind
+ 1 >= argc
) {
1525 filename
= argv
[optind
++];
1526 size
= argv
[optind
++];
1528 /* Choose grow, shrink, or absolute resize mode */
1544 param
= parse_option_parameters("", resize_options
, NULL
);
1545 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1546 /* Error message already printed when size parsing fails */
1549 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1550 free_option_parameters(param
);
1552 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1558 total_size
= bdrv_getlength(bs
) + n
* relative
;
1562 if (total_size
<= 0) {
1563 error("New image size must be positive");
1568 ret
= bdrv_truncate(bs
, total_size
);
1571 printf("Image resized.\n");
1574 error("This image format does not support resize");
1577 error("Image is read-only");
1580 error("Error resizing image (%d)", -ret
);
1591 static const img_cmd_t img_cmds
[] = {
1592 #define DEF(option, callback, arg_string) \
1593 { option, callback },
1594 #include "qemu-img-cmds.h"
1600 int main(int argc
, char **argv
)
1602 const img_cmd_t
*cmd
;
1603 const char *cmdname
;
1611 /* find the command */
1612 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1613 if (!strcmp(cmdname
, cmd
->name
)) {
1614 return cmd
->handler(argc
, argv
);