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
25 #include "qemu/osdep.h"
28 #include "qemu-common.h"
29 #include "qemu-version.h"
30 #include "qapi/error.h"
31 #include "qapi/qapi-commands-block-core.h"
32 #include "qapi/qapi-visit-block-core.h"
33 #include "qapi/qobject-output-visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qemu/cutils.h"
37 #include "qemu/config-file.h"
38 #include "qemu/option.h"
39 #include "qemu/error-report.h"
41 #include "qemu/main-loop.h"
42 #include "qemu/module.h"
43 #include "qemu/sockets.h"
44 #include "qemu/units.h"
45 #include "qom/object_interfaces.h"
46 #include "sysemu/block-backend.h"
47 #include "block/block_int.h"
48 #include "block/blockjob.h"
49 #include "block/qapi.h"
50 #include "crypto/init.h"
51 #include "trace/control.h"
52 #include "qemu/throttle.h"
53 #include "block/throttle-groups.h"
55 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \
56 "\n" QEMU_COPYRIGHT "\n"
58 typedef struct img_cmd_t
{
60 int (*handler
)(int argc
, char **argv
);
65 OPTION_BACKING_CHAIN
= 257,
67 OPTION_IMAGE_OPTS
= 259,
69 OPTION_FLUSH_INTERVAL
= 261,
70 OPTION_NO_DRAIN
= 262,
71 OPTION_TARGET_IMAGE_OPTS
= 263,
73 OPTION_PREALLOCATION
= 265,
76 OPTION_TARGET_IS_ZERO
= 268,
87 typedef enum OutputFormat
{
92 /* Default to cache=writeback as data integrity is not important for qemu-img */
93 #define BDRV_DEFAULT_CACHE "writeback"
95 static void format_print(void *opaque
, const char *name
)
100 static void QEMU_NORETURN
GCC_FMT_ATTR(1, 2) error_exit(const char *fmt
, ...)
105 error_vreport(fmt
, ap
);
108 error_printf("Try 'qemu-img --help' for more information\n");
112 static void QEMU_NORETURN
missing_argument(const char *option
)
114 error_exit("missing argument for option '%s'", option
);
117 static void QEMU_NORETURN
unrecognized_option(const char *option
)
119 error_exit("unrecognized option '%s'", option
);
122 /* Please keep in synch with docs/tools/qemu-img.rst */
123 static void QEMU_NORETURN
help(void)
125 const char *help_msg
=
127 "usage: qemu-img [standard options] command [command options]\n"
128 "QEMU disk image utility\n"
130 " '-h', '--help' display this help and exit\n"
131 " '-V', '--version' output version information and exit\n"
132 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
133 " specify tracing options\n"
136 #define DEF(option, callback, arg_string) \
138 #include "qemu-img-cmds.h"
141 "Command parameters:\n"
142 " 'filename' is a disk image filename\n"
143 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
144 " manual page for a description of the object properties. The most common\n"
145 " object type is a 'secret', which is used to supply passwords and/or\n"
146 " encryption keys.\n"
147 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
148 " 'cache' is the cache mode used to write the output disk image, the valid\n"
149 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
150 " 'directsync' and 'unsafe' (default for convert)\n"
151 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
152 " options are the same as for the 'cache' option\n"
153 " 'size' is the disk image size in bytes. Optional suffixes\n"
154 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
155 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
156 " supported. 'b' is ignored.\n"
157 " 'output_filename' is the destination disk image filename\n"
158 " 'output_fmt' is the destination format\n"
159 " 'options' is a comma separated list of format specific options in a\n"
160 " name=value format. Use -o ? for an overview of the options supported by the\n"
162 " 'snapshot_param' is param used for internal snapshot, format\n"
163 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
165 " '-c' indicates that target image must be compressed (qcow format only)\n"
166 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
167 " new backing file match exactly. The image doesn't need a working\n"
168 " backing file before rebasing in this case (useful for renaming the\n"
169 " backing file). For image creation, allow creating without attempting\n"
170 " to open the backing file.\n"
171 " '-h' with or without a command shows this help and lists the supported formats\n"
172 " '-p' show progress of command (only certain commands)\n"
173 " '-q' use Quiet mode - do not print any output (except errors)\n"
174 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
175 " contain only zeros for qemu-img to create a sparse image during\n"
176 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
177 " unallocated or zero sectors, and the destination image will always be\n"
179 " '--output' takes the format in which the output must be done (human or json)\n"
180 " '-n' skips the target volume creation (useful if the volume is created\n"
181 " prior to running qemu-img)\n"
183 "Parameters to bitmap subcommand:\n"
184 " 'bitmap' is the name of the bitmap to manipulate, through one or more\n"
185 " actions from '--add', '--remove', '--clear', '--enable', '--disable',\n"
186 " or '--merge source'\n"
187 " '-g granularity' sets the granularity for '--add' actions\n"
188 " '-b source' and '-F src_fmt' tell '--merge' actions to find the source\n"
189 " bitmaps from an alternative file\n"
191 "Parameters to check subcommand:\n"
192 " '-r' tries to repair any inconsistencies that are found during the check.\n"
193 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
194 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
195 " hiding corruption that has already occurred.\n"
197 "Parameters to convert subcommand:\n"
198 " '--bitmaps' copies all top-level persistent bitmaps to destination\n"
199 " '-m' specifies how many coroutines work in parallel during the convert\n"
200 " process (defaults to 8)\n"
201 " '-W' allow to write to the target out of order rather than sequential\n"
203 "Parameters to snapshot subcommand:\n"
204 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
205 " '-a' applies a snapshot (revert disk to saved state)\n"
206 " '-c' creates a snapshot\n"
207 " '-d' deletes a snapshot\n"
208 " '-l' lists all snapshots in the given image\n"
210 "Parameters to compare subcommand:\n"
211 " '-f' first image format\n"
212 " '-F' second image format\n"
213 " '-s' run in Strict mode - fail on different image size or sector allocation\n"
215 "Parameters to dd subcommand:\n"
216 " 'bs=BYTES' read and write up to BYTES bytes at a time "
218 " 'count=N' copy only N input blocks\n"
219 " 'if=FILE' read from FILE\n"
220 " 'of=FILE' write to FILE\n"
221 " 'skip=N' skip N bs-sized blocks at the start of input\n";
223 printf("%s\nSupported formats:", help_msg
);
224 bdrv_iterate_format(format_print
, NULL
, false);
225 printf("\n\n" QEMU_HELP_BOTTOM
"\n");
229 static QemuOptsList qemu_object_opts
= {
231 .implied_opt_name
= "qom-type",
232 .head
= QTAILQ_HEAD_INITIALIZER(qemu_object_opts
.head
),
238 static bool qemu_img_object_print_help(const char *type
, QemuOpts
*opts
)
240 if (user_creatable_print_help(type
, opts
)) {
247 * Is @optarg safe for accumulate_options()?
248 * It is when multiple of them can be joined together separated by ','.
249 * To make that work, @optarg must not start with ',' (or else a
250 * separating ',' preceding it gets escaped), and it must not end with
251 * an odd number of ',' (or else a separating ',' following it gets
252 * escaped), or be empty (or else a separating ',' preceding it can
253 * escape a separating ',' following it).
256 static bool is_valid_option_list(const char *optarg
)
258 size_t len
= strlen(optarg
);
261 if (!optarg
[0] || optarg
[0] == ',') {
265 for (i
= len
; i
> 0 && optarg
[i
- 1] == ','; i
--) {
274 static int accumulate_options(char **options
, char *optarg
)
278 if (!is_valid_option_list(optarg
)) {
279 error_report("Invalid option list: %s", optarg
);
284 *options
= g_strdup(optarg
);
286 new_options
= g_strdup_printf("%s,%s", *options
, optarg
);
288 *options
= new_options
;
293 static QemuOptsList qemu_source_opts
= {
295 .implied_opt_name
= "file",
296 .head
= QTAILQ_HEAD_INITIALIZER(qemu_source_opts
.head
),
302 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet
, const char *fmt
, ...)
308 ret
= vprintf(fmt
, args
);
315 static int print_block_option_help(const char *filename
, const char *fmt
)
317 BlockDriver
*drv
, *proto_drv
;
318 QemuOptsList
*create_opts
= NULL
;
319 Error
*local_err
= NULL
;
321 /* Find driver and parse its options */
322 drv
= bdrv_find_format(fmt
);
324 error_report("Unknown file format '%s'", fmt
);
328 if (!drv
->create_opts
) {
329 error_report("Format driver '%s' does not support image creation", fmt
);
333 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
335 proto_drv
= bdrv_find_protocol(filename
, true, &local_err
);
337 error_report_err(local_err
);
338 qemu_opts_free(create_opts
);
341 if (!proto_drv
->create_opts
) {
342 error_report("Protocol driver '%s' does not support image creation",
343 proto_drv
->format_name
);
344 qemu_opts_free(create_opts
);
347 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
351 printf("Supported options:\n");
353 printf("Supported %s options:\n", fmt
);
355 qemu_opts_print_help(create_opts
, false);
356 qemu_opts_free(create_opts
);
360 "The protocol level may support further options.\n"
361 "Specify the target filename to include those options.\n");
368 static BlockBackend
*img_open_opts(const char *optstr
,
369 QemuOpts
*opts
, int flags
, bool writethrough
,
370 bool quiet
, bool force_share
)
373 Error
*local_err
= NULL
;
375 options
= qemu_opts_to_qdict(opts
, NULL
);
377 if (qdict_haskey(options
, BDRV_OPT_FORCE_SHARE
)
378 && strcmp(qdict_get_str(options
, BDRV_OPT_FORCE_SHARE
), "on")) {
379 error_report("--force-share/-U conflicts with image options");
380 qobject_unref(options
);
383 qdict_put_str(options
, BDRV_OPT_FORCE_SHARE
, "on");
385 blk
= blk_new_open(NULL
, NULL
, options
, flags
, &local_err
);
387 error_reportf_err(local_err
, "Could not open '%s': ", optstr
);
390 blk_set_enable_write_cache(blk
, !writethrough
);
395 static BlockBackend
*img_open_file(const char *filename
,
397 const char *fmt
, int flags
,
398 bool writethrough
, bool quiet
,
402 Error
*local_err
= NULL
;
405 options
= qdict_new();
408 qdict_put_str(options
, "driver", fmt
);
412 qdict_put_bool(options
, BDRV_OPT_FORCE_SHARE
, true);
414 blk
= blk_new_open(filename
, NULL
, options
, flags
, &local_err
);
416 error_reportf_err(local_err
, "Could not open '%s': ", filename
);
419 blk_set_enable_write_cache(blk
, !writethrough
);
425 static int img_add_key_secrets(void *opaque
,
426 const char *name
, const char *value
,
429 QDict
*options
= opaque
;
431 if (g_str_has_suffix(name
, "key-secret")) {
432 qdict_put_str(options
, name
, value
);
439 static BlockBackend
*img_open(bool image_opts
,
440 const char *filename
,
441 const char *fmt
, int flags
, bool writethrough
,
442 bool quiet
, bool force_share
)
448 error_report("--image-opts and --format are mutually exclusive");
451 opts
= qemu_opts_parse_noisily(qemu_find_opts("source"),
456 blk
= img_open_opts(filename
, opts
, flags
, writethrough
, quiet
,
459 blk
= img_open_file(filename
, NULL
, fmt
, flags
, writethrough
, quiet
,
466 static int add_old_style_options(const char *fmt
, QemuOpts
*opts
,
467 const char *base_filename
,
468 const char *base_fmt
)
471 if (!qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
,
473 error_report("Backing file not supported for file format '%s'",
479 if (!qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, NULL
)) {
480 error_report("Backing file format not supported for file "
488 static int64_t cvtnum_full(const char *name
, const char *value
, int64_t min
,
494 err
= qemu_strtosz(value
, NULL
, &res
);
495 if (err
< 0 && err
!= -ERANGE
) {
496 error_report("Invalid %s specified. You may use "
497 "k, M, G, T, P or E suffixes for", name
);
498 error_report("kilobytes, megabytes, gigabytes, terabytes, "
499 "petabytes and exabytes.");
502 if (err
== -ERANGE
|| res
> max
|| res
< min
) {
503 error_report("Invalid %s specified. Must be between %" PRId64
504 " and %" PRId64
".", name
, min
, max
);
510 static int64_t cvtnum(const char *name
, const char *value
)
512 return cvtnum_full(name
, value
, 0, INT64_MAX
);
515 static int img_create(int argc
, char **argv
)
518 uint64_t img_size
= -1;
519 const char *fmt
= "raw";
520 const char *base_fmt
= NULL
;
521 const char *filename
;
522 const char *base_filename
= NULL
;
523 char *options
= NULL
;
524 Error
*local_err
= NULL
;
529 static const struct option long_options
[] = {
530 {"help", no_argument
, 0, 'h'},
531 {"object", required_argument
, 0, OPTION_OBJECT
},
534 c
= getopt_long(argc
, argv
, ":F:b:f:ho:qu",
541 missing_argument(argv
[optind
- 1]);
544 unrecognized_option(argv
[optind
- 1]);
553 base_filename
= optarg
;
559 if (accumulate_options(&options
, optarg
) < 0) {
567 flags
|= BDRV_O_NO_BACKING
;
569 case OPTION_OBJECT
: {
571 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
580 /* Get the filename */
581 filename
= (optind
< argc
) ? argv
[optind
] : NULL
;
582 if (options
&& has_help_option(options
)) {
584 return print_block_option_help(filename
, fmt
);
587 if (optind
>= argc
) {
588 error_exit("Expecting image file name");
592 if (qemu_opts_foreach(&qemu_object_opts
,
593 user_creatable_add_opts_foreach
,
594 qemu_img_object_print_help
, &error_fatal
)) {
598 /* Get image size, if specified */
602 sval
= cvtnum("image size", argv
[optind
++]);
606 img_size
= (uint64_t)sval
;
608 if (optind
!= argc
) {
609 error_exit("Unexpected argument: %s", argv
[optind
]);
612 bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
613 options
, img_size
, flags
, quiet
, &local_err
);
615 error_reportf_err(local_err
, "%s: ", filename
);
627 static void dump_json_image_check(ImageCheck
*check
, bool quiet
)
631 Visitor
*v
= qobject_output_visitor_new(&obj
);
633 visit_type_ImageCheck(v
, NULL
, &check
, &error_abort
);
634 visit_complete(v
, &obj
);
635 str
= qobject_to_json_pretty(obj
, true);
637 qprintf(quiet
, "%s\n", str
->str
);
640 g_string_free(str
, true);
643 static void dump_human_image_check(ImageCheck
*check
, bool quiet
)
645 if (!(check
->corruptions
|| check
->leaks
|| check
->check_errors
)) {
646 qprintf(quiet
, "No errors were found on the image.\n");
648 if (check
->corruptions
) {
649 qprintf(quiet
, "\n%" PRId64
" errors were found on the image.\n"
650 "Data may be corrupted, or further writes to the image "
657 "\n%" PRId64
" leaked clusters were found on the image.\n"
658 "This means waste of disk space, but no harm to data.\n",
662 if (check
->check_errors
) {
665 " internal errors have occurred during the check.\n",
666 check
->check_errors
);
670 if (check
->total_clusters
!= 0 && check
->allocated_clusters
!= 0) {
671 qprintf(quiet
, "%" PRId64
"/%" PRId64
" = %0.2f%% allocated, "
672 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
673 check
->allocated_clusters
, check
->total_clusters
,
674 check
->allocated_clusters
* 100.0 / check
->total_clusters
,
675 check
->fragmented_clusters
* 100.0 / check
->allocated_clusters
,
676 check
->compressed_clusters
* 100.0 /
677 check
->allocated_clusters
);
680 if (check
->image_end_offset
) {
682 "Image end offset: %" PRId64
"\n", check
->image_end_offset
);
686 static int collect_image_check(BlockDriverState
*bs
,
688 const char *filename
,
693 BdrvCheckResult result
;
695 ret
= bdrv_check(bs
, &result
, fix
);
700 check
->filename
= g_strdup(filename
);
701 check
->format
= g_strdup(bdrv_get_format_name(bs
));
702 check
->check_errors
= result
.check_errors
;
703 check
->corruptions
= result
.corruptions
;
704 check
->has_corruptions
= result
.corruptions
!= 0;
705 check
->leaks
= result
.leaks
;
706 check
->has_leaks
= result
.leaks
!= 0;
707 check
->corruptions_fixed
= result
.corruptions_fixed
;
708 check
->has_corruptions_fixed
= result
.corruptions_fixed
!= 0;
709 check
->leaks_fixed
= result
.leaks_fixed
;
710 check
->has_leaks_fixed
= result
.leaks_fixed
!= 0;
711 check
->image_end_offset
= result
.image_end_offset
;
712 check
->has_image_end_offset
= result
.image_end_offset
!= 0;
713 check
->total_clusters
= result
.bfi
.total_clusters
;
714 check
->has_total_clusters
= result
.bfi
.total_clusters
!= 0;
715 check
->allocated_clusters
= result
.bfi
.allocated_clusters
;
716 check
->has_allocated_clusters
= result
.bfi
.allocated_clusters
!= 0;
717 check
->fragmented_clusters
= result
.bfi
.fragmented_clusters
;
718 check
->has_fragmented_clusters
= result
.bfi
.fragmented_clusters
!= 0;
719 check
->compressed_clusters
= result
.bfi
.compressed_clusters
;
720 check
->has_compressed_clusters
= result
.bfi
.compressed_clusters
!= 0;
726 * Checks an image for consistency. Exit codes:
728 * 0 - Check completed, image is good
729 * 1 - Check not completed because of internal errors
730 * 2 - Check completed, image is corrupted
731 * 3 - Check completed, image has leaked clusters, but is good otherwise
732 * 63 - Checks are not supported by the image format
734 static int img_check(int argc
, char **argv
)
737 OutputFormat output_format
= OFORMAT_HUMAN
;
738 const char *filename
, *fmt
, *output
, *cache
;
740 BlockDriverState
*bs
;
742 int flags
= BDRV_O_CHECK
;
746 bool image_opts
= false;
747 bool force_share
= false;
751 cache
= BDRV_DEFAULT_CACHE
;
754 int option_index
= 0;
755 static const struct option long_options
[] = {
756 {"help", no_argument
, 0, 'h'},
757 {"format", required_argument
, 0, 'f'},
758 {"repair", required_argument
, 0, 'r'},
759 {"output", required_argument
, 0, OPTION_OUTPUT
},
760 {"object", required_argument
, 0, OPTION_OBJECT
},
761 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
762 {"force-share", no_argument
, 0, 'U'},
765 c
= getopt_long(argc
, argv
, ":hf:r:T:qU",
766 long_options
, &option_index
);
772 missing_argument(argv
[optind
- 1]);
775 unrecognized_option(argv
[optind
- 1]);
784 flags
|= BDRV_O_RDWR
;
786 if (!strcmp(optarg
, "leaks")) {
787 fix
= BDRV_FIX_LEAKS
;
788 } else if (!strcmp(optarg
, "all")) {
789 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
791 error_exit("Unknown option value for -r "
792 "(expecting 'leaks' or 'all'): %s", optarg
);
807 case OPTION_OBJECT
: {
809 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
815 case OPTION_IMAGE_OPTS
:
820 if (optind
!= argc
- 1) {
821 error_exit("Expecting one image file name");
823 filename
= argv
[optind
++];
825 if (output
&& !strcmp(output
, "json")) {
826 output_format
= OFORMAT_JSON
;
827 } else if (output
&& !strcmp(output
, "human")) {
828 output_format
= OFORMAT_HUMAN
;
830 error_report("--output must be used with human or json as argument.");
834 if (qemu_opts_foreach(&qemu_object_opts
,
835 user_creatable_add_opts_foreach
,
836 qemu_img_object_print_help
, &error_fatal
)) {
840 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
842 error_report("Invalid source cache option: %s", cache
);
846 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
853 check
= g_new0(ImageCheck
, 1);
854 ret
= collect_image_check(bs
, check
, filename
, fmt
, fix
);
856 if (ret
== -ENOTSUP
) {
857 error_report("This image format does not support checks");
862 if (check
->corruptions_fixed
|| check
->leaks_fixed
) {
863 int corruptions_fixed
, leaks_fixed
;
864 bool has_leaks_fixed
, has_corruptions_fixed
;
866 leaks_fixed
= check
->leaks_fixed
;
867 has_leaks_fixed
= check
->has_leaks_fixed
;
868 corruptions_fixed
= check
->corruptions_fixed
;
869 has_corruptions_fixed
= check
->has_corruptions_fixed
;
871 if (output_format
== OFORMAT_HUMAN
) {
873 "The following inconsistencies were found and repaired:\n\n"
874 " %" PRId64
" leaked clusters\n"
875 " %" PRId64
" corruptions\n\n"
876 "Double checking the fixed image now...\n",
878 check
->corruptions_fixed
);
881 qapi_free_ImageCheck(check
);
882 check
= g_new0(ImageCheck
, 1);
883 ret
= collect_image_check(bs
, check
, filename
, fmt
, 0);
885 check
->leaks_fixed
= leaks_fixed
;
886 check
->has_leaks_fixed
= has_leaks_fixed
;
887 check
->corruptions_fixed
= corruptions_fixed
;
888 check
->has_corruptions_fixed
= has_corruptions_fixed
;
892 switch (output_format
) {
894 dump_human_image_check(check
, quiet
);
897 dump_json_image_check(check
, quiet
);
902 if (ret
|| check
->check_errors
) {
904 error_report("Check failed: %s", strerror(-ret
));
906 error_report("Check failed");
912 if (check
->corruptions
) {
914 } else if (check
->leaks
) {
921 qapi_free_ImageCheck(check
);
926 typedef struct CommonBlockJobCBInfo
{
927 BlockDriverState
*bs
;
929 } CommonBlockJobCBInfo
;
931 static void common_block_job_cb(void *opaque
, int ret
)
933 CommonBlockJobCBInfo
*cbi
= opaque
;
936 error_setg_errno(cbi
->errp
, -ret
, "Block job failed");
940 static void run_block_job(BlockJob
*job
, Error
**errp
)
942 AioContext
*aio_context
= blk_get_aio_context(job
->blk
);
945 aio_context_acquire(aio_context
);
948 float progress
= 0.0f
;
949 aio_poll(aio_context
, true);
950 if (job
->job
.progress
.total
) {
951 progress
= (float)job
->job
.progress
.current
/
952 job
->job
.progress
.total
* 100.f
;
954 qemu_progress_print(progress
, 0);
955 } while (!job_is_ready(&job
->job
) && !job_is_completed(&job
->job
));
957 if (!job_is_completed(&job
->job
)) {
958 ret
= job_complete_sync(&job
->job
, errp
);
962 job_unref(&job
->job
);
963 aio_context_release(aio_context
);
965 /* publish completion progress only when success */
967 qemu_progress_print(100.f
, 0);
971 static int img_commit(int argc
, char **argv
)
974 const char *filename
, *fmt
, *cache
, *base
;
976 BlockDriverState
*bs
, *base_bs
;
978 bool progress
= false, quiet
= false, drop
= false;
980 Error
*local_err
= NULL
;
981 CommonBlockJobCBInfo cbi
;
982 bool image_opts
= false;
983 AioContext
*aio_context
;
984 int64_t rate_limit
= 0;
987 cache
= BDRV_DEFAULT_CACHE
;
990 static const struct option long_options
[] = {
991 {"help", no_argument
, 0, 'h'},
992 {"object", required_argument
, 0, OPTION_OBJECT
},
993 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
996 c
= getopt_long(argc
, argv
, ":f:ht:b:dpqr:",
1003 missing_argument(argv
[optind
- 1]);
1006 unrecognized_option(argv
[optind
- 1]);
1032 rate_limit
= cvtnum("rate limit", optarg
);
1033 if (rate_limit
< 0) {
1037 case OPTION_OBJECT
: {
1039 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
1045 case OPTION_IMAGE_OPTS
:
1051 /* Progress is not shown in Quiet mode */
1056 if (optind
!= argc
- 1) {
1057 error_exit("Expecting one image file name");
1059 filename
= argv
[optind
++];
1061 if (qemu_opts_foreach(&qemu_object_opts
,
1062 user_creatable_add_opts_foreach
,
1063 qemu_img_object_print_help
, &error_fatal
)) {
1067 flags
= BDRV_O_RDWR
| BDRV_O_UNMAP
;
1068 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
1070 error_report("Invalid cache option: %s", cache
);
1074 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
1081 qemu_progress_init(progress
, 1.f
);
1082 qemu_progress_print(0.f
, 100);
1085 base_bs
= bdrv_find_backing_image(bs
, base
);
1087 error_setg(&local_err
,
1088 "Did not find '%s' in the backing chain of '%s'",
1093 /* This is different from QMP, which by default uses the deepest file in
1094 * the backing chain (i.e., the very base); however, the traditional
1095 * behavior of qemu-img commit is using the immediate backing file. */
1096 base_bs
= bdrv_backing_chain_next(bs
);
1098 error_setg(&local_err
, "Image does not have a backing file");
1103 cbi
= (CommonBlockJobCBInfo
){
1108 aio_context
= bdrv_get_aio_context(bs
);
1109 aio_context_acquire(aio_context
);
1110 commit_active_start("commit", bs
, base_bs
, JOB_DEFAULT
, rate_limit
,
1111 BLOCKDEV_ON_ERROR_REPORT
, NULL
, common_block_job_cb
,
1112 &cbi
, false, &local_err
);
1113 aio_context_release(aio_context
);
1118 /* When the block job completes, the BlockBackend reference will point to
1119 * the old backing file. In order to avoid that the top image is already
1120 * deleted, so we can still empty it afterwards, increment the reference
1121 * counter here preemptively. */
1126 job
= block_job_get("commit");
1128 run_block_job(job
, &local_err
);
1134 BlockBackend
*old_backing_blk
;
1136 old_backing_blk
= blk_new_with_bs(bs
, BLK_PERM_WRITE
, BLK_PERM_ALL
,
1138 if (!old_backing_blk
) {
1141 ret
= blk_make_empty(old_backing_blk
, &local_err
);
1142 blk_unref(old_backing_blk
);
1143 if (ret
== -ENOTSUP
) {
1144 error_free(local_err
);
1146 } else if (ret
< 0) {
1157 qemu_progress_end();
1162 error_report_err(local_err
);
1166 qprintf(quiet
, "Image committed.\n");
1171 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1172 * of the first sector boundary within buf where the sector contains a
1173 * non-zero byte. This function is robust to a buffer that is not
1176 static int64_t find_nonzero(const uint8_t *buf
, int64_t n
)
1179 int64_t end
= QEMU_ALIGN_DOWN(n
, BDRV_SECTOR_SIZE
);
1181 for (i
= 0; i
< end
; i
+= BDRV_SECTOR_SIZE
) {
1182 if (!buffer_is_zero(buf
+ i
, BDRV_SECTOR_SIZE
)) {
1186 if (i
< n
&& !buffer_is_zero(buf
+ i
, n
- end
)) {
1193 * Returns true iff the first sector pointed to by 'buf' contains at least
1196 * 'pnum' is set to the number of sectors (including and immediately following
1197 * the first one) that are known to be in the same allocated/unallocated state.
1198 * The function will try to align the end offset to alignment boundaries so
1199 * that the request will at least end aligned and consecutive requests will
1200 * also start at an aligned offset.
1202 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
,
1203 int64_t sector_num
, int alignment
)
1212 is_zero
= buffer_is_zero(buf
, BDRV_SECTOR_SIZE
);
1213 for(i
= 1; i
< n
; i
++) {
1214 buf
+= BDRV_SECTOR_SIZE
;
1215 if (is_zero
!= buffer_is_zero(buf
, BDRV_SECTOR_SIZE
)) {
1220 tail
= (sector_num
+ i
) & (alignment
- 1);
1222 if (is_zero
&& i
<= tail
) {
1223 /* treat unallocated areas which only consist
1224 * of a small tail as allocated. */
1228 /* align up end offset of allocated areas. */
1229 i
+= alignment
- tail
;
1232 /* align down end offset of zero areas. */
1241 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1242 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1243 * breaking up write requests for only small sparse areas.
1245 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
1246 int min
, int64_t sector_num
, int alignment
)
1249 int num_checked
, num_used
;
1255 ret
= is_allocated_sectors(buf
, n
, pnum
, sector_num
, alignment
);
1261 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
1263 sector_num
+= *pnum
;
1264 num_checked
= num_used
;
1267 ret
= is_allocated_sectors(buf
, n
, pnum
, sector_num
, alignment
);
1269 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
1271 sector_num
+= *pnum
;
1272 num_checked
+= *pnum
;
1274 num_used
= num_checked
;
1275 } else if (*pnum
>= min
) {
1285 * Compares two buffers sector by sector. Returns 0 if the first
1286 * sector of each buffer matches, non-zero otherwise.
1288 * pnum is set to the sector-aligned size of the buffer prefix that
1289 * has the same matching status as the first sector.
1291 static int compare_buffers(const uint8_t *buf1
, const uint8_t *buf2
,
1292 int64_t bytes
, int64_t *pnum
)
1295 int64_t i
= MIN(bytes
, BDRV_SECTOR_SIZE
);
1299 res
= !!memcmp(buf1
, buf2
, i
);
1301 int64_t len
= MIN(bytes
- i
, BDRV_SECTOR_SIZE
);
1303 if (!!memcmp(buf1
+ i
, buf2
+ i
, len
) != res
) {
1313 #define IO_BUF_SIZE (2 * MiB)
1316 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1318 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1319 * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1320 * failure), and 4 on error (the exit status for read errors), after emitting
1323 * @param blk: BlockBackend for the image
1324 * @param offset: Starting offset to check
1325 * @param bytes: Number of bytes to check
1326 * @param filename: Name of disk file we are checking (logging purpose)
1327 * @param buffer: Allocated buffer for storing read data
1328 * @param quiet: Flag for quiet mode
1330 static int check_empty_sectors(BlockBackend
*blk
, int64_t offset
,
1331 int64_t bytes
, const char *filename
,
1332 uint8_t *buffer
, bool quiet
)
1337 ret
= blk_pread(blk
, offset
, buffer
, bytes
);
1339 error_report("Error while reading offset %" PRId64
" of %s: %s",
1340 offset
, filename
, strerror(-ret
));
1343 idx
= find_nonzero(buffer
, bytes
);
1345 qprintf(quiet
, "Content mismatch at offset %" PRId64
"!\n",
1354 * Compares two images. Exit codes:
1356 * 0 - Images are identical
1358 * >1 - Error occurred
1360 static int img_compare(int argc
, char **argv
)
1362 const char *fmt1
= NULL
, *fmt2
= NULL
, *cache
, *filename1
, *filename2
;
1363 BlockBackend
*blk1
, *blk2
;
1364 BlockDriverState
*bs1
, *bs2
;
1365 int64_t total_size1
, total_size2
;
1366 uint8_t *buf1
= NULL
, *buf2
= NULL
;
1367 int64_t pnum1
, pnum2
;
1368 int allocated1
, allocated2
;
1369 int ret
= 0; /* return value - 0 Ident, 1 Different, >1 Error */
1370 bool progress
= false, quiet
= false, strict
= false;
1377 uint64_t progress_base
;
1378 bool image_opts
= false;
1379 bool force_share
= false;
1381 cache
= BDRV_DEFAULT_CACHE
;
1383 static const struct option long_options
[] = {
1384 {"help", no_argument
, 0, 'h'},
1385 {"object", required_argument
, 0, OPTION_OBJECT
},
1386 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
1387 {"force-share", no_argument
, 0, 'U'},
1390 c
= getopt_long(argc
, argv
, ":hf:F:T:pqsU",
1391 long_options
, NULL
);
1397 missing_argument(argv
[optind
- 1]);
1400 unrecognized_option(argv
[optind
- 1]);
1426 case OPTION_OBJECT
: {
1428 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
1435 case OPTION_IMAGE_OPTS
:
1441 /* Progress is not shown in Quiet mode */
1447 if (optind
!= argc
- 2) {
1448 error_exit("Expecting two image file names");
1450 filename1
= argv
[optind
++];
1451 filename2
= argv
[optind
++];
1453 if (qemu_opts_foreach(&qemu_object_opts
,
1454 user_creatable_add_opts_foreach
,
1455 qemu_img_object_print_help
, &error_fatal
)) {
1460 /* Initialize before goto out */
1461 qemu_progress_init(progress
, 2.0);
1464 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
1466 error_report("Invalid source cache option: %s", cache
);
1471 blk1
= img_open(image_opts
, filename1
, fmt1
, flags
, writethrough
, quiet
,
1478 blk2
= img_open(image_opts
, filename2
, fmt2
, flags
, writethrough
, quiet
,
1487 buf1
= blk_blockalign(blk1
, IO_BUF_SIZE
);
1488 buf2
= blk_blockalign(blk2
, IO_BUF_SIZE
);
1489 total_size1
= blk_getlength(blk1
);
1490 if (total_size1
< 0) {
1491 error_report("Can't get size of %s: %s",
1492 filename1
, strerror(-total_size1
));
1496 total_size2
= blk_getlength(blk2
);
1497 if (total_size2
< 0) {
1498 error_report("Can't get size of %s: %s",
1499 filename2
, strerror(-total_size2
));
1503 total_size
= MIN(total_size1
, total_size2
);
1504 progress_base
= MAX(total_size1
, total_size2
);
1506 qemu_progress_print(0, 100);
1508 if (strict
&& total_size1
!= total_size2
) {
1510 qprintf(quiet
, "Strict mode: Image size mismatch!\n");
1514 while (offset
< total_size
) {
1515 int status1
, status2
;
1517 status1
= bdrv_block_status_above(bs1
, NULL
, offset
,
1518 total_size1
- offset
, &pnum1
, NULL
,
1522 error_report("Sector allocation test failed for %s", filename1
);
1525 allocated1
= status1
& BDRV_BLOCK_ALLOCATED
;
1527 status2
= bdrv_block_status_above(bs2
, NULL
, offset
,
1528 total_size2
- offset
, &pnum2
, NULL
,
1532 error_report("Sector allocation test failed for %s", filename2
);
1535 allocated2
= status2
& BDRV_BLOCK_ALLOCATED
;
1537 assert(pnum1
&& pnum2
);
1538 chunk
= MIN(pnum1
, pnum2
);
1541 if (status1
!= status2
) {
1543 qprintf(quiet
, "Strict mode: Offset %" PRId64
1544 " block status mismatch!\n", offset
);
1548 if ((status1
& BDRV_BLOCK_ZERO
) && (status2
& BDRV_BLOCK_ZERO
)) {
1550 } else if (allocated1
== allocated2
) {
1554 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1555 ret
= blk_pread(blk1
, offset
, buf1
, chunk
);
1557 error_report("Error while reading offset %" PRId64
1559 offset
, filename1
, strerror(-ret
));
1563 ret
= blk_pread(blk2
, offset
, buf2
, chunk
);
1565 error_report("Error while reading offset %" PRId64
1567 offset
, filename2
, strerror(-ret
));
1571 ret
= compare_buffers(buf1
, buf2
, chunk
, &pnum
);
1572 if (ret
|| pnum
!= chunk
) {
1573 qprintf(quiet
, "Content mismatch at offset %" PRId64
"!\n",
1574 offset
+ (ret ?
0 : pnum
));
1580 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1582 ret
= check_empty_sectors(blk1
, offset
, chunk
,
1583 filename1
, buf1
, quiet
);
1585 ret
= check_empty_sectors(blk2
, offset
, chunk
,
1586 filename2
, buf1
, quiet
);
1593 qemu_progress_print(((float) chunk
/ progress_base
) * 100, 100);
1596 if (total_size1
!= total_size2
) {
1597 BlockBackend
*blk_over
;
1598 const char *filename_over
;
1600 qprintf(quiet
, "Warning: Image size mismatch!\n");
1601 if (total_size1
> total_size2
) {
1603 filename_over
= filename1
;
1606 filename_over
= filename2
;
1609 while (offset
< progress_base
) {
1610 ret
= bdrv_block_status_above(blk_bs(blk_over
), NULL
, offset
,
1611 progress_base
- offset
, &chunk
,
1615 error_report("Sector allocation test failed for %s",
1620 if (ret
& BDRV_BLOCK_ALLOCATED
&& !(ret
& BDRV_BLOCK_ZERO
)) {
1621 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1622 ret
= check_empty_sectors(blk_over
, offset
, chunk
,
1623 filename_over
, buf1
, quiet
);
1629 qemu_progress_print(((float) chunk
/ progress_base
) * 100, 100);
1633 qprintf(quiet
, "Images are identical.\n");
1643 qemu_progress_end();
1648 /* Convenience wrapper around qmp_block_dirty_bitmap_merge */
1649 static void do_dirty_bitmap_merge(const char *dst_node
, const char *dst_name
,
1650 const char *src_node
, const char *src_name
,
1653 BlockDirtyBitmapMergeSource
*merge_src
;
1654 BlockDirtyBitmapMergeSourceList
*list
= NULL
;
1656 merge_src
= g_new0(BlockDirtyBitmapMergeSource
, 1);
1657 merge_src
->type
= QTYPE_QDICT
;
1658 merge_src
->u
.external
.node
= g_strdup(src_node
);
1659 merge_src
->u
.external
.name
= g_strdup(src_name
);
1660 QAPI_LIST_PREPEND(list
, merge_src
);
1661 qmp_block_dirty_bitmap_merge(dst_node
, dst_name
, list
, errp
);
1662 qapi_free_BlockDirtyBitmapMergeSourceList(list
);
1665 enum ImgConvertBlockStatus
{
1671 #define MAX_COROUTINES 16
1672 #define CONVERT_THROTTLE_GROUP "img_convert"
1674 typedef struct ImgConvertState
{
1676 int64_t *src_sectors
;
1679 int64_t total_sectors
;
1680 int64_t allocated_sectors
;
1681 int64_t allocated_done
;
1684 enum ImgConvertBlockStatus status
;
1685 int64_t sector_next_status
;
1686 BlockBackend
*target
;
1690 bool target_has_backing
;
1691 int64_t target_backing_sectors
; /* negative if unknown */
1698 size_t cluster_sectors
;
1700 long num_coroutines
;
1701 int running_coroutines
;
1702 Coroutine
*co
[MAX_COROUTINES
];
1703 int64_t wait_sector_num
[MAX_COROUTINES
];
1708 static void convert_select_part(ImgConvertState
*s
, int64_t sector_num
,
1709 int *src_cur
, int64_t *src_cur_offset
)
1712 *src_cur_offset
= 0;
1713 while (sector_num
- *src_cur_offset
>= s
->src_sectors
[*src_cur
]) {
1714 *src_cur_offset
+= s
->src_sectors
[*src_cur
];
1716 assert(*src_cur
< s
->src_num
);
1720 static int convert_iteration_sectors(ImgConvertState
*s
, int64_t sector_num
)
1722 int64_t src_cur_offset
;
1723 int ret
, n
, src_cur
;
1724 bool post_backing_zero
= false;
1726 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1728 assert(s
->total_sectors
> sector_num
);
1729 n
= MIN(s
->total_sectors
- sector_num
, BDRV_REQUEST_MAX_SECTORS
);
1731 if (s
->target_backing_sectors
>= 0) {
1732 if (sector_num
>= s
->target_backing_sectors
) {
1733 post_backing_zero
= true;
1734 } else if (sector_num
+ n
> s
->target_backing_sectors
) {
1735 /* Split requests around target_backing_sectors (because
1736 * starting from there, zeros are handled differently) */
1737 n
= s
->target_backing_sectors
- sector_num
;
1741 if (s
->sector_next_status
<= sector_num
) {
1742 uint64_t offset
= (sector_num
- src_cur_offset
) * BDRV_SECTOR_SIZE
;
1745 BlockDriverState
*src_bs
= blk_bs(s
->src
[src_cur
]);
1746 BlockDriverState
*base
;
1748 if (s
->target_has_backing
) {
1749 base
= bdrv_cow_bs(bdrv_skip_filters(src_bs
));
1755 count
= n
* BDRV_SECTOR_SIZE
;
1757 ret
= bdrv_block_status_above(src_bs
, base
, offset
, count
, &count
,
1764 warn_report("error while reading block status at "
1765 "offset %" PRIu64
": %s", offset
,
1768 /* Just try to read the data, then */
1769 ret
= BDRV_BLOCK_DATA
;
1770 count
= BDRV_SECTOR_SIZE
;
1772 /* Retry on a shorter range */
1773 n
= DIV_ROUND_UP(n
, 4);
1776 error_report("error while reading block status at offset "
1777 "%" PRIu64
": %s", offset
, strerror(-ret
));
1783 n
= DIV_ROUND_UP(count
, BDRV_SECTOR_SIZE
);
1786 * Avoid that s->sector_next_status becomes unaligned to the source
1787 * request alignment and/or cluster size to avoid unnecessary read
1790 tail
= (sector_num
- src_cur_offset
+ n
) % s
->src_alignment
[src_cur
];
1795 if (ret
& BDRV_BLOCK_ZERO
) {
1796 s
->status
= post_backing_zero ? BLK_BACKING_FILE
: BLK_ZERO
;
1797 } else if (ret
& BDRV_BLOCK_DATA
) {
1798 s
->status
= BLK_DATA
;
1800 s
->status
= s
->target_has_backing ? BLK_BACKING_FILE
: BLK_DATA
;
1803 s
->sector_next_status
= sector_num
+ n
;
1806 n
= MIN(n
, s
->sector_next_status
- sector_num
);
1807 if (s
->status
== BLK_DATA
) {
1808 n
= MIN(n
, s
->buf_sectors
);
1811 /* We need to write complete clusters for compressed images, so if an
1812 * unallocated area is shorter than that, we must consider the whole
1813 * cluster allocated. */
1814 if (s
->compressed
) {
1815 if (n
< s
->cluster_sectors
) {
1816 n
= MIN(s
->cluster_sectors
, s
->total_sectors
- sector_num
);
1817 s
->status
= BLK_DATA
;
1819 n
= QEMU_ALIGN_DOWN(n
, s
->cluster_sectors
);
1826 static int coroutine_fn
convert_co_read(ImgConvertState
*s
, int64_t sector_num
,
1827 int nb_sectors
, uint8_t *buf
)
1829 uint64_t single_read_until
= 0;
1832 assert(nb_sectors
<= s
->buf_sectors
);
1833 while (nb_sectors
> 0) {
1836 int64_t bs_sectors
, src_cur_offset
;
1839 /* In the case of compression with multiple source files, we can get a
1840 * nb_sectors that spreads into the next part. So we must be able to
1841 * read across multiple BDSes for one convert_read() call. */
1842 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1843 blk
= s
->src
[src_cur
];
1844 bs_sectors
= s
->src_sectors
[src_cur
];
1846 offset
= (sector_num
- src_cur_offset
) << BDRV_SECTOR_BITS
;
1848 n
= MIN(nb_sectors
, bs_sectors
- (sector_num
- src_cur_offset
));
1849 if (single_read_until
> offset
) {
1853 ret
= blk_co_pread(blk
, offset
, n
<< BDRV_SECTOR_BITS
, buf
, 0);
1857 single_read_until
= offset
+ (n
<< BDRV_SECTOR_BITS
);
1861 warn_report("error while reading offset %" PRIu64
1862 ": %s", offset
, strerror(-ret
));
1864 memset(buf
, 0, BDRV_SECTOR_SIZE
);
1873 buf
+= n
* BDRV_SECTOR_SIZE
;
1880 static int coroutine_fn
convert_co_write(ImgConvertState
*s
, int64_t sector_num
,
1881 int nb_sectors
, uint8_t *buf
,
1882 enum ImgConvertBlockStatus status
)
1886 while (nb_sectors
> 0) {
1888 BdrvRequestFlags flags
= s
->compressed ? BDRV_REQ_WRITE_COMPRESSED
: 0;
1891 case BLK_BACKING_FILE
:
1892 /* If we have a backing file, leave clusters unallocated that are
1893 * unallocated in the source image, so that the backing file is
1894 * visible at the respective offset. */
1895 assert(s
->target_has_backing
);
1899 /* If we're told to keep the target fully allocated (-S 0) or there
1900 * is real non-zero data, we must write it. Otherwise we can treat
1901 * it as zero sectors.
1902 * Compressed clusters need to be written as a whole, so in that
1903 * case we can only save the write if the buffer is completely
1905 if (!s
->min_sparse
||
1907 is_allocated_sectors_min(buf
, n
, &n
, s
->min_sparse
,
1908 sector_num
, s
->alignment
)) ||
1910 !buffer_is_zero(buf
, n
* BDRV_SECTOR_SIZE
)))
1912 ret
= blk_co_pwrite(s
->target
, sector_num
<< BDRV_SECTOR_BITS
,
1913 n
<< BDRV_SECTOR_BITS
, buf
, flags
);
1922 if (s
->has_zero_init
) {
1923 assert(!s
->target_has_backing
);
1926 ret
= blk_co_pwrite_zeroes(s
->target
,
1927 sector_num
<< BDRV_SECTOR_BITS
,
1928 n
<< BDRV_SECTOR_BITS
,
1929 BDRV_REQ_MAY_UNMAP
);
1938 buf
+= n
* BDRV_SECTOR_SIZE
;
1944 static int coroutine_fn
convert_co_copy_range(ImgConvertState
*s
, int64_t sector_num
,
1949 while (nb_sectors
> 0) {
1952 int64_t bs_sectors
, src_cur_offset
;
1955 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1956 offset
= (sector_num
- src_cur_offset
) << BDRV_SECTOR_BITS
;
1957 blk
= s
->src
[src_cur
];
1958 bs_sectors
= s
->src_sectors
[src_cur
];
1960 n
= MIN(nb_sectors
, bs_sectors
- (sector_num
- src_cur_offset
));
1962 ret
= blk_co_copy_range(blk
, offset
, s
->target
,
1963 sector_num
<< BDRV_SECTOR_BITS
,
1964 n
<< BDRV_SECTOR_BITS
, 0, 0);
1975 static void coroutine_fn
convert_co_do_copy(void *opaque
)
1977 ImgConvertState
*s
= opaque
;
1978 uint8_t *buf
= NULL
;
1982 for (i
= 0; i
< s
->num_coroutines
; i
++) {
1983 if (s
->co
[i
] == qemu_coroutine_self()) {
1990 s
->running_coroutines
++;
1991 buf
= blk_blockalign(s
->target
, s
->buf_sectors
* BDRV_SECTOR_SIZE
);
1996 enum ImgConvertBlockStatus status
;
1999 qemu_co_mutex_lock(&s
->lock
);
2000 if (s
->ret
!= -EINPROGRESS
|| s
->sector_num
>= s
->total_sectors
) {
2001 qemu_co_mutex_unlock(&s
->lock
);
2004 n
= convert_iteration_sectors(s
, s
->sector_num
);
2006 qemu_co_mutex_unlock(&s
->lock
);
2010 /* save current sector and allocation status to local variables */
2011 sector_num
= s
->sector_num
;
2013 if (!s
->min_sparse
&& s
->status
== BLK_ZERO
) {
2014 n
= MIN(n
, s
->buf_sectors
);
2016 /* increment global sector counter so that other coroutines can
2017 * already continue reading beyond this request */
2019 qemu_co_mutex_unlock(&s
->lock
);
2021 if (status
== BLK_DATA
|| (!s
->min_sparse
&& status
== BLK_ZERO
)) {
2022 s
->allocated_done
+= n
;
2023 qemu_progress_print(100.0 * s
->allocated_done
/
2024 s
->allocated_sectors
, 0);
2028 copy_range
= s
->copy_range
&& s
->status
== BLK_DATA
;
2029 if (status
== BLK_DATA
&& !copy_range
) {
2030 ret
= convert_co_read(s
, sector_num
, n
, buf
);
2032 error_report("error while reading at byte %lld: %s",
2033 sector_num
* BDRV_SECTOR_SIZE
, strerror(-ret
));
2036 } else if (!s
->min_sparse
&& status
== BLK_ZERO
) {
2038 memset(buf
, 0x00, n
* BDRV_SECTOR_SIZE
);
2041 if (s
->wr_in_order
) {
2042 /* keep writes in order */
2043 while (s
->wr_offs
!= sector_num
&& s
->ret
== -EINPROGRESS
) {
2044 s
->wait_sector_num
[index
] = sector_num
;
2045 qemu_coroutine_yield();
2047 s
->wait_sector_num
[index
] = -1;
2050 if (s
->ret
== -EINPROGRESS
) {
2052 ret
= convert_co_copy_range(s
, sector_num
, n
);
2054 s
->copy_range
= false;
2058 ret
= convert_co_write(s
, sector_num
, n
, buf
, status
);
2061 error_report("error while writing at byte %lld: %s",
2062 sector_num
* BDRV_SECTOR_SIZE
, strerror(-ret
));
2067 if (s
->wr_in_order
) {
2068 /* reenter the coroutine that might have waited
2069 * for this write to complete */
2070 s
->wr_offs
= sector_num
+ n
;
2071 for (i
= 0; i
< s
->num_coroutines
; i
++) {
2072 if (s
->co
[i
] && s
->wait_sector_num
[i
] == s
->wr_offs
) {
2074 * A -> B -> A cannot occur because A has
2075 * s->wait_sector_num[i] == -1 during A -> B. Therefore
2076 * B will never enter A during this time window.
2078 qemu_coroutine_enter(s
->co
[i
]);
2086 s
->co
[index
] = NULL
;
2087 s
->running_coroutines
--;
2088 if (!s
->running_coroutines
&& s
->ret
== -EINPROGRESS
) {
2089 /* the convert job finished successfully */
2094 static int convert_do_copy(ImgConvertState
*s
)
2097 int64_t sector_num
= 0;
2099 /* Check whether we have zero initialisation or can get it efficiently */
2100 if (!s
->has_zero_init
&& s
->target_is_new
&& s
->min_sparse
&&
2101 !s
->target_has_backing
) {
2102 s
->has_zero_init
= bdrv_has_zero_init(blk_bs(s
->target
));
2105 /* Allocate buffer for copied data. For compressed images, only one cluster
2106 * can be copied at a time. */
2107 if (s
->compressed
) {
2108 if (s
->cluster_sectors
<= 0 || s
->cluster_sectors
> s
->buf_sectors
) {
2109 error_report("invalid cluster size");
2112 s
->buf_sectors
= s
->cluster_sectors
;
2115 while (sector_num
< s
->total_sectors
) {
2116 n
= convert_iteration_sectors(s
, sector_num
);
2120 if (s
->status
== BLK_DATA
|| (!s
->min_sparse
&& s
->status
== BLK_ZERO
))
2122 s
->allocated_sectors
+= n
;
2128 s
->sector_next_status
= 0;
2129 s
->ret
= -EINPROGRESS
;
2131 qemu_co_mutex_init(&s
->lock
);
2132 for (i
= 0; i
< s
->num_coroutines
; i
++) {
2133 s
->co
[i
] = qemu_coroutine_create(convert_co_do_copy
, s
);
2134 s
->wait_sector_num
[i
] = -1;
2135 qemu_coroutine_enter(s
->co
[i
]);
2138 while (s
->running_coroutines
) {
2139 main_loop_wait(false);
2142 if (s
->compressed
&& !s
->ret
) {
2143 /* signal EOF to align */
2144 ret
= blk_pwrite_compressed(s
->target
, 0, NULL
, 0);
2153 static int convert_copy_bitmaps(BlockDriverState
*src
, BlockDriverState
*dst
)
2155 BdrvDirtyBitmap
*bm
;
2158 FOR_EACH_DIRTY_BITMAP(src
, bm
) {
2161 if (!bdrv_dirty_bitmap_get_persistence(bm
)) {
2164 name
= bdrv_dirty_bitmap_name(bm
);
2165 qmp_block_dirty_bitmap_add(dst
->node_name
, name
,
2166 true, bdrv_dirty_bitmap_granularity(bm
),
2168 true, !bdrv_dirty_bitmap_enabled(bm
),
2171 error_reportf_err(err
, "Failed to create bitmap %s: ", name
);
2175 do_dirty_bitmap_merge(dst
->node_name
, name
, src
->node_name
, name
,
2178 error_reportf_err(err
, "Failed to populate bitmap %s: ", name
);
2186 #define MAX_BUF_SECTORS 32768
2188 static void set_rate_limit(BlockBackend
*blk
, int64_t rate_limit
)
2192 throttle_config_init(&cfg
);
2193 cfg
.buckets
[THROTTLE_BPS_WRITE
].avg
= rate_limit
;
2195 blk_io_limits_enable(blk
, CONVERT_THROTTLE_GROUP
);
2196 blk_set_io_limits(blk
, &cfg
);
2199 static int img_convert(int argc
, char **argv
)
2201 int c
, bs_i
, flags
, src_flags
= 0;
2202 const char *fmt
= NULL
, *out_fmt
= NULL
, *cache
= "unsafe",
2203 *src_cache
= BDRV_DEFAULT_CACHE
, *out_baseimg
= NULL
,
2204 *out_filename
, *out_baseimg_param
, *snapshot_name
= NULL
;
2205 BlockDriver
*drv
= NULL
, *proto_drv
= NULL
;
2206 BlockDriverInfo bdi
;
2207 BlockDriverState
*out_bs
;
2208 QemuOpts
*opts
= NULL
, *sn_opts
= NULL
;
2209 QemuOptsList
*create_opts
= NULL
;
2210 QDict
*open_opts
= NULL
;
2211 char *options
= NULL
;
2212 Error
*local_err
= NULL
;
2213 bool writethrough
, src_writethrough
, image_opts
= false,
2214 skip_create
= false, progress
= false, tgt_image_opts
= false;
2215 int64_t ret
= -EINVAL
;
2216 bool force_share
= false;
2217 bool explict_min_sparse
= false;
2218 bool bitmaps
= false;
2219 int64_t rate_limit
= 0;
2221 ImgConvertState s
= (ImgConvertState
) {
2222 /* Need at least 4k of zeros for sparse detection */
2224 .copy_range
= false,
2225 .buf_sectors
= IO_BUF_SIZE
/ BDRV_SECTOR_SIZE
,
2226 .wr_in_order
= true,
2227 .num_coroutines
= 8,
2231 static const struct option long_options
[] = {
2232 {"help", no_argument
, 0, 'h'},
2233 {"object", required_argument
, 0, OPTION_OBJECT
},
2234 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
2235 {"force-share", no_argument
, 0, 'U'},
2236 {"target-image-opts", no_argument
, 0, OPTION_TARGET_IMAGE_OPTS
},
2237 {"salvage", no_argument
, 0, OPTION_SALVAGE
},
2238 {"target-is-zero", no_argument
, 0, OPTION_TARGET_IS_ZERO
},
2239 {"bitmaps", no_argument
, 0, OPTION_BITMAPS
},
2242 c
= getopt_long(argc
, argv
, ":hf:O:B:Cco:l:S:pt:T:qnm:WUr:",
2243 long_options
, NULL
);
2249 missing_argument(argv
[optind
- 1]);
2252 unrecognized_option(argv
[optind
- 1]);
2264 out_baseimg
= optarg
;
2267 s
.copy_range
= true;
2270 s
.compressed
= true;
2273 if (accumulate_options(&options
, optarg
) < 0) {
2278 if (strstart(optarg
, SNAPSHOT_OPT_BASE
, NULL
)) {
2279 sn_opts
= qemu_opts_parse_noisily(&internal_snapshot_opts
,
2282 error_report("Failed in parsing snapshot param '%s'",
2287 snapshot_name
= optarg
;
2294 sval
= cvtnum("buffer size for sparse output", optarg
);
2297 } else if (!QEMU_IS_ALIGNED(sval
, BDRV_SECTOR_SIZE
) ||
2298 sval
/ BDRV_SECTOR_SIZE
> MAX_BUF_SECTORS
) {
2299 error_report("Invalid buffer size for sparse output specified. "
2300 "Valid sizes are multiples of %llu up to %llu. Select "
2301 "0 to disable sparse detection (fully allocates output).",
2302 BDRV_SECTOR_SIZE
, MAX_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2306 s
.min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
2307 explict_min_sparse
= true;
2326 if (qemu_strtol(optarg
, NULL
, 0, &s
.num_coroutines
) ||
2327 s
.num_coroutines
< 1 || s
.num_coroutines
> MAX_COROUTINES
) {
2328 error_report("Invalid number of coroutines. Allowed number of"
2329 " coroutines is between 1 and %d", MAX_COROUTINES
);
2334 s
.wr_in_order
= false;
2340 rate_limit
= cvtnum("rate limit", optarg
);
2341 if (rate_limit
< 0) {
2345 case OPTION_OBJECT
: {
2346 QemuOpts
*object_opts
;
2347 object_opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
2354 case OPTION_IMAGE_OPTS
:
2357 case OPTION_SALVAGE
:
2360 case OPTION_TARGET_IMAGE_OPTS
:
2361 tgt_image_opts
= true;
2363 case OPTION_TARGET_IS_ZERO
:
2365 * The user asserting that the target is blank has the
2366 * same effect as the target driver supporting zero
2369 s
.has_zero_init
= true;
2371 case OPTION_BITMAPS
:
2377 if (!out_fmt
&& !tgt_image_opts
) {
2381 if (qemu_opts_foreach(&qemu_object_opts
,
2382 user_creatable_add_opts_foreach
,
2383 qemu_img_object_print_help
, &error_fatal
)) {
2387 if (s
.compressed
&& s
.copy_range
) {
2388 error_report("Cannot enable copy offloading when -c is used");
2392 if (explict_min_sparse
&& s
.copy_range
) {
2393 error_report("Cannot enable copy offloading when -S is used");
2397 if (s
.copy_range
&& s
.salvage
) {
2398 error_report("Cannot use copy offloading in salvaging mode");
2402 if (tgt_image_opts
&& !skip_create
) {
2403 error_report("--target-image-opts requires use of -n flag");
2407 if (skip_create
&& options
) {
2408 error_report("-o has no effect when skipping image creation");
2412 if (s
.has_zero_init
&& !skip_create
) {
2413 error_report("--target-is-zero requires use of -n flag");
2417 s
.src_num
= argc
- optind
- 1;
2418 out_filename
= s
.src_num
>= 1 ? argv
[argc
- 1] : NULL
;
2420 if (options
&& has_help_option(options
)) {
2422 ret
= print_block_option_help(out_filename
, out_fmt
);
2425 error_report("Option help requires a format be specified");
2430 if (s
.src_num
< 1) {
2431 error_report("Must specify image file name");
2435 /* ret is still -EINVAL until here */
2436 ret
= bdrv_parse_cache_mode(src_cache
, &src_flags
, &src_writethrough
);
2438 error_report("Invalid source cache option: %s", src_cache
);
2442 /* Initialize before goto out */
2446 qemu_progress_init(progress
, 1.0);
2447 qemu_progress_print(0, 100);
2449 s
.src
= g_new0(BlockBackend
*, s
.src_num
);
2450 s
.src_sectors
= g_new(int64_t, s
.src_num
);
2451 s
.src_alignment
= g_new(int, s
.src_num
);
2453 for (bs_i
= 0; bs_i
< s
.src_num
; bs_i
++) {
2454 BlockDriverState
*src_bs
;
2455 s
.src
[bs_i
] = img_open(image_opts
, argv
[optind
+ bs_i
],
2456 fmt
, src_flags
, src_writethrough
, s
.quiet
,
2462 s
.src_sectors
[bs_i
] = blk_nb_sectors(s
.src
[bs_i
]);
2463 if (s
.src_sectors
[bs_i
] < 0) {
2464 error_report("Could not get size of %s: %s",
2465 argv
[optind
+ bs_i
], strerror(-s
.src_sectors
[bs_i
]));
2469 src_bs
= blk_bs(s
.src
[bs_i
]);
2470 s
.src_alignment
[bs_i
] = DIV_ROUND_UP(src_bs
->bl
.request_alignment
,
2472 if (!bdrv_get_info(src_bs
, &bdi
)) {
2473 s
.src_alignment
[bs_i
] = MAX(s
.src_alignment
[bs_i
],
2474 bdi
.cluster_size
/ BDRV_SECTOR_SIZE
);
2476 s
.total_sectors
+= s
.src_sectors
[bs_i
];
2480 bdrv_snapshot_load_tmp(blk_bs(s
.src
[0]),
2481 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_ID
),
2482 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_NAME
),
2484 } else if (snapshot_name
!= NULL
) {
2485 if (s
.src_num
> 1) {
2486 error_report("No support for concatenating multiple snapshot");
2491 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s
.src
[0]), snapshot_name
,
2495 error_reportf_err(local_err
, "Failed to load snapshot: ");
2501 /* Find driver and parse its options */
2502 drv
= bdrv_find_format(out_fmt
);
2504 error_report("Unknown file format '%s'", out_fmt
);
2509 proto_drv
= bdrv_find_protocol(out_filename
, true, &local_err
);
2511 error_report_err(local_err
);
2516 if (!drv
->create_opts
) {
2517 error_report("Format driver '%s' does not support image creation",
2523 if (!proto_drv
->create_opts
) {
2524 error_report("Protocol driver '%s' does not support image creation",
2525 proto_drv
->format_name
);
2530 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
2531 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
2533 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
2535 if (!qemu_opts_do_parse(opts
, options
, NULL
, &local_err
)) {
2536 error_report_err(local_err
);
2542 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
2543 s
.total_sectors
* BDRV_SECTOR_SIZE
, &error_abort
);
2544 ret
= add_old_style_options(out_fmt
, opts
, out_baseimg
, NULL
);
2550 /* Get backing file name if -o backing_file was used */
2551 out_baseimg_param
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
2552 if (out_baseimg_param
) {
2553 out_baseimg
= out_baseimg_param
;
2555 s
.target_has_backing
= (bool) out_baseimg
;
2557 if (s
.has_zero_init
&& s
.target_has_backing
) {
2558 error_report("Cannot use --target-is-zero when the destination "
2559 "image has a backing file");
2563 if (s
.src_num
> 1 && out_baseimg
) {
2564 error_report("Having a backing file for the target makes no sense when "
2565 "concatenating multiple input images");
2570 if (out_baseimg_param
) {
2571 if (!qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
)) {
2572 warn_report("Deprecated use of backing file without explicit "
2577 /* Check if compression is supported */
2580 qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
, false);
2581 const char *encryptfmt
=
2582 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
);
2583 const char *preallocation
=
2584 qemu_opt_get(opts
, BLOCK_OPT_PREALLOC
);
2586 if (drv
&& !block_driver_can_compress(drv
)) {
2587 error_report("Compression not supported for this file format");
2592 if (encryption
|| encryptfmt
) {
2593 error_report("Compression and encryption not supported at "
2600 && strcmp(preallocation
, "off"))
2602 error_report("Compression and preallocation not supported at "
2609 /* Determine if bitmaps need copying */
2611 if (s
.src_num
> 1) {
2612 error_report("Copying bitmaps only possible with single source");
2616 if (!bdrv_supports_persistent_dirty_bitmap(blk_bs(s
.src
[0]))) {
2617 error_report("Source lacks bitmap support");
2624 * The later open call will need any decryption secrets, and
2625 * bdrv_create() will purge "opts", so extract them now before
2629 open_opts
= qdict_new();
2630 qemu_opt_foreach(opts
, img_add_key_secrets
, open_opts
, &error_abort
);
2632 /* Create the new image */
2633 ret
= bdrv_create(drv
, out_filename
, opts
, &local_err
);
2635 error_reportf_err(local_err
, "%s: error while converting %s: ",
2636 out_filename
, out_fmt
);
2641 s
.target_is_new
= !skip_create
;
2643 flags
= s
.min_sparse ?
(BDRV_O_RDWR
| BDRV_O_UNMAP
) : BDRV_O_RDWR
;
2644 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
2646 error_report("Invalid cache option: %s", cache
);
2651 s
.target
= img_open(tgt_image_opts
, out_filename
, out_fmt
,
2652 flags
, writethrough
, s
.quiet
, false);
2654 /* TODO ultimately we should allow --target-image-opts
2655 * to be used even when -n is not given.
2656 * That has to wait for bdrv_create to be improved
2657 * to allow filenames in option syntax
2659 s
.target
= img_open_file(out_filename
, open_opts
, out_fmt
,
2660 flags
, writethrough
, s
.quiet
, false);
2661 open_opts
= NULL
; /* blk_new_open will have freed it */
2667 out_bs
= blk_bs(s
.target
);
2669 if (bitmaps
&& !bdrv_supports_persistent_dirty_bitmap(out_bs
)) {
2670 error_report("Format driver '%s' does not support bitmaps",
2671 out_bs
->drv
->format_name
);
2676 if (s
.compressed
&& !block_driver_can_compress(out_bs
->drv
)) {
2677 error_report("Compression not supported for this file format");
2682 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2683 * or discard_alignment of the out_bs is greater. Limit to
2684 * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2685 s
.buf_sectors
= MIN(MAX_BUF_SECTORS
,
2687 MAX(out_bs
->bl
.opt_transfer
>> BDRV_SECTOR_BITS
,
2688 out_bs
->bl
.pdiscard_alignment
>>
2689 BDRV_SECTOR_BITS
)));
2691 /* try to align the write requests to the destination to avoid unnecessary
2693 s
.alignment
= MAX(pow2floor(s
.min_sparse
),
2694 DIV_ROUND_UP(out_bs
->bl
.request_alignment
,
2696 assert(is_power_of_2(s
.alignment
));
2699 int64_t output_sectors
= blk_nb_sectors(s
.target
);
2700 if (output_sectors
< 0) {
2701 error_report("unable to get output image length: %s",
2702 strerror(-output_sectors
));
2705 } else if (output_sectors
< s
.total_sectors
) {
2706 error_report("output file is smaller than input file");
2712 if (s
.target_has_backing
&& s
.target_is_new
) {
2713 /* Errors are treated as "backing length unknown" (which means
2714 * s.target_backing_sectors has to be negative, which it will
2715 * be automatically). The backing file length is used only
2716 * for optimizations, so such a case is not fatal. */
2717 s
.target_backing_sectors
=
2718 bdrv_nb_sectors(bdrv_backing_chain_next(out_bs
));
2720 s
.target_backing_sectors
= -1;
2723 ret
= bdrv_get_info(out_bs
, &bdi
);
2726 error_report("could not get block driver info");
2730 s
.compressed
= s
.compressed
|| bdi
.needs_compressed_writes
;
2731 s
.cluster_sectors
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2735 set_rate_limit(s
.target
, rate_limit
);
2738 ret
= convert_do_copy(&s
);
2740 /* Now copy the bitmaps */
2741 if (bitmaps
&& ret
== 0) {
2742 ret
= convert_copy_bitmaps(blk_bs(s
.src
[0]), out_bs
);
2747 qemu_progress_print(100, 0);
2749 qemu_progress_end();
2750 qemu_opts_del(opts
);
2751 qemu_opts_free(create_opts
);
2752 qobject_unref(open_opts
);
2753 blk_unref(s
.target
);
2755 for (bs_i
= 0; bs_i
< s
.src_num
; bs_i
++) {
2756 blk_unref(s
.src
[bs_i
]);
2760 g_free(s
.src_sectors
);
2761 g_free(s
.src_alignment
);
2763 qemu_opts_del(sn_opts
);
2770 static void dump_snapshots(BlockDriverState
*bs
)
2772 QEMUSnapshotInfo
*sn_tab
, *sn
;
2775 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
2778 printf("Snapshot list:\n");
2779 bdrv_snapshot_dump(NULL
);
2781 for(i
= 0; i
< nb_sns
; i
++) {
2783 bdrv_snapshot_dump(sn
);
2789 static void dump_json_image_info_list(ImageInfoList
*list
)
2793 Visitor
*v
= qobject_output_visitor_new(&obj
);
2795 visit_type_ImageInfoList(v
, NULL
, &list
, &error_abort
);
2796 visit_complete(v
, &obj
);
2797 str
= qobject_to_json_pretty(obj
, true);
2798 assert(str
!= NULL
);
2799 printf("%s\n", str
->str
);
2802 g_string_free(str
, true);
2805 static void dump_json_image_info(ImageInfo
*info
)
2809 Visitor
*v
= qobject_output_visitor_new(&obj
);
2811 visit_type_ImageInfo(v
, NULL
, &info
, &error_abort
);
2812 visit_complete(v
, &obj
);
2813 str
= qobject_to_json_pretty(obj
, true);
2814 assert(str
!= NULL
);
2815 printf("%s\n", str
->str
);
2818 g_string_free(str
, true);
2821 static void dump_human_image_info_list(ImageInfoList
*list
)
2823 ImageInfoList
*elem
;
2826 for (elem
= list
; elem
; elem
= elem
->next
) {
2832 bdrv_image_info_dump(elem
->value
);
2836 static gboolean
str_equal_func(gconstpointer a
, gconstpointer b
)
2838 return strcmp(a
, b
) == 0;
2842 * Open an image file chain and return an ImageInfoList
2844 * @filename: topmost image filename
2845 * @fmt: topmost image format (may be NULL to autodetect)
2846 * @chain: true - enumerate entire backing file chain
2847 * false - only topmost image file
2849 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2850 * image file. If there was an error a message will have been printed to
2853 static ImageInfoList
*collect_image_info_list(bool image_opts
,
2854 const char *filename
,
2856 bool chain
, bool force_share
)
2858 ImageInfoList
*head
= NULL
;
2859 ImageInfoList
**last
= &head
;
2860 GHashTable
*filenames
;
2863 filenames
= g_hash_table_new_full(g_str_hash
, str_equal_func
, NULL
, NULL
);
2867 BlockDriverState
*bs
;
2869 ImageInfoList
*elem
;
2871 if (g_hash_table_lookup_extended(filenames
, filename
, NULL
, NULL
)) {
2872 error_report("Backing file '%s' creates an infinite loop.",
2876 g_hash_table_insert(filenames
, (gpointer
)filename
, NULL
);
2878 blk
= img_open(image_opts
, filename
, fmt
,
2879 BDRV_O_NO_BACKING
| BDRV_O_NO_IO
, false, false,
2886 bdrv_query_image_info(bs
, &info
, &err
);
2888 error_report_err(err
);
2893 elem
= g_new0(ImageInfoList
, 1);
2900 /* Clear parameters that only apply to the topmost image */
2901 filename
= fmt
= NULL
;
2905 if (info
->has_full_backing_filename
) {
2906 filename
= info
->full_backing_filename
;
2907 } else if (info
->has_backing_filename
) {
2908 error_report("Could not determine absolute backing filename,"
2909 " but backing filename '%s' present",
2910 info
->backing_filename
);
2913 if (info
->has_backing_filename_format
) {
2914 fmt
= info
->backing_filename_format
;
2918 g_hash_table_destroy(filenames
);
2922 qapi_free_ImageInfoList(head
);
2923 g_hash_table_destroy(filenames
);
2927 static int img_info(int argc
, char **argv
)
2930 OutputFormat output_format
= OFORMAT_HUMAN
;
2932 const char *filename
, *fmt
, *output
;
2933 ImageInfoList
*list
;
2934 bool image_opts
= false;
2935 bool force_share
= false;
2940 int option_index
= 0;
2941 static const struct option long_options
[] = {
2942 {"help", no_argument
, 0, 'h'},
2943 {"format", required_argument
, 0, 'f'},
2944 {"output", required_argument
, 0, OPTION_OUTPUT
},
2945 {"backing-chain", no_argument
, 0, OPTION_BACKING_CHAIN
},
2946 {"object", required_argument
, 0, OPTION_OBJECT
},
2947 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
2948 {"force-share", no_argument
, 0, 'U'},
2951 c
= getopt_long(argc
, argv
, ":f:hU",
2952 long_options
, &option_index
);
2958 missing_argument(argv
[optind
- 1]);
2961 unrecognized_option(argv
[optind
- 1]);
2975 case OPTION_BACKING_CHAIN
:
2978 case OPTION_OBJECT
: {
2980 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
2986 case OPTION_IMAGE_OPTS
:
2991 if (optind
!= argc
- 1) {
2992 error_exit("Expecting one image file name");
2994 filename
= argv
[optind
++];
2996 if (output
&& !strcmp(output
, "json")) {
2997 output_format
= OFORMAT_JSON
;
2998 } else if (output
&& !strcmp(output
, "human")) {
2999 output_format
= OFORMAT_HUMAN
;
3000 } else if (output
) {
3001 error_report("--output must be used with human or json as argument.");
3005 if (qemu_opts_foreach(&qemu_object_opts
,
3006 user_creatable_add_opts_foreach
,
3007 qemu_img_object_print_help
, &error_fatal
)) {
3011 list
= collect_image_info_list(image_opts
, filename
, fmt
, chain
,
3017 switch (output_format
) {
3019 dump_human_image_info_list(list
);
3023 dump_json_image_info_list(list
);
3025 dump_json_image_info(list
->value
);
3030 qapi_free_ImageInfoList(list
);
3034 static int dump_map_entry(OutputFormat output_format
, MapEntry
*e
,
3037 switch (output_format
) {
3039 if (e
->data
&& !e
->has_offset
) {
3040 error_report("File contains external, encrypted or compressed clusters.");
3043 if (e
->data
&& !e
->zero
) {
3044 printf("%#-16"PRIx64
"%#-16"PRIx64
"%#-16"PRIx64
"%s\n",
3045 e
->start
, e
->length
,
3046 e
->has_offset ? e
->offset
: 0,
3047 e
->has_filename ? e
->filename
: "");
3049 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
3050 * Modify the flags here to allow more coalescing.
3052 if (next
&& (!next
->data
|| next
->zero
)) {
3058 printf("{ \"start\": %"PRId64
", \"length\": %"PRId64
","
3059 " \"depth\": %"PRId64
", \"zero\": %s, \"data\": %s",
3060 e
->start
, e
->length
, e
->depth
,
3061 e
->zero ?
"true" : "false",
3062 e
->data ?
"true" : "false");
3063 if (e
->has_offset
) {
3064 printf(", \"offset\": %"PRId64
"", e
->offset
);
3076 static int get_block_status(BlockDriverState
*bs
, int64_t offset
,
3077 int64_t bytes
, MapEntry
*e
)
3081 BlockDriverState
*file
;
3084 char *filename
= NULL
;
3086 /* As an optimization, we could cache the current range of unallocated
3087 * clusters in each file of the chain, and avoid querying the same
3093 bs
= bdrv_skip_filters(bs
);
3094 ret
= bdrv_block_status(bs
, offset
, bytes
, &bytes
, &map
, &file
);
3099 if (ret
& (BDRV_BLOCK_ZERO
|BDRV_BLOCK_DATA
)) {
3102 bs
= bdrv_cow_bs(bs
);
3111 has_offset
= !!(ret
& BDRV_BLOCK_OFFSET_VALID
);
3113 if (file
&& has_offset
) {
3114 bdrv_refresh_filename(file
);
3115 filename
= file
->filename
;
3121 .data
= !!(ret
& BDRV_BLOCK_DATA
),
3122 .zero
= !!(ret
& BDRV_BLOCK_ZERO
),
3124 .has_offset
= has_offset
,
3126 .has_filename
= filename
,
3127 .filename
= filename
,
3133 static inline bool entry_mergeable(const MapEntry
*curr
, const MapEntry
*next
)
3135 if (curr
->length
== 0) {
3138 if (curr
->zero
!= next
->zero
||
3139 curr
->data
!= next
->data
||
3140 curr
->depth
!= next
->depth
||
3141 curr
->has_filename
!= next
->has_filename
||
3142 curr
->has_offset
!= next
->has_offset
) {
3145 if (curr
->has_filename
&& strcmp(curr
->filename
, next
->filename
)) {
3148 if (curr
->has_offset
&& curr
->offset
+ curr
->length
!= next
->offset
) {
3154 static int img_map(int argc
, char **argv
)
3157 OutputFormat output_format
= OFORMAT_HUMAN
;
3159 BlockDriverState
*bs
;
3160 const char *filename
, *fmt
, *output
;
3162 MapEntry curr
= { .length
= 0 }, next
;
3164 bool image_opts
= false;
3165 bool force_share
= false;
3166 int64_t start_offset
= 0;
3167 int64_t max_length
= -1;
3172 int option_index
= 0;
3173 static const struct option long_options
[] = {
3174 {"help", no_argument
, 0, 'h'},
3175 {"format", required_argument
, 0, 'f'},
3176 {"output", required_argument
, 0, OPTION_OUTPUT
},
3177 {"object", required_argument
, 0, OPTION_OBJECT
},
3178 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3179 {"force-share", no_argument
, 0, 'U'},
3180 {"start-offset", required_argument
, 0, 's'},
3181 {"max-length", required_argument
, 0, 'l'},
3184 c
= getopt_long(argc
, argv
, ":f:s:l:hU",
3185 long_options
, &option_index
);
3191 missing_argument(argv
[optind
- 1]);
3194 unrecognized_option(argv
[optind
- 1]);
3209 start_offset
= cvtnum("start offset", optarg
);
3210 if (start_offset
< 0) {
3215 max_length
= cvtnum("max length", optarg
);
3216 if (max_length
< 0) {
3220 case OPTION_OBJECT
: {
3222 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
3228 case OPTION_IMAGE_OPTS
:
3233 if (optind
!= argc
- 1) {
3234 error_exit("Expecting one image file name");
3236 filename
= argv
[optind
];
3238 if (output
&& !strcmp(output
, "json")) {
3239 output_format
= OFORMAT_JSON
;
3240 } else if (output
&& !strcmp(output
, "human")) {
3241 output_format
= OFORMAT_HUMAN
;
3242 } else if (output
) {
3243 error_report("--output must be used with human or json as argument.");
3247 if (qemu_opts_foreach(&qemu_object_opts
,
3248 user_creatable_add_opts_foreach
,
3249 qemu_img_object_print_help
, &error_fatal
)) {
3253 blk
= img_open(image_opts
, filename
, fmt
, 0, false, false, force_share
);
3259 if (output_format
== OFORMAT_HUMAN
) {
3260 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
3261 } else if (output_format
== OFORMAT_JSON
) {
3265 length
= blk_getlength(blk
);
3267 error_report("Failed to get size for '%s'", filename
);
3270 if (max_length
!= -1) {
3271 length
= MIN(start_offset
+ max_length
, length
);
3274 curr
.start
= start_offset
;
3275 while (curr
.start
+ curr
.length
< length
) {
3276 int64_t offset
= curr
.start
+ curr
.length
;
3277 int64_t n
= length
- offset
;
3279 ret
= get_block_status(bs
, offset
, n
, &next
);
3281 error_report("Could not read file metadata: %s", strerror(-ret
));
3285 if (entry_mergeable(&curr
, &next
)) {
3286 curr
.length
+= next
.length
;
3290 if (curr
.length
> 0) {
3291 ret
= dump_map_entry(output_format
, &curr
, &next
);
3299 ret
= dump_map_entry(output_format
, &curr
, NULL
);
3300 if (output_format
== OFORMAT_JSON
) {
3309 #define SNAPSHOT_LIST 1
3310 #define SNAPSHOT_CREATE 2
3311 #define SNAPSHOT_APPLY 3
3312 #define SNAPSHOT_DELETE 4
3314 static int img_snapshot(int argc
, char **argv
)
3317 BlockDriverState
*bs
;
3318 QEMUSnapshotInfo sn
;
3319 char *filename
, *snapshot_name
= NULL
;
3320 int c
, ret
= 0, bdrv_oflags
;
3325 bool image_opts
= false;
3326 bool force_share
= false;
3328 bdrv_oflags
= BDRV_O_RDWR
;
3329 /* Parse commandline parameters */
3331 static const struct option long_options
[] = {
3332 {"help", no_argument
, 0, 'h'},
3333 {"object", required_argument
, 0, OPTION_OBJECT
},
3334 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3335 {"force-share", no_argument
, 0, 'U'},
3338 c
= getopt_long(argc
, argv
, ":la:c:d:hqU",
3339 long_options
, NULL
);
3345 missing_argument(argv
[optind
- 1]);
3348 unrecognized_option(argv
[optind
- 1]);
3355 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3358 action
= SNAPSHOT_LIST
;
3359 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
3363 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3366 action
= SNAPSHOT_APPLY
;
3367 snapshot_name
= optarg
;
3371 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3374 action
= SNAPSHOT_CREATE
;
3375 snapshot_name
= optarg
;
3379 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3382 action
= SNAPSHOT_DELETE
;
3383 snapshot_name
= optarg
;
3391 case OPTION_OBJECT
: {
3393 opts
= qemu_opts_parse_noisily(&qemu_object_opts
,
3399 case OPTION_IMAGE_OPTS
:
3405 if (optind
!= argc
- 1) {
3406 error_exit("Expecting one image file name");
3408 filename
= argv
[optind
++];