iothread: provide helpers for internal use
[qemu/ar7.git] / qemu-img.c
blobd6007b2a6dc1ad61ab7c300f5f05962c3cda2a30
1 /*
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
22 * THE SOFTWARE.
24 #include "qemu/osdep.h"
25 #include <getopt.h>
27 #include "qemu-version.h"
28 #include "qapi/error.h"
29 #include "qapi-visit.h"
30 #include "qapi/qobject-output-visitor.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qjson.h"
33 #include "qapi/qmp/qbool.h"
34 #include "qemu/cutils.h"
35 #include "qemu/config-file.h"
36 #include "qemu/option.h"
37 #include "qemu/error-report.h"
38 #include "qemu/log.h"
39 #include "qom/object_interfaces.h"
40 #include "sysemu/sysemu.h"
41 #include "sysemu/block-backend.h"
42 #include "block/block_int.h"
43 #include "block/blockjob.h"
44 #include "block/qapi.h"
45 #include "crypto/init.h"
46 #include "trace/control.h"
48 #define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
49 "\n" QEMU_COPYRIGHT "\n"
51 typedef struct img_cmd_t {
52 const char *name;
53 int (*handler)(int argc, char **argv);
54 } img_cmd_t;
56 enum {
57 OPTION_OUTPUT = 256,
58 OPTION_BACKING_CHAIN = 257,
59 OPTION_OBJECT = 258,
60 OPTION_IMAGE_OPTS = 259,
61 OPTION_PATTERN = 260,
62 OPTION_FLUSH_INTERVAL = 261,
63 OPTION_NO_DRAIN = 262,
64 OPTION_TARGET_IMAGE_OPTS = 263,
65 OPTION_SIZE = 264,
66 OPTION_PREALLOCATION = 265,
67 OPTION_SHRINK = 266,
70 typedef enum OutputFormat {
71 OFORMAT_JSON,
72 OFORMAT_HUMAN,
73 } OutputFormat;
75 /* Default to cache=writeback as data integrity is not important for qemu-img */
76 #define BDRV_DEFAULT_CACHE "writeback"
78 static void format_print(void *opaque, const char *name)
80 printf(" %s", name);
83 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
85 va_list ap;
87 error_printf("qemu-img: ");
89 va_start(ap, fmt);
90 error_vprintf(fmt, ap);
91 va_end(ap);
93 error_printf("\nTry 'qemu-img --help' for more information\n");
94 exit(EXIT_FAILURE);
97 static void QEMU_NORETURN missing_argument(const char *option)
99 error_exit("missing argument for option '%s'", option);
102 static void QEMU_NORETURN unrecognized_option(const char *option)
104 error_exit("unrecognized option '%s'", option);
107 /* Please keep in synch with qemu-img.texi */
108 static void QEMU_NORETURN help(void)
110 const char *help_msg =
111 QEMU_IMG_VERSION
112 "usage: qemu-img [standard options] command [command options]\n"
113 "QEMU disk image utility\n"
114 "\n"
115 " '-h', '--help' display this help and exit\n"
116 " '-V', '--version' output version information and exit\n"
117 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
118 " specify tracing options\n"
119 "\n"
120 "Command syntax:\n"
121 #define DEF(option, callback, arg_string) \
122 " " arg_string "\n"
123 #include "qemu-img-cmds.h"
124 #undef DEF
125 #undef GEN_DOCS
126 "\n"
127 "Command parameters:\n"
128 " 'filename' is a disk image filename\n"
129 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
130 " manual page for a description of the object properties. The most common\n"
131 " object type is a 'secret', which is used to supply passwords and/or\n"
132 " encryption keys.\n"
133 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
134 " 'cache' is the cache mode used to write the output disk image, the valid\n"
135 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
136 " 'directsync' and 'unsafe' (default for convert)\n"
137 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
138 " options are the same as for the 'cache' option\n"
139 " 'size' is the disk image size in bytes. Optional suffixes\n"
140 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
141 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
142 " supported. 'b' is ignored.\n"
143 " 'output_filename' is the destination disk image filename\n"
144 " 'output_fmt' is the destination format\n"
145 " 'options' is a comma separated list of format specific options in a\n"
146 " name=value format. Use -o ? for an overview of the options supported by the\n"
147 " used format\n"
148 " 'snapshot_param' is param used for internal snapshot, format\n"
149 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
150 " '[ID_OR_NAME]'\n"
151 " 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
152 " instead\n"
153 " '-c' indicates that target image must be compressed (qcow format only)\n"
154 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
155 " new backing file match exactly. The image doesn't need a working\n"
156 " backing file before rebasing in this case (useful for renaming the\n"
157 " backing file). For image creation, allow creating without attempting\n"
158 " to open the backing file.\n"
159 " '-h' with or without a command shows this help and lists the supported formats\n"
160 " '-p' show progress of command (only certain commands)\n"
161 " '-q' use Quiet mode - do not print any output (except errors)\n"
162 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
163 " contain only zeros for qemu-img to create a sparse image during\n"
164 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
165 " unallocated or zero sectors, and the destination image will always be\n"
166 " fully allocated\n"
167 " '--output' takes the format in which the output must be done (human or json)\n"
168 " '-n' skips the target volume creation (useful if the volume is created\n"
169 " prior to running qemu-img)\n"
170 "\n"
171 "Parameters to check subcommand:\n"
172 " '-r' tries to repair any inconsistencies that are found during the check.\n"
173 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
174 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
175 " hiding corruption that has already occurred.\n"
176 "\n"
177 "Parameters to convert subcommand:\n"
178 " '-m' specifies how many coroutines work in parallel during the convert\n"
179 " process (defaults to 8)\n"
180 " '-W' allow to write to the target out of order rather than sequential\n"
181 "\n"
182 "Parameters to snapshot subcommand:\n"
183 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
184 " '-a' applies a snapshot (revert disk to saved state)\n"
185 " '-c' creates a snapshot\n"
186 " '-d' deletes a snapshot\n"
187 " '-l' lists all snapshots in the given image\n"
188 "\n"
189 "Parameters to compare subcommand:\n"
190 " '-f' first image format\n"
191 " '-F' second image format\n"
192 " '-s' run in Strict mode - fail on different image size or sector allocation\n"
193 "\n"
194 "Parameters to dd subcommand:\n"
195 " 'bs=BYTES' read and write up to BYTES bytes at a time "
196 "(default: 512)\n"
197 " 'count=N' copy only N input blocks\n"
198 " 'if=FILE' read from FILE\n"
199 " 'of=FILE' write to FILE\n"
200 " 'skip=N' skip N bs-sized blocks at the start of input\n";
202 printf("%s\nSupported formats:", help_msg);
203 bdrv_iterate_format(format_print, NULL);
204 printf("\n\n" QEMU_HELP_BOTTOM "\n");
205 exit(EXIT_SUCCESS);
208 static QemuOptsList qemu_object_opts = {
209 .name = "object",
210 .implied_opt_name = "qom-type",
211 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
212 .desc = {
217 static QemuOptsList qemu_source_opts = {
218 .name = "source",
219 .implied_opt_name = "file",
220 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
221 .desc = {
226 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
228 int ret = 0;
229 if (!quiet) {
230 va_list args;
231 va_start(args, fmt);
232 ret = vprintf(fmt, args);
233 va_end(args);
235 return ret;
239 static int print_block_option_help(const char *filename, const char *fmt)
241 BlockDriver *drv, *proto_drv;
242 QemuOptsList *create_opts = NULL;
243 Error *local_err = NULL;
245 /* Find driver and parse its options */
246 drv = bdrv_find_format(fmt);
247 if (!drv) {
248 error_report("Unknown file format '%s'", fmt);
249 return 1;
252 create_opts = qemu_opts_append(create_opts, drv->create_opts);
253 if (filename) {
254 proto_drv = bdrv_find_protocol(filename, true, &local_err);
255 if (!proto_drv) {
256 error_report_err(local_err);
257 qemu_opts_free(create_opts);
258 return 1;
260 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
263 qemu_opts_print_help(create_opts);
264 qemu_opts_free(create_opts);
265 return 0;
269 static BlockBackend *img_open_opts(const char *optstr,
270 QemuOpts *opts, int flags, bool writethrough,
271 bool quiet, bool force_share)
273 QDict *options;
274 Error *local_err = NULL;
275 BlockBackend *blk;
276 options = qemu_opts_to_qdict(opts, NULL);
277 if (force_share) {
278 if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
279 && !qdict_get_bool(options, BDRV_OPT_FORCE_SHARE)) {
280 error_report("--force-share/-U conflicts with image options");
281 QDECREF(options);
282 return NULL;
284 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
286 blk = blk_new_open(NULL, NULL, options, flags, &local_err);
287 if (!blk) {
288 error_reportf_err(local_err, "Could not open '%s': ", optstr);
289 return NULL;
291 blk_set_enable_write_cache(blk, !writethrough);
293 return blk;
296 static BlockBackend *img_open_file(const char *filename,
297 QDict *options,
298 const char *fmt, int flags,
299 bool writethrough, bool quiet,
300 bool force_share)
302 BlockBackend *blk;
303 Error *local_err = NULL;
305 if (!options) {
306 options = qdict_new();
308 if (fmt) {
309 qdict_put_str(options, "driver", fmt);
312 if (force_share) {
313 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
315 blk = blk_new_open(filename, NULL, options, flags, &local_err);
316 if (!blk) {
317 error_reportf_err(local_err, "Could not open '%s': ", filename);
318 return NULL;
320 blk_set_enable_write_cache(blk, !writethrough);
322 return blk;
326 static int img_add_key_secrets(void *opaque,
327 const char *name, const char *value,
328 Error **errp)
330 QDict *options = opaque;
332 if (g_str_has_suffix(name, "key-secret")) {
333 qdict_put_str(options, name, value);
336 return 0;
339 static BlockBackend *img_open_new_file(const char *filename,
340 QemuOpts *create_opts,
341 const char *fmt, int flags,
342 bool writethrough, bool quiet,
343 bool force_share)
345 QDict *options = NULL;
347 options = qdict_new();
348 qemu_opt_foreach(create_opts, img_add_key_secrets, options, &error_abort);
350 return img_open_file(filename, options, fmt, flags, writethrough, quiet,
351 force_share);
355 static BlockBackend *img_open(bool image_opts,
356 const char *filename,
357 const char *fmt, int flags, bool writethrough,
358 bool quiet, bool force_share)
360 BlockBackend *blk;
361 if (image_opts) {
362 QemuOpts *opts;
363 if (fmt) {
364 error_report("--image-opts and --format are mutually exclusive");
365 return NULL;
367 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
368 filename, true);
369 if (!opts) {
370 return NULL;
372 blk = img_open_opts(filename, opts, flags, writethrough, quiet,
373 force_share);
374 } else {
375 blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
376 force_share);
378 return blk;
382 static int add_old_style_options(const char *fmt, QemuOpts *opts,
383 const char *base_filename,
384 const char *base_fmt)
386 Error *err = NULL;
388 if (base_filename) {
389 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
390 if (err) {
391 error_report("Backing file not supported for file format '%s'",
392 fmt);
393 error_free(err);
394 return -1;
397 if (base_fmt) {
398 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
399 if (err) {
400 error_report("Backing file format not supported for file "
401 "format '%s'", fmt);
402 error_free(err);
403 return -1;
406 return 0;
409 static int64_t cvtnum(const char *s)
411 int err;
412 uint64_t value;
414 err = qemu_strtosz(s, NULL, &value);
415 if (err < 0) {
416 return err;
418 if (value > INT64_MAX) {
419 return -ERANGE;
421 return value;
424 static int img_create(int argc, char **argv)
426 int c;
427 uint64_t img_size = -1;
428 const char *fmt = "raw";
429 const char *base_fmt = NULL;
430 const char *filename;
431 const char *base_filename = NULL;
432 char *options = NULL;
433 Error *local_err = NULL;
434 bool quiet = false;
435 int flags = 0;
437 for(;;) {
438 static const struct option long_options[] = {
439 {"help", no_argument, 0, 'h'},
440 {"object", required_argument, 0, OPTION_OBJECT},
441 {0, 0, 0, 0}
443 c = getopt_long(argc, argv, ":F:b:f:ho:qu",
444 long_options, NULL);
445 if (c == -1) {
446 break;
448 switch(c) {
449 case ':':
450 missing_argument(argv[optind - 1]);
451 break;
452 case '?':
453 unrecognized_option(argv[optind - 1]);
454 break;
455 case 'h':
456 help();
457 break;
458 case 'F':
459 base_fmt = optarg;
460 break;
461 case 'b':
462 base_filename = optarg;
463 break;
464 case 'f':
465 fmt = optarg;
466 break;
467 case 'o':
468 if (!is_valid_option_list(optarg)) {
469 error_report("Invalid option list: %s", optarg);
470 goto fail;
472 if (!options) {
473 options = g_strdup(optarg);
474 } else {
475 char *old_options = options;
476 options = g_strdup_printf("%s,%s", options, optarg);
477 g_free(old_options);
479 break;
480 case 'q':
481 quiet = true;
482 break;
483 case 'u':
484 flags |= BDRV_O_NO_BACKING;
485 break;
486 case OPTION_OBJECT: {
487 QemuOpts *opts;
488 opts = qemu_opts_parse_noisily(&qemu_object_opts,
489 optarg, true);
490 if (!opts) {
491 goto fail;
493 } break;
497 /* Get the filename */
498 filename = (optind < argc) ? argv[optind] : NULL;
499 if (options && has_help_option(options)) {
500 g_free(options);
501 return print_block_option_help(filename, fmt);
504 if (optind >= argc) {
505 error_exit("Expecting image file name");
507 optind++;
509 if (qemu_opts_foreach(&qemu_object_opts,
510 user_creatable_add_opts_foreach,
511 NULL, NULL)) {
512 goto fail;
515 /* Get image size, if specified */
516 if (optind < argc) {
517 int64_t sval;
519 sval = cvtnum(argv[optind++]);
520 if (sval < 0) {
521 if (sval == -ERANGE) {
522 error_report("Image size must be less than 8 EiB!");
523 } else {
524 error_report("Invalid image size specified! You may use k, M, "
525 "G, T, P or E suffixes for ");
526 error_report("kilobytes, megabytes, gigabytes, terabytes, "
527 "petabytes and exabytes.");
529 goto fail;
531 img_size = (uint64_t)sval;
533 if (optind != argc) {
534 error_exit("Unexpected argument: %s", argv[optind]);
537 bdrv_img_create(filename, fmt, base_filename, base_fmt,
538 options, img_size, flags, quiet, &local_err);
539 if (local_err) {
540 error_reportf_err(local_err, "%s: ", filename);
541 goto fail;
544 g_free(options);
545 return 0;
547 fail:
548 g_free(options);
549 return 1;
552 static void dump_json_image_check(ImageCheck *check, bool quiet)
554 QString *str;
555 QObject *obj;
556 Visitor *v = qobject_output_visitor_new(&obj);
558 visit_type_ImageCheck(v, NULL, &check, &error_abort);
559 visit_complete(v, &obj);
560 str = qobject_to_json_pretty(obj);
561 assert(str != NULL);
562 qprintf(quiet, "%s\n", qstring_get_str(str));
563 qobject_decref(obj);
564 visit_free(v);
565 QDECREF(str);
568 static void dump_human_image_check(ImageCheck *check, bool quiet)
570 if (!(check->corruptions || check->leaks || check->check_errors)) {
571 qprintf(quiet, "No errors were found on the image.\n");
572 } else {
573 if (check->corruptions) {
574 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
575 "Data may be corrupted, or further writes to the image "
576 "may corrupt it.\n",
577 check->corruptions);
580 if (check->leaks) {
581 qprintf(quiet,
582 "\n%" PRId64 " leaked clusters were found on the image.\n"
583 "This means waste of disk space, but no harm to data.\n",
584 check->leaks);
587 if (check->check_errors) {
588 qprintf(quiet,
589 "\n%" PRId64
590 " internal errors have occurred during the check.\n",
591 check->check_errors);
595 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
596 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
597 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
598 check->allocated_clusters, check->total_clusters,
599 check->allocated_clusters * 100.0 / check->total_clusters,
600 check->fragmented_clusters * 100.0 / check->allocated_clusters,
601 check->compressed_clusters * 100.0 /
602 check->allocated_clusters);
605 if (check->image_end_offset) {
606 qprintf(quiet,
607 "Image end offset: %" PRId64 "\n", check->image_end_offset);
611 static int collect_image_check(BlockDriverState *bs,
612 ImageCheck *check,
613 const char *filename,
614 const char *fmt,
615 int fix)
617 int ret;
618 BdrvCheckResult result;
620 ret = bdrv_check(bs, &result, fix);
621 if (ret < 0) {
622 return ret;
625 check->filename = g_strdup(filename);
626 check->format = g_strdup(bdrv_get_format_name(bs));
627 check->check_errors = result.check_errors;
628 check->corruptions = result.corruptions;
629 check->has_corruptions = result.corruptions != 0;
630 check->leaks = result.leaks;
631 check->has_leaks = result.leaks != 0;
632 check->corruptions_fixed = result.corruptions_fixed;
633 check->has_corruptions_fixed = result.corruptions != 0;
634 check->leaks_fixed = result.leaks_fixed;
635 check->has_leaks_fixed = result.leaks != 0;
636 check->image_end_offset = result.image_end_offset;
637 check->has_image_end_offset = result.image_end_offset != 0;
638 check->total_clusters = result.bfi.total_clusters;
639 check->has_total_clusters = result.bfi.total_clusters != 0;
640 check->allocated_clusters = result.bfi.allocated_clusters;
641 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
642 check->fragmented_clusters = result.bfi.fragmented_clusters;
643 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
644 check->compressed_clusters = result.bfi.compressed_clusters;
645 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
647 return 0;
651 * Checks an image for consistency. Exit codes:
653 * 0 - Check completed, image is good
654 * 1 - Check not completed because of internal errors
655 * 2 - Check completed, image is corrupted
656 * 3 - Check completed, image has leaked clusters, but is good otherwise
657 * 63 - Checks are not supported by the image format
659 static int img_check(int argc, char **argv)
661 int c, ret;
662 OutputFormat output_format = OFORMAT_HUMAN;
663 const char *filename, *fmt, *output, *cache;
664 BlockBackend *blk;
665 BlockDriverState *bs;
666 int fix = 0;
667 int flags = BDRV_O_CHECK;
668 bool writethrough;
669 ImageCheck *check;
670 bool quiet = false;
671 bool image_opts = false;
672 bool force_share = false;
674 fmt = NULL;
675 output = NULL;
676 cache = BDRV_DEFAULT_CACHE;
678 for(;;) {
679 int option_index = 0;
680 static const struct option long_options[] = {
681 {"help", no_argument, 0, 'h'},
682 {"format", required_argument, 0, 'f'},
683 {"repair", required_argument, 0, 'r'},
684 {"output", required_argument, 0, OPTION_OUTPUT},
685 {"object", required_argument, 0, OPTION_OBJECT},
686 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
687 {"force-share", no_argument, 0, 'U'},
688 {0, 0, 0, 0}
690 c = getopt_long(argc, argv, ":hf:r:T:qU",
691 long_options, &option_index);
692 if (c == -1) {
693 break;
695 switch(c) {
696 case ':':
697 missing_argument(argv[optind - 1]);
698 break;
699 case '?':
700 unrecognized_option(argv[optind - 1]);
701 break;
702 case 'h':
703 help();
704 break;
705 case 'f':
706 fmt = optarg;
707 break;
708 case 'r':
709 flags |= BDRV_O_RDWR;
711 if (!strcmp(optarg, "leaks")) {
712 fix = BDRV_FIX_LEAKS;
713 } else if (!strcmp(optarg, "all")) {
714 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
715 } else {
716 error_exit("Unknown option value for -r "
717 "(expecting 'leaks' or 'all'): %s", optarg);
719 break;
720 case OPTION_OUTPUT:
721 output = optarg;
722 break;
723 case 'T':
724 cache = optarg;
725 break;
726 case 'q':
727 quiet = true;
728 break;
729 case 'U':
730 force_share = true;
731 break;
732 case OPTION_OBJECT: {
733 QemuOpts *opts;
734 opts = qemu_opts_parse_noisily(&qemu_object_opts,
735 optarg, true);
736 if (!opts) {
737 return 1;
739 } break;
740 case OPTION_IMAGE_OPTS:
741 image_opts = true;
742 break;
745 if (optind != argc - 1) {
746 error_exit("Expecting one image file name");
748 filename = argv[optind++];
750 if (output && !strcmp(output, "json")) {
751 output_format = OFORMAT_JSON;
752 } else if (output && !strcmp(output, "human")) {
753 output_format = OFORMAT_HUMAN;
754 } else if (output) {
755 error_report("--output must be used with human or json as argument.");
756 return 1;
759 if (qemu_opts_foreach(&qemu_object_opts,
760 user_creatable_add_opts_foreach,
761 NULL, NULL)) {
762 return 1;
765 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
766 if (ret < 0) {
767 error_report("Invalid source cache option: %s", cache);
768 return 1;
771 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
772 force_share);
773 if (!blk) {
774 return 1;
776 bs = blk_bs(blk);
778 check = g_new0(ImageCheck, 1);
779 ret = collect_image_check(bs, check, filename, fmt, fix);
781 if (ret == -ENOTSUP) {
782 error_report("This image format does not support checks");
783 ret = 63;
784 goto fail;
787 if (check->corruptions_fixed || check->leaks_fixed) {
788 int corruptions_fixed, leaks_fixed;
790 leaks_fixed = check->leaks_fixed;
791 corruptions_fixed = check->corruptions_fixed;
793 if (output_format == OFORMAT_HUMAN) {
794 qprintf(quiet,
795 "The following inconsistencies were found and repaired:\n\n"
796 " %" PRId64 " leaked clusters\n"
797 " %" PRId64 " corruptions\n\n"
798 "Double checking the fixed image now...\n",
799 check->leaks_fixed,
800 check->corruptions_fixed);
803 ret = collect_image_check(bs, check, filename, fmt, 0);
805 check->leaks_fixed = leaks_fixed;
806 check->corruptions_fixed = corruptions_fixed;
809 if (!ret) {
810 switch (output_format) {
811 case OFORMAT_HUMAN:
812 dump_human_image_check(check, quiet);
813 break;
814 case OFORMAT_JSON:
815 dump_json_image_check(check, quiet);
816 break;
820 if (ret || check->check_errors) {
821 if (ret) {
822 error_report("Check failed: %s", strerror(-ret));
823 } else {
824 error_report("Check failed");
826 ret = 1;
827 goto fail;
830 if (check->corruptions) {
831 ret = 2;
832 } else if (check->leaks) {
833 ret = 3;
834 } else {
835 ret = 0;
838 fail:
839 qapi_free_ImageCheck(check);
840 blk_unref(blk);
841 return ret;
844 typedef struct CommonBlockJobCBInfo {
845 BlockDriverState *bs;
846 Error **errp;
847 } CommonBlockJobCBInfo;
849 static void common_block_job_cb(void *opaque, int ret)
851 CommonBlockJobCBInfo *cbi = opaque;
853 if (ret < 0) {
854 error_setg_errno(cbi->errp, -ret, "Block job failed");
858 static void run_block_job(BlockJob *job, Error **errp)
860 AioContext *aio_context = blk_get_aio_context(job->blk);
861 int ret = 0;
863 aio_context_acquire(aio_context);
864 block_job_ref(job);
865 do {
866 aio_poll(aio_context, true);
867 qemu_progress_print(job->len ?
868 ((float)job->offset / job->len * 100.f) : 0.0f, 0);
869 } while (!job->ready && !job->completed);
871 if (!job->completed) {
872 ret = block_job_complete_sync(job, errp);
873 } else {
874 ret = job->ret;
876 block_job_unref(job);
877 aio_context_release(aio_context);
879 /* publish completion progress only when success */
880 if (!ret) {
881 qemu_progress_print(100.f, 0);
885 static int img_commit(int argc, char **argv)
887 int c, ret, flags;
888 const char *filename, *fmt, *cache, *base;
889 BlockBackend *blk;
890 BlockDriverState *bs, *base_bs;
891 BlockJob *job;
892 bool progress = false, quiet = false, drop = false;
893 bool writethrough;
894 Error *local_err = NULL;
895 CommonBlockJobCBInfo cbi;
896 bool image_opts = false;
897 AioContext *aio_context;
899 fmt = NULL;
900 cache = BDRV_DEFAULT_CACHE;
901 base = NULL;
902 for(;;) {
903 static const struct option long_options[] = {
904 {"help", no_argument, 0, 'h'},
905 {"object", required_argument, 0, OPTION_OBJECT},
906 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
907 {0, 0, 0, 0}
909 c = getopt_long(argc, argv, ":f:ht:b:dpq",
910 long_options, NULL);
911 if (c == -1) {
912 break;
914 switch(c) {
915 case ':':
916 missing_argument(argv[optind - 1]);
917 break;
918 case '?':
919 unrecognized_option(argv[optind - 1]);
920 break;
921 case 'h':
922 help();
923 break;
924 case 'f':
925 fmt = optarg;
926 break;
927 case 't':
928 cache = optarg;
929 break;
930 case 'b':
931 base = optarg;
932 /* -b implies -d */
933 drop = true;
934 break;
935 case 'd':
936 drop = true;
937 break;
938 case 'p':
939 progress = true;
940 break;
941 case 'q':
942 quiet = true;
943 break;
944 case OPTION_OBJECT: {
945 QemuOpts *opts;
946 opts = qemu_opts_parse_noisily(&qemu_object_opts,
947 optarg, true);
948 if (!opts) {
949 return 1;
951 } break;
952 case OPTION_IMAGE_OPTS:
953 image_opts = true;
954 break;
958 /* Progress is not shown in Quiet mode */
959 if (quiet) {
960 progress = false;
963 if (optind != argc - 1) {
964 error_exit("Expecting one image file name");
966 filename = argv[optind++];
968 if (qemu_opts_foreach(&qemu_object_opts,
969 user_creatable_add_opts_foreach,
970 NULL, NULL)) {
971 return 1;
974 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
975 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
976 if (ret < 0) {
977 error_report("Invalid cache option: %s", cache);
978 return 1;
981 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
982 false);
983 if (!blk) {
984 return 1;
986 bs = blk_bs(blk);
988 qemu_progress_init(progress, 1.f);
989 qemu_progress_print(0.f, 100);
991 if (base) {
992 base_bs = bdrv_find_backing_image(bs, base);
993 if (!base_bs) {
994 error_setg(&local_err,
995 "Did not find '%s' in the backing chain of '%s'",
996 base, filename);
997 goto done;
999 } else {
1000 /* This is different from QMP, which by default uses the deepest file in
1001 * the backing chain (i.e., the very base); however, the traditional
1002 * behavior of qemu-img commit is using the immediate backing file. */
1003 base_bs = backing_bs(bs);
1004 if (!base_bs) {
1005 error_setg(&local_err, "Image does not have a backing file");
1006 goto done;
1010 cbi = (CommonBlockJobCBInfo){
1011 .errp = &local_err,
1012 .bs = bs,
1015 aio_context = bdrv_get_aio_context(bs);
1016 aio_context_acquire(aio_context);
1017 commit_active_start("commit", bs, base_bs, BLOCK_JOB_DEFAULT, 0,
1018 BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1019 &cbi, false, &local_err);
1020 aio_context_release(aio_context);
1021 if (local_err) {
1022 goto done;
1025 /* When the block job completes, the BlockBackend reference will point to
1026 * the old backing file. In order to avoid that the top image is already
1027 * deleted, so we can still empty it afterwards, increment the reference
1028 * counter here preemptively. */
1029 if (!drop) {
1030 bdrv_ref(bs);
1033 job = block_job_get("commit");
1034 run_block_job(job, &local_err);
1035 if (local_err) {
1036 goto unref_backing;
1039 if (!drop && bs->drv->bdrv_make_empty) {
1040 ret = bs->drv->bdrv_make_empty(bs);
1041 if (ret) {
1042 error_setg_errno(&local_err, -ret, "Could not empty %s",
1043 filename);
1044 goto unref_backing;
1048 unref_backing:
1049 if (!drop) {
1050 bdrv_unref(bs);
1053 done:
1054 qemu_progress_end();
1056 blk_unref(blk);
1058 if (local_err) {
1059 error_report_err(local_err);
1060 return 1;
1063 qprintf(quiet, "Image committed.\n");
1064 return 0;
1068 * Returns true iff the first sector pointed to by 'buf' contains at least
1069 * a non-NUL byte.
1071 * 'pnum' is set to the number of sectors (including and immediately following
1072 * the first one) that are known to be in the same allocated/unallocated state.
1074 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
1076 bool is_zero;
1077 int i;
1079 if (n <= 0) {
1080 *pnum = 0;
1081 return 0;
1083 is_zero = buffer_is_zero(buf, 512);
1084 for(i = 1; i < n; i++) {
1085 buf += 512;
1086 if (is_zero != buffer_is_zero(buf, 512)) {
1087 break;
1090 *pnum = i;
1091 return !is_zero;
1095 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1096 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1097 * breaking up write requests for only small sparse areas.
1099 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1100 int min)
1102 int ret;
1103 int num_checked, num_used;
1105 if (n < min) {
1106 min = n;
1109 ret = is_allocated_sectors(buf, n, pnum);
1110 if (!ret) {
1111 return ret;
1114 num_used = *pnum;
1115 buf += BDRV_SECTOR_SIZE * *pnum;
1116 n -= *pnum;
1117 num_checked = num_used;
1119 while (n > 0) {
1120 ret = is_allocated_sectors(buf, n, pnum);
1122 buf += BDRV_SECTOR_SIZE * *pnum;
1123 n -= *pnum;
1124 num_checked += *pnum;
1125 if (ret) {
1126 num_used = num_checked;
1127 } else if (*pnum >= min) {
1128 break;
1132 *pnum = num_used;
1133 return 1;
1137 * Compares two buffers sector by sector. Returns 0 if the first sector of both
1138 * buffers matches, non-zero otherwise.
1140 * pnum is set to the number of sectors (including and immediately following
1141 * the first one) that are known to have the same comparison result
1143 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
1144 int *pnum)
1146 bool res;
1147 int i;
1149 if (n <= 0) {
1150 *pnum = 0;
1151 return 0;
1154 res = !!memcmp(buf1, buf2, 512);
1155 for(i = 1; i < n; i++) {
1156 buf1 += 512;
1157 buf2 += 512;
1159 if (!!memcmp(buf1, buf2, 512) != res) {
1160 break;
1164 *pnum = i;
1165 return res;
1168 #define IO_BUF_SIZE (2 * 1024 * 1024)
1170 static int64_t sectors_to_bytes(int64_t sectors)
1172 return sectors << BDRV_SECTOR_BITS;
1175 static int64_t sectors_to_process(int64_t total, int64_t from)
1177 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
1181 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1183 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
1184 * data and negative value on error.
1186 * @param blk: BlockBackend for the image
1187 * @param sect_num: Number of first sector to check
1188 * @param sect_count: Number of sectors to check
1189 * @param filename: Name of disk file we are checking (logging purpose)
1190 * @param buffer: Allocated buffer for storing read data
1191 * @param quiet: Flag for quiet mode
1193 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
1194 int sect_count, const char *filename,
1195 uint8_t *buffer, bool quiet)
1197 int pnum, ret = 0;
1198 ret = blk_pread(blk, sect_num << BDRV_SECTOR_BITS, buffer,
1199 sect_count << BDRV_SECTOR_BITS);
1200 if (ret < 0) {
1201 error_report("Error while reading offset %" PRId64 " of %s: %s",
1202 sectors_to_bytes(sect_num), filename, strerror(-ret));
1203 return ret;
1205 ret = is_allocated_sectors(buffer, sect_count, &pnum);
1206 if (ret || pnum != sect_count) {
1207 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1208 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
1209 return 1;
1212 return 0;
1216 * Compares two images. Exit codes:
1218 * 0 - Images are identical
1219 * 1 - Images differ
1220 * >1 - Error occurred
1222 static int img_compare(int argc, char **argv)
1224 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1225 BlockBackend *blk1, *blk2;
1226 BlockDriverState *bs1, *bs2;
1227 int64_t total_sectors1, total_sectors2;
1228 uint8_t *buf1 = NULL, *buf2 = NULL;
1229 int pnum1, pnum2;
1230 int allocated1, allocated2;
1231 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1232 bool progress = false, quiet = false, strict = false;
1233 int flags;
1234 bool writethrough;
1235 int64_t total_sectors;
1236 int64_t sector_num = 0;
1237 int64_t nb_sectors;
1238 int c, pnum;
1239 uint64_t progress_base;
1240 bool image_opts = false;
1241 bool force_share = false;
1243 cache = BDRV_DEFAULT_CACHE;
1244 for (;;) {
1245 static const struct option long_options[] = {
1246 {"help", no_argument, 0, 'h'},
1247 {"object", required_argument, 0, OPTION_OBJECT},
1248 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1249 {"force-share", no_argument, 0, 'U'},
1250 {0, 0, 0, 0}
1252 c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1253 long_options, NULL);
1254 if (c == -1) {
1255 break;
1257 switch (c) {
1258 case ':':
1259 missing_argument(argv[optind - 1]);
1260 break;
1261 case '?':
1262 unrecognized_option(argv[optind - 1]);
1263 break;
1264 case 'h':
1265 help();
1266 break;
1267 case 'f':
1268 fmt1 = optarg;
1269 break;
1270 case 'F':
1271 fmt2 = optarg;
1272 break;
1273 case 'T':
1274 cache = optarg;
1275 break;
1276 case 'p':
1277 progress = true;
1278 break;
1279 case 'q':
1280 quiet = true;
1281 break;
1282 case 's':
1283 strict = true;
1284 break;
1285 case 'U':
1286 force_share = true;
1287 break;
1288 case OPTION_OBJECT: {
1289 QemuOpts *opts;
1290 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1291 optarg, true);
1292 if (!opts) {
1293 ret = 2;
1294 goto out4;
1296 } break;
1297 case OPTION_IMAGE_OPTS:
1298 image_opts = true;
1299 break;
1303 /* Progress is not shown in Quiet mode */
1304 if (quiet) {
1305 progress = false;
1309 if (optind != argc - 2) {
1310 error_exit("Expecting two image file names");
1312 filename1 = argv[optind++];
1313 filename2 = argv[optind++];
1315 if (qemu_opts_foreach(&qemu_object_opts,
1316 user_creatable_add_opts_foreach,
1317 NULL, NULL)) {
1318 ret = 2;
1319 goto out4;
1322 /* Initialize before goto out */
1323 qemu_progress_init(progress, 2.0);
1325 flags = 0;
1326 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1327 if (ret < 0) {
1328 error_report("Invalid source cache option: %s", cache);
1329 ret = 2;
1330 goto out3;
1333 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1334 force_share);
1335 if (!blk1) {
1336 ret = 2;
1337 goto out3;
1340 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1341 force_share);
1342 if (!blk2) {
1343 ret = 2;
1344 goto out2;
1346 bs1 = blk_bs(blk1);
1347 bs2 = blk_bs(blk2);
1349 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1350 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1351 total_sectors1 = blk_nb_sectors(blk1);
1352 if (total_sectors1 < 0) {
1353 error_report("Can't get size of %s: %s",
1354 filename1, strerror(-total_sectors1));
1355 ret = 4;
1356 goto out;
1358 total_sectors2 = blk_nb_sectors(blk2);
1359 if (total_sectors2 < 0) {
1360 error_report("Can't get size of %s: %s",
1361 filename2, strerror(-total_sectors2));
1362 ret = 4;
1363 goto out;
1365 total_sectors = MIN(total_sectors1, total_sectors2);
1366 progress_base = MAX(total_sectors1, total_sectors2);
1368 qemu_progress_print(0, 100);
1370 if (strict && total_sectors1 != total_sectors2) {
1371 ret = 1;
1372 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1373 goto out;
1376 for (;;) {
1377 int64_t status1, status2;
1378 BlockDriverState *file;
1380 nb_sectors = sectors_to_process(total_sectors, sector_num);
1381 if (nb_sectors <= 0) {
1382 break;
1384 status1 = bdrv_get_block_status_above(bs1, NULL, sector_num,
1385 total_sectors1 - sector_num,
1386 &pnum1, &file);
1387 if (status1 < 0) {
1388 ret = 3;
1389 error_report("Sector allocation test failed for %s", filename1);
1390 goto out;
1392 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1394 status2 = bdrv_get_block_status_above(bs2, NULL, sector_num,
1395 total_sectors2 - sector_num,
1396 &pnum2, &file);
1397 if (status2 < 0) {
1398 ret = 3;
1399 error_report("Sector allocation test failed for %s", filename2);
1400 goto out;
1402 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1403 if (pnum1) {
1404 nb_sectors = MIN(nb_sectors, pnum1);
1406 if (pnum2) {
1407 nb_sectors = MIN(nb_sectors, pnum2);
1410 if (strict) {
1411 if ((status1 & ~BDRV_BLOCK_OFFSET_MASK) !=
1412 (status2 & ~BDRV_BLOCK_OFFSET_MASK)) {
1413 ret = 1;
1414 qprintf(quiet, "Strict mode: Offset %" PRId64
1415 " block status mismatch!\n",
1416 sectors_to_bytes(sector_num));
1417 goto out;
1420 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1421 nb_sectors = MIN(pnum1, pnum2);
1422 } else if (allocated1 == allocated2) {
1423 if (allocated1) {
1424 ret = blk_pread(blk1, sector_num << BDRV_SECTOR_BITS, buf1,
1425 nb_sectors << BDRV_SECTOR_BITS);
1426 if (ret < 0) {
1427 error_report("Error while reading offset %" PRId64 " of %s:"
1428 " %s", sectors_to_bytes(sector_num), filename1,
1429 strerror(-ret));
1430 ret = 4;
1431 goto out;
1433 ret = blk_pread(blk2, sector_num << BDRV_SECTOR_BITS, buf2,
1434 nb_sectors << BDRV_SECTOR_BITS);
1435 if (ret < 0) {
1436 error_report("Error while reading offset %" PRId64
1437 " of %s: %s", sectors_to_bytes(sector_num),
1438 filename2, strerror(-ret));
1439 ret = 4;
1440 goto out;
1442 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1443 if (ret || pnum != nb_sectors) {
1444 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1445 sectors_to_bytes(
1446 ret ? sector_num : sector_num + pnum));
1447 ret = 1;
1448 goto out;
1451 } else {
1453 if (allocated1) {
1454 ret = check_empty_sectors(blk1, sector_num, nb_sectors,
1455 filename1, buf1, quiet);
1456 } else {
1457 ret = check_empty_sectors(blk2, sector_num, nb_sectors,
1458 filename2, buf1, quiet);
1460 if (ret) {
1461 if (ret < 0) {
1462 error_report("Error while reading offset %" PRId64 ": %s",
1463 sectors_to_bytes(sector_num), strerror(-ret));
1464 ret = 4;
1466 goto out;
1469 sector_num += nb_sectors;
1470 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1473 if (total_sectors1 != total_sectors2) {
1474 BlockBackend *blk_over;
1475 int64_t total_sectors_over;
1476 const char *filename_over;
1478 qprintf(quiet, "Warning: Image size mismatch!\n");
1479 if (total_sectors1 > total_sectors2) {
1480 total_sectors_over = total_sectors1;
1481 blk_over = blk1;
1482 filename_over = filename1;
1483 } else {
1484 total_sectors_over = total_sectors2;
1485 blk_over = blk2;
1486 filename_over = filename2;
1489 for (;;) {
1490 int64_t count;
1492 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1493 if (nb_sectors <= 0) {
1494 break;
1496 ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL,
1497 sector_num * BDRV_SECTOR_SIZE,
1498 nb_sectors * BDRV_SECTOR_SIZE,
1499 &count);
1500 if (ret < 0) {
1501 ret = 3;
1502 error_report("Sector allocation test failed for %s",
1503 filename_over);
1504 goto out;
1507 /* TODO relax this once bdrv_is_allocated_above does not enforce
1508 * sector alignment */
1509 assert(QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE));
1510 nb_sectors = count >> BDRV_SECTOR_BITS;
1511 if (ret) {
1512 ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
1513 filename_over, buf1, quiet);
1514 if (ret) {
1515 if (ret < 0) {
1516 error_report("Error while reading offset %" PRId64
1517 " of %s: %s", sectors_to_bytes(sector_num),
1518 filename_over, strerror(-ret));
1519 ret = 4;
1521 goto out;
1524 sector_num += nb_sectors;
1525 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1529 qprintf(quiet, "Images are identical.\n");
1530 ret = 0;
1532 out:
1533 qemu_vfree(buf1);
1534 qemu_vfree(buf2);
1535 blk_unref(blk2);
1536 out2:
1537 blk_unref(blk1);
1538 out3:
1539 qemu_progress_end();
1540 out4:
1541 return ret;
1544 enum ImgConvertBlockStatus {
1545 BLK_DATA,
1546 BLK_ZERO,
1547 BLK_BACKING_FILE,
1550 #define MAX_COROUTINES 16
1552 typedef struct ImgConvertState {
1553 BlockBackend **src;
1554 int64_t *src_sectors;
1555 int src_num;
1556 int64_t total_sectors;
1557 int64_t allocated_sectors;
1558 int64_t allocated_done;
1559 int64_t sector_num;
1560 int64_t wr_offs;
1561 enum ImgConvertBlockStatus status;
1562 int64_t sector_next_status;
1563 BlockBackend *target;
1564 bool has_zero_init;
1565 bool compressed;
1566 bool target_has_backing;
1567 bool wr_in_order;
1568 int min_sparse;
1569 size_t cluster_sectors;
1570 size_t buf_sectors;
1571 long num_coroutines;
1572 int running_coroutines;
1573 Coroutine *co[MAX_COROUTINES];
1574 int64_t wait_sector_num[MAX_COROUTINES];
1575 CoMutex lock;
1576 int ret;
1577 } ImgConvertState;
1579 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1580 int *src_cur, int64_t *src_cur_offset)
1582 *src_cur = 0;
1583 *src_cur_offset = 0;
1584 while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1585 *src_cur_offset += s->src_sectors[*src_cur];
1586 (*src_cur)++;
1587 assert(*src_cur < s->src_num);
1591 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1593 int64_t ret, src_cur_offset;
1594 int n, src_cur;
1596 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1598 assert(s->total_sectors > sector_num);
1599 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1601 if (s->sector_next_status <= sector_num) {
1602 BlockDriverState *file;
1603 if (s->target_has_backing) {
1604 ret = bdrv_get_block_status(blk_bs(s->src[src_cur]),
1605 sector_num - src_cur_offset,
1606 n, &n, &file);
1607 } else {
1608 ret = bdrv_get_block_status_above(blk_bs(s->src[src_cur]), NULL,
1609 sector_num - src_cur_offset,
1610 n, &n, &file);
1612 if (ret < 0) {
1613 return ret;
1616 if (ret & BDRV_BLOCK_ZERO) {
1617 s->status = BLK_ZERO;
1618 } else if (ret & BDRV_BLOCK_DATA) {
1619 s->status = BLK_DATA;
1620 } else {
1621 s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1624 s->sector_next_status = sector_num + n;
1627 n = MIN(n, s->sector_next_status - sector_num);
1628 if (s->status == BLK_DATA) {
1629 n = MIN(n, s->buf_sectors);
1632 /* We need to write complete clusters for compressed images, so if an
1633 * unallocated area is shorter than that, we must consider the whole
1634 * cluster allocated. */
1635 if (s->compressed) {
1636 if (n < s->cluster_sectors) {
1637 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1638 s->status = BLK_DATA;
1639 } else {
1640 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1644 return n;
1647 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1648 int nb_sectors, uint8_t *buf)
1650 int n, ret;
1651 QEMUIOVector qiov;
1652 struct iovec iov;
1654 assert(nb_sectors <= s->buf_sectors);
1655 while (nb_sectors > 0) {
1656 BlockBackend *blk;
1657 int src_cur;
1658 int64_t bs_sectors, src_cur_offset;
1660 /* In the case of compression with multiple source files, we can get a
1661 * nb_sectors that spreads into the next part. So we must be able to
1662 * read across multiple BDSes for one convert_read() call. */
1663 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1664 blk = s->src[src_cur];
1665 bs_sectors = s->src_sectors[src_cur];
1667 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1668 iov.iov_base = buf;
1669 iov.iov_len = n << BDRV_SECTOR_BITS;
1670 qemu_iovec_init_external(&qiov, &iov, 1);
1672 ret = blk_co_preadv(
1673 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
1674 n << BDRV_SECTOR_BITS, &qiov, 0);
1675 if (ret < 0) {
1676 return ret;
1679 sector_num += n;
1680 nb_sectors -= n;
1681 buf += n * BDRV_SECTOR_SIZE;
1684 return 0;
1688 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1689 int nb_sectors, uint8_t *buf,
1690 enum ImgConvertBlockStatus status)
1692 int ret;
1693 QEMUIOVector qiov;
1694 struct iovec iov;
1696 while (nb_sectors > 0) {
1697 int n = nb_sectors;
1698 BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1700 switch (status) {
1701 case BLK_BACKING_FILE:
1702 /* If we have a backing file, leave clusters unallocated that are
1703 * unallocated in the source image, so that the backing file is
1704 * visible at the respective offset. */
1705 assert(s->target_has_backing);
1706 break;
1708 case BLK_DATA:
1709 /* If we're told to keep the target fully allocated (-S 0) or there
1710 * is real non-zero data, we must write it. Otherwise we can treat
1711 * it as zero sectors.
1712 * Compressed clusters need to be written as a whole, so in that
1713 * case we can only save the write if the buffer is completely
1714 * zeroed. */
1715 if (!s->min_sparse ||
1716 (!s->compressed &&
1717 is_allocated_sectors_min(buf, n, &n, s->min_sparse)) ||
1718 (s->compressed &&
1719 !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1721 iov.iov_base = buf;
1722 iov.iov_len = n << BDRV_SECTOR_BITS;
1723 qemu_iovec_init_external(&qiov, &iov, 1);
1725 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
1726 n << BDRV_SECTOR_BITS, &qiov, flags);
1727 if (ret < 0) {
1728 return ret;
1730 break;
1732 /* fall-through */
1734 case BLK_ZERO:
1735 if (s->has_zero_init) {
1736 assert(!s->target_has_backing);
1737 break;
1739 ret = blk_co_pwrite_zeroes(s->target,
1740 sector_num << BDRV_SECTOR_BITS,
1741 n << BDRV_SECTOR_BITS, 0);
1742 if (ret < 0) {
1743 return ret;
1745 break;
1748 sector_num += n;
1749 nb_sectors -= n;
1750 buf += n * BDRV_SECTOR_SIZE;
1753 return 0;
1756 static void coroutine_fn convert_co_do_copy(void *opaque)
1758 ImgConvertState *s = opaque;
1759 uint8_t *buf = NULL;
1760 int ret, i;
1761 int index = -1;
1763 for (i = 0; i < s->num_coroutines; i++) {
1764 if (s->co[i] == qemu_coroutine_self()) {
1765 index = i;
1766 break;
1769 assert(index >= 0);
1771 s->running_coroutines++;
1772 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1774 while (1) {
1775 int n;
1776 int64_t sector_num;
1777 enum ImgConvertBlockStatus status;
1779 qemu_co_mutex_lock(&s->lock);
1780 if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1781 qemu_co_mutex_unlock(&s->lock);
1782 break;
1784 n = convert_iteration_sectors(s, s->sector_num);
1785 if (n < 0) {
1786 qemu_co_mutex_unlock(&s->lock);
1787 s->ret = n;
1788 break;
1790 /* save current sector and allocation status to local variables */
1791 sector_num = s->sector_num;
1792 status = s->status;
1793 if (!s->min_sparse && s->status == BLK_ZERO) {
1794 n = MIN(n, s->buf_sectors);
1796 /* increment global sector counter so that other coroutines can
1797 * already continue reading beyond this request */
1798 s->sector_num += n;
1799 qemu_co_mutex_unlock(&s->lock);
1801 if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
1802 s->allocated_done += n;
1803 qemu_progress_print(100.0 * s->allocated_done /
1804 s->allocated_sectors, 0);
1807 if (status == BLK_DATA) {
1808 ret = convert_co_read(s, sector_num, n, buf);
1809 if (ret < 0) {
1810 error_report("error while reading sector %" PRId64
1811 ": %s", sector_num, strerror(-ret));
1812 s->ret = ret;
1814 } else if (!s->min_sparse && status == BLK_ZERO) {
1815 status = BLK_DATA;
1816 memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
1819 if (s->wr_in_order) {
1820 /* keep writes in order */
1821 while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
1822 s->wait_sector_num[index] = sector_num;
1823 qemu_coroutine_yield();
1825 s->wait_sector_num[index] = -1;
1828 if (s->ret == -EINPROGRESS) {
1829 ret = convert_co_write(s, sector_num, n, buf, status);
1830 if (ret < 0) {
1831 error_report("error while writing sector %" PRId64
1832 ": %s", sector_num, strerror(-ret));
1833 s->ret = ret;
1837 if (s->wr_in_order) {
1838 /* reenter the coroutine that might have waited
1839 * for this write to complete */
1840 s->wr_offs = sector_num + n;
1841 for (i = 0; i < s->num_coroutines; i++) {
1842 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
1844 * A -> B -> A cannot occur because A has
1845 * s->wait_sector_num[i] == -1 during A -> B. Therefore
1846 * B will never enter A during this time window.
1848 qemu_coroutine_enter(s->co[i]);
1849 break;
1855 qemu_vfree(buf);
1856 s->co[index] = NULL;
1857 s->running_coroutines--;
1858 if (!s->running_coroutines && s->ret == -EINPROGRESS) {
1859 /* the convert job finished successfully */
1860 s->ret = 0;
1864 static int convert_do_copy(ImgConvertState *s)
1866 int ret, i, n;
1867 int64_t sector_num = 0;
1869 /* Check whether we have zero initialisation or can get it efficiently */
1870 s->has_zero_init = s->min_sparse && !s->target_has_backing
1871 ? bdrv_has_zero_init(blk_bs(s->target))
1872 : false;
1874 if (!s->has_zero_init && !s->target_has_backing &&
1875 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1877 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP);
1878 if (ret == 0) {
1879 s->has_zero_init = true;
1883 /* Allocate buffer for copied data. For compressed images, only one cluster
1884 * can be copied at a time. */
1885 if (s->compressed) {
1886 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1887 error_report("invalid cluster size");
1888 return -EINVAL;
1890 s->buf_sectors = s->cluster_sectors;
1893 while (sector_num < s->total_sectors) {
1894 n = convert_iteration_sectors(s, sector_num);
1895 if (n < 0) {
1896 return n;
1898 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
1900 s->allocated_sectors += n;
1902 sector_num += n;
1905 /* Do the copy */
1906 s->sector_next_status = 0;
1907 s->ret = -EINPROGRESS;
1909 qemu_co_mutex_init(&s->lock);
1910 for (i = 0; i < s->num_coroutines; i++) {
1911 s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
1912 s->wait_sector_num[i] = -1;
1913 qemu_coroutine_enter(s->co[i]);
1916 while (s->running_coroutines) {
1917 main_loop_wait(false);
1920 if (s->compressed && !s->ret) {
1921 /* signal EOF to align */
1922 ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
1923 if (ret < 0) {
1924 return ret;
1928 return s->ret;
1931 static int img_convert(int argc, char **argv)
1933 int c, bs_i, flags, src_flags = 0;
1934 const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
1935 *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
1936 *out_filename, *out_baseimg_param, *snapshot_name = NULL;
1937 BlockDriver *drv = NULL, *proto_drv = NULL;
1938 BlockDriverInfo bdi;
1939 BlockDriverState *out_bs;
1940 QemuOpts *opts = NULL, *sn_opts = NULL;
1941 QemuOptsList *create_opts = NULL;
1942 char *options = NULL;
1943 Error *local_err = NULL;
1944 bool writethrough, src_writethrough, quiet = false, image_opts = false,
1945 skip_create = false, progress = false, tgt_image_opts = false;
1946 int64_t ret = -EINVAL;
1947 bool force_share = false;
1949 ImgConvertState s = (ImgConvertState) {
1950 /* Need at least 4k of zeros for sparse detection */
1951 .min_sparse = 8,
1952 .buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
1953 .wr_in_order = true,
1954 .num_coroutines = 8,
1957 for(;;) {
1958 static const struct option long_options[] = {
1959 {"help", no_argument, 0, 'h'},
1960 {"object", required_argument, 0, OPTION_OBJECT},
1961 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1962 {"force-share", no_argument, 0, 'U'},
1963 {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
1964 {0, 0, 0, 0}
1966 c = getopt_long(argc, argv, ":hf:O:B:co:s:l:S:pt:T:qnm:WU",
1967 long_options, NULL);
1968 if (c == -1) {
1969 break;
1971 switch(c) {
1972 case ':':
1973 missing_argument(argv[optind - 1]);
1974 break;
1975 case '?':
1976 unrecognized_option(argv[optind - 1]);
1977 break;
1978 case 'h':
1979 help();
1980 break;
1981 case 'f':
1982 fmt = optarg;
1983 break;
1984 case 'O':
1985 out_fmt = optarg;
1986 break;
1987 case 'B':
1988 out_baseimg = optarg;
1989 break;
1990 case 'c':
1991 s.compressed = true;
1992 break;
1993 case 'o':
1994 if (!is_valid_option_list(optarg)) {
1995 error_report("Invalid option list: %s", optarg);
1996 goto fail_getopt;
1998 if (!options) {
1999 options = g_strdup(optarg);
2000 } else {
2001 char *old_options = options;
2002 options = g_strdup_printf("%s,%s", options, optarg);
2003 g_free(old_options);
2005 break;
2006 case 's':
2007 snapshot_name = optarg;
2008 break;
2009 case 'l':
2010 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2011 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2012 optarg, false);
2013 if (!sn_opts) {
2014 error_report("Failed in parsing snapshot param '%s'",
2015 optarg);
2016 goto fail_getopt;
2018 } else {
2019 snapshot_name = optarg;
2021 break;
2022 case 'S':
2024 int64_t sval;
2026 sval = cvtnum(optarg);
2027 if (sval < 0) {
2028 error_report("Invalid minimum zero buffer size for sparse output specified");
2029 goto fail_getopt;
2032 s.min_sparse = sval / BDRV_SECTOR_SIZE;
2033 break;
2035 case 'p':
2036 progress = true;
2037 break;
2038 case 't':
2039 cache = optarg;
2040 break;
2041 case 'T':
2042 src_cache = optarg;
2043 break;
2044 case 'q':
2045 quiet = true;
2046 break;
2047 case 'n':
2048 skip_create = true;
2049 break;
2050 case 'm':
2051 if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2052 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2053 error_report("Invalid number of coroutines. Allowed number of"
2054 " coroutines is between 1 and %d", MAX_COROUTINES);
2055 goto fail_getopt;
2057 break;
2058 case 'W':
2059 s.wr_in_order = false;
2060 break;
2061 case 'U':
2062 force_share = true;
2063 break;
2064 case OPTION_OBJECT: {
2065 QemuOpts *object_opts;
2066 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2067 optarg, true);
2068 if (!object_opts) {
2069 goto fail_getopt;
2071 break;
2073 case OPTION_IMAGE_OPTS:
2074 image_opts = true;
2075 break;
2076 case OPTION_TARGET_IMAGE_OPTS:
2077 tgt_image_opts = true;
2078 break;
2082 if (!out_fmt && !tgt_image_opts) {
2083 out_fmt = "raw";
2086 if (qemu_opts_foreach(&qemu_object_opts,
2087 user_creatable_add_opts_foreach,
2088 NULL, NULL)) {
2089 goto fail_getopt;
2092 if (!s.wr_in_order && s.compressed) {
2093 error_report("Out of order write and compress are mutually exclusive");
2094 goto fail_getopt;
2097 if (tgt_image_opts && !skip_create) {
2098 error_report("--target-image-opts requires use of -n flag");
2099 goto fail_getopt;
2102 s.src_num = argc - optind - 1;
2103 out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2105 if (options && has_help_option(options)) {
2106 if (out_fmt) {
2107 ret = print_block_option_help(out_filename, out_fmt);
2108 goto fail_getopt;
2109 } else {
2110 error_report("Option help requires a format be specified");
2111 goto fail_getopt;
2115 if (s.src_num < 1) {
2116 error_report("Must specify image file name");
2117 goto fail_getopt;
2121 /* ret is still -EINVAL until here */
2122 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2123 if (ret < 0) {
2124 error_report("Invalid source cache option: %s", src_cache);
2125 goto fail_getopt;
2128 /* Initialize before goto out */
2129 if (quiet) {
2130 progress = false;
2132 qemu_progress_init(progress, 1.0);
2133 qemu_progress_print(0, 100);
2135 s.src = g_new0(BlockBackend *, s.src_num);
2136 s.src_sectors = g_new(int64_t, s.src_num);
2138 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2139 s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2140 fmt, src_flags, src_writethrough, quiet,
2141 force_share);
2142 if (!s.src[bs_i]) {
2143 ret = -1;
2144 goto out;
2146 s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2147 if (s.src_sectors[bs_i] < 0) {
2148 error_report("Could not get size of %s: %s",
2149 argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2150 ret = -1;
2151 goto out;
2153 s.total_sectors += s.src_sectors[bs_i];
2156 if (sn_opts) {
2157 bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2158 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2159 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2160 &local_err);
2161 } else if (snapshot_name != NULL) {
2162 if (s.src_num > 1) {
2163 error_report("No support for concatenating multiple snapshot");
2164 ret = -1;
2165 goto out;
2168 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2169 &local_err);
2171 if (local_err) {
2172 error_reportf_err(local_err, "Failed to load snapshot: ");
2173 ret = -1;
2174 goto out;
2177 if (!skip_create) {
2178 /* Find driver and parse its options */
2179 drv = bdrv_find_format(out_fmt);
2180 if (!drv) {
2181 error_report("Unknown file format '%s'", out_fmt);
2182 ret = -1;
2183 goto out;
2186 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2187 if (!proto_drv) {
2188 error_report_err(local_err);
2189 ret = -1;
2190 goto out;
2193 if (!drv->create_opts) {
2194 error_report("Format driver '%s' does not support image creation",
2195 drv->format_name);
2196 ret = -1;
2197 goto out;
2200 if (!proto_drv->create_opts) {
2201 error_report("Protocol driver '%s' does not support image creation",
2202 proto_drv->format_name);
2203 ret = -1;
2204 goto out;
2207 create_opts = qemu_opts_append(create_opts, drv->create_opts);
2208 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2210 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2211 if (options) {
2212 qemu_opts_do_parse(opts, options, NULL, &local_err);
2213 if (local_err) {
2214 error_report_err(local_err);
2215 ret = -1;
2216 goto out;
2220 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2221 &error_abort);
2222 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2223 if (ret < 0) {
2224 goto out;
2228 /* Get backing file name if -o backing_file was used */
2229 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2230 if (out_baseimg_param) {
2231 out_baseimg = out_baseimg_param;
2233 s.target_has_backing = (bool) out_baseimg;
2235 if (s.src_num > 1 && out_baseimg) {
2236 error_report("Having a backing file for the target makes no sense when "
2237 "concatenating multiple input images");
2238 ret = -1;
2239 goto out;
2242 /* Check if compression is supported */
2243 if (s.compressed) {
2244 bool encryption =
2245 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2246 const char *encryptfmt =
2247 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2248 const char *preallocation =
2249 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2251 if (drv && !drv->bdrv_co_pwritev_compressed) {
2252 error_report("Compression not supported for this file format");
2253 ret = -1;
2254 goto out;
2257 if (encryption || encryptfmt) {
2258 error_report("Compression and encryption not supported at "
2259 "the same time");
2260 ret = -1;
2261 goto out;
2264 if (preallocation
2265 && strcmp(preallocation, "off"))
2267 error_report("Compression and preallocation not supported at "
2268 "the same time");
2269 ret = -1;
2270 goto out;
2274 if (!skip_create) {
2275 /* Create the new image */
2276 ret = bdrv_create(drv, out_filename, opts, &local_err);
2277 if (ret < 0) {
2278 error_reportf_err(local_err, "%s: error while converting %s: ",
2279 out_filename, out_fmt);
2280 goto out;
2284 flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2285 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2286 if (ret < 0) {
2287 error_report("Invalid cache option: %s", cache);
2288 goto out;
2291 if (skip_create) {
2292 s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2293 flags, writethrough, quiet, false);
2294 } else {
2295 /* TODO ultimately we should allow --target-image-opts
2296 * to be used even when -n is not given.
2297 * That has to wait for bdrv_create to be improved
2298 * to allow filenames in option syntax
2300 s.target = img_open_new_file(out_filename, opts, out_fmt,
2301 flags, writethrough, quiet, false);
2303 if (!s.target) {
2304 ret = -1;
2305 goto out;
2307 out_bs = blk_bs(s.target);
2309 if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
2310 error_report("Compression not supported for this file format");
2311 ret = -1;
2312 goto out;
2315 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2316 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
2317 * as maximum. */
2318 s.buf_sectors = MIN(32768,
2319 MAX(s.buf_sectors,
2320 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2321 out_bs->bl.pdiscard_alignment >>
2322 BDRV_SECTOR_BITS)));
2324 if (skip_create) {
2325 int64_t output_sectors = blk_nb_sectors(s.target);
2326 if (output_sectors < 0) {
2327 error_report("unable to get output image length: %s",
2328 strerror(-output_sectors));
2329 ret = -1;
2330 goto out;
2331 } else if (output_sectors < s.total_sectors) {
2332 error_report("output file is smaller than input file");
2333 ret = -1;
2334 goto out;
2338 ret = bdrv_get_info(out_bs, &bdi);
2339 if (ret < 0) {
2340 if (s.compressed) {
2341 error_report("could not get block driver info");
2342 goto out;
2344 } else {
2345 s.compressed = s.compressed || bdi.needs_compressed_writes;
2346 s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2349 ret = convert_do_copy(&s);
2350 out:
2351 if (!ret) {
2352 qemu_progress_print(100, 0);
2354 qemu_progress_end();
2355 qemu_opts_del(opts);
2356 qemu_opts_free(create_opts);
2357 qemu_opts_del(sn_opts);
2358 blk_unref(s.target);
2359 if (s.src) {
2360 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2361 blk_unref(s.src[bs_i]);
2363 g_free(s.src);
2365 g_free(s.src_sectors);
2366 fail_getopt:
2367 g_free(options);
2369 return !!ret;
2373 static void dump_snapshots(BlockDriverState *bs)
2375 QEMUSnapshotInfo *sn_tab, *sn;
2376 int nb_sns, i;
2378 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2379 if (nb_sns <= 0)
2380 return;
2381 printf("Snapshot list:\n");
2382 bdrv_snapshot_dump(fprintf, stdout, NULL);
2383 printf("\n");
2384 for(i = 0; i < nb_sns; i++) {
2385 sn = &sn_tab[i];
2386 bdrv_snapshot_dump(fprintf, stdout, sn);
2387 printf("\n");
2389 g_free(sn_tab);
2392 static void dump_json_image_info_list(ImageInfoList *list)
2394 QString *str;
2395 QObject *obj;
2396 Visitor *v = qobject_output_visitor_new(&obj);
2398 visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2399 visit_complete(v, &obj);
2400 str = qobject_to_json_pretty(obj);
2401 assert(str != NULL);
2402 printf("%s\n", qstring_get_str(str));
2403 qobject_decref(obj);
2404 visit_free(v);
2405 QDECREF(str);
2408 static void dump_json_image_info(ImageInfo *info)
2410 QString *str;
2411 QObject *obj;
2412 Visitor *v = qobject_output_visitor_new(&obj);
2414 visit_type_ImageInfo(v, NULL, &info, &error_abort);
2415 visit_complete(v, &obj);
2416 str = qobject_to_json_pretty(obj);
2417 assert(str != NULL);
2418 printf("%s\n", qstring_get_str(str));
2419 qobject_decref(obj);
2420 visit_free(v);
2421 QDECREF(str);
2424 static void dump_human_image_info_list(ImageInfoList *list)
2426 ImageInfoList *elem;
2427 bool delim = false;
2429 for (elem = list; elem; elem = elem->next) {
2430 if (delim) {
2431 printf("\n");
2433 delim = true;
2435 bdrv_image_info_dump(fprintf, stdout, elem->value);
2439 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2441 return strcmp(a, b) == 0;
2445 * Open an image file chain and return an ImageInfoList
2447 * @filename: topmost image filename
2448 * @fmt: topmost image format (may be NULL to autodetect)
2449 * @chain: true - enumerate entire backing file chain
2450 * false - only topmost image file
2452 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2453 * image file. If there was an error a message will have been printed to
2454 * stderr.
2456 static ImageInfoList *collect_image_info_list(bool image_opts,
2457 const char *filename,
2458 const char *fmt,
2459 bool chain, bool force_share)
2461 ImageInfoList *head = NULL;
2462 ImageInfoList **last = &head;
2463 GHashTable *filenames;
2464 Error *err = NULL;
2466 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2468 while (filename) {
2469 BlockBackend *blk;
2470 BlockDriverState *bs;
2471 ImageInfo *info;
2472 ImageInfoList *elem;
2474 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2475 error_report("Backing file '%s' creates an infinite loop.",
2476 filename);
2477 goto err;
2479 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2481 blk = img_open(image_opts, filename, fmt,
2482 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2483 force_share);
2484 if (!blk) {
2485 goto err;
2487 bs = blk_bs(blk);
2489 bdrv_query_image_info(bs, &info, &err);
2490 if (err) {
2491 error_report_err(err);
2492 blk_unref(blk);
2493 goto err;
2496 elem = g_new0(ImageInfoList, 1);
2497 elem->value = info;
2498 *last = elem;
2499 last = &elem->next;
2501 blk_unref(blk);
2503 filename = fmt = NULL;
2504 if (chain) {
2505 if (info->has_full_backing_filename) {
2506 filename = info->full_backing_filename;
2507 } else if (info->has_backing_filename) {
2508 error_report("Could not determine absolute backing filename,"
2509 " but backing filename '%s' present",
2510 info->backing_filename);
2511 goto err;
2513 if (info->has_backing_filename_format) {
2514 fmt = info->backing_filename_format;
2518 g_hash_table_destroy(filenames);
2519 return head;
2521 err:
2522 qapi_free_ImageInfoList(head);
2523 g_hash_table_destroy(filenames);
2524 return NULL;
2527 static int img_info(int argc, char **argv)
2529 int c;
2530 OutputFormat output_format = OFORMAT_HUMAN;
2531 bool chain = false;
2532 const char *filename, *fmt, *output;
2533 ImageInfoList *list;
2534 bool image_opts = false;
2535 bool force_share = false;
2537 fmt = NULL;
2538 output = NULL;
2539 for(;;) {
2540 int option_index = 0;
2541 static const struct option long_options[] = {
2542 {"help", no_argument, 0, 'h'},
2543 {"format", required_argument, 0, 'f'},
2544 {"output", required_argument, 0, OPTION_OUTPUT},
2545 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2546 {"object", required_argument, 0, OPTION_OBJECT},
2547 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2548 {"force-share", no_argument, 0, 'U'},
2549 {0, 0, 0, 0}
2551 c = getopt_long(argc, argv, ":f:hU",
2552 long_options, &option_index);
2553 if (c == -1) {
2554 break;
2556 switch(c) {
2557 case ':':
2558 missing_argument(argv[optind - 1]);
2559 break;
2560 case '?':
2561 unrecognized_option(argv[optind - 1]);
2562 break;
2563 case 'h':
2564 help();
2565 break;
2566 case 'f':
2567 fmt = optarg;
2568 break;
2569 case 'U':
2570 force_share = true;
2571 break;
2572 case OPTION_OUTPUT:
2573 output = optarg;
2574 break;
2575 case OPTION_BACKING_CHAIN:
2576 chain = true;
2577 break;
2578 case OPTION_OBJECT: {
2579 QemuOpts *opts;
2580 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2581 optarg, true);
2582 if (!opts) {
2583 return 1;
2585 } break;
2586 case OPTION_IMAGE_OPTS:
2587 image_opts = true;
2588 break;
2591 if (optind != argc - 1) {
2592 error_exit("Expecting one image file name");
2594 filename = argv[optind++];
2596 if (output && !strcmp(output, "json")) {
2597 output_format = OFORMAT_JSON;
2598 } else if (output && !strcmp(output, "human")) {
2599 output_format = OFORMAT_HUMAN;
2600 } else if (output) {
2601 error_report("--output must be used with human or json as argument.");
2602 return 1;
2605 if (qemu_opts_foreach(&qemu_object_opts,
2606 user_creatable_add_opts_foreach,
2607 NULL, NULL)) {
2608 return 1;
2611 list = collect_image_info_list(image_opts, filename, fmt, chain,
2612 force_share);
2613 if (!list) {
2614 return 1;
2617 switch (output_format) {
2618 case OFORMAT_HUMAN:
2619 dump_human_image_info_list(list);
2620 break;
2621 case OFORMAT_JSON:
2622 if (chain) {
2623 dump_json_image_info_list(list);
2624 } else {
2625 dump_json_image_info(list->value);
2627 break;
2630 qapi_free_ImageInfoList(list);
2631 return 0;
2634 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2635 MapEntry *next)
2637 switch (output_format) {
2638 case OFORMAT_HUMAN:
2639 if (e->data && !e->has_offset) {
2640 error_report("File contains external, encrypted or compressed clusters.");
2641 exit(1);
2643 if (e->data && !e->zero) {
2644 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2645 e->start, e->length,
2646 e->has_offset ? e->offset : 0,
2647 e->has_filename ? e->filename : "");
2649 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2650 * Modify the flags here to allow more coalescing.
2652 if (next && (!next->data || next->zero)) {
2653 next->data = false;
2654 next->zero = true;
2656 break;
2657 case OFORMAT_JSON:
2658 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2659 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2660 (e->start == 0 ? "[" : ",\n"),
2661 e->start, e->length, e->depth,
2662 e->zero ? "true" : "false",
2663 e->data ? "true" : "false");
2664 if (e->has_offset) {
2665 printf(", \"offset\": %"PRId64"", e->offset);
2667 putchar('}');
2669 if (!next) {
2670 printf("]\n");
2672 break;
2676 static int get_block_status(BlockDriverState *bs, int64_t sector_num,
2677 int nb_sectors, MapEntry *e)
2679 int64_t ret;
2680 int depth;
2681 BlockDriverState *file;
2682 bool has_offset;
2684 /* As an optimization, we could cache the current range of unallocated
2685 * clusters in each file of the chain, and avoid querying the same
2686 * range repeatedly.
2689 depth = 0;
2690 for (;;) {
2691 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,
2692 &file);
2693 if (ret < 0) {
2694 return ret;
2696 assert(nb_sectors);
2697 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2698 break;
2700 bs = backing_bs(bs);
2701 if (bs == NULL) {
2702 ret = 0;
2703 break;
2706 depth++;
2709 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2711 *e = (MapEntry) {
2712 .start = sector_num * BDRV_SECTOR_SIZE,
2713 .length = nb_sectors * BDRV_SECTOR_SIZE,
2714 .data = !!(ret & BDRV_BLOCK_DATA),
2715 .zero = !!(ret & BDRV_BLOCK_ZERO),
2716 .offset = ret & BDRV_BLOCK_OFFSET_MASK,
2717 .has_offset = has_offset,
2718 .depth = depth,
2719 .has_filename = file && has_offset,
2720 .filename = file && has_offset ? file->filename : NULL,
2723 return 0;
2726 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2728 if (curr->length == 0) {
2729 return false;
2731 if (curr->zero != next->zero ||
2732 curr->data != next->data ||
2733 curr->depth != next->depth ||
2734 curr->has_filename != next->has_filename ||
2735 curr->has_offset != next->has_offset) {
2736 return false;
2738 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2739 return false;
2741 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2742 return false;
2744 return true;
2747 static int img_map(int argc, char **argv)
2749 int c;
2750 OutputFormat output_format = OFORMAT_HUMAN;
2751 BlockBackend *blk;
2752 BlockDriverState *bs;
2753 const char *filename, *fmt, *output;
2754 int64_t length;
2755 MapEntry curr = { .length = 0 }, next;
2756 int ret = 0;
2757 bool image_opts = false;
2758 bool force_share = false;
2760 fmt = NULL;
2761 output = NULL;
2762 for (;;) {
2763 int option_index = 0;
2764 static const struct option long_options[] = {
2765 {"help", no_argument, 0, 'h'},
2766 {"format", required_argument, 0, 'f'},
2767 {"output", required_argument, 0, OPTION_OUTPUT},
2768 {"object", required_argument, 0, OPTION_OBJECT},
2769 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2770 {"force-share", no_argument, 0, 'U'},
2771 {0, 0, 0, 0}
2773 c = getopt_long(argc, argv, ":f:hU",
2774 long_options, &option_index);
2775 if (c == -1) {
2776 break;
2778 switch (c) {
2779 case ':':
2780 missing_argument(argv[optind - 1]);
2781 break;
2782 case '?':
2783 unrecognized_option(argv[optind - 1]);
2784 break;
2785 case 'h':
2786 help();
2787 break;
2788 case 'f':
2789 fmt = optarg;
2790 break;
2791 case 'U':
2792 force_share = true;
2793 break;
2794 case OPTION_OUTPUT:
2795 output = optarg;
2796 break;
2797 case OPTION_OBJECT: {
2798 QemuOpts *opts;
2799 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2800 optarg, true);
2801 if (!opts) {
2802 return 1;
2804 } break;
2805 case OPTION_IMAGE_OPTS:
2806 image_opts = true;
2807 break;
2810 if (optind != argc - 1) {
2811 error_exit("Expecting one image file name");
2813 filename = argv[optind];
2815 if (output && !strcmp(output, "json")) {
2816 output_format = OFORMAT_JSON;
2817 } else if (output && !strcmp(output, "human")) {
2818 output_format = OFORMAT_HUMAN;
2819 } else if (output) {
2820 error_report("--output must be used with human or json as argument.");
2821 return 1;
2824 if (qemu_opts_foreach(&qemu_object_opts,
2825 user_creatable_add_opts_foreach,
2826 NULL, NULL)) {
2827 return 1;
2830 blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
2831 if (!blk) {
2832 return 1;
2834 bs = blk_bs(blk);
2836 if (output_format == OFORMAT_HUMAN) {
2837 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2840 length = blk_getlength(blk);
2841 while (curr.start + curr.length < length) {
2842 int64_t nsectors_left;
2843 int64_t sector_num;
2844 int n;
2846 sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
2848 /* Probe up to 1 GiB at a time. */
2849 nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
2850 n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
2851 ret = get_block_status(bs, sector_num, n, &next);
2853 if (ret < 0) {
2854 error_report("Could not read file metadata: %s", strerror(-ret));
2855 goto out;
2858 if (entry_mergeable(&curr, &next)) {
2859 curr.length += next.length;
2860 continue;
2863 if (curr.length > 0) {
2864 dump_map_entry(output_format, &curr, &next);
2866 curr = next;
2869 dump_map_entry(output_format, &curr, NULL);
2871 out:
2872 blk_unref(blk);
2873 return ret < 0;
2876 #define SNAPSHOT_LIST 1
2877 #define SNAPSHOT_CREATE 2
2878 #define SNAPSHOT_APPLY 3
2879 #define SNAPSHOT_DELETE 4
2881 static int img_snapshot(int argc, char **argv)
2883 BlockBackend *blk;
2884 BlockDriverState *bs;
2885 QEMUSnapshotInfo sn;
2886 char *filename, *snapshot_name = NULL;
2887 int c, ret = 0, bdrv_oflags;
2888 int action = 0;
2889 qemu_timeval tv;
2890 bool quiet = false;
2891 Error *err = NULL;
2892 bool image_opts = false;
2893 bool force_share = false;
2895 bdrv_oflags = BDRV_O_RDWR;
2896 /* Parse commandline parameters */
2897 for(;;) {
2898 static const struct option long_options[] = {
2899 {"help", no_argument, 0, 'h'},
2900 {"object", required_argument, 0, OPTION_OBJECT},
2901 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2902 {"force-share", no_argument, 0, 'U'},
2903 {0, 0, 0, 0}
2905 c = getopt_long(argc, argv, ":la:c:d:hqU",
2906 long_options, NULL);
2907 if (c == -1) {
2908 break;
2910 switch(c) {
2911 case ':':
2912 missing_argument(argv[optind - 1]);
2913 break;
2914 case '?':
2915 unrecognized_option(argv[optind - 1]);
2916 break;
2917 case 'h':
2918 help();
2919 return 0;
2920 case 'l':
2921 if (action) {
2922 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2923 return 0;
2925 action = SNAPSHOT_LIST;
2926 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2927 break;
2928 case 'a':
2929 if (action) {
2930 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2931 return 0;
2933 action = SNAPSHOT_APPLY;
2934 snapshot_name = optarg;
2935 break;
2936 case 'c':
2937 if (action) {
2938 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2939 return 0;
2941 action = SNAPSHOT_CREATE;
2942 snapshot_name = optarg;
2943 break;
2944 case 'd':
2945 if (action) {
2946 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
2947 return 0;
2949 action = SNAPSHOT_DELETE;
2950 snapshot_name = optarg;
2951 break;
2952 case 'q':
2953 quiet = true;
2954 break;
2955 case 'U':
2956 force_share = true;
2957 break;
2958 case OPTION_OBJECT: {
2959 QemuOpts *opts;
2960 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2961 optarg, true);
2962 if (!opts) {
2963 return 1;
2965 } break;
2966 case OPTION_IMAGE_OPTS:
2967 image_opts = true;
2968 break;
2972 if (optind != argc - 1) {
2973 error_exit("Expecting one image file name");
2975 filename = argv[optind++];
2977 if (qemu_opts_foreach(&qemu_object_opts,
2978 user_creatable_add_opts_foreach,
2979 NULL, NULL)) {
2980 return 1;
2983 /* Open the image */
2984 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
2985 force_share);
2986 if (!blk) {
2987 return 1;
2989 bs = blk_bs(blk);
2991 /* Perform the requested action */
2992 switch(action) {
2993 case SNAPSHOT_LIST:
2994 dump_snapshots(bs);
2995 break;
2997 case SNAPSHOT_CREATE:
2998 memset(&sn, 0, sizeof(sn));
2999 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3001 qemu_gettimeofday(&tv);
3002 sn.date_sec = tv.tv_sec;
3003 sn.date_nsec = tv.tv_usec * 1000;
3005 ret = bdrv_snapshot_create(bs, &sn);
3006 if (ret) {
3007 error_report("Could not create snapshot '%s': %d (%s)",
3008 snapshot_name, ret, strerror(-ret));
3010 break;
3012 case SNAPSHOT_APPLY:
3013 ret = bdrv_snapshot_goto(bs, snapshot_name);
3014 if (ret) {
3015 error_report("Could not apply snapshot '%s': %d (%s)",
3016 snapshot_name, ret, strerror(-ret));
3018 break;
3020 case SNAPSHOT_DELETE:
3021 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
3022 if (err) {
3023 error_reportf_err(err, "Could not delete snapshot '%s': ",
3024 snapshot_name);
3025 ret = 1;
3027 break;
3030 /* Cleanup */
3031 blk_unref(blk);
3032 if (ret) {
3033 return 1;
3035 return 0;
3038 static int img_rebase(int argc, char **argv)
3040 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
3041 uint8_t *buf_old = NULL;
3042 uint8_t *buf_new = NULL;
3043 BlockDriverState *bs = NULL;
3044 char *filename;
3045 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
3046 int c, flags, src_flags, ret;
3047 bool writethrough, src_writethrough;
3048 int unsafe = 0;
3049 bool force_share = false;
3050 int progress = 0;
3051 bool quiet = false;
3052 Error *local_err = NULL;
3053 bool image_opts = false;
3055 /* Parse commandline parameters */
3056 fmt = NULL;
3057 cache = BDRV_DEFAULT_CACHE;
3058 src_cache = BDRV_DEFAULT_CACHE;
3059 out_baseimg = NULL;
3060 out_basefmt = NULL;
3061 for(;;) {
3062 static const struct option long_options[] = {
3063 {"help", no_argument, 0, 'h'},
3064 {"object", required_argument, 0, OPTION_OBJECT},
3065 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3066 {"force-share", no_argument, 0, 'U'},
3067 {0, 0, 0, 0}
3069 c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU",
3070 long_options, NULL);
3071 if (c == -1) {
3072 break;
3074 switch(c) {
3075 case ':':
3076 missing_argument(argv[optind - 1]);
3077 break;
3078 case '?':
3079 unrecognized_option(argv[optind - 1]);
3080 break;
3081 case 'h':
3082 help();
3083 return 0;
3084 case 'f':
3085 fmt = optarg;
3086 break;
3087 case 'F':
3088 out_basefmt = optarg;
3089 break;
3090 case 'b':
3091 out_baseimg = optarg;
3092 break;
3093 case 'u':
3094 unsafe = 1;
3095 break;
3096 case 'p':
3097 progress = 1;
3098 break;
3099 case 't':
3100 cache = optarg;
3101 break;
3102 case 'T':
3103 src_cache = optarg;
3104 break;
3105 case 'q':
3106 quiet = true;
3107 break;
3108 case OPTION_OBJECT: {
3109 QemuOpts *opts;
3110 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3111 optarg, true);
3112 if (!opts) {
3113 return 1;
3115 } break;
3116 case OPTION_IMAGE_OPTS:
3117 image_opts = true;
3118 break;
3119 case 'U':
3120 force_share = true;
3121 break;
3125 if (quiet) {
3126 progress = 0;
3129 if (optind != argc - 1) {
3130 error_exit("Expecting one image file name");
3132 if (!unsafe && !out_baseimg) {
3133 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3135 filename = argv[optind++];
3137 if (qemu_opts_foreach(&qemu_object_opts,
3138 user_creatable_add_opts_foreach,
3139 NULL, NULL)) {
3140 return 1;
3143 qemu_progress_init(progress, 2.0);
3144 qemu_progress_print(0, 100);
3146 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
3147 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3148 if (ret < 0) {
3149 error_report("Invalid cache option: %s", cache);
3150 goto out;
3153 src_flags = 0;
3154 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
3155 if (ret < 0) {
3156 error_report("Invalid source cache option: %s", src_cache);
3157 goto out;
3160 /* The source files are opened read-only, don't care about WCE */
3161 assert((src_flags & BDRV_O_RDWR) == 0);
3162 (void) src_writethrough;
3165 * Open the images.
3167 * Ignore the old backing file for unsafe rebase in case we want to correct
3168 * the reference to a renamed or moved backing file.
3170 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3171 false);
3172 if (!blk) {
3173 ret = -1;
3174 goto out;
3176 bs = blk_bs(blk);
3178 if (out_basefmt != NULL) {
3179 if (bdrv_find_format(out_basefmt) == NULL) {
3180 error_report("Invalid format name: '%s'", out_basefmt);
3181 ret = -1;
3182 goto out;
3186 /* For safe rebasing we need to compare old and new backing file */
3187 if (!unsafe) {
3188 char backing_name[PATH_MAX];
3189 QDict *options = NULL;
3191 if (bs->backing_format[0] != '\0') {
3192 options = qdict_new();
3193 qdict_put_str(options, "driver", bs->backing_format);
3196 if (force_share) {
3197 if (!options) {
3198 options = qdict_new();
3200 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3202 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3203 blk_old_backing = blk_new_open(backing_name, NULL,
3204 options, src_flags, &local_err);
3205 if (!blk_old_backing) {
3206 error_reportf_err(local_err,
3207 "Could not open old backing file '%s': ",
3208 backing_name);
3209 ret = -1;
3210 goto out;
3213 if (out_baseimg[0]) {
3214 options = qdict_new();
3215 if (out_basefmt) {
3216 qdict_put_str(options, "driver", out_basefmt);
3218 if (force_share) {
3219 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3222 blk_new_backing = blk_new_open(out_baseimg, NULL,
3223 options, src_flags, &local_err);
3224 if (!blk_new_backing) {
3225 error_reportf_err(local_err,
3226 "Could not open new backing file '%s': ",
3227 out_baseimg);
3228 ret = -1;
3229 goto out;
3235 * Check each unallocated cluster in the COW file. If it is unallocated,
3236 * accesses go to the backing file. We must therefore compare this cluster
3237 * in the old and new backing file, and if they differ we need to copy it
3238 * from the old backing file into the COW file.
3240 * If qemu-img crashes during this step, no harm is done. The content of
3241 * the image is the same as the original one at any time.
3243 if (!unsafe) {
3244 int64_t num_sectors;
3245 int64_t old_backing_num_sectors;
3246 int64_t new_backing_num_sectors = 0;
3247 uint64_t sector;
3248 int n;
3249 int64_t count;
3250 float local_progress = 0;
3252 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
3253 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
3255 num_sectors = blk_nb_sectors(blk);
3256 if (num_sectors < 0) {
3257 error_report("Could not get size of '%s': %s",
3258 filename, strerror(-num_sectors));
3259 ret = -1;
3260 goto out;
3262 old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
3263 if (old_backing_num_sectors < 0) {
3264 char backing_name[PATH_MAX];
3266 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3267 error_report("Could not get size of '%s': %s",
3268 backing_name, strerror(-old_backing_num_sectors));
3269 ret = -1;
3270 goto out;
3272 if (blk_new_backing) {
3273 new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
3274 if (new_backing_num_sectors < 0) {
3275 error_report("Could not get size of '%s': %s",
3276 out_baseimg, strerror(-new_backing_num_sectors));
3277 ret = -1;
3278 goto out;
3282 if (num_sectors != 0) {
3283 local_progress = (float)100 /
3284 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
3287 for (sector = 0; sector < num_sectors; sector += n) {
3289 /* How many sectors can we handle with the next read? */
3290 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
3291 n = (IO_BUF_SIZE / 512);
3292 } else {
3293 n = num_sectors - sector;
3296 /* If the cluster is allocated, we don't need to take action */
3297 ret = bdrv_is_allocated(bs, sector << BDRV_SECTOR_BITS,
3298 n << BDRV_SECTOR_BITS, &count);
3299 if (ret < 0) {
3300 error_report("error while reading image metadata: %s",
3301 strerror(-ret));
3302 goto out;
3304 /* TODO relax this once bdrv_is_allocated does not enforce
3305 * sector alignment */
3306 assert(QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE));
3307 n = count >> BDRV_SECTOR_BITS;
3308 if (ret) {
3309 continue;
3313 * Read old and new backing file and take into consideration that
3314 * backing files may be smaller than the COW image.
3316 if (sector >= old_backing_num_sectors) {
3317 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
3318 } else {
3319 if (sector + n > old_backing_num_sectors) {
3320 n = old_backing_num_sectors - sector;
3323 ret = blk_pread(blk_old_backing, sector << BDRV_SECTOR_BITS,
3324 buf_old, n << BDRV_SECTOR_BITS);
3325 if (ret < 0) {
3326 error_report("error while reading from old backing file");
3327 goto out;
3331 if (sector >= new_backing_num_sectors || !blk_new_backing) {
3332 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
3333 } else {
3334 if (sector + n > new_backing_num_sectors) {
3335 n = new_backing_num_sectors - sector;
3338 ret = blk_pread(blk_new_backing, sector << BDRV_SECTOR_BITS,
3339 buf_new, n << BDRV_SECTOR_BITS);
3340 if (ret < 0) {
3341 error_report("error while reading from new backing file");
3342 goto out;
3346 /* If they differ, we need to write to the COW file */
3347 uint64_t written = 0;
3349 while (written < n) {
3350 int pnum;
3352 if (compare_sectors(buf_old + written * 512,
3353 buf_new + written * 512, n - written, &pnum))
3355 ret = blk_pwrite(blk,
3356 (sector + written) << BDRV_SECTOR_BITS,
3357 buf_old + written * 512,
3358 pnum << BDRV_SECTOR_BITS, 0);
3359 if (ret < 0) {
3360 error_report("Error while writing to COW image: %s",
3361 strerror(-ret));
3362 goto out;
3366 written += pnum;
3368 qemu_progress_print(local_progress, 100);
3373 * Change the backing file. All clusters that are different from the old
3374 * backing file are overwritten in the COW file now, so the visible content
3375 * doesn't change when we switch the backing file.
3377 if (out_baseimg && *out_baseimg) {
3378 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3379 } else {
3380 ret = bdrv_change_backing_file(bs, NULL, NULL);
3383 if (ret == -ENOSPC) {
3384 error_report("Could not change the backing file to '%s': No "
3385 "space left in the file header", out_baseimg);
3386 } else if (ret < 0) {
3387 error_report("Could not change the backing file to '%s': %s",
3388 out_baseimg, strerror(-ret));
3391 qemu_progress_print(100, 0);
3393 * TODO At this point it is possible to check if any clusters that are
3394 * allocated in the COW file are the same in the backing file. If so, they
3395 * could be dropped from the COW file. Don't do this before switching the
3396 * backing file, in case of a crash this would lead to corruption.
3398 out:
3399 qemu_progress_end();
3400 /* Cleanup */
3401 if (!unsafe) {
3402 blk_unref(blk_old_backing);
3403 blk_unref(blk_new_backing);
3405 qemu_vfree(buf_old);
3406 qemu_vfree(buf_new);
3408 blk_unref(blk);
3409 if (ret) {
3410 return 1;
3412 return 0;
3415 static int img_resize(int argc, char **argv)
3417 Error *err = NULL;
3418 int c, ret, relative;
3419 const char *filename, *fmt, *size;
3420 int64_t n, total_size, current_size;
3421 bool quiet = false;
3422 BlockBackend *blk = NULL;
3423 PreallocMode prealloc = PREALLOC_MODE_OFF;
3424 QemuOpts *param;
3426 static QemuOptsList resize_options = {
3427 .name = "resize_options",
3428 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3429 .desc = {
3431 .name = BLOCK_OPT_SIZE,
3432 .type = QEMU_OPT_SIZE,
3433 .help = "Virtual disk size"
3434 }, {
3435 /* end of list */
3439 bool image_opts = false;
3440 bool shrink = false;
3442 /* Remove size from argv manually so that negative numbers are not treated
3443 * as options by getopt. */
3444 if (argc < 3) {
3445 error_exit("Not enough arguments");
3446 return 1;
3449 size = argv[--argc];
3451 /* Parse getopt arguments */
3452 fmt = NULL;
3453 for(;;) {
3454 static const struct option long_options[] = {
3455 {"help", no_argument, 0, 'h'},
3456 {"object", required_argument, 0, OPTION_OBJECT},
3457 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3458 {"preallocation", required_argument, 0, OPTION_PREALLOCATION},
3459 {"shrink", no_argument, 0, OPTION_SHRINK},
3460 {0, 0, 0, 0}
3462 c = getopt_long(argc, argv, ":f:hq",
3463 long_options, NULL);
3464 if (c == -1) {
3465 break;
3467 switch(c) {
3468 case ':':
3469 missing_argument(argv[optind - 1]);
3470 break;
3471 case '?':
3472 unrecognized_option(argv[optind - 1]);
3473 break;
3474 case 'h':
3475 help();
3476 break;
3477 case 'f':
3478 fmt = optarg;
3479 break;
3480 case 'q':
3481 quiet = true;
3482 break;
3483 case OPTION_OBJECT: {
3484 QemuOpts *opts;
3485 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3486 optarg, true);
3487 if (!opts) {
3488 return 1;
3490 } break;
3491 case OPTION_IMAGE_OPTS:
3492 image_opts = true;
3493 break;
3494 case OPTION_PREALLOCATION:
3495 prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg,
3496 PREALLOC_MODE__MAX, NULL);
3497 if (prealloc == PREALLOC_MODE__MAX) {
3498 error_report("Invalid preallocation mode '%s'", optarg);
3499 return 1;
3501 break;
3502 case OPTION_SHRINK:
3503 shrink = true;
3504 break;
3507 if (optind != argc - 1) {
3508 error_exit("Expecting one image file name");
3510 filename = argv[optind++];
3512 if (qemu_opts_foreach(&qemu_object_opts,
3513 user_creatable_add_opts_foreach,
3514 NULL, NULL)) {
3515 return 1;
3518 /* Choose grow, shrink, or absolute resize mode */
3519 switch (size[0]) {
3520 case '+':
3521 relative = 1;
3522 size++;
3523 break;
3524 case '-':
3525 relative = -1;
3526 size++;
3527 break;
3528 default:
3529 relative = 0;
3530 break;
3533 /* Parse size */
3534 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3535 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3536 if (err) {
3537 error_report_err(err);
3538 ret = -1;
3539 qemu_opts_del(param);
3540 goto out;
3542 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3543 qemu_opts_del(param);
3545 blk = img_open(image_opts, filename, fmt,
3546 BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet,
3547 false);
3548 if (!blk) {
3549 ret = -1;
3550 goto out;
3553 current_size = blk_getlength(blk);
3554 if (current_size < 0) {
3555 error_report("Failed to inquire current image length: %s",
3556 strerror(-current_size));
3557 ret = -1;
3558 goto out;
3561 if (relative) {
3562 total_size = current_size + n * relative;
3563 } else {
3564 total_size = n;
3566 if (total_size <= 0) {
3567 error_report("New image size must be positive");
3568 ret = -1;
3569 goto out;
3572 if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) {
3573 error_report("Preallocation can only be used for growing images");
3574 ret = -1;
3575 goto out;
3578 if (total_size < current_size && !shrink) {
3579 warn_report("Shrinking an image will delete all data beyond the "
3580 "shrunken image's end. Before performing such an "
3581 "operation, make sure there is no important data there.");
3583 if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) {
3584 error_report(
3585 "Use the --shrink option to perform a shrink operation.");
3586 ret = -1;
3587 goto out;
3588 } else {
3589 warn_report("Using the --shrink option will suppress this message. "
3590 "Note that future versions of qemu-img may refuse to "
3591 "shrink images without this option.");
3595 ret = blk_truncate(blk, total_size, prealloc, &err);
3596 if (!ret) {
3597 qprintf(quiet, "Image resized.\n");
3598 } else {
3599 error_report_err(err);
3601 out:
3602 blk_unref(blk);
3603 if (ret) {
3604 return 1;
3606 return 0;
3609 static void amend_status_cb(BlockDriverState *bs,
3610 int64_t offset, int64_t total_work_size,
3611 void *opaque)
3613 qemu_progress_print(100.f * offset / total_work_size, 0);
3616 static int img_amend(int argc, char **argv)
3618 Error *err = NULL;
3619 int c, ret = 0;
3620 char *options = NULL;
3621 QemuOptsList *create_opts = NULL;
3622 QemuOpts *opts = NULL;
3623 const char *fmt = NULL, *filename, *cache;
3624 int flags;
3625 bool writethrough;
3626 bool quiet = false, progress = false;
3627 BlockBackend *blk = NULL;
3628 BlockDriverState *bs = NULL;
3629 bool image_opts = false;
3631 cache = BDRV_DEFAULT_CACHE;
3632 for (;;) {
3633 static const struct option long_options[] = {
3634 {"help", no_argument, 0, 'h'},
3635 {"object", required_argument, 0, OPTION_OBJECT},
3636 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3637 {0, 0, 0, 0}
3639 c = getopt_long(argc, argv, ":ho:f:t:pq",
3640 long_options, NULL);
3641 if (c == -1) {
3642 break;
3645 switch (c) {
3646 case ':':
3647 missing_argument(argv[optind - 1]);
3648 break;
3649 case '?':
3650 unrecognized_option(argv[optind - 1]);
3651 break;
3652 case 'h':
3653 help();
3654 break;
3655 case 'o':
3656 if (!is_valid_option_list(optarg)) {
3657 error_report("Invalid option list: %s", optarg);
3658 ret = -1;
3659 goto out_no_progress;
3661 if (!options) {
3662 options = g_strdup(optarg);
3663 } else {
3664 char *old_options = options;
3665 options = g_strdup_printf("%s,%s", options, optarg);
3666 g_free(old_options);
3668 break;
3669 case 'f':
3670 fmt = optarg;
3671 break;
3672 case 't':
3673 cache = optarg;
3674 break;
3675 case 'p':
3676 progress = true;
3677 break;
3678 case 'q':
3679 quiet = true;
3680 break;
3681 case OPTION_OBJECT:
3682 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3683 optarg, true);
3684 if (!opts) {
3685 ret = -1;
3686 goto out_no_progress;
3688 break;
3689 case OPTION_IMAGE_OPTS:
3690 image_opts = true;
3691 break;
3695 if (!options) {
3696 error_exit("Must specify options (-o)");
3699 if (qemu_opts_foreach(&qemu_object_opts,
3700 user_creatable_add_opts_foreach,
3701 NULL, NULL)) {
3702 ret = -1;
3703 goto out_no_progress;
3706 if (quiet) {
3707 progress = false;
3709 qemu_progress_init(progress, 1.0);
3711 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3712 if (fmt && has_help_option(options)) {
3713 /* If a format is explicitly specified (and possibly no filename is
3714 * given), print option help here */
3715 ret = print_block_option_help(filename, fmt);
3716 goto out;
3719 if (optind != argc - 1) {
3720 error_report("Expecting one image file name");
3721 ret = -1;
3722 goto out;
3725 flags = BDRV_O_RDWR;
3726 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3727 if (ret < 0) {
3728 error_report("Invalid cache option: %s", cache);
3729 goto out;
3732 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3733 false);
3734 if (!blk) {
3735 ret = -1;
3736 goto out;
3738 bs = blk_bs(blk);
3740 fmt = bs->drv->format_name;
3742 if (has_help_option(options)) {
3743 /* If the format was auto-detected, print option help here */
3744 ret = print_block_option_help(filename, fmt);
3745 goto out;
3748 if (!bs->drv->create_opts) {
3749 error_report("Format driver '%s' does not support any options to amend",
3750 fmt);
3751 ret = -1;
3752 goto out;
3755 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3756 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3757 qemu_opts_do_parse(opts, options, NULL, &err);
3758 if (err) {
3759 error_report_err(err);
3760 ret = -1;
3761 goto out;
3764 /* In case the driver does not call amend_status_cb() */
3765 qemu_progress_print(0.f, 0);
3766 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
3767 qemu_progress_print(100.f, 0);
3768 if (ret < 0) {
3769 error_report("Error while amending options: %s", strerror(-ret));
3770 goto out;
3773 out:
3774 qemu_progress_end();
3776 out_no_progress:
3777 blk_unref(blk);
3778 qemu_opts_del(opts);
3779 qemu_opts_free(create_opts);
3780 g_free(options);
3782 if (ret) {
3783 return 1;
3785 return 0;
3788 typedef struct BenchData {
3789 BlockBackend *blk;
3790 uint64_t image_size;
3791 bool write;
3792 int bufsize;
3793 int step;
3794 int nrreq;
3795 int n;
3796 int flush_interval;
3797 bool drain_on_flush;
3798 uint8_t *buf;
3799 QEMUIOVector *qiov;
3801 int in_flight;
3802 bool in_flush;
3803 uint64_t offset;
3804 } BenchData;
3806 static void bench_undrained_flush_cb(void *opaque, int ret)
3808 if (ret < 0) {
3809 error_report("Failed flush request: %s", strerror(-ret));
3810 exit(EXIT_FAILURE);
3814 static void bench_cb(void *opaque, int ret)
3816 BenchData *b = opaque;
3817 BlockAIOCB *acb;
3819 if (ret < 0) {
3820 error_report("Failed request: %s", strerror(-ret));
3821 exit(EXIT_FAILURE);
3824 if (b->in_flush) {
3825 /* Just finished a flush with drained queue: Start next requests */
3826 assert(b->in_flight == 0);
3827 b->in_flush = false;
3828 } else if (b->in_flight > 0) {
3829 int remaining = b->n - b->in_flight;
3831 b->n--;
3832 b->in_flight--;
3834 /* Time for flush? Drain queue if requested, then flush */
3835 if (b->flush_interval && remaining % b->flush_interval == 0) {
3836 if (!b->in_flight || !b->drain_on_flush) {
3837 BlockCompletionFunc *cb;
3839 if (b->drain_on_flush) {
3840 b->in_flush = true;
3841 cb = bench_cb;
3842 } else {
3843 cb = bench_undrained_flush_cb;
3846 acb = blk_aio_flush(b->blk, cb, b);
3847 if (!acb) {
3848 error_report("Failed to issue flush request");
3849 exit(EXIT_FAILURE);
3852 if (b->drain_on_flush) {
3853 return;
3858 while (b->n > b->in_flight && b->in_flight < b->nrreq) {
3859 int64_t offset = b->offset;
3860 /* blk_aio_* might look for completed I/Os and kick bench_cb
3861 * again, so make sure this operation is counted by in_flight
3862 * and b->offset is ready for the next submission.
3864 b->in_flight++;
3865 b->offset += b->step;
3866 b->offset %= b->image_size;
3867 if (b->write) {
3868 acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b);
3869 } else {
3870 acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b);
3872 if (!acb) {
3873 error_report("Failed to issue request");
3874 exit(EXIT_FAILURE);
3879 static int img_bench(int argc, char **argv)
3881 int c, ret = 0;
3882 const char *fmt = NULL, *filename;
3883 bool quiet = false;
3884 bool image_opts = false;
3885 bool is_write = false;
3886 int count = 75000;
3887 int depth = 64;
3888 int64_t offset = 0;
3889 size_t bufsize = 4096;
3890 int pattern = 0;
3891 size_t step = 0;
3892 int flush_interval = 0;
3893 bool drain_on_flush = true;
3894 int64_t image_size;
3895 BlockBackend *blk = NULL;
3896 BenchData data = {};
3897 int flags = 0;
3898 bool writethrough = false;
3899 struct timeval t1, t2;
3900 int i;
3901 bool force_share = false;
3903 for (;;) {
3904 static const struct option long_options[] = {
3905 {"help", no_argument, 0, 'h'},
3906 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
3907 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3908 {"pattern", required_argument, 0, OPTION_PATTERN},
3909 {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
3910 {"force-share", no_argument, 0, 'U'},
3911 {0, 0, 0, 0}
3913 c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
3914 if (c == -1) {
3915 break;
3918 switch (c) {
3919 case ':':
3920 missing_argument(argv[optind - 1]);
3921 break;
3922 case '?':
3923 unrecognized_option(argv[optind - 1]);
3924 break;
3925 case 'h':
3926 help();
3927 break;
3928 case 'c':
3930 unsigned long res;
3932 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
3933 error_report("Invalid request count specified");
3934 return 1;
3936 count = res;
3937 break;
3939 case 'd':
3941 unsigned long res;
3943 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
3944 error_report("Invalid queue depth specified");
3945 return 1;
3947 depth = res;
3948 break;
3950 case 'f':
3951 fmt = optarg;
3952 break;
3953 case 'n':
3954 flags |= BDRV_O_NATIVE_AIO;
3955 break;
3956 case 'o':
3958 offset = cvtnum(optarg);
3959 if (offset < 0) {
3960 error_report("Invalid offset specified");
3961 return 1;
3963 break;
3965 break;
3966 case 'q':
3967 quiet = true;
3968 break;
3969 case 's':
3971 int64_t sval;
3973 sval = cvtnum(optarg);
3974 if (sval < 0 || sval > INT_MAX) {
3975 error_report("Invalid buffer size specified");
3976 return 1;
3979 bufsize = sval;
3980 break;
3982 case 'S':
3984 int64_t sval;
3986 sval = cvtnum(optarg);
3987 if (sval < 0 || sval > INT_MAX) {
3988 error_report("Invalid step size specified");
3989 return 1;
3992 step = sval;
3993 break;
3995 case 't':
3996 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
3997 if (ret < 0) {
3998 error_report("Invalid cache mode");
3999 ret = -1;
4000 goto out;
4002 break;
4003 case 'w':
4004 flags |= BDRV_O_RDWR;
4005 is_write = true;
4006 break;
4007 case 'U':
4008 force_share = true;
4009 break;
4010 case OPTION_PATTERN:
4012 unsigned long res;
4014 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
4015 error_report("Invalid pattern byte specified");
4016 return 1;
4018 pattern = res;
4019 break;
4021 case OPTION_FLUSH_INTERVAL:
4023 unsigned long res;
4025 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4026 error_report("Invalid flush interval specified");
4027 return 1;
4029 flush_interval = res;
4030 break;
4032 case OPTION_NO_DRAIN:
4033 drain_on_flush = false;
4034 break;
4035 case OPTION_IMAGE_OPTS:
4036 image_opts = true;
4037 break;
4041 if (optind != argc - 1) {
4042 error_exit("Expecting one image file name");
4044 filename = argv[argc - 1];
4046 if (!is_write && flush_interval) {
4047 error_report("--flush-interval is only available in write tests");
4048 ret = -1;
4049 goto out;
4051 if (flush_interval && flush_interval < depth) {
4052 error_report("Flush interval can't be smaller than depth");
4053 ret = -1;
4054 goto out;
4057 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4058 force_share);
4059 if (!blk) {
4060 ret = -1;
4061 goto out;
4064 image_size = blk_getlength(blk);
4065 if (image_size < 0) {
4066 ret = image_size;
4067 goto out;
4070 data = (BenchData) {
4071 .blk = blk,
4072 .image_size = image_size,
4073 .bufsize = bufsize,
4074 .step = step ?: bufsize,
4075 .nrreq = depth,
4076 .n = count,
4077 .offset = offset,
4078 .write = is_write,
4079 .flush_interval = flush_interval,
4080 .drain_on_flush = drain_on_flush,
4082 printf("Sending %d %s requests, %d bytes each, %d in parallel "
4083 "(starting at offset %" PRId64 ", step size %d)\n",
4084 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
4085 data.offset, data.step);
4086 if (flush_interval) {
4087 printf("Sending flush every %d requests\n", flush_interval);
4090 data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);
4091 memset(data.buf, pattern, data.nrreq * data.bufsize);
4093 data.qiov = g_new(QEMUIOVector, data.nrreq);
4094 for (i = 0; i < data.nrreq; i++) {
4095 qemu_iovec_init(&data.qiov[i], 1);
4096 qemu_iovec_add(&data.qiov[i],
4097 data.buf + i * data.bufsize, data.bufsize);
4100 gettimeofday(&t1, NULL);
4101 bench_cb(&data, 0);
4103 while (data.n > 0) {
4104 main_loop_wait(false);
4106 gettimeofday(&t2, NULL);
4108 printf("Run completed in %3.3f seconds.\n",
4109 (t2.tv_sec - t1.tv_sec)
4110 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
4112 out:
4113 qemu_vfree(data.buf);
4114 blk_unref(blk);
4116 if (ret) {
4117 return 1;
4119 return 0;
4122 #define C_BS 01
4123 #define C_COUNT 02
4124 #define C_IF 04
4125 #define C_OF 010
4126 #define C_SKIP 020
4128 struct DdInfo {
4129 unsigned int flags;
4130 int64_t count;
4133 struct DdIo {
4134 int bsz; /* Block size */
4135 char *filename;
4136 uint8_t *buf;
4137 int64_t offset;
4140 struct DdOpts {
4141 const char *name;
4142 int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
4143 unsigned int flag;
4146 static int img_dd_bs(const char *arg,
4147 struct DdIo *in, struct DdIo *out,
4148 struct DdInfo *dd)
4150 int64_t res;
4152 res = cvtnum(arg);
4154 if (res <= 0 || res > INT_MAX) {
4155 error_report("invalid number: '%s'", arg);
4156 return 1;
4158 in->bsz = out->bsz = res;
4160 return 0;
4163 static int img_dd_count(const char *arg,
4164 struct DdIo *in, struct DdIo *out,
4165 struct DdInfo *dd)
4167 dd->count = cvtnum(arg);
4169 if (dd->count < 0) {
4170 error_report("invalid number: '%s'", arg);
4171 return 1;
4174 return 0;
4177 static int img_dd_if(const char *arg,
4178 struct DdIo *in, struct DdIo *out,
4179 struct DdInfo *dd)
4181 in->filename = g_strdup(arg);
4183 return 0;
4186 static int img_dd_of(const char *arg,
4187 struct DdIo *in, struct DdIo *out,
4188 struct DdInfo *dd)
4190 out->filename = g_strdup(arg);
4192 return 0;
4195 static int img_dd_skip(const char *arg,
4196 struct DdIo *in, struct DdIo *out,
4197 struct DdInfo *dd)
4199 in->offset = cvtnum(arg);
4201 if (in->offset < 0) {
4202 error_report("invalid number: '%s'", arg);
4203 return 1;
4206 return 0;
4209 static int img_dd(int argc, char **argv)
4211 int ret = 0;
4212 char *arg = NULL;
4213 char *tmp;
4214 BlockDriver *drv = NULL, *proto_drv = NULL;
4215 BlockBackend *blk1 = NULL, *blk2 = NULL;
4216 QemuOpts *opts = NULL;
4217 QemuOptsList *create_opts = NULL;
4218 Error *local_err = NULL;
4219 bool image_opts = false;
4220 int c, i;
4221 const char *out_fmt = "raw";
4222 const char *fmt = NULL;
4223 int64_t size = 0;
4224 int64_t block_count = 0, out_pos, in_pos;
4225 bool force_share = false;
4226 struct DdInfo dd = {
4227 .flags = 0,
4228 .count = 0,
4230 struct DdIo in = {
4231 .bsz = 512, /* Block size is by default 512 bytes */
4232 .filename = NULL,
4233 .buf = NULL,
4234 .offset = 0
4236 struct DdIo out = {
4237 .bsz = 512,
4238 .filename = NULL,
4239 .buf = NULL,
4240 .offset = 0
4243 const struct DdOpts options[] = {
4244 { "bs", img_dd_bs, C_BS },
4245 { "count", img_dd_count, C_COUNT },
4246 { "if", img_dd_if, C_IF },
4247 { "of", img_dd_of, C_OF },
4248 { "skip", img_dd_skip, C_SKIP },
4249 { NULL, NULL, 0 }
4251 const struct option long_options[] = {
4252 { "help", no_argument, 0, 'h'},
4253 { "object", required_argument, 0, OPTION_OBJECT},
4254 { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4255 { "force-share", no_argument, 0, 'U'},
4256 { 0, 0, 0, 0 }
4259 while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) {
4260 if (c == EOF) {
4261 break;
4263 switch (c) {
4264 case 'O':
4265 out_fmt = optarg;
4266 break;
4267 case 'f':
4268 fmt = optarg;
4269 break;
4270 case ':':
4271 missing_argument(argv[optind - 1]);
4272 break;
4273 case '?':
4274 unrecognized_option(argv[optind - 1]);
4275 break;
4276 case 'h':
4277 help();
4278 break;
4279 case 'U':
4280 force_share = true;
4281 break;
4282 case OPTION_OBJECT:
4283 if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) {
4284 ret = -1;
4285 goto out;
4287 break;
4288 case OPTION_IMAGE_OPTS:
4289 image_opts = true;
4290 break;
4294 for (i = optind; i < argc; i++) {
4295 int j;
4296 arg = g_strdup(argv[i]);
4298 tmp = strchr(arg, '=');
4299 if (tmp == NULL) {
4300 error_report("unrecognized operand %s", arg);
4301 ret = -1;
4302 goto out;
4305 *tmp++ = '\0';
4307 for (j = 0; options[j].name != NULL; j++) {
4308 if (!strcmp(arg, options[j].name)) {
4309 break;
4312 if (options[j].name == NULL) {
4313 error_report("unrecognized operand %s", arg);
4314 ret = -1;
4315 goto out;
4318 if (options[j].f(tmp, &in, &out, &dd) != 0) {
4319 ret = -1;
4320 goto out;
4322 dd.flags |= options[j].flag;
4323 g_free(arg);
4324 arg = NULL;
4327 if (!(dd.flags & C_IF && dd.flags & C_OF)) {
4328 error_report("Must specify both input and output files");
4329 ret = -1;
4330 goto out;
4333 if (qemu_opts_foreach(&qemu_object_opts,
4334 user_creatable_add_opts_foreach,
4335 NULL, NULL)) {
4336 ret = -1;
4337 goto out;
4340 blk1 = img_open(image_opts, in.filename, fmt, 0, false, false,
4341 force_share);
4343 if (!blk1) {
4344 ret = -1;
4345 goto out;
4348 drv = bdrv_find_format(out_fmt);
4349 if (!drv) {
4350 error_report("Unknown file format");
4351 ret = -1;
4352 goto out;
4354 proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
4356 if (!proto_drv) {
4357 error_report_err(local_err);
4358 ret = -1;
4359 goto out;
4361 if (!drv->create_opts) {
4362 error_report("Format driver '%s' does not support image creation",
4363 drv->format_name);
4364 ret = -1;
4365 goto out;
4367 if (!proto_drv->create_opts) {
4368 error_report("Protocol driver '%s' does not support image creation",
4369 proto_drv->format_name);
4370 ret = -1;
4371 goto out;
4373 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4374 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4376 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4378 size = blk_getlength(blk1);
4379 if (size < 0) {
4380 error_report("Failed to get size for '%s'", in.filename);
4381 ret = -1;
4382 goto out;
4385 if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz &&
4386 dd.count * in.bsz < size) {
4387 size = dd.count * in.bsz;
4390 /* Overflow means the specified offset is beyond input image's size */
4391 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4392 size < in.bsz * in.offset)) {
4393 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort);
4394 } else {
4395 qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
4396 size - in.bsz * in.offset, &error_abort);
4399 ret = bdrv_create(drv, out.filename, opts, &local_err);
4400 if (ret < 0) {
4401 error_reportf_err(local_err,
4402 "%s: error while creating output image: ",
4403 out.filename);
4404 ret = -1;
4405 goto out;
4408 /* TODO, we can't honour --image-opts for the target,
4409 * since it needs to be given in a format compatible
4410 * with the bdrv_create() call above which does not
4411 * support image-opts style.
4413 blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR,
4414 false, false, false);
4416 if (!blk2) {
4417 ret = -1;
4418 goto out;
4421 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4422 size < in.offset * in.bsz)) {
4423 /* We give a warning if the skip option is bigger than the input
4424 * size and create an empty output disk image (i.e. like dd(1)).
4426 error_report("%s: cannot skip to specified offset", in.filename);
4427 in_pos = size;
4428 } else {
4429 in_pos = in.offset * in.bsz;
4432 in.buf = g_new(uint8_t, in.bsz);
4434 for (out_pos = 0; in_pos < size; block_count++) {
4435 int in_ret, out_ret;
4437 if (in_pos + in.bsz > size) {
4438 in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
4439 } else {
4440 in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
4442 if (in_ret < 0) {
4443 error_report("error while reading from input image file: %s",
4444 strerror(-in_ret));
4445 ret = -1;
4446 goto out;
4448 in_pos += in_ret;
4450 out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
4452 if (out_ret < 0) {
4453 error_report("error while writing to output image file: %s",
4454 strerror(-out_ret));
4455 ret = -1;
4456 goto out;
4458 out_pos += out_ret;
4461 out:
4462 g_free(arg);
4463 qemu_opts_del(opts);
4464 qemu_opts_free(create_opts);
4465 blk_unref(blk1);
4466 blk_unref(blk2);
4467 g_free(in.filename);
4468 g_free(out.filename);
4469 g_free(in.buf);
4470 g_free(out.buf);
4472 if (ret) {
4473 return 1;
4475 return 0;
4478 static void dump_json_block_measure_info(BlockMeasureInfo *info)
4480 QString *str;
4481 QObject *obj;
4482 Visitor *v = qobject_output_visitor_new(&obj);
4484 visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort);
4485 visit_complete(v, &obj);
4486 str = qobject_to_json_pretty(obj);
4487 assert(str != NULL);
4488 printf("%s\n", qstring_get_str(str));
4489 qobject_decref(obj);
4490 visit_free(v);
4491 QDECREF(str);
4494 static int img_measure(int argc, char **argv)
4496 static const struct option long_options[] = {
4497 {"help", no_argument, 0, 'h'},
4498 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4499 {"object", required_argument, 0, OPTION_OBJECT},
4500 {"output", required_argument, 0, OPTION_OUTPUT},
4501 {"size", required_argument, 0, OPTION_SIZE},
4502 {"force-share", no_argument, 0, 'U'},
4503 {0, 0, 0, 0}
4505 OutputFormat output_format = OFORMAT_HUMAN;
4506 BlockBackend *in_blk = NULL;
4507 BlockDriver *drv;
4508 const char *filename = NULL;
4509 const char *fmt = NULL;
4510 const char *out_fmt = "raw";
4511 char *options = NULL;
4512 char *snapshot_name = NULL;
4513 bool force_share = false;
4514 QemuOpts *opts = NULL;
4515 QemuOpts *object_opts = NULL;
4516 QemuOpts *sn_opts = NULL;
4517 QemuOptsList *create_opts = NULL;
4518 bool image_opts = false;
4519 uint64_t img_size = UINT64_MAX;
4520 BlockMeasureInfo *info = NULL;
4521 Error *local_err = NULL;
4522 int ret = 1;
4523 int c;
4525 while ((c = getopt_long(argc, argv, "hf:O:o:l:U",
4526 long_options, NULL)) != -1) {
4527 switch (c) {
4528 case '?':
4529 case 'h':
4530 help();
4531 break;
4532 case 'f':
4533 fmt = optarg;
4534 break;
4535 case 'O':
4536 out_fmt = optarg;
4537 break;
4538 case 'o':
4539 if (!is_valid_option_list(optarg)) {
4540 error_report("Invalid option list: %s", optarg);
4541 goto out;
4543 if (!options) {
4544 options = g_strdup(optarg);
4545 } else {
4546 char *old_options = options;
4547 options = g_strdup_printf("%s,%s", options, optarg);
4548 g_free(old_options);
4550 break;
4551 case 'l':
4552 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
4553 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
4554 optarg, false);
4555 if (!sn_opts) {
4556 error_report("Failed in parsing snapshot param '%s'",
4557 optarg);
4558 goto out;
4560 } else {
4561 snapshot_name = optarg;
4563 break;
4564 case 'U':
4565 force_share = true;
4566 break;
4567 case OPTION_OBJECT:
4568 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
4569 optarg, true);
4570 if (!object_opts) {
4571 goto out;
4573 break;
4574 case OPTION_IMAGE_OPTS:
4575 image_opts = true;
4576 break;
4577 case OPTION_OUTPUT:
4578 if (!strcmp(optarg, "json")) {
4579 output_format = OFORMAT_JSON;
4580 } else if (!strcmp(optarg, "human")) {
4581 output_format = OFORMAT_HUMAN;
4582 } else {
4583 error_report("--output must be used with human or json "
4584 "as argument.");
4585 goto out;
4587 break;
4588 case OPTION_SIZE:
4590 int64_t sval;
4592 sval = cvtnum(optarg);
4593 if (sval < 0) {
4594 if (sval == -ERANGE) {
4595 error_report("Image size must be less than 8 EiB!");
4596 } else {
4597 error_report("Invalid image size specified! You may use "
4598 "k, M, G, T, P or E suffixes for ");
4599 error_report("kilobytes, megabytes, gigabytes, terabytes, "
4600 "petabytes and exabytes.");
4602 goto out;
4604 img_size = (uint64_t)sval;
4606 break;
4610 if (qemu_opts_foreach(&qemu_object_opts,
4611 user_creatable_add_opts_foreach,
4612 NULL, NULL)) {
4613 goto out;
4616 if (argc - optind > 1) {
4617 error_report("At most one filename argument is allowed.");
4618 goto out;
4619 } else if (argc - optind == 1) {
4620 filename = argv[optind];
4623 if (!filename &&
4624 (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
4625 error_report("--object, --image-opts, -f, and -l "
4626 "require a filename argument.");
4627 goto out;
4629 if (filename && img_size != UINT64_MAX) {
4630 error_report("--size N cannot be used together with a filename.");
4631 goto out;
4633 if (!filename && img_size == UINT64_MAX) {
4634 error_report("Either --size N or one filename must be specified.");
4635 goto out;
4638 if (filename) {
4639 in_blk = img_open(image_opts, filename, fmt, 0,
4640 false, false, force_share);
4641 if (!in_blk) {
4642 goto out;
4645 if (sn_opts) {
4646 bdrv_snapshot_load_tmp(blk_bs(in_blk),
4647 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
4648 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
4649 &local_err);
4650 } else if (snapshot_name != NULL) {
4651 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk),
4652 snapshot_name, &local_err);
4654 if (local_err) {
4655 error_reportf_err(local_err, "Failed to load snapshot: ");
4656 goto out;
4660 drv = bdrv_find_format(out_fmt);
4661 if (!drv) {
4662 error_report("Unknown file format '%s'", out_fmt);
4663 goto out;
4665 if (!drv->create_opts) {
4666 error_report("Format driver '%s' does not support image creation",
4667 drv->format_name);
4668 goto out;
4671 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4672 create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
4673 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4674 if (options) {
4675 qemu_opts_do_parse(opts, options, NULL, &local_err);
4676 if (local_err) {
4677 error_report_err(local_err);
4678 error_report("Invalid options for file format '%s'", out_fmt);
4679 goto out;
4682 if (img_size != UINT64_MAX) {
4683 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4686 info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err);
4687 if (local_err) {
4688 error_report_err(local_err);
4689 goto out;
4692 if (output_format == OFORMAT_HUMAN) {
4693 printf("required size: %" PRIu64 "\n", info->required);
4694 printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated);
4695 } else {
4696 dump_json_block_measure_info(info);
4699 ret = 0;
4701 out:
4702 qapi_free_BlockMeasureInfo(info);
4703 qemu_opts_del(object_opts);
4704 qemu_opts_del(opts);
4705 qemu_opts_del(sn_opts);
4706 qemu_opts_free(create_opts);
4707 g_free(options);
4708 blk_unref(in_blk);
4709 return ret;
4712 static const img_cmd_t img_cmds[] = {
4713 #define DEF(option, callback, arg_string) \
4714 { option, callback },
4715 #include "qemu-img-cmds.h"
4716 #undef DEF
4717 #undef GEN_DOCS
4718 { NULL, NULL, },
4721 int main(int argc, char **argv)
4723 const img_cmd_t *cmd;
4724 const char *cmdname;
4725 Error *local_error = NULL;
4726 char *trace_file = NULL;
4727 int c;
4728 static const struct option long_options[] = {
4729 {"help", no_argument, 0, 'h'},
4730 {"version", no_argument, 0, 'V'},
4731 {"trace", required_argument, NULL, 'T'},
4732 {0, 0, 0, 0}
4735 #ifdef CONFIG_POSIX
4736 signal(SIGPIPE, SIG_IGN);
4737 #endif
4739 module_call_init(MODULE_INIT_TRACE);
4740 error_set_progname(argv[0]);
4741 qemu_init_exec_dir(argv[0]);
4743 if (qemu_init_main_loop(&local_error)) {
4744 error_report_err(local_error);
4745 exit(EXIT_FAILURE);
4748 qcrypto_init(&error_fatal);
4750 module_call_init(MODULE_INIT_QOM);
4751 bdrv_init();
4752 if (argc < 2) {
4753 error_exit("Not enough arguments");
4756 qemu_add_opts(&qemu_object_opts);
4757 qemu_add_opts(&qemu_source_opts);
4758 qemu_add_opts(&qemu_trace_opts);
4760 while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) {
4761 switch (c) {
4762 case ':':
4763 missing_argument(argv[optind - 1]);
4764 return 0;
4765 case '?':
4766 unrecognized_option(argv[optind - 1]);
4767 return 0;
4768 case 'h':
4769 help();
4770 return 0;
4771 case 'V':
4772 printf(QEMU_IMG_VERSION);
4773 return 0;
4774 case 'T':
4775 g_free(trace_file);
4776 trace_file = trace_opt_parse(optarg);
4777 break;
4781 cmdname = argv[optind];
4783 /* reset getopt_long scanning */
4784 argc -= optind;
4785 if (argc < 1) {
4786 return 0;
4788 argv += optind;
4789 optind = 0;
4791 if (!trace_init_backends()) {
4792 exit(1);
4794 trace_init_file(trace_file);
4795 qemu_set_log(LOG_TRACE);
4797 /* find the command */
4798 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
4799 if (!strcmp(cmdname, cmd->name)) {
4800 return cmd->handler(argc, argv);
4804 /* not found */
4805 error_exit("Command not found: %s", cmdname);