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
);
356 proto_drv
= bdrv_find_protocol(filename
);
358 error("Unknown protocol '%s'", filename
);
363 create_options
= append_option_parameters(create_options
,
364 drv
->create_options
);
365 create_options
= append_option_parameters(create_options
,
366 proto_drv
->create_options
);
368 /* Create parameter list with default values */
369 param
= parse_option_parameters("", create_options
, param
);
370 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
372 /* Parse -o options */
374 param
= parse_option_parameters(options
, create_options
, param
);
376 error("Invalid options for file format '%s'.", fmt
);
382 /* Add size to parameters */
384 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
387 /* Add old-style options to parameters */
388 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
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
);
399 QEMUOptionParameter
*backing_fmt
=
400 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
402 if (backing_file
&& backing_file
->value
.s
) {
403 BlockDriverState
*bs
;
405 const char *fmt
= NULL
;
408 if (backing_fmt
&& backing_fmt
->value
.s
) {
409 if (bdrv_find_format(backing_fmt
->value
.s
)) {
410 fmt
= backing_fmt
->value
.s
;
412 error("Unknown backing file format '%s'",
413 backing_fmt
->value
.s
);
419 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
424 bdrv_get_geometry(bs
, &size
);
428 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
429 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
431 error("Image creation needs a size parameter");
437 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
438 print_option_parameters(param
);
441 ret
= bdrv_create(drv
, filename
, param
);
442 free_option_parameters(create_options
);
443 free_option_parameters(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
));
462 * Checks an image for consistency. Exit codes:
464 * 0 - Check completed, image is good
465 * 1 - Check not completed because of internal errors
466 * 2 - Check completed, image is corrupted
467 * 3 - Check completed, image has leaked clusters, but is good otherwise
469 static int img_check(int argc
, char **argv
)
472 const char *filename
, *fmt
;
473 BlockDriverState
*bs
;
474 BdrvCheckResult result
;
478 c
= getopt(argc
, argv
, "f:h");
492 if (optind
>= argc
) {
495 filename
= argv
[optind
++];
497 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
501 ret
= bdrv_check(bs
, &result
);
503 if (ret
== -ENOTSUP
) {
504 error("This image format does not support checks");
509 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
510 printf("No errors were found on the image.\n");
512 if (result
.corruptions
) {
513 printf("\n%d errors were found on the image.\n"
514 "Data may be corrupted, or further writes to the image "
520 printf("\n%d leaked clusters were found on the image.\n"
521 "This means waste of disk space, but no harm to data.\n",
525 if (result
.check_errors
) {
526 printf("\n%d internal errors have occurred during the check.\n",
527 result
.check_errors
);
533 if (ret
< 0 || result
.check_errors
) {
534 printf("\nAn error has occurred during the check: %s\n"
535 "The check is not complete and may have missed error.\n",
540 if (result
.corruptions
) {
542 } else if (result
.leaks
) {
549 static int img_commit(int argc
, char **argv
)
552 const char *filename
, *fmt
;
553 BlockDriverState
*bs
;
557 c
= getopt(argc
, argv
, "f:h");
571 if (optind
>= argc
) {
574 filename
= argv
[optind
++];
576 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
580 ret
= bdrv_commit(bs
);
583 printf("Image committed.\n");
586 error("No disk inserted");
589 error("Image is read-only");
592 error("Image is already committed");
595 error("Error while committing image");
606 static int is_not_zero(const uint8_t *sector
, int len
)
610 for(i
= 0;i
< len
; i
++) {
611 if (((uint32_t *)sector
)[i
] != 0)
618 * Returns true iff the first sector pointed to by 'buf' contains at least
621 * 'pnum' is set to the number of sectors (including and immediately following
622 * the first one) that are known to be in the same allocated/unallocated state.
624 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
632 v
= is_not_zero(buf
, 512);
633 for(i
= 1; i
< n
; i
++) {
635 if (v
!= is_not_zero(buf
, 512))
643 * Compares two buffers sector by sector. Returns 0 if the first sector of both
644 * buffers matches, non-zero otherwise.
646 * pnum is set to the number of sectors (including and immediately following
647 * the first one) that are known to have the same comparison result
649 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
659 res
= !!memcmp(buf1
, buf2
, 512);
660 for(i
= 1; i
< n
; i
++) {
664 if (!!memcmp(buf1
, buf2
, 512) != res
) {
673 #define IO_BUF_SIZE (2 * 1024 * 1024)
675 static int img_convert(int argc
, char **argv
)
677 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
678 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
679 BlockDriver
*drv
, *proto_drv
;
680 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
681 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
683 uint8_t * buf
= NULL
;
686 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
687 QEMUOptionParameter
*out_baseimg_param
;
688 char *options
= NULL
;
689 const char *snapshot_name
= NULL
;
696 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
712 out_baseimg
= optarg
;
715 flags
|= BLOCK_FLAG_COMPRESS
;
718 flags
|= BLOCK_FLAG_ENCRYPT
;
721 flags
|= BLOCK_FLAG_COMPAT6
;
727 snapshot_name
= optarg
;
732 bs_n
= argc
- optind
- 1;
737 out_filename
= argv
[argc
- 1];
739 if (options
&& !strcmp(options
, "?")) {
740 ret
= print_block_option_help(out_filename
, out_fmt
);
744 if (bs_n
> 1 && out_baseimg
) {
745 error("-B makes no sense when concatenating multiple input images");
750 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
753 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
754 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
756 error("Could not open '%s'", argv
[optind
+ bs_i
]);
760 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
761 total_sectors
+= bs_sectors
;
764 if (snapshot_name
!= NULL
) {
766 error("No support for concatenating multiple snapshot\n");
770 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
771 error("Failed to load snapshot\n");
777 /* Find driver and parse its options */
778 drv
= bdrv_find_format(out_fmt
);
780 error("Unknown file format '%s'", out_fmt
);
785 proto_drv
= bdrv_find_protocol(out_filename
);
787 error("Unknown protocol '%s'", out_filename
);
792 create_options
= append_option_parameters(create_options
,
793 drv
->create_options
);
794 create_options
= append_option_parameters(create_options
,
795 proto_drv
->create_options
);
798 param
= parse_option_parameters(options
, create_options
, param
);
800 error("Invalid options for file format '%s'.", out_fmt
);
805 param
= parse_option_parameters("", create_options
, param
);
808 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
809 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
814 /* Get backing file name if -o backing_file was used */
815 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
816 if (out_baseimg_param
) {
817 out_baseimg
= out_baseimg_param
->value
.s
;
820 /* Check if compression is supported */
821 if (flags
& BLOCK_FLAG_COMPRESS
) {
822 QEMUOptionParameter
*encryption
=
823 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
825 if (!drv
->bdrv_write_compressed
) {
826 error("Compression not supported for this file format");
831 if (encryption
&& encryption
->value
.n
) {
832 error("Compression and encryption not supported at the same time");
838 /* Create the new image */
839 ret
= bdrv_create(drv
, out_filename
, param
);
841 if (ret
== -ENOTSUP
) {
842 error("Formatting not supported for file format '%s'", out_fmt
);
843 } else if (ret
== -EFBIG
) {
844 error("The image size is too large for file format '%s'", out_fmt
);
846 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
851 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
852 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
860 bdrv_get_geometry(bs
[0], &bs_sectors
);
861 buf
= qemu_malloc(IO_BUF_SIZE
);
863 if (flags
& BLOCK_FLAG_COMPRESS
) {
864 ret
= bdrv_get_info(out_bs
, &bdi
);
866 error("could not get block driver info");
869 cluster_size
= bdi
.cluster_size
;
870 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
871 error("invalid cluster size");
875 cluster_sectors
= cluster_size
>> 9;
882 nb_sectors
= total_sectors
- sector_num
;
885 if (nb_sectors
>= cluster_sectors
)
890 bs_num
= sector_num
- bs_offset
;
891 assert (bs_num
>= 0);
894 while (remainder
> 0) {
896 while (bs_num
== bs_sectors
) {
898 assert (bs_i
< bs_n
);
899 bs_offset
+= bs_sectors
;
900 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
902 /* printf("changing part: sector_num=%" PRId64 ", "
903 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
904 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
906 assert (bs_num
< bs_sectors
);
908 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
910 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
912 error("error while reading");
921 assert (remainder
== 0);
923 if (n
< cluster_sectors
) {
924 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
926 if (is_not_zero(buf
, cluster_size
)) {
927 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
930 error("error while compressing sector %" PRId64
,
937 /* signal EOF to align */
938 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
940 int has_zero_init
= bdrv_has_zero_init(out_bs
);
942 sector_num
= 0; // total number of sectors converted so far
944 nb_sectors
= total_sectors
- sector_num
;
945 if (nb_sectors
<= 0) {
948 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
949 n
= (IO_BUF_SIZE
/ 512);
954 while (sector_num
- bs_offset
>= bs_sectors
) {
956 assert (bs_i
< bs_n
);
957 bs_offset
+= bs_sectors
;
958 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
959 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
960 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
961 sector_num, bs_i, bs_offset, bs_sectors); */
964 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
965 n
= bs_offset
+ bs_sectors
- sector_num
;
969 /* If the output image is being created as a copy on write image,
970 assume that sectors which are unallocated in the input image
971 are present in both the output's and input's base images (no
972 need to copy them). */
974 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
979 /* The next 'n1' sectors are allocated in the input image. Copy
980 only those as they may be followed by unallocated sectors. */
987 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
989 error("error while reading");
992 /* NOTE: at the same time we convert, we do not write zero
993 sectors to have a chance to compress the image. Ideally, we
994 should add a specific call to have the info to go faster */
997 /* If the output image is being created as a copy on write image,
998 copy all sectors even the ones containing only NUL bytes,
999 because they may differ from the sectors in the base image.
1001 If the output is to a host device, we also write out
1002 sectors that are entirely 0, since whatever data was
1003 already there is garbage, not 0s. */
1004 if (!has_zero_init
|| out_baseimg
||
1005 is_allocated_sectors(buf1
, n
, &n1
)) {
1006 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1008 error("error while writing");
1019 free_option_parameters(create_options
);
1020 free_option_parameters(param
);
1023 bdrv_delete(out_bs
);
1026 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1028 bdrv_delete(bs
[bs_i
]);
1040 static int64_t get_allocated_file_size(const char *filename
)
1042 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1043 get_compressed_t get_compressed
;
1046 /* WinNT support GetCompressedFileSize to determine allocate size */
1047 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1048 if (get_compressed
) {
1050 low
= get_compressed(filename
, &high
);
1051 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1052 return (((int64_t) high
) << 32) + low
;
1055 if (_stati64(filename
, &st
) < 0)
1060 static int64_t get_allocated_file_size(const char *filename
)
1063 if (stat(filename
, &st
) < 0)
1065 return (int64_t)st
.st_blocks
* 512;
1069 static void dump_snapshots(BlockDriverState
*bs
)
1071 QEMUSnapshotInfo
*sn_tab
, *sn
;
1075 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1078 printf("Snapshot list:\n");
1079 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1080 for(i
= 0; i
< nb_sns
; i
++) {
1082 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1087 static int img_info(int argc
, char **argv
)
1090 const char *filename
, *fmt
;
1091 BlockDriverState
*bs
;
1092 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1093 uint64_t total_sectors
;
1094 int64_t allocated_size
;
1095 char backing_filename
[1024];
1096 char backing_filename2
[1024];
1097 BlockDriverInfo bdi
;
1101 c
= getopt(argc
, argv
, "f:h");
1115 if (optind
>= argc
) {
1118 filename
= argv
[optind
++];
1120 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1124 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1125 bdrv_get_geometry(bs
, &total_sectors
);
1126 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1127 allocated_size
= get_allocated_file_size(filename
);
1128 if (allocated_size
< 0) {
1129 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1131 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1134 printf("image: %s\n"
1136 "virtual size: %s (%" PRId64
" bytes)\n"
1138 filename
, fmt_name
, size_buf
,
1139 (total_sectors
* 512),
1141 if (bdrv_is_encrypted(bs
)) {
1142 printf("encrypted: yes\n");
1144 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1145 if (bdi
.cluster_size
!= 0) {
1146 printf("cluster_size: %d\n", bdi
.cluster_size
);
1149 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1150 if (backing_filename
[0] != '\0') {
1151 path_combine(backing_filename2
, sizeof(backing_filename2
),
1152 filename
, backing_filename
);
1153 printf("backing file: %s (actual path: %s)\n",
1162 #define SNAPSHOT_LIST 1
1163 #define SNAPSHOT_CREATE 2
1164 #define SNAPSHOT_APPLY 3
1165 #define SNAPSHOT_DELETE 4
1167 static int img_snapshot(int argc
, char **argv
)
1169 BlockDriverState
*bs
;
1170 QEMUSnapshotInfo sn
;
1171 char *filename
, *snapshot_name
= NULL
;
1172 int c
, ret
= 0, bdrv_oflags
;
1176 bdrv_oflags
= BDRV_O_RDWR
;
1177 /* Parse commandline parameters */
1179 c
= getopt(argc
, argv
, "la:c:d:h");
1193 action
= SNAPSHOT_LIST
;
1194 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1201 action
= SNAPSHOT_APPLY
;
1202 snapshot_name
= optarg
;
1209 action
= SNAPSHOT_CREATE
;
1210 snapshot_name
= optarg
;
1217 action
= SNAPSHOT_DELETE
;
1218 snapshot_name
= optarg
;
1223 if (optind
>= argc
) {
1226 filename
= argv
[optind
++];
1228 /* Open the image */
1229 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1234 /* Perform the requested action */
1240 case SNAPSHOT_CREATE
:
1241 memset(&sn
, 0, sizeof(sn
));
1242 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1244 qemu_gettimeofday(&tv
);
1245 sn
.date_sec
= tv
.tv_sec
;
1246 sn
.date_nsec
= tv
.tv_usec
* 1000;
1248 ret
= bdrv_snapshot_create(bs
, &sn
);
1250 error("Could not create snapshot '%s': %d (%s)",
1251 snapshot_name
, ret
, strerror(-ret
));
1255 case SNAPSHOT_APPLY
:
1256 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1258 error("Could not apply snapshot '%s': %d (%s)",
1259 snapshot_name
, ret
, strerror(-ret
));
1263 case SNAPSHOT_DELETE
:
1264 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1266 error("Could not delete snapshot '%s': %d (%s)",
1267 snapshot_name
, ret
, strerror(-ret
));
1280 static int img_rebase(int argc
, char **argv
)
1282 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1283 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1285 const char *fmt
, *out_basefmt
, *out_baseimg
;
1289 /* Parse commandline parameters */
1295 c
= getopt(argc
, argv
, "uhf:F:b:");
1308 out_basefmt
= optarg
;
1311 out_baseimg
= optarg
;
1319 if ((optind
>= argc
) || !out_baseimg
) {
1322 filename
= argv
[optind
++];
1327 * Ignore the old backing file for unsafe rebase in case we want to correct
1328 * the reference to a renamed or moved backing file.
1330 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1331 bs
= bdrv_new_open(filename
, fmt
, flags
);
1336 /* Find the right drivers for the backing files */
1337 old_backing_drv
= NULL
;
1338 new_backing_drv
= NULL
;
1340 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1341 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1342 if (old_backing_drv
== NULL
) {
1343 error("Invalid format name: '%s'", bs
->backing_format
);
1349 if (out_basefmt
!= NULL
) {
1350 new_backing_drv
= bdrv_find_format(out_basefmt
);
1351 if (new_backing_drv
== NULL
) {
1352 error("Invalid format name: '%s'", out_basefmt
);
1358 /* For safe rebasing we need to compare old and new backing file */
1360 /* Make the compiler happy */
1361 bs_old_backing
= NULL
;
1362 bs_new_backing
= NULL
;
1364 char backing_name
[1024];
1366 bs_old_backing
= bdrv_new("old_backing");
1367 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1368 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1371 error("Could not open old backing file '%s'", backing_name
);
1375 bs_new_backing
= bdrv_new("new_backing");
1376 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1379 error("Could not open new backing file '%s'", out_baseimg
);
1385 * Check each unallocated cluster in the COW file. If it is unallocated,
1386 * accesses go to the backing file. We must therefore compare this cluster
1387 * in the old and new backing file, and if they differ we need to copy it
1388 * from the old backing file into the COW file.
1390 * If qemu-img crashes during this step, no harm is done. The content of
1391 * the image is the same as the original one at any time.
1394 uint64_t num_sectors
;
1400 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1401 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1403 bdrv_get_geometry(bs
, &num_sectors
);
1405 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1407 /* How many sectors can we handle with the next read? */
1408 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1409 n
= (IO_BUF_SIZE
/ 512);
1411 n
= num_sectors
- sector
;
1414 /* If the cluster is allocated, we don't need to take action */
1415 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1420 /* Read old and new backing file */
1421 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1423 error("error while reading from old backing file");
1426 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1428 error("error while reading from new backing file");
1432 /* If they differ, we need to write to the COW file */
1433 uint64_t written
= 0;
1435 while (written
< n
) {
1438 if (compare_sectors(buf_old
+ written
* 512,
1439 buf_new
+ written
* 512, n
- written
, &pnum
))
1441 ret
= bdrv_write(bs
, sector
+ written
,
1442 buf_old
+ written
* 512, pnum
);
1444 error("Error while writing to COW image: %s",
1459 * Change the backing file. All clusters that are different from the old
1460 * backing file are overwritten in the COW file now, so the visible content
1461 * doesn't change when we switch the backing file.
1463 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1464 if (ret
== -ENOSPC
) {
1465 error("Could not change the backing file to '%s': No space left in "
1466 "the file header", out_baseimg
);
1467 } else if (ret
< 0) {
1468 error("Could not change the backing file to '%s': %s",
1469 out_baseimg
, strerror(-ret
));
1473 * TODO At this point it is possible to check if any clusters that are
1474 * allocated in the COW file are the same in the backing file. If so, they
1475 * could be dropped from the COW file. Don't do this before switching the
1476 * backing file, in case of a crash this would lead to corruption.
1481 bdrv_delete(bs_old_backing
);
1482 bdrv_delete(bs_new_backing
);
1492 static int img_resize(int argc
, char **argv
)
1494 int c
, ret
, relative
;
1495 const char *filename
, *fmt
, *size
;
1496 int64_t n
, total_size
;
1497 BlockDriverState
*bs
= NULL
;
1498 QEMUOptionParameter
*param
;
1499 QEMUOptionParameter resize_options
[] = {
1501 .name
= BLOCK_OPT_SIZE
,
1503 .help
= "Virtual disk size"
1510 c
= getopt(argc
, argv
, "f:h");
1524 if (optind
+ 1 >= argc
) {
1527 filename
= argv
[optind
++];
1528 size
= argv
[optind
++];
1530 /* Choose grow, shrink, or absolute resize mode */
1546 param
= parse_option_parameters("", resize_options
, NULL
);
1547 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1548 /* Error message already printed when size parsing fails */
1552 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1553 free_option_parameters(param
);
1555 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1562 total_size
= bdrv_getlength(bs
) + n
* relative
;
1566 if (total_size
<= 0) {
1567 error("New image size must be positive");
1572 ret
= bdrv_truncate(bs
, total_size
);
1575 printf("Image resized.\n");
1578 error("This image format does not support resize");
1581 error("Image is read-only");
1584 error("Error resizing image (%d)", -ret
);
1597 static const img_cmd_t img_cmds
[] = {
1598 #define DEF(option, callback, arg_string) \
1599 { option, callback },
1600 #include "qemu-img-cmds.h"
1606 int main(int argc
, char **argv
)
1608 const img_cmd_t
*cmd
;
1609 const char *cmdname
;
1617 /* find the command */
1618 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1619 if (!strcmp(cmdname
, cmd
->name
)) {
1620 return cmd
->handler(argc
, argv
);