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 format_print(void *opaque
, const char *name
)
49 /* Please keep in synch with qemu-img.texi */
50 static void help(void)
52 const char *help_msg
=
53 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
54 "usage: qemu-img command [command options]\n"
55 "QEMU disk image utility\n"
58 #define DEF(option, callback, arg_string) \
60 #include "qemu-img-cmds.h"
64 "Command parameters:\n"
65 " 'filename' is a disk image filename\n"
66 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
67 " 'size' is the disk image size in bytes. Optional suffixes\n"
68 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
69 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
70 " 'output_filename' is the destination disk image filename\n"
71 " 'output_fmt' is the destination format\n"
72 " 'options' is a comma separated list of format specific options in a\n"
73 " name=value format. Use -o ? for an overview of the options supported by the\n"
75 " '-c' indicates that target image must be compressed (qcow format only)\n"
76 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
77 " match exactly. The image doesn't need a working backing file before\n"
78 " rebasing in this case (useful for renaming the backing file)\n"
79 " '-h' with or without a command shows this help and lists the supported formats\n"
81 "Parameters to snapshot subcommand:\n"
82 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
83 " '-a' applies a snapshot (revert disk to saved state)\n"
84 " '-c' creates a snapshot\n"
85 " '-d' deletes a snapshot\n"
86 " '-l' lists all snapshots in the given image\n";
88 printf("%s\nSupported formats:", help_msg
);
89 bdrv_iterate_format(format_print
, NULL
);
95 /* XXX: put correct support for win32 */
96 static int read_password(char *buf
, int buf_size
)
106 if (i
< (buf_size
- 1))
117 static struct termios oldtty
;
119 static void term_exit(void)
121 tcsetattr (0, TCSANOW
, &oldtty
);
124 static void term_init(void)
131 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
132 |INLCR
|IGNCR
|ICRNL
|IXON
);
133 tty
.c_oflag
|= OPOST
;
134 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
135 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
140 tcsetattr (0, TCSANOW
, &tty
);
145 static int read_password(char *buf
, int buf_size
)
150 printf("password: ");
155 ret
= read(0, &ch
, 1);
157 if (errno
== EAGAIN
|| errno
== EINTR
) {
163 } else if (ret
== 0) {
171 if (i
< (buf_size
- 1))
182 static int print_block_option_help(const char *filename
, const char *fmt
)
184 BlockDriver
*drv
, *proto_drv
;
185 QEMUOptionParameter
*create_options
= NULL
;
187 /* Find driver and parse its options */
188 drv
= bdrv_find_format(fmt
);
190 error_report("Unknown file format '%s'", fmt
);
194 proto_drv
= bdrv_find_protocol(filename
);
196 error_report("Unknown protocol '%s'", filename
);
200 create_options
= append_option_parameters(create_options
,
201 drv
->create_options
);
202 create_options
= append_option_parameters(create_options
,
203 proto_drv
->create_options
);
204 print_option_help(create_options
);
205 free_option_parameters(create_options
);
209 static BlockDriverState
*bdrv_new_open(const char *filename
,
213 BlockDriverState
*bs
;
219 error_report("Not enough memory");
223 drv
= bdrv_find_format(fmt
);
225 error_report("Unknown file format '%s'", fmt
);
231 if (bdrv_open(bs
, filename
, flags
, drv
) < 0) {
232 error_report("Could not open '%s'", filename
);
235 if (bdrv_is_encrypted(bs
)) {
236 printf("Disk image '%s' is encrypted.\n", filename
);
237 if (read_password(password
, sizeof(password
)) < 0) {
238 error_report("No password given");
241 if (bdrv_set_key(bs
, password
) < 0) {
242 error_report("invalid password");
254 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
255 const char *base_filename
,
256 const char *base_fmt
)
259 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
260 error_report("Backing file not supported for file format '%s'",
266 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
267 error_report("Backing file format not supported for file "
275 static int img_create(int argc
, char **argv
)
278 uint64_t img_size
= -1;
279 const char *fmt
= "raw";
280 const char *base_fmt
= NULL
;
281 const char *filename
;
282 const char *base_filename
= NULL
;
283 char *options
= NULL
;
286 c
= getopt(argc
, argv
, "F:b:f:he6o:");
299 base_filename
= optarg
;
305 error_report("qemu-img: option -e is deprecated, please use \'-o "
306 "encryption\' instead!");
309 error_report("qemu-img: option -6 is deprecated, please use \'-o "
310 "compat6\' instead!");
318 /* Get the filename */
319 if (optind
>= argc
) {
322 filename
= argv
[optind
++];
324 /* Get image size, if specified */
327 sval
= strtosz_suffix(argv
[optind
++], NULL
, STRTOSZ_DEFSUFFIX_B
);
329 error_report("Invalid image size specified! You may use k, M, G or "
331 error_report("kilobytes, megabytes, gigabytes and terabytes.");
335 img_size
= (uint64_t)sval
;
338 if (options
&& !strcmp(options
, "?")) {
339 ret
= print_block_option_help(filename
, fmt
);
343 ret
= bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
344 options
, img_size
, BDRV_O_FLAGS
);
353 * Checks an image for consistency. Exit codes:
355 * 0 - Check completed, image is good
356 * 1 - Check not completed because of internal errors
357 * 2 - Check completed, image is corrupted
358 * 3 - Check completed, image has leaked clusters, but is good otherwise
360 static int img_check(int argc
, char **argv
)
363 const char *filename
, *fmt
;
364 BlockDriverState
*bs
;
365 BdrvCheckResult result
;
369 c
= getopt(argc
, argv
, "f:h");
383 if (optind
>= argc
) {
386 filename
= argv
[optind
++];
388 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
);
392 ret
= bdrv_check(bs
, &result
);
394 if (ret
== -ENOTSUP
) {
395 error_report("This image format does not support checks");
400 if (!(result
.corruptions
|| result
.leaks
|| result
.check_errors
)) {
401 printf("No errors were found on the image.\n");
403 if (result
.corruptions
) {
404 printf("\n%d errors were found on the image.\n"
405 "Data may be corrupted, or further writes to the image "
411 printf("\n%d leaked clusters were found on the image.\n"
412 "This means waste of disk space, but no harm to data.\n",
416 if (result
.check_errors
) {
417 printf("\n%d internal errors have occurred during the check.\n",
418 result
.check_errors
);
424 if (ret
< 0 || result
.check_errors
) {
425 printf("\nAn error has occurred during the check: %s\n"
426 "The check is not complete and may have missed error.\n",
431 if (result
.corruptions
) {
433 } else if (result
.leaks
) {
440 static int img_commit(int argc
, char **argv
)
443 const char *filename
, *fmt
;
444 BlockDriverState
*bs
;
448 c
= getopt(argc
, argv
, "f:h");
462 if (optind
>= argc
) {
465 filename
= argv
[optind
++];
467 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
471 ret
= bdrv_commit(bs
);
474 printf("Image committed.\n");
477 error_report("No disk inserted");
480 error_report("Image is read-only");
483 error_report("Image is already committed");
486 error_report("Error while committing image");
497 static int is_not_zero(const uint8_t *sector
, int len
)
501 for(i
= 0;i
< len
; i
++) {
502 if (((uint32_t *)sector
)[i
] != 0)
509 * Returns true iff the first sector pointed to by 'buf' contains at least
512 * 'pnum' is set to the number of sectors (including and immediately following
513 * the first one) that are known to be in the same allocated/unallocated state.
515 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
523 v
= is_not_zero(buf
, 512);
524 for(i
= 1; i
< n
; i
++) {
526 if (v
!= is_not_zero(buf
, 512))
534 * Compares two buffers sector by sector. Returns 0 if the first sector of both
535 * buffers matches, non-zero otherwise.
537 * pnum is set to the number of sectors (including and immediately following
538 * the first one) that are known to have the same comparison result
540 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
550 res
= !!memcmp(buf1
, buf2
, 512);
551 for(i
= 1; i
< n
; i
++) {
555 if (!!memcmp(buf1
, buf2
, 512) != res
) {
564 #define IO_BUF_SIZE (2 * 1024 * 1024)
566 static int img_convert(int argc
, char **argv
)
568 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
569 const char *fmt
, *out_fmt
, *out_baseimg
, *out_filename
;
570 BlockDriver
*drv
, *proto_drv
;
571 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
572 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
574 uint8_t * buf
= NULL
;
577 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
578 QEMUOptionParameter
*out_baseimg_param
;
579 char *options
= NULL
;
580 const char *snapshot_name
= NULL
;
587 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:");
603 out_baseimg
= optarg
;
609 error_report("qemu-img: option -e is deprecated, please use \'-o "
610 "encryption\' instead!");
613 error_report("qemu-img: option -6 is deprecated, please use \'-o "
614 "compat6\' instead!");
620 snapshot_name
= optarg
;
625 bs_n
= argc
- optind
- 1;
630 out_filename
= argv
[argc
- 1];
632 if (options
&& !strcmp(options
, "?")) {
633 ret
= print_block_option_help(out_filename
, out_fmt
);
637 if (bs_n
> 1 && out_baseimg
) {
638 error_report("-B makes no sense when concatenating multiple input "
644 bs
= qemu_mallocz(bs_n
* sizeof(BlockDriverState
*));
647 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
648 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
);
650 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
654 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
655 total_sectors
+= bs_sectors
;
658 if (snapshot_name
!= NULL
) {
660 error_report("No support for concatenating multiple snapshot\n");
664 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
665 error_report("Failed to load snapshot\n");
671 /* Find driver and parse its options */
672 drv
= bdrv_find_format(out_fmt
);
674 error_report("Unknown file format '%s'", out_fmt
);
679 proto_drv
= bdrv_find_protocol(out_filename
);
681 error_report("Unknown protocol '%s'", out_filename
);
686 create_options
= append_option_parameters(create_options
,
687 drv
->create_options
);
688 create_options
= append_option_parameters(create_options
,
689 proto_drv
->create_options
);
692 param
= parse_option_parameters(options
, create_options
, param
);
694 error_report("Invalid options for file format '%s'.", out_fmt
);
699 param
= parse_option_parameters("", create_options
, param
);
702 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
703 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
708 /* Get backing file name if -o backing_file was used */
709 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
710 if (out_baseimg_param
) {
711 out_baseimg
= out_baseimg_param
->value
.s
;
714 /* Check if compression is supported */
716 QEMUOptionParameter
*encryption
=
717 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
719 if (!drv
->bdrv_write_compressed
) {
720 error_report("Compression not supported for this file format");
725 if (encryption
&& encryption
->value
.n
) {
726 error_report("Compression and encryption not supported at "
733 /* Create the new image */
734 ret
= bdrv_create(drv
, out_filename
, param
);
736 if (ret
== -ENOTSUP
) {
737 error_report("Formatting not supported for file format '%s'",
739 } else if (ret
== -EFBIG
) {
740 error_report("The image size is too large for file format '%s'",
743 error_report("%s: error while converting %s: %s",
744 out_filename
, out_fmt
, strerror(-ret
));
749 out_bs
= bdrv_new_open(out_filename
, out_fmt
,
750 BDRV_O_FLAGS
| BDRV_O_RDWR
| BDRV_O_NO_FLUSH
);
758 bdrv_get_geometry(bs
[0], &bs_sectors
);
759 buf
= qemu_malloc(IO_BUF_SIZE
);
762 ret
= bdrv_get_info(out_bs
, &bdi
);
764 error_report("could not get block driver info");
767 cluster_size
= bdi
.cluster_size
;
768 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
769 error_report("invalid cluster size");
773 cluster_sectors
= cluster_size
>> 9;
780 nb_sectors
= total_sectors
- sector_num
;
783 if (nb_sectors
>= cluster_sectors
)
788 bs_num
= sector_num
- bs_offset
;
789 assert (bs_num
>= 0);
792 while (remainder
> 0) {
794 while (bs_num
== bs_sectors
) {
796 assert (bs_i
< bs_n
);
797 bs_offset
+= bs_sectors
;
798 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
800 /* printf("changing part: sector_num=%" PRId64 ", "
801 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
802 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
804 assert (bs_num
< bs_sectors
);
806 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
808 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
810 error_report("error while reading");
819 assert (remainder
== 0);
821 if (n
< cluster_sectors
) {
822 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
824 if (is_not_zero(buf
, cluster_size
)) {
825 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
828 error_report("error while compressing sector %" PRId64
,
835 /* signal EOF to align */
836 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
838 int has_zero_init
= bdrv_has_zero_init(out_bs
);
840 sector_num
= 0; // total number of sectors converted so far
842 nb_sectors
= total_sectors
- sector_num
;
843 if (nb_sectors
<= 0) {
846 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
847 n
= (IO_BUF_SIZE
/ 512);
852 while (sector_num
- bs_offset
>= bs_sectors
) {
854 assert (bs_i
< bs_n
);
855 bs_offset
+= bs_sectors
;
856 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
857 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
858 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
859 sector_num, bs_i, bs_offset, bs_sectors); */
862 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
863 n
= bs_offset
+ bs_sectors
- sector_num
;
867 /* If the output image is being created as a copy on write image,
868 assume that sectors which are unallocated in the input image
869 are present in both the output's and input's base images (no
870 need to copy them). */
872 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
877 /* The next 'n1' sectors are allocated in the input image. Copy
878 only those as they may be followed by unallocated sectors. */
885 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
887 error_report("error while reading");
890 /* NOTE: at the same time we convert, we do not write zero
891 sectors to have a chance to compress the image. Ideally, we
892 should add a specific call to have the info to go faster */
895 /* If the output image is being created as a copy on write image,
896 copy all sectors even the ones containing only NUL bytes,
897 because they may differ from the sectors in the base image.
899 If the output is to a host device, we also write out
900 sectors that are entirely 0, since whatever data was
901 already there is garbage, not 0s. */
902 if (!has_zero_init
|| out_baseimg
||
903 is_allocated_sectors(buf1
, n
, &n1
)) {
904 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
906 error_report("error while writing");
917 free_option_parameters(create_options
);
918 free_option_parameters(param
);
924 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
926 bdrv_delete(bs
[bs_i
]);
938 static int64_t get_allocated_file_size(const char *filename
)
940 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
, DWORD
*high
);
941 get_compressed_t get_compressed
;
944 /* WinNT support GetCompressedFileSize to determine allocate size */
945 get_compressed
= (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
946 if (get_compressed
) {
948 low
= get_compressed(filename
, &high
);
949 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
)
950 return (((int64_t) high
) << 32) + low
;
953 if (_stati64(filename
, &st
) < 0)
958 static int64_t get_allocated_file_size(const char *filename
)
961 if (stat(filename
, &st
) < 0)
963 return (int64_t)st
.st_blocks
* 512;
967 static void dump_snapshots(BlockDriverState
*bs
)
969 QEMUSnapshotInfo
*sn_tab
, *sn
;
973 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
976 printf("Snapshot list:\n");
977 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
978 for(i
= 0; i
< nb_sns
; i
++) {
980 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
985 static int img_info(int argc
, char **argv
)
988 const char *filename
, *fmt
;
989 BlockDriverState
*bs
;
990 char fmt_name
[128], size_buf
[128], dsize_buf
[128];
991 uint64_t total_sectors
;
992 int64_t allocated_size
;
993 char backing_filename
[1024];
994 char backing_filename2
[1024];
999 c
= getopt(argc
, argv
, "f:h");
1013 if (optind
>= argc
) {
1016 filename
= argv
[optind
++];
1018 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
);
1022 bdrv_get_format(bs
, fmt_name
, sizeof(fmt_name
));
1023 bdrv_get_geometry(bs
, &total_sectors
);
1024 get_human_readable_size(size_buf
, sizeof(size_buf
), total_sectors
* 512);
1025 allocated_size
= get_allocated_file_size(filename
);
1026 if (allocated_size
< 0) {
1027 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1029 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1032 printf("image: %s\n"
1034 "virtual size: %s (%" PRId64
" bytes)\n"
1036 filename
, fmt_name
, size_buf
,
1037 (total_sectors
* 512),
1039 if (bdrv_is_encrypted(bs
)) {
1040 printf("encrypted: yes\n");
1042 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1043 if (bdi
.cluster_size
!= 0) {
1044 printf("cluster_size: %d\n", bdi
.cluster_size
);
1047 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1048 if (backing_filename
[0] != '\0') {
1049 path_combine(backing_filename2
, sizeof(backing_filename2
),
1050 filename
, backing_filename
);
1051 printf("backing file: %s (actual path: %s)\n",
1060 #define SNAPSHOT_LIST 1
1061 #define SNAPSHOT_CREATE 2
1062 #define SNAPSHOT_APPLY 3
1063 #define SNAPSHOT_DELETE 4
1065 static int img_snapshot(int argc
, char **argv
)
1067 BlockDriverState
*bs
;
1068 QEMUSnapshotInfo sn
;
1069 char *filename
, *snapshot_name
= NULL
;
1070 int c
, ret
= 0, bdrv_oflags
;
1074 bdrv_oflags
= BDRV_O_RDWR
;
1075 /* Parse commandline parameters */
1077 c
= getopt(argc
, argv
, "la:c:d:h");
1091 action
= SNAPSHOT_LIST
;
1092 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1099 action
= SNAPSHOT_APPLY
;
1100 snapshot_name
= optarg
;
1107 action
= SNAPSHOT_CREATE
;
1108 snapshot_name
= optarg
;
1115 action
= SNAPSHOT_DELETE
;
1116 snapshot_name
= optarg
;
1121 if (optind
>= argc
) {
1124 filename
= argv
[optind
++];
1126 /* Open the image */
1127 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
);
1132 /* Perform the requested action */
1138 case SNAPSHOT_CREATE
:
1139 memset(&sn
, 0, sizeof(sn
));
1140 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1142 qemu_gettimeofday(&tv
);
1143 sn
.date_sec
= tv
.tv_sec
;
1144 sn
.date_nsec
= tv
.tv_usec
* 1000;
1146 ret
= bdrv_snapshot_create(bs
, &sn
);
1148 error_report("Could not create snapshot '%s': %d (%s)",
1149 snapshot_name
, ret
, strerror(-ret
));
1153 case SNAPSHOT_APPLY
:
1154 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1156 error_report("Could not apply snapshot '%s': %d (%s)",
1157 snapshot_name
, ret
, strerror(-ret
));
1161 case SNAPSHOT_DELETE
:
1162 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1164 error_report("Could not delete snapshot '%s': %d (%s)",
1165 snapshot_name
, ret
, strerror(-ret
));
1178 static int img_rebase(int argc
, char **argv
)
1180 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1181 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1183 const char *fmt
, *out_basefmt
, *out_baseimg
;
1187 /* Parse commandline parameters */
1193 c
= getopt(argc
, argv
, "uhf:F:b:");
1206 out_basefmt
= optarg
;
1209 out_baseimg
= optarg
;
1217 if ((optind
>= argc
) || !out_baseimg
) {
1220 filename
= argv
[optind
++];
1225 * Ignore the old backing file for unsafe rebase in case we want to correct
1226 * the reference to a renamed or moved backing file.
1228 flags
= BDRV_O_FLAGS
| BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1229 bs
= bdrv_new_open(filename
, fmt
, flags
);
1234 /* Find the right drivers for the backing files */
1235 old_backing_drv
= NULL
;
1236 new_backing_drv
= NULL
;
1238 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1239 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1240 if (old_backing_drv
== NULL
) {
1241 error_report("Invalid format name: '%s'", bs
->backing_format
);
1247 if (out_basefmt
!= NULL
) {
1248 new_backing_drv
= bdrv_find_format(out_basefmt
);
1249 if (new_backing_drv
== NULL
) {
1250 error_report("Invalid format name: '%s'", out_basefmt
);
1256 /* For safe rebasing we need to compare old and new backing file */
1258 /* Make the compiler happy */
1259 bs_old_backing
= NULL
;
1260 bs_new_backing
= NULL
;
1262 char backing_name
[1024];
1264 bs_old_backing
= bdrv_new("old_backing");
1265 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1266 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1269 error_report("Could not open old backing file '%s'", backing_name
);
1273 bs_new_backing
= bdrv_new("new_backing");
1274 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1277 error_report("Could not open new backing file '%s'", out_baseimg
);
1283 * Check each unallocated cluster in the COW file. If it is unallocated,
1284 * accesses go to the backing file. We must therefore compare this cluster
1285 * in the old and new backing file, and if they differ we need to copy it
1286 * from the old backing file into the COW file.
1288 * If qemu-img crashes during this step, no harm is done. The content of
1289 * the image is the same as the original one at any time.
1292 uint64_t num_sectors
;
1298 buf_old
= qemu_malloc(IO_BUF_SIZE
);
1299 buf_new
= qemu_malloc(IO_BUF_SIZE
);
1301 bdrv_get_geometry(bs
, &num_sectors
);
1303 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1305 /* How many sectors can we handle with the next read? */
1306 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1307 n
= (IO_BUF_SIZE
/ 512);
1309 n
= num_sectors
- sector
;
1312 /* If the cluster is allocated, we don't need to take action */
1313 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1318 /* Read old and new backing file */
1319 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1321 error_report("error while reading from old backing file");
1324 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1326 error_report("error while reading from new backing file");
1330 /* If they differ, we need to write to the COW file */
1331 uint64_t written
= 0;
1333 while (written
< n
) {
1336 if (compare_sectors(buf_old
+ written
* 512,
1337 buf_new
+ written
* 512, n
- written
, &pnum
))
1339 ret
= bdrv_write(bs
, sector
+ written
,
1340 buf_old
+ written
* 512, pnum
);
1342 error_report("Error while writing to COW image: %s",
1357 * Change the backing file. All clusters that are different from the old
1358 * backing file are overwritten in the COW file now, so the visible content
1359 * doesn't change when we switch the backing file.
1361 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1362 if (ret
== -ENOSPC
) {
1363 error_report("Could not change the backing file to '%s': No "
1364 "space left in the file header", out_baseimg
);
1365 } else if (ret
< 0) {
1366 error_report("Could not change the backing file to '%s': %s",
1367 out_baseimg
, strerror(-ret
));
1371 * TODO At this point it is possible to check if any clusters that are
1372 * allocated in the COW file are the same in the backing file. If so, they
1373 * could be dropped from the COW file. Don't do this before switching the
1374 * backing file, in case of a crash this would lead to corruption.
1379 bdrv_delete(bs_old_backing
);
1380 bdrv_delete(bs_new_backing
);
1390 static int img_resize(int argc
, char **argv
)
1392 int c
, ret
, relative
;
1393 const char *filename
, *fmt
, *size
;
1394 int64_t n
, total_size
;
1395 BlockDriverState
*bs
= NULL
;
1396 QEMUOptionParameter
*param
;
1397 QEMUOptionParameter resize_options
[] = {
1399 .name
= BLOCK_OPT_SIZE
,
1401 .help
= "Virtual disk size"
1408 c
= getopt(argc
, argv
, "f:h");
1422 if (optind
+ 1 >= argc
) {
1425 filename
= argv
[optind
++];
1426 size
= argv
[optind
++];
1428 /* Choose grow, shrink, or absolute resize mode */
1444 param
= parse_option_parameters("", resize_options
, NULL
);
1445 if (set_option_parameter(param
, BLOCK_OPT_SIZE
, size
)) {
1446 /* Error message already printed when size parsing fails */
1450 n
= get_option_parameter(param
, BLOCK_OPT_SIZE
)->value
.n
;
1451 free_option_parameters(param
);
1453 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
);
1460 total_size
= bdrv_getlength(bs
) + n
* relative
;
1464 if (total_size
<= 0) {
1465 error_report("New image size must be positive");
1470 ret
= bdrv_truncate(bs
, total_size
);
1473 printf("Image resized.\n");
1476 error_report("This image format does not support resize");
1479 error_report("Image is read-only");
1482 error_report("Error resizing image (%d)", -ret
);
1495 static const img_cmd_t img_cmds
[] = {
1496 #define DEF(option, callback, arg_string) \
1497 { option, callback },
1498 #include "qemu-img-cmds.h"
1504 int main(int argc
, char **argv
)
1506 const img_cmd_t
*cmd
;
1507 const char *cmdname
;
1509 error_set_progname(argv
[0]);
1517 /* find the command */
1518 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
1519 if (!strcmp(cmdname
, cmd
->name
)) {
1520 return cmd
->handler(argc
, argv
);