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 const char *base_filename
,
265 const char *base_fmt
)
268 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
269 error("Backing file not supported for file format '%s'", fmt
);
274 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
275 error("Backing file format not supported for file format '%s'", fmt
);
282 static int img_create(int argc
, char **argv
)
285 const char *fmt
= "raw";
286 const char *base_fmt
= NULL
;
287 const char *filename
;
288 const char *base_filename
= NULL
;
289 BlockDriver
*drv
, *proto_drv
;
290 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
291 QEMUOptionParameter
*backing_fmt
= NULL
;
292 char *options
= NULL
;
295 c
= getopt(argc
, argv
, "F:b:f:he6o:");
308 base_filename
= optarg
;
314 error("qemu-img: option -e is deprecated, please use \'-o "
315 "encryption\' instead!");
318 error("qemu-img: option -6 is deprecated, please use \'-o "
319 "compat6\' instead!");
327 /* Get the filename */
328 if (optind
>= argc
) {
331 filename
= argv
[optind
++];
333 if (options
&& !strcmp(options
, "?")) {
334 ret
= print_block_option_help(filename
, fmt
);
338 /* Find driver and parse its options */
339 drv
= bdrv_find_format(fmt
);
341 error("Unknown file format '%s'", fmt
);
346 proto_drv
= bdrv_find_protocol(filename
);
348 error("Unknown protocol '%s'", filename
);
353 create_options
= append_option_parameters(create_options
,
354 drv
->create_options
);
355 create_options
= append_option_parameters(create_options
,
356 proto_drv
->create_options
);
358 /* Create parameter list with default values */
359 param
= parse_option_parameters("", create_options
, param
);
360 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
362 /* Parse -o options */
364 param
= parse_option_parameters(options
, create_options
, param
);
366 error("Invalid options for file format '%s'.", fmt
);
372 /* Add size to parameters */
374 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
377 /* Add old-style options to parameters */
378 ret
= add_old_style_options(fmt
, param
, base_filename
, base_fmt
);
383 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
384 if (backing_fmt
&& backing_fmt
->value
.s
) {
385 if (!bdrv_find_format(backing_fmt
->value
.s
)) {
386 error("Unknown backing file format '%s'",
387 backing_fmt
->value
.s
);
393 // The size for the image must always be specified, with one exception:
394 // If we are using a backing file, we can obtain the size from there
395 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
397 QEMUOptionParameter
*backing_file
=
398 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
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 fmt
= backing_fmt
->value
.s
;
410 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
415 bdrv_get_geometry(bs
, &size
);
419 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
420 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
422 error("Image creation needs a size parameter");
428 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
429 print_option_parameters(param
);
432 ret
= bdrv_create(drv
, filename
, param
);
435 if (ret
== -ENOTSUP
) {
436 error("Formatting or formatting option not supported for file format '%s'", fmt
);
437 } else if (ret
== -EFBIG
) {
438 error("The image size is too large for file format '%s'", fmt
);
440 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
444 free_option_parameters(create_options
);
445 free_option_parameters(param
);
453 * Checks an image for consistency. Exit codes:
455 * 0 - Check completed, image is good
456 * 1 - Check not completed because of internal errors
457 * 2 - Check completed, image is corrupted
458 * 3 - Check completed, image has leaked clusters, but is good otherwise
460 static int img_check(int argc
, char **argv
)
463 const char *filename
, *fmt
;
464 BlockDriverState
*bs
;
465 BdrvCheckResult result
;
469 c
= getopt(argc
, argv
, "f:h");
483 if (optind
>= argc
) {
486 filename
= argv
[optind
++];
488 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
492 ret
= bdrv_check(bs
, &result
);
494 if (ret
== -ENOTSUP
) {
495 error("This image format does not support checks");
500 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
501 printf("No errors were found on the image.\n");
503 if (result
.corruptions
) {
504 printf("\n%d errors were found on the image.\n"
505 "Data may be corrupted, or further writes to the image "
511 printf("\n%d leaked clusters were found on the image.\n"
512 "This means waste of disk space, but no harm to data.\n",
516 if (result
.check_errors
) {
517 printf("\n%d internal errors have occurred during the check.\n",
518 result
.check_errors
);
524 if (ret
< 0 || result
.check_errors
) {
525 printf("\nAn error has occurred during the check: %s\n"
526 "The check is not complete and may have missed error.\n",
531 if (result
.corruptions
) {
533 } else if (result
.leaks
) {
540 static int img_commit(int argc
, char **argv
)
543 const char *filename
, *fmt
;
544 BlockDriverState
*bs
;
548 c
= getopt(argc
, argv
, "f:h");
562 if (optind
>= argc
) {
565 filename
= argv
[optind
++];
567 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
571 ret
= bdrv_commit(bs
);
574 printf("Image committed.\n");
577 error("No disk inserted");
580 error("Image is read-only");
583 error("Image is already committed");
586 error("Error while committing image");
597 static int is_not_zero(const uint8_t *sector
, int len
)
601 for(i
= 0;i
< len
; i
++) {
602 if (((uint32_t *)sector
)[i
] != 0)
609 * Returns true iff the first sector pointed to by 'buf' contains at least
612 * 'pnum' is set to the number of sectors (including and immediately following
613 * the first one) that are known to be in the same allocated/unallocated state.
615 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
623 v
= is_not_zero(buf
, 512);
624 for(i
= 1; i
< n
; i
++) {
626 if (v
!= is_not_zero(buf
, 512))
634 * Compares two buffers sector by sector. Returns 0 if the first sector of both
635 * buffers matches, non-zero otherwise.
637 * pnum is set to the number of sectors (including and immediately following
638 * the first one) that are known to have the same comparison result
640 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
650 res
= !!memcmp(buf1
, buf2
, 512);
651 for(i
= 1; i
< n
; i
++) {
655 if (!!memcmp(buf1
, buf2
, 512) != res
) {
664 #define IO_BUF_SIZE (2 * 1024 * 1024)
666 static int img_convert(int argc
, char **argv
)
668 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
669 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
670 BlockDriver
*drv
, *proto_drv
;
671 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
672 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
674 uint8_t * buf
= NULL
;
677 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
678 QEMUOptionParameter
*out_baseimg_param
;
679 char *options
= NULL
;
680 const char *snapshot_name
= NULL
;
687 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
703 out_baseimg
= optarg
;
709 error("qemu-img: option -e is deprecated, please use \'-o "
710 "encryption\' instead!");
713 error("qemu-img: option -6 is deprecated, please use \'-o "
714 "compat6\' instead!");
720 snapshot_name
= optarg
;
725 bs_n
= argc
- optind
- 1;
730 out_filename
= argv
[argc
- 1];
732 if (options
&& !strcmp(options
, "?")) {
733 ret
= print_block_option_help(out_filename
, out_fmt
);
737 if (bs_n
> 1 && out_baseimg
) {
738 error("-B makes no sense when concatenating multiple input images");
743 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
746 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
747 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
749 error("Could not open '%s'", argv
[optind
+ bs_i
]);
753 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
754 total_sectors
+= bs_sectors
;
757 if (snapshot_name
!= NULL
) {
759 error("No support for concatenating multiple snapshot\n");
763 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
764 error("Failed to load snapshot\n");
770 /* Find driver and parse its options */
771 drv
= bdrv_find_format(out_fmt
);
773 error("Unknown file format '%s'", out_fmt
);
778 proto_drv
= bdrv_find_protocol(out_filename
);
780 error("Unknown protocol '%s'", out_filename
);
785 create_options
= append_option_parameters(create_options
,
786 drv
->create_options
);
787 create_options
= append_option_parameters(create_options
,
788 proto_drv
->create_options
);
791 param
= parse_option_parameters(options
, create_options
, param
);
793 error("Invalid options for file format '%s'.", out_fmt
);
798 param
= parse_option_parameters("", create_options
, param
);
801 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
802 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
807 /* Get backing file name if -o backing_file was used */
808 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
809 if (out_baseimg_param
) {
810 out_baseimg
= out_baseimg_param
->value
.s
;
813 /* Check if compression is supported */
815 QEMUOptionParameter
*encryption
=
816 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
818 if (!drv
->bdrv_write_compressed
) {
819 error("Compression not supported for this file format");
824 if (encryption
&& encryption
->value
.n
) {
825 error("Compression and encryption not supported at the same time");
831 /* Create the new image */
832 ret
= bdrv_create(drv
, out_filename
, param
);
834 if (ret
== -ENOTSUP
) {
835 error("Formatting not supported for file format '%s'", out_fmt
);
836 } else if (ret
== -EFBIG
) {
837 error("The image size is too large for file format '%s'", out_fmt
);
839 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
844 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
845 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
853 bdrv_get_geometry(bs
[0], &bs_sectors
);
854 buf
= qemu_malloc(IO_BUF_SIZE
);
857 ret
= bdrv_get_info(out_bs
, &bdi
);
859 error("could not get block driver info");
862 cluster_size
= bdi
.cluster_size
;
863 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
864 error("invalid cluster size");
868 cluster_sectors
= cluster_size
>> 9;
875 nb_sectors
= total_sectors
- sector_num
;
878 if (nb_sectors
>= cluster_sectors
)
883 bs_num
= sector_num
- bs_offset
;
884 assert (bs_num
>= 0);
887 while (remainder
> 0) {
889 while (bs_num
== bs_sectors
) {
891 assert (bs_i
< bs_n
);
892 bs_offset
+= bs_sectors
;
893 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
895 /* printf("changing part: sector_num=%" PRId64 ", "
896 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
897 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
899 assert (bs_num
< bs_sectors
);
901 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
903 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
905 error("error while reading");
914 assert (remainder
== 0);
916 if (n
< cluster_sectors
) {
917 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
919 if (is_not_zero(buf
, cluster_size
)) {
920 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
923 error("error while compressing sector %" PRId64
,
930 /* signal EOF to align */
931 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
933 int has_zero_init
= bdrv_has_zero_init(out_bs
);
935 sector_num
= 0; // total number of sectors converted so far
937 nb_sectors
= total_sectors
- sector_num
;
938 if (nb_sectors
<= 0) {
941 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
942 n
= (IO_BUF_SIZE
/ 512);
947 while (sector_num
- bs_offset
>= bs_sectors
) {
949 assert (bs_i
< bs_n
);
950 bs_offset
+= bs_sectors
;
951 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
952 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
953 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
954 sector_num, bs_i, bs_offset, bs_sectors); */
957 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
958 n
= bs_offset
+ bs_sectors
- sector_num
;
962 /* If the output image is being created as a copy on write image,
963 assume that sectors which are unallocated in the input image
964 are present in both the output's and input's base images (no
965 need to copy them). */
967 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
972 /* The next 'n1' sectors are allocated in the input image. Copy
973 only those as they may be followed by unallocated sectors. */
980 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
982 error("error while reading");
985 /* NOTE: at the same time we convert, we do not write zero
986 sectors to have a chance to compress the image. Ideally, we
987 should add a specific call to have the info to go faster */
990 /* If the output image is being created as a copy on write image,
991 copy all sectors even the ones containing only NUL bytes,
992 because they may differ from the sectors in the base image.
994 If the output is to a host device, we also write out
995 sectors that are entirely 0, since whatever data was
996 already there is garbage, not 0s. */
997 if (!has_zero_init
|| out_baseimg
||
998 is_allocated_sectors(buf1
, n
, &n1
)) {
999 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1001 error("error while writing");
1012 free_option_parameters(create_options
);
1013 free_option_parameters(param
);
1016 bdrv_delete(out_bs
);
1019 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1021 bdrv_delete(bs
[bs_i
]);
1033 static int64_t get_allocated_file_size(const char *filename
)
1035 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1036 get_compressed_t get_compressed
;
1039 /* WinNT support GetCompressedFileSize to determine allocate size */
1040 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1041 if (get_compressed
) {
1043 low
= get_compressed(filename
, &high
);
1044 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1045 return (((int64_t) high
) << 32) + low
;
1048 if (_stati64(filename
, &st
) < 0)
1053 static int64_t get_allocated_file_size(const char *filename
)
1056 if (stat(filename
, &st
) < 0)
1058 return (int64_t)st
.st_blocks
* 512;
1062 static void dump_snapshots(BlockDriverState
*bs
)
1064 QEMUSnapshotInfo
*sn_tab
, *sn
;
1068 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1071 printf("Snapshot list:\n");
1072 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1073 for(i
= 0; i
< nb_sns
; i
++) {
1075 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1080 static int img_info(int argc
, char **argv
)
1083 const char *filename
, *fmt
;
1084 BlockDriverState
*bs
;
1085 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1086 uint64_t total_sectors
;
1087 int64_t allocated_size
;
1088 char backing_filename
[1024];
1089 char backing_filename2
[1024];
1090 BlockDriverInfo bdi
;
1094 c
= getopt(argc
, argv
, "f:h");
1108 if (optind
>= argc
) {
1111 filename
= argv
[optind
++];
1113 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1117 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1118 bdrv_get_geometry(bs
, &total_sectors
);
1119 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1120 allocated_size
= get_allocated_file_size(filename
);
1121 if (allocated_size
< 0) {
1122 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1124 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1127 printf("image: %s\n"
1129 "virtual size: %s (%" PRId64
" bytes)\n"
1131 filename
, fmt_name
, size_buf
,
1132 (total_sectors
* 512),
1134 if (bdrv_is_encrypted(bs
)) {
1135 printf("encrypted: yes\n");
1137 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1138 if (bdi
.cluster_size
!= 0) {
1139 printf("cluster_size: %d\n", bdi
.cluster_size
);
1142 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1143 if (backing_filename
[0] != '\0') {
1144 path_combine(backing_filename2
, sizeof(backing_filename2
),
1145 filename
, backing_filename
);
1146 printf("backing file: %s (actual path: %s)\n",
1155 #define SNAPSHOT_LIST 1
1156 #define SNAPSHOT_CREATE 2
1157 #define SNAPSHOT_APPLY 3
1158 #define SNAPSHOT_DELETE 4
1160 static int img_snapshot(int argc
, char **argv
)
1162 BlockDriverState
*bs
;
1163 QEMUSnapshotInfo sn
;
1164 char *filename
, *snapshot_name
= NULL
;
1165 int c
, ret
= 0, bdrv_oflags
;
1169 bdrv_oflags
= BDRV_O_RDWR
;
1170 /* Parse commandline parameters */
1172 c
= getopt(argc
, argv
, "la:c:d:h");
1186 action
= SNAPSHOT_LIST
;
1187 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1194 action
= SNAPSHOT_APPLY
;
1195 snapshot_name
= optarg
;
1202 action
= SNAPSHOT_CREATE
;
1203 snapshot_name
= optarg
;
1210 action
= SNAPSHOT_DELETE
;
1211 snapshot_name
= optarg
;
1216 if (optind
>= argc
) {
1219 filename
= argv
[optind
++];
1221 /* Open the image */
1222 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1227 /* Perform the requested action */
1233 case SNAPSHOT_CREATE
:
1234 memset(&sn
, 0, sizeof(sn
));
1235 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1237 qemu_gettimeofday(&tv
);
1238 sn
.date_sec
= tv
.tv_sec
;
1239 sn
.date_nsec
= tv
.tv_usec
* 1000;
1241 ret
= bdrv_snapshot_create(bs
, &sn
);
1243 error("Could not create snapshot '%s': %d (%s)",
1244 snapshot_name
, ret
, strerror(-ret
));
1248 case SNAPSHOT_APPLY
:
1249 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1251 error("Could not apply snapshot '%s': %d (%s)",
1252 snapshot_name
, ret
, strerror(-ret
));
1256 case SNAPSHOT_DELETE
:
1257 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1259 error("Could not delete snapshot '%s': %d (%s)",
1260 snapshot_name
, ret
, strerror(-ret
));
1273 static int img_rebase(int argc
, char **argv
)
1275 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1276 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1278 const char *fmt
, *out_basefmt
, *out_baseimg
;
1282 /* Parse commandline parameters */
1288 c
= getopt(argc
, argv
, "uhf:F:b:");
1301 out_basefmt
= optarg
;
1304 out_baseimg
= optarg
;
1312 if ((optind
>= argc
) || !out_baseimg
) {
1315 filename
= argv
[optind
++];
1320 * Ignore the old backing file for unsafe rebase in case we want to correct
1321 * the reference to a renamed or moved backing file.
1323 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1324 bs
= bdrv_new_open(filename
, fmt
, flags
);
1329 /* Find the right drivers for the backing files */
1330 old_backing_drv
= NULL
;
1331 new_backing_drv
= NULL
;
1333 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1334 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1335 if (old_backing_drv
== NULL
) {
1336 error("Invalid format name: '%s'", bs
->backing_format
);
1342 if (out_basefmt
!= NULL
) {
1343 new_backing_drv
= bdrv_find_format(out_basefmt
);
1344 if (new_backing_drv
== NULL
) {
1345 error("Invalid format name: '%s'", out_basefmt
);
1351 /* For safe rebasing we need to compare old and new backing file */
1353 /* Make the compiler happy */
1354 bs_old_backing
= NULL
;
1355 bs_new_backing
= NULL
;
1357 char backing_name
[1024];
1359 bs_old_backing
= bdrv_new("old_backing");
1360 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1361 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1364 error("Could not open old backing file '%s'", backing_name
);
1368 bs_new_backing
= bdrv_new("new_backing");
1369 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1372 error("Could not open new backing file '%s'", out_baseimg
);
1378 * Check each unallocated cluster in the COW file. If it is unallocated,
1379 * accesses go to the backing file. We must therefore compare this cluster
1380 * in the old and new backing file, and if they differ we need to copy it
1381 * from the old backing file into the COW file.
1383 * If qemu-img crashes during this step, no harm is done. The content of
1384 * the image is the same as the original one at any time.
1387 uint64_t num_sectors
;
1393 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1394 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1396 bdrv_get_geometry(bs
, &num_sectors
);
1398 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1400 /* How many sectors can we handle with the next read? */
1401 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1402 n
= (IO_BUF_SIZE
/ 512);
1404 n
= num_sectors
- sector
;
1407 /* If the cluster is allocated, we don't need to take action */
1408 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1413 /* Read old and new backing file */
1414 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1416 error("error while reading from old backing file");
1419 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1421 error("error while reading from new backing file");
1425 /* If they differ, we need to write to the COW file */
1426 uint64_t written
= 0;
1428 while (written
< n
) {
1431 if (compare_sectors(buf_old
+ written
* 512,
1432 buf_new
+ written
* 512, n
- written
, &pnum
))
1434 ret
= bdrv_write(bs
, sector
+ written
,
1435 buf_old
+ written
* 512, pnum
);
1437 error("Error while writing to COW image: %s",
1452 * Change the backing file. All clusters that are different from the old
1453 * backing file are overwritten in the COW file now, so the visible content
1454 * doesn't change when we switch the backing file.
1456 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1457 if (ret
== -ENOSPC
) {
1458 error("Could not change the backing file to '%s': No space left in "
1459 "the file header", out_baseimg
);
1460 } else if (ret
< 0) {
1461 error("Could not change the backing file to '%s': %s",
1462 out_baseimg
, strerror(-ret
));
1466 * TODO At this point it is possible to check if any clusters that are
1467 * allocated in the COW file are the same in the backing file. If so, they
1468 * could be dropped from the COW file. Don't do this before switching the
1469 * backing file, in case of a crash this would lead to corruption.
1474 bdrv_delete(bs_old_backing
);
1475 bdrv_delete(bs_new_backing
);
1485 static int img_resize(int argc
, char **argv
)
1487 int c
, ret
, relative
;
1488 const char *filename
, *fmt
, *size
;
1489 int64_t n
, total_size
;
1490 BlockDriverState
*bs
= NULL
;
1491 QEMUOptionParameter
*param
;
1492 QEMUOptionParameter resize_options
[] = {
1494 .name
= BLOCK_OPT_SIZE
,
1496 .help
= "Virtual disk size"
1503 c
= getopt(argc
, argv
, "f:h");
1517 if (optind
+ 1 >= argc
) {
1520 filename
= argv
[optind
++];
1521 size
= argv
[optind
++];
1523 /* Choose grow, shrink, or absolute resize mode */
1539 param
= parse_option_parameters("", resize_options
, NULL
);
1540 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1541 /* Error message already printed when size parsing fails */
1545 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1546 free_option_parameters(param
);
1548 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1555 total_size
= bdrv_getlength(bs
) + n
* relative
;
1559 if (total_size
<= 0) {
1560 error("New image size must be positive");
1565 ret
= bdrv_truncate(bs
, total_size
);
1568 printf("Image resized.\n");
1571 error("This image format does not support resize");
1574 error("Image is read-only");
1577 error("Error resizing image (%d)", -ret
);
1590 static const img_cmd_t img_cmds
[] = {
1591 #define DEF(option, callback, arg_string) \
1592 { option, callback },
1593 #include "qemu-img-cmds.h"
1599 int main(int argc
, char **argv
)
1601 const img_cmd_t
*cmd
;
1602 const char *cmdname
;
1610 /* find the command */
1611 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1612 if (!strcmp(cmdname
, cmd
->name
)) {
1613 return cmd
->handler(argc
, argv
);