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:");
319 base_filename
= optarg
;
325 flags
|= BLOCK_FLAG_ENCRYPT
;
328 flags
|= BLOCK_FLAG_COMPAT6
;
336 /* Get the filename */
337 if (optind
>= argc
) {
340 filename
= argv
[optind
++];
342 if (options
&& !strcmp(options
, "?")) {
343 ret
= print_block_option_help(filename
, fmt
);
347 /* Find driver and parse its options */
348 drv
= bdrv_find_format(fmt
);
350 error("Unknown file format '%s'", fmt
);
354 proto_drv
= bdrv_find_protocol(filename
);
356 error("Unknown protocol '%s'", filename
);
360 create_options
= append_option_parameters(create_options
,
361 drv
->create_options
);
362 create_options
= append_option_parameters(create_options
,
363 proto_drv
->create_options
);
365 /* Create parameter list with default values */
366 param
= parse_option_parameters("", create_options
, param
);
367 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
369 /* Parse -o options */
371 param
= parse_option_parameters(options
, create_options
, param
);
373 error("Invalid options for file format '%s'.", fmt
);
379 /* Add size to parameters */
381 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
384 /* Add old-style options to parameters */
385 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
390 // The size for the image must always be specified, with one exception:
391 // If we are using a backing file, we can obtain the size from there
392 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
394 QEMUOptionParameter
*backing_file
=
395 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
396 QEMUOptionParameter
*backing_fmt
=
397 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
399 if (backing_file
&& backing_file
->value
.s
) {
400 BlockDriverState
*bs
;
402 const char *fmt
= NULL
;
405 if (backing_fmt
&& backing_fmt
->value
.s
) {
406 if (bdrv_find_format(backing_fmt
->value
.s
)) {
407 fmt
= backing_fmt
->value
.s
;
409 error("Unknown backing file format '%s'",
410 backing_fmt
->value
.s
);
416 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
421 bdrv_get_geometry(bs
, &size
);
425 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
426 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
428 error("Image creation needs a size parameter");
434 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
435 print_option_parameters(param
);
438 ret
= bdrv_create(drv
, filename
, param
);
439 free_option_parameters(create_options
);
440 free_option_parameters(param
);
443 if (ret
== -ENOTSUP
) {
444 error("Formatting or formatting option not supported for file format '%s'", fmt
);
445 } else if (ret
== -EFBIG
) {
446 error("The image size is too large for file format '%s'", fmt
);
448 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
459 * Checks an image for consistency. Exit codes:
461 * 0 - Check completed, image is good
462 * 1 - Check not completed because of internal errors
463 * 2 - Check completed, image is corrupted
464 * 3 - Check completed, image has leaked clusters, but is good otherwise
466 static int img_check(int argc
, char **argv
)
469 const char *filename
, *fmt
;
470 BlockDriverState
*bs
;
471 BdrvCheckResult result
;
475 c
= getopt(argc
, argv
, "f:h");
488 if (optind
>= argc
) {
491 filename
= argv
[optind
++];
493 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
497 ret
= bdrv_check(bs
, &result
);
499 if (ret
== -ENOTSUP
) {
500 error("This image format does not support checks");
505 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
506 printf("No errors were found on the image.\n");
508 if (result
.corruptions
) {
509 printf("\n%d errors were found on the image.\n"
510 "Data may be corrupted, or further writes to the image "
516 printf("\n%d leaked clusters were found on the image.\n"
517 "This means waste of disk space, but no harm to data.\n",
521 if (result
.check_errors
) {
522 printf("\n%d internal errors have occurred during the check.\n",
523 result
.check_errors
);
529 if (ret
< 0 || result
.check_errors
) {
530 printf("\nAn error has occurred during the check: %s\n"
531 "The check is not complete and may have missed error.\n",
536 if (result
.corruptions
) {
538 } else if (result
.leaks
) {
545 static int img_commit(int argc
, char **argv
)
548 const char *filename
, *fmt
;
549 BlockDriverState
*bs
;
553 c
= getopt(argc
, argv
, "f:h");
566 if (optind
>= argc
) {
569 filename
= argv
[optind
++];
571 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
575 ret
= bdrv_commit(bs
);
578 printf("Image committed.\n");
581 error("No disk inserted");
584 error("Image is read-only");
587 error("Image is already committed");
590 error("Error while committing image");
601 static int is_not_zero(const uint8_t *sector
, int len
)
605 for(i
= 0;i
< len
; i
++) {
606 if (((uint32_t *)sector
)[i
] != 0)
613 * Returns true iff the first sector pointed to by 'buf' contains at least
616 * 'pnum' is set to the number of sectors (including and immediately following
617 * the first one) that are known to be in the same allocated/unallocated state.
619 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
627 v
= is_not_zero(buf
, 512);
628 for(i
= 1; i
< n
; i
++) {
630 if (v
!= is_not_zero(buf
, 512))
638 * Compares two buffers sector by sector. Returns 0 if the first sector of both
639 * buffers matches, non-zero otherwise.
641 * pnum is set to the number of sectors (including and immediately following
642 * the first one) that are known to have the same comparison result
644 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
654 res
= !!memcmp(buf1
, buf2
, 512);
655 for(i
= 1; i
< n
; i
++) {
659 if (!!memcmp(buf1
, buf2
, 512) != res
) {
668 #define IO_BUF_SIZE (2 * 1024 * 1024)
670 static int img_convert(int argc
, char **argv
)
672 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
673 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
674 BlockDriver
*drv
, *proto_drv
;
675 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
676 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
678 uint8_t * buf
= NULL
;
681 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
682 QEMUOptionParameter
*out_baseimg_param
;
683 char *options
= NULL
;
684 const char *snapshot_name
= NULL
;
691 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
706 out_baseimg
= optarg
;
709 flags
|= BLOCK_FLAG_COMPRESS
;
712 flags
|= BLOCK_FLAG_ENCRYPT
;
715 flags
|= BLOCK_FLAG_COMPAT6
;
721 snapshot_name
= optarg
;
726 bs_n
= argc
- optind
- 1;
731 out_filename
= argv
[argc
- 1];
733 if (options
&& !strcmp(options
, "?")) {
734 ret
= print_block_option_help(out_filename
, out_fmt
);
738 if (bs_n
> 1 && out_baseimg
) {
739 error("-B makes no sense when concatenating multiple input images");
744 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
747 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
748 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
750 error("Could not open '%s'", argv
[optind
+ bs_i
]);
754 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
755 total_sectors
+= bs_sectors
;
758 if (snapshot_name
!= NULL
) {
760 error("No support for concatenating multiple snapshot\n");
764 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
765 error("Failed to load snapshot\n");
771 /* Find driver and parse its options */
772 drv
= bdrv_find_format(out_fmt
);
774 error("Unknown file format '%s'", out_fmt
);
779 proto_drv
= bdrv_find_protocol(out_filename
);
781 error("Unknown protocol '%s'", out_filename
);
786 create_options
= append_option_parameters(create_options
,
787 drv
->create_options
);
788 create_options
= append_option_parameters(create_options
,
789 proto_drv
->create_options
);
792 param
= parse_option_parameters(options
, create_options
, param
);
794 error("Invalid options for file format '%s'.", out_fmt
);
799 param
= parse_option_parameters("", create_options
, param
);
802 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
803 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
808 /* Get backing file name if -o backing_file was used */
809 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
810 if (out_baseimg_param
) {
811 out_baseimg
= out_baseimg_param
->value
.s
;
814 /* Check if compression is supported */
815 if (flags
& BLOCK_FLAG_COMPRESS
) {
816 QEMUOptionParameter
*encryption
=
817 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
819 if (!drv
->bdrv_write_compressed
) {
820 error("Compression not supported for this file format");
825 if (encryption
&& encryption
->value
.n
) {
826 error("Compression and encryption not supported at the same time");
832 /* Create the new image */
833 ret
= bdrv_create(drv
, out_filename
, param
);
835 if (ret
== -ENOTSUP
) {
836 error("Formatting not supported for file format '%s'", out_fmt
);
837 } else if (ret
== -EFBIG
) {
838 error("The image size is too large for file format '%s'", out_fmt
);
840 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
845 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
846 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
854 bdrv_get_geometry(bs
[0], &bs_sectors
);
855 buf
= qemu_malloc(IO_BUF_SIZE
);
857 if (flags
& BLOCK_FLAG_COMPRESS
) {
858 ret
= bdrv_get_info(out_bs
, &bdi
);
860 error("could not get block driver info");
863 cluster_size
= bdi
.cluster_size
;
864 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
865 error("invalid cluster size");
869 cluster_sectors
= cluster_size
>> 9;
876 nb_sectors
= total_sectors
- sector_num
;
879 if (nb_sectors
>= cluster_sectors
)
884 bs_num
= sector_num
- bs_offset
;
885 assert (bs_num
>= 0);
888 while (remainder
> 0) {
890 while (bs_num
== bs_sectors
) {
892 assert (bs_i
< bs_n
);
893 bs_offset
+= bs_sectors
;
894 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
896 /* printf("changing part: sector_num=%" PRId64 ", "
897 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
898 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
900 assert (bs_num
< bs_sectors
);
902 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
904 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
906 error("error while reading");
915 assert (remainder
== 0);
917 if (n
< cluster_sectors
) {
918 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
920 if (is_not_zero(buf
, cluster_size
)) {
921 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
924 error("error while compressing sector %" PRId64
,
931 /* signal EOF to align */
932 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
934 int has_zero_init
= bdrv_has_zero_init(out_bs
);
936 sector_num
= 0; // total number of sectors converted so far
938 nb_sectors
= total_sectors
- sector_num
;
939 if (nb_sectors
<= 0) {
942 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
943 n
= (IO_BUF_SIZE
/ 512);
948 while (sector_num
- bs_offset
>= bs_sectors
) {
950 assert (bs_i
< bs_n
);
951 bs_offset
+= bs_sectors
;
952 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
953 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
954 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
955 sector_num, bs_i, bs_offset, bs_sectors); */
958 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
959 n
= bs_offset
+ bs_sectors
- sector_num
;
963 /* If the output image is being created as a copy on write image,
964 assume that sectors which are unallocated in the input image
965 are present in both the output's and input's base images (no
966 need to copy them). */
968 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
973 /* The next 'n1' sectors are allocated in the input image. Copy
974 only those as they may be followed by unallocated sectors. */
981 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
983 error("error while reading");
986 /* NOTE: at the same time we convert, we do not write zero
987 sectors to have a chance to compress the image. Ideally, we
988 should add a specific call to have the info to go faster */
991 /* If the output image is being created as a copy on write image,
992 copy all sectors even the ones containing only NUL bytes,
993 because they may differ from the sectors in the base image.
995 If the output is to a host device, we also write out
996 sectors that are entirely 0, since whatever data was
997 already there is garbage, not 0s. */
998 if (!has_zero_init
|| out_baseimg
||
999 is_allocated_sectors(buf1
, n
, &n1
)) {
1000 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1002 error("error while writing");
1013 free_option_parameters(create_options
);
1014 free_option_parameters(param
);
1017 bdrv_delete(out_bs
);
1020 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1022 bdrv_delete(bs
[bs_i
]);
1034 static int64_t get_allocated_file_size(const char *filename
)
1036 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1037 get_compressed_t get_compressed
;
1040 /* WinNT support GetCompressedFileSize to determine allocate size */
1041 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1042 if (get_compressed
) {
1044 low
= get_compressed(filename
, &high
);
1045 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1046 return (((int64_t) high
) << 32) + low
;
1049 if (_stati64(filename
, &st
) < 0)
1054 static int64_t get_allocated_file_size(const char *filename
)
1057 if (stat(filename
, &st
) < 0)
1059 return (int64_t)st
.st_blocks
* 512;
1063 static void dump_snapshots(BlockDriverState
*bs
)
1065 QEMUSnapshotInfo
*sn_tab
, *sn
;
1069 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1072 printf("Snapshot list:\n");
1073 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1074 for(i
= 0; i
< nb_sns
; i
++) {
1076 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1081 static int img_info(int argc
, char **argv
)
1084 const char *filename
, *fmt
;
1085 BlockDriverState
*bs
;
1086 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1087 uint64_t total_sectors
;
1088 int64_t allocated_size
;
1089 char backing_filename
[1024];
1090 char backing_filename2
[1024];
1091 BlockDriverInfo bdi
;
1095 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");
1185 action
= SNAPSHOT_LIST
;
1186 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1193 action
= SNAPSHOT_APPLY
;
1194 snapshot_name
= optarg
;
1201 action
= SNAPSHOT_CREATE
;
1202 snapshot_name
= optarg
;
1209 action
= SNAPSHOT_DELETE
;
1210 snapshot_name
= optarg
;
1215 if (optind
>= argc
) {
1218 filename
= argv
[optind
++];
1220 /* Open the image */
1221 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1226 /* Perform the requested action */
1232 case SNAPSHOT_CREATE
:
1233 memset(&sn
, 0, sizeof(sn
));
1234 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1236 qemu_gettimeofday(&tv
);
1237 sn
.date_sec
= tv
.tv_sec
;
1238 sn
.date_nsec
= tv
.tv_usec
* 1000;
1240 ret
= bdrv_snapshot_create(bs
, &sn
);
1242 error("Could not create snapshot '%s': %d (%s)",
1243 snapshot_name
, ret
, strerror(-ret
));
1247 case SNAPSHOT_APPLY
:
1248 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1250 error("Could not apply snapshot '%s': %d (%s)",
1251 snapshot_name
, ret
, strerror(-ret
));
1255 case SNAPSHOT_DELETE
:
1256 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1258 error("Could not delete snapshot '%s': %d (%s)",
1259 snapshot_name
, ret
, strerror(-ret
));
1272 static int img_rebase(int argc
, char **argv
)
1274 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1275 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1277 const char *fmt
, *out_basefmt
, *out_baseimg
;
1281 /* Parse commandline parameters */
1287 c
= getopt(argc
, argv
, "uhf:F:b:");
1299 out_basefmt
= optarg
;
1302 out_baseimg
= optarg
;
1310 if ((optind
>= argc
) || !out_baseimg
) {
1313 filename
= argv
[optind
++];
1318 * Ignore the old backing file for unsafe rebase in case we want to correct
1319 * the reference to a renamed or moved backing file.
1321 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1322 bs
= bdrv_new_open(filename
, fmt
, flags
);
1327 /* Find the right drivers for the backing files */
1328 old_backing_drv
= NULL
;
1329 new_backing_drv
= NULL
;
1331 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1332 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1333 if (old_backing_drv
== NULL
) {
1334 error("Invalid format name: '%s'", bs
->backing_format
);
1340 if (out_basefmt
!= NULL
) {
1341 new_backing_drv
= bdrv_find_format(out_basefmt
);
1342 if (new_backing_drv
== NULL
) {
1343 error("Invalid format name: '%s'", out_basefmt
);
1349 /* For safe rebasing we need to compare old and new backing file */
1351 /* Make the compiler happy */
1352 bs_old_backing
= NULL
;
1353 bs_new_backing
= NULL
;
1355 char backing_name
[1024];
1357 bs_old_backing
= bdrv_new("old_backing");
1358 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1359 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1362 error("Could not open old backing file '%s'", backing_name
);
1366 bs_new_backing
= bdrv_new("new_backing");
1367 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1370 error("Could not open new backing file '%s'", out_baseimg
);
1376 * Check each unallocated cluster in the COW file. If it is unallocated,
1377 * accesses go to the backing file. We must therefore compare this cluster
1378 * in the old and new backing file, and if they differ we need to copy it
1379 * from the old backing file into the COW file.
1381 * If qemu-img crashes during this step, no harm is done. The content of
1382 * the image is the same as the original one at any time.
1385 uint64_t num_sectors
;
1391 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1392 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1394 bdrv_get_geometry(bs
, &num_sectors
);
1396 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1398 /* How many sectors can we handle with the next read? */
1399 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1400 n
= (IO_BUF_SIZE
/ 512);
1402 n
= num_sectors
- sector
;
1405 /* If the cluster is allocated, we don't need to take action */
1406 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1411 /* Read old and new backing file */
1412 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1414 error("error while reading from old backing file");
1417 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1419 error("error while reading from new backing file");
1423 /* If they differ, we need to write to the COW file */
1424 uint64_t written
= 0;
1426 while (written
< n
) {
1429 if (compare_sectors(buf_old
+ written
* 512,
1430 buf_new
+ written
* 512, n
- written
, &pnum
))
1432 ret
= bdrv_write(bs
, sector
+ written
,
1433 buf_old
+ written
* 512, pnum
);
1435 error("Error while writing to COW image: %s",
1450 * Change the backing file. All clusters that are different from the old
1451 * backing file are overwritten in the COW file now, so the visible content
1452 * doesn't change when we switch the backing file.
1454 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1455 if (ret
== -ENOSPC
) {
1456 error("Could not change the backing file to '%s': No space left in "
1457 "the file header", out_baseimg
);
1458 } else if (ret
< 0) {
1459 error("Could not change the backing file to '%s': %s",
1460 out_baseimg
, strerror(-ret
));
1464 * TODO At this point it is possible to check if any clusters that are
1465 * allocated in the COW file are the same in the backing file. If so, they
1466 * could be dropped from the COW file. Don't do this before switching the
1467 * backing file, in case of a crash this would lead to corruption.
1472 bdrv_delete(bs_old_backing
);
1473 bdrv_delete(bs_new_backing
);
1483 static int img_resize(int argc
, char **argv
)
1485 int c
, ret
, relative
;
1486 const char *filename
, *fmt
, *size
;
1487 int64_t n
, total_size
;
1488 BlockDriverState
*bs
;
1489 QEMUOptionParameter
*param
;
1490 QEMUOptionParameter resize_options
[] = {
1492 .name
= BLOCK_OPT_SIZE
,
1494 .help
= "Virtual disk size"
1501 c
= getopt(argc
, argv
, "f:h");
1514 if (optind
+ 1 >= argc
) {
1517 filename
= argv
[optind
++];
1518 size
= argv
[optind
++];
1520 /* Choose grow, shrink, or absolute resize mode */
1536 param
= parse_option_parameters("", resize_options
, NULL
);
1537 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1538 /* Error message already printed when size parsing fails */
1541 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1542 free_option_parameters(param
);
1544 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1550 total_size
= bdrv_getlength(bs
) + n
* relative
;
1554 if (total_size
<= 0) {
1555 error("New image size must be positive");
1560 ret
= bdrv_truncate(bs
, total_size
);
1563 printf("Image resized.\n");
1566 error("This image format does not support resize");
1569 error("Image is read-only");
1572 error("Error resizing image (%d)", -ret
);
1583 static const img_cmd_t img_cmds
[] = {
1584 #define DEF(option, callback, arg_string) \
1585 { option, callback },
1586 #include "qemu-img-cmds.h"
1592 int main(int argc
, char **argv
)
1594 const img_cmd_t
*cmd
;
1595 const char *cmdname
;
1603 /* find the command */
1604 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1605 if (!strcmp(cmdname
, cmd
->name
)) {
1606 return cmd
->handler(argc
, argv
);