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 const char *fmt
= "raw";
286 const char *base_fmt
= NULL
;
287 const char *filename
;
288 const char *base_filename
= NULL
;
289 BlockDriver
*drv
, *proto_drv
;
290 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
291 char *options
= NULL
;
294 c
= getopt(argc
, argv
, "F:b:f:he6o:");
307 base_filename
= optarg
;
313 error("qemu-img: option -e is deprecated, please use \'-o "
314 "encryption\' instead!");
317 error("qemu-img: option -6 is deprecated, please use \'-o "
318 "compat6\' instead!");
326 /* Get the filename */
327 if (optind
>= argc
) {
330 filename
= argv
[optind
++];
332 if (options
&& !strcmp(options
, "?")) {
333 ret
= print_block_option_help(filename
, fmt
);
337 /* Find driver and parse its options */
338 drv
= bdrv_find_format(fmt
);
340 error("Unknown file format '%s'", fmt
);
345 proto_drv
= bdrv_find_protocol(filename
);
347 error("Unknown protocol '%s'", filename
);
352 create_options
= append_option_parameters(create_options
,
353 drv
->create_options
);
354 create_options
= append_option_parameters(create_options
,
355 proto_drv
->create_options
);
357 /* Create parameter list with default values */
358 param
= parse_option_parameters("", create_options
, param
);
359 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, -1);
361 /* Parse -o options */
363 param
= parse_option_parameters(options
, create_options
, param
);
365 error("Invalid options for file format '%s'.", fmt
);
371 /* Add size to parameters */
373 set_option_parameter(param
, BLOCK_OPT_SIZE
, argv
[optind
++]);
376 /* Add old-style options to parameters */
377 ret
= add_old_style_options(fmt
, param
, base_filename
, base_fmt
);
382 // The size for the image must always be specified, with one exception:
383 // If we are using a backing file, we can obtain the size from there
384 if (get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
== -1) {
386 QEMUOptionParameter
*backing_file
=
387 get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
388 QEMUOptionParameter
*backing_fmt
=
389 get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
391 if (backing_file
&& backing_file
->value
.s
) {
392 BlockDriverState
*bs
;
394 const char *fmt
= NULL
;
397 if (backing_fmt
&& backing_fmt
->value
.s
) {
398 if (bdrv_find_format(backing_fmt
->value
.s
)) {
399 fmt
= backing_fmt
->value
.s
;
401 error("Unknown backing file format '%s'",
402 backing_fmt
->value
.s
);
408 bs
= bdrv_new_open(backing_file
->value
.s
, fmt
, BDRV_O_FLAGS
);
413 bdrv_get_geometry(bs
, &size
);
417 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
418 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
420 error("Image creation needs a size parameter");
426 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
427 print_option_parameters(param
);
430 ret
= bdrv_create(drv
, filename
, param
);
433 if (ret
== -ENOTSUP
) {
434 error("Formatting or formatting option not supported for file format '%s'", fmt
);
435 } else if (ret
== -EFBIG
) {
436 error("The image size is too large for file format '%s'", fmt
);
438 error("%s: error while creating %s: %s", filename
, fmt
, strerror(-ret
));
442 free_option_parameters(create_options
);
443 free_option_parameters(param
);
451 * Checks an image for consistency. Exit codes:
453 * 0 - Check completed, image is good
454 * 1 - Check not completed because of internal errors
455 * 2 - Check completed, image is corrupted
456 * 3 - Check completed, image has leaked clusters, but is good otherwise
458 static int img_check(int argc
, char **argv
)
461 const char *filename
, *fmt
;
462 BlockDriverState
*bs
;
463 BdrvCheckResult result
;
467 c
= getopt(argc
, argv
, "f:h");
481 if (optind
>= argc
) {
484 filename
= argv
[optind
++];
486 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
490 ret
= bdrv_check(bs
, &result
);
492 if (ret
== -ENOTSUP
) {
493 error("This image format does not support checks");
498 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
499 printf("No errors were found on the image.\n");
501 if (result
.corruptions
) {
502 printf("\n%d errors were found on the image.\n"
503 "Data may be corrupted, or further writes to the image "
509 printf("\n%d leaked clusters were found on the image.\n"
510 "This means waste of disk space, but no harm to data.\n",
514 if (result
.check_errors
) {
515 printf("\n%d internal errors have occurred during the check.\n",
516 result
.check_errors
);
522 if (ret
< 0 || result
.check_errors
) {
523 printf("\nAn error has occurred during the check: %s\n"
524 "The check is not complete and may have missed error.\n",
529 if (result
.corruptions
) {
531 } else if (result
.leaks
) {
538 static int img_commit(int argc
, char **argv
)
541 const char *filename
, *fmt
;
542 BlockDriverState
*bs
;
546 c
= getopt(argc
, argv
, "f:h");
560 if (optind
>= argc
) {
563 filename
= argv
[optind
++];
565 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
569 ret
= bdrv_commit(bs
);
572 printf("Image committed.\n");
575 error("No disk inserted");
578 error("Image is read-only");
581 error("Image is already committed");
584 error("Error while committing image");
595 static int is_not_zero(const uint8_t *sector
, int len
)
599 for(i
= 0;i
< len
; i
++) {
600 if (((uint32_t *)sector
)[i
] != 0)
607 * Returns true iff the first sector pointed to by 'buf' contains at least
610 * 'pnum' is set to the number of sectors (including and immediately following
611 * the first one) that are known to be in the same allocated/unallocated state.
613 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
621 v
= is_not_zero(buf
, 512);
622 for(i
= 1; i
< n
; i
++) {
624 if (v
!= is_not_zero(buf
, 512))
632 * Compares two buffers sector by sector. Returns 0 if the first sector of both
633 * buffers matches, non-zero otherwise.
635 * pnum is set to the number of sectors (including and immediately following
636 * the first one) that are known to have the same comparison result
638 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
648 res
= !!memcmp(buf1
, buf2
, 512);
649 for(i
= 1; i
< n
; i
++) {
653 if (!!memcmp(buf1
, buf2
, 512) != res
) {
662 #define IO_BUF_SIZE (2 * 1024 * 1024)
664 static int img_convert(int argc
, char **argv
)
666 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
667 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
668 BlockDriver
*drv
, *proto_drv
;
669 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
670 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
672 uint8_t * buf
= NULL
;
675 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
676 QEMUOptionParameter
*out_baseimg_param
;
677 char *options
= NULL
;
678 const char *snapshot_name
= NULL
;
685 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
701 out_baseimg
= optarg
;
707 error("qemu-img: option -e is deprecated, please use \'-o "
708 "encryption\' instead!");
711 error("qemu-img: option -6 is deprecated, please use \'-o "
712 "compat6\' instead!");
718 snapshot_name
= optarg
;
723 bs_n
= argc
- optind
- 1;
728 out_filename
= argv
[argc
- 1];
730 if (options
&& !strcmp(options
, "?")) {
731 ret
= print_block_option_help(out_filename
, out_fmt
);
735 if (bs_n
> 1 && out_baseimg
) {
736 error("-B makes no sense when concatenating multiple input images");
741 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
744 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
745 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
747 error("Could not open '%s'", argv
[optind
+ bs_i
]);
751 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
752 total_sectors
+= bs_sectors
;
755 if (snapshot_name
!= NULL
) {
757 error("No support for concatenating multiple snapshot\n");
761 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
762 error("Failed to load snapshot\n");
768 /* Find driver and parse its options */
769 drv
= bdrv_find_format(out_fmt
);
771 error("Unknown file format '%s'", out_fmt
);
776 proto_drv
= bdrv_find_protocol(out_filename
);
778 error("Unknown protocol '%s'", out_filename
);
783 create_options
= append_option_parameters(create_options
,
784 drv
->create_options
);
785 create_options
= append_option_parameters(create_options
,
786 proto_drv
->create_options
);
789 param
= parse_option_parameters(options
, create_options
, param
);
791 error("Invalid options for file format '%s'.", out_fmt
);
796 param
= parse_option_parameters("", create_options
, param
);
799 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
800 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
805 /* Get backing file name if -o backing_file was used */
806 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
807 if (out_baseimg_param
) {
808 out_baseimg
= out_baseimg_param
->value
.s
;
811 /* Check if compression is supported */
813 QEMUOptionParameter
*encryption
=
814 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
816 if (!drv
->bdrv_write_compressed
) {
817 error("Compression not supported for this file format");
822 if (encryption
&& encryption
->value
.n
) {
823 error("Compression and encryption not supported at the same time");
829 /* Create the new image */
830 ret
= bdrv_create(drv
, out_filename
, param
);
832 if (ret
== -ENOTSUP
) {
833 error("Formatting not supported for file format '%s'", out_fmt
);
834 } else if (ret
== -EFBIG
) {
835 error("The image size is too large for file format '%s'", out_fmt
);
837 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
842 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
843 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
851 bdrv_get_geometry(bs
[0], &bs_sectors
);
852 buf
= qemu_malloc(IO_BUF_SIZE
);
855 ret
= bdrv_get_info(out_bs
, &bdi
);
857 error("could not get block driver info");
860 cluster_size
= bdi
.cluster_size
;
861 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
862 error("invalid cluster size");
866 cluster_sectors
= cluster_size
>> 9;
873 nb_sectors
= total_sectors
- sector_num
;
876 if (nb_sectors
>= cluster_sectors
)
881 bs_num
= sector_num
- bs_offset
;
882 assert (bs_num
>= 0);
885 while (remainder
> 0) {
887 while (bs_num
== bs_sectors
) {
889 assert (bs_i
< bs_n
);
890 bs_offset
+= bs_sectors
;
891 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
893 /* printf("changing part: sector_num=%" PRId64 ", "
894 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
895 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
897 assert (bs_num
< bs_sectors
);
899 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
901 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
903 error("error while reading");
912 assert (remainder
== 0);
914 if (n
< cluster_sectors
) {
915 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
917 if (is_not_zero(buf
, cluster_size
)) {
918 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
921 error("error while compressing sector %" PRId64
,
928 /* signal EOF to align */
929 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
931 int has_zero_init
= bdrv_has_zero_init(out_bs
);
933 sector_num
= 0; // total number of sectors converted so far
935 nb_sectors
= total_sectors
- sector_num
;
936 if (nb_sectors
<= 0) {
939 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
940 n
= (IO_BUF_SIZE
/ 512);
945 while (sector_num
- bs_offset
>= bs_sectors
) {
947 assert (bs_i
< bs_n
);
948 bs_offset
+= bs_sectors
;
949 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
950 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
951 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
952 sector_num, bs_i, bs_offset, bs_sectors); */
955 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
956 n
= bs_offset
+ bs_sectors
- sector_num
;
960 /* If the output image is being created as a copy on write image,
961 assume that sectors which are unallocated in the input image
962 are present in both the output's and input's base images (no
963 need to copy them). */
965 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
970 /* The next 'n1' sectors are allocated in the input image. Copy
971 only those as they may be followed by unallocated sectors. */
978 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
980 error("error while reading");
983 /* NOTE: at the same time we convert, we do not write zero
984 sectors to have a chance to compress the image. Ideally, we
985 should add a specific call to have the info to go faster */
988 /* If the output image is being created as a copy on write image,
989 copy all sectors even the ones containing only NUL bytes,
990 because they may differ from the sectors in the base image.
992 If the output is to a host device, we also write out
993 sectors that are entirely 0, since whatever data was
994 already there is garbage, not 0s. */
995 if (!has_zero_init
|| out_baseimg
||
996 is_allocated_sectors(buf1
, n
, &n1
)) {
997 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
999 error("error while writing");
1010 free_option_parameters(create_options
);
1011 free_option_parameters(param
);
1014 bdrv_delete(out_bs
);
1017 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1019 bdrv_delete(bs
[bs_i
]);
1031 static int64_t get_allocated_file_size(const char *filename
)
1033 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
1034 get_compressed_t get_compressed
;
1037 /* WinNT support GetCompressedFileSize to determine allocate size */
1038 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1039 if (get_compressed
) {
1041 low
= get_compressed(filename
, &high
);
1042 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
1043 return (((int64_t) high
) << 32) + low
;
1046 if (_stati64(filename
, &st
) < 0)
1051 static int64_t get_allocated_file_size(const char *filename
)
1054 if (stat(filename
, &st
) < 0)
1056 return (int64_t)st
.st_blocks
* 512;
1060 static void dump_snapshots(BlockDriverState
*bs
)
1062 QEMUSnapshotInfo
*sn_tab
, *sn
;
1066 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1069 printf("Snapshot list:\n");
1070 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1071 for(i
= 0; i
< nb_sns
; i
++) {
1073 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1078 static int img_info(int argc
, char **argv
)
1081 const char *filename
, *fmt
;
1082 BlockDriverState
*bs
;
1083 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
1084 uint64_t total_sectors
;
1085 int64_t allocated_size
;
1086 char backing_filename
[1024];
1087 char backing_filename2
[1024];
1088 BlockDriverInfo bdi
;
1092 c
= getopt(argc
, argv
, "f:h");
1106 if (optind
>= argc
) {
1109 filename
= argv
[optind
++];
1111 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1115 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1116 bdrv_get_geometry(bs
, &total_sectors
);
1117 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1118 allocated_size
= get_allocated_file_size(filename
);
1119 if (allocated_size
< 0) {
1120 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1122 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1125 printf("image: %s\n"
1127 "virtual size: %s (%" PRId64
" bytes)\n"
1129 filename
, fmt_name
, size_buf
,
1130 (total_sectors
* 512),
1132 if (bdrv_is_encrypted(bs
)) {
1133 printf("encrypted: yes\n");
1135 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1136 if (bdi
.cluster_size
!= 0) {
1137 printf("cluster_size: %d\n", bdi
.cluster_size
);
1140 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1141 if (backing_filename
[0] != '\0') {
1142 path_combine(backing_filename2
, sizeof(backing_filename2
),
1143 filename
, backing_filename
);
1144 printf("backing file: %s (actual path: %s)\n",
1153 #define SNAPSHOT_LIST 1
1154 #define SNAPSHOT_CREATE 2
1155 #define SNAPSHOT_APPLY 3
1156 #define SNAPSHOT_DELETE 4
1158 static int img_snapshot(int argc
, char **argv
)
1160 BlockDriverState
*bs
;
1161 QEMUSnapshotInfo sn
;
1162 char *filename
, *snapshot_name
= NULL
;
1163 int c
, ret
= 0, bdrv_oflags
;
1167 bdrv_oflags
= BDRV_O_RDWR
;
1168 /* Parse commandline parameters */
1170 c
= getopt(argc
, argv
, "la:c:d:h");
1184 action
= SNAPSHOT_LIST
;
1185 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1192 action
= SNAPSHOT_APPLY
;
1193 snapshot_name
= optarg
;
1200 action
= SNAPSHOT_CREATE
;
1201 snapshot_name
= optarg
;
1208 action
= SNAPSHOT_DELETE
;
1209 snapshot_name
= optarg
;
1214 if (optind
>= argc
) {
1217 filename
= argv
[optind
++];
1219 /* Open the image */
1220 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1225 /* Perform the requested action */
1231 case SNAPSHOT_CREATE
:
1232 memset(&sn
, 0, sizeof(sn
));
1233 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1235 qemu_gettimeofday(&tv
);
1236 sn
.date_sec
= tv
.tv_sec
;
1237 sn
.date_nsec
= tv
.tv_usec
* 1000;
1239 ret
= bdrv_snapshot_create(bs
, &sn
);
1241 error("Could not create snapshot '%s': %d (%s)",
1242 snapshot_name
, ret
, strerror(-ret
));
1246 case SNAPSHOT_APPLY
:
1247 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1249 error("Could not apply snapshot '%s': %d (%s)",
1250 snapshot_name
, ret
, strerror(-ret
));
1254 case SNAPSHOT_DELETE
:
1255 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1257 error("Could not delete snapshot '%s': %d (%s)",
1258 snapshot_name
, ret
, strerror(-ret
));
1271 static int img_rebase(int argc
, char **argv
)
1273 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1274 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1276 const char *fmt
, *out_basefmt
, *out_baseimg
;
1280 /* Parse commandline parameters */
1286 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
= NULL
;
1489 QEMUOptionParameter
*param
;
1490 QEMUOptionParameter resize_options
[] = {
1492 .name
= BLOCK_OPT_SIZE
,
1494 .help
= "Virtual disk size"
1501 c
= getopt(argc
, argv
, "f:h");
1515 if (optind
+ 1 >= argc
) {
1518 filename
= argv
[optind
++];
1519 size
= argv
[optind
++];
1521 /* Choose grow, shrink, or absolute resize mode */
1537 param
= parse_option_parameters("", resize_options
, NULL
);
1538 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1539 /* Error message already printed when size parsing fails */
1543 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1544 free_option_parameters(param
);
1546 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1553 total_size
= bdrv_getlength(bs
) + n
* relative
;
1557 if (total_size
<= 0) {
1558 error("New image size must be positive");
1563 ret
= bdrv_truncate(bs
, total_size
);
1566 printf("Image resized.\n");
1569 error("This image format does not support resize");
1572 error("Image is read-only");
1575 error("Error resizing image (%d)", -ret
);
1588 static const img_cmd_t img_cmds
[] = {
1589 #define DEF(option, callback, arg_string) \
1590 { option, callback },
1591 #include "qemu-img-cmds.h"
1597 int main(int argc
, char **argv
)
1599 const img_cmd_t
*cmd
;
1600 const char *cmdname
;
1608 /* find the command */
1609 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1610 if (!strcmp(cmdname
, cmd
->name
)) {
1611 return cmd
->handler(argc
, argv
);