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 "qapi-visit.h"
25 #include "qapi/qmp-output-visitor.h"
26 #include "qapi/qmp/qjson.h"
27 #include "qemu-common.h"
28 #include "qemu/option.h"
29 #include "qemu/error-report.h"
30 #include "qemu/osdep.h"
31 #include "sysemu/sysemu.h"
32 #include "block/block_int.h"
40 typedef struct img_cmd_t
{
42 int (*handler
)(int argc
, char **argv
);
47 OPTION_BACKING_CHAIN
= 257,
50 typedef enum OutputFormat
{
55 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
56 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
57 #define BDRV_DEFAULT_CACHE "writeback"
59 static void format_print(void *opaque
, const char *name
)
64 /* Please keep in synch with qemu-img.texi */
65 static void help(void)
67 const char *help_msg
=
68 "qemu-img version " QEMU_VERSION
", Copyright (c) 2004-2008 Fabrice Bellard\n"
69 "usage: qemu-img command [command options]\n"
70 "QEMU disk image utility\n"
73 #define DEF(option, callback, arg_string) \
75 #include "qemu-img-cmds.h"
79 "Command parameters:\n"
80 " 'filename' is a disk image filename\n"
81 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
82 " 'cache' is the cache mode used to write the output disk image, the valid\n"
83 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
84 " 'directsync' and 'unsafe' (default for convert)\n"
85 " 'size' is the disk image size in bytes. Optional suffixes\n"
86 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
87 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
88 " 'output_filename' is the destination disk image filename\n"
89 " 'output_fmt' is the destination format\n"
90 " 'options' is a comma separated list of format specific options in a\n"
91 " name=value format. Use -o ? for an overview of the options supported by the\n"
93 " '-c' indicates that target image must be compressed (qcow format only)\n"
94 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
95 " match exactly. The image doesn't need a working backing file before\n"
96 " rebasing in this case (useful for renaming the backing file)\n"
97 " '-h' with or without a command shows this help and lists the supported formats\n"
98 " '-p' show progress of command (only certain commands)\n"
99 " '-S' indicates the consecutive number of bytes that must contain only zeros\n"
100 " for qemu-img to create a sparse image during conversion\n"
101 " '--output' takes the format in which the output must be done (human or json)\n"
103 "Parameters to check subcommand:\n"
104 " '-r' tries to repair any inconsistencies that are found during the check.\n"
105 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
106 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
107 " hiding corruption that has already occurred.\n"
109 "Parameters to snapshot subcommand:\n"
110 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
111 " '-a' applies a snapshot (revert disk to saved state)\n"
112 " '-c' creates a snapshot\n"
113 " '-d' deletes a snapshot\n"
114 " '-l' lists all snapshots in the given image\n";
116 printf("%s\nSupported formats:", help_msg
);
117 bdrv_iterate_format(format_print
, NULL
);
123 /* XXX: put correct support for win32 */
124 static int read_password(char *buf
, int buf_size
)
127 printf("Password: ");
134 if (i
< (buf_size
- 1))
145 static struct termios oldtty
;
147 static void term_exit(void)
149 tcsetattr (0, TCSANOW
, &oldtty
);
152 static void term_init(void)
159 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
160 |INLCR
|IGNCR
|ICRNL
|IXON
);
161 tty
.c_oflag
|= OPOST
;
162 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
163 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
168 tcsetattr (0, TCSANOW
, &tty
);
173 static int read_password(char *buf
, int buf_size
)
178 printf("password: ");
183 ret
= read(0, &ch
, 1);
185 if (errno
== EAGAIN
|| errno
== EINTR
) {
191 } else if (ret
== 0) {
199 if (i
< (buf_size
- 1))
210 static int print_block_option_help(const char *filename
, const char *fmt
)
212 BlockDriver
*drv
, *proto_drv
;
213 QEMUOptionParameter
*create_options
= NULL
;
215 /* Find driver and parse its options */
216 drv
= bdrv_find_format(fmt
);
218 error_report("Unknown file format '%s'", fmt
);
222 proto_drv
= bdrv_find_protocol(filename
);
224 error_report("Unknown protocol '%s'", filename
);
228 create_options
= append_option_parameters(create_options
,
229 drv
->create_options
);
230 create_options
= append_option_parameters(create_options
,
231 proto_drv
->create_options
);
232 print_option_help(create_options
);
233 free_option_parameters(create_options
);
237 static BlockDriverState
*bdrv_new_open(const char *filename
,
242 BlockDriverState
*bs
;
247 bs
= bdrv_new("image");
250 drv
= bdrv_find_format(fmt
);
252 error_report("Unknown file format '%s'", fmt
);
259 ret
= bdrv_open(bs
, filename
, flags
, drv
);
261 error_report("Could not open '%s': %s", filename
, strerror(-ret
));
265 if (bdrv_is_encrypted(bs
) && require_io
) {
266 printf("Disk image '%s' is encrypted.\n", filename
);
267 if (read_password(password
, sizeof(password
)) < 0) {
268 error_report("No password given");
271 if (bdrv_set_key(bs
, password
) < 0) {
272 error_report("invalid password");
284 static int add_old_style_options(const char *fmt
, QEMUOptionParameter
*list
,
285 const char *base_filename
,
286 const char *base_fmt
)
289 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
290 error_report("Backing file not supported for file format '%s'",
296 if (set_option_parameter(list
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
297 error_report("Backing file format not supported for file "
305 static int img_create(int argc
, char **argv
)
308 uint64_t img_size
= -1;
309 const char *fmt
= "raw";
310 const char *base_fmt
= NULL
;
311 const char *filename
;
312 const char *base_filename
= NULL
;
313 char *options
= NULL
;
314 Error
*local_err
= NULL
;
317 c
= getopt(argc
, argv
, "F:b:f:he6o:");
330 base_filename
= optarg
;
336 error_report("option -e is deprecated, please use \'-o "
337 "encryption\' instead!");
340 error_report("option -6 is deprecated, please use \'-o "
341 "compat6\' instead!");
349 /* Get the filename */
350 if (optind
>= argc
) {
353 filename
= argv
[optind
++];
355 /* Get image size, if specified */
359 sval
= strtosz_suffix(argv
[optind
++], &end
, STRTOSZ_DEFSUFFIX_B
);
360 if (sval
< 0 || *end
) {
361 if (sval
== -ERANGE
) {
362 error_report("Image size must be less than 8 EiB!");
364 error_report("Invalid image size specified! You may use k, M, "
365 "G or T suffixes for ");
366 error_report("kilobytes, megabytes, gigabytes and terabytes.");
370 img_size
= (uint64_t)sval
;
373 if (options
&& is_help_option(options
)) {
374 return print_block_option_help(filename
, fmt
);
377 bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
378 options
, img_size
, BDRV_O_FLAGS
, &local_err
);
379 if (error_is_set(&local_err
)) {
380 error_report("%s", error_get_pretty(local_err
));
381 error_free(local_err
);
388 static void dump_json_image_check(ImageCheck
*check
)
392 QmpOutputVisitor
*ov
= qmp_output_visitor_new();
394 visit_type_ImageCheck(qmp_output_get_visitor(ov
),
395 &check
, NULL
, &errp
);
396 obj
= qmp_output_get_qobject(ov
);
397 str
= qobject_to_json_pretty(obj
);
399 printf("%s\n", qstring_get_str(str
));
401 qmp_output_visitor_cleanup(ov
);
405 static void dump_human_image_check(ImageCheck
*check
)
407 if (!(check
->corruptions
|| check
->leaks
|| check
->check_errors
)) {
408 printf("No errors were found on the image.\n");
410 if (check
->corruptions
) {
411 printf("\n%" PRId64
" errors were found on the image.\n"
412 "Data may be corrupted, or further writes to the image "
418 printf("\n%" PRId64
" leaked clusters were found on the image.\n"
419 "This means waste of disk space, but no harm to data.\n",
423 if (check
->check_errors
) {
424 printf("\n%" PRId64
" internal errors have occurred during the check.\n",
425 check
->check_errors
);
429 if (check
->total_clusters
!= 0 && check
->allocated_clusters
!= 0) {
430 printf("%" PRId64
"/%" PRId64
" = %0.2f%% allocated, "
431 "%0.2f%% fragmented\n",
432 check
->allocated_clusters
, check
->total_clusters
,
433 check
->allocated_clusters
* 100.0 / check
->total_clusters
,
434 check
->fragmented_clusters
* 100.0 / check
->allocated_clusters
);
437 if (check
->image_end_offset
) {
438 printf("Image end offset: %" PRId64
"\n", check
->image_end_offset
);
442 static int collect_image_check(BlockDriverState
*bs
,
444 const char *filename
,
449 BdrvCheckResult result
;
451 ret
= bdrv_check(bs
, &result
, fix
);
456 check
->filename
= g_strdup(filename
);
457 check
->format
= g_strdup(bdrv_get_format_name(bs
));
458 check
->check_errors
= result
.check_errors
;
459 check
->corruptions
= result
.corruptions
;
460 check
->has_corruptions
= result
.corruptions
!= 0;
461 check
->leaks
= result
.leaks
;
462 check
->has_leaks
= result
.leaks
!= 0;
463 check
->corruptions_fixed
= result
.corruptions_fixed
;
464 check
->has_corruptions_fixed
= result
.corruptions
!= 0;
465 check
->leaks_fixed
= result
.leaks_fixed
;
466 check
->has_leaks_fixed
= result
.leaks
!= 0;
467 check
->image_end_offset
= result
.image_end_offset
;
468 check
->has_image_end_offset
= result
.image_end_offset
!= 0;
469 check
->total_clusters
= result
.bfi
.total_clusters
;
470 check
->has_total_clusters
= result
.bfi
.total_clusters
!= 0;
471 check
->allocated_clusters
= result
.bfi
.allocated_clusters
;
472 check
->has_allocated_clusters
= result
.bfi
.allocated_clusters
!= 0;
473 check
->fragmented_clusters
= result
.bfi
.fragmented_clusters
;
474 check
->has_fragmented_clusters
= result
.bfi
.fragmented_clusters
!= 0;
480 * Checks an image for consistency. Exit codes:
482 * 0 - Check completed, image is good
483 * 1 - Check not completed because of internal errors
484 * 2 - Check completed, image is corrupted
485 * 3 - Check completed, image has leaked clusters, but is good otherwise
487 static int img_check(int argc
, char **argv
)
490 OutputFormat output_format
= OFORMAT_HUMAN
;
491 const char *filename
, *fmt
, *output
;
492 BlockDriverState
*bs
;
494 int flags
= BDRV_O_FLAGS
| BDRV_O_CHECK
;
500 int option_index
= 0;
501 static const struct option long_options
[] = {
502 {"help", no_argument
, 0, 'h'},
503 {"format", required_argument
, 0, 'f'},
504 {"repair", no_argument
, 0, 'r'},
505 {"output", required_argument
, 0, OPTION_OUTPUT
},
508 c
= getopt_long(argc
, argv
, "f:hr:",
509 long_options
, &option_index
);
522 flags
|= BDRV_O_RDWR
;
524 if (!strcmp(optarg
, "leaks")) {
525 fix
= BDRV_FIX_LEAKS
;
526 } else if (!strcmp(optarg
, "all")) {
527 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
537 if (optind
>= argc
) {
540 filename
= argv
[optind
++];
542 if (output
&& !strcmp(output
, "json")) {
543 output_format
= OFORMAT_JSON
;
544 } else if (output
&& !strcmp(output
, "human")) {
545 output_format
= OFORMAT_HUMAN
;
547 error_report("--output must be used with human or json as argument.");
551 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
556 check
= g_new0(ImageCheck
, 1);
557 ret
= collect_image_check(bs
, check
, filename
, fmt
, fix
);
559 if (ret
== -ENOTSUP
) {
560 if (output_format
== OFORMAT_HUMAN
) {
561 error_report("This image format does not support checks");
567 if (check
->corruptions_fixed
|| check
->leaks_fixed
) {
568 int corruptions_fixed
, leaks_fixed
;
570 leaks_fixed
= check
->leaks_fixed
;
571 corruptions_fixed
= check
->corruptions_fixed
;
573 if (output_format
== OFORMAT_HUMAN
) {
574 printf("The following inconsistencies were found and repaired:\n\n"
575 " %" PRId64
" leaked clusters\n"
576 " %" PRId64
" corruptions\n\n"
577 "Double checking the fixed image now...\n",
579 check
->corruptions_fixed
);
582 ret
= collect_image_check(bs
, check
, filename
, fmt
, 0);
584 check
->leaks_fixed
= leaks_fixed
;
585 check
->corruptions_fixed
= corruptions_fixed
;
588 switch (output_format
) {
590 dump_human_image_check(check
);
593 dump_json_image_check(check
);
597 if (ret
|| check
->check_errors
) {
602 if (check
->corruptions
) {
604 } else if (check
->leaks
) {
611 qapi_free_ImageCheck(check
);
617 static int img_commit(int argc
, char **argv
)
620 const char *filename
, *fmt
, *cache
;
621 BlockDriverState
*bs
;
624 cache
= BDRV_DEFAULT_CACHE
;
626 c
= getopt(argc
, argv
, "f:ht:");
643 if (optind
>= argc
) {
646 filename
= argv
[optind
++];
649 ret
= bdrv_parse_cache_flags(cache
, &flags
);
651 error_report("Invalid cache option: %s", cache
);
655 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
659 ret
= bdrv_commit(bs
);
662 printf("Image committed.\n");
665 error_report("No disk inserted");
668 error_report("Image is read-only");
671 error_report("Image is already committed");
674 error_report("Error while committing image");
686 * Returns true iff the first sector pointed to by 'buf' contains at least
689 * 'pnum' is set to the number of sectors (including and immediately following
690 * the first one) that are known to be in the same allocated/unallocated state.
692 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
)
701 is_zero
= buffer_is_zero(buf
, 512);
702 for(i
= 1; i
< n
; i
++) {
704 if (is_zero
!= buffer_is_zero(buf
, 512)) {
713 * Like is_allocated_sectors, but if the buffer starts with a used sector,
714 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
715 * breaking up write requests for only small sparse areas.
717 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
721 int num_checked
, num_used
;
727 ret
= is_allocated_sectors(buf
, n
, pnum
);
733 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
735 num_checked
= num_used
;
738 ret
= is_allocated_sectors(buf
, n
, pnum
);
740 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
742 num_checked
+= *pnum
;
744 num_used
= num_checked
;
745 } else if (*pnum
>= min
) {
755 * Compares two buffers sector by sector. Returns 0 if the first sector of both
756 * buffers matches, non-zero otherwise.
758 * pnum is set to the number of sectors (including and immediately following
759 * the first one) that are known to have the same comparison result
761 static int compare_sectors(const uint8_t *buf1
, const uint8_t *buf2
, int n
,
771 res
= !!memcmp(buf1
, buf2
, 512);
772 for(i
= 1; i
< n
; i
++) {
776 if (!!memcmp(buf1
, buf2
, 512) != res
) {
785 #define IO_BUF_SIZE (2 * 1024 * 1024)
787 static int img_convert(int argc
, char **argv
)
789 int c
, ret
= 0, n
, n1
, bs_n
, bs_i
, compress
, cluster_size
, cluster_sectors
;
790 int progress
= 0, flags
;
791 const char *fmt
, *out_fmt
, *cache
, *out_baseimg
, *out_filename
;
792 BlockDriver
*drv
, *proto_drv
;
793 BlockDriverState
**bs
= NULL
, *out_bs
= NULL
;
794 int64_t total_sectors
, nb_sectors
, sector_num
, bs_offset
;
796 uint8_t * buf
= NULL
;
799 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
800 QEMUOptionParameter
*out_baseimg_param
;
801 char *options
= NULL
;
802 const char *snapshot_name
= NULL
;
803 float local_progress
= 0;
804 int min_sparse
= 8; /* Need at least 4k of zeros for sparse detection */
812 c
= getopt(argc
, argv
, "f:O:B:s:hce6o:pS:t:");
828 out_baseimg
= optarg
;
834 error_report("option -e is deprecated, please use \'-o "
835 "encryption\' instead!");
838 error_report("option -6 is deprecated, please use \'-o "
839 "compat6\' instead!");
845 snapshot_name
= optarg
;
851 sval
= strtosz_suffix(optarg
, &end
, STRTOSZ_DEFSUFFIX_B
);
852 if (sval
< 0 || *end
) {
853 error_report("Invalid minimum zero buffer size for sparse output specified");
857 min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
869 bs_n
= argc
- optind
- 1;
874 out_filename
= argv
[argc
- 1];
876 /* Initialize before goto out */
877 qemu_progress_init(progress
, 2.0);
879 if (options
&& is_help_option(options
)) {
880 ret
= print_block_option_help(out_filename
, out_fmt
);
884 if (bs_n
> 1 && out_baseimg
) {
885 error_report("-B makes no sense when concatenating multiple input "
891 qemu_progress_print(0, 100);
893 bs
= g_malloc0(bs_n
* sizeof(BlockDriverState
*));
896 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
897 bs
[bs_i
] = bdrv_new_open(argv
[optind
+ bs_i
], fmt
, BDRV_O_FLAGS
, true);
899 error_report("Could not open '%s'", argv
[optind
+ bs_i
]);
903 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
904 total_sectors
+= bs_sectors
;
907 if (snapshot_name
!= NULL
) {
909 error_report("No support for concatenating multiple snapshot");
913 if (bdrv_snapshot_load_tmp(bs
[0], snapshot_name
) < 0) {
914 error_report("Failed to load snapshot");
920 /* Find driver and parse its options */
921 drv
= bdrv_find_format(out_fmt
);
923 error_report("Unknown file format '%s'", out_fmt
);
928 proto_drv
= bdrv_find_protocol(out_filename
);
930 error_report("Unknown protocol '%s'", out_filename
);
935 create_options
= append_option_parameters(create_options
,
936 drv
->create_options
);
937 create_options
= append_option_parameters(create_options
,
938 proto_drv
->create_options
);
941 param
= parse_option_parameters(options
, create_options
, param
);
943 error_report("Invalid options for file format '%s'.", out_fmt
);
948 param
= parse_option_parameters("", create_options
, param
);
951 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, total_sectors
* 512);
952 ret
= add_old_style_options(out_fmt
, param
, out_baseimg
, NULL
);
957 /* Get backing file name if -o backing_file was used */
958 out_baseimg_param
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
959 if (out_baseimg_param
) {
960 out_baseimg
= out_baseimg_param
->value
.s
;
963 /* Check if compression is supported */
965 QEMUOptionParameter
*encryption
=
966 get_option_parameter(param
, BLOCK_OPT_ENCRYPT
);
967 QEMUOptionParameter
*preallocation
=
968 get_option_parameter(param
, BLOCK_OPT_PREALLOC
);
970 if (!drv
->bdrv_write_compressed
) {
971 error_report("Compression not supported for this file format");
976 if (encryption
&& encryption
->value
.n
) {
977 error_report("Compression and encryption not supported at "
983 if (preallocation
&& preallocation
->value
.s
984 && strcmp(preallocation
->value
.s
, "off"))
986 error_report("Compression and preallocation not supported at "
993 /* Create the new image */
994 ret
= bdrv_create(drv
, out_filename
, param
);
996 if (ret
== -ENOTSUP
) {
997 error_report("Formatting not supported for file format '%s'",
999 } else if (ret
== -EFBIG
) {
1000 error_report("The image size is too large for file format '%s'",
1003 error_report("%s: error while converting %s: %s",
1004 out_filename
, out_fmt
, strerror(-ret
));
1009 flags
= BDRV_O_RDWR
;
1010 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1012 error_report("Invalid cache option: %s", cache
);
1016 out_bs
= bdrv_new_open(out_filename
, out_fmt
, flags
, true);
1024 bdrv_get_geometry(bs
[0], &bs_sectors
);
1025 buf
= qemu_blockalign(out_bs
, IO_BUF_SIZE
);
1028 ret
= bdrv_get_info(out_bs
, &bdi
);
1030 error_report("could not get block driver info");
1033 cluster_size
= bdi
.cluster_size
;
1034 if (cluster_size
<= 0 || cluster_size
> IO_BUF_SIZE
) {
1035 error_report("invalid cluster size");
1039 cluster_sectors
= cluster_size
>> 9;
1042 nb_sectors
= total_sectors
;
1043 if (nb_sectors
!= 0) {
1044 local_progress
= (float)100 /
1045 (nb_sectors
/ MIN(nb_sectors
, cluster_sectors
));
1053 nb_sectors
= total_sectors
- sector_num
;
1054 if (nb_sectors
<= 0)
1056 if (nb_sectors
>= cluster_sectors
)
1057 n
= cluster_sectors
;
1061 bs_num
= sector_num
- bs_offset
;
1062 assert (bs_num
>= 0);
1065 while (remainder
> 0) {
1067 while (bs_num
== bs_sectors
) {
1069 assert (bs_i
< bs_n
);
1070 bs_offset
+= bs_sectors
;
1071 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
1073 /* printf("changing part: sector_num=%" PRId64 ", "
1074 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1075 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1077 assert (bs_num
< bs_sectors
);
1079 nlow
= (remainder
> bs_sectors
- bs_num
) ? bs_sectors
- bs_num
: remainder
;
1081 ret
= bdrv_read(bs
[bs_i
], bs_num
, buf2
, nlow
);
1083 error_report("error while reading sector %" PRId64
": %s",
1084 bs_num
, strerror(-ret
));
1093 assert (remainder
== 0);
1095 if (n
< cluster_sectors
) {
1096 memset(buf
+ n
* 512, 0, cluster_size
- n
* 512);
1098 if (!buffer_is_zero(buf
, cluster_size
)) {
1099 ret
= bdrv_write_compressed(out_bs
, sector_num
, buf
,
1102 error_report("error while compressing sector %" PRId64
1103 ": %s", sector_num
, strerror(-ret
));
1108 qemu_progress_print(local_progress
, 100);
1110 /* signal EOF to align */
1111 bdrv_write_compressed(out_bs
, 0, NULL
, 0);
1113 int has_zero_init
= bdrv_has_zero_init(out_bs
);
1115 sector_num
= 0; // total number of sectors converted so far
1116 nb_sectors
= total_sectors
- sector_num
;
1117 if (nb_sectors
!= 0) {
1118 local_progress
= (float)100 /
1119 (nb_sectors
/ MIN(nb_sectors
, IO_BUF_SIZE
/ 512));
1123 nb_sectors
= total_sectors
- sector_num
;
1124 if (nb_sectors
<= 0) {
1127 if (nb_sectors
>= (IO_BUF_SIZE
/ 512)) {
1128 n
= (IO_BUF_SIZE
/ 512);
1133 while (sector_num
- bs_offset
>= bs_sectors
) {
1135 assert (bs_i
< bs_n
);
1136 bs_offset
+= bs_sectors
;
1137 bdrv_get_geometry(bs
[bs_i
], &bs_sectors
);
1138 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1139 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1140 sector_num, bs_i, bs_offset, bs_sectors); */
1143 if (n
> bs_offset
+ bs_sectors
- sector_num
) {
1144 n
= bs_offset
+ bs_sectors
- sector_num
;
1147 if (has_zero_init
) {
1148 /* If the output image is being created as a copy on write image,
1149 assume that sectors which are unallocated in the input image
1150 are present in both the output's and input's base images (no
1151 need to copy them). */
1153 if (!bdrv_is_allocated(bs
[bs_i
], sector_num
- bs_offset
,
1158 /* The next 'n1' sectors are allocated in the input image. Copy
1159 only those as they may be followed by unallocated sectors. */
1166 ret
= bdrv_read(bs
[bs_i
], sector_num
- bs_offset
, buf
, n
);
1168 error_report("error while reading sector %" PRId64
": %s",
1169 sector_num
- bs_offset
, strerror(-ret
));
1172 /* NOTE: at the same time we convert, we do not write zero
1173 sectors to have a chance to compress the image. Ideally, we
1174 should add a specific call to have the info to go faster */
1177 /* If the output image is being created as a copy on write image,
1178 copy all sectors even the ones containing only NUL bytes,
1179 because they may differ from the sectors in the base image.
1181 If the output is to a host device, we also write out
1182 sectors that are entirely 0, since whatever data was
1183 already there is garbage, not 0s. */
1184 if (!has_zero_init
|| out_baseimg
||
1185 is_allocated_sectors_min(buf1
, n
, &n1
, min_sparse
)) {
1186 ret
= bdrv_write(out_bs
, sector_num
, buf1
, n1
);
1188 error_report("error while writing sector %" PRId64
1189 ": %s", sector_num
, strerror(-ret
));
1197 qemu_progress_print(local_progress
, 100);
1201 qemu_progress_end();
1202 free_option_parameters(create_options
);
1203 free_option_parameters(param
);
1206 bdrv_delete(out_bs
);
1209 for (bs_i
= 0; bs_i
< bs_n
; bs_i
++) {
1211 bdrv_delete(bs
[bs_i
]);
1223 static void dump_snapshots(BlockDriverState
*bs
)
1225 QEMUSnapshotInfo
*sn_tab
, *sn
;
1229 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1232 printf("Snapshot list:\n");
1233 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1234 for(i
= 0; i
< nb_sns
; i
++) {
1236 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
1241 static void dump_json_image_info_list(ImageInfoList
*list
)
1245 QmpOutputVisitor
*ov
= qmp_output_visitor_new();
1247 visit_type_ImageInfoList(qmp_output_get_visitor(ov
),
1248 &list
, NULL
, &errp
);
1249 obj
= qmp_output_get_qobject(ov
);
1250 str
= qobject_to_json_pretty(obj
);
1251 assert(str
!= NULL
);
1252 printf("%s\n", qstring_get_str(str
));
1253 qobject_decref(obj
);
1254 qmp_output_visitor_cleanup(ov
);
1258 static void collect_snapshots(BlockDriverState
*bs
, ImageInfo
*info
)
1261 QEMUSnapshotInfo
*sn_tab
= NULL
;
1262 SnapshotInfoList
*info_list
, *cur_item
= NULL
;
1263 sn_count
= bdrv_snapshot_list(bs
, &sn_tab
);
1265 for (i
= 0; i
< sn_count
; i
++) {
1266 info
->has_snapshots
= true;
1267 info_list
= g_new0(SnapshotInfoList
, 1);
1269 info_list
->value
= g_new0(SnapshotInfo
, 1);
1270 info_list
->value
->id
= g_strdup(sn_tab
[i
].id_str
);
1271 info_list
->value
->name
= g_strdup(sn_tab
[i
].name
);
1272 info_list
->value
->vm_state_size
= sn_tab
[i
].vm_state_size
;
1273 info_list
->value
->date_sec
= sn_tab
[i
].date_sec
;
1274 info_list
->value
->date_nsec
= sn_tab
[i
].date_nsec
;
1275 info_list
->value
->vm_clock_sec
= sn_tab
[i
].vm_clock_nsec
/ 1000000000;
1276 info_list
->value
->vm_clock_nsec
= sn_tab
[i
].vm_clock_nsec
% 1000000000;
1278 /* XXX: waiting for the qapi to support qemu-queue.h types */
1280 info
->snapshots
= cur_item
= info_list
;
1282 cur_item
->next
= info_list
;
1283 cur_item
= info_list
;
1291 static void dump_json_image_info(ImageInfo
*info
)
1295 QmpOutputVisitor
*ov
= qmp_output_visitor_new();
1297 visit_type_ImageInfo(qmp_output_get_visitor(ov
),
1298 &info
, NULL
, &errp
);
1299 obj
= qmp_output_get_qobject(ov
);
1300 str
= qobject_to_json_pretty(obj
);
1301 assert(str
!= NULL
);
1302 printf("%s\n", qstring_get_str(str
));
1303 qobject_decref(obj
);
1304 qmp_output_visitor_cleanup(ov
);
1308 static void collect_image_info(BlockDriverState
*bs
,
1310 const char *filename
,
1313 uint64_t total_sectors
;
1314 char backing_filename
[1024];
1315 char backing_filename2
[1024];
1316 BlockDriverInfo bdi
;
1318 bdrv_get_geometry(bs
, &total_sectors
);
1320 info
->filename
= g_strdup(filename
);
1321 info
->format
= g_strdup(bdrv_get_format_name(bs
));
1322 info
->virtual_size
= total_sectors
* 512;
1323 info
->actual_size
= bdrv_get_allocated_file_size(bs
);
1324 info
->has_actual_size
= info
->actual_size
>= 0;
1325 if (bdrv_is_encrypted(bs
)) {
1326 info
->encrypted
= true;
1327 info
->has_encrypted
= true;
1329 if (bdrv_get_info(bs
, &bdi
) >= 0) {
1330 if (bdi
.cluster_size
!= 0) {
1331 info
->cluster_size
= bdi
.cluster_size
;
1332 info
->has_cluster_size
= true;
1334 info
->dirty_flag
= bdi
.is_dirty
;
1335 info
->has_dirty_flag
= true;
1337 bdrv_get_backing_filename(bs
, backing_filename
, sizeof(backing_filename
));
1338 if (backing_filename
[0] != '\0') {
1339 info
->backing_filename
= g_strdup(backing_filename
);
1340 info
->has_backing_filename
= true;
1341 bdrv_get_full_backing_filename(bs
, backing_filename2
,
1342 sizeof(backing_filename2
));
1344 if (strcmp(backing_filename
, backing_filename2
) != 0) {
1345 info
->full_backing_filename
=
1346 g_strdup(backing_filename2
);
1347 info
->has_full_backing_filename
= true;
1350 if (bs
->backing_format
[0]) {
1351 info
->backing_filename_format
= g_strdup(bs
->backing_format
);
1352 info
->has_backing_filename_format
= true;
1357 static void dump_human_image_info(ImageInfo
*info
)
1359 char size_buf
[128], dsize_buf
[128];
1360 if (!info
->has_actual_size
) {
1361 snprintf(dsize_buf
, sizeof(dsize_buf
), "unavailable");
1363 get_human_readable_size(dsize_buf
, sizeof(dsize_buf
),
1366 get_human_readable_size(size_buf
, sizeof(size_buf
), info
->virtual_size
);
1367 printf("image: %s\n"
1369 "virtual size: %s (%" PRId64
" bytes)\n"
1371 info
->filename
, info
->format
, size_buf
,
1375 if (info
->has_encrypted
&& info
->encrypted
) {
1376 printf("encrypted: yes\n");
1379 if (info
->has_cluster_size
) {
1380 printf("cluster_size: %" PRId64
"\n", info
->cluster_size
);
1383 if (info
->has_dirty_flag
&& info
->dirty_flag
) {
1384 printf("cleanly shut down: no\n");
1387 if (info
->has_backing_filename
) {
1388 printf("backing file: %s", info
->backing_filename
);
1389 if (info
->has_full_backing_filename
) {
1390 printf(" (actual path: %s)", info
->full_backing_filename
);
1393 if (info
->has_backing_filename_format
) {
1394 printf("backing file format: %s\n", info
->backing_filename_format
);
1398 if (info
->has_snapshots
) {
1399 SnapshotInfoList
*elem
;
1402 printf("Snapshot list:\n");
1403 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
1405 /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1406 * we convert to the block layer's native QEMUSnapshotInfo for now.
1408 for (elem
= info
->snapshots
; elem
; elem
= elem
->next
) {
1409 QEMUSnapshotInfo sn
= {
1410 .vm_state_size
= elem
->value
->vm_state_size
,
1411 .date_sec
= elem
->value
->date_sec
,
1412 .date_nsec
= elem
->value
->date_nsec
,
1413 .vm_clock_nsec
= elem
->value
->vm_clock_sec
* 1000000000ULL +
1414 elem
->value
->vm_clock_nsec
,
1417 pstrcpy(sn
.id_str
, sizeof(sn
.id_str
), elem
->value
->id
);
1418 pstrcpy(sn
.name
, sizeof(sn
.name
), elem
->value
->name
);
1419 printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), &sn
));
1424 static void dump_human_image_info_list(ImageInfoList
*list
)
1426 ImageInfoList
*elem
;
1429 for (elem
= list
; elem
; elem
= elem
->next
) {
1435 dump_human_image_info(elem
->value
);
1439 static gboolean
str_equal_func(gconstpointer a
, gconstpointer b
)
1441 return strcmp(a
, b
) == 0;
1445 * Open an image file chain and return an ImageInfoList
1447 * @filename: topmost image filename
1448 * @fmt: topmost image format (may be NULL to autodetect)
1449 * @chain: true - enumerate entire backing file chain
1450 * false - only topmost image file
1452 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1453 * image file. If there was an error a message will have been printed to
1456 static ImageInfoList
*collect_image_info_list(const char *filename
,
1460 ImageInfoList
*head
= NULL
;
1461 ImageInfoList
**last
= &head
;
1462 GHashTable
*filenames
;
1464 filenames
= g_hash_table_new_full(g_str_hash
, str_equal_func
, NULL
, NULL
);
1467 BlockDriverState
*bs
;
1469 ImageInfoList
*elem
;
1471 if (g_hash_table_lookup_extended(filenames
, filename
, NULL
, NULL
)) {
1472 error_report("Backing file '%s' creates an infinite loop.",
1476 g_hash_table_insert(filenames
, (gpointer
)filename
, NULL
);
1478 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_NO_BACKING
,
1484 info
= g_new0(ImageInfo
, 1);
1485 collect_image_info(bs
, info
, filename
, fmt
);
1486 collect_snapshots(bs
, info
);
1488 elem
= g_new0(ImageInfoList
, 1);
1495 filename
= fmt
= NULL
;
1497 if (info
->has_full_backing_filename
) {
1498 filename
= info
->full_backing_filename
;
1499 } else if (info
->has_backing_filename
) {
1500 filename
= info
->backing_filename
;
1502 if (info
->has_backing_filename_format
) {
1503 fmt
= info
->backing_filename_format
;
1507 g_hash_table_destroy(filenames
);
1511 qapi_free_ImageInfoList(head
);
1512 g_hash_table_destroy(filenames
);
1516 static int img_info(int argc
, char **argv
)
1519 OutputFormat output_format
= OFORMAT_HUMAN
;
1521 const char *filename
, *fmt
, *output
;
1522 ImageInfoList
*list
;
1527 int option_index
= 0;
1528 static const struct option long_options
[] = {
1529 {"help", no_argument
, 0, 'h'},
1530 {"format", required_argument
, 0, 'f'},
1531 {"output", required_argument
, 0, OPTION_OUTPUT
},
1532 {"backing-chain", no_argument
, 0, OPTION_BACKING_CHAIN
},
1535 c
= getopt_long(argc
, argv
, "f:h",
1536 long_options
, &option_index
);
1551 case OPTION_BACKING_CHAIN
:
1556 if (optind
>= argc
) {
1559 filename
= argv
[optind
++];
1561 if (output
&& !strcmp(output
, "json")) {
1562 output_format
= OFORMAT_JSON
;
1563 } else if (output
&& !strcmp(output
, "human")) {
1564 output_format
= OFORMAT_HUMAN
;
1565 } else if (output
) {
1566 error_report("--output must be used with human or json as argument.");
1570 list
= collect_image_info_list(filename
, fmt
, chain
);
1575 switch (output_format
) {
1577 dump_human_image_info_list(list
);
1581 dump_json_image_info_list(list
);
1583 dump_json_image_info(list
->value
);
1588 qapi_free_ImageInfoList(list
);
1592 #define SNAPSHOT_LIST 1
1593 #define SNAPSHOT_CREATE 2
1594 #define SNAPSHOT_APPLY 3
1595 #define SNAPSHOT_DELETE 4
1597 static int img_snapshot(int argc
, char **argv
)
1599 BlockDriverState
*bs
;
1600 QEMUSnapshotInfo sn
;
1601 char *filename
, *snapshot_name
= NULL
;
1602 int c
, ret
= 0, bdrv_oflags
;
1606 bdrv_oflags
= BDRV_O_FLAGS
| BDRV_O_RDWR
;
1607 /* Parse commandline parameters */
1609 c
= getopt(argc
, argv
, "la:c:d:h");
1623 action
= SNAPSHOT_LIST
;
1624 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
1631 action
= SNAPSHOT_APPLY
;
1632 snapshot_name
= optarg
;
1639 action
= SNAPSHOT_CREATE
;
1640 snapshot_name
= optarg
;
1647 action
= SNAPSHOT_DELETE
;
1648 snapshot_name
= optarg
;
1653 if (optind
>= argc
) {
1656 filename
= argv
[optind
++];
1658 /* Open the image */
1659 bs
= bdrv_new_open(filename
, NULL
, bdrv_oflags
, true);
1664 /* Perform the requested action */
1670 case SNAPSHOT_CREATE
:
1671 memset(&sn
, 0, sizeof(sn
));
1672 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
1674 qemu_gettimeofday(&tv
);
1675 sn
.date_sec
= tv
.tv_sec
;
1676 sn
.date_nsec
= tv
.tv_usec
* 1000;
1678 ret
= bdrv_snapshot_create(bs
, &sn
);
1680 error_report("Could not create snapshot '%s': %d (%s)",
1681 snapshot_name
, ret
, strerror(-ret
));
1685 case SNAPSHOT_APPLY
:
1686 ret
= bdrv_snapshot_goto(bs
, snapshot_name
);
1688 error_report("Could not apply snapshot '%s': %d (%s)",
1689 snapshot_name
, ret
, strerror(-ret
));
1693 case SNAPSHOT_DELETE
:
1694 ret
= bdrv_snapshot_delete(bs
, snapshot_name
);
1696 error_report("Could not delete snapshot '%s': %d (%s)",
1697 snapshot_name
, ret
, strerror(-ret
));
1710 static int img_rebase(int argc
, char **argv
)
1712 BlockDriverState
*bs
, *bs_old_backing
= NULL
, *bs_new_backing
= NULL
;
1713 BlockDriver
*old_backing_drv
, *new_backing_drv
;
1715 const char *fmt
, *cache
, *out_basefmt
, *out_baseimg
;
1720 /* Parse commandline parameters */
1722 cache
= BDRV_DEFAULT_CACHE
;
1726 c
= getopt(argc
, argv
, "uhf:F:b:pt:");
1739 out_basefmt
= optarg
;
1742 out_baseimg
= optarg
;
1756 if ((optind
>= argc
) || (!unsafe
&& !out_baseimg
)) {
1759 filename
= argv
[optind
++];
1761 qemu_progress_init(progress
, 2.0);
1762 qemu_progress_print(0, 100);
1764 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
1765 ret
= bdrv_parse_cache_flags(cache
, &flags
);
1767 error_report("Invalid cache option: %s", cache
);
1774 * Ignore the old backing file for unsafe rebase in case we want to correct
1775 * the reference to a renamed or moved backing file.
1777 bs
= bdrv_new_open(filename
, fmt
, flags
, true);
1782 /* Find the right drivers for the backing files */
1783 old_backing_drv
= NULL
;
1784 new_backing_drv
= NULL
;
1786 if (!unsafe
&& bs
->backing_format
[0] != '\0') {
1787 old_backing_drv
= bdrv_find_format(bs
->backing_format
);
1788 if (old_backing_drv
== NULL
) {
1789 error_report("Invalid format name: '%s'", bs
->backing_format
);
1795 if (out_basefmt
!= NULL
) {
1796 new_backing_drv
= bdrv_find_format(out_basefmt
);
1797 if (new_backing_drv
== NULL
) {
1798 error_report("Invalid format name: '%s'", out_basefmt
);
1804 /* For safe rebasing we need to compare old and new backing file */
1806 /* Make the compiler happy */
1807 bs_old_backing
= NULL
;
1808 bs_new_backing
= NULL
;
1810 char backing_name
[1024];
1812 bs_old_backing
= bdrv_new("old_backing");
1813 bdrv_get_backing_filename(bs
, backing_name
, sizeof(backing_name
));
1814 ret
= bdrv_open(bs_old_backing
, backing_name
, BDRV_O_FLAGS
,
1817 error_report("Could not open old backing file '%s'", backing_name
);
1820 if (out_baseimg
[0]) {
1821 bs_new_backing
= bdrv_new("new_backing");
1822 ret
= bdrv_open(bs_new_backing
, out_baseimg
, BDRV_O_FLAGS
,
1825 error_report("Could not open new backing file '%s'",
1833 * Check each unallocated cluster in the COW file. If it is unallocated,
1834 * accesses go to the backing file. We must therefore compare this cluster
1835 * in the old and new backing file, and if they differ we need to copy it
1836 * from the old backing file into the COW file.
1838 * If qemu-img crashes during this step, no harm is done. The content of
1839 * the image is the same as the original one at any time.
1842 uint64_t num_sectors
;
1843 uint64_t old_backing_num_sectors
;
1844 uint64_t new_backing_num_sectors
= 0;
1849 float local_progress
= 0;
1851 buf_old
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1852 buf_new
= qemu_blockalign(bs
, IO_BUF_SIZE
);
1854 bdrv_get_geometry(bs
, &num_sectors
);
1855 bdrv_get_geometry(bs_old_backing
, &old_backing_num_sectors
);
1856 if (bs_new_backing
) {
1857 bdrv_get_geometry(bs_new_backing
, &new_backing_num_sectors
);
1860 if (num_sectors
!= 0) {
1861 local_progress
= (float)100 /
1862 (num_sectors
/ MIN(num_sectors
, IO_BUF_SIZE
/ 512));
1865 for (sector
= 0; sector
< num_sectors
; sector
+= n
) {
1867 /* How many sectors can we handle with the next read? */
1868 if (sector
+ (IO_BUF_SIZE
/ 512) <= num_sectors
) {
1869 n
= (IO_BUF_SIZE
/ 512);
1871 n
= num_sectors
- sector
;
1874 /* If the cluster is allocated, we don't need to take action */
1875 ret
= bdrv_is_allocated(bs
, sector
, n
, &n
);
1881 * Read old and new backing file and take into consideration that
1882 * backing files may be smaller than the COW image.
1884 if (sector
>= old_backing_num_sectors
) {
1885 memset(buf_old
, 0, n
* BDRV_SECTOR_SIZE
);
1887 if (sector
+ n
> old_backing_num_sectors
) {
1888 n
= old_backing_num_sectors
- sector
;
1891 ret
= bdrv_read(bs_old_backing
, sector
, buf_old
, n
);
1893 error_report("error while reading from old backing file");
1898 if (sector
>= new_backing_num_sectors
|| !bs_new_backing
) {
1899 memset(buf_new
, 0, n
* BDRV_SECTOR_SIZE
);
1901 if (sector
+ n
> new_backing_num_sectors
) {
1902 n
= new_backing_num_sectors
- sector
;
1905 ret
= bdrv_read(bs_new_backing
, sector
, buf_new
, n
);
1907 error_report("error while reading from new backing file");
1912 /* If they differ, we need to write to the COW file */
1913 uint64_t written
= 0;
1915 while (written
< n
) {
1918 if (compare_sectors(buf_old
+ written
* 512,
1919 buf_new
+ written
* 512, n
- written
, &pnum
))
1921 ret
= bdrv_write(bs
, sector
+ written
,
1922 buf_old
+ written
* 512, pnum
);
1924 error_report("Error while writing to COW image: %s",
1932 qemu_progress_print(local_progress
, 100);
1935 qemu_vfree(buf_old
);
1936 qemu_vfree(buf_new
);
1940 * Change the backing file. All clusters that are different from the old
1941 * backing file are overwritten in the COW file now, so the visible content
1942 * doesn't change when we switch the backing file.
1944 if (out_baseimg
&& *out_baseimg
) {
1945 ret
= bdrv_change_backing_file(bs
, out_baseimg
, out_basefmt
);
1947 ret
= bdrv_change_backing_file(bs
, NULL
, NULL
);
1950 if (ret
== -ENOSPC
) {
1951 error_report("Could not change the backing file to '%s': No "
1952 "space left in the file header", out_baseimg
);
1953 } else if (ret
< 0) {
1954 error_report("Could not change the backing file to '%s': %s",
1955 out_baseimg
, strerror(-ret
));
1958 qemu_progress_print(100, 0);
1960 * TODO At this point it is possible to check if any clusters that are
1961 * allocated in the COW file are the same in the backing file. If so, they
1962 * could be dropped from the COW file. Don't do this before switching the
1963 * backing file, in case of a crash this would lead to corruption.
1966 qemu_progress_end();
1969 if (bs_old_backing
!= NULL
) {
1970 bdrv_delete(bs_old_backing
);
1972 if (bs_new_backing
!= NULL
) {
1973 bdrv_delete(bs_new_backing
);
1984 static int img_resize(int argc
, char **argv
)
1986 int c
, ret
, relative
;
1987 const char *filename
, *fmt
, *size
;
1988 int64_t n
, total_size
;
1989 BlockDriverState
*bs
= NULL
;
1991 static QemuOptsList resize_options
= {
1992 .name
= "resize_options",
1993 .head
= QTAILQ_HEAD_INITIALIZER(resize_options
.head
),
1996 .name
= BLOCK_OPT_SIZE
,
1997 .type
= QEMU_OPT_SIZE
,
1998 .help
= "Virtual disk size"
2005 /* Remove size from argv manually so that negative numbers are not treated
2006 * as options by getopt. */
2012 size
= argv
[--argc
];
2014 /* Parse getopt arguments */
2017 c
= getopt(argc
, argv
, "f:h");
2031 if (optind
>= argc
) {
2034 filename
= argv
[optind
++];
2036 /* Choose grow, shrink, or absolute resize mode */
2052 param
= qemu_opts_create_nofail(&resize_options
);
2053 if (qemu_opt_set(param
, BLOCK_OPT_SIZE
, size
)) {
2054 /* Error message already printed when size parsing fails */
2056 qemu_opts_del(param
);
2059 n
= qemu_opt_get_size(param
, BLOCK_OPT_SIZE
, 0);
2060 qemu_opts_del(param
);
2062 bs
= bdrv_new_open(filename
, fmt
, BDRV_O_FLAGS
| BDRV_O_RDWR
, true);
2069 total_size
= bdrv_getlength(bs
) + n
* relative
;
2073 if (total_size
<= 0) {
2074 error_report("New image size must be positive");
2079 ret
= bdrv_truncate(bs
, total_size
);
2082 printf("Image resized.\n");
2085 error_report("This image does not support resize");
2088 error_report("Image is read-only");
2091 error_report("Error resizing image (%d)", -ret
);
2104 static const img_cmd_t img_cmds
[] = {
2105 #define DEF(option, callback, arg_string) \
2106 { option, callback },
2107 #include "qemu-img-cmds.h"
2113 int main(int argc
, char **argv
)
2115 const img_cmd_t
*cmd
;
2116 const char *cmdname
;
2118 error_set_progname(argv
[0]);
2120 qemu_init_main_loop();
2127 /* find the command */
2128 for(cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
2129 if (!strcmp(cmdname
, cmd
->name
)) {
2130 return cmd
->handler(argc
, argv
);