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"
27 #include "block_int.h"
34 typedef struct img_cmd_t
{
36 int (*handler
)(int argc
, char **argv
);
39 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
40 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
42 static void GCC_FMT_ATTR(1, 2) error(const char *fmt
, ...)
46 fprintf(stderr
, "qemu-img: ");
47 vfprintf(stderr
, fmt
, ap
);
48 fprintf(stderr
, "\n");
52 static void format_print(void *opaque
, const char *name
)
57 /* Please keep in synch with qemu-img.texi */
58 static void help(void)
60 const char *help_msg
=
61 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
62 "usage: qemu-img command [command options]\n"
63 "QEMU disk image utility\n"
66 #define DEF(option, callback, arg_string) \
68 #include "qemu-img-cmds.h"
72 "Command parameters:\n"
73 " 'filename' is a disk image filename\n"
74 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
75 " 'size' is the disk image size in bytes. Optional suffixes\n"
76 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
77 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
78 " 'output_filename' is the destination disk image filename\n"
79 " 'output_fmt' is the destination format\n"
80 " 'options' is a comma separated list of format specific options in a\n"
81 " name=value format. Use -o ? for an overview of the options supported by the\n"
83 " '-c' indicates that target image must be compressed (qcow format only)\n"
84 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
85 " match exactly. The image doesn't need a working backing file before\n"
86 " rebasing in this case (useful for renaming the backing file)\n"
87 " '-h' with or without a command shows this help and lists the supported formats\n"
89 "Parameters to snapshot subcommand:\n"
90 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
91 " '-a' applies a snapshot (revert disk to saved state)\n"
92 " '-c' creates a snapshot\n"
93 " '-d' deletes a snapshot\n"
94 " '-l' lists all snapshots in the given image\n";
96 printf("%s\nSupported formats:", help_msg
);
97 bdrv_iterate_format(format_print
, NULL
);
103 /* XXX: put correct support for win32 */
104 static int read_password(char *buf
, int buf_size
)
107 printf("Password: ");
114 if (i
< (buf_size
- 1))
125 static struct termios oldtty
;
127 static void term_exit(void)
129 tcsetattr (0, TCSANOW
, &oldtty
);
132 static void term_init(void)
139 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
140 |INLCR
|IGNCR
|ICRNL
|IXON
);
141 tty
.c_oflag
|= OPOST
;
142 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
143 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
148 tcsetattr (0, TCSANOW
, &tty
);
153 static int read_password(char *buf
, int buf_size
)
158 printf("password: ");
163 ret
= read(0, &ch
, 1);
165 if (errno
== EAGAIN
|| errno
== EINTR
) {
171 } else if (ret
== 0) {
179 if (i
< (buf_size
- 1))
190 static BlockDriverState
*bdrv_new_open(const char *filename
,
194 BlockDriverState
*bs
;
200 error("Not enough memory");
204 drv
= bdrv_find_format(fmt
);
206 error("Unknown file format '%s'", fmt
);
212 if (bdrv_open(bs
, filename
, flags
, drv
) < 0) {
213 error("Could not open '%s'", filename
);
216 if (bdrv_is_encrypted(bs
)) {
217 printf("Disk image '%s' is encrypted.\n", filename
);
218 if (read_password(password
, sizeof(password
)) < 0) {
219 error("No password given");
222 if (bdrv_set_key(bs
, password
) < 0) {
223 error("invalid password");
235 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
236 int flags
, const char *base_filename
, const char *base_fmt
)
238 if (flags
& BLOCK_FLAG_ENCRYPT
) {
239 if (set_option_parameter(list
, BLOCK_OPT_ENCRYPT
, "on")) {
240 error("Encryption not supported for file format '%s'", fmt
);
244 if (flags
& BLOCK_FLAG_COMPAT6
) {
245 if (set_option_parameter(list
, BLOCK_OPT_COMPAT6
, "on")) {
246 error("VMDK version 6 not supported for file format '%s'", fmt
);
252 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
253 error("Backing file not supported for file format '%s'", fmt
);
258 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
259 error("Backing file format not supported for file format '%s'", fmt
);
266 static int img_create(int argc
, char **argv
)
268 int c
, ret
= 0, flags
;
269 const char *fmt
= "raw";
270 const char *base_fmt
= NULL
;
271 const char *filename
;
272 const char *base_filename
= NULL
;
273 BlockDriver
*drv
, *proto_drv
;
274 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
275 char *options
= NULL
;
279 c
= getopt(argc
, argv
, "F:b:f:he6o:");
290 base_filename
= optarg
;
296 flags
|= BLOCK_FLAG_ENCRYPT
;
299 flags
|= BLOCK_FLAG_COMPAT6
;
307 /* Get the filename */
310 filename
= argv
[optind
++];
312 /* Find driver and parse its options */
313 drv
= bdrv_find_format(fmt
);
315 error("Unknown file format '%s'", fmt
);
319 proto_drv
= bdrv_find_protocol(filename
);
321 error("Unknown protocol '%s'", filename
);
325 create_options
= append_option_parameters(create_options
,
326 drv
->create_options
);
327 create_options
= append_option_parameters(create_options
,
328 proto_drv
->create_options
);
330 if (options
&& !strcmp(options
, "?")) {
331 print_option_help(create_options
);
335 /* Create parameter list with default values */
336 param
= parse_option_parameters("", create_options
, param
);
337 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
339 /* Parse -o options */
341 param
= parse_option_parameters(options
, create_options
, param
);
343 error("Invalid options for file format '%s'.", fmt
);
349 /* Add size to parameters */
351 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
354 /* Add old-style options to parameters */
355 ret
= add_old_style_options(fmt
, param
, flags
, base_filename
, base_fmt
);
360 // The size for the image must always be specified, with one exception:
361 // If we are using a backing file, we can obtain the size from there
362 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
364 QEMUOptionParameter
*backing_file
=
365 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
366 QEMUOptionParameter
*backing_fmt
=
367 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
369 if (backing_file
&& backing_file
->value
.s
) {
370 BlockDriverState
*bs
;
372 const char *fmt
= NULL
;
375 if (backing_fmt
&& backing_fmt
->value
.s
) {
376 if (bdrv_find_format(backing_fmt
->value
.s
)) {
377 fmt
= backing_fmt
->value
.s
;
379 error("Unknown backing file format '%s'",
380 backing_fmt
->value
.s
);
386 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
391 bdrv_get_geometry(bs
, &size
);
395 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
396 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
398 error("Image creation needs a size parameter");
404 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
405 print_option_parameters(param
);
408 ret
= bdrv_create(drv
, filename
, param
);
409 free_option_parameters(create_options
);
410 free_option_parameters(param
);
413 if (ret
== -ENOTSUP
) {
414 error("Formatting or formatting option not supported for file format '%s'", fmt
);
415 } else if (ret
== -EFBIG
) {
416 error("The image size is too large for file format '%s'", fmt
);
418 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
429 * Checks an image for consistency. Exit codes:
431 * 0 - Check completed, image is good
432 * 1 - Check not completed because of internal errors
433 * 2 - Check completed, image is corrupted
434 * 3 - Check completed, image has leaked clusters, but is good otherwise
436 static int img_check(int argc
, char **argv
)
439 const char *filename
, *fmt
;
440 BlockDriverState
*bs
;
441 BdrvCheckResult result
;
445 c
= getopt(argc
, argv
, "f:h");
459 filename
= argv
[optind
++];
461 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
465 ret
= bdrv_check(bs
, &result
);
467 if (ret
== -ENOTSUP
) {
468 error("This image format does not support checks");
473 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
474 printf("No errors were found on the image.\n");
476 if (result
.corruptions
) {
477 printf("\n%d errors were found on the image.\n"
478 "Data may be corrupted, or further writes to the image "
484 printf("\n%d leaked clusters were found on the image.\n"
485 "This means waste of disk space, but no harm to data.\n",
489 if (result
.check_errors
) {
490 printf("\n%d internal errors have occurred during the check.\n",
491 result
.check_errors
);
497 if (ret
< 0 || result
.check_errors
) {
498 printf("\nAn error has occurred during the check: %s\n"
499 "The check is not complete and may have missed error.\n",
504 if (result
.corruptions
) {
506 } else if (result
.leaks
) {
513 static int img_commit(int argc
, char **argv
)
516 const char *filename
, *fmt
;
517 BlockDriverState
*bs
;
521 c
= getopt(argc
, argv
, "f:h");
535 filename
= argv
[optind
++];
537 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
541 ret
= bdrv_commit(bs
);
544 printf("Image committed.\n");
547 error("No disk inserted");
550 error("Image is read-only");
553 error("Image is already committed");
556 error("Error while committing image");
567 static int is_not_zero(const uint8_t *sector
, int len
)
571 for(i
= 0;i
< len
; i
++) {
572 if (((uint32_t *)sector
)[i
] != 0)
579 * Returns true iff the first sector pointed to by 'buf' contains at least
582 * 'pnum' is set to the number of sectors (including and immediately following
583 * the first one) that are known to be in the same allocated/unallocated state.
585 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
593 v
= is_not_zero(buf
, 512);
594 for(i
= 1; i
< n
; i
++) {
596 if (v
!= is_not_zero(buf
, 512))
604 * Compares two buffers sector by sector. Returns 0 if the first sector of both
605 * buffers matches, non-zero otherwise.
607 * pnum is set to the number of sectors (including and immediately following
608 * the first one) that are known to have the same comparison result
610 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
620 res
= !!memcmp(buf1
, buf2
, 512);
621 for(i
= 1; i
< n
; i
++) {
625 if (!!memcmp(buf1
, buf2
, 512) != res
) {
634 #define IO_BUF_SIZE (2 * 1024 * 1024)
636 static int img_convert(int argc
, char **argv
)
638 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, flags
, cluster_size
, cluster_sectors
;
639 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
640 BlockDriver
*drv
, *proto_drv
;
641 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
642 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
644 uint8_t * buf
= NULL
;
647 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
648 QEMUOptionParameter
*out_baseimg_param
;
649 char *options
= NULL
;
650 const char *snapshot_name
= NULL
;
657 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
671 out_baseimg
= optarg
;
674 flags
|= BLOCK_FLAG_COMPRESS
;
677 flags
|= BLOCK_FLAG_ENCRYPT
;
680 flags
|= BLOCK_FLAG_COMPAT6
;
686 snapshot_name
= optarg
;
691 bs_n
= argc
- optind
- 1;
692 if (bs_n
< 1) help();
694 out_filename
= argv
[argc
- 1];
696 if (bs_n
> 1 && out_baseimg
) {
697 error("-B makes no sense when concatenating multiple input images");
701 bs
= calloc(bs_n
, sizeof(BlockDriverState
*));
703 error("Out of memory");
708 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
709 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
711 error("Could not open '%s'", argv
[optind
+ bs_i
]);
715 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
716 total_sectors
+= bs_sectors
;
719 if (snapshot_name
!= NULL
) {
721 error("No support for concatenating multiple snapshot\n");
725 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
726 error("Failed to load snapshot\n");
732 /* Find driver and parse its options */
733 drv
= bdrv_find_format(out_fmt
);
735 error("Unknown file format '%s'", out_fmt
);
740 proto_drv
= bdrv_find_protocol(out_filename
);
742 error("Unknown protocol '%s'", out_filename
);
747 create_options
= append_option_parameters(create_options
,
748 drv
->create_options
);
749 create_options
= append_option_parameters(create_options
,
750 proto_drv
->create_options
);
751 if (options
&& !strcmp(options
, "?")) {
752 print_option_help(create_options
);
757 param
= parse_option_parameters(options
, create_options
, param
);
759 error("Invalid options for file format '%s'.", out_fmt
);
764 param
= parse_option_parameters("", create_options
, param
);
767 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
768 ret
= add_old_style_options(out_fmt
, param
, flags
, out_baseimg
, NULL
);
773 /* Get backing file name if -o backing_file was used */
774 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
775 if (out_baseimg_param
) {
776 out_baseimg
= out_baseimg_param
->value
.s
;
779 /* Check if compression is supported */
780 if (flags
& BLOCK_FLAG_COMPRESS
) {
781 QEMUOptionParameter
*encryption
=
782 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
784 if (!drv
->bdrv_write_compressed
) {
785 error("Compression not supported for this file format");
790 if (encryption
&& encryption
->value
.n
) {
791 error("Compression and encryption not supported at the same time");
797 /* Create the new image */
798 ret
= bdrv_create(drv
, out_filename
, param
);
800 if (ret
== -ENOTSUP
) {
801 error("Formatting not supported for file format '%s'", out_fmt
);
802 } else if (ret
== -EFBIG
) {
803 error("The image size is too large for file format '%s'", out_fmt
);
805 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
810 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
811 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
819 bdrv_get_geometry(bs
[0], &bs_sectors
);
820 buf
= qemu_malloc(IO_BUF_SIZE
);
822 if (flags
& BLOCK_FLAG_COMPRESS
) {
823 ret
= bdrv_get_info(out_bs
, &bdi
);
825 error("could not get block driver info");
828 cluster_size
= bdi
.cluster_size
;
829 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
830 error("invalid cluster size");
834 cluster_sectors
= cluster_size
>> 9;
841 nb_sectors
= total_sectors
- sector_num
;
844 if (nb_sectors
>= cluster_sectors
)
849 bs_num
= sector_num
- bs_offset
;
850 assert (bs_num
>= 0);
853 while (remainder
> 0) {
855 while (bs_num
== bs_sectors
) {
857 assert (bs_i
< bs_n
);
858 bs_offset
+= bs_sectors
;
859 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
861 /* printf("changing part: sector_num=%" PRId64 ", "
862 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
863 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
865 assert (bs_num
< bs_sectors
);
867 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
869 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
871 error("error while reading");
880 assert (remainder
== 0);
882 if (n
< cluster_sectors
)
883 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
884 if (is_not_zero(buf
, cluster_size
)) {
885 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
888 error("error while compressing sector %" PRId64
,
895 /* signal EOF to align */
896 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
898 int has_zero_init
= bdrv_has_zero_init(out_bs
);
900 sector_num
= 0; // total number of sectors converted so far
902 nb_sectors
= total_sectors
- sector_num
;
905 if (nb_sectors
>= (IO_BUF_SIZE
/ 512))
906 n
= (IO_BUF_SIZE
/ 512);
910 while (sector_num
- bs_offset
>= bs_sectors
) {
912 assert (bs_i
< bs_n
);
913 bs_offset
+= bs_sectors
;
914 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
915 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
916 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
917 sector_num, bs_i, bs_offset, bs_sectors); */
920 if (n
> bs_offset
+ bs_sectors
- sector_num
)
921 n
= bs_offset
+ bs_sectors
- sector_num
;
924 /* If the output image is being created as a copy on write image,
925 assume that sectors which are unallocated in the input image
926 are present in both the output's and input's base images (no
927 need to copy them). */
929 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
934 /* The next 'n1' sectors are allocated in the input image. Copy
935 only those as they may be followed by unallocated sectors. */
942 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
944 error("error while reading");
947 /* NOTE: at the same time we convert, we do not write zero
948 sectors to have a chance to compress the image. Ideally, we
949 should add a specific call to have the info to go faster */
952 /* If the output image is being created as a copy on write image,
953 copy all sectors even the ones containing only NUL bytes,
954 because they may differ from the sectors in the base image.
956 If the output is to a host device, we also write out
957 sectors that are entirely 0, since whatever data was
958 already there is garbage, not 0s. */
959 if (!has_zero_init
|| out_baseimg
||
960 is_allocated_sectors(buf1
, n
, &n1
)) {
961 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
963 error("error while writing");
974 free_option_parameters(create_options
);
975 free_option_parameters(param
);
980 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
982 bdrv_delete(bs
[bs_i
]);
993 static int64_t get_allocated_file_size(const char *filename
)
995 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
996 get_compressed_t get_compressed
;
999 /* WinNT support GetCompressedFileSize to determine allocate size */
1000 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1001 if (get_compressed
) {
1003 low
= get_compressed(filename
, &high
);
1004 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1005 return (((int64_t) high
) << 32) + low
;
1008 if (_stati64(filename
, &st
) < 0)
1013 static int64_t get_allocated_file_size(const char *filename
)
1016 if (stat(filename
, &st
) < 0)
1018 return (int64_t)st
.st_blocks
* 512;
1022 static void dump_snapshots(BlockDriverState
*bs
)
1024 QEMUSnapshotInfo
*sn_tab
, *sn
;
1028 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1031 printf("Snapshot list:\n");
1032 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1033 for(i
= 0; i
< nb_sns
; i
++) {
1035 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1040 static int img_info(int argc
, char **argv
)
1043 const char *filename
, *fmt
;
1044 BlockDriverState
*bs
;
1045 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1046 uint64_t total_sectors
;
1047 int64_t allocated_size
;
1048 char backing_filename
[1024];
1049 char backing_filename2
[1024];
1050 BlockDriverInfo bdi
;
1054 c
= getopt(argc
, argv
, "f:h");
1068 filename
= argv
[optind
++];
1070 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1074 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1075 bdrv_get_geometry(bs
, &total_sectors
);
1076 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1077 allocated_size
= get_allocated_file_size(filename
);
1078 if (allocated_size
< 0)
1079 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1081 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1083 printf("image: %s\n"
1085 "virtual size: %s (%" PRId64
" bytes)\n"
1087 filename
, fmt_name
, size_buf
,
1088 (total_sectors
* 512),
1090 if (bdrv_is_encrypted(bs
))
1091 printf("encrypted: yes\n");
1092 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1093 if (bdi
.cluster_size
!= 0)
1094 printf("cluster_size: %d\n", bdi
.cluster_size
);
1096 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1097 if (backing_filename
[0] != '\0') {
1098 path_combine(backing_filename2
, sizeof(backing_filename2
),
1099 filename
, backing_filename
);
1100 printf("backing file: %s (actual path: %s)\n",
1109 #define SNAPSHOT_LIST 1
1110 #define SNAPSHOT_CREATE 2
1111 #define SNAPSHOT_APPLY 3
1112 #define SNAPSHOT_DELETE 4
1114 static int img_snapshot(int argc
, char **argv
)
1116 BlockDriverState
*bs
;
1117 QEMUSnapshotInfo sn
;
1118 char *filename
, *snapshot_name
= NULL
;
1119 int c
, ret
= 0, bdrv_oflags
;
1123 bdrv_oflags
= BDRV_O_RDWR
;
1124 /* Parse commandline parameters */
1126 c
= getopt(argc
, argv
, "la:c:d:h");
1138 action
= SNAPSHOT_LIST
;
1139 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1146 action
= SNAPSHOT_APPLY
;
1147 snapshot_name
= optarg
;
1154 action
= SNAPSHOT_CREATE
;
1155 snapshot_name
= optarg
;
1162 action
= SNAPSHOT_DELETE
;
1163 snapshot_name
= optarg
;
1170 filename
= argv
[optind
++];
1172 /* Open the image */
1173 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1178 /* Perform the requested action */
1184 case SNAPSHOT_CREATE
:
1185 memset(&sn
, 0, sizeof(sn
));
1186 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1188 qemu_gettimeofday(&tv
);
1189 sn
.date_sec
= tv
.tv_sec
;
1190 sn
.date_nsec
= tv
.tv_usec
* 1000;
1192 ret
= bdrv_snapshot_create(bs
, &sn
);
1194 error("Could not create snapshot '%s': %d (%s)",
1195 snapshot_name
, ret
, strerror(-ret
));
1198 case SNAPSHOT_APPLY
:
1199 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1201 error("Could not apply snapshot '%s': %d (%s)",
1202 snapshot_name
, ret
, strerror(-ret
));
1205 case SNAPSHOT_DELETE
:
1206 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1208 error("Could not delete snapshot '%s': %d (%s)",
1209 snapshot_name
, ret
, strerror(-ret
));
1221 static int img_rebase(int argc
, char **argv
)
1223 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1224 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1226 const char *fmt
, *out_basefmt
, *out_baseimg
;
1230 /* Parse commandline parameters */
1236 c
= getopt(argc
, argv
, "uhf:F:b:");
1247 out_basefmt
= optarg
;
1250 out_baseimg
= optarg
;
1258 if ((optind
>= argc
) || !out_baseimg
)
1260 filename
= argv
[optind
++];
1265 * Ignore the old backing file for unsafe rebase in case we want to correct
1266 * the reference to a renamed or moved backing file.
1268 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1269 bs
= bdrv_new_open(filename
, fmt
, flags
);
1274 /* Find the right drivers for the backing files */
1275 old_backing_drv
= NULL
;
1276 new_backing_drv
= NULL
;
1278 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1279 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1280 if (old_backing_drv
== NULL
) {
1281 error("Invalid format name: '%s'", bs
->backing_format
);
1287 if (out_basefmt
!= NULL
) {
1288 new_backing_drv
= bdrv_find_format(out_basefmt
);
1289 if (new_backing_drv
== NULL
) {
1290 error("Invalid format name: '%s'", out_basefmt
);
1296 /* For safe rebasing we need to compare old and new backing file */
1298 /* Make the compiler happy */
1299 bs_old_backing
= NULL
;
1300 bs_new_backing
= NULL
;
1302 char backing_name
[1024];
1304 bs_old_backing
= bdrv_new("old_backing");
1305 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1306 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1309 error("Could not open old backing file '%s'", backing_name
);
1313 bs_new_backing
= bdrv_new("new_backing");
1314 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1317 error("Could not open new backing file '%s'", out_baseimg
);
1323 * Check each unallocated cluster in the COW file. If it is unallocated,
1324 * accesses go to the backing file. We must therefore compare this cluster
1325 * in the old and new backing file, and if they differ we need to copy it
1326 * from the old backing file into the COW file.
1328 * If qemu-img crashes during this step, no harm is done. The content of
1329 * the image is the same as the original one at any time.
1332 uint64_t num_sectors
;
1338 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1339 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1341 bdrv_get_geometry(bs
, &num_sectors
);
1343 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1345 /* How many sectors can we handle with the next read? */
1346 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1347 n
= (IO_BUF_SIZE
/ 512);
1349 n
= num_sectors
- sector
;
1352 /* If the cluster is allocated, we don't need to take action */
1353 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1358 /* Read old and new backing file */
1359 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1361 error("error while reading from old backing file");
1364 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1366 error("error while reading from new backing file");
1370 /* If they differ, we need to write to the COW file */
1371 uint64_t written
= 0;
1373 while (written
< n
) {
1376 if (compare_sectors(buf_old
+ written
* 512,
1377 buf_new
+ written
* 512, n
- written
, &pnum
))
1379 ret
= bdrv_write(bs
, sector
+ written
,
1380 buf_old
+ written
* 512, pnum
);
1382 error("Error while writing to COW image: %s",
1397 * Change the backing file. All clusters that are different from the old
1398 * backing file are overwritten in the COW file now, so the visible content
1399 * doesn't change when we switch the backing file.
1401 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1402 if (ret
== -ENOSPC
) {
1403 error("Could not change the backing file to '%s': No space left in "
1404 "the file header", out_baseimg
);
1405 } else if (ret
< 0) {
1406 error("Could not change the backing file to '%s': %s",
1407 out_baseimg
, strerror(-ret
));
1411 * TODO At this point it is possible to check if any clusters that are
1412 * allocated in the COW file are the same in the backing file. If so, they
1413 * could be dropped from the COW file. Don't do this before switching the
1414 * backing file, in case of a crash this would lead to corruption.
1419 bdrv_delete(bs_old_backing
);
1420 bdrv_delete(bs_new_backing
);
1430 static int img_resize(int argc
, char **argv
)
1432 int c
, ret
, relative
;
1433 const char *filename
, *fmt
, *size
;
1434 int64_t n
, total_size
;
1435 BlockDriverState
*bs
;
1436 QEMUOptionParameter
*param
;
1437 QEMUOptionParameter resize_options
[] = {
1439 .name
= BLOCK_OPT_SIZE
,
1441 .help
= "Virtual disk size"
1448 c
= getopt(argc
, argv
, "f:h");
1461 if (optind
+ 1 >= argc
) {
1464 filename
= argv
[optind
++];
1465 size
= argv
[optind
++];
1467 /* Choose grow, shrink, or absolute resize mode */
1483 param
= parse_option_parameters("", resize_options
, NULL
);
1484 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1485 /* Error message already printed when size parsing fails */
1488 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1489 free_option_parameters(param
);
1491 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1497 total_size
= bdrv_getlength(bs
) + n
* relative
;
1501 if (total_size
<= 0) {
1502 error("New image size must be positive");
1507 ret
= bdrv_truncate(bs
, total_size
);
1510 printf("Image resized.\n");
1513 error("This image format does not support resize");
1516 error("Image is read-only");
1519 error("Error resizing image (%d)", -ret
);
1530 static const img_cmd_t img_cmds
[] = {
1531 #define DEF(option, callback, arg_string) \
1532 { option, callback },
1533 #include "qemu-img-cmds.h"
1539 int main(int argc
, char **argv
)
1541 const img_cmd_t
*cmd
;
1542 const char *cmdname
;
1550 /* find the command */
1551 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1552 if (!strcmp(cmdname
, cmd
->name
)) {
1553 return cmd
->handler(argc
, argv
);