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:");
318 base_filename
= optarg
;
324 flags
|= BLOCK_FLAG_ENCRYPT
;
327 flags
|= BLOCK_FLAG_COMPAT6
;
335 /* Get the filename */
338 filename
= argv
[optind
++];
340 if (options
&& !strcmp(options
, "?")) {
341 ret
= print_block_option_help(filename
, fmt
);
345 /* Find driver and parse its options */
346 drv
= bdrv_find_format(fmt
);
348 error("Unknown file format '%s'", fmt
);
352 proto_drv
= bdrv_find_protocol(filename
);
354 error("Unknown protocol '%s'", filename
);
358 create_options
= append_option_parameters(create_options
,
359 drv
->create_options
);
360 create_options
= append_option_parameters(create_options
,
361 proto_drv
->create_options
);
363 /* Create parameter list with default values */
364 param
= parse_option_parameters("", create_options
, param
);
365 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
367 /* Parse -o options */
369 param
= parse_option_parameters(options
, create_options
, param
);
371 error("Invalid options for file format '%s'.", fmt
);
377 /* Add size to parameters */
379 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
382 /* Add old-style options to parameters */
383 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
388 // The size for the image must always be specified, with one exception:
389 // If we are using a backing file, we can obtain the size from there
390 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
392 QEMUOptionParameter
*backing_file
=
393 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
394 QEMUOptionParameter
*backing_fmt
=
395 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
397 if (backing_file
&& backing_file
->value
.s
) {
398 BlockDriverState
*bs
;
400 const char *fmt
= NULL
;
403 if (backing_fmt
&& backing_fmt
->value
.s
) {
404 if (bdrv_find_format(backing_fmt
->value
.s
)) {
405 fmt
= backing_fmt
->value
.s
;
407 error("Unknown backing file format '%s'",
408 backing_fmt
->value
.s
);
414 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
419 bdrv_get_geometry(bs
, &size
);
423 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
424 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
426 error("Image creation needs a size parameter");
432 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
433 print_option_parameters(param
);
436 ret
= bdrv_create(drv
, filename
, param
);
437 free_option_parameters(create_options
);
438 free_option_parameters(param
);
441 if (ret
== -ENOTSUP
) {
442 error("Formatting or formatting option not supported for file format '%s'", fmt
);
443 } else if (ret
== -EFBIG
) {
444 error("The image size is too large for file format '%s'", fmt
);
446 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
457 * Checks an image for consistency. Exit codes:
459 * 0 - Check completed, image is good
460 * 1 - Check not completed because of internal errors
461 * 2 - Check completed, image is corrupted
462 * 3 - Check completed, image has leaked clusters, but is good otherwise
464 static int img_check(int argc
, char **argv
)
467 const char *filename
, *fmt
;
468 BlockDriverState
*bs
;
469 BdrvCheckResult result
;
473 c
= getopt(argc
, argv
, "f:h");
487 filename
= argv
[optind
++];
489 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
493 ret
= bdrv_check(bs
, &result
);
495 if (ret
== -ENOTSUP
) {
496 error("This image format does not support checks");
501 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
502 printf("No errors were found on the image.\n");
504 if (result
.corruptions
) {
505 printf("\n%d errors were found on the image.\n"
506 "Data may be corrupted, or further writes to the image "
512 printf("\n%d leaked clusters were found on the image.\n"
513 "This means waste of disk space, but no harm to data.\n",
517 if (result
.check_errors
) {
518 printf("\n%d internal errors have occurred during the check.\n",
519 result
.check_errors
);
525 if (ret
< 0 || result
.check_errors
) {
526 printf("\nAn error has occurred during the check: %s\n"
527 "The check is not complete and may have missed error.\n",
532 if (result
.corruptions
) {
534 } else if (result
.leaks
) {
541 static int img_commit(int argc
, char **argv
)
544 const char *filename
, *fmt
;
545 BlockDriverState
*bs
;
549 c
= getopt(argc
, argv
, "f:h");
563 filename
= argv
[optind
++];
565 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
569 ret
= bdrv_commit(bs
);
572 printf("Image committed.\n");
575 error("No disk inserted");
578 error("Image is read-only");
581 error("Image is already committed");
584 error("Error while committing image");
595 static int is_not_zero(const uint8_t *sector
, int len
)
599 for(i
= 0;i
< len
; i
++) {
600 if (((uint32_t *)sector
)[i
] != 0)
607 * Returns true iff the first sector pointed to by 'buf' contains at least
610 * 'pnum' is set to the number of sectors (including and immediately following
611 * the first one) that are known to be in the same allocated/unallocated state.
613 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
621 v
= is_not_zero(buf
, 512);
622 for(i
= 1; i
< n
; i
++) {
624 if (v
!= is_not_zero(buf
, 512))
632 * Compares two buffers sector by sector. Returns 0 if the first sector of both
633 * buffers matches, non-zero otherwise.
635 * pnum is set to the number of sectors (including and immediately following
636 * the first one) that are known to have the same comparison result
638 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
648 res
= !!memcmp(buf1
, buf2
, 512);
649 for(i
= 1; i
< n
; i
++) {
653 if (!!memcmp(buf1
, buf2
, 512) != res
) {
662 #define IO_BUF_SIZE (2 * 1024 * 1024)
664 static int img_convert(int argc
, char **argv
)
666 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
667 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
668 BlockDriver
*drv
, *proto_drv
;
669 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
670 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
672 uint8_t * buf
= NULL
;
675 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
676 QEMUOptionParameter
*out_baseimg_param
;
677 char *options
= NULL
;
678 const char *snapshot_name
= NULL
;
685 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
699 out_baseimg
= optarg
;
702 flags
|= BLOCK_FLAG_COMPRESS
;
705 flags
|= BLOCK_FLAG_ENCRYPT
;
708 flags
|= BLOCK_FLAG_COMPAT6
;
714 snapshot_name
= optarg
;
719 bs_n
= argc
- optind
- 1;
720 if (bs_n
< 1) help();
722 out_filename
= argv
[argc
- 1];
724 if (options
&& !strcmp(options
, "?")) {
725 ret
= print_block_option_help(out_filename
, out_fmt
);
729 if (bs_n
> 1 && out_baseimg
) {
730 error("-B makes no sense when concatenating multiple input images");
735 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
738 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
739 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
741 error("Could not open '%s'", argv
[optind
+ bs_i
]);
745 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
746 total_sectors
+= bs_sectors
;
749 if (snapshot_name
!= NULL
) {
751 error("No support for concatenating multiple snapshot\n");
755 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
756 error("Failed to load snapshot\n");
762 /* Find driver and parse its options */
763 drv
= bdrv_find_format(out_fmt
);
765 error("Unknown file format '%s'", out_fmt
);
770 proto_drv
= bdrv_find_protocol(out_filename
);
772 error("Unknown protocol '%s'", out_filename
);
777 create_options
= append_option_parameters(create_options
,
778 drv
->create_options
);
779 create_options
= append_option_parameters(create_options
,
780 proto_drv
->create_options
);
783 param
= parse_option_parameters(options
, create_options
, param
);
785 error("Invalid options for file format '%s'.", out_fmt
);
790 param
= parse_option_parameters("", create_options
, param
);
793 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
794 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
799 /* Get backing file name if -o backing_file was used */
800 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
801 if (out_baseimg_param
) {
802 out_baseimg
= out_baseimg_param
->value
.s
;
805 /* Check if compression is supported */
806 if (flags
& BLOCK_FLAG_COMPRESS
) {
807 QEMUOptionParameter
*encryption
=
808 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
810 if (!drv
->bdrv_write_compressed
) {
811 error("Compression not supported for this file format");
816 if (encryption
&& encryption
->value
.n
) {
817 error("Compression and encryption not supported at the same time");
823 /* Create the new image */
824 ret
= bdrv_create(drv
, out_filename
, param
);
826 if (ret
== -ENOTSUP
) {
827 error("Formatting not supported for file format '%s'", out_fmt
);
828 } else if (ret
== -EFBIG
) {
829 error("The image size is too large for file format '%s'", out_fmt
);
831 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
836 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
837 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
845 bdrv_get_geometry(bs
[0], &bs_sectors
);
846 buf
= qemu_malloc(IO_BUF_SIZE
);
848 if (flags
& BLOCK_FLAG_COMPRESS
) {
849 ret
= bdrv_get_info(out_bs
, &bdi
);
851 error("could not get block driver info");
854 cluster_size
= bdi
.cluster_size
;
855 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
856 error("invalid cluster size");
860 cluster_sectors
= cluster_size
>> 9;
867 nb_sectors
= total_sectors
- sector_num
;
870 if (nb_sectors
>= cluster_sectors
)
875 bs_num
= sector_num
- bs_offset
;
876 assert (bs_num
>= 0);
879 while (remainder
> 0) {
881 while (bs_num
== bs_sectors
) {
883 assert (bs_i
< bs_n
);
884 bs_offset
+= bs_sectors
;
885 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
887 /* printf("changing part: sector_num=%" PRId64 ", "
888 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
889 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
891 assert (bs_num
< bs_sectors
);
893 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
895 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
897 error("error while reading");
906 assert (remainder
== 0);
908 if (n
< cluster_sectors
)
909 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
910 if (is_not_zero(buf
, cluster_size
)) {
911 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
914 error("error while compressing sector %" PRId64
,
921 /* signal EOF to align */
922 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
924 int has_zero_init
= bdrv_has_zero_init(out_bs
);
926 sector_num
= 0; // total number of sectors converted so far
928 nb_sectors
= total_sectors
- sector_num
;
931 if (nb_sectors
>= (IO_BUF_SIZE
/ 512))
932 n
= (IO_BUF_SIZE
/ 512);
936 while (sector_num
- bs_offset
>= bs_sectors
) {
938 assert (bs_i
< bs_n
);
939 bs_offset
+= bs_sectors
;
940 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
941 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
942 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
943 sector_num, bs_i, bs_offset, bs_sectors); */
946 if (n
> bs_offset
+ bs_sectors
- sector_num
)
947 n
= bs_offset
+ bs_sectors
- sector_num
;
950 /* If the output image is being created as a copy on write image,
951 assume that sectors which are unallocated in the input image
952 are present in both the output's and input's base images (no
953 need to copy them). */
955 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
960 /* The next 'n1' sectors are allocated in the input image. Copy
961 only those as they may be followed by unallocated sectors. */
968 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
970 error("error while reading");
973 /* NOTE: at the same time we convert, we do not write zero
974 sectors to have a chance to compress the image. Ideally, we
975 should add a specific call to have the info to go faster */
978 /* If the output image is being created as a copy on write image,
979 copy all sectors even the ones containing only NUL bytes,
980 because they may differ from the sectors in the base image.
982 If the output is to a host device, we also write out
983 sectors that are entirely 0, since whatever data was
984 already there is garbage, not 0s. */
985 if (!has_zero_init
|| out_baseimg
||
986 is_allocated_sectors(buf1
, n
, &n1
)) {
987 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
989 error("error while writing");
1000 free_option_parameters(create_options
);
1001 free_option_parameters(param
);
1004 bdrv_delete(out_bs
);
1007 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1009 bdrv_delete(bs
[bs_i
]);
1021 static int64_t get_allocated_file_size(const char *filename
)
1023 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1024 get_compressed_t get_compressed
;
1027 /* WinNT support GetCompressedFileSize to determine allocate size */
1028 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1029 if (get_compressed
) {
1031 low
= get_compressed(filename
, &high
);
1032 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1033 return (((int64_t) high
) << 32) + low
;
1036 if (_stati64(filename
, &st
) < 0)
1041 static int64_t get_allocated_file_size(const char *filename
)
1044 if (stat(filename
, &st
) < 0)
1046 return (int64_t)st
.st_blocks
* 512;
1050 static void dump_snapshots(BlockDriverState
*bs
)
1052 QEMUSnapshotInfo
*sn_tab
, *sn
;
1056 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1059 printf("Snapshot list:\n");
1060 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1061 for(i
= 0; i
< nb_sns
; i
++) {
1063 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1068 static int img_info(int argc
, char **argv
)
1071 const char *filename
, *fmt
;
1072 BlockDriverState
*bs
;
1073 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1074 uint64_t total_sectors
;
1075 int64_t allocated_size
;
1076 char backing_filename
[1024];
1077 char backing_filename2
[1024];
1078 BlockDriverInfo bdi
;
1082 c
= getopt(argc
, argv
, "f:h");
1096 filename
= argv
[optind
++];
1098 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1102 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1103 bdrv_get_geometry(bs
, &total_sectors
);
1104 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1105 allocated_size
= get_allocated_file_size(filename
);
1106 if (allocated_size
< 0)
1107 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1109 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1111 printf("image: %s\n"
1113 "virtual size: %s (%" PRId64
" bytes)\n"
1115 filename
, fmt_name
, size_buf
,
1116 (total_sectors
* 512),
1118 if (bdrv_is_encrypted(bs
))
1119 printf("encrypted: yes\n");
1120 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1121 if (bdi
.cluster_size
!= 0)
1122 printf("cluster_size: %d\n", bdi
.cluster_size
);
1124 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1125 if (backing_filename
[0] != '\0') {
1126 path_combine(backing_filename2
, sizeof(backing_filename2
),
1127 filename
, backing_filename
);
1128 printf("backing file: %s (actual path: %s)\n",
1137 #define SNAPSHOT_LIST 1
1138 #define SNAPSHOT_CREATE 2
1139 #define SNAPSHOT_APPLY 3
1140 #define SNAPSHOT_DELETE 4
1142 static int img_snapshot(int argc
, char **argv
)
1144 BlockDriverState
*bs
;
1145 QEMUSnapshotInfo sn
;
1146 char *filename
, *snapshot_name
= NULL
;
1147 int c
, ret
= 0, bdrv_oflags
;
1151 bdrv_oflags
= BDRV_O_RDWR
;
1152 /* Parse commandline parameters */
1154 c
= getopt(argc
, argv
, "la:c:d:h");
1166 action
= SNAPSHOT_LIST
;
1167 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1174 action
= SNAPSHOT_APPLY
;
1175 snapshot_name
= optarg
;
1182 action
= SNAPSHOT_CREATE
;
1183 snapshot_name
= optarg
;
1190 action
= SNAPSHOT_DELETE
;
1191 snapshot_name
= optarg
;
1198 filename
= argv
[optind
++];
1200 /* Open the image */
1201 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1206 /* Perform the requested action */
1212 case SNAPSHOT_CREATE
:
1213 memset(&sn
, 0, sizeof(sn
));
1214 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1216 qemu_gettimeofday(&tv
);
1217 sn
.date_sec
= tv
.tv_sec
;
1218 sn
.date_nsec
= tv
.tv_usec
* 1000;
1220 ret
= bdrv_snapshot_create(bs
, &sn
);
1222 error("Could not create snapshot '%s': %d (%s)",
1223 snapshot_name
, ret
, strerror(-ret
));
1226 case SNAPSHOT_APPLY
:
1227 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1229 error("Could not apply snapshot '%s': %d (%s)",
1230 snapshot_name
, ret
, strerror(-ret
));
1233 case SNAPSHOT_DELETE
:
1234 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1236 error("Could not delete snapshot '%s': %d (%s)",
1237 snapshot_name
, ret
, strerror(-ret
));
1249 static int img_rebase(int argc
, char **argv
)
1251 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1252 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1254 const char *fmt
, *out_basefmt
, *out_baseimg
;
1258 /* Parse commandline parameters */
1264 c
= getopt(argc
, argv
, "uhf:F:b:");
1275 out_basefmt
= optarg
;
1278 out_baseimg
= optarg
;
1286 if ((optind
>= argc
) || !out_baseimg
)
1288 filename
= argv
[optind
++];
1293 * Ignore the old backing file for unsafe rebase in case we want to correct
1294 * the reference to a renamed or moved backing file.
1296 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1297 bs
= bdrv_new_open(filename
, fmt
, flags
);
1302 /* Find the right drivers for the backing files */
1303 old_backing_drv
= NULL
;
1304 new_backing_drv
= NULL
;
1306 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1307 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1308 if (old_backing_drv
== NULL
) {
1309 error("Invalid format name: '%s'", bs
->backing_format
);
1315 if (out_basefmt
!= NULL
) {
1316 new_backing_drv
= bdrv_find_format(out_basefmt
);
1317 if (new_backing_drv
== NULL
) {
1318 error("Invalid format name: '%s'", out_basefmt
);
1324 /* For safe rebasing we need to compare old and new backing file */
1326 /* Make the compiler happy */
1327 bs_old_backing
= NULL
;
1328 bs_new_backing
= NULL
;
1330 char backing_name
[1024];
1332 bs_old_backing
= bdrv_new("old_backing");
1333 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1334 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1337 error("Could not open old backing file '%s'", backing_name
);
1341 bs_new_backing
= bdrv_new("new_backing");
1342 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1345 error("Could not open new backing file '%s'", out_baseimg
);
1351 * Check each unallocated cluster in the COW file. If it is unallocated,
1352 * accesses go to the backing file. We must therefore compare this cluster
1353 * in the old and new backing file, and if they differ we need to copy it
1354 * from the old backing file into the COW file.
1356 * If qemu-img crashes during this step, no harm is done. The content of
1357 * the image is the same as the original one at any time.
1360 uint64_t num_sectors
;
1366 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1367 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1369 bdrv_get_geometry(bs
, &num_sectors
);
1371 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1373 /* How many sectors can we handle with the next read? */
1374 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1375 n
= (IO_BUF_SIZE
/ 512);
1377 n
= num_sectors
- sector
;
1380 /* If the cluster is allocated, we don't need to take action */
1381 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1386 /* Read old and new backing file */
1387 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1389 error("error while reading from old backing file");
1392 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1394 error("error while reading from new backing file");
1398 /* If they differ, we need to write to the COW file */
1399 uint64_t written
= 0;
1401 while (written
< n
) {
1404 if (compare_sectors(buf_old
+ written
* 512,
1405 buf_new
+ written
* 512, n
- written
, &pnum
))
1407 ret
= bdrv_write(bs
, sector
+ written
,
1408 buf_old
+ written
* 512, pnum
);
1410 error("Error while writing to COW image: %s",
1425 * Change the backing file. All clusters that are different from the old
1426 * backing file are overwritten in the COW file now, so the visible content
1427 * doesn't change when we switch the backing file.
1429 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1430 if (ret
== -ENOSPC
) {
1431 error("Could not change the backing file to '%s': No space left in "
1432 "the file header", out_baseimg
);
1433 } else if (ret
< 0) {
1434 error("Could not change the backing file to '%s': %s",
1435 out_baseimg
, strerror(-ret
));
1439 * TODO At this point it is possible to check if any clusters that are
1440 * allocated in the COW file are the same in the backing file. If so, they
1441 * could be dropped from the COW file. Don't do this before switching the
1442 * backing file, in case of a crash this would lead to corruption.
1447 bdrv_delete(bs_old_backing
);
1448 bdrv_delete(bs_new_backing
);
1458 static int img_resize(int argc
, char **argv
)
1460 int c
, ret
, relative
;
1461 const char *filename
, *fmt
, *size
;
1462 int64_t n
, total_size
;
1463 BlockDriverState
*bs
;
1464 QEMUOptionParameter
*param
;
1465 QEMUOptionParameter resize_options
[] = {
1467 .name
= BLOCK_OPT_SIZE
,
1469 .help
= "Virtual disk size"
1476 c
= getopt(argc
, argv
, "f:h");
1489 if (optind
+ 1 >= argc
) {
1492 filename
= argv
[optind
++];
1493 size
= argv
[optind
++];
1495 /* Choose grow, shrink, or absolute resize mode */
1511 param
= parse_option_parameters("", resize_options
, NULL
);
1512 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1513 /* Error message already printed when size parsing fails */
1516 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1517 free_option_parameters(param
);
1519 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1525 total_size
= bdrv_getlength(bs
) + n
* relative
;
1529 if (total_size
<= 0) {
1530 error("New image size must be positive");
1535 ret
= bdrv_truncate(bs
, total_size
);
1538 printf("Image resized.\n");
1541 error("This image format does not support resize");
1544 error("Image is read-only");
1547 error("Error resizing image (%d)", -ret
);
1558 static const img_cmd_t img_cmds
[] = {
1559 #define DEF(option, callback, arg_string) \
1560 { option, callback },
1561 #include "qemu-img-cmds.h"
1567 int main(int argc
, char **argv
)
1569 const img_cmd_t
*cmd
;
1570 const char *cmdname
;
1578 /* find the command */
1579 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1580 if (!strcmp(cmdname
, cmd
->name
)) {
1581 return cmd
->handler(argc
, argv
);