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"
26 #include "qemu-error.h"
29 #include "block_int.h"
36 typedef struct img_cmd_t
{
38 int (*handler
)(int argc
, char **argv
);
41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
44 static void GCC_FMT_ATTR(1, 2) error(const char *fmt
, ...)
48 fprintf(stderr
, "qemu-img: ");
49 vfprintf(stderr
, fmt
, ap
);
50 fprintf(stderr
, "\n");
54 static void format_print(void *opaque
, const char *name
)
59 /* Please keep in synch with qemu-img.texi */
60 static void help(void)
62 const char *help_msg
=
63 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
64 "usage: qemu-img command [command options]\n"
65 "QEMU disk image utility\n"
68 #define DEF(option, callback, arg_string) \
70 #include "qemu-img-cmds.h"
74 "Command parameters:\n"
75 " 'filename' is a disk image filename\n"
76 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
77 " 'size' is the disk image size in bytes. Optional suffixes\n"
78 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
79 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
80 " 'output_filename' is the destination disk image filename\n"
81 " 'output_fmt' is the destination format\n"
82 " 'options' is a comma separated list of format specific options in a\n"
83 " name=value format. Use -o ? for an overview of the options supported by the\n"
85 " '-c' indicates that target image must be compressed (qcow format only)\n"
86 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
87 " match exactly. The image doesn't need a working backing file before\n"
88 " rebasing in this case (useful for renaming the backing file)\n"
89 " '-h' with or without a command shows this help and lists the supported formats\n"
91 "Parameters to snapshot subcommand:\n"
92 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
93 " '-a' applies a snapshot (revert disk to saved state)\n"
94 " '-c' creates a snapshot\n"
95 " '-d' deletes a snapshot\n"
96 " '-l' lists all snapshots in the given image\n";
98 printf("%s\nSupported formats:", help_msg
);
99 bdrv_iterate_format(format_print
, NULL
);
105 /* XXX: put correct support for win32 */
106 static int read_password(char *buf
, int buf_size
)
109 printf("Password: ");
116 if (i
< (buf_size
- 1))
127 static struct termios oldtty
;
129 static void term_exit(void)
131 tcsetattr (0, TCSANOW
, &oldtty
);
134 static void term_init(void)
141 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
142 |INLCR
|IGNCR
|ICRNL
|IXON
);
143 tty
.c_oflag
|= OPOST
;
144 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
145 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
150 tcsetattr (0, TCSANOW
, &tty
);
155 static int read_password(char *buf
, int buf_size
)
160 printf("password: ");
165 ret
= read(0, &ch
, 1);
167 if (errno
== EAGAIN
|| errno
== EINTR
) {
173 } else if (ret
== 0) {
181 if (i
< (buf_size
- 1))
192 static int print_block_option_help(const char *filename
, const char *fmt
)
194 BlockDriver
*drv
, *proto_drv
;
195 QEMUOptionParameter
*create_options
= NULL
;
197 /* Find driver and parse its options */
198 drv
= bdrv_find_format(fmt
);
200 error("Unknown file format '%s'", fmt
);
204 proto_drv
= bdrv_find_protocol(filename
);
206 error("Unknown protocol '%s'", filename
);
210 create_options
= append_option_parameters(create_options
,
211 drv
->create_options
);
212 create_options
= append_option_parameters(create_options
,
213 proto_drv
->create_options
);
214 print_option_help(create_options
);
215 free_option_parameters(create_options
);
219 static BlockDriverState
*bdrv_new_open(const char *filename
,
223 BlockDriverState
*bs
;
229 error("Not enough memory");
233 drv
= bdrv_find_format(fmt
);
235 error("Unknown file format '%s'", fmt
);
241 if (bdrv_open(bs
, filename
, flags
, drv
) < 0) {
242 error("Could not open '%s'", filename
);
245 if (bdrv_is_encrypted(bs
)) {
246 printf("Disk image '%s' is encrypted.\n", filename
);
247 if (read_password(password
, sizeof(password
)) < 0) {
248 error("No password given");
251 if (bdrv_set_key(bs
, password
) < 0) {
252 error("invalid password");
264 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
265 const char *base_filename
,
266 const char *base_fmt
)
269 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
270 error("Backing file not supported for file format '%s'", fmt
);
275 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
276 error("Backing file format not supported for file format '%s'", fmt
);
283 static int img_create(int argc
, char **argv
)
286 uint64_t img_size
= -1;
287 const char *fmt
= "raw";
288 const char *base_fmt
= NULL
;
289 const char *filename
;
290 const char *base_filename
= 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 /* Get image size, if specified */
335 sval
= strtosz_suffix(argv
[optind
++], NULL
, STRTOSZ_DEFSUFFIX_B
);
337 error("Invalid image size specified! You may use k, M, G or "
339 error("kilobytes, megabytes, gigabytes and terabytes.");
343 img_size
= (uint64_t)sval
;
346 if (options
&& !strcmp(options
, "?")) {
347 ret
= print_block_option_help(filename
, fmt
);
351 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
352 options
, img_size
, BDRV_O_FLAGS
);
361 * Checks an image for consistency. Exit codes:
363 * 0 - Check completed, image is good
364 * 1 - Check not completed because of internal errors
365 * 2 - Check completed, image is corrupted
366 * 3 - Check completed, image has leaked clusters, but is good otherwise
368 static int img_check(int argc
, char **argv
)
371 const char *filename
, *fmt
;
372 BlockDriverState
*bs
;
373 BdrvCheckResult result
;
377 c
= getopt(argc
, argv
, "f:h");
391 if (optind
>= argc
) {
394 filename
= argv
[optind
++];
396 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
400 ret
= bdrv_check(bs
, &result
);
402 if (ret
== -ENOTSUP
) {
403 error("This image format does not support checks");
408 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
409 printf("No errors were found on the image.\n");
411 if (result
.corruptions
) {
412 printf("\n%d errors were found on the image.\n"
413 "Data may be corrupted, or further writes to the image "
419 printf("\n%d leaked clusters were found on the image.\n"
420 "This means waste of disk space, but no harm to data.\n",
424 if (result
.check_errors
) {
425 printf("\n%d internal errors have occurred during the check.\n",
426 result
.check_errors
);
432 if (ret
< 0 || result
.check_errors
) {
433 printf("\nAn error has occurred during the check: %s\n"
434 "The check is not complete and may have missed error.\n",
439 if (result
.corruptions
) {
441 } else if (result
.leaks
) {
448 static int img_commit(int argc
, char **argv
)
451 const char *filename
, *fmt
;
452 BlockDriverState
*bs
;
456 c
= getopt(argc
, argv
, "f:h");
470 if (optind
>= argc
) {
473 filename
= argv
[optind
++];
475 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
479 ret
= bdrv_commit(bs
);
482 printf("Image committed.\n");
485 error("No disk inserted");
488 error("Image is read-only");
491 error("Image is already committed");
494 error("Error while committing image");
505 static int is_not_zero(const uint8_t *sector
, int len
)
509 for(i
= 0;i
< len
; i
++) {
510 if (((uint32_t *)sector
)[i
] != 0)
517 * Returns true iff the first sector pointed to by 'buf' contains at least
520 * 'pnum' is set to the number of sectors (including and immediately following
521 * the first one) that are known to be in the same allocated/unallocated state.
523 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
531 v
= is_not_zero(buf
, 512);
532 for(i
= 1; i
< n
; i
++) {
534 if (v
!= is_not_zero(buf
, 512))
542 * Compares two buffers sector by sector. Returns 0 if the first sector of both
543 * buffers matches, non-zero otherwise.
545 * pnum is set to the number of sectors (including and immediately following
546 * the first one) that are known to have the same comparison result
548 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
558 res
= !!memcmp(buf1
, buf2
, 512);
559 for(i
= 1; i
< n
; i
++) {
563 if (!!memcmp(buf1
, buf2
, 512) != res
) {
572 #define IO_BUF_SIZE (2 * 1024 * 1024)
574 static int img_convert(int argc
, char **argv
)
576 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
577 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
578 BlockDriver
*drv
, *proto_drv
;
579 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
580 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
582 uint8_t * buf
= NULL
;
585 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
586 QEMUOptionParameter
*out_baseimg_param
;
587 char *options
= NULL
;
588 const char *snapshot_name
= NULL
;
595 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
611 out_baseimg
= optarg
;
617 error("qemu-img: option -e is deprecated, please use \'-o "
618 "encryption\' instead!");
621 error("qemu-img: option -6 is deprecated, please use \'-o "
622 "compat6\' instead!");
628 snapshot_name
= optarg
;
633 bs_n
= argc
- optind
- 1;
638 out_filename
= argv
[argc
- 1];
640 if (options
&& !strcmp(options
, "?")) {
641 ret
= print_block_option_help(out_filename
, out_fmt
);
645 if (bs_n
> 1 && out_baseimg
) {
646 error("-B makes no sense when concatenating multiple input images");
651 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
654 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
655 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
657 error("Could not open '%s'", argv
[optind
+ bs_i
]);
661 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
662 total_sectors
+= bs_sectors
;
665 if (snapshot_name
!= NULL
) {
667 error("No support for concatenating multiple snapshot\n");
671 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
672 error("Failed to load snapshot\n");
678 /* Find driver and parse its options */
679 drv
= bdrv_find_format(out_fmt
);
681 error("Unknown file format '%s'", out_fmt
);
686 proto_drv
= bdrv_find_protocol(out_filename
);
688 error("Unknown protocol '%s'", out_filename
);
693 create_options
= append_option_parameters(create_options
,
694 drv
->create_options
);
695 create_options
= append_option_parameters(create_options
,
696 proto_drv
->create_options
);
699 param
= parse_option_parameters(options
, create_options
, param
);
701 error("Invalid options for file format '%s'.", out_fmt
);
706 param
= parse_option_parameters("", create_options
, param
);
709 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
710 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
715 /* Get backing file name if -o backing_file was used */
716 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
717 if (out_baseimg_param
) {
718 out_baseimg
= out_baseimg_param
->value
.s
;
721 /* Check if compression is supported */
723 QEMUOptionParameter
*encryption
=
724 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
726 if (!drv
->bdrv_write_compressed
) {
727 error("Compression not supported for this file format");
732 if (encryption
&& encryption
->value
.n
) {
733 error("Compression and encryption not supported at the same time");
739 /* Create the new image */
740 ret
= bdrv_create(drv
, out_filename
, param
);
742 if (ret
== -ENOTSUP
) {
743 error("Formatting not supported for file format '%s'", out_fmt
);
744 } else if (ret
== -EFBIG
) {
745 error("The image size is too large for file format '%s'", out_fmt
);
747 error("%s: error while converting %s: %s", out_filename
, out_fmt
, strerror(-ret
));
752 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
753 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
761 bdrv_get_geometry(bs
[0], &bs_sectors
);
762 buf
= qemu_malloc(IO_BUF_SIZE
);
765 ret
= bdrv_get_info(out_bs
, &bdi
);
767 error("could not get block driver info");
770 cluster_size
= bdi
.cluster_size
;
771 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
772 error("invalid cluster size");
776 cluster_sectors
= cluster_size
>> 9;
783 nb_sectors
= total_sectors
- sector_num
;
786 if (nb_sectors
>= cluster_sectors
)
791 bs_num
= sector_num
- bs_offset
;
792 assert (bs_num
>= 0);
795 while (remainder
> 0) {
797 while (bs_num
== bs_sectors
) {
799 assert (bs_i
< bs_n
);
800 bs_offset
+= bs_sectors
;
801 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
803 /* printf("changing part: sector_num=%" PRId64 ", "
804 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
805 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
807 assert (bs_num
< bs_sectors
);
809 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
811 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
813 error("error while reading");
822 assert (remainder
== 0);
824 if (n
< cluster_sectors
) {
825 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
827 if (is_not_zero(buf
, cluster_size
)) {
828 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
831 error("error while compressing sector %" PRId64
,
838 /* signal EOF to align */
839 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
841 int has_zero_init
= bdrv_has_zero_init(out_bs
);
843 sector_num
= 0; // total number of sectors converted so far
845 nb_sectors
= total_sectors
- sector_num
;
846 if (nb_sectors
<= 0) {
849 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
850 n
= (IO_BUF_SIZE
/ 512);
855 while (sector_num
- bs_offset
>= bs_sectors
) {
857 assert (bs_i
< bs_n
);
858 bs_offset
+= bs_sectors
;
859 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
860 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
861 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
862 sector_num, bs_i, bs_offset, bs_sectors); */
865 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
866 n
= bs_offset
+ bs_sectors
- sector_num
;
870 /* If the output image is being created as a copy on write image,
871 assume that sectors which are unallocated in the input image
872 are present in both the output's and input's base images (no
873 need to copy them). */
875 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
880 /* The next 'n1' sectors are allocated in the input image. Copy
881 only those as they may be followed by unallocated sectors. */
888 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
890 error("error while reading");
893 /* NOTE: at the same time we convert, we do not write zero
894 sectors to have a chance to compress the image. Ideally, we
895 should add a specific call to have the info to go faster */
898 /* If the output image is being created as a copy on write image,
899 copy all sectors even the ones containing only NUL bytes,
900 because they may differ from the sectors in the base image.
902 If the output is to a host device, we also write out
903 sectors that are entirely 0, since whatever data was
904 already there is garbage, not 0s. */
905 if (!has_zero_init
|| out_baseimg
||
906 is_allocated_sectors(buf1
, n
, &n1
)) {
907 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
909 error("error while writing");
920 free_option_parameters(create_options
);
921 free_option_parameters(param
);
927 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
929 bdrv_delete(bs
[bs_i
]);
941 static int64_t get_allocated_file_size(const char *filename
)
943 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
944 get_compressed_t get_compressed
;
947 /* WinNT support GetCompressedFileSize to determine allocate size */
948 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
949 if (get_compressed
) {
951 low
= get_compressed(filename
, &high
);
952 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
953 return (((int64_t) high
) << 32) + low
;
956 if (_stati64(filename
, &st
) < 0)
961 static int64_t get_allocated_file_size(const char *filename
)
964 if (stat(filename
, &st
) < 0)
966 return (int64_t)st
.st_blocks
* 512;
970 static void dump_snapshots(BlockDriverState
*bs
)
972 QEMUSnapshotInfo
*sn_tab
, *sn
;
976 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
979 printf("Snapshot list:\n");
980 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
981 for(i
= 0; i
< nb_sns
; i
++) {
983 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
988 static int img_info(int argc
, char **argv
)
991 const char *filename
, *fmt
;
992 BlockDriverState
*bs
;
993 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
994 uint64_t total_sectors
;
995 int64_t allocated_size
;
996 char backing_filename
[1024];
997 char backing_filename2
[1024];
1002 c
= getopt(argc
, argv
, "f:h");
1016 if (optind
>= argc
) {
1019 filename
= argv
[optind
++];
1021 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1025 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1026 bdrv_get_geometry(bs
, &total_sectors
);
1027 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1028 allocated_size
= get_allocated_file_size(filename
);
1029 if (allocated_size
< 0) {
1030 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1032 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1035 printf("image: %s\n"
1037 "virtual size: %s (%" PRId64
" bytes)\n"
1039 filename
, fmt_name
, size_buf
,
1040 (total_sectors
* 512),
1042 if (bdrv_is_encrypted(bs
)) {
1043 printf("encrypted: yes\n");
1045 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1046 if (bdi
.cluster_size
!= 0) {
1047 printf("cluster_size: %d\n", bdi
.cluster_size
);
1050 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1051 if (backing_filename
[0] != '\0') {
1052 path_combine(backing_filename2
, sizeof(backing_filename2
),
1053 filename
, backing_filename
);
1054 printf("backing file: %s (actual path: %s)\n",
1063 #define SNAPSHOT_LIST 1
1064 #define SNAPSHOT_CREATE 2
1065 #define SNAPSHOT_APPLY 3
1066 #define SNAPSHOT_DELETE 4
1068 static int img_snapshot(int argc
, char **argv
)
1070 BlockDriverState
*bs
;
1071 QEMUSnapshotInfo sn
;
1072 char *filename
, *snapshot_name
= NULL
;
1073 int c
, ret
= 0, bdrv_oflags
;
1077 bdrv_oflags
= BDRV_O_RDWR
;
1078 /* Parse commandline parameters */
1080 c
= getopt(argc
, argv
, "la:c:d:h");
1094 action
= SNAPSHOT_LIST
;
1095 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1102 action
= SNAPSHOT_APPLY
;
1103 snapshot_name
= optarg
;
1110 action
= SNAPSHOT_CREATE
;
1111 snapshot_name
= optarg
;
1118 action
= SNAPSHOT_DELETE
;
1119 snapshot_name
= optarg
;
1124 if (optind
>= argc
) {
1127 filename
= argv
[optind
++];
1129 /* Open the image */
1130 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1135 /* Perform the requested action */
1141 case SNAPSHOT_CREATE
:
1142 memset(&sn
, 0, sizeof(sn
));
1143 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1145 qemu_gettimeofday(&tv
);
1146 sn
.date_sec
= tv
.tv_sec
;
1147 sn
.date_nsec
= tv
.tv_usec
* 1000;
1149 ret
= bdrv_snapshot_create(bs
, &sn
);
1151 error("Could not create snapshot '%s': %d (%s)",
1152 snapshot_name
, ret
, strerror(-ret
));
1156 case SNAPSHOT_APPLY
:
1157 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1159 error("Could not apply snapshot '%s': %d (%s)",
1160 snapshot_name
, ret
, strerror(-ret
));
1164 case SNAPSHOT_DELETE
:
1165 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1167 error("Could not delete snapshot '%s': %d (%s)",
1168 snapshot_name
, ret
, strerror(-ret
));
1181 static int img_rebase(int argc
, char **argv
)
1183 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1184 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1186 const char *fmt
, *out_basefmt
, *out_baseimg
;
1190 /* Parse commandline parameters */
1196 c
= getopt(argc
, argv
, "uhf:F:b:");
1209 out_basefmt
= optarg
;
1212 out_baseimg
= optarg
;
1220 if ((optind
>= argc
) || !out_baseimg
) {
1223 filename
= argv
[optind
++];
1228 * Ignore the old backing file for unsafe rebase in case we want to correct
1229 * the reference to a renamed or moved backing file.
1231 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1232 bs
= bdrv_new_open(filename
, fmt
, flags
);
1237 /* Find the right drivers for the backing files */
1238 old_backing_drv
= NULL
;
1239 new_backing_drv
= NULL
;
1241 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1242 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1243 if (old_backing_drv
== NULL
) {
1244 error("Invalid format name: '%s'", bs
->backing_format
);
1250 if (out_basefmt
!= NULL
) {
1251 new_backing_drv
= bdrv_find_format(out_basefmt
);
1252 if (new_backing_drv
== NULL
) {
1253 error("Invalid format name: '%s'", out_basefmt
);
1259 /* For safe rebasing we need to compare old and new backing file */
1261 /* Make the compiler happy */
1262 bs_old_backing
= NULL
;
1263 bs_new_backing
= NULL
;
1265 char backing_name
[1024];
1267 bs_old_backing
= bdrv_new("old_backing");
1268 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1269 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1272 error("Could not open old backing file '%s'", backing_name
);
1276 bs_new_backing
= bdrv_new("new_backing");
1277 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1280 error("Could not open new backing file '%s'", out_baseimg
);
1286 * Check each unallocated cluster in the COW file. If it is unallocated,
1287 * accesses go to the backing file. We must therefore compare this cluster
1288 * in the old and new backing file, and if they differ we need to copy it
1289 * from the old backing file into the COW file.
1291 * If qemu-img crashes during this step, no harm is done. The content of
1292 * the image is the same as the original one at any time.
1295 uint64_t num_sectors
;
1301 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1302 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1304 bdrv_get_geometry(bs
, &num_sectors
);
1306 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1308 /* How many sectors can we handle with the next read? */
1309 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1310 n
= (IO_BUF_SIZE
/ 512);
1312 n
= num_sectors
- sector
;
1315 /* If the cluster is allocated, we don't need to take action */
1316 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1321 /* Read old and new backing file */
1322 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1324 error("error while reading from old backing file");
1327 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1329 error("error while reading from new backing file");
1333 /* If they differ, we need to write to the COW file */
1334 uint64_t written
= 0;
1336 while (written
< n
) {
1339 if (compare_sectors(buf_old
+ written
* 512,
1340 buf_new
+ written
* 512, n
- written
, &pnum
))
1342 ret
= bdrv_write(bs
, sector
+ written
,
1343 buf_old
+ written
* 512, pnum
);
1345 error("Error while writing to COW image: %s",
1360 * Change the backing file. All clusters that are different from the old
1361 * backing file are overwritten in the COW file now, so the visible content
1362 * doesn't change when we switch the backing file.
1364 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1365 if (ret
== -ENOSPC
) {
1366 error("Could not change the backing file to '%s': No space left in "
1367 "the file header", out_baseimg
);
1368 } else if (ret
< 0) {
1369 error("Could not change the backing file to '%s': %s",
1370 out_baseimg
, strerror(-ret
));
1374 * TODO At this point it is possible to check if any clusters that are
1375 * allocated in the COW file are the same in the backing file. If so, they
1376 * could be dropped from the COW file. Don't do this before switching the
1377 * backing file, in case of a crash this would lead to corruption.
1382 bdrv_delete(bs_old_backing
);
1383 bdrv_delete(bs_new_backing
);
1393 static int img_resize(int argc
, char **argv
)
1395 int c
, ret
, relative
;
1396 const char *filename
, *fmt
, *size
;
1397 int64_t n
, total_size
;
1398 BlockDriverState
*bs
= NULL
;
1399 QEMUOptionParameter
*param
;
1400 QEMUOptionParameter resize_options
[] = {
1402 .name
= BLOCK_OPT_SIZE
,
1404 .help
= "Virtual disk size"
1411 c
= getopt(argc
, argv
, "f:h");
1425 if (optind
+ 1 >= argc
) {
1428 filename
= argv
[optind
++];
1429 size
= argv
[optind
++];
1431 /* Choose grow, shrink, or absolute resize mode */
1447 param
= parse_option_parameters("", resize_options
, NULL
);
1448 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1449 /* Error message already printed when size parsing fails */
1453 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1454 free_option_parameters(param
);
1456 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1463 total_size
= bdrv_getlength(bs
) + n
* relative
;
1467 if (total_size
<= 0) {
1468 error("New image size must be positive");
1473 ret
= bdrv_truncate(bs
, total_size
);
1476 printf("Image resized.\n");
1479 error("This image format does not support resize");
1482 error("Image is read-only");
1485 error("Error resizing image (%d)", -ret
);
1498 static const img_cmd_t img_cmds
[] = {
1499 #define DEF(option, callback, arg_string) \
1500 { option, callback },
1501 #include "qemu-img-cmds.h"
1507 int main(int argc
, char **argv
)
1509 const img_cmd_t
*cmd
;
1510 const char *cmdname
;
1512 error_set_progname(argv
[0]);
1520 /* find the command */
1521 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1522 if (!strcmp(cmdname
, cmd
->name
)) {
1523 return cmd
->handler(argc
, argv
);