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,
85 OPTION_SKIP_BROKEN
= 277,
88 typedef enum OutputFormat
{
93 /* Default to cache=writeback as data integrity is not important for qemu-img */
94 #define BDRV_DEFAULT_CACHE "writeback"
96 static void format_print(void *opaque
, const char *name
)
101 static void QEMU_NORETURN
GCC_FMT_ATTR(1, 2) error_exit(const char *fmt
, ...)
106 error_vreport(fmt
, ap
);
109 error_printf("Try 'qemu-img --help' for more information\n");
113 static void QEMU_NORETURN
missing_argument(const char *option
)
115 error_exit("missing argument for option '%s'", option
);
118 static void QEMU_NORETURN
unrecognized_option(const char *option
)
120 error_exit("unrecognized option '%s'", option
);
123 /* Please keep in synch with docs/tools/qemu-img.rst */
124 static void QEMU_NORETURN
help(void)
126 const char *help_msg
=
128 "usage: qemu-img [standard options] command [command options]\n"
129 "QEMU disk image utility\n"
131 " '-h', '--help' display this help and exit\n"
132 " '-V', '--version' output version information and exit\n"
133 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
134 " specify tracing options\n"
137 #define DEF(option, callback, arg_string) \
139 #include "qemu-img-cmds.h"
142 "Command parameters:\n"
143 " 'filename' is a disk image filename\n"
144 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
145 " manual page for a description of the object properties. The most common\n"
146 " object type is a 'secret', which is used to supply passwords and/or\n"
147 " encryption keys.\n"
148 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
149 " 'cache' is the cache mode used to write the output disk image, the valid\n"
150 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
151 " 'directsync' and 'unsafe' (default for convert)\n"
152 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
153 " options are the same as for the 'cache' option\n"
154 " 'size' is the disk image size in bytes. Optional suffixes\n"
155 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
156 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
157 " supported. 'b' is ignored.\n"
158 " 'output_filename' is the destination disk image filename\n"
159 " 'output_fmt' is the destination format\n"
160 " 'options' is a comma separated list of format specific options in a\n"
161 " name=value format. Use -o ? for an overview of the options supported by the\n"
163 " 'snapshot_param' is param used for internal snapshot, format\n"
164 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
166 " '-c' indicates that target image must be compressed (qcow format only)\n"
167 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
168 " new backing file match exactly. The image doesn't need a working\n"
169 " backing file before rebasing in this case (useful for renaming the\n"
170 " backing file). For image creation, allow creating without attempting\n"
171 " to open the backing file.\n"
172 " '-h' with or without a command shows this help and lists the supported formats\n"
173 " '-p' show progress of command (only certain commands)\n"
174 " '-q' use Quiet mode - do not print any output (except errors)\n"
175 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
176 " contain only zeros for qemu-img to create a sparse image during\n"
177 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
178 " unallocated or zero sectors, and the destination image will always be\n"
180 " '--output' takes the format in which the output must be done (human or json)\n"
181 " '-n' skips the target volume creation (useful if the volume is created\n"
182 " prior to running qemu-img)\n"
184 "Parameters to bitmap subcommand:\n"
185 " 'bitmap' is the name of the bitmap to manipulate, through one or more\n"
186 " actions from '--add', '--remove', '--clear', '--enable', '--disable',\n"
187 " or '--merge source'\n"
188 " '-g granularity' sets the granularity for '--add' actions\n"
189 " '-b source' and '-F src_fmt' tell '--merge' actions to find the source\n"
190 " bitmaps from an alternative file\n"
192 "Parameters to check subcommand:\n"
193 " '-r' tries to repair any inconsistencies that are found during the check.\n"
194 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
195 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
196 " hiding corruption that has already occurred.\n"
198 "Parameters to convert subcommand:\n"
199 " '--bitmaps' copies all top-level persistent bitmaps to destination\n"
200 " '-m' specifies how many coroutines work in parallel during the convert\n"
201 " process (defaults to 8)\n"
202 " '-W' allow to write to the target out of order rather than sequential\n"
204 "Parameters to snapshot subcommand:\n"
205 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
206 " '-a' applies a snapshot (revert disk to saved state)\n"
207 " '-c' creates a snapshot\n"
208 " '-d' deletes a snapshot\n"
209 " '-l' lists all snapshots in the given image\n"
211 "Parameters to compare subcommand:\n"
212 " '-f' first image format\n"
213 " '-F' second image format\n"
214 " '-s' run in Strict mode - fail on different image size or sector allocation\n"
216 "Parameters to dd subcommand:\n"
217 " 'bs=BYTES' read and write up to BYTES bytes at a time "
219 " 'count=N' copy only N input blocks\n"
220 " 'if=FILE' read from FILE\n"
221 " 'of=FILE' write to FILE\n"
222 " 'skip=N' skip N bs-sized blocks at the start of input\n";
224 printf("%s\nSupported formats:", help_msg
);
225 bdrv_iterate_format(format_print
, NULL
, false);
226 printf("\n\n" QEMU_HELP_BOTTOM
"\n");
231 * Is @optarg safe for accumulate_options()?
232 * It is when multiple of them can be joined together separated by ','.
233 * To make that work, @optarg must not start with ',' (or else a
234 * separating ',' preceding it gets escaped), and it must not end with
235 * an odd number of ',' (or else a separating ',' following it gets
236 * escaped), or be empty (or else a separating ',' preceding it can
237 * escape a separating ',' following it).
240 static bool is_valid_option_list(const char *optarg
)
242 size_t len
= strlen(optarg
);
245 if (!optarg
[0] || optarg
[0] == ',') {
249 for (i
= len
; i
> 0 && optarg
[i
- 1] == ','; i
--) {
258 static int accumulate_options(char **options
, char *optarg
)
262 if (!is_valid_option_list(optarg
)) {
263 error_report("Invalid option list: %s", optarg
);
268 *options
= g_strdup(optarg
);
270 new_options
= g_strdup_printf("%s,%s", *options
, optarg
);
272 *options
= new_options
;
277 static QemuOptsList qemu_source_opts
= {
279 .implied_opt_name
= "file",
280 .head
= QTAILQ_HEAD_INITIALIZER(qemu_source_opts
.head
),
286 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet
, const char *fmt
, ...)
292 ret
= vprintf(fmt
, args
);
299 static int print_block_option_help(const char *filename
, const char *fmt
)
301 BlockDriver
*drv
, *proto_drv
;
302 QemuOptsList
*create_opts
= NULL
;
303 Error
*local_err
= NULL
;
305 /* Find driver and parse its options */
306 drv
= bdrv_find_format(fmt
);
308 error_report("Unknown file format '%s'", fmt
);
312 if (!drv
->create_opts
) {
313 error_report("Format driver '%s' does not support image creation", fmt
);
317 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
319 proto_drv
= bdrv_find_protocol(filename
, true, &local_err
);
321 error_report_err(local_err
);
322 qemu_opts_free(create_opts
);
325 if (!proto_drv
->create_opts
) {
326 error_report("Protocol driver '%s' does not support image creation",
327 proto_drv
->format_name
);
328 qemu_opts_free(create_opts
);
331 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
335 printf("Supported options:\n");
337 printf("Supported %s options:\n", fmt
);
339 qemu_opts_print_help(create_opts
, false);
340 qemu_opts_free(create_opts
);
344 "The protocol level may support further options.\n"
345 "Specify the target filename to include those options.\n");
352 static BlockBackend
*img_open_opts(const char *optstr
,
353 QemuOpts
*opts
, int flags
, bool writethrough
,
354 bool quiet
, bool force_share
)
357 Error
*local_err
= NULL
;
359 options
= qemu_opts_to_qdict(opts
, NULL
);
361 if (qdict_haskey(options
, BDRV_OPT_FORCE_SHARE
)
362 && strcmp(qdict_get_str(options
, BDRV_OPT_FORCE_SHARE
), "on")) {
363 error_report("--force-share/-U conflicts with image options");
364 qobject_unref(options
);
367 qdict_put_str(options
, BDRV_OPT_FORCE_SHARE
, "on");
369 blk
= blk_new_open(NULL
, NULL
, options
, flags
, &local_err
);
371 error_reportf_err(local_err
, "Could not open '%s': ", optstr
);
374 blk_set_enable_write_cache(blk
, !writethrough
);
379 static BlockBackend
*img_open_file(const char *filename
,
381 const char *fmt
, int flags
,
382 bool writethrough
, bool quiet
,
386 Error
*local_err
= NULL
;
389 options
= qdict_new();
392 qdict_put_str(options
, "driver", fmt
);
396 qdict_put_bool(options
, BDRV_OPT_FORCE_SHARE
, true);
398 blk
= blk_new_open(filename
, NULL
, options
, flags
, &local_err
);
400 error_reportf_err(local_err
, "Could not open '%s': ", filename
);
403 blk_set_enable_write_cache(blk
, !writethrough
);
409 static int img_add_key_secrets(void *opaque
,
410 const char *name
, const char *value
,
413 QDict
*options
= opaque
;
415 if (g_str_has_suffix(name
, "key-secret")) {
416 qdict_put_str(options
, name
, value
);
423 static BlockBackend
*img_open(bool image_opts
,
424 const char *filename
,
425 const char *fmt
, int flags
, bool writethrough
,
426 bool quiet
, bool force_share
)
432 error_report("--image-opts and --format are mutually exclusive");
435 opts
= qemu_opts_parse_noisily(qemu_find_opts("source"),
440 blk
= img_open_opts(filename
, opts
, flags
, writethrough
, quiet
,
443 blk
= img_open_file(filename
, NULL
, fmt
, flags
, writethrough
, quiet
,
450 static int add_old_style_options(const char *fmt
, QemuOpts
*opts
,
451 const char *base_filename
,
452 const char *base_fmt
)
455 if (!qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
,
457 error_report("Backing file not supported for file format '%s'",
463 if (!qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, NULL
)) {
464 error_report("Backing file format not supported for file "
472 static int64_t cvtnum_full(const char *name
, const char *value
, int64_t min
,
478 err
= qemu_strtosz(value
, NULL
, &res
);
479 if (err
< 0 && err
!= -ERANGE
) {
480 error_report("Invalid %s specified. You may use "
481 "k, M, G, T, P or E suffixes for", name
);
482 error_report("kilobytes, megabytes, gigabytes, terabytes, "
483 "petabytes and exabytes.");
486 if (err
== -ERANGE
|| res
> max
|| res
< min
) {
487 error_report("Invalid %s specified. Must be between %" PRId64
488 " and %" PRId64
".", name
, min
, max
);
494 static int64_t cvtnum(const char *name
, const char *value
)
496 return cvtnum_full(name
, value
, 0, INT64_MAX
);
499 static int img_create(int argc
, char **argv
)
502 uint64_t img_size
= -1;
503 const char *fmt
= "raw";
504 const char *base_fmt
= NULL
;
505 const char *filename
;
506 const char *base_filename
= NULL
;
507 char *options
= NULL
;
508 Error
*local_err
= NULL
;
513 static const struct option long_options
[] = {
514 {"help", no_argument
, 0, 'h'},
515 {"object", required_argument
, 0, OPTION_OBJECT
},
518 c
= getopt_long(argc
, argv
, ":F:b:f:ho:qu",
525 missing_argument(argv
[optind
- 1]);
528 unrecognized_option(argv
[optind
- 1]);
537 base_filename
= optarg
;
543 if (accumulate_options(&options
, optarg
) < 0) {
551 flags
|= BDRV_O_NO_BACKING
;
554 user_creatable_process_cmdline(optarg
);
559 /* Get the filename */
560 filename
= (optind
< argc
) ? argv
[optind
] : NULL
;
561 if (options
&& has_help_option(options
)) {
563 return print_block_option_help(filename
, fmt
);
566 if (optind
>= argc
) {
567 error_exit("Expecting image file name");
571 /* Get image size, if specified */
575 sval
= cvtnum("image size", argv
[optind
++]);
579 img_size
= (uint64_t)sval
;
581 if (optind
!= argc
) {
582 error_exit("Unexpected argument: %s", argv
[optind
]);
585 bdrv_img_create(filename
, fmt
, base_filename
, base_fmt
,
586 options
, img_size
, flags
, quiet
, &local_err
);
588 error_reportf_err(local_err
, "%s: ", filename
);
600 static void dump_json_image_check(ImageCheck
*check
, bool quiet
)
604 Visitor
*v
= qobject_output_visitor_new(&obj
);
606 visit_type_ImageCheck(v
, NULL
, &check
, &error_abort
);
607 visit_complete(v
, &obj
);
608 str
= qobject_to_json_pretty(obj
, true);
610 qprintf(quiet
, "%s\n", str
->str
);
613 g_string_free(str
, true);
616 static void dump_human_image_check(ImageCheck
*check
, bool quiet
)
618 if (!(check
->corruptions
|| check
->leaks
|| check
->check_errors
)) {
619 qprintf(quiet
, "No errors were found on the image.\n");
621 if (check
->corruptions
) {
622 qprintf(quiet
, "\n%" PRId64
" errors were found on the image.\n"
623 "Data may be corrupted, or further writes to the image "
630 "\n%" PRId64
" leaked clusters were found on the image.\n"
631 "This means waste of disk space, but no harm to data.\n",
635 if (check
->check_errors
) {
638 " internal errors have occurred during the check.\n",
639 check
->check_errors
);
643 if (check
->total_clusters
!= 0 && check
->allocated_clusters
!= 0) {
644 qprintf(quiet
, "%" PRId64
"/%" PRId64
" = %0.2f%% allocated, "
645 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
646 check
->allocated_clusters
, check
->total_clusters
,
647 check
->allocated_clusters
* 100.0 / check
->total_clusters
,
648 check
->fragmented_clusters
* 100.0 / check
->allocated_clusters
,
649 check
->compressed_clusters
* 100.0 /
650 check
->allocated_clusters
);
653 if (check
->image_end_offset
) {
655 "Image end offset: %" PRId64
"\n", check
->image_end_offset
);
659 static int collect_image_check(BlockDriverState
*bs
,
661 const char *filename
,
666 BdrvCheckResult result
;
668 ret
= bdrv_check(bs
, &result
, fix
);
673 check
->filename
= g_strdup(filename
);
674 check
->format
= g_strdup(bdrv_get_format_name(bs
));
675 check
->check_errors
= result
.check_errors
;
676 check
->corruptions
= result
.corruptions
;
677 check
->has_corruptions
= result
.corruptions
!= 0;
678 check
->leaks
= result
.leaks
;
679 check
->has_leaks
= result
.leaks
!= 0;
680 check
->corruptions_fixed
= result
.corruptions_fixed
;
681 check
->has_corruptions_fixed
= result
.corruptions_fixed
!= 0;
682 check
->leaks_fixed
= result
.leaks_fixed
;
683 check
->has_leaks_fixed
= result
.leaks_fixed
!= 0;
684 check
->image_end_offset
= result
.image_end_offset
;
685 check
->has_image_end_offset
= result
.image_end_offset
!= 0;
686 check
->total_clusters
= result
.bfi
.total_clusters
;
687 check
->has_total_clusters
= result
.bfi
.total_clusters
!= 0;
688 check
->allocated_clusters
= result
.bfi
.allocated_clusters
;
689 check
->has_allocated_clusters
= result
.bfi
.allocated_clusters
!= 0;
690 check
->fragmented_clusters
= result
.bfi
.fragmented_clusters
;
691 check
->has_fragmented_clusters
= result
.bfi
.fragmented_clusters
!= 0;
692 check
->compressed_clusters
= result
.bfi
.compressed_clusters
;
693 check
->has_compressed_clusters
= result
.bfi
.compressed_clusters
!= 0;
699 * Checks an image for consistency. Exit codes:
701 * 0 - Check completed, image is good
702 * 1 - Check not completed because of internal errors
703 * 2 - Check completed, image is corrupted
704 * 3 - Check completed, image has leaked clusters, but is good otherwise
705 * 63 - Checks are not supported by the image format
707 static int img_check(int argc
, char **argv
)
710 OutputFormat output_format
= OFORMAT_HUMAN
;
711 const char *filename
, *fmt
, *output
, *cache
;
713 BlockDriverState
*bs
;
715 int flags
= BDRV_O_CHECK
;
719 bool image_opts
= false;
720 bool force_share
= false;
724 cache
= BDRV_DEFAULT_CACHE
;
727 int option_index
= 0;
728 static const struct option long_options
[] = {
729 {"help", no_argument
, 0, 'h'},
730 {"format", required_argument
, 0, 'f'},
731 {"repair", required_argument
, 0, 'r'},
732 {"output", required_argument
, 0, OPTION_OUTPUT
},
733 {"object", required_argument
, 0, OPTION_OBJECT
},
734 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
735 {"force-share", no_argument
, 0, 'U'},
738 c
= getopt_long(argc
, argv
, ":hf:r:T:qU",
739 long_options
, &option_index
);
745 missing_argument(argv
[optind
- 1]);
748 unrecognized_option(argv
[optind
- 1]);
757 flags
|= BDRV_O_RDWR
;
759 if (!strcmp(optarg
, "leaks")) {
760 fix
= BDRV_FIX_LEAKS
;
761 } else if (!strcmp(optarg
, "all")) {
762 fix
= BDRV_FIX_LEAKS
| BDRV_FIX_ERRORS
;
764 error_exit("Unknown option value for -r "
765 "(expecting 'leaks' or 'all'): %s", optarg
);
781 user_creatable_process_cmdline(optarg
);
783 case OPTION_IMAGE_OPTS
:
788 if (optind
!= argc
- 1) {
789 error_exit("Expecting one image file name");
791 filename
= argv
[optind
++];
793 if (output
&& !strcmp(output
, "json")) {
794 output_format
= OFORMAT_JSON
;
795 } else if (output
&& !strcmp(output
, "human")) {
796 output_format
= OFORMAT_HUMAN
;
798 error_report("--output must be used with human or json as argument.");
802 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
804 error_report("Invalid source cache option: %s", cache
);
808 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
815 check
= g_new0(ImageCheck
, 1);
816 ret
= collect_image_check(bs
, check
, filename
, fmt
, fix
);
818 if (ret
== -ENOTSUP
) {
819 error_report("This image format does not support checks");
824 if (check
->corruptions_fixed
|| check
->leaks_fixed
) {
825 int corruptions_fixed
, leaks_fixed
;
826 bool has_leaks_fixed
, has_corruptions_fixed
;
828 leaks_fixed
= check
->leaks_fixed
;
829 has_leaks_fixed
= check
->has_leaks_fixed
;
830 corruptions_fixed
= check
->corruptions_fixed
;
831 has_corruptions_fixed
= check
->has_corruptions_fixed
;
833 if (output_format
== OFORMAT_HUMAN
) {
835 "The following inconsistencies were found and repaired:\n\n"
836 " %" PRId64
" leaked clusters\n"
837 " %" PRId64
" corruptions\n\n"
838 "Double checking the fixed image now...\n",
840 check
->corruptions_fixed
);
843 qapi_free_ImageCheck(check
);
844 check
= g_new0(ImageCheck
, 1);
845 ret
= collect_image_check(bs
, check
, filename
, fmt
, 0);
847 check
->leaks_fixed
= leaks_fixed
;
848 check
->has_leaks_fixed
= has_leaks_fixed
;
849 check
->corruptions_fixed
= corruptions_fixed
;
850 check
->has_corruptions_fixed
= has_corruptions_fixed
;
854 switch (output_format
) {
856 dump_human_image_check(check
, quiet
);
859 dump_json_image_check(check
, quiet
);
864 if (ret
|| check
->check_errors
) {
866 error_report("Check failed: %s", strerror(-ret
));
868 error_report("Check failed");
874 if (check
->corruptions
) {
876 } else if (check
->leaks
) {
883 qapi_free_ImageCheck(check
);
888 typedef struct CommonBlockJobCBInfo
{
889 BlockDriverState
*bs
;
891 } CommonBlockJobCBInfo
;
893 static void common_block_job_cb(void *opaque
, int ret
)
895 CommonBlockJobCBInfo
*cbi
= opaque
;
898 error_setg_errno(cbi
->errp
, -ret
, "Block job failed");
902 static void run_block_job(BlockJob
*job
, Error
**errp
)
904 uint64_t progress_current
, progress_total
;
905 AioContext
*aio_context
= blk_get_aio_context(job
->blk
);
908 aio_context_acquire(aio_context
);
911 float progress
= 0.0f
;
912 aio_poll(aio_context
, true);
914 progress_get_snapshot(&job
->job
.progress
, &progress_current
,
916 if (progress_total
) {
917 progress
= (float)progress_current
/ progress_total
* 100.f
;
919 qemu_progress_print(progress
, 0);
920 } while (!job_is_ready(&job
->job
) && !job_is_completed(&job
->job
));
922 if (!job_is_completed(&job
->job
)) {
923 ret
= job_complete_sync(&job
->job
, errp
);
927 job_unref(&job
->job
);
928 aio_context_release(aio_context
);
930 /* publish completion progress only when success */
932 qemu_progress_print(100.f
, 0);
936 static int img_commit(int argc
, char **argv
)
939 const char *filename
, *fmt
, *cache
, *base
;
941 BlockDriverState
*bs
, *base_bs
;
943 bool progress
= false, quiet
= false, drop
= false;
945 Error
*local_err
= NULL
;
946 CommonBlockJobCBInfo cbi
;
947 bool image_opts
= false;
948 AioContext
*aio_context
;
949 int64_t rate_limit
= 0;
952 cache
= BDRV_DEFAULT_CACHE
;
955 static const struct option long_options
[] = {
956 {"help", no_argument
, 0, 'h'},
957 {"object", required_argument
, 0, OPTION_OBJECT
},
958 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
961 c
= getopt_long(argc
, argv
, ":f:ht:b:dpqr:",
968 missing_argument(argv
[optind
- 1]);
971 unrecognized_option(argv
[optind
- 1]);
997 rate_limit
= cvtnum("rate limit", optarg
);
998 if (rate_limit
< 0) {
1003 user_creatable_process_cmdline(optarg
);
1005 case OPTION_IMAGE_OPTS
:
1011 /* Progress is not shown in Quiet mode */
1016 if (optind
!= argc
- 1) {
1017 error_exit("Expecting one image file name");
1019 filename
= argv
[optind
++];
1021 flags
= BDRV_O_RDWR
| BDRV_O_UNMAP
;
1022 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
1024 error_report("Invalid cache option: %s", cache
);
1028 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
1035 qemu_progress_init(progress
, 1.f
);
1036 qemu_progress_print(0.f
, 100);
1039 base_bs
= bdrv_find_backing_image(bs
, base
);
1041 error_setg(&local_err
,
1042 "Did not find '%s' in the backing chain of '%s'",
1047 /* This is different from QMP, which by default uses the deepest file in
1048 * the backing chain (i.e., the very base); however, the traditional
1049 * behavior of qemu-img commit is using the immediate backing file. */
1050 base_bs
= bdrv_backing_chain_next(bs
);
1052 error_setg(&local_err
, "Image does not have a backing file");
1057 cbi
= (CommonBlockJobCBInfo
){
1062 aio_context
= bdrv_get_aio_context(bs
);
1063 aio_context_acquire(aio_context
);
1064 commit_active_start("commit", bs
, base_bs
, JOB_DEFAULT
, rate_limit
,
1065 BLOCKDEV_ON_ERROR_REPORT
, NULL
, common_block_job_cb
,
1066 &cbi
, false, &local_err
);
1067 aio_context_release(aio_context
);
1072 /* When the block job completes, the BlockBackend reference will point to
1073 * the old backing file. In order to avoid that the top image is already
1074 * deleted, so we can still empty it afterwards, increment the reference
1075 * counter here preemptively. */
1080 job
= block_job_get("commit");
1082 run_block_job(job
, &local_err
);
1088 BlockBackend
*old_backing_blk
;
1090 old_backing_blk
= blk_new_with_bs(bs
, BLK_PERM_WRITE
, BLK_PERM_ALL
,
1092 if (!old_backing_blk
) {
1095 ret
= blk_make_empty(old_backing_blk
, &local_err
);
1096 blk_unref(old_backing_blk
);
1097 if (ret
== -ENOTSUP
) {
1098 error_free(local_err
);
1100 } else if (ret
< 0) {
1111 qemu_progress_end();
1116 error_report_err(local_err
);
1120 qprintf(quiet
, "Image committed.\n");
1125 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1126 * of the first sector boundary within buf where the sector contains a
1127 * non-zero byte. This function is robust to a buffer that is not
1130 static int64_t find_nonzero(const uint8_t *buf
, int64_t n
)
1133 int64_t end
= QEMU_ALIGN_DOWN(n
, BDRV_SECTOR_SIZE
);
1135 for (i
= 0; i
< end
; i
+= BDRV_SECTOR_SIZE
) {
1136 if (!buffer_is_zero(buf
+ i
, BDRV_SECTOR_SIZE
)) {
1140 if (i
< n
&& !buffer_is_zero(buf
+ i
, n
- end
)) {
1147 * Returns true iff the first sector pointed to by 'buf' contains at least
1150 * 'pnum' is set to the number of sectors (including and immediately following
1151 * the first one) that are known to be in the same allocated/unallocated state.
1152 * The function will try to align the end offset to alignment boundaries so
1153 * that the request will at least end aligned and consecutive requests will
1154 * also start at an aligned offset.
1156 static int is_allocated_sectors(const uint8_t *buf
, int n
, int *pnum
,
1157 int64_t sector_num
, int alignment
)
1166 is_zero
= buffer_is_zero(buf
, BDRV_SECTOR_SIZE
);
1167 for(i
= 1; i
< n
; i
++) {
1168 buf
+= BDRV_SECTOR_SIZE
;
1169 if (is_zero
!= buffer_is_zero(buf
, BDRV_SECTOR_SIZE
)) {
1174 tail
= (sector_num
+ i
) & (alignment
- 1);
1176 if (is_zero
&& i
<= tail
) {
1177 /* treat unallocated areas which only consist
1178 * of a small tail as allocated. */
1182 /* align up end offset of allocated areas. */
1183 i
+= alignment
- tail
;
1186 /* align down end offset of zero areas. */
1195 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1196 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1197 * breaking up write requests for only small sparse areas.
1199 static int is_allocated_sectors_min(const uint8_t *buf
, int n
, int *pnum
,
1200 int min
, int64_t sector_num
, int alignment
)
1203 int num_checked
, num_used
;
1209 ret
= is_allocated_sectors(buf
, n
, pnum
, sector_num
, alignment
);
1215 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
1217 sector_num
+= *pnum
;
1218 num_checked
= num_used
;
1221 ret
= is_allocated_sectors(buf
, n
, pnum
, sector_num
, alignment
);
1223 buf
+= BDRV_SECTOR_SIZE
* *pnum
;
1225 sector_num
+= *pnum
;
1226 num_checked
+= *pnum
;
1228 num_used
= num_checked
;
1229 } else if (*pnum
>= min
) {
1239 * Compares two buffers sector by sector. Returns 0 if the first
1240 * sector of each buffer matches, non-zero otherwise.
1242 * pnum is set to the sector-aligned size of the buffer prefix that
1243 * has the same matching status as the first sector.
1245 static int compare_buffers(const uint8_t *buf1
, const uint8_t *buf2
,
1246 int64_t bytes
, int64_t *pnum
)
1249 int64_t i
= MIN(bytes
, BDRV_SECTOR_SIZE
);
1253 res
= !!memcmp(buf1
, buf2
, i
);
1255 int64_t len
= MIN(bytes
- i
, BDRV_SECTOR_SIZE
);
1257 if (!!memcmp(buf1
+ i
, buf2
+ i
, len
) != res
) {
1267 #define IO_BUF_SIZE (2 * MiB)
1270 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1272 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1273 * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1274 * failure), and 4 on error (the exit status for read errors), after emitting
1277 * @param blk: BlockBackend for the image
1278 * @param offset: Starting offset to check
1279 * @param bytes: Number of bytes to check
1280 * @param filename: Name of disk file we are checking (logging purpose)
1281 * @param buffer: Allocated buffer for storing read data
1282 * @param quiet: Flag for quiet mode
1284 static int check_empty_sectors(BlockBackend
*blk
, int64_t offset
,
1285 int64_t bytes
, const char *filename
,
1286 uint8_t *buffer
, bool quiet
)
1291 ret
= blk_pread(blk
, offset
, buffer
, bytes
);
1293 error_report("Error while reading offset %" PRId64
" of %s: %s",
1294 offset
, filename
, strerror(-ret
));
1297 idx
= find_nonzero(buffer
, bytes
);
1299 qprintf(quiet
, "Content mismatch at offset %" PRId64
"!\n",
1308 * Compares two images. Exit codes:
1310 * 0 - Images are identical or the requested help was printed
1312 * >1 - Error occurred
1314 static int img_compare(int argc
, char **argv
)
1316 const char *fmt1
= NULL
, *fmt2
= NULL
, *cache
, *filename1
, *filename2
;
1317 BlockBackend
*blk1
, *blk2
;
1318 BlockDriverState
*bs1
, *bs2
;
1319 int64_t total_size1
, total_size2
;
1320 uint8_t *buf1
= NULL
, *buf2
= NULL
;
1321 int64_t pnum1
, pnum2
;
1322 int allocated1
, allocated2
;
1323 int ret
= 0; /* return value - 0 Ident, 1 Different, >1 Error */
1324 bool progress
= false, quiet
= false, strict
= false;
1331 uint64_t progress_base
;
1332 bool image_opts
= false;
1333 bool force_share
= false;
1335 cache
= BDRV_DEFAULT_CACHE
;
1337 static const struct option long_options
[] = {
1338 {"help", no_argument
, 0, 'h'},
1339 {"object", required_argument
, 0, OPTION_OBJECT
},
1340 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
1341 {"force-share", no_argument
, 0, 'U'},
1344 c
= getopt_long(argc
, argv
, ":hf:F:T:pqsU",
1345 long_options
, NULL
);
1351 missing_argument(argv
[optind
- 1]);
1354 unrecognized_option(argv
[optind
- 1]);
1382 Error
*local_err
= NULL
;
1384 if (!user_creatable_add_from_str(optarg
, &local_err
)) {
1386 error_report_err(local_err
);
1389 /* Help was printed */
1395 case OPTION_IMAGE_OPTS
:
1401 /* Progress is not shown in Quiet mode */
1407 if (optind
!= argc
- 2) {
1408 error_exit("Expecting two image file names");
1410 filename1
= argv
[optind
++];
1411 filename2
= argv
[optind
++];
1413 /* Initialize before goto out */
1414 qemu_progress_init(progress
, 2.0);
1417 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
1419 error_report("Invalid source cache option: %s", cache
);
1424 blk1
= img_open(image_opts
, filename1
, fmt1
, flags
, writethrough
, quiet
,
1431 blk2
= img_open(image_opts
, filename2
, fmt2
, flags
, writethrough
, quiet
,
1440 buf1
= blk_blockalign(blk1
, IO_BUF_SIZE
);
1441 buf2
= blk_blockalign(blk2
, IO_BUF_SIZE
);
1442 total_size1
= blk_getlength(blk1
);
1443 if (total_size1
< 0) {
1444 error_report("Can't get size of %s: %s",
1445 filename1
, strerror(-total_size1
));
1449 total_size2
= blk_getlength(blk2
);
1450 if (total_size2
< 0) {
1451 error_report("Can't get size of %s: %s",
1452 filename2
, strerror(-total_size2
));
1456 total_size
= MIN(total_size1
, total_size2
);
1457 progress_base
= MAX(total_size1
, total_size2
);
1459 qemu_progress_print(0, 100);
1461 if (strict
&& total_size1
!= total_size2
) {
1463 qprintf(quiet
, "Strict mode: Image size mismatch!\n");
1467 while (offset
< total_size
) {
1468 int status1
, status2
;
1470 status1
= bdrv_block_status_above(bs1
, NULL
, offset
,
1471 total_size1
- offset
, &pnum1
, NULL
,
1475 error_report("Sector allocation test failed for %s", filename1
);
1478 allocated1
= status1
& BDRV_BLOCK_ALLOCATED
;
1480 status2
= bdrv_block_status_above(bs2
, NULL
, offset
,
1481 total_size2
- offset
, &pnum2
, NULL
,
1485 error_report("Sector allocation test failed for %s", filename2
);
1488 allocated2
= status2
& BDRV_BLOCK_ALLOCATED
;
1490 assert(pnum1
&& pnum2
);
1491 chunk
= MIN(pnum1
, pnum2
);
1494 if (status1
!= status2
) {
1496 qprintf(quiet
, "Strict mode: Offset %" PRId64
1497 " block status mismatch!\n", offset
);
1501 if ((status1
& BDRV_BLOCK_ZERO
) && (status2
& BDRV_BLOCK_ZERO
)) {
1503 } else if (allocated1
== allocated2
) {
1507 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1508 ret
= blk_pread(blk1
, offset
, buf1
, chunk
);
1510 error_report("Error while reading offset %" PRId64
1512 offset
, filename1
, strerror(-ret
));
1516 ret
= blk_pread(blk2
, offset
, buf2
, chunk
);
1518 error_report("Error while reading offset %" PRId64
1520 offset
, filename2
, strerror(-ret
));
1524 ret
= compare_buffers(buf1
, buf2
, chunk
, &pnum
);
1525 if (ret
|| pnum
!= chunk
) {
1526 qprintf(quiet
, "Content mismatch at offset %" PRId64
"!\n",
1527 offset
+ (ret
? 0 : pnum
));
1533 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1535 ret
= check_empty_sectors(blk1
, offset
, chunk
,
1536 filename1
, buf1
, quiet
);
1538 ret
= check_empty_sectors(blk2
, offset
, chunk
,
1539 filename2
, buf1
, quiet
);
1546 qemu_progress_print(((float) chunk
/ progress_base
) * 100, 100);
1549 if (total_size1
!= total_size2
) {
1550 BlockBackend
*blk_over
;
1551 const char *filename_over
;
1553 qprintf(quiet
, "Warning: Image size mismatch!\n");
1554 if (total_size1
> total_size2
) {
1556 filename_over
= filename1
;
1559 filename_over
= filename2
;
1562 while (offset
< progress_base
) {
1563 ret
= bdrv_block_status_above(blk_bs(blk_over
), NULL
, offset
,
1564 progress_base
- offset
, &chunk
,
1568 error_report("Sector allocation test failed for %s",
1573 if (ret
& BDRV_BLOCK_ALLOCATED
&& !(ret
& BDRV_BLOCK_ZERO
)) {
1574 chunk
= MIN(chunk
, IO_BUF_SIZE
);
1575 ret
= check_empty_sectors(blk_over
, offset
, chunk
,
1576 filename_over
, buf1
, quiet
);
1582 qemu_progress_print(((float) chunk
/ progress_base
) * 100, 100);
1586 qprintf(quiet
, "Images are identical.\n");
1596 qemu_progress_end();
1600 /* Convenience wrapper around qmp_block_dirty_bitmap_merge */
1601 static void do_dirty_bitmap_merge(const char *dst_node
, const char *dst_name
,
1602 const char *src_node
, const char *src_name
,
1605 BlockDirtyBitmapMergeSource
*merge_src
;
1606 BlockDirtyBitmapMergeSourceList
*list
= NULL
;
1608 merge_src
= g_new0(BlockDirtyBitmapMergeSource
, 1);
1609 merge_src
->type
= QTYPE_QDICT
;
1610 merge_src
->u
.external
.node
= g_strdup(src_node
);
1611 merge_src
->u
.external
.name
= g_strdup(src_name
);
1612 QAPI_LIST_PREPEND(list
, merge_src
);
1613 qmp_block_dirty_bitmap_merge(dst_node
, dst_name
, list
, errp
);
1614 qapi_free_BlockDirtyBitmapMergeSourceList(list
);
1617 enum ImgConvertBlockStatus
{
1623 #define MAX_COROUTINES 16
1624 #define CONVERT_THROTTLE_GROUP "img_convert"
1626 typedef struct ImgConvertState
{
1628 int64_t *src_sectors
;
1631 int64_t total_sectors
;
1632 int64_t allocated_sectors
;
1633 int64_t allocated_done
;
1636 enum ImgConvertBlockStatus status
;
1637 int64_t sector_next_status
;
1638 BlockBackend
*target
;
1642 bool target_has_backing
;
1643 int64_t target_backing_sectors
; /* negative if unknown */
1650 size_t cluster_sectors
;
1652 long num_coroutines
;
1653 int running_coroutines
;
1654 Coroutine
*co
[MAX_COROUTINES
];
1655 int64_t wait_sector_num
[MAX_COROUTINES
];
1660 static void convert_select_part(ImgConvertState
*s
, int64_t sector_num
,
1661 int *src_cur
, int64_t *src_cur_offset
)
1664 *src_cur_offset
= 0;
1665 while (sector_num
- *src_cur_offset
>= s
->src_sectors
[*src_cur
]) {
1666 *src_cur_offset
+= s
->src_sectors
[*src_cur
];
1668 assert(*src_cur
< s
->src_num
);
1672 static int convert_iteration_sectors(ImgConvertState
*s
, int64_t sector_num
)
1674 int64_t src_cur_offset
;
1675 int ret
, n
, src_cur
;
1676 bool post_backing_zero
= false;
1678 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1680 assert(s
->total_sectors
> sector_num
);
1681 n
= MIN(s
->total_sectors
- sector_num
, BDRV_REQUEST_MAX_SECTORS
);
1683 if (s
->target_backing_sectors
>= 0) {
1684 if (sector_num
>= s
->target_backing_sectors
) {
1685 post_backing_zero
= true;
1686 } else if (sector_num
+ n
> s
->target_backing_sectors
) {
1687 /* Split requests around target_backing_sectors (because
1688 * starting from there, zeros are handled differently) */
1689 n
= s
->target_backing_sectors
- sector_num
;
1693 if (s
->sector_next_status
<= sector_num
) {
1694 uint64_t offset
= (sector_num
- src_cur_offset
) * BDRV_SECTOR_SIZE
;
1697 BlockDriverState
*src_bs
= blk_bs(s
->src
[src_cur
]);
1698 BlockDriverState
*base
;
1700 if (s
->target_has_backing
) {
1701 base
= bdrv_cow_bs(bdrv_skip_filters(src_bs
));
1707 count
= n
* BDRV_SECTOR_SIZE
;
1709 ret
= bdrv_block_status_above(src_bs
, base
, offset
, count
, &count
,
1716 warn_report("error while reading block status at "
1717 "offset %" PRIu64
": %s", offset
,
1720 /* Just try to read the data, then */
1721 ret
= BDRV_BLOCK_DATA
;
1722 count
= BDRV_SECTOR_SIZE
;
1724 /* Retry on a shorter range */
1725 n
= DIV_ROUND_UP(n
, 4);
1728 error_report("error while reading block status at offset "
1729 "%" PRIu64
": %s", offset
, strerror(-ret
));
1735 n
= DIV_ROUND_UP(count
, BDRV_SECTOR_SIZE
);
1738 * Avoid that s->sector_next_status becomes unaligned to the source
1739 * request alignment and/or cluster size to avoid unnecessary read
1742 tail
= (sector_num
- src_cur_offset
+ n
) % s
->src_alignment
[src_cur
];
1747 if (ret
& BDRV_BLOCK_ZERO
) {
1748 s
->status
= post_backing_zero
? BLK_BACKING_FILE
: BLK_ZERO
;
1749 } else if (ret
& BDRV_BLOCK_DATA
) {
1750 s
->status
= BLK_DATA
;
1752 s
->status
= s
->target_has_backing
? BLK_BACKING_FILE
: BLK_DATA
;
1755 s
->sector_next_status
= sector_num
+ n
;
1758 n
= MIN(n
, s
->sector_next_status
- sector_num
);
1759 if (s
->status
== BLK_DATA
) {
1760 n
= MIN(n
, s
->buf_sectors
);
1763 /* We need to write complete clusters for compressed images, so if an
1764 * unallocated area is shorter than that, we must consider the whole
1765 * cluster allocated. */
1766 if (s
->compressed
) {
1767 if (n
< s
->cluster_sectors
) {
1768 n
= MIN(s
->cluster_sectors
, s
->total_sectors
- sector_num
);
1769 s
->status
= BLK_DATA
;
1771 n
= QEMU_ALIGN_DOWN(n
, s
->cluster_sectors
);
1778 static int coroutine_fn
convert_co_read(ImgConvertState
*s
, int64_t sector_num
,
1779 int nb_sectors
, uint8_t *buf
)
1781 uint64_t single_read_until
= 0;
1784 assert(nb_sectors
<= s
->buf_sectors
);
1785 while (nb_sectors
> 0) {
1788 int64_t bs_sectors
, src_cur_offset
;
1791 /* In the case of compression with multiple source files, we can get a
1792 * nb_sectors that spreads into the next part. So we must be able to
1793 * read across multiple BDSes for one convert_read() call. */
1794 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1795 blk
= s
->src
[src_cur
];
1796 bs_sectors
= s
->src_sectors
[src_cur
];
1798 offset
= (sector_num
- src_cur_offset
) << BDRV_SECTOR_BITS
;
1800 n
= MIN(nb_sectors
, bs_sectors
- (sector_num
- src_cur_offset
));
1801 if (single_read_until
> offset
) {
1805 ret
= blk_co_pread(blk
, offset
, n
<< BDRV_SECTOR_BITS
, buf
, 0);
1809 single_read_until
= offset
+ (n
<< BDRV_SECTOR_BITS
);
1813 warn_report("error while reading offset %" PRIu64
1814 ": %s", offset
, strerror(-ret
));
1816 memset(buf
, 0, BDRV_SECTOR_SIZE
);
1825 buf
+= n
* BDRV_SECTOR_SIZE
;
1832 static int coroutine_fn
convert_co_write(ImgConvertState
*s
, int64_t sector_num
,
1833 int nb_sectors
, uint8_t *buf
,
1834 enum ImgConvertBlockStatus status
)
1838 while (nb_sectors
> 0) {
1840 BdrvRequestFlags flags
= s
->compressed
? BDRV_REQ_WRITE_COMPRESSED
: 0;
1843 case BLK_BACKING_FILE
:
1844 /* If we have a backing file, leave clusters unallocated that are
1845 * unallocated in the source image, so that the backing file is
1846 * visible at the respective offset. */
1847 assert(s
->target_has_backing
);
1851 /* If we're told to keep the target fully allocated (-S 0) or there
1852 * is real non-zero data, we must write it. Otherwise we can treat
1853 * it as zero sectors.
1854 * Compressed clusters need to be written as a whole, so in that
1855 * case we can only save the write if the buffer is completely
1857 if (!s
->min_sparse
||
1859 is_allocated_sectors_min(buf
, n
, &n
, s
->min_sparse
,
1860 sector_num
, s
->alignment
)) ||
1862 !buffer_is_zero(buf
, n
* BDRV_SECTOR_SIZE
)))
1864 ret
= blk_co_pwrite(s
->target
, sector_num
<< BDRV_SECTOR_BITS
,
1865 n
<< BDRV_SECTOR_BITS
, buf
, flags
);
1874 if (s
->has_zero_init
) {
1875 assert(!s
->target_has_backing
);
1878 ret
= blk_co_pwrite_zeroes(s
->target
,
1879 sector_num
<< BDRV_SECTOR_BITS
,
1880 n
<< BDRV_SECTOR_BITS
,
1881 BDRV_REQ_MAY_UNMAP
);
1890 buf
+= n
* BDRV_SECTOR_SIZE
;
1896 static int coroutine_fn
convert_co_copy_range(ImgConvertState
*s
, int64_t sector_num
,
1901 while (nb_sectors
> 0) {
1904 int64_t bs_sectors
, src_cur_offset
;
1907 convert_select_part(s
, sector_num
, &src_cur
, &src_cur_offset
);
1908 offset
= (sector_num
- src_cur_offset
) << BDRV_SECTOR_BITS
;
1909 blk
= s
->src
[src_cur
];
1910 bs_sectors
= s
->src_sectors
[src_cur
];
1912 n
= MIN(nb_sectors
, bs_sectors
- (sector_num
- src_cur_offset
));
1914 ret
= blk_co_copy_range(blk
, offset
, s
->target
,
1915 sector_num
<< BDRV_SECTOR_BITS
,
1916 n
<< BDRV_SECTOR_BITS
, 0, 0);
1927 static void coroutine_fn
convert_co_do_copy(void *opaque
)
1929 ImgConvertState
*s
= opaque
;
1930 uint8_t *buf
= NULL
;
1934 for (i
= 0; i
< s
->num_coroutines
; i
++) {
1935 if (s
->co
[i
] == qemu_coroutine_self()) {
1942 s
->running_coroutines
++;
1943 buf
= blk_blockalign(s
->target
, s
->buf_sectors
* BDRV_SECTOR_SIZE
);
1948 enum ImgConvertBlockStatus status
;
1951 qemu_co_mutex_lock(&s
->lock
);
1952 if (s
->ret
!= -EINPROGRESS
|| s
->sector_num
>= s
->total_sectors
) {
1953 qemu_co_mutex_unlock(&s
->lock
);
1956 n
= convert_iteration_sectors(s
, s
->sector_num
);
1958 qemu_co_mutex_unlock(&s
->lock
);
1962 /* save current sector and allocation status to local variables */
1963 sector_num
= s
->sector_num
;
1965 if (!s
->min_sparse
&& s
->status
== BLK_ZERO
) {
1966 n
= MIN(n
, s
->buf_sectors
);
1968 /* increment global sector counter so that other coroutines can
1969 * already continue reading beyond this request */
1971 qemu_co_mutex_unlock(&s
->lock
);
1973 if (status
== BLK_DATA
|| (!s
->min_sparse
&& status
== BLK_ZERO
)) {
1974 s
->allocated_done
+= n
;
1975 qemu_progress_print(100.0 * s
->allocated_done
/
1976 s
->allocated_sectors
, 0);
1980 copy_range
= s
->copy_range
&& s
->status
== BLK_DATA
;
1981 if (status
== BLK_DATA
&& !copy_range
) {
1982 ret
= convert_co_read(s
, sector_num
, n
, buf
);
1984 error_report("error while reading at byte %lld: %s",
1985 sector_num
* BDRV_SECTOR_SIZE
, strerror(-ret
));
1988 } else if (!s
->min_sparse
&& status
== BLK_ZERO
) {
1990 memset(buf
, 0x00, n
* BDRV_SECTOR_SIZE
);
1993 if (s
->wr_in_order
) {
1994 /* keep writes in order */
1995 while (s
->wr_offs
!= sector_num
&& s
->ret
== -EINPROGRESS
) {
1996 s
->wait_sector_num
[index
] = sector_num
;
1997 qemu_coroutine_yield();
1999 s
->wait_sector_num
[index
] = -1;
2002 if (s
->ret
== -EINPROGRESS
) {
2004 ret
= convert_co_copy_range(s
, sector_num
, n
);
2006 s
->copy_range
= false;
2010 ret
= convert_co_write(s
, sector_num
, n
, buf
, status
);
2013 error_report("error while writing at byte %lld: %s",
2014 sector_num
* BDRV_SECTOR_SIZE
, strerror(-ret
));
2019 if (s
->wr_in_order
) {
2020 /* reenter the coroutine that might have waited
2021 * for this write to complete */
2022 s
->wr_offs
= sector_num
+ n
;
2023 for (i
= 0; i
< s
->num_coroutines
; i
++) {
2024 if (s
->co
[i
] && s
->wait_sector_num
[i
] == s
->wr_offs
) {
2026 * A -> B -> A cannot occur because A has
2027 * s->wait_sector_num[i] == -1 during A -> B. Therefore
2028 * B will never enter A during this time window.
2030 qemu_coroutine_enter(s
->co
[i
]);
2038 s
->co
[index
] = NULL
;
2039 s
->running_coroutines
--;
2040 if (!s
->running_coroutines
&& s
->ret
== -EINPROGRESS
) {
2041 /* the convert job finished successfully */
2046 static int convert_do_copy(ImgConvertState
*s
)
2049 int64_t sector_num
= 0;
2051 /* Check whether we have zero initialisation or can get it efficiently */
2052 if (!s
->has_zero_init
&& s
->target_is_new
&& s
->min_sparse
&&
2053 !s
->target_has_backing
) {
2054 s
->has_zero_init
= bdrv_has_zero_init(blk_bs(s
->target
));
2057 /* Allocate buffer for copied data. For compressed images, only one cluster
2058 * can be copied at a time. */
2059 if (s
->compressed
) {
2060 if (s
->cluster_sectors
<= 0 || s
->cluster_sectors
> s
->buf_sectors
) {
2061 error_report("invalid cluster size");
2064 s
->buf_sectors
= s
->cluster_sectors
;
2067 while (sector_num
< s
->total_sectors
) {
2068 n
= convert_iteration_sectors(s
, sector_num
);
2072 if (s
->status
== BLK_DATA
|| (!s
->min_sparse
&& s
->status
== BLK_ZERO
))
2074 s
->allocated_sectors
+= n
;
2080 s
->sector_next_status
= 0;
2081 s
->ret
= -EINPROGRESS
;
2083 qemu_co_mutex_init(&s
->lock
);
2084 for (i
= 0; i
< s
->num_coroutines
; i
++) {
2085 s
->co
[i
] = qemu_coroutine_create(convert_co_do_copy
, s
);
2086 s
->wait_sector_num
[i
] = -1;
2087 qemu_coroutine_enter(s
->co
[i
]);
2090 while (s
->running_coroutines
) {
2091 main_loop_wait(false);
2094 if (s
->compressed
&& !s
->ret
) {
2095 /* signal EOF to align */
2096 ret
= blk_pwrite_compressed(s
->target
, 0, NULL
, 0);
2105 /* Check that bitmaps can be copied, or output an error */
2106 static int convert_check_bitmaps(BlockDriverState
*src
, bool skip_broken
)
2108 BdrvDirtyBitmap
*bm
;
2110 if (!bdrv_supports_persistent_dirty_bitmap(src
)) {
2111 error_report("Source lacks bitmap support");
2114 FOR_EACH_DIRTY_BITMAP(src
, bm
) {
2115 if (!bdrv_dirty_bitmap_get_persistence(bm
)) {
2118 if (!skip_broken
&& bdrv_dirty_bitmap_inconsistent(bm
)) {
2119 error_report("Cannot copy inconsistent bitmap '%s'",
2120 bdrv_dirty_bitmap_name(bm
));
2121 error_printf("Try --skip-broken-bitmaps, or "
2122 "use 'qemu-img bitmap --remove' to delete it\n");
2129 static int convert_copy_bitmaps(BlockDriverState
*src
, BlockDriverState
*dst
,
2132 BdrvDirtyBitmap
*bm
;
2135 FOR_EACH_DIRTY_BITMAP(src
, bm
) {
2138 if (!bdrv_dirty_bitmap_get_persistence(bm
)) {
2141 name
= bdrv_dirty_bitmap_name(bm
);
2142 if (skip_broken
&& bdrv_dirty_bitmap_inconsistent(bm
)) {
2143 warn_report("Skipping inconsistent bitmap '%s'", name
);
2146 qmp_block_dirty_bitmap_add(dst
->node_name
, name
,
2147 true, bdrv_dirty_bitmap_granularity(bm
),
2149 true, !bdrv_dirty_bitmap_enabled(bm
),
2152 error_reportf_err(err
, "Failed to create bitmap %s: ", name
);
2156 do_dirty_bitmap_merge(dst
->node_name
, name
, src
->node_name
, name
,
2159 error_reportf_err(err
, "Failed to populate bitmap %s: ", name
);
2160 qmp_block_dirty_bitmap_remove(dst
->node_name
, name
, NULL
);
2168 #define MAX_BUF_SECTORS 32768
2170 static void set_rate_limit(BlockBackend
*blk
, int64_t rate_limit
)
2174 throttle_config_init(&cfg
);
2175 cfg
.buckets
[THROTTLE_BPS_WRITE
].avg
= rate_limit
;
2177 blk_io_limits_enable(blk
, CONVERT_THROTTLE_GROUP
);
2178 blk_set_io_limits(blk
, &cfg
);
2181 static int img_convert(int argc
, char **argv
)
2183 int c
, bs_i
, flags
, src_flags
= BDRV_O_NO_SHARE
;
2184 const char *fmt
= NULL
, *out_fmt
= NULL
, *cache
= "unsafe",
2185 *src_cache
= BDRV_DEFAULT_CACHE
, *out_baseimg
= NULL
,
2186 *out_filename
, *out_baseimg_param
, *snapshot_name
= NULL
;
2187 BlockDriver
*drv
= NULL
, *proto_drv
= NULL
;
2188 BlockDriverInfo bdi
;
2189 BlockDriverState
*out_bs
;
2190 QemuOpts
*opts
= NULL
, *sn_opts
= NULL
;
2191 QemuOptsList
*create_opts
= NULL
;
2192 QDict
*open_opts
= NULL
;
2193 char *options
= NULL
;
2194 Error
*local_err
= NULL
;
2195 bool writethrough
, src_writethrough
, image_opts
= false,
2196 skip_create
= false, progress
= false, tgt_image_opts
= false;
2197 int64_t ret
= -EINVAL
;
2198 bool force_share
= false;
2199 bool explict_min_sparse
= false;
2200 bool bitmaps
= false;
2201 bool skip_broken
= false;
2202 int64_t rate_limit
= 0;
2204 ImgConvertState s
= (ImgConvertState
) {
2205 /* Need at least 4k of zeros for sparse detection */
2207 .copy_range
= false,
2208 .buf_sectors
= IO_BUF_SIZE
/ BDRV_SECTOR_SIZE
,
2209 .wr_in_order
= true,
2210 .num_coroutines
= 8,
2214 static const struct option long_options
[] = {
2215 {"help", no_argument
, 0, 'h'},
2216 {"object", required_argument
, 0, OPTION_OBJECT
},
2217 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
2218 {"force-share", no_argument
, 0, 'U'},
2219 {"target-image-opts", no_argument
, 0, OPTION_TARGET_IMAGE_OPTS
},
2220 {"salvage", no_argument
, 0, OPTION_SALVAGE
},
2221 {"target-is-zero", no_argument
, 0, OPTION_TARGET_IS_ZERO
},
2222 {"bitmaps", no_argument
, 0, OPTION_BITMAPS
},
2223 {"skip-broken-bitmaps", no_argument
, 0, OPTION_SKIP_BROKEN
},
2226 c
= getopt_long(argc
, argv
, ":hf:O:B:Cco:l:S:pt:T:qnm:WUr:",
2227 long_options
, NULL
);
2233 missing_argument(argv
[optind
- 1]);
2236 unrecognized_option(argv
[optind
- 1]);
2248 out_baseimg
= optarg
;
2251 s
.copy_range
= true;
2254 s
.compressed
= true;
2257 if (accumulate_options(&options
, optarg
) < 0) {
2262 if (strstart(optarg
, SNAPSHOT_OPT_BASE
, NULL
)) {
2263 sn_opts
= qemu_opts_parse_noisily(&internal_snapshot_opts
,
2266 error_report("Failed in parsing snapshot param '%s'",
2271 snapshot_name
= optarg
;
2278 sval
= cvtnum("buffer size for sparse output", optarg
);
2281 } else if (!QEMU_IS_ALIGNED(sval
, BDRV_SECTOR_SIZE
) ||
2282 sval
/ BDRV_SECTOR_SIZE
> MAX_BUF_SECTORS
) {
2283 error_report("Invalid buffer size for sparse output specified. "
2284 "Valid sizes are multiples of %llu up to %llu. Select "
2285 "0 to disable sparse detection (fully allocates output).",
2286 BDRV_SECTOR_SIZE
, MAX_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2290 s
.min_sparse
= sval
/ BDRV_SECTOR_SIZE
;
2291 explict_min_sparse
= true;
2310 if (qemu_strtol(optarg
, NULL
, 0, &s
.num_coroutines
) ||
2311 s
.num_coroutines
< 1 || s
.num_coroutines
> MAX_COROUTINES
) {
2312 error_report("Invalid number of coroutines. Allowed number of"
2313 " coroutines is between 1 and %d", MAX_COROUTINES
);
2318 s
.wr_in_order
= false;
2324 rate_limit
= cvtnum("rate limit", optarg
);
2325 if (rate_limit
< 0) {
2330 user_creatable_process_cmdline(optarg
);
2332 case OPTION_IMAGE_OPTS
:
2335 case OPTION_SALVAGE
:
2338 case OPTION_TARGET_IMAGE_OPTS
:
2339 tgt_image_opts
= true;
2341 case OPTION_TARGET_IS_ZERO
:
2343 * The user asserting that the target is blank has the
2344 * same effect as the target driver supporting zero
2347 s
.has_zero_init
= true;
2349 case OPTION_BITMAPS
:
2352 case OPTION_SKIP_BROKEN
:
2358 if (!out_fmt
&& !tgt_image_opts
) {
2362 if (skip_broken
&& !bitmaps
) {
2363 error_report("Use of --skip-broken-bitmaps requires --bitmaps");
2367 if (s
.compressed
&& s
.copy_range
) {
2368 error_report("Cannot enable copy offloading when -c is used");
2372 if (explict_min_sparse
&& s
.copy_range
) {
2373 error_report("Cannot enable copy offloading when -S is used");
2377 if (s
.copy_range
&& s
.salvage
) {
2378 error_report("Cannot use copy offloading in salvaging mode");
2382 if (tgt_image_opts
&& !skip_create
) {
2383 error_report("--target-image-opts requires use of -n flag");
2387 if (skip_create
&& options
) {
2388 error_report("-o has no effect when skipping image creation");
2392 if (s
.has_zero_init
&& !skip_create
) {
2393 error_report("--target-is-zero requires use of -n flag");
2397 s
.src_num
= argc
- optind
- 1;
2398 out_filename
= s
.src_num
>= 1 ? argv
[argc
- 1] : NULL
;
2400 if (options
&& has_help_option(options
)) {
2402 ret
= print_block_option_help(out_filename
, out_fmt
);
2405 error_report("Option help requires a format be specified");
2410 if (s
.src_num
< 1) {
2411 error_report("Must specify image file name");
2415 /* ret is still -EINVAL until here */
2416 ret
= bdrv_parse_cache_mode(src_cache
, &src_flags
, &src_writethrough
);
2418 error_report("Invalid source cache option: %s", src_cache
);
2422 /* Initialize before goto out */
2426 qemu_progress_init(progress
, 1.0);
2427 qemu_progress_print(0, 100);
2429 s
.src
= g_new0(BlockBackend
*, s
.src_num
);
2430 s
.src_sectors
= g_new(int64_t, s
.src_num
);
2431 s
.src_alignment
= g_new(int, s
.src_num
);
2433 for (bs_i
= 0; bs_i
< s
.src_num
; bs_i
++) {
2434 BlockDriverState
*src_bs
;
2435 s
.src
[bs_i
] = img_open(image_opts
, argv
[optind
+ bs_i
],
2436 fmt
, src_flags
, src_writethrough
, s
.quiet
,
2442 s
.src_sectors
[bs_i
] = blk_nb_sectors(s
.src
[bs_i
]);
2443 if (s
.src_sectors
[bs_i
] < 0) {
2444 error_report("Could not get size of %s: %s",
2445 argv
[optind
+ bs_i
], strerror(-s
.src_sectors
[bs_i
]));
2449 src_bs
= blk_bs(s
.src
[bs_i
]);
2450 s
.src_alignment
[bs_i
] = DIV_ROUND_UP(src_bs
->bl
.request_alignment
,
2452 if (!bdrv_get_info(src_bs
, &bdi
)) {
2453 s
.src_alignment
[bs_i
] = MAX(s
.src_alignment
[bs_i
],
2454 bdi
.cluster_size
/ BDRV_SECTOR_SIZE
);
2456 s
.total_sectors
+= s
.src_sectors
[bs_i
];
2460 bdrv_snapshot_load_tmp(blk_bs(s
.src
[0]),
2461 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_ID
),
2462 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_NAME
),
2464 } else if (snapshot_name
!= NULL
) {
2465 if (s
.src_num
> 1) {
2466 error_report("No support for concatenating multiple snapshot");
2471 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s
.src
[0]), snapshot_name
,
2475 error_reportf_err(local_err
, "Failed to load snapshot: ");
2481 /* Find driver and parse its options */
2482 drv
= bdrv_find_format(out_fmt
);
2484 error_report("Unknown file format '%s'", out_fmt
);
2489 proto_drv
= bdrv_find_protocol(out_filename
, true, &local_err
);
2491 error_report_err(local_err
);
2496 if (!drv
->create_opts
) {
2497 error_report("Format driver '%s' does not support image creation",
2503 if (!proto_drv
->create_opts
) {
2504 error_report("Protocol driver '%s' does not support image creation",
2505 proto_drv
->format_name
);
2510 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
2511 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
2513 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
2515 if (!qemu_opts_do_parse(opts
, options
, NULL
, &local_err
)) {
2516 error_report_err(local_err
);
2522 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
2523 s
.total_sectors
* BDRV_SECTOR_SIZE
, &error_abort
);
2524 ret
= add_old_style_options(out_fmt
, opts
, out_baseimg
, NULL
);
2530 /* Get backing file name if -o backing_file was used */
2531 out_baseimg_param
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
2532 if (out_baseimg_param
) {
2533 out_baseimg
= out_baseimg_param
;
2535 s
.target_has_backing
= (bool) out_baseimg
;
2537 if (s
.has_zero_init
&& s
.target_has_backing
) {
2538 error_report("Cannot use --target-is-zero when the destination "
2539 "image has a backing file");
2543 if (s
.src_num
> 1 && out_baseimg
) {
2544 error_report("Having a backing file for the target makes no sense when "
2545 "concatenating multiple input images");
2550 if (out_baseimg_param
) {
2551 if (!qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
)) {
2552 error_report("Use of backing file requires explicit "
2559 /* Check if compression is supported */
2562 qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
, false);
2563 const char *encryptfmt
=
2564 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
);
2565 const char *preallocation
=
2566 qemu_opt_get(opts
, BLOCK_OPT_PREALLOC
);
2568 if (drv
&& !block_driver_can_compress(drv
)) {
2569 error_report("Compression not supported for this file format");
2574 if (encryption
|| encryptfmt
) {
2575 error_report("Compression and encryption not supported at "
2582 && strcmp(preallocation
, "off"))
2584 error_report("Compression and preallocation not supported at "
2591 /* Determine if bitmaps need copying */
2593 if (s
.src_num
> 1) {
2594 error_report("Copying bitmaps only possible with single source");
2598 ret
= convert_check_bitmaps(blk_bs(s
.src
[0]), skip_broken
);
2605 * The later open call will need any decryption secrets, and
2606 * bdrv_create() will purge "opts", so extract them now before
2610 open_opts
= qdict_new();
2611 qemu_opt_foreach(opts
, img_add_key_secrets
, open_opts
, &error_abort
);
2613 /* Create the new image */
2614 ret
= bdrv_create(drv
, out_filename
, opts
, &local_err
);
2616 error_reportf_err(local_err
, "%s: error while converting %s: ",
2617 out_filename
, out_fmt
);
2622 s
.target_is_new
= !skip_create
;
2624 flags
= s
.min_sparse
? (BDRV_O_RDWR
| BDRV_O_UNMAP
) : BDRV_O_RDWR
;
2625 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
2627 error_report("Invalid cache option: %s", cache
);
2631 if (flags
& BDRV_O_NOCACHE
) {
2633 * If we open the target with O_DIRECT, it may be necessary to
2634 * extend its size to align to the physical sector size.
2636 flags
|= BDRV_O_RESIZE
;
2640 s
.target
= img_open(tgt_image_opts
, out_filename
, out_fmt
,
2641 flags
, writethrough
, s
.quiet
, false);
2643 /* TODO ultimately we should allow --target-image-opts
2644 * to be used even when -n is not given.
2645 * That has to wait for bdrv_create to be improved
2646 * to allow filenames in option syntax
2648 s
.target
= img_open_file(out_filename
, open_opts
, out_fmt
,
2649 flags
, writethrough
, s
.quiet
, false);
2650 open_opts
= NULL
; /* blk_new_open will have freed it */
2656 out_bs
= blk_bs(s
.target
);
2658 if (bitmaps
&& !bdrv_supports_persistent_dirty_bitmap(out_bs
)) {
2659 error_report("Format driver '%s' does not support bitmaps",
2660 out_bs
->drv
->format_name
);
2665 if (s
.compressed
&& !block_driver_can_compress(out_bs
->drv
)) {
2666 error_report("Compression not supported for this file format");
2671 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2672 * or discard_alignment of the out_bs is greater. Limit to
2673 * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2674 s
.buf_sectors
= MIN(MAX_BUF_SECTORS
,
2676 MAX(out_bs
->bl
.opt_transfer
>> BDRV_SECTOR_BITS
,
2677 out_bs
->bl
.pdiscard_alignment
>>
2678 BDRV_SECTOR_BITS
)));
2680 /* try to align the write requests to the destination to avoid unnecessary
2682 s
.alignment
= MAX(pow2floor(s
.min_sparse
),
2683 DIV_ROUND_UP(out_bs
->bl
.request_alignment
,
2685 assert(is_power_of_2(s
.alignment
));
2688 int64_t output_sectors
= blk_nb_sectors(s
.target
);
2689 if (output_sectors
< 0) {
2690 error_report("unable to get output image length: %s",
2691 strerror(-output_sectors
));
2694 } else if (output_sectors
< s
.total_sectors
) {
2695 error_report("output file is smaller than input file");
2701 if (s
.target_has_backing
&& s
.target_is_new
) {
2702 /* Errors are treated as "backing length unknown" (which means
2703 * s.target_backing_sectors has to be negative, which it will
2704 * be automatically). The backing file length is used only
2705 * for optimizations, so such a case is not fatal. */
2706 s
.target_backing_sectors
=
2707 bdrv_nb_sectors(bdrv_backing_chain_next(out_bs
));
2709 s
.target_backing_sectors
= -1;
2712 ret
= bdrv_get_info(out_bs
, &bdi
);
2715 error_report("could not get block driver info");
2719 s
.compressed
= s
.compressed
|| bdi
.needs_compressed_writes
;
2720 s
.cluster_sectors
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2724 set_rate_limit(s
.target
, rate_limit
);
2727 ret
= convert_do_copy(&s
);
2729 /* Now copy the bitmaps */
2730 if (bitmaps
&& ret
== 0) {
2731 ret
= convert_copy_bitmaps(blk_bs(s
.src
[0]), out_bs
, skip_broken
);
2736 qemu_progress_print(100, 0);
2738 qemu_progress_end();
2739 qemu_opts_del(opts
);
2740 qemu_opts_free(create_opts
);
2741 qobject_unref(open_opts
);
2742 blk_unref(s
.target
);
2744 for (bs_i
= 0; bs_i
< s
.src_num
; bs_i
++) {
2745 blk_unref(s
.src
[bs_i
]);
2749 g_free(s
.src_sectors
);
2750 g_free(s
.src_alignment
);
2752 qemu_opts_del(sn_opts
);
2759 static void dump_snapshots(BlockDriverState
*bs
)
2761 QEMUSnapshotInfo
*sn_tab
, *sn
;
2764 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
2767 printf("Snapshot list:\n");
2768 bdrv_snapshot_dump(NULL
);
2770 for(i
= 0; i
< nb_sns
; i
++) {
2772 bdrv_snapshot_dump(sn
);
2778 static void dump_json_image_info_list(ImageInfoList
*list
)
2782 Visitor
*v
= qobject_output_visitor_new(&obj
);
2784 visit_type_ImageInfoList(v
, NULL
, &list
, &error_abort
);
2785 visit_complete(v
, &obj
);
2786 str
= qobject_to_json_pretty(obj
, true);
2787 assert(str
!= NULL
);
2788 printf("%s\n", str
->str
);
2791 g_string_free(str
, true);
2794 static void dump_json_image_info(ImageInfo
*info
)
2798 Visitor
*v
= qobject_output_visitor_new(&obj
);
2800 visit_type_ImageInfo(v
, NULL
, &info
, &error_abort
);
2801 visit_complete(v
, &obj
);
2802 str
= qobject_to_json_pretty(obj
, true);
2803 assert(str
!= NULL
);
2804 printf("%s\n", str
->str
);
2807 g_string_free(str
, true);
2810 static void dump_human_image_info_list(ImageInfoList
*list
)
2812 ImageInfoList
*elem
;
2815 for (elem
= list
; elem
; elem
= elem
->next
) {
2821 bdrv_image_info_dump(elem
->value
);
2825 static gboolean
str_equal_func(gconstpointer a
, gconstpointer b
)
2827 return strcmp(a
, b
) == 0;
2831 * Open an image file chain and return an ImageInfoList
2833 * @filename: topmost image filename
2834 * @fmt: topmost image format (may be NULL to autodetect)
2835 * @chain: true - enumerate entire backing file chain
2836 * false - only topmost image file
2838 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2839 * image file. If there was an error a message will have been printed to
2842 static ImageInfoList
*collect_image_info_list(bool image_opts
,
2843 const char *filename
,
2845 bool chain
, bool force_share
)
2847 ImageInfoList
*head
= NULL
;
2848 ImageInfoList
**tail
= &head
;
2849 GHashTable
*filenames
;
2852 filenames
= g_hash_table_new_full(g_str_hash
, str_equal_func
, NULL
, NULL
);
2856 BlockDriverState
*bs
;
2859 if (g_hash_table_lookup_extended(filenames
, filename
, NULL
, NULL
)) {
2860 error_report("Backing file '%s' creates an infinite loop.",
2864 g_hash_table_insert(filenames
, (gpointer
)filename
, NULL
);
2866 blk
= img_open(image_opts
, filename
, fmt
,
2867 BDRV_O_NO_BACKING
| BDRV_O_NO_IO
, false, false,
2874 bdrv_query_image_info(bs
, &info
, &err
);
2876 error_report_err(err
);
2881 QAPI_LIST_APPEND(tail
, info
);
2885 /* Clear parameters that only apply to the topmost image */
2886 filename
= fmt
= NULL
;
2890 if (info
->has_full_backing_filename
) {
2891 filename
= info
->full_backing_filename
;
2892 } else if (info
->has_backing_filename
) {
2893 error_report("Could not determine absolute backing filename,"
2894 " but backing filename '%s' present",
2895 info
->backing_filename
);
2898 if (info
->has_backing_filename_format
) {
2899 fmt
= info
->backing_filename_format
;
2903 g_hash_table_destroy(filenames
);
2907 qapi_free_ImageInfoList(head
);
2908 g_hash_table_destroy(filenames
);
2912 static int img_info(int argc
, char **argv
)
2915 OutputFormat output_format
= OFORMAT_HUMAN
;
2917 const char *filename
, *fmt
, *output
;
2918 ImageInfoList
*list
;
2919 bool image_opts
= false;
2920 bool force_share
= false;
2925 int option_index
= 0;
2926 static const struct option long_options
[] = {
2927 {"help", no_argument
, 0, 'h'},
2928 {"format", required_argument
, 0, 'f'},
2929 {"output", required_argument
, 0, OPTION_OUTPUT
},
2930 {"backing-chain", no_argument
, 0, OPTION_BACKING_CHAIN
},
2931 {"object", required_argument
, 0, OPTION_OBJECT
},
2932 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
2933 {"force-share", no_argument
, 0, 'U'},
2936 c
= getopt_long(argc
, argv
, ":f:hU",
2937 long_options
, &option_index
);
2943 missing_argument(argv
[optind
- 1]);
2946 unrecognized_option(argv
[optind
- 1]);
2960 case OPTION_BACKING_CHAIN
:
2964 user_creatable_process_cmdline(optarg
);
2966 case OPTION_IMAGE_OPTS
:
2971 if (optind
!= argc
- 1) {
2972 error_exit("Expecting one image file name");
2974 filename
= argv
[optind
++];
2976 if (output
&& !strcmp(output
, "json")) {
2977 output_format
= OFORMAT_JSON
;
2978 } else if (output
&& !strcmp(output
, "human")) {
2979 output_format
= OFORMAT_HUMAN
;
2980 } else if (output
) {
2981 error_report("--output must be used with human or json as argument.");
2985 list
= collect_image_info_list(image_opts
, filename
, fmt
, chain
,
2991 switch (output_format
) {
2993 dump_human_image_info_list(list
);
2997 dump_json_image_info_list(list
);
2999 dump_json_image_info(list
->value
);
3004 qapi_free_ImageInfoList(list
);
3008 static int dump_map_entry(OutputFormat output_format
, MapEntry
*e
,
3011 switch (output_format
) {
3013 if (e
->data
&& !e
->has_offset
) {
3014 error_report("File contains external, encrypted or compressed clusters.");
3017 if (e
->data
&& !e
->zero
) {
3018 printf("%#-16"PRIx64
"%#-16"PRIx64
"%#-16"PRIx64
"%s\n",
3019 e
->start
, e
->length
,
3020 e
->has_offset
? e
->offset
: 0,
3021 e
->has_filename
? e
->filename
: "");
3023 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
3024 * Modify the flags here to allow more coalescing.
3026 if (next
&& (!next
->data
|| next
->zero
)) {
3032 printf("{ \"start\": %"PRId64
", \"length\": %"PRId64
","
3033 " \"depth\": %"PRId64
", \"present\": %s, \"zero\": %s,"
3034 " \"data\": %s", e
->start
, e
->length
, e
->depth
,
3035 e
->present
? "true" : "false",
3036 e
->zero
? "true" : "false",
3037 e
->data
? "true" : "false");
3038 if (e
->has_offset
) {
3039 printf(", \"offset\": %"PRId64
"", e
->offset
);
3051 static int get_block_status(BlockDriverState
*bs
, int64_t offset
,
3052 int64_t bytes
, MapEntry
*e
)
3056 BlockDriverState
*file
;
3059 char *filename
= NULL
;
3061 /* As an optimization, we could cache the current range of unallocated
3062 * clusters in each file of the chain, and avoid querying the same
3068 bs
= bdrv_skip_filters(bs
);
3069 ret
= bdrv_block_status(bs
, offset
, bytes
, &bytes
, &map
, &file
);
3074 if (ret
& (BDRV_BLOCK_ZERO
|BDRV_BLOCK_DATA
)) {
3077 bs
= bdrv_cow_bs(bs
);
3086 has_offset
= !!(ret
& BDRV_BLOCK_OFFSET_VALID
);
3088 if (file
&& has_offset
) {
3089 bdrv_refresh_filename(file
);
3090 filename
= file
->filename
;
3096 .data
= !!(ret
& BDRV_BLOCK_DATA
),
3097 .zero
= !!(ret
& BDRV_BLOCK_ZERO
),
3099 .has_offset
= has_offset
,
3101 .present
= !!(ret
& BDRV_BLOCK_ALLOCATED
),
3102 .has_filename
= filename
,
3103 .filename
= filename
,
3109 static inline bool entry_mergeable(const MapEntry
*curr
, const MapEntry
*next
)
3111 if (curr
->length
== 0) {
3114 if (curr
->zero
!= next
->zero
||
3115 curr
->data
!= next
->data
||
3116 curr
->depth
!= next
->depth
||
3117 curr
->present
!= next
->present
||
3118 curr
->has_filename
!= next
->has_filename
||
3119 curr
->has_offset
!= next
->has_offset
) {
3122 if (curr
->has_filename
&& strcmp(curr
->filename
, next
->filename
)) {
3125 if (curr
->has_offset
&& curr
->offset
+ curr
->length
!= next
->offset
) {
3131 static int img_map(int argc
, char **argv
)
3134 OutputFormat output_format
= OFORMAT_HUMAN
;
3136 BlockDriverState
*bs
;
3137 const char *filename
, *fmt
, *output
;
3139 MapEntry curr
= { .length
= 0 }, next
;
3141 bool image_opts
= false;
3142 bool force_share
= false;
3143 int64_t start_offset
= 0;
3144 int64_t max_length
= -1;
3149 int option_index
= 0;
3150 static const struct option long_options
[] = {
3151 {"help", no_argument
, 0, 'h'},
3152 {"format", required_argument
, 0, 'f'},
3153 {"output", required_argument
, 0, OPTION_OUTPUT
},
3154 {"object", required_argument
, 0, OPTION_OBJECT
},
3155 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3156 {"force-share", no_argument
, 0, 'U'},
3157 {"start-offset", required_argument
, 0, 's'},
3158 {"max-length", required_argument
, 0, 'l'},
3161 c
= getopt_long(argc
, argv
, ":f:s:l:hU",
3162 long_options
, &option_index
);
3168 missing_argument(argv
[optind
- 1]);
3171 unrecognized_option(argv
[optind
- 1]);
3186 start_offset
= cvtnum("start offset", optarg
);
3187 if (start_offset
< 0) {
3192 max_length
= cvtnum("max length", optarg
);
3193 if (max_length
< 0) {
3198 user_creatable_process_cmdline(optarg
);
3200 case OPTION_IMAGE_OPTS
:
3205 if (optind
!= argc
- 1) {
3206 error_exit("Expecting one image file name");
3208 filename
= argv
[optind
];
3210 if (output
&& !strcmp(output
, "json")) {
3211 output_format
= OFORMAT_JSON
;
3212 } else if (output
&& !strcmp(output
, "human")) {
3213 output_format
= OFORMAT_HUMAN
;
3214 } else if (output
) {
3215 error_report("--output must be used with human or json as argument.");
3219 blk
= img_open(image_opts
, filename
, fmt
, 0, false, false, force_share
);
3225 if (output_format
== OFORMAT_HUMAN
) {
3226 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
3227 } else if (output_format
== OFORMAT_JSON
) {
3231 length
= blk_getlength(blk
);
3233 error_report("Failed to get size for '%s'", filename
);
3236 if (max_length
!= -1) {
3237 length
= MIN(start_offset
+ max_length
, length
);
3240 curr
.start
= start_offset
;
3241 while (curr
.start
+ curr
.length
< length
) {
3242 int64_t offset
= curr
.start
+ curr
.length
;
3243 int64_t n
= length
- offset
;
3245 ret
= get_block_status(bs
, offset
, n
, &next
);
3247 error_report("Could not read file metadata: %s", strerror(-ret
));
3251 if (entry_mergeable(&curr
, &next
)) {
3252 curr
.length
+= next
.length
;
3256 if (curr
.length
> 0) {
3257 ret
= dump_map_entry(output_format
, &curr
, &next
);
3265 ret
= dump_map_entry(output_format
, &curr
, NULL
);
3266 if (output_format
== OFORMAT_JSON
) {
3275 #define SNAPSHOT_LIST 1
3276 #define SNAPSHOT_CREATE 2
3277 #define SNAPSHOT_APPLY 3
3278 #define SNAPSHOT_DELETE 4
3280 static int img_snapshot(int argc
, char **argv
)
3283 BlockDriverState
*bs
;
3284 QEMUSnapshotInfo sn
;
3285 char *filename
, *snapshot_name
= NULL
;
3286 int c
, ret
= 0, bdrv_oflags
;
3291 bool image_opts
= false;
3292 bool force_share
= false;
3294 bdrv_oflags
= BDRV_O_RDWR
;
3295 /* Parse commandline parameters */
3297 static const struct option long_options
[] = {
3298 {"help", no_argument
, 0, 'h'},
3299 {"object", required_argument
, 0, OPTION_OBJECT
},
3300 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3301 {"force-share", no_argument
, 0, 'U'},
3304 c
= getopt_long(argc
, argv
, ":la:c:d:hqU",
3305 long_options
, NULL
);
3311 missing_argument(argv
[optind
- 1]);
3314 unrecognized_option(argv
[optind
- 1]);
3321 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3324 action
= SNAPSHOT_LIST
;
3325 bdrv_oflags
&= ~BDRV_O_RDWR
; /* no need for RW */
3329 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3332 action
= SNAPSHOT_APPLY
;
3333 snapshot_name
= optarg
;
3337 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3340 action
= SNAPSHOT_CREATE
;
3341 snapshot_name
= optarg
;
3345 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3348 action
= SNAPSHOT_DELETE
;
3349 snapshot_name
= optarg
;
3358 user_creatable_process_cmdline(optarg
);
3360 case OPTION_IMAGE_OPTS
:
3366 if (optind
!= argc
- 1) {
3367 error_exit("Expecting one image file name");
3369 filename
= argv
[optind
++];
3371 /* Open the image */
3372 blk
= img_open(image_opts
, filename
, NULL
, bdrv_oflags
, false, quiet
,
3379 /* Perform the requested action */
3385 case SNAPSHOT_CREATE
:
3386 memset(&sn
, 0, sizeof(sn
));
3387 pstrcpy(sn
.name
, sizeof(sn
.name
), snapshot_name
);
3389 qemu_gettimeofday(&tv
);
3390 sn
.date_sec
= tv
.tv_sec
;
3391 sn
.date_nsec
= tv
.tv_usec
* 1000;
3393 ret
= bdrv_snapshot_create(bs
, &sn
);
3395 error_report("Could not create snapshot '%s': %d (%s)",
3396 snapshot_name
, ret
, strerror(-ret
));
3400 case SNAPSHOT_APPLY
:
3401 ret
= bdrv_snapshot_goto(bs
, snapshot_name
, &err
);
3403 error_reportf_err(err
, "Could not apply snapshot '%s': ",
3408 case SNAPSHOT_DELETE
:
3409 ret
= bdrv_snapshot_find(bs
, &sn
, snapshot_name
);
3411 error_report("Could not delete snapshot '%s': snapshot not "
3412 "found", snapshot_name
);
3415 ret
= bdrv_snapshot_delete(bs
, sn
.id_str
, sn
.name
, &err
);
3417 error_reportf_err(err
, "Could not delete snapshot '%s': ",
3433 static int img_rebase(int argc
, char **argv
)
3435 BlockBackend
*blk
= NULL
, *blk_old_backing
= NULL
, *blk_new_backing
= NULL
;
3436 uint8_t *buf_old
= NULL
;
3437 uint8_t *buf_new
= NULL
;
3438 BlockDriverState
*bs
= NULL
, *prefix_chain_bs
= NULL
;
3439 BlockDriverState
*unfiltered_bs
;
3441 const char *fmt
, *cache
, *src_cache
, *out_basefmt
, *out_baseimg
;
3442 int c
, flags
, src_flags
, ret
;
3443 bool writethrough
, src_writethrough
;
3445 bool force_share
= false;
3448 Error
*local_err
= NULL
;
3449 bool image_opts
= false;
3451 /* Parse commandline parameters */
3453 cache
= BDRV_DEFAULT_CACHE
;
3454 src_cache
= BDRV_DEFAULT_CACHE
;
3458 static const struct option long_options
[] = {
3459 {"help", no_argument
, 0, 'h'},
3460 {"object", required_argument
, 0, OPTION_OBJECT
},
3461 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3462 {"force-share", no_argument
, 0, 'U'},
3465 c
= getopt_long(argc
, argv
, ":hf:F:b:upt:T:qU",
3466 long_options
, NULL
);
3472 missing_argument(argv
[optind
- 1]);
3475 unrecognized_option(argv
[optind
- 1]);
3484 out_basefmt
= optarg
;
3487 out_baseimg
= optarg
;
3505 user_creatable_process_cmdline(optarg
);
3507 case OPTION_IMAGE_OPTS
:
3520 if (optind
!= argc
- 1) {
3521 error_exit("Expecting one image file name");
3523 if (!unsafe
&& !out_baseimg
) {
3524 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3526 filename
= argv
[optind
++];
3528 qemu_progress_init(progress
, 2.0);
3529 qemu_progress_print(0, 100);
3531 flags
= BDRV_O_RDWR
| (unsafe
? BDRV_O_NO_BACKING
: 0);
3532 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
3534 error_report("Invalid cache option: %s", cache
);
3539 ret
= bdrv_parse_cache_mode(src_cache
, &src_flags
, &src_writethrough
);
3541 error_report("Invalid source cache option: %s", src_cache
);
3545 /* The source files are opened read-only, don't care about WCE */
3546 assert((src_flags
& BDRV_O_RDWR
) == 0);
3547 (void) src_writethrough
;
3552 * Ignore the old backing file for unsafe rebase in case we want to correct
3553 * the reference to a renamed or moved backing file.
3555 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
3563 unfiltered_bs
= bdrv_skip_filters(bs
);
3565 if (out_basefmt
!= NULL
) {
3566 if (bdrv_find_format(out_basefmt
) == NULL
) {
3567 error_report("Invalid format name: '%s'", out_basefmt
);
3573 /* For safe rebasing we need to compare old and new backing file */
3575 QDict
*options
= NULL
;
3576 BlockDriverState
*base_bs
= bdrv_cow_bs(unfiltered_bs
);
3579 blk_old_backing
= blk_new(qemu_get_aio_context(),
3580 BLK_PERM_CONSISTENT_READ
,
3582 ret
= blk_insert_bs(blk_old_backing
, base_bs
,
3585 error_reportf_err(local_err
,
3586 "Could not reuse old backing file '%s': ",
3591 blk_old_backing
= NULL
;
3594 if (out_baseimg
[0]) {
3595 const char *overlay_filename
;
3596 char *out_real_path
;
3598 options
= qdict_new();
3600 qdict_put_str(options
, "driver", out_basefmt
);
3603 qdict_put_bool(options
, BDRV_OPT_FORCE_SHARE
, true);
3606 bdrv_refresh_filename(bs
);
3607 overlay_filename
= bs
->exact_filename
[0] ? bs
->exact_filename
3610 bdrv_get_full_backing_filename_from_filename(overlay_filename
,
3614 qobject_unref(options
);
3615 error_reportf_err(local_err
,
3616 "Could not resolve backing filename: ");
3622 * Find out whether we rebase an image on top of a previous image
3625 prefix_chain_bs
= bdrv_find_backing_image(bs
, out_real_path
);
3626 if (prefix_chain_bs
) {
3627 qobject_unref(options
);
3628 g_free(out_real_path
);
3630 blk_new_backing
= blk_new(qemu_get_aio_context(),
3631 BLK_PERM_CONSISTENT_READ
,
3633 ret
= blk_insert_bs(blk_new_backing
, prefix_chain_bs
,
3636 error_reportf_err(local_err
,
3637 "Could not reuse backing file '%s': ",
3642 blk_new_backing
= blk_new_open(out_real_path
, NULL
,
3643 options
, src_flags
, &local_err
);
3644 g_free(out_real_path
);
3645 if (!blk_new_backing
) {
3646 error_reportf_err(local_err
,
3647 "Could not open new backing file '%s': ",
3657 * Check each unallocated cluster in the COW file. If it is unallocated,
3658 * accesses go to the backing file. We must therefore compare this cluster
3659 * in the old and new backing file, and if they differ we need to copy it
3660 * from the old backing file into the COW file.
3662 * If qemu-img crashes during this step, no harm is done. The content of
3663 * the image is the same as the original one at any time.
3667 int64_t old_backing_size
= 0;
3668 int64_t new_backing_size
= 0;
3671 float local_progress
= 0;
3673 buf_old
= blk_blockalign(blk
, IO_BUF_SIZE
);
3674 buf_new
= blk_blockalign(blk
, IO_BUF_SIZE
);
3676 size
= blk_getlength(blk
);
3678 error_report("Could not get size of '%s': %s",
3679 filename
, strerror(-size
));
3683 if (blk_old_backing
) {
3684 old_backing_size
= blk_getlength(blk_old_backing
);
3685 if (old_backing_size
< 0) {
3686 char backing_name
[PATH_MAX
];
3688 bdrv_get_backing_filename(bs
, backing_name
,
3689 sizeof(backing_name
));
3690 error_report("Could not get size of '%s': %s",
3691 backing_name
, strerror(-old_backing_size
));
3696 if (blk_new_backing
) {
3697 new_backing_size
= blk_getlength(blk_new_backing
);
3698 if (new_backing_size
< 0) {
3699 error_report("Could not get size of '%s': %s",
3700 out_baseimg
, strerror(-new_backing_size
));
3707 local_progress
= (float)100 / (size
/ MIN(size
, IO_BUF_SIZE
));
3710 for (offset
= 0; offset
< size
; offset
+= n
) {
3711 bool buf_old_is_zero
= false;
3713 /* How many bytes can we handle with the next read? */
3714 n
= MIN(IO_BUF_SIZE
, size
- offset
);
3716 /* If the cluster is allocated, we don't need to take action */
3717 ret
= bdrv_is_allocated(unfiltered_bs
, offset
, n
, &n
);
3719 error_report("error while reading image metadata: %s",
3727 if (prefix_chain_bs
) {
3729 * If cluster wasn't changed since prefix_chain, we don't need
3732 ret
= bdrv_is_allocated_above(bdrv_cow_bs(unfiltered_bs
),
3733 prefix_chain_bs
, false,
3736 error_report("error while reading image metadata: %s",
3746 * Read old and new backing file and take into consideration that
3747 * backing files may be smaller than the COW image.
3749 if (offset
>= old_backing_size
) {
3750 memset(buf_old
, 0, n
);
3751 buf_old_is_zero
= true;
3753 if (offset
+ n
> old_backing_size
) {
3754 n
= old_backing_size
- offset
;
3757 ret
= blk_pread(blk_old_backing
, offset
, buf_old
, n
);
3759 error_report("error while reading from old backing file");
3764 if (offset
>= new_backing_size
|| !blk_new_backing
) {
3765 memset(buf_new
, 0, n
);
3767 if (offset
+ n
> new_backing_size
) {
3768 n
= new_backing_size
- offset
;
3771 ret
= blk_pread(blk_new_backing
, offset
, buf_new
, n
);
3773 error_report("error while reading from new backing file");
3778 /* If they differ, we need to write to the COW file */
3779 uint64_t written
= 0;
3781 while (written
< n
) {
3784 if (compare_buffers(buf_old
+ written
, buf_new
+ written
,
3785 n
- written
, &pnum
))
3787 if (buf_old_is_zero
) {
3788 ret
= blk_pwrite_zeroes(blk
, offset
+ written
, pnum
, 0);
3790 ret
= blk_pwrite(blk
, offset
+ written
,
3791 buf_old
+ written
, pnum
, 0);
3794 error_report("Error while writing to COW image: %s",
3802 qemu_progress_print(local_progress
, 100);
3807 * Change the backing file. All clusters that are different from the old
3808 * backing file are overwritten in the COW file now, so the visible content
3809 * doesn't change when we switch the backing file.
3811 if (out_baseimg
&& *out_baseimg
) {
3812 ret
= bdrv_change_backing_file(unfiltered_bs
, out_baseimg
, out_basefmt
,
3815 ret
= bdrv_change_backing_file(unfiltered_bs
, NULL
, NULL
, false);
3818 if (ret
== -ENOSPC
) {
3819 error_report("Could not change the backing file to '%s': No "
3820 "space left in the file header", out_baseimg
);
3821 } else if (ret
== -EINVAL
&& out_baseimg
&& !out_basefmt
) {
3822 error_report("Could not change the backing file to '%s': backing "
3823 "format must be specified", out_baseimg
);
3824 } else if (ret
< 0) {
3825 error_report("Could not change the backing file to '%s': %s",
3826 out_baseimg
, strerror(-ret
));
3829 qemu_progress_print(100, 0);
3831 * TODO At this point it is possible to check if any clusters that are
3832 * allocated in the COW file are the same in the backing file. If so, they
3833 * could be dropped from the COW file. Don't do this before switching the
3834 * backing file, in case of a crash this would lead to corruption.
3837 qemu_progress_end();
3840 blk_unref(blk_old_backing
);
3841 blk_unref(blk_new_backing
);
3843 qemu_vfree(buf_old
);
3844 qemu_vfree(buf_new
);
3853 static int img_resize(int argc
, char **argv
)
3856 int c
, ret
, relative
;
3857 const char *filename
, *fmt
, *size
;
3858 int64_t n
, total_size
, current_size
;
3860 BlockBackend
*blk
= NULL
;
3861 PreallocMode prealloc
= PREALLOC_MODE_OFF
;
3864 static QemuOptsList resize_options
= {
3865 .name
= "resize_options",
3866 .head
= QTAILQ_HEAD_INITIALIZER(resize_options
.head
),
3869 .name
= BLOCK_OPT_SIZE
,
3870 .type
= QEMU_OPT_SIZE
,
3871 .help
= "Virtual disk size"
3877 bool image_opts
= false;
3878 bool shrink
= false;
3880 /* Remove size from argv manually so that negative numbers are not treated
3881 * as options by getopt. */
3883 error_exit("Not enough arguments");
3887 size
= argv
[--argc
];
3889 /* Parse getopt arguments */
3892 static const struct option long_options
[] = {
3893 {"help", no_argument
, 0, 'h'},
3894 {"object", required_argument
, 0, OPTION_OBJECT
},
3895 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
3896 {"preallocation", required_argument
, 0, OPTION_PREALLOCATION
},
3897 {"shrink", no_argument
, 0, OPTION_SHRINK
},
3900 c
= getopt_long(argc
, argv
, ":f:hq",
3901 long_options
, NULL
);
3907 missing_argument(argv
[optind
- 1]);
3910 unrecognized_option(argv
[optind
- 1]);
3922 user_creatable_process_cmdline(optarg
);
3924 case OPTION_IMAGE_OPTS
:
3927 case OPTION_PREALLOCATION
:
3928 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optarg
,
3929 PREALLOC_MODE__MAX
, NULL
);
3930 if (prealloc
== PREALLOC_MODE__MAX
) {
3931 error_report("Invalid preallocation mode '%s'", optarg
);
3940 if (optind
!= argc
- 1) {
3941 error_exit("Expecting image file name and size");
3943 filename
= argv
[optind
++];
3945 /* Choose grow, shrink, or absolute resize mode */
3961 param
= qemu_opts_create(&resize_options
, NULL
, 0, &error_abort
);
3962 if (!qemu_opt_set(param
, BLOCK_OPT_SIZE
, size
, &err
)) {
3963 error_report_err(err
);
3965 qemu_opts_del(param
);
3968 n
= qemu_opt_get_size(param
, BLOCK_OPT_SIZE
, 0);
3969 qemu_opts_del(param
);
3971 blk
= img_open(image_opts
, filename
, fmt
,
3972 BDRV_O_RDWR
| BDRV_O_RESIZE
, false, quiet
,
3979 current_size
= blk_getlength(blk
);
3980 if (current_size
< 0) {
3981 error_report("Failed to inquire current image length: %s",
3982 strerror(-current_size
));
3988 total_size
= current_size
+ n
* relative
;
3992 if (total_size
<= 0) {
3993 error_report("New image size must be positive");
3998 if (total_size
<= current_size
&& prealloc
!= PREALLOC_MODE_OFF
) {
3999 error_report("Preallocation can only be used for growing images");
4004 if (total_size
< current_size
&& !shrink
) {
4005 error_report("Use the --shrink option to perform a shrink operation.");
4006 warn_report("Shrinking an image will delete all data beyond the "
4007 "shrunken image's end. Before performing such an "
4008 "operation, make sure there is no important data there.");
4014 * The user expects the image to have the desired size after
4015 * resizing, so pass @exact=true. It is of no use to report
4016 * success when the image has not actually been resized.
4018 ret
= blk_truncate(blk
, total_size
, true, prealloc
, 0, &err
);
4020 qprintf(quiet
, "Image resized.\n");
4022 error_report_err(err
);
4032 static void amend_status_cb(BlockDriverState
*bs
,
4033 int64_t offset
, int64_t total_work_size
,
4036 qemu_progress_print(100.f
* offset
/ total_work_size
, 0);
4039 static int print_amend_option_help(const char *format
)
4043 /* Find driver and parse its options */
4044 drv
= bdrv_find_format(format
);
4046 error_report("Unknown file format '%s'", format
);
4050 if (!drv
->bdrv_amend_options
) {
4051 error_report("Format driver '%s' does not support option amendment",
4056 /* Every driver supporting amendment must have amend_opts */
4057 assert(drv
->amend_opts
);
4059 printf("Amend options for '%s':\n", format
);
4060 qemu_opts_print_help(drv
->amend_opts
, false);
4064 static int img_amend(int argc
, char **argv
)
4068 char *options
= NULL
;
4069 QemuOptsList
*amend_opts
= NULL
;
4070 QemuOpts
*opts
= NULL
;
4071 const char *fmt
= NULL
, *filename
, *cache
;
4074 bool quiet
= false, progress
= false;
4075 BlockBackend
*blk
= NULL
;
4076 BlockDriverState
*bs
= NULL
;
4077 bool image_opts
= false;
4080 cache
= BDRV_DEFAULT_CACHE
;
4082 static const struct option long_options
[] = {
4083 {"help", no_argument
, 0, 'h'},
4084 {"object", required_argument
, 0, OPTION_OBJECT
},
4085 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
4086 {"force", no_argument
, 0, OPTION_FORCE
},
4089 c
= getopt_long(argc
, argv
, ":ho:f:t:pq",
4090 long_options
, NULL
);
4097 missing_argument(argv
[optind
- 1]);
4100 unrecognized_option(argv
[optind
- 1]);
4106 if (accumulate_options(&options
, optarg
) < 0) {
4108 goto out_no_progress
;
4124 user_creatable_process_cmdline(optarg
);
4126 case OPTION_IMAGE_OPTS
:
4136 error_exit("Must specify options (-o)");
4142 qemu_progress_init(progress
, 1.0);
4144 filename
= (optind
== argc
- 1) ? argv
[argc
- 1] : NULL
;
4145 if (fmt
&& has_help_option(options
)) {
4146 /* If a format is explicitly specified (and possibly no filename is
4147 * given), print option help here */
4148 ret
= print_amend_option_help(fmt
);
4152 if (optind
!= argc
- 1) {
4153 error_report("Expecting one image file name");
4158 flags
= BDRV_O_RDWR
;
4159 ret
= bdrv_parse_cache_mode(cache
, &flags
, &writethrough
);
4161 error_report("Invalid cache option: %s", cache
);
4165 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
4173 fmt
= bs
->drv
->format_name
;
4175 if (has_help_option(options
)) {
4176 /* If the format was auto-detected, print option help here */
4177 ret
= print_amend_option_help(fmt
);
4181 if (!bs
->drv
->bdrv_amend_options
) {
4182 error_report("Format driver '%s' does not support option amendment",
4188 /* Every driver supporting amendment must have amend_opts */
4189 assert(bs
->drv
->amend_opts
);
4191 amend_opts
= qemu_opts_append(amend_opts
, bs
->drv
->amend_opts
);
4192 opts
= qemu_opts_create(amend_opts
, NULL
, 0, &error_abort
);
4193 if (!qemu_opts_do_parse(opts
, options
, NULL
, &err
)) {
4194 /* Try to parse options using the create options */
4195 amend_opts
= qemu_opts_append(amend_opts
, bs
->drv
->create_opts
);
4196 qemu_opts_del(opts
);
4197 opts
= qemu_opts_create(amend_opts
, NULL
, 0, &error_abort
);
4198 if (qemu_opts_do_parse(opts
, options
, NULL
, NULL
)) {
4199 error_append_hint(&err
,
4200 "This option is only supported for image creation\n");
4203 error_report_err(err
);
4208 /* In case the driver does not call amend_status_cb() */
4209 qemu_progress_print(0.f
, 0);
4210 ret
= bdrv_amend_options(bs
, opts
, &amend_status_cb
, NULL
, force
, &err
);
4211 qemu_progress_print(100.f
, 0);
4213 error_report_err(err
);
4218 qemu_progress_end();
4222 qemu_opts_del(opts
);
4223 qemu_opts_free(amend_opts
);
4232 typedef struct BenchData
{
4234 uint64_t image_size
;
4241 bool drain_on_flush
;
4250 static void bench_undrained_flush_cb(void *opaque
, int ret
)
4253 error_report("Failed flush request: %s", strerror(-ret
));
4258 static void bench_cb(void *opaque
, int ret
)
4260 BenchData
*b
= opaque
;
4264 error_report("Failed request: %s", strerror(-ret
));
4269 /* Just finished a flush with drained queue: Start next requests */
4270 assert(b
->in_flight
== 0);
4271 b
->in_flush
= false;
4272 } else if (b
->in_flight
> 0) {
4273 int remaining
= b
->n
- b
->in_flight
;
4278 /* Time for flush? Drain queue if requested, then flush */
4279 if (b
->flush_interval
&& remaining
% b
->flush_interval
== 0) {
4280 if (!b
->in_flight
|| !b
->drain_on_flush
) {
4281 BlockCompletionFunc
*cb
;
4283 if (b
->drain_on_flush
) {
4287 cb
= bench_undrained_flush_cb
;
4290 acb
= blk_aio_flush(b
->blk
, cb
, b
);
4292 error_report("Failed to issue flush request");
4296 if (b
->drain_on_flush
) {
4302 while (b
->n
> b
->in_flight
&& b
->in_flight
< b
->nrreq
) {
4303 int64_t offset
= b
->offset
;
4304 /* blk_aio_* might look for completed I/Os and kick bench_cb
4305 * again, so make sure this operation is counted by in_flight
4306 * and b->offset is ready for the next submission.
4309 b
->offset
+= b
->step
;
4310 b
->offset
%= b
->image_size
;
4312 acb
= blk_aio_pwritev(b
->blk
, offset
, b
->qiov
, 0, bench_cb
, b
);
4314 acb
= blk_aio_preadv(b
->blk
, offset
, b
->qiov
, 0, bench_cb
, b
);
4317 error_report("Failed to issue request");
4323 static int img_bench(int argc
, char **argv
)
4326 const char *fmt
= NULL
, *filename
;
4328 bool image_opts
= false;
4329 bool is_write
= false;
4333 size_t bufsize
= 4096;
4336 int flush_interval
= 0;
4337 bool drain_on_flush
= true;
4339 BlockBackend
*blk
= NULL
;
4340 BenchData data
= {};
4342 bool writethrough
= false;
4343 struct timeval t1
, t2
;
4345 bool force_share
= false;
4349 static const struct option long_options
[] = {
4350 {"help", no_argument
, 0, 'h'},
4351 {"flush-interval", required_argument
, 0, OPTION_FLUSH_INTERVAL
},
4352 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
4353 {"pattern", required_argument
, 0, OPTION_PATTERN
},
4354 {"no-drain", no_argument
, 0, OPTION_NO_DRAIN
},
4355 {"force-share", no_argument
, 0, 'U'},
4358 c
= getopt_long(argc
, argv
, ":hc:d:f:ni:o:qs:S:t:wU", long_options
,
4366 missing_argument(argv
[optind
- 1]);
4369 unrecognized_option(argv
[optind
- 1]);
4378 if (qemu_strtoul(optarg
, NULL
, 0, &res
) < 0 || res
> INT_MAX
) {
4379 error_report("Invalid request count specified");
4389 if (qemu_strtoul(optarg
, NULL
, 0, &res
) < 0 || res
> INT_MAX
) {
4390 error_report("Invalid queue depth specified");
4400 flags
|= BDRV_O_NATIVE_AIO
;
4403 ret
= bdrv_parse_aio(optarg
, &flags
);
4405 error_report("Invalid aio option: %s", optarg
);
4412 offset
= cvtnum("offset", optarg
);
4426 sval
= cvtnum_full("buffer size", optarg
, 0, INT_MAX
);
4438 sval
= cvtnum_full("step_size", optarg
, 0, INT_MAX
);
4447 ret
= bdrv_parse_cache_mode(optarg
, &flags
, &writethrough
);
4449 error_report("Invalid cache mode");
4455 flags
|= BDRV_O_RDWR
;
4461 case OPTION_PATTERN
:
4465 if (qemu_strtoul(optarg
, NULL
, 0, &res
) < 0 || res
> 0xff) {
4466 error_report("Invalid pattern byte specified");
4472 case OPTION_FLUSH_INTERVAL
:
4476 if (qemu_strtoul(optarg
, NULL
, 0, &res
) < 0 || res
> INT_MAX
) {
4477 error_report("Invalid flush interval specified");
4480 flush_interval
= res
;
4483 case OPTION_NO_DRAIN
:
4484 drain_on_flush
= false;
4486 case OPTION_IMAGE_OPTS
:
4492 if (optind
!= argc
- 1) {
4493 error_exit("Expecting one image file name");
4495 filename
= argv
[argc
- 1];
4497 if (!is_write
&& flush_interval
) {
4498 error_report("--flush-interval is only available in write tests");
4502 if (flush_interval
&& flush_interval
< depth
) {
4503 error_report("Flush interval can't be smaller than depth");
4508 blk
= img_open(image_opts
, filename
, fmt
, flags
, writethrough
, quiet
,
4515 image_size
= blk_getlength(blk
);
4516 if (image_size
< 0) {
4521 data
= (BenchData
) {
4523 .image_size
= image_size
,
4525 .step
= step
?: bufsize
,
4530 .flush_interval
= flush_interval
,
4531 .drain_on_flush
= drain_on_flush
,
4533 printf("Sending %d %s requests, %d bytes each, %d in parallel "
4534 "(starting at offset %" PRId64
", step size %d)\n",
4535 data
.n
, data
.write
? "write" : "read", data
.bufsize
, data
.nrreq
,
4536 data
.offset
, data
.step
);
4537 if (flush_interval
) {
4538 printf("Sending flush every %d requests\n", flush_interval
);
4541 buf_size
= data
.nrreq
* data
.bufsize
;
4542 data
.buf
= blk_blockalign(blk
, buf_size
);
4543 memset(data
.buf
, pattern
, data
.nrreq
* data
.bufsize
);
4545 blk_register_buf(blk
, data
.buf
, buf_size
);
4547 data
.qiov
= g_new(QEMUIOVector
, data
.nrreq
);
4548 for (i
= 0; i
< data
.nrreq
; i
++) {
4549 qemu_iovec_init(&data
.qiov
[i
], 1);
4550 qemu_iovec_add(&data
.qiov
[i
],
4551 data
.buf
+ i
* data
.bufsize
, data
.bufsize
);
4554 gettimeofday(&t1
, NULL
);
4557 while (data
.n
> 0) {
4558 main_loop_wait(false);
4560 gettimeofday(&t2
, NULL
);
4562 printf("Run completed in %3.3f seconds.\n",
4563 (t2
.tv_sec
- t1
.tv_sec
)
4564 + ((double)(t2
.tv_usec
- t1
.tv_usec
) / 1000000));
4568 blk_unregister_buf(blk
, data
.buf
);
4570 qemu_vfree(data
.buf
);
4587 typedef struct ImgBitmapAction
{
4588 enum ImgBitmapAct act
;
4589 const char *src
; /* only used for merge */
4590 QSIMPLEQ_ENTRY(ImgBitmapAction
) next
;
4593 static int img_bitmap(int argc
, char **argv
)
4597 QemuOpts
*opts
= NULL
;
4598 const char *fmt
= NULL
, *src_fmt
= NULL
, *src_filename
= NULL
;
4599 const char *filename
, *bitmap
;
4600 BlockBackend
*blk
= NULL
, *src
= NULL
;
4601 BlockDriverState
*bs
= NULL
, *src_bs
= NULL
;
4602 bool image_opts
= false;
4603 int64_t granularity
= 0;
4604 bool add
= false, merge
= false;
4605 QSIMPLEQ_HEAD(, ImgBitmapAction
) actions
;
4606 ImgBitmapAction
*act
, *act_next
;
4609 QSIMPLEQ_INIT(&actions
);
4612 static const struct option long_options
[] = {
4613 {"help", no_argument
, 0, 'h'},
4614 {"object", required_argument
, 0, OPTION_OBJECT
},
4615 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
4616 {"add", no_argument
, 0, OPTION_ADD
},
4617 {"remove", no_argument
, 0, OPTION_REMOVE
},
4618 {"clear", no_argument
, 0, OPTION_CLEAR
},
4619 {"enable", no_argument
, 0, OPTION_ENABLE
},
4620 {"disable", no_argument
, 0, OPTION_DISABLE
},
4621 {"merge", required_argument
, 0, OPTION_MERGE
},
4622 {"granularity", required_argument
, 0, 'g'},
4623 {"source-file", required_argument
, 0, 'b'},
4624 {"source-format", required_argument
, 0, 'F'},
4627 c
= getopt_long(argc
, argv
, ":b:f:F:g:h", long_options
, NULL
);
4634 missing_argument(argv
[optind
- 1]);
4637 unrecognized_option(argv
[optind
- 1]);
4643 src_filename
= optarg
;
4652 granularity
= cvtnum("granularity", optarg
);
4653 if (granularity
< 0) {
4658 act
= g_new0(ImgBitmapAction
, 1);
4659 act
->act
= BITMAP_ADD
;
4660 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4664 act
= g_new0(ImgBitmapAction
, 1);
4665 act
->act
= BITMAP_REMOVE
;
4666 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4669 act
= g_new0(ImgBitmapAction
, 1);
4670 act
->act
= BITMAP_CLEAR
;
4671 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4674 act
= g_new0(ImgBitmapAction
, 1);
4675 act
->act
= BITMAP_ENABLE
;
4676 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4678 case OPTION_DISABLE
:
4679 act
= g_new0(ImgBitmapAction
, 1);
4680 act
->act
= BITMAP_DISABLE
;
4681 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4684 act
= g_new0(ImgBitmapAction
, 1);
4685 act
->act
= BITMAP_MERGE
;
4687 QSIMPLEQ_INSERT_TAIL(&actions
, act
, next
);
4691 user_creatable_process_cmdline(optarg
);
4693 case OPTION_IMAGE_OPTS
:
4699 if (QSIMPLEQ_EMPTY(&actions
)) {
4700 error_report("Need at least one of --add, --remove, --clear, "
4701 "--enable, --disable, or --merge");
4705 if (granularity
&& !add
) {
4706 error_report("granularity only supported with --add");
4709 if (src_fmt
&& !src_filename
) {
4710 error_report("-F only supported with -b");
4713 if (src_filename
&& !merge
) {
4714 error_report("Merge bitmap source file only supported with "
4719 if (optind
!= argc
- 2) {
4720 error_report("Expecting filename and bitmap name");
4724 filename
= argv
[optind
];
4725 bitmap
= argv
[optind
+ 1];
4728 * No need to open backing chains; we will be manipulating bitmaps
4729 * directly in this image without reference to image contents.
4731 blk
= img_open(image_opts
, filename
, fmt
, BDRV_O_RDWR
| BDRV_O_NO_BACKING
,
4732 false, false, false);
4738 src
= img_open(false, src_filename
, src_fmt
, BDRV_O_NO_BACKING
,
4739 false, false, false);
4743 src_bs
= blk_bs(src
);
4748 QSIMPLEQ_FOREACH_SAFE(act
, &actions
, next
, act_next
) {
4751 qmp_block_dirty_bitmap_add(bs
->node_name
, bitmap
,
4752 !!granularity
, granularity
, true, true,
4753 false, false, &err
);
4757 qmp_block_dirty_bitmap_remove(bs
->node_name
, bitmap
, &err
);
4761 qmp_block_dirty_bitmap_clear(bs
->node_name
, bitmap
, &err
);
4765 qmp_block_dirty_bitmap_enable(bs
->node_name
, bitmap
, &err
);
4768 case BITMAP_DISABLE
:
4769 qmp_block_dirty_bitmap_disable(bs
->node_name
, bitmap
, &err
);
4773 do_dirty_bitmap_merge(bs
->node_name
, bitmap
, src_bs
->node_name
,
4778 g_assert_not_reached();
4782 error_reportf_err(err
, "Operation %s on bitmap %s failed: ",
4794 qemu_opts_del(opts
);
4810 int bsz
; /* Block size */
4818 int (*f
)(const char *, struct DdIo
*, struct DdIo
*, struct DdInfo
*);
4822 static int img_dd_bs(const char *arg
,
4823 struct DdIo
*in
, struct DdIo
*out
,
4828 res
= cvtnum_full("bs", arg
, 1, INT_MAX
);
4833 in
->bsz
= out
->bsz
= res
;
4838 static int img_dd_count(const char *arg
,
4839 struct DdIo
*in
, struct DdIo
*out
,
4842 dd
->count
= cvtnum("count", arg
);
4844 if (dd
->count
< 0) {
4851 static int img_dd_if(const char *arg
,
4852 struct DdIo
*in
, struct DdIo
*out
,
4855 in
->filename
= g_strdup(arg
);
4860 static int img_dd_of(const char *arg
,
4861 struct DdIo
*in
, struct DdIo
*out
,
4864 out
->filename
= g_strdup(arg
);
4869 static int img_dd_skip(const char *arg
,
4870 struct DdIo
*in
, struct DdIo
*out
,
4873 in
->offset
= cvtnum("skip", arg
);
4875 if (in
->offset
< 0) {
4882 static int img_dd(int argc
, char **argv
)
4887 BlockDriver
*drv
= NULL
, *proto_drv
= NULL
;
4888 BlockBackend
*blk1
= NULL
, *blk2
= NULL
;
4889 QemuOpts
*opts
= NULL
;
4890 QemuOptsList
*create_opts
= NULL
;
4891 Error
*local_err
= NULL
;
4892 bool image_opts
= false;
4894 const char *out_fmt
= "raw";
4895 const char *fmt
= NULL
;
4897 int64_t block_count
= 0, out_pos
, in_pos
;
4898 bool force_share
= false;
4899 struct DdInfo dd
= {
4904 .bsz
= 512, /* Block size is by default 512 bytes */
4916 const struct DdOpts options
[] = {
4917 { "bs", img_dd_bs
, C_BS
},
4918 { "count", img_dd_count
, C_COUNT
},
4919 { "if", img_dd_if
, C_IF
},
4920 { "of", img_dd_of
, C_OF
},
4921 { "skip", img_dd_skip
, C_SKIP
},
4924 const struct option long_options
[] = {
4925 { "help", no_argument
, 0, 'h'},
4926 { "object", required_argument
, 0, OPTION_OBJECT
},
4927 { "image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
4928 { "force-share", no_argument
, 0, 'U'},
4932 while ((c
= getopt_long(argc
, argv
, ":hf:O:U", long_options
, NULL
))) {
4944 missing_argument(argv
[optind
- 1]);
4947 unrecognized_option(argv
[optind
- 1]);
4956 user_creatable_process_cmdline(optarg
);
4958 case OPTION_IMAGE_OPTS
:
4964 for (i
= optind
; i
< argc
; i
++) {
4966 arg
= g_strdup(argv
[i
]);
4968 tmp
= strchr(arg
, '=');
4970 error_report("unrecognized operand %s", arg
);
4977 for (j
= 0; options
[j
].name
!= NULL
; j
++) {
4978 if (!strcmp(arg
, options
[j
].name
)) {
4982 if (options
[j
].name
== NULL
) {
4983 error_report("unrecognized operand %s", arg
);
4988 if (options
[j
].f(tmp
, &in
, &out
, &dd
) != 0) {
4992 dd
.flags
|= options
[j
].flag
;
4997 if (!(dd
.flags
& C_IF
&& dd
.flags
& C_OF
)) {
4998 error_report("Must specify both input and output files");
5003 blk1
= img_open(image_opts
, in
.filename
, fmt
, 0, false, false,
5011 drv
= bdrv_find_format(out_fmt
);
5013 error_report("Unknown file format");
5017 proto_drv
= bdrv_find_protocol(out
.filename
, true, &local_err
);
5020 error_report_err(local_err
);
5024 if (!drv
->create_opts
) {
5025 error_report("Format driver '%s' does not support image creation",
5030 if (!proto_drv
->create_opts
) {
5031 error_report("Protocol driver '%s' does not support image creation",
5032 proto_drv
->format_name
);
5036 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5037 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5039 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5041 size
= blk_getlength(blk1
);
5043 error_report("Failed to get size for '%s'", in
.filename
);
5048 if (dd
.flags
& C_COUNT
&& dd
.count
<= INT64_MAX
/ in
.bsz
&&
5049 dd
.count
* in
.bsz
< size
) {
5050 size
= dd
.count
* in
.bsz
;
5053 /* Overflow means the specified offset is beyond input image's size */
5054 if (dd
.flags
& C_SKIP
&& (in
.offset
> INT64_MAX
/ in
.bsz
||
5055 size
< in
.bsz
* in
.offset
)) {
5056 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, 0, &error_abort
);
5058 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
5059 size
- in
.bsz
* in
.offset
, &error_abort
);
5062 ret
= bdrv_create(drv
, out
.filename
, opts
, &local_err
);
5064 error_reportf_err(local_err
,
5065 "%s: error while creating output image: ",
5071 /* TODO, we can't honour --image-opts for the target,
5072 * since it needs to be given in a format compatible
5073 * with the bdrv_create() call above which does not
5074 * support image-opts style.
5076 blk2
= img_open_file(out
.filename
, NULL
, out_fmt
, BDRV_O_RDWR
,
5077 false, false, false);
5084 if (dd
.flags
& C_SKIP
&& (in
.offset
> INT64_MAX
/ in
.bsz
||
5085 size
< in
.offset
* in
.bsz
)) {
5086 /* We give a warning if the skip option is bigger than the input
5087 * size and create an empty output disk image (i.e. like dd(1)).
5089 error_report("%s: cannot skip to specified offset", in
.filename
);
5092 in_pos
= in
.offset
* in
.bsz
;
5095 in
.buf
= g_new(uint8_t, in
.bsz
);
5097 for (out_pos
= 0; in_pos
< size
; block_count
++) {
5098 int in_ret
, out_ret
;
5100 if (in_pos
+ in
.bsz
> size
) {
5101 in_ret
= blk_pread(blk1
, in_pos
, in
.buf
, size
- in_pos
);
5103 in_ret
= blk_pread(blk1
, in_pos
, in
.buf
, in
.bsz
);
5106 error_report("error while reading from input image file: %s",
5113 out_ret
= blk_pwrite(blk2
, out_pos
, in
.buf
, in_ret
, 0);
5116 error_report("error while writing to output image file: %s",
5117 strerror(-out_ret
));
5126 qemu_opts_del(opts
);
5127 qemu_opts_free(create_opts
);
5130 g_free(in
.filename
);
5131 g_free(out
.filename
);
5141 static void dump_json_block_measure_info(BlockMeasureInfo
*info
)
5145 Visitor
*v
= qobject_output_visitor_new(&obj
);
5147 visit_type_BlockMeasureInfo(v
, NULL
, &info
, &error_abort
);
5148 visit_complete(v
, &obj
);
5149 str
= qobject_to_json_pretty(obj
, true);
5150 assert(str
!= NULL
);
5151 printf("%s\n", str
->str
);
5154 g_string_free(str
, true);
5157 static int img_measure(int argc
, char **argv
)
5159 static const struct option long_options
[] = {
5160 {"help", no_argument
, 0, 'h'},
5161 {"image-opts", no_argument
, 0, OPTION_IMAGE_OPTS
},
5162 {"object", required_argument
, 0, OPTION_OBJECT
},
5163 {"output", required_argument
, 0, OPTION_OUTPUT
},
5164 {"size", required_argument
, 0, OPTION_SIZE
},
5165 {"force-share", no_argument
, 0, 'U'},
5168 OutputFormat output_format
= OFORMAT_HUMAN
;
5169 BlockBackend
*in_blk
= NULL
;
5171 const char *filename
= NULL
;
5172 const char *fmt
= NULL
;
5173 const char *out_fmt
= "raw";
5174 char *options
= NULL
;
5175 char *snapshot_name
= NULL
;
5176 bool force_share
= false;
5177 QemuOpts
*opts
= NULL
;
5178 QemuOpts
*object_opts
= NULL
;
5179 QemuOpts
*sn_opts
= NULL
;
5180 QemuOptsList
*create_opts
= NULL
;
5181 bool image_opts
= false;
5182 uint64_t img_size
= UINT64_MAX
;
5183 BlockMeasureInfo
*info
= NULL
;
5184 Error
*local_err
= NULL
;
5188 while ((c
= getopt_long(argc
, argv
, "hf:O:o:l:U",
5189 long_options
, NULL
)) != -1) {
5202 if (accumulate_options(&options
, optarg
) < 0) {
5207 if (strstart(optarg
, SNAPSHOT_OPT_BASE
, NULL
)) {
5208 sn_opts
= qemu_opts_parse_noisily(&internal_snapshot_opts
,
5211 error_report("Failed in parsing snapshot param '%s'",
5216 snapshot_name
= optarg
;
5223 user_creatable_process_cmdline(optarg
);
5225 case OPTION_IMAGE_OPTS
:
5229 if (!strcmp(optarg
, "json")) {
5230 output_format
= OFORMAT_JSON
;
5231 } else if (!strcmp(optarg
, "human")) {
5232 output_format
= OFORMAT_HUMAN
;
5234 error_report("--output must be used with human or json "
5243 sval
= cvtnum("image size", optarg
);
5247 img_size
= (uint64_t)sval
;
5253 if (argc
- optind
> 1) {
5254 error_report("At most one filename argument is allowed.");
5256 } else if (argc
- optind
== 1) {
5257 filename
= argv
[optind
];
5260 if (!filename
&& (image_opts
|| fmt
|| snapshot_name
|| sn_opts
)) {
5261 error_report("--image-opts, -f, and -l require a filename argument.");
5264 if (filename
&& img_size
!= UINT64_MAX
) {
5265 error_report("--size N cannot be used together with a filename.");
5268 if (!filename
&& img_size
== UINT64_MAX
) {
5269 error_report("Either --size N or one filename must be specified.");
5274 in_blk
= img_open(image_opts
, filename
, fmt
, 0,
5275 false, false, force_share
);
5281 bdrv_snapshot_load_tmp(blk_bs(in_blk
),
5282 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_ID
),
5283 qemu_opt_get(sn_opts
, SNAPSHOT_OPT_NAME
),
5285 } else if (snapshot_name
!= NULL
) {
5286 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk
),
5287 snapshot_name
, &local_err
);
5290 error_reportf_err(local_err
, "Failed to load snapshot: ");
5295 drv
= bdrv_find_format(out_fmt
);
5297 error_report("Unknown file format '%s'", out_fmt
);
5300 if (!drv
->create_opts
) {
5301 error_report("Format driver '%s' does not support image creation",
5306 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5307 create_opts
= qemu_opts_append(create_opts
, bdrv_file
.create_opts
);
5308 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5310 if (!qemu_opts_do_parse(opts
, options
, NULL
, &local_err
)) {
5311 error_report_err(local_err
);
5312 error_report("Invalid options for file format '%s'", out_fmt
);
5316 if (img_size
!= UINT64_MAX
) {
5317 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
5320 info
= bdrv_measure(drv
, opts
, in_blk
? blk_bs(in_blk
) : NULL
, &local_err
);
5322 error_report_err(local_err
);
5326 if (output_format
== OFORMAT_HUMAN
) {
5327 printf("required size: %" PRIu64
"\n", info
->required
);
5328 printf("fully allocated size: %" PRIu64
"\n", info
->fully_allocated
);
5329 if (info
->has_bitmaps
) {
5330 printf("bitmaps size: %" PRIu64
"\n", info
->bitmaps
);
5333 dump_json_block_measure_info(info
);
5339 qapi_free_BlockMeasureInfo(info
);
5340 qemu_opts_del(object_opts
);
5341 qemu_opts_del(opts
);
5342 qemu_opts_del(sn_opts
);
5343 qemu_opts_free(create_opts
);
5349 static const img_cmd_t img_cmds
[] = {
5350 #define DEF(option, callback, arg_string) \
5351 { option, callback },
5352 #include "qemu-img-cmds.h"
5357 int main(int argc
, char **argv
)
5359 const img_cmd_t
*cmd
;
5360 const char *cmdname
;
5362 static const struct option long_options
[] = {
5363 {"help", no_argument
, 0, 'h'},
5364 {"version", no_argument
, 0, 'V'},
5365 {"trace", required_argument
, NULL
, 'T'},
5370 signal(SIGPIPE
, SIG_IGN
);
5374 error_init(argv
[0]);
5375 module_call_init(MODULE_INIT_TRACE
);
5376 qemu_init_exec_dir(argv
[0]);
5378 qemu_init_main_loop(&error_fatal
);
5380 qcrypto_init(&error_fatal
);
5382 module_call_init(MODULE_INIT_QOM
);
5385 error_exit("Not enough arguments");
5388 qemu_add_opts(&qemu_source_opts
);
5389 qemu_add_opts(&qemu_trace_opts
);
5391 while ((c
= getopt_long(argc
, argv
, "+:hVT:", long_options
, NULL
)) != -1) {
5394 missing_argument(argv
[optind
- 1]);
5397 unrecognized_option(argv
[optind
- 1]);
5403 printf(QEMU_IMG_VERSION
);
5406 trace_opt_parse(optarg
);
5411 cmdname
= argv
[optind
];
5413 /* reset getopt_long scanning */
5419 qemu_reset_optind();
5421 if (!trace_init_backends()) {
5425 qemu_set_log(LOG_TRACE
);
5427 /* find the command */
5428 for (cmd
= img_cmds
; cmd
->name
!= NULL
; cmd
++) {
5429 if (!strcmp(cmdname
, cmd
->name
)) {
5430 return cmd
->handler(argc
, argv
);
5435 error_exit("Command not found: %s", cmdname
);