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 uint64_t img_size
= -1;
286 const char *fmt
= "raw";
287 const char *base_fmt
= NULL
;
288 const char *filename
;
289 const char *base_filename
= NULL
;
290 BlockDriver
*drv
, *proto_drv
;
291 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
292 QEMUOptionParameter
*backing_fmt
= NULL
;
293 char *options
= NULL
;
296 c
= getopt(argc
, argv
, "F:b:f:he6o:");
309 base_filename
= optarg
;
315 error("qemu-img: option -e is deprecated, please use \'-o "
316 "encryption\' instead!");
319 error("qemu-img: option -6 is deprecated, please use \'-o "
320 "compat6\' instead!");
328 /* Get the filename */
329 if (optind
>= argc
) {
332 filename
= argv
[optind
++];
334 /* Get image size, if specified */
337 sval
= strtosz_suffix(argv
[optind
++], NULL
, STRTOSZ_DEFSUFFIX_B
);
339 error("Invalid image size specified! You may use k, M, G or "
341 error("kilobytes, megabytes, gigabytes and terabytes.");
345 img_size
= (uint64_t)sval
;
348 if (options
&& !strcmp(options
, "?")) {
349 ret
= print_block_option_help(filename
, fmt
);
353 /* Find driver and parse its options */
354 drv
= bdrv_find_format(fmt
);
356 error("Unknown file format '%s'", fmt
);
361 proto_drv
= bdrv_find_protocol(filename
);
363 error("Unknown protocol '%s'", filename
);
368 create_options
= append_option_parameters(create_options
,
369 drv
->create_options
);
370 create_options
= append_option_parameters(create_options
,
371 proto_drv
->create_options
);
373 /* Create parameter list with default values */
374 param
= parse_option_parameters("", create_options
, param
);
376 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
378 /* Parse -o options */
380 param
= parse_option_parameters(options
, create_options
, param
);
382 error("Invalid options for file format '%s'.", fmt
);
388 /* Add old-style options to parameters */
389 ret
= add_old_style_options(fmt
, param
, base_filename
, base_fmt
);
394 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
395 if (backing_fmt
&& backing_fmt
->value
.s
) {
396 if (!bdrv_find_format(backing_fmt
->value
.s
)) {
397 error("Unknown backing file format '%s'",
398 backing_fmt
->value
.s
);
404 // The size for the image must always be specified, with one exception:
405 // If we are using a backing file, we can obtain the size from there
406 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
408 QEMUOptionParameter
*backing_file
=
409 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
411 if (backing_file
&& backing_file
->value
.s
) {
412 BlockDriverState
*bs
;
414 const char *fmt
= NULL
;
417 if (backing_fmt
&& backing_fmt
->value
.s
) {
418 fmt
= backing_fmt
->value
.s
;
421 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
426 bdrv_get_geometry(bs
, &size
);
430 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
431 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
433 error("Image creation needs a size parameter");
439 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
440 print_option_parameters(param
);
443 ret
= bdrv_create(drv
, filename
, param
);
446 if (ret
== -ENOTSUP
) {
447 error("Formatting or formatting option not supported for file format '%s'", fmt
);
448 } else if (ret
== -EFBIG
) {
449 error("The image size is too large for file format '%s'", fmt
);
451 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
455 free_option_parameters(create_options
);
456 free_option_parameters(param
);
464 * Checks an image for consistency. Exit codes:
466 * 0 - Check completed, image is good
467 * 1 - Check not completed because of internal errors
468 * 2 - Check completed, image is corrupted
469 * 3 - Check completed, image has leaked clusters, but is good otherwise
471 static int img_check(int argc
, char **argv
)
474 const char *filename
, *fmt
;
475 BlockDriverState
*bs
;
476 BdrvCheckResult result
;
480 c
= getopt(argc
, argv
, "f:h");
494 if (optind
>= argc
) {
497 filename
= argv
[optind
++];
499 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
503 ret
= bdrv_check(bs
, &result
);
505 if (ret
== -ENOTSUP
) {
506 error("This image format does not support checks");
511 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
512 printf("No errors were found on the image.\n");
514 if (result
.corruptions
) {
515 printf("\n%d errors were found on the image.\n"
516 "Data may be corrupted, or further writes to the image "
522 printf("\n%d leaked clusters were found on the image.\n"
523 "This means waste of disk space, but no harm to data.\n",
527 if (result
.check_errors
) {
528 printf("\n%d internal errors have occurred during the check.\n",
529 result
.check_errors
);
535 if (ret
< 0 || result
.check_errors
) {
536 printf("\nAn error has occurred during the check: %s\n"
537 "The check is not complete and may have missed error.\n",
542 if (result
.corruptions
) {
544 } else if (result
.leaks
) {
551 static int img_commit(int argc
, char **argv
)
554 const char *filename
, *fmt
;
555 BlockDriverState
*bs
;
559 c
= getopt(argc
, argv
, "f:h");
573 if (optind
>= argc
) {
576 filename
= argv
[optind
++];
578 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
582 ret
= bdrv_commit(bs
);
585 printf("Image committed.\n");
588 error("No disk inserted");
591 error("Image is read-only");
594 error("Image is already committed");
597 error("Error while committing image");
608 static int is_not_zero(const uint8_t *sector
, int len
)
612 for(i
= 0;i
< len
; i
++) {
613 if (((uint32_t *)sector
)[i
] != 0)
620 * Returns true iff the first sector pointed to by 'buf' contains at least
623 * 'pnum' is set to the number of sectors (including and immediately following
624 * the first one) that are known to be in the same allocated/unallocated state.
626 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
634 v
= is_not_zero(buf
, 512);
635 for(i
= 1; i
< n
; i
++) {
637 if (v
!= is_not_zero(buf
, 512))
645 * Compares two buffers sector by sector. Returns 0 if the first sector of both
646 * buffers matches, non-zero otherwise.
648 * pnum is set to the number of sectors (including and immediately following
649 * the first one) that are known to have the same comparison result
651 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
661 res
= !!memcmp(buf1
, buf2
, 512);
662 for(i
= 1; i
< n
; i
++) {
666 if (!!memcmp(buf1
, buf2
, 512) != res
) {
675 #define IO_BUF_SIZE (2 * 1024 * 1024)
677 static int img_convert(int argc
, char **argv
)
679 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
680 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
681 BlockDriver
*drv
, *proto_drv
;
682 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
683 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
685 uint8_t * buf
= NULL
;
688 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
689 QEMUOptionParameter
*out_baseimg_param
;
690 char *options
= NULL
;
691 const char *snapshot_name
= NULL
;
698 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
714 out_baseimg
= optarg
;
720 error("qemu-img: option -e is deprecated, please use \'-o "
721 "encryption\' instead!");
724 error("qemu-img: option -6 is deprecated, please use \'-o "
725 "compat6\' instead!");
731 snapshot_name
= optarg
;
736 bs_n
= argc
- optind
- 1;
741 out_filename
= argv
[argc
- 1];
743 if (options
&& !strcmp(options
, "?")) {
744 ret
= print_block_option_help(out_filename
, out_fmt
);
748 if (bs_n
> 1 && out_baseimg
) {
749 error("-B makes no sense when concatenating multiple input images");
754 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
757 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
758 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
760 error("Could not open '%s'", argv
[optind
+ bs_i
]);
764 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
765 total_sectors
+= bs_sectors
;
768 if (snapshot_name
!= NULL
) {
770 error("No support for concatenating multiple snapshot\n");
774 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
775 error("Failed to load snapshot\n");
781 /* Find driver and parse its options */
782 drv
= bdrv_find_format(out_fmt
);
784 error("Unknown file format '%s'", out_fmt
);
789 proto_drv
= bdrv_find_protocol(out_filename
);
791 error("Unknown protocol '%s'", out_filename
);
796 create_options
= append_option_parameters(create_options
,
797 drv
->create_options
);
798 create_options
= append_option_parameters(create_options
,
799 proto_drv
->create_options
);
802 param
= parse_option_parameters(options
, create_options
, param
);
804 error("Invalid options for file format '%s'.", out_fmt
);
809 param
= parse_option_parameters("", create_options
, param
);
812 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
813 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
818 /* Get backing file name if -o backing_file was used */
819 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
820 if (out_baseimg_param
) {
821 out_baseimg
= out_baseimg_param
->value
.s
;
824 /* Check if compression is supported */
826 QEMUOptionParameter
*encryption
=
827 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
829 if (!drv
->bdrv_write_compressed
) {
830 error("Compression not supported for this file format");
835 if (encryption
&& encryption
->value
.n
) {
836 error("Compression and encryption not supported at the same time");
842 /* Create the new image */
843 ret
= bdrv_create(drv
, out_filename
, param
);
845 if (ret
== -ENOTSUP
) {
846 error("Formatting not supported for file format '%s'", out_fmt
);
847 } else if (ret
== -EFBIG
) {
848 error("The image size is too large for file format '%s'", out_fmt
);
850 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
855 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
856 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
864 bdrv_get_geometry(bs
[0], &bs_sectors
);
865 buf
= qemu_malloc(IO_BUF_SIZE
);
868 ret
= bdrv_get_info(out_bs
, &bdi
);
870 error("could not get block driver info");
873 cluster_size
= bdi
.cluster_size
;
874 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
875 error("invalid cluster size");
879 cluster_sectors
= cluster_size
>> 9;
886 nb_sectors
= total_sectors
- sector_num
;
889 if (nb_sectors
>= cluster_sectors
)
894 bs_num
= sector_num
- bs_offset
;
895 assert (bs_num
>= 0);
898 while (remainder
> 0) {
900 while (bs_num
== bs_sectors
) {
902 assert (bs_i
< bs_n
);
903 bs_offset
+= bs_sectors
;
904 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
906 /* printf("changing part: sector_num=%" PRId64 ", "
907 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
908 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
910 assert (bs_num
< bs_sectors
);
912 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
914 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
916 error("error while reading");
925 assert (remainder
== 0);
927 if (n
< cluster_sectors
) {
928 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
930 if (is_not_zero(buf
, cluster_size
)) {
931 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
934 error("error while compressing sector %" PRId64
,
941 /* signal EOF to align */
942 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
944 int has_zero_init
= bdrv_has_zero_init(out_bs
);
946 sector_num
= 0; // total number of sectors converted so far
948 nb_sectors
= total_sectors
- sector_num
;
949 if (nb_sectors
<= 0) {
952 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
953 n
= (IO_BUF_SIZE
/ 512);
958 while (sector_num
- bs_offset
>= bs_sectors
) {
960 assert (bs_i
< bs_n
);
961 bs_offset
+= bs_sectors
;
962 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
963 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
964 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
965 sector_num, bs_i, bs_offset, bs_sectors); */
968 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
969 n
= bs_offset
+ bs_sectors
- sector_num
;
973 /* If the output image is being created as a copy on write image,
974 assume that sectors which are unallocated in the input image
975 are present in both the output's and input's base images (no
976 need to copy them). */
978 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
983 /* The next 'n1' sectors are allocated in the input image. Copy
984 only those as they may be followed by unallocated sectors. */
991 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
993 error("error while reading");
996 /* NOTE: at the same time we convert, we do not write zero
997 sectors to have a chance to compress the image. Ideally, we
998 should add a specific call to have the info to go faster */
1001 /* If the output image is being created as a copy on write image,
1002 copy all sectors even the ones containing only NUL bytes,
1003 because they may differ from the sectors in the base image.
1005 If the output is to a host device, we also write out
1006 sectors that are entirely 0, since whatever data was
1007 already there is garbage, not 0s. */
1008 if (!has_zero_init
|| out_baseimg
||
1009 is_allocated_sectors(buf1
, n
, &n1
)) {
1010 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1012 error("error while writing");
1023 free_option_parameters(create_options
);
1024 free_option_parameters(param
);
1027 bdrv_delete(out_bs
);
1030 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1032 bdrv_delete(bs
[bs_i
]);
1044 static int64_t get_allocated_file_size(const char *filename
)
1046 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1047 get_compressed_t get_compressed
;
1050 /* WinNT support GetCompressedFileSize to determine allocate size */
1051 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1052 if (get_compressed
) {
1054 low
= get_compressed(filename
, &high
);
1055 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1056 return (((int64_t) high
) << 32) + low
;
1059 if (_stati64(filename
, &st
) < 0)
1064 static int64_t get_allocated_file_size(const char *filename
)
1067 if (stat(filename
, &st
) < 0)
1069 return (int64_t)st
.st_blocks
* 512;
1073 static void dump_snapshots(BlockDriverState
*bs
)
1075 QEMUSnapshotInfo
*sn_tab
, *sn
;
1079 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1082 printf("Snapshot list:\n");
1083 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1084 for(i
= 0; i
< nb_sns
; i
++) {
1086 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1091 static int img_info(int argc
, char **argv
)
1094 const char *filename
, *fmt
;
1095 BlockDriverState
*bs
;
1096 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1097 uint64_t total_sectors
;
1098 int64_t allocated_size
;
1099 char backing_filename
[1024];
1100 char backing_filename2
[1024];
1101 BlockDriverInfo bdi
;
1105 c
= getopt(argc
, argv
, "f:h");
1119 if (optind
>= argc
) {
1122 filename
= argv
[optind
++];
1124 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1128 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1129 bdrv_get_geometry(bs
, &total_sectors
);
1130 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1131 allocated_size
= get_allocated_file_size(filename
);
1132 if (allocated_size
< 0) {
1133 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1135 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1138 printf("image: %s\n"
1140 "virtual size: %s (%" PRId64
" bytes)\n"
1142 filename
, fmt_name
, size_buf
,
1143 (total_sectors
* 512),
1145 if (bdrv_is_encrypted(bs
)) {
1146 printf("encrypted: yes\n");
1148 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1149 if (bdi
.cluster_size
!= 0) {
1150 printf("cluster_size: %d\n", bdi
.cluster_size
);
1153 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1154 if (backing_filename
[0] != '\0') {
1155 path_combine(backing_filename2
, sizeof(backing_filename2
),
1156 filename
, backing_filename
);
1157 printf("backing file: %s (actual path: %s)\n",
1166 #define SNAPSHOT_LIST 1
1167 #define SNAPSHOT_CREATE 2
1168 #define SNAPSHOT_APPLY 3
1169 #define SNAPSHOT_DELETE 4
1171 static int img_snapshot(int argc
, char **argv
)
1173 BlockDriverState
*bs
;
1174 QEMUSnapshotInfo sn
;
1175 char *filename
, *snapshot_name
= NULL
;
1176 int c
, ret
= 0, bdrv_oflags
;
1180 bdrv_oflags
= BDRV_O_RDWR
;
1181 /* Parse commandline parameters */
1183 c
= getopt(argc
, argv
, "la:c:d:h");
1197 action
= SNAPSHOT_LIST
;
1198 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1205 action
= SNAPSHOT_APPLY
;
1206 snapshot_name
= optarg
;
1213 action
= SNAPSHOT_CREATE
;
1214 snapshot_name
= optarg
;
1221 action
= SNAPSHOT_DELETE
;
1222 snapshot_name
= optarg
;
1227 if (optind
>= argc
) {
1230 filename
= argv
[optind
++];
1232 /* Open the image */
1233 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1238 /* Perform the requested action */
1244 case SNAPSHOT_CREATE
:
1245 memset(&sn
, 0, sizeof(sn
));
1246 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1248 qemu_gettimeofday(&tv
);
1249 sn
.date_sec
= tv
.tv_sec
;
1250 sn
.date_nsec
= tv
.tv_usec
* 1000;
1252 ret
= bdrv_snapshot_create(bs
, &sn
);
1254 error("Could not create snapshot '%s': %d (%s)",
1255 snapshot_name
, ret
, strerror(-ret
));
1259 case SNAPSHOT_APPLY
:
1260 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1262 error("Could not apply snapshot '%s': %d (%s)",
1263 snapshot_name
, ret
, strerror(-ret
));
1267 case SNAPSHOT_DELETE
:
1268 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1270 error("Could not delete snapshot '%s': %d (%s)",
1271 snapshot_name
, ret
, strerror(-ret
));
1284 static int img_rebase(int argc
, char **argv
)
1286 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1287 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1289 const char *fmt
, *out_basefmt
, *out_baseimg
;
1293 /* Parse commandline parameters */
1299 c
= getopt(argc
, argv
, "uhf:F:b:");
1312 out_basefmt
= optarg
;
1315 out_baseimg
= optarg
;
1323 if ((optind
>= argc
) || !out_baseimg
) {
1326 filename
= argv
[optind
++];
1331 * Ignore the old backing file for unsafe rebase in case we want to correct
1332 * the reference to a renamed or moved backing file.
1334 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1335 bs
= bdrv_new_open(filename
, fmt
, flags
);
1340 /* Find the right drivers for the backing files */
1341 old_backing_drv
= NULL
;
1342 new_backing_drv
= NULL
;
1344 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1345 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1346 if (old_backing_drv
== NULL
) {
1347 error("Invalid format name: '%s'", bs
->backing_format
);
1353 if (out_basefmt
!= NULL
) {
1354 new_backing_drv
= bdrv_find_format(out_basefmt
);
1355 if (new_backing_drv
== NULL
) {
1356 error("Invalid format name: '%s'", out_basefmt
);
1362 /* For safe rebasing we need to compare old and new backing file */
1364 /* Make the compiler happy */
1365 bs_old_backing
= NULL
;
1366 bs_new_backing
= NULL
;
1368 char backing_name
[1024];
1370 bs_old_backing
= bdrv_new("old_backing");
1371 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1372 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1375 error("Could not open old backing file '%s'", backing_name
);
1379 bs_new_backing
= bdrv_new("new_backing");
1380 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1383 error("Could not open new backing file '%s'", out_baseimg
);
1389 * Check each unallocated cluster in the COW file. If it is unallocated,
1390 * accesses go to the backing file. We must therefore compare this cluster
1391 * in the old and new backing file, and if they differ we need to copy it
1392 * from the old backing file into the COW file.
1394 * If qemu-img crashes during this step, no harm is done. The content of
1395 * the image is the same as the original one at any time.
1398 uint64_t num_sectors
;
1404 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1405 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1407 bdrv_get_geometry(bs
, &num_sectors
);
1409 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1411 /* How many sectors can we handle with the next read? */
1412 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1413 n
= (IO_BUF_SIZE
/ 512);
1415 n
= num_sectors
- sector
;
1418 /* If the cluster is allocated, we don't need to take action */
1419 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1424 /* Read old and new backing file */
1425 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1427 error("error while reading from old backing file");
1430 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1432 error("error while reading from new backing file");
1436 /* If they differ, we need to write to the COW file */
1437 uint64_t written
= 0;
1439 while (written
< n
) {
1442 if (compare_sectors(buf_old
+ written
* 512,
1443 buf_new
+ written
* 512, n
- written
, &pnum
))
1445 ret
= bdrv_write(bs
, sector
+ written
,
1446 buf_old
+ written
* 512, pnum
);
1448 error("Error while writing to COW image: %s",
1463 * Change the backing file. All clusters that are different from the old
1464 * backing file are overwritten in the COW file now, so the visible content
1465 * doesn't change when we switch the backing file.
1467 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1468 if (ret
== -ENOSPC
) {
1469 error("Could not change the backing file to '%s': No space left in "
1470 "the file header", out_baseimg
);
1471 } else if (ret
< 0) {
1472 error("Could not change the backing file to '%s': %s",
1473 out_baseimg
, strerror(-ret
));
1477 * TODO At this point it is possible to check if any clusters that are
1478 * allocated in the COW file are the same in the backing file. If so, they
1479 * could be dropped from the COW file. Don't do this before switching the
1480 * backing file, in case of a crash this would lead to corruption.
1485 bdrv_delete(bs_old_backing
);
1486 bdrv_delete(bs_new_backing
);
1496 static int img_resize(int argc
, char **argv
)
1498 int c
, ret
, relative
;
1499 const char *filename
, *fmt
, *size
;
1500 int64_t n
, total_size
;
1501 BlockDriverState
*bs
= NULL
;
1502 QEMUOptionParameter
*param
;
1503 QEMUOptionParameter resize_options
[] = {
1505 .name
= BLOCK_OPT_SIZE
,
1507 .help
= "Virtual disk size"
1514 c
= getopt(argc
, argv
, "f:h");
1528 if (optind
+ 1 >= argc
) {
1531 filename
= argv
[optind
++];
1532 size
= argv
[optind
++];
1534 /* Choose grow, shrink, or absolute resize mode */
1550 param
= parse_option_parameters("", resize_options
, NULL
);
1551 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1552 /* Error message already printed when size parsing fails */
1556 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1557 free_option_parameters(param
);
1559 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1566 total_size
= bdrv_getlength(bs
) + n
* relative
;
1570 if (total_size
<= 0) {
1571 error("New image size must be positive");
1576 ret
= bdrv_truncate(bs
, total_size
);
1579 printf("Image resized.\n");
1582 error("This image format does not support resize");
1585 error("Image is read-only");
1588 error("Error resizing image (%d)", -ret
);
1601 static const img_cmd_t img_cmds
[] = {
1602 #define DEF(option, callback, arg_string) \
1603 { option, callback },
1604 #include "qemu-img-cmds.h"
1610 int main(int argc
, char **argv
)
1612 const img_cmd_t
*cmd
;
1613 const char *cmdname
;
1621 /* find the command */
1622 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1623 if (!strcmp(cmdname
, cmd
->name
)) {
1624 return cmd
->handler(argc
, argv
);