test-bdrv-drain: AIO_WAIT_WHILE() in job .commit/.abort
[qemu/ar7.git] / qemu-img.c
blobb12f4cd19b0a938dba9f5d8b3bfde5d52ab7bfae
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.
25 #include "qemu/osdep.h"
26 #include <getopt.h>
28 #include "qemu-version.h"
29 #include "qapi/error.h"
30 #include "qapi/qapi-visit-block-core.h"
31 #include "qapi/qobject-output-visitor.h"
32 #include "qapi/qmp/qjson.h"
33 #include "qapi/qmp/qdict.h"
34 #include "qapi/qmp/qstring.h"
35 #include "qemu/cutils.h"
36 #include "qemu/config-file.h"
37 #include "qemu/option.h"
38 #include "qemu/error-report.h"
39 #include "qemu/log.h"
40 #include "qom/object_interfaces.h"
41 #include "sysemu/sysemu.h"
42 #include "sysemu/block-backend.h"
43 #include "block/block_int.h"
44 #include "block/blockjob.h"
45 #include "block/qapi.h"
46 #include "crypto/init.h"
47 #include "trace/control.h"
49 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \
50 "\n" QEMU_COPYRIGHT "\n"
52 typedef struct img_cmd_t {
53 const char *name;
54 int (*handler)(int argc, char **argv);
55 } img_cmd_t;
57 enum {
58 OPTION_OUTPUT = 256,
59 OPTION_BACKING_CHAIN = 257,
60 OPTION_OBJECT = 258,
61 OPTION_IMAGE_OPTS = 259,
62 OPTION_PATTERN = 260,
63 OPTION_FLUSH_INTERVAL = 261,
64 OPTION_NO_DRAIN = 262,
65 OPTION_TARGET_IMAGE_OPTS = 263,
66 OPTION_SIZE = 264,
67 OPTION_PREALLOCATION = 265,
68 OPTION_SHRINK = 266,
71 typedef enum OutputFormat {
72 OFORMAT_JSON,
73 OFORMAT_HUMAN,
74 } OutputFormat;
76 /* Default to cache=writeback as data integrity is not important for qemu-img */
77 #define BDRV_DEFAULT_CACHE "writeback"
79 static void format_print(void *opaque, const char *name)
81 printf(" %s", name);
84 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
86 va_list ap;
88 error_printf("qemu-img: ");
90 va_start(ap, fmt);
91 error_vprintf(fmt, ap);
92 va_end(ap);
94 error_printf("\nTry 'qemu-img --help' for more information\n");
95 exit(EXIT_FAILURE);
98 static void QEMU_NORETURN missing_argument(const char *option)
100 error_exit("missing argument for option '%s'", option);
103 static void QEMU_NORETURN unrecognized_option(const char *option)
105 error_exit("unrecognized option '%s'", option);
108 /* Please keep in synch with qemu-img.texi */
109 static void QEMU_NORETURN help(void)
111 const char *help_msg =
112 QEMU_IMG_VERSION
113 "usage: qemu-img [standard options] command [command options]\n"
114 "QEMU disk image utility\n"
115 "\n"
116 " '-h', '--help' display this help and exit\n"
117 " '-V', '--version' output version information and exit\n"
118 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
119 " specify tracing options\n"
120 "\n"
121 "Command syntax:\n"
122 #define DEF(option, callback, arg_string) \
123 " " arg_string "\n"
124 #include "qemu-img-cmds.h"
125 #undef DEF
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 " '-c' indicates that target image must be compressed (qcow format only)\n"
152 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
153 " new backing file match exactly. The image doesn't need a working\n"
154 " backing file before rebasing in this case (useful for renaming the\n"
155 " backing file). For image creation, allow creating without attempting\n"
156 " to open the backing file.\n"
157 " '-h' with or without a command shows this help and lists the supported formats\n"
158 " '-p' show progress of command (only certain commands)\n"
159 " '-q' use Quiet mode - do not print any output (except errors)\n"
160 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
161 " contain only zeros for qemu-img to create a sparse image during\n"
162 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
163 " unallocated or zero sectors, and the destination image will always be\n"
164 " fully allocated\n"
165 " '--output' takes the format in which the output must be done (human or json)\n"
166 " '-n' skips the target volume creation (useful if the volume is created\n"
167 " prior to running qemu-img)\n"
168 "\n"
169 "Parameters to check subcommand:\n"
170 " '-r' tries to repair any inconsistencies that are found during the check.\n"
171 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
172 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
173 " hiding corruption that has already occurred.\n"
174 "\n"
175 "Parameters to convert subcommand:\n"
176 " '-m' specifies how many coroutines work in parallel during the convert\n"
177 " process (defaults to 8)\n"
178 " '-W' allow to write to the target out of order rather than sequential\n"
179 "\n"
180 "Parameters to snapshot subcommand:\n"
181 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
182 " '-a' applies a snapshot (revert disk to saved state)\n"
183 " '-c' creates a snapshot\n"
184 " '-d' deletes a snapshot\n"
185 " '-l' lists all snapshots in the given image\n"
186 "\n"
187 "Parameters to compare subcommand:\n"
188 " '-f' first image format\n"
189 " '-F' second image format\n"
190 " '-s' run in Strict mode - fail on different image size or sector allocation\n"
191 "\n"
192 "Parameters to dd subcommand:\n"
193 " 'bs=BYTES' read and write up to BYTES bytes at a time "
194 "(default: 512)\n"
195 " 'count=N' copy only N input blocks\n"
196 " 'if=FILE' read from FILE\n"
197 " 'of=FILE' write to FILE\n"
198 " 'skip=N' skip N bs-sized blocks at the start of input\n";
200 printf("%s\nSupported formats:", help_msg);
201 bdrv_iterate_format(format_print, NULL);
202 printf("\n\n" QEMU_HELP_BOTTOM "\n");
203 exit(EXIT_SUCCESS);
206 static QemuOptsList qemu_object_opts = {
207 .name = "object",
208 .implied_opt_name = "qom-type",
209 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
210 .desc = {
215 static QemuOptsList qemu_source_opts = {
216 .name = "source",
217 .implied_opt_name = "file",
218 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
219 .desc = {
224 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
226 int ret = 0;
227 if (!quiet) {
228 va_list args;
229 va_start(args, fmt);
230 ret = vprintf(fmt, args);
231 va_end(args);
233 return ret;
237 static int print_block_option_help(const char *filename, const char *fmt)
239 BlockDriver *drv, *proto_drv;
240 QemuOptsList *create_opts = NULL;
241 Error *local_err = NULL;
243 /* Find driver and parse its options */
244 drv = bdrv_find_format(fmt);
245 if (!drv) {
246 error_report("Unknown file format '%s'", fmt);
247 return 1;
250 if (!drv->create_opts) {
251 error_report("Format driver '%s' does not support image creation", fmt);
252 return 1;
255 create_opts = qemu_opts_append(create_opts, drv->create_opts);
256 if (filename) {
257 proto_drv = bdrv_find_protocol(filename, true, &local_err);
258 if (!proto_drv) {
259 error_report_err(local_err);
260 qemu_opts_free(create_opts);
261 return 1;
263 if (!proto_drv->create_opts) {
264 error_report("Protocal driver '%s' does not support image creation",
265 proto_drv->format_name);
266 return 1;
268 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
271 printf("Supported options:\n");
272 qemu_opts_print_help(create_opts);
273 qemu_opts_free(create_opts);
274 return 0;
278 static BlockBackend *img_open_opts(const char *optstr,
279 QemuOpts *opts, int flags, bool writethrough,
280 bool quiet, bool force_share)
282 QDict *options;
283 Error *local_err = NULL;
284 BlockBackend *blk;
285 options = qemu_opts_to_qdict(opts, NULL);
286 if (force_share) {
287 if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
288 && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) {
289 error_report("--force-share/-U conflicts with image options");
290 qobject_unref(options);
291 return NULL;
293 qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on");
295 blk = blk_new_open(NULL, NULL, options, flags, &local_err);
296 if (!blk) {
297 error_reportf_err(local_err, "Could not open '%s': ", optstr);
298 return NULL;
300 blk_set_enable_write_cache(blk, !writethrough);
302 return blk;
305 static BlockBackend *img_open_file(const char *filename,
306 QDict *options,
307 const char *fmt, int flags,
308 bool writethrough, bool quiet,
309 bool force_share)
311 BlockBackend *blk;
312 Error *local_err = NULL;
314 if (!options) {
315 options = qdict_new();
317 if (fmt) {
318 qdict_put_str(options, "driver", fmt);
321 if (force_share) {
322 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
324 blk = blk_new_open(filename, NULL, options, flags, &local_err);
325 if (!blk) {
326 error_reportf_err(local_err, "Could not open '%s': ", filename);
327 return NULL;
329 blk_set_enable_write_cache(blk, !writethrough);
331 return blk;
335 static int img_add_key_secrets(void *opaque,
336 const char *name, const char *value,
337 Error **errp)
339 QDict *options = opaque;
341 if (g_str_has_suffix(name, "key-secret")) {
342 qdict_put_str(options, name, value);
345 return 0;
349 static BlockBackend *img_open(bool image_opts,
350 const char *filename,
351 const char *fmt, int flags, bool writethrough,
352 bool quiet, bool force_share)
354 BlockBackend *blk;
355 if (image_opts) {
356 QemuOpts *opts;
357 if (fmt) {
358 error_report("--image-opts and --format are mutually exclusive");
359 return NULL;
361 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
362 filename, true);
363 if (!opts) {
364 return NULL;
366 blk = img_open_opts(filename, opts, flags, writethrough, quiet,
367 force_share);
368 } else {
369 blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
370 force_share);
372 return blk;
376 static int add_old_style_options(const char *fmt, QemuOpts *opts,
377 const char *base_filename,
378 const char *base_fmt)
380 Error *err = NULL;
382 if (base_filename) {
383 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
384 if (err) {
385 error_report("Backing file not supported for file format '%s'",
386 fmt);
387 error_free(err);
388 return -1;
391 if (base_fmt) {
392 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
393 if (err) {
394 error_report("Backing file format not supported for file "
395 "format '%s'", fmt);
396 error_free(err);
397 return -1;
400 return 0;
403 static int64_t cvtnum(const char *s)
405 int err;
406 uint64_t value;
408 err = qemu_strtosz(s, NULL, &value);
409 if (err < 0) {
410 return err;
412 if (value > INT64_MAX) {
413 return -ERANGE;
415 return value;
418 static int img_create(int argc, char **argv)
420 int c;
421 uint64_t img_size = -1;
422 const char *fmt = "raw";
423 const char *base_fmt = NULL;
424 const char *filename;
425 const char *base_filename = NULL;
426 char *options = NULL;
427 Error *local_err = NULL;
428 bool quiet = false;
429 int flags = 0;
431 for(;;) {
432 static const struct option long_options[] = {
433 {"help", no_argument, 0, 'h'},
434 {"object", required_argument, 0, OPTION_OBJECT},
435 {0, 0, 0, 0}
437 c = getopt_long(argc, argv, ":F:b:f:ho:qu",
438 long_options, NULL);
439 if (c == -1) {
440 break;
442 switch(c) {
443 case ':':
444 missing_argument(argv[optind - 1]);
445 break;
446 case '?':
447 unrecognized_option(argv[optind - 1]);
448 break;
449 case 'h':
450 help();
451 break;
452 case 'F':
453 base_fmt = optarg;
454 break;
455 case 'b':
456 base_filename = optarg;
457 break;
458 case 'f':
459 fmt = optarg;
460 break;
461 case 'o':
462 if (!is_valid_option_list(optarg)) {
463 error_report("Invalid option list: %s", optarg);
464 goto fail;
466 if (!options) {
467 options = g_strdup(optarg);
468 } else {
469 char *old_options = options;
470 options = g_strdup_printf("%s,%s", options, optarg);
471 g_free(old_options);
473 break;
474 case 'q':
475 quiet = true;
476 break;
477 case 'u':
478 flags |= BDRV_O_NO_BACKING;
479 break;
480 case OPTION_OBJECT: {
481 QemuOpts *opts;
482 opts = qemu_opts_parse_noisily(&qemu_object_opts,
483 optarg, true);
484 if (!opts) {
485 goto fail;
487 } break;
491 /* Get the filename */
492 filename = (optind < argc) ? argv[optind] : NULL;
493 if (options && has_help_option(options)) {
494 g_free(options);
495 return print_block_option_help(filename, fmt);
498 if (optind >= argc) {
499 error_exit("Expecting image file name");
501 optind++;
503 if (qemu_opts_foreach(&qemu_object_opts,
504 user_creatable_add_opts_foreach,
505 NULL, NULL)) {
506 goto fail;
509 /* Get image size, if specified */
510 if (optind < argc) {
511 int64_t sval;
513 sval = cvtnum(argv[optind++]);
514 if (sval < 0) {
515 if (sval == -ERANGE) {
516 error_report("Image size must be less than 8 EiB!");
517 } else {
518 error_report("Invalid image size specified! You may use k, M, "
519 "G, T, P or E suffixes for ");
520 error_report("kilobytes, megabytes, gigabytes, terabytes, "
521 "petabytes and exabytes.");
523 goto fail;
525 img_size = (uint64_t)sval;
527 if (optind != argc) {
528 error_exit("Unexpected argument: %s", argv[optind]);
531 bdrv_img_create(filename, fmt, base_filename, base_fmt,
532 options, img_size, flags, quiet, &local_err);
533 if (local_err) {
534 error_reportf_err(local_err, "%s: ", filename);
535 goto fail;
538 g_free(options);
539 return 0;
541 fail:
542 g_free(options);
543 return 1;
546 static void dump_json_image_check(ImageCheck *check, bool quiet)
548 QString *str;
549 QObject *obj;
550 Visitor *v = qobject_output_visitor_new(&obj);
552 visit_type_ImageCheck(v, NULL, &check, &error_abort);
553 visit_complete(v, &obj);
554 str = qobject_to_json_pretty(obj);
555 assert(str != NULL);
556 qprintf(quiet, "%s\n", qstring_get_str(str));
557 qobject_unref(obj);
558 visit_free(v);
559 qobject_unref(str);
562 static void dump_human_image_check(ImageCheck *check, bool quiet)
564 if (!(check->corruptions || check->leaks || check->check_errors)) {
565 qprintf(quiet, "No errors were found on the image.\n");
566 } else {
567 if (check->corruptions) {
568 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
569 "Data may be corrupted, or further writes to the image "
570 "may corrupt it.\n",
571 check->corruptions);
574 if (check->leaks) {
575 qprintf(quiet,
576 "\n%" PRId64 " leaked clusters were found on the image.\n"
577 "This means waste of disk space, but no harm to data.\n",
578 check->leaks);
581 if (check->check_errors) {
582 qprintf(quiet,
583 "\n%" PRId64
584 " internal errors have occurred during the check.\n",
585 check->check_errors);
589 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
590 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
591 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
592 check->allocated_clusters, check->total_clusters,
593 check->allocated_clusters * 100.0 / check->total_clusters,
594 check->fragmented_clusters * 100.0 / check->allocated_clusters,
595 check->compressed_clusters * 100.0 /
596 check->allocated_clusters);
599 if (check->image_end_offset) {
600 qprintf(quiet,
601 "Image end offset: %" PRId64 "\n", check->image_end_offset);
605 static int collect_image_check(BlockDriverState *bs,
606 ImageCheck *check,
607 const char *filename,
608 const char *fmt,
609 int fix)
611 int ret;
612 BdrvCheckResult result;
614 ret = bdrv_check(bs, &result, fix);
615 if (ret < 0) {
616 return ret;
619 check->filename = g_strdup(filename);
620 check->format = g_strdup(bdrv_get_format_name(bs));
621 check->check_errors = result.check_errors;
622 check->corruptions = result.corruptions;
623 check->has_corruptions = result.corruptions != 0;
624 check->leaks = result.leaks;
625 check->has_leaks = result.leaks != 0;
626 check->corruptions_fixed = result.corruptions_fixed;
627 check->has_corruptions_fixed = result.corruptions != 0;
628 check->leaks_fixed = result.leaks_fixed;
629 check->has_leaks_fixed = result.leaks != 0;
630 check->image_end_offset = result.image_end_offset;
631 check->has_image_end_offset = result.image_end_offset != 0;
632 check->total_clusters = result.bfi.total_clusters;
633 check->has_total_clusters = result.bfi.total_clusters != 0;
634 check->allocated_clusters = result.bfi.allocated_clusters;
635 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
636 check->fragmented_clusters = result.bfi.fragmented_clusters;
637 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
638 check->compressed_clusters = result.bfi.compressed_clusters;
639 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
641 return 0;
645 * Checks an image for consistency. Exit codes:
647 * 0 - Check completed, image is good
648 * 1 - Check not completed because of internal errors
649 * 2 - Check completed, image is corrupted
650 * 3 - Check completed, image has leaked clusters, but is good otherwise
651 * 63 - Checks are not supported by the image format
653 static int img_check(int argc, char **argv)
655 int c, ret;
656 OutputFormat output_format = OFORMAT_HUMAN;
657 const char *filename, *fmt, *output, *cache;
658 BlockBackend *blk;
659 BlockDriverState *bs;
660 int fix = 0;
661 int flags = BDRV_O_CHECK;
662 bool writethrough;
663 ImageCheck *check;
664 bool quiet = false;
665 bool image_opts = false;
666 bool force_share = false;
668 fmt = NULL;
669 output = NULL;
670 cache = BDRV_DEFAULT_CACHE;
672 for(;;) {
673 int option_index = 0;
674 static const struct option long_options[] = {
675 {"help", no_argument, 0, 'h'},
676 {"format", required_argument, 0, 'f'},
677 {"repair", required_argument, 0, 'r'},
678 {"output", required_argument, 0, OPTION_OUTPUT},
679 {"object", required_argument, 0, OPTION_OBJECT},
680 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
681 {"force-share", no_argument, 0, 'U'},
682 {0, 0, 0, 0}
684 c = getopt_long(argc, argv, ":hf:r:T:qU",
685 long_options, &option_index);
686 if (c == -1) {
687 break;
689 switch(c) {
690 case ':':
691 missing_argument(argv[optind - 1]);
692 break;
693 case '?':
694 unrecognized_option(argv[optind - 1]);
695 break;
696 case 'h':
697 help();
698 break;
699 case 'f':
700 fmt = optarg;
701 break;
702 case 'r':
703 flags |= BDRV_O_RDWR;
705 if (!strcmp(optarg, "leaks")) {
706 fix = BDRV_FIX_LEAKS;
707 } else if (!strcmp(optarg, "all")) {
708 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
709 } else {
710 error_exit("Unknown option value for -r "
711 "(expecting 'leaks' or 'all'): %s", optarg);
713 break;
714 case OPTION_OUTPUT:
715 output = optarg;
716 break;
717 case 'T':
718 cache = optarg;
719 break;
720 case 'q':
721 quiet = true;
722 break;
723 case 'U':
724 force_share = true;
725 break;
726 case OPTION_OBJECT: {
727 QemuOpts *opts;
728 opts = qemu_opts_parse_noisily(&qemu_object_opts,
729 optarg, true);
730 if (!opts) {
731 return 1;
733 } break;
734 case OPTION_IMAGE_OPTS:
735 image_opts = true;
736 break;
739 if (optind != argc - 1) {
740 error_exit("Expecting one image file name");
742 filename = argv[optind++];
744 if (output && !strcmp(output, "json")) {
745 output_format = OFORMAT_JSON;
746 } else if (output && !strcmp(output, "human")) {
747 output_format = OFORMAT_HUMAN;
748 } else if (output) {
749 error_report("--output must be used with human or json as argument.");
750 return 1;
753 if (qemu_opts_foreach(&qemu_object_opts,
754 user_creatable_add_opts_foreach,
755 NULL, NULL)) {
756 return 1;
759 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
760 if (ret < 0) {
761 error_report("Invalid source cache option: %s", cache);
762 return 1;
765 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
766 force_share);
767 if (!blk) {
768 return 1;
770 bs = blk_bs(blk);
772 check = g_new0(ImageCheck, 1);
773 ret = collect_image_check(bs, check, filename, fmt, fix);
775 if (ret == -ENOTSUP) {
776 error_report("This image format does not support checks");
777 ret = 63;
778 goto fail;
781 if (check->corruptions_fixed || check->leaks_fixed) {
782 int corruptions_fixed, leaks_fixed;
784 leaks_fixed = check->leaks_fixed;
785 corruptions_fixed = check->corruptions_fixed;
787 if (output_format == OFORMAT_HUMAN) {
788 qprintf(quiet,
789 "The following inconsistencies were found and repaired:\n\n"
790 " %" PRId64 " leaked clusters\n"
791 " %" PRId64 " corruptions\n\n"
792 "Double checking the fixed image now...\n",
793 check->leaks_fixed,
794 check->corruptions_fixed);
797 ret = collect_image_check(bs, check, filename, fmt, 0);
799 check->leaks_fixed = leaks_fixed;
800 check->corruptions_fixed = corruptions_fixed;
803 if (!ret) {
804 switch (output_format) {
805 case OFORMAT_HUMAN:
806 dump_human_image_check(check, quiet);
807 break;
808 case OFORMAT_JSON:
809 dump_json_image_check(check, quiet);
810 break;
814 if (ret || check->check_errors) {
815 if (ret) {
816 error_report("Check failed: %s", strerror(-ret));
817 } else {
818 error_report("Check failed");
820 ret = 1;
821 goto fail;
824 if (check->corruptions) {
825 ret = 2;
826 } else if (check->leaks) {
827 ret = 3;
828 } else {
829 ret = 0;
832 fail:
833 qapi_free_ImageCheck(check);
834 blk_unref(blk);
835 return ret;
838 typedef struct CommonBlockJobCBInfo {
839 BlockDriverState *bs;
840 Error **errp;
841 } CommonBlockJobCBInfo;
843 static void common_block_job_cb(void *opaque, int ret)
845 CommonBlockJobCBInfo *cbi = opaque;
847 if (ret < 0) {
848 error_setg_errno(cbi->errp, -ret, "Block job failed");
852 static void run_block_job(BlockJob *job, Error **errp)
854 AioContext *aio_context = blk_get_aio_context(job->blk);
855 int ret = 0;
857 aio_context_acquire(aio_context);
858 job_ref(&job->job);
859 do {
860 float progress = 0.0f;
861 aio_poll(aio_context, true);
862 if (job->job.progress_total) {
863 progress = (float)job->job.progress_current /
864 job->job.progress_total * 100.f;
866 qemu_progress_print(progress, 0);
867 } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
869 if (!job_is_completed(&job->job)) {
870 ret = job_complete_sync(&job->job, errp);
871 } else {
872 ret = job->job.ret;
874 job_unref(&job->job);
875 aio_context_release(aio_context);
877 /* publish completion progress only when success */
878 if (!ret) {
879 qemu_progress_print(100.f, 0);
883 static int img_commit(int argc, char **argv)
885 int c, ret, flags;
886 const char *filename, *fmt, *cache, *base;
887 BlockBackend *blk;
888 BlockDriverState *bs, *base_bs;
889 BlockJob *job;
890 bool progress = false, quiet = false, drop = false;
891 bool writethrough;
892 Error *local_err = NULL;
893 CommonBlockJobCBInfo cbi;
894 bool image_opts = false;
895 AioContext *aio_context;
897 fmt = NULL;
898 cache = BDRV_DEFAULT_CACHE;
899 base = NULL;
900 for(;;) {
901 static const struct option long_options[] = {
902 {"help", no_argument, 0, 'h'},
903 {"object", required_argument, 0, OPTION_OBJECT},
904 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
905 {0, 0, 0, 0}
907 c = getopt_long(argc, argv, ":f:ht:b:dpq",
908 long_options, NULL);
909 if (c == -1) {
910 break;
912 switch(c) {
913 case ':':
914 missing_argument(argv[optind - 1]);
915 break;
916 case '?':
917 unrecognized_option(argv[optind - 1]);
918 break;
919 case 'h':
920 help();
921 break;
922 case 'f':
923 fmt = optarg;
924 break;
925 case 't':
926 cache = optarg;
927 break;
928 case 'b':
929 base = optarg;
930 /* -b implies -d */
931 drop = true;
932 break;
933 case 'd':
934 drop = true;
935 break;
936 case 'p':
937 progress = true;
938 break;
939 case 'q':
940 quiet = true;
941 break;
942 case OPTION_OBJECT: {
943 QemuOpts *opts;
944 opts = qemu_opts_parse_noisily(&qemu_object_opts,
945 optarg, true);
946 if (!opts) {
947 return 1;
949 } break;
950 case OPTION_IMAGE_OPTS:
951 image_opts = true;
952 break;
956 /* Progress is not shown in Quiet mode */
957 if (quiet) {
958 progress = false;
961 if (optind != argc - 1) {
962 error_exit("Expecting one image file name");
964 filename = argv[optind++];
966 if (qemu_opts_foreach(&qemu_object_opts,
967 user_creatable_add_opts_foreach,
968 NULL, NULL)) {
969 return 1;
972 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
973 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
974 if (ret < 0) {
975 error_report("Invalid cache option: %s", cache);
976 return 1;
979 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
980 false);
981 if (!blk) {
982 return 1;
984 bs = blk_bs(blk);
986 qemu_progress_init(progress, 1.f);
987 qemu_progress_print(0.f, 100);
989 if (base) {
990 base_bs = bdrv_find_backing_image(bs, base);
991 if (!base_bs) {
992 error_setg(&local_err,
993 "Did not find '%s' in the backing chain of '%s'",
994 base, filename);
995 goto done;
997 } else {
998 /* This is different from QMP, which by default uses the deepest file in
999 * the backing chain (i.e., the very base); however, the traditional
1000 * behavior of qemu-img commit is using the immediate backing file. */
1001 base_bs = backing_bs(bs);
1002 if (!base_bs) {
1003 error_setg(&local_err, "Image does not have a backing file");
1004 goto done;
1008 cbi = (CommonBlockJobCBInfo){
1009 .errp = &local_err,
1010 .bs = bs,
1013 aio_context = bdrv_get_aio_context(bs);
1014 aio_context_acquire(aio_context);
1015 commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,
1016 BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1017 &cbi, false, &local_err);
1018 aio_context_release(aio_context);
1019 if (local_err) {
1020 goto done;
1023 /* When the block job completes, the BlockBackend reference will point to
1024 * the old backing file. In order to avoid that the top image is already
1025 * deleted, so we can still empty it afterwards, increment the reference
1026 * counter here preemptively. */
1027 if (!drop) {
1028 bdrv_ref(bs);
1031 job = block_job_get("commit");
1032 run_block_job(job, &local_err);
1033 if (local_err) {
1034 goto unref_backing;
1037 if (!drop && bs->drv->bdrv_make_empty) {
1038 ret = bs->drv->bdrv_make_empty(bs);
1039 if (ret) {
1040 error_setg_errno(&local_err, -ret, "Could not empty %s",
1041 filename);
1042 goto unref_backing;
1046 unref_backing:
1047 if (!drop) {
1048 bdrv_unref(bs);
1051 done:
1052 qemu_progress_end();
1054 blk_unref(blk);
1056 if (local_err) {
1057 error_report_err(local_err);
1058 return 1;
1061 qprintf(quiet, "Image committed.\n");
1062 return 0;
1066 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1067 * of the first sector boundary within buf where the sector contains a
1068 * non-zero byte. This function is robust to a buffer that is not
1069 * sector-aligned.
1071 static int64_t find_nonzero(const uint8_t *buf, int64_t n)
1073 int64_t i;
1074 int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE);
1076 for (i = 0; i < end; i += BDRV_SECTOR_SIZE) {
1077 if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) {
1078 return i;
1081 if (i < n && !buffer_is_zero(buf + i, n - end)) {
1082 return i;
1084 return -1;
1088 * Returns true iff the first sector pointed to by 'buf' contains at least
1089 * a non-NUL byte.
1091 * 'pnum' is set to the number of sectors (including and immediately following
1092 * the first one) that are known to be in the same allocated/unallocated state.
1093 * The function will try to align the end offset to alignment boundaries so
1094 * that the request will at least end aligned and consequtive requests will
1095 * also start at an aligned offset.
1097 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
1098 int64_t sector_num, int alignment)
1100 bool is_zero;
1101 int i, tail;
1103 if (n <= 0) {
1104 *pnum = 0;
1105 return 0;
1107 is_zero = buffer_is_zero(buf, 512);
1108 for(i = 1; i < n; i++) {
1109 buf += 512;
1110 if (is_zero != buffer_is_zero(buf, 512)) {
1111 break;
1115 tail = (sector_num + i) & (alignment - 1);
1116 if (tail) {
1117 if (is_zero && i <= tail) {
1118 /* treat unallocated areas which only consist
1119 * of a small tail as allocated. */
1120 is_zero = false;
1122 if (!is_zero) {
1123 /* align up end offset of allocated areas. */
1124 i += alignment - tail;
1125 i = MIN(i, n);
1126 } else {
1127 /* align down end offset of zero areas. */
1128 i -= tail;
1131 *pnum = i;
1132 return !is_zero;
1136 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1137 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1138 * breaking up write requests for only small sparse areas.
1140 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1141 int min, int64_t sector_num, int alignment)
1143 int ret;
1144 int num_checked, num_used;
1146 if (n < min) {
1147 min = n;
1150 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1151 if (!ret) {
1152 return ret;
1155 num_used = *pnum;
1156 buf += BDRV_SECTOR_SIZE * *pnum;
1157 n -= *pnum;
1158 sector_num += *pnum;
1159 num_checked = num_used;
1161 while (n > 0) {
1162 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1164 buf += BDRV_SECTOR_SIZE * *pnum;
1165 n -= *pnum;
1166 sector_num += *pnum;
1167 num_checked += *pnum;
1168 if (ret) {
1169 num_used = num_checked;
1170 } else if (*pnum >= min) {
1171 break;
1175 *pnum = num_used;
1176 return 1;
1180 * Compares two buffers sector by sector. Returns 0 if the first
1181 * sector of each buffer matches, non-zero otherwise.
1183 * pnum is set to the sector-aligned size of the buffer prefix that
1184 * has the same matching status as the first sector.
1186 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,
1187 int64_t bytes, int64_t *pnum)
1189 bool res;
1190 int64_t i = MIN(bytes, BDRV_SECTOR_SIZE);
1192 assert(bytes > 0);
1194 res = !!memcmp(buf1, buf2, i);
1195 while (i < bytes) {
1196 int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE);
1198 if (!!memcmp(buf1 + i, buf2 + i, len) != res) {
1199 break;
1201 i += len;
1204 *pnum = i;
1205 return res;
1208 #define IO_BUF_SIZE (2 * 1024 * 1024)
1211 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1213 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1214 * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1215 * failure), and 4 on error (the exit status for read errors), after emitting
1216 * an error message.
1218 * @param blk: BlockBackend for the image
1219 * @param offset: Starting offset to check
1220 * @param bytes: Number of bytes to check
1221 * @param filename: Name of disk file we are checking (logging purpose)
1222 * @param buffer: Allocated buffer for storing read data
1223 * @param quiet: Flag for quiet mode
1225 static int check_empty_sectors(BlockBackend *blk, int64_t offset,
1226 int64_t bytes, const char *filename,
1227 uint8_t *buffer, bool quiet)
1229 int ret = 0;
1230 int64_t idx;
1232 ret = blk_pread(blk, offset, buffer, bytes);
1233 if (ret < 0) {
1234 error_report("Error while reading offset %" PRId64 " of %s: %s",
1235 offset, filename, strerror(-ret));
1236 return 4;
1238 idx = find_nonzero(buffer, bytes);
1239 if (idx >= 0) {
1240 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1241 offset + idx);
1242 return 1;
1245 return 0;
1249 * Compares two images. Exit codes:
1251 * 0 - Images are identical
1252 * 1 - Images differ
1253 * >1 - Error occurred
1255 static int img_compare(int argc, char **argv)
1257 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1258 BlockBackend *blk1, *blk2;
1259 BlockDriverState *bs1, *bs2;
1260 int64_t total_size1, total_size2;
1261 uint8_t *buf1 = NULL, *buf2 = NULL;
1262 int64_t pnum1, pnum2;
1263 int allocated1, allocated2;
1264 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1265 bool progress = false, quiet = false, strict = false;
1266 int flags;
1267 bool writethrough;
1268 int64_t total_size;
1269 int64_t offset = 0;
1270 int64_t chunk;
1271 int c;
1272 uint64_t progress_base;
1273 bool image_opts = false;
1274 bool force_share = false;
1276 cache = BDRV_DEFAULT_CACHE;
1277 for (;;) {
1278 static const struct option long_options[] = {
1279 {"help", no_argument, 0, 'h'},
1280 {"object", required_argument, 0, OPTION_OBJECT},
1281 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1282 {"force-share", no_argument, 0, 'U'},
1283 {0, 0, 0, 0}
1285 c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1286 long_options, NULL);
1287 if (c == -1) {
1288 break;
1290 switch (c) {
1291 case ':':
1292 missing_argument(argv[optind - 1]);
1293 break;
1294 case '?':
1295 unrecognized_option(argv[optind - 1]);
1296 break;
1297 case 'h':
1298 help();
1299 break;
1300 case 'f':
1301 fmt1 = optarg;
1302 break;
1303 case 'F':
1304 fmt2 = optarg;
1305 break;
1306 case 'T':
1307 cache = optarg;
1308 break;
1309 case 'p':
1310 progress = true;
1311 break;
1312 case 'q':
1313 quiet = true;
1314 break;
1315 case 's':
1316 strict = true;
1317 break;
1318 case 'U':
1319 force_share = true;
1320 break;
1321 case OPTION_OBJECT: {
1322 QemuOpts *opts;
1323 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1324 optarg, true);
1325 if (!opts) {
1326 ret = 2;
1327 goto out4;
1329 } break;
1330 case OPTION_IMAGE_OPTS:
1331 image_opts = true;
1332 break;
1336 /* Progress is not shown in Quiet mode */
1337 if (quiet) {
1338 progress = false;
1342 if (optind != argc - 2) {
1343 error_exit("Expecting two image file names");
1345 filename1 = argv[optind++];
1346 filename2 = argv[optind++];
1348 if (qemu_opts_foreach(&qemu_object_opts,
1349 user_creatable_add_opts_foreach,
1350 NULL, NULL)) {
1351 ret = 2;
1352 goto out4;
1355 /* Initialize before goto out */
1356 qemu_progress_init(progress, 2.0);
1358 flags = 0;
1359 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1360 if (ret < 0) {
1361 error_report("Invalid source cache option: %s", cache);
1362 ret = 2;
1363 goto out3;
1366 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1367 force_share);
1368 if (!blk1) {
1369 ret = 2;
1370 goto out3;
1373 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1374 force_share);
1375 if (!blk2) {
1376 ret = 2;
1377 goto out2;
1379 bs1 = blk_bs(blk1);
1380 bs2 = blk_bs(blk2);
1382 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1383 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1384 total_size1 = blk_getlength(blk1);
1385 if (total_size1 < 0) {
1386 error_report("Can't get size of %s: %s",
1387 filename1, strerror(-total_size1));
1388 ret = 4;
1389 goto out;
1391 total_size2 = blk_getlength(blk2);
1392 if (total_size2 < 0) {
1393 error_report("Can't get size of %s: %s",
1394 filename2, strerror(-total_size2));
1395 ret = 4;
1396 goto out;
1398 total_size = MIN(total_size1, total_size2);
1399 progress_base = MAX(total_size1, total_size2);
1401 qemu_progress_print(0, 100);
1403 if (strict && total_size1 != total_size2) {
1404 ret = 1;
1405 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1406 goto out;
1409 while (offset < total_size) {
1410 int status1, status2;
1412 status1 = bdrv_block_status_above(bs1, NULL, offset,
1413 total_size1 - offset, &pnum1, NULL,
1414 NULL);
1415 if (status1 < 0) {
1416 ret = 3;
1417 error_report("Sector allocation test failed for %s", filename1);
1418 goto out;
1420 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1422 status2 = bdrv_block_status_above(bs2, NULL, offset,
1423 total_size2 - offset, &pnum2, NULL,
1424 NULL);
1425 if (status2 < 0) {
1426 ret = 3;
1427 error_report("Sector allocation test failed for %s", filename2);
1428 goto out;
1430 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1432 assert(pnum1 && pnum2);
1433 chunk = MIN(pnum1, pnum2);
1435 if (strict) {
1436 if (status1 != status2) {
1437 ret = 1;
1438 qprintf(quiet, "Strict mode: Offset %" PRId64
1439 " block status mismatch!\n", offset);
1440 goto out;
1443 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1444 /* nothing to do */
1445 } else if (allocated1 == allocated2) {
1446 if (allocated1) {
1447 int64_t pnum;
1449 chunk = MIN(chunk, IO_BUF_SIZE);
1450 ret = blk_pread(blk1, offset, buf1, chunk);
1451 if (ret < 0) {
1452 error_report("Error while reading offset %" PRId64
1453 " of %s: %s",
1454 offset, filename1, strerror(-ret));
1455 ret = 4;
1456 goto out;
1458 ret = blk_pread(blk2, offset, buf2, chunk);
1459 if (ret < 0) {
1460 error_report("Error while reading offset %" PRId64
1461 " of %s: %s",
1462 offset, filename2, strerror(-ret));
1463 ret = 4;
1464 goto out;
1466 ret = compare_buffers(buf1, buf2, chunk, &pnum);
1467 if (ret || pnum != chunk) {
1468 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1469 offset + (ret ? 0 : pnum));
1470 ret = 1;
1471 goto out;
1474 } else {
1475 chunk = MIN(chunk, IO_BUF_SIZE);
1476 if (allocated1) {
1477 ret = check_empty_sectors(blk1, offset, chunk,
1478 filename1, buf1, quiet);
1479 } else {
1480 ret = check_empty_sectors(blk2, offset, chunk,
1481 filename2, buf1, quiet);
1483 if (ret) {
1484 goto out;
1487 offset += chunk;
1488 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1491 if (total_size1 != total_size2) {
1492 BlockBackend *blk_over;
1493 const char *filename_over;
1495 qprintf(quiet, "Warning: Image size mismatch!\n");
1496 if (total_size1 > total_size2) {
1497 blk_over = blk1;
1498 filename_over = filename1;
1499 } else {
1500 blk_over = blk2;
1501 filename_over = filename2;
1504 while (offset < progress_base) {
1505 ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,
1506 progress_base - offset, &chunk,
1507 NULL, NULL);
1508 if (ret < 0) {
1509 ret = 3;
1510 error_report("Sector allocation test failed for %s",
1511 filename_over);
1512 goto out;
1515 if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {
1516 chunk = MIN(chunk, IO_BUF_SIZE);
1517 ret = check_empty_sectors(blk_over, offset, chunk,
1518 filename_over, buf1, quiet);
1519 if (ret) {
1520 goto out;
1523 offset += chunk;
1524 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1528 qprintf(quiet, "Images are identical.\n");
1529 ret = 0;
1531 out:
1532 qemu_vfree(buf1);
1533 qemu_vfree(buf2);
1534 blk_unref(blk2);
1535 out2:
1536 blk_unref(blk1);
1537 out3:
1538 qemu_progress_end();
1539 out4:
1540 return ret;
1543 enum ImgConvertBlockStatus {
1544 BLK_DATA,
1545 BLK_ZERO,
1546 BLK_BACKING_FILE,
1549 #define MAX_COROUTINES 16
1551 typedef struct ImgConvertState {
1552 BlockBackend **src;
1553 int64_t *src_sectors;
1554 int src_num;
1555 int64_t total_sectors;
1556 int64_t allocated_sectors;
1557 int64_t allocated_done;
1558 int64_t sector_num;
1559 int64_t wr_offs;
1560 enum ImgConvertBlockStatus status;
1561 int64_t sector_next_status;
1562 BlockBackend *target;
1563 bool has_zero_init;
1564 bool compressed;
1565 bool unallocated_blocks_are_zero;
1566 bool target_has_backing;
1567 int64_t target_backing_sectors; /* negative if unknown */
1568 bool wr_in_order;
1569 bool copy_range;
1570 int min_sparse;
1571 int alignment;
1572 size_t cluster_sectors;
1573 size_t buf_sectors;
1574 long num_coroutines;
1575 int running_coroutines;
1576 Coroutine *co[MAX_COROUTINES];
1577 int64_t wait_sector_num[MAX_COROUTINES];
1578 CoMutex lock;
1579 int ret;
1580 } ImgConvertState;
1582 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1583 int *src_cur, int64_t *src_cur_offset)
1585 *src_cur = 0;
1586 *src_cur_offset = 0;
1587 while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1588 *src_cur_offset += s->src_sectors[*src_cur];
1589 (*src_cur)++;
1590 assert(*src_cur < s->src_num);
1594 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1596 int64_t src_cur_offset;
1597 int ret, n, src_cur;
1598 bool post_backing_zero = false;
1600 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1602 assert(s->total_sectors > sector_num);
1603 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1605 if (s->target_backing_sectors >= 0) {
1606 if (sector_num >= s->target_backing_sectors) {
1607 post_backing_zero = s->unallocated_blocks_are_zero;
1608 } else if (sector_num + n > s->target_backing_sectors) {
1609 /* Split requests around target_backing_sectors (because
1610 * starting from there, zeros are handled differently) */
1611 n = s->target_backing_sectors - sector_num;
1615 if (s->sector_next_status <= sector_num) {
1616 int64_t count = n * BDRV_SECTOR_SIZE;
1618 if (s->target_has_backing) {
1620 ret = bdrv_block_status(blk_bs(s->src[src_cur]),
1621 (sector_num - src_cur_offset) *
1622 BDRV_SECTOR_SIZE,
1623 count, &count, NULL, NULL);
1624 } else {
1625 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,
1626 (sector_num - src_cur_offset) *
1627 BDRV_SECTOR_SIZE,
1628 count, &count, NULL, NULL);
1630 if (ret < 0) {
1631 return ret;
1633 n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
1635 if (ret & BDRV_BLOCK_ZERO) {
1636 s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;
1637 } else if (ret & BDRV_BLOCK_DATA) {
1638 s->status = BLK_DATA;
1639 } else {
1640 s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1643 s->sector_next_status = sector_num + n;
1646 n = MIN(n, s->sector_next_status - sector_num);
1647 if (s->status == BLK_DATA) {
1648 n = MIN(n, s->buf_sectors);
1651 /* We need to write complete clusters for compressed images, so if an
1652 * unallocated area is shorter than that, we must consider the whole
1653 * cluster allocated. */
1654 if (s->compressed) {
1655 if (n < s->cluster_sectors) {
1656 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1657 s->status = BLK_DATA;
1658 } else {
1659 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1663 return n;
1666 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1667 int nb_sectors, uint8_t *buf)
1669 int n, ret;
1670 QEMUIOVector qiov;
1671 struct iovec iov;
1673 assert(nb_sectors <= s->buf_sectors);
1674 while (nb_sectors > 0) {
1675 BlockBackend *blk;
1676 int src_cur;
1677 int64_t bs_sectors, src_cur_offset;
1679 /* In the case of compression with multiple source files, we can get a
1680 * nb_sectors that spreads into the next part. So we must be able to
1681 * read across multiple BDSes for one convert_read() call. */
1682 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1683 blk = s->src[src_cur];
1684 bs_sectors = s->src_sectors[src_cur];
1686 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1687 iov.iov_base = buf;
1688 iov.iov_len = n << BDRV_SECTOR_BITS;
1689 qemu_iovec_init_external(&qiov, &iov, 1);
1691 ret = blk_co_preadv(
1692 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
1693 n << BDRV_SECTOR_BITS, &qiov, 0);
1694 if (ret < 0) {
1695 return ret;
1698 sector_num += n;
1699 nb_sectors -= n;
1700 buf += n * BDRV_SECTOR_SIZE;
1703 return 0;
1707 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1708 int nb_sectors, uint8_t *buf,
1709 enum ImgConvertBlockStatus status)
1711 int ret;
1712 QEMUIOVector qiov;
1713 struct iovec iov;
1715 while (nb_sectors > 0) {
1716 int n = nb_sectors;
1717 BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1719 switch (status) {
1720 case BLK_BACKING_FILE:
1721 /* If we have a backing file, leave clusters unallocated that are
1722 * unallocated in the source image, so that the backing file is
1723 * visible at the respective offset. */
1724 assert(s->target_has_backing);
1725 break;
1727 case BLK_DATA:
1728 /* If we're told to keep the target fully allocated (-S 0) or there
1729 * is real non-zero data, we must write it. Otherwise we can treat
1730 * it as zero sectors.
1731 * Compressed clusters need to be written as a whole, so in that
1732 * case we can only save the write if the buffer is completely
1733 * zeroed. */
1734 if (!s->min_sparse ||
1735 (!s->compressed &&
1736 is_allocated_sectors_min(buf, n, &n, s->min_sparse,
1737 sector_num, s->alignment)) ||
1738 (s->compressed &&
1739 !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1741 iov.iov_base = buf;
1742 iov.iov_len = n << BDRV_SECTOR_BITS;
1743 qemu_iovec_init_external(&qiov, &iov, 1);
1745 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
1746 n << BDRV_SECTOR_BITS, &qiov, flags);
1747 if (ret < 0) {
1748 return ret;
1750 break;
1752 /* fall-through */
1754 case BLK_ZERO:
1755 if (s->has_zero_init) {
1756 assert(!s->target_has_backing);
1757 break;
1759 ret = blk_co_pwrite_zeroes(s->target,
1760 sector_num << BDRV_SECTOR_BITS,
1761 n << BDRV_SECTOR_BITS, 0);
1762 if (ret < 0) {
1763 return ret;
1765 break;
1768 sector_num += n;
1769 nb_sectors -= n;
1770 buf += n * BDRV_SECTOR_SIZE;
1773 return 0;
1776 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
1777 int nb_sectors)
1779 int n, ret;
1781 while (nb_sectors > 0) {
1782 BlockBackend *blk;
1783 int src_cur;
1784 int64_t bs_sectors, src_cur_offset;
1785 int64_t offset;
1787 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1788 offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1789 blk = s->src[src_cur];
1790 bs_sectors = s->src_sectors[src_cur];
1792 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1794 ret = blk_co_copy_range(blk, offset, s->target,
1795 sector_num << BDRV_SECTOR_BITS,
1796 n << BDRV_SECTOR_BITS, 0, 0);
1797 if (ret < 0) {
1798 return ret;
1801 sector_num += n;
1802 nb_sectors -= n;
1804 return 0;
1807 static void coroutine_fn convert_co_do_copy(void *opaque)
1809 ImgConvertState *s = opaque;
1810 uint8_t *buf = NULL;
1811 int ret, i;
1812 int index = -1;
1814 for (i = 0; i < s->num_coroutines; i++) {
1815 if (s->co[i] == qemu_coroutine_self()) {
1816 index = i;
1817 break;
1820 assert(index >= 0);
1822 s->running_coroutines++;
1823 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1825 while (1) {
1826 int n;
1827 int64_t sector_num;
1828 enum ImgConvertBlockStatus status;
1829 bool copy_range;
1831 qemu_co_mutex_lock(&s->lock);
1832 if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1833 qemu_co_mutex_unlock(&s->lock);
1834 break;
1836 n = convert_iteration_sectors(s, s->sector_num);
1837 if (n < 0) {
1838 qemu_co_mutex_unlock(&s->lock);
1839 s->ret = n;
1840 break;
1842 /* save current sector and allocation status to local variables */
1843 sector_num = s->sector_num;
1844 status = s->status;
1845 if (!s->min_sparse && s->status == BLK_ZERO) {
1846 n = MIN(n, s->buf_sectors);
1848 /* increment global sector counter so that other coroutines can
1849 * already continue reading beyond this request */
1850 s->sector_num += n;
1851 qemu_co_mutex_unlock(&s->lock);
1853 if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
1854 s->allocated_done += n;
1855 qemu_progress_print(100.0 * s->allocated_done /
1856 s->allocated_sectors, 0);
1859 retry:
1860 copy_range = s->copy_range && s->status == BLK_DATA;
1861 if (status == BLK_DATA && !copy_range) {
1862 ret = convert_co_read(s, sector_num, n, buf);
1863 if (ret < 0) {
1864 error_report("error while reading sector %" PRId64
1865 ": %s", sector_num, strerror(-ret));
1866 s->ret = ret;
1868 } else if (!s->min_sparse && status == BLK_ZERO) {
1869 status = BLK_DATA;
1870 memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
1873 if (s->wr_in_order) {
1874 /* keep writes in order */
1875 while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
1876 s->wait_sector_num[index] = sector_num;
1877 qemu_coroutine_yield();
1879 s->wait_sector_num[index] = -1;
1882 if (s->ret == -EINPROGRESS) {
1883 if (copy_range) {
1884 ret = convert_co_copy_range(s, sector_num, n);
1885 if (ret) {
1886 s->copy_range = false;
1887 goto retry;
1889 } else {
1890 ret = convert_co_write(s, sector_num, n, buf, status);
1892 if (ret < 0) {
1893 error_report("error while writing sector %" PRId64
1894 ": %s", sector_num, strerror(-ret));
1895 s->ret = ret;
1899 if (s->wr_in_order) {
1900 /* reenter the coroutine that might have waited
1901 * for this write to complete */
1902 s->wr_offs = sector_num + n;
1903 for (i = 0; i < s->num_coroutines; i++) {
1904 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
1906 * A -> B -> A cannot occur because A has
1907 * s->wait_sector_num[i] == -1 during A -> B. Therefore
1908 * B will never enter A during this time window.
1910 qemu_coroutine_enter(s->co[i]);
1911 break;
1917 qemu_vfree(buf);
1918 s->co[index] = NULL;
1919 s->running_coroutines--;
1920 if (!s->running_coroutines && s->ret == -EINPROGRESS) {
1921 /* the convert job finished successfully */
1922 s->ret = 0;
1926 static int convert_do_copy(ImgConvertState *s)
1928 int ret, i, n;
1929 int64_t sector_num = 0;
1931 /* Check whether we have zero initialisation or can get it efficiently */
1932 s->has_zero_init = s->min_sparse && !s->target_has_backing
1933 ? bdrv_has_zero_init(blk_bs(s->target))
1934 : false;
1936 if (!s->has_zero_init && !s->target_has_backing &&
1937 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1939 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP);
1940 if (ret == 0) {
1941 s->has_zero_init = true;
1945 /* Allocate buffer for copied data. For compressed images, only one cluster
1946 * can be copied at a time. */
1947 if (s->compressed) {
1948 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1949 error_report("invalid cluster size");
1950 return -EINVAL;
1952 s->buf_sectors = s->cluster_sectors;
1955 while (sector_num < s->total_sectors) {
1956 n = convert_iteration_sectors(s, sector_num);
1957 if (n < 0) {
1958 return n;
1960 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
1962 s->allocated_sectors += n;
1964 sector_num += n;
1967 /* Do the copy */
1968 s->sector_next_status = 0;
1969 s->ret = -EINPROGRESS;
1971 qemu_co_mutex_init(&s->lock);
1972 for (i = 0; i < s->num_coroutines; i++) {
1973 s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
1974 s->wait_sector_num[i] = -1;
1975 qemu_coroutine_enter(s->co[i]);
1978 while (s->running_coroutines) {
1979 main_loop_wait(false);
1982 if (s->compressed && !s->ret) {
1983 /* signal EOF to align */
1984 ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
1985 if (ret < 0) {
1986 return ret;
1990 return s->ret;
1993 #define MAX_BUF_SECTORS 32768
1995 static int img_convert(int argc, char **argv)
1997 int c, bs_i, flags, src_flags = 0;
1998 const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
1999 *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
2000 *out_filename, *out_baseimg_param, *snapshot_name = NULL;
2001 BlockDriver *drv = NULL, *proto_drv = NULL;
2002 BlockDriverInfo bdi;
2003 BlockDriverState *out_bs;
2004 QemuOpts *opts = NULL, *sn_opts = NULL;
2005 QemuOptsList *create_opts = NULL;
2006 QDict *open_opts = NULL;
2007 char *options = NULL;
2008 Error *local_err = NULL;
2009 bool writethrough, src_writethrough, quiet = false, image_opts = false,
2010 skip_create = false, progress = false, tgt_image_opts = false;
2011 int64_t ret = -EINVAL;
2012 bool force_share = false;
2013 bool explict_min_sparse = false;
2015 ImgConvertState s = (ImgConvertState) {
2016 /* Need at least 4k of zeros for sparse detection */
2017 .min_sparse = 8,
2018 .copy_range = false,
2019 .buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
2020 .wr_in_order = true,
2021 .num_coroutines = 8,
2024 for(;;) {
2025 static const struct option long_options[] = {
2026 {"help", no_argument, 0, 'h'},
2027 {"object", required_argument, 0, OPTION_OBJECT},
2028 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2029 {"force-share", no_argument, 0, 'U'},
2030 {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
2031 {0, 0, 0, 0}
2033 c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
2034 long_options, NULL);
2035 if (c == -1) {
2036 break;
2038 switch(c) {
2039 case ':':
2040 missing_argument(argv[optind - 1]);
2041 break;
2042 case '?':
2043 unrecognized_option(argv[optind - 1]);
2044 break;
2045 case 'h':
2046 help();
2047 break;
2048 case 'f':
2049 fmt = optarg;
2050 break;
2051 case 'O':
2052 out_fmt = optarg;
2053 break;
2054 case 'B':
2055 out_baseimg = optarg;
2056 break;
2057 case 'C':
2058 s.copy_range = true;
2059 break;
2060 case 'c':
2061 s.compressed = true;
2062 break;
2063 case 'o':
2064 if (!is_valid_option_list(optarg)) {
2065 error_report("Invalid option list: %s", optarg);
2066 goto fail_getopt;
2068 if (!options) {
2069 options = g_strdup(optarg);
2070 } else {
2071 char *old_options = options;
2072 options = g_strdup_printf("%s,%s", options, optarg);
2073 g_free(old_options);
2075 break;
2076 case 'l':
2077 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2078 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2079 optarg, false);
2080 if (!sn_opts) {
2081 error_report("Failed in parsing snapshot param '%s'",
2082 optarg);
2083 goto fail_getopt;
2085 } else {
2086 snapshot_name = optarg;
2088 break;
2089 case 'S':
2091 int64_t sval;
2093 sval = cvtnum(optarg);
2094 if (sval < 0 || sval & (BDRV_SECTOR_SIZE - 1) ||
2095 sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) {
2096 error_report("Invalid buffer size for sparse output specified. "
2097 "Valid sizes are multiples of %llu up to %llu. Select "
2098 "0 to disable sparse detection (fully allocates output).",
2099 BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE);
2100 goto fail_getopt;
2103 s.min_sparse = sval / BDRV_SECTOR_SIZE;
2104 explict_min_sparse = true;
2105 break;
2107 case 'p':
2108 progress = true;
2109 break;
2110 case 't':
2111 cache = optarg;
2112 break;
2113 case 'T':
2114 src_cache = optarg;
2115 break;
2116 case 'q':
2117 quiet = true;
2118 break;
2119 case 'n':
2120 skip_create = true;
2121 break;
2122 case 'm':
2123 if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2124 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2125 error_report("Invalid number of coroutines. Allowed number of"
2126 " coroutines is between 1 and %d", MAX_COROUTINES);
2127 goto fail_getopt;
2129 break;
2130 case 'W':
2131 s.wr_in_order = false;
2132 break;
2133 case 'U':
2134 force_share = true;
2135 break;
2136 case OPTION_OBJECT: {
2137 QemuOpts *object_opts;
2138 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2139 optarg, true);
2140 if (!object_opts) {
2141 goto fail_getopt;
2143 break;
2145 case OPTION_IMAGE_OPTS:
2146 image_opts = true;
2147 break;
2148 case OPTION_TARGET_IMAGE_OPTS:
2149 tgt_image_opts = true;
2150 break;
2154 if (!out_fmt && !tgt_image_opts) {
2155 out_fmt = "raw";
2158 if (qemu_opts_foreach(&qemu_object_opts,
2159 user_creatable_add_opts_foreach,
2160 NULL, NULL)) {
2161 goto fail_getopt;
2164 if (s.compressed && s.copy_range) {
2165 error_report("Cannot enable copy offloading when -c is used");
2166 goto fail_getopt;
2169 if (explict_min_sparse && s.copy_range) {
2170 error_report("Cannot enable copy offloading when -S is used");
2171 goto fail_getopt;
2174 if (tgt_image_opts && !skip_create) {
2175 error_report("--target-image-opts requires use of -n flag");
2176 goto fail_getopt;
2179 s.src_num = argc - optind - 1;
2180 out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2182 if (options && has_help_option(options)) {
2183 if (out_fmt) {
2184 ret = print_block_option_help(out_filename, out_fmt);
2185 goto fail_getopt;
2186 } else {
2187 error_report("Option help requires a format be specified");
2188 goto fail_getopt;
2192 if (s.src_num < 1) {
2193 error_report("Must specify image file name");
2194 goto fail_getopt;
2198 /* ret is still -EINVAL until here */
2199 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2200 if (ret < 0) {
2201 error_report("Invalid source cache option: %s", src_cache);
2202 goto fail_getopt;
2205 /* Initialize before goto out */
2206 if (quiet) {
2207 progress = false;
2209 qemu_progress_init(progress, 1.0);
2210 qemu_progress_print(0, 100);
2212 s.src = g_new0(BlockBackend *, s.src_num);
2213 s.src_sectors = g_new(int64_t, s.src_num);
2215 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2216 s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2217 fmt, src_flags, src_writethrough, quiet,
2218 force_share);
2219 if (!s.src[bs_i]) {
2220 ret = -1;
2221 goto out;
2223 s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2224 if (s.src_sectors[bs_i] < 0) {
2225 error_report("Could not get size of %s: %s",
2226 argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2227 ret = -1;
2228 goto out;
2230 s.total_sectors += s.src_sectors[bs_i];
2233 if (sn_opts) {
2234 bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2235 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2236 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2237 &local_err);
2238 } else if (snapshot_name != NULL) {
2239 if (s.src_num > 1) {
2240 error_report("No support for concatenating multiple snapshot");
2241 ret = -1;
2242 goto out;
2245 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2246 &local_err);
2248 if (local_err) {
2249 error_reportf_err(local_err, "Failed to load snapshot: ");
2250 ret = -1;
2251 goto out;
2254 if (!skip_create) {
2255 /* Find driver and parse its options */
2256 drv = bdrv_find_format(out_fmt);
2257 if (!drv) {
2258 error_report("Unknown file format '%s'", out_fmt);
2259 ret = -1;
2260 goto out;
2263 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2264 if (!proto_drv) {
2265 error_report_err(local_err);
2266 ret = -1;
2267 goto out;
2270 if (!drv->create_opts) {
2271 error_report("Format driver '%s' does not support image creation",
2272 drv->format_name);
2273 ret = -1;
2274 goto out;
2277 if (!proto_drv->create_opts) {
2278 error_report("Protocol driver '%s' does not support image creation",
2279 proto_drv->format_name);
2280 ret = -1;
2281 goto out;
2284 create_opts = qemu_opts_append(create_opts, drv->create_opts);
2285 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2287 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2288 if (options) {
2289 qemu_opts_do_parse(opts, options, NULL, &local_err);
2290 if (local_err) {
2291 error_report_err(local_err);
2292 ret = -1;
2293 goto out;
2297 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2298 &error_abort);
2299 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2300 if (ret < 0) {
2301 goto out;
2305 /* Get backing file name if -o backing_file was used */
2306 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2307 if (out_baseimg_param) {
2308 out_baseimg = out_baseimg_param;
2310 s.target_has_backing = (bool) out_baseimg;
2312 if (s.src_num > 1 && out_baseimg) {
2313 error_report("Having a backing file for the target makes no sense when "
2314 "concatenating multiple input images");
2315 ret = -1;
2316 goto out;
2319 /* Check if compression is supported */
2320 if (s.compressed) {
2321 bool encryption =
2322 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2323 const char *encryptfmt =
2324 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2325 const char *preallocation =
2326 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2328 if (drv && !drv->bdrv_co_pwritev_compressed) {
2329 error_report("Compression not supported for this file format");
2330 ret = -1;
2331 goto out;
2334 if (encryption || encryptfmt) {
2335 error_report("Compression and encryption not supported at "
2336 "the same time");
2337 ret = -1;
2338 goto out;
2341 if (preallocation
2342 && strcmp(preallocation, "off"))
2344 error_report("Compression and preallocation not supported at "
2345 "the same time");
2346 ret = -1;
2347 goto out;
2352 * The later open call will need any decryption secrets, and
2353 * bdrv_create() will purge "opts", so extract them now before
2354 * they are lost.
2356 if (!skip_create) {
2357 open_opts = qdict_new();
2358 qemu_opt_foreach(opts, img_add_key_secrets, open_opts, &error_abort);
2361 if (!skip_create) {
2362 /* Create the new image */
2363 ret = bdrv_create(drv, out_filename, opts, &local_err);
2364 if (ret < 0) {
2365 error_reportf_err(local_err, "%s: error while converting %s: ",
2366 out_filename, out_fmt);
2367 goto out;
2371 flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2372 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2373 if (ret < 0) {
2374 error_report("Invalid cache option: %s", cache);
2375 goto out;
2378 if (skip_create) {
2379 s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2380 flags, writethrough, quiet, false);
2381 } else {
2382 /* TODO ultimately we should allow --target-image-opts
2383 * to be used even when -n is not given.
2384 * That has to wait for bdrv_create to be improved
2385 * to allow filenames in option syntax
2387 s.target = img_open_file(out_filename, open_opts, out_fmt,
2388 flags, writethrough, quiet, false);
2389 open_opts = NULL; /* blk_new_open will have freed it */
2391 if (!s.target) {
2392 ret = -1;
2393 goto out;
2395 out_bs = blk_bs(s.target);
2397 if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
2398 error_report("Compression not supported for this file format");
2399 ret = -1;
2400 goto out;
2403 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2404 * or discard_alignment of the out_bs is greater. Limit to
2405 * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2406 s.buf_sectors = MIN(MAX_BUF_SECTORS,
2407 MAX(s.buf_sectors,
2408 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2409 out_bs->bl.pdiscard_alignment >>
2410 BDRV_SECTOR_BITS)));
2412 /* try to align the write requests to the destination to avoid unnecessary
2413 * RMW cycles. */
2414 s.alignment = MAX(pow2floor(s.min_sparse),
2415 DIV_ROUND_UP(out_bs->bl.request_alignment,
2416 BDRV_SECTOR_SIZE));
2417 assert(is_power_of_2(s.alignment));
2419 if (skip_create) {
2420 int64_t output_sectors = blk_nb_sectors(s.target);
2421 if (output_sectors < 0) {
2422 error_report("unable to get output image length: %s",
2423 strerror(-output_sectors));
2424 ret = -1;
2425 goto out;
2426 } else if (output_sectors < s.total_sectors) {
2427 error_report("output file is smaller than input file");
2428 ret = -1;
2429 goto out;
2433 if (s.target_has_backing) {
2434 /* Errors are treated as "backing length unknown" (which means
2435 * s.target_backing_sectors has to be negative, which it will
2436 * be automatically). The backing file length is used only
2437 * for optimizations, so such a case is not fatal. */
2438 s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
2439 } else {
2440 s.target_backing_sectors = -1;
2443 ret = bdrv_get_info(out_bs, &bdi);
2444 if (ret < 0) {
2445 if (s.compressed) {
2446 error_report("could not get block driver info");
2447 goto out;
2449 } else {
2450 s.compressed = s.compressed || bdi.needs_compressed_writes;
2451 s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2452 s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;
2455 ret = convert_do_copy(&s);
2456 out:
2457 if (!ret) {
2458 qemu_progress_print(100, 0);
2460 qemu_progress_end();
2461 qemu_opts_del(opts);
2462 qemu_opts_free(create_opts);
2463 qemu_opts_del(sn_opts);
2464 qobject_unref(open_opts);
2465 blk_unref(s.target);
2466 if (s.src) {
2467 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2468 blk_unref(s.src[bs_i]);
2470 g_free(s.src);
2472 g_free(s.src_sectors);
2473 fail_getopt:
2474 g_free(options);
2476 return !!ret;
2480 static void dump_snapshots(BlockDriverState *bs)
2482 QEMUSnapshotInfo *sn_tab, *sn;
2483 int nb_sns, i;
2485 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2486 if (nb_sns <= 0)
2487 return;
2488 printf("Snapshot list:\n");
2489 bdrv_snapshot_dump(fprintf, stdout, NULL);
2490 printf("\n");
2491 for(i = 0; i < nb_sns; i++) {
2492 sn = &sn_tab[i];
2493 bdrv_snapshot_dump(fprintf, stdout, sn);
2494 printf("\n");
2496 g_free(sn_tab);
2499 static void dump_json_image_info_list(ImageInfoList *list)
2501 QString *str;
2502 QObject *obj;
2503 Visitor *v = qobject_output_visitor_new(&obj);
2505 visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2506 visit_complete(v, &obj);
2507 str = qobject_to_json_pretty(obj);
2508 assert(str != NULL);
2509 printf("%s\n", qstring_get_str(str));
2510 qobject_unref(obj);
2511 visit_free(v);
2512 qobject_unref(str);
2515 static void dump_json_image_info(ImageInfo *info)
2517 QString *str;
2518 QObject *obj;
2519 Visitor *v = qobject_output_visitor_new(&obj);
2521 visit_type_ImageInfo(v, NULL, &info, &error_abort);
2522 visit_complete(v, &obj);
2523 str = qobject_to_json_pretty(obj);
2524 assert(str != NULL);
2525 printf("%s\n", qstring_get_str(str));
2526 qobject_unref(obj);
2527 visit_free(v);
2528 qobject_unref(str);
2531 static void dump_human_image_info_list(ImageInfoList *list)
2533 ImageInfoList *elem;
2534 bool delim = false;
2536 for (elem = list; elem; elem = elem->next) {
2537 if (delim) {
2538 printf("\n");
2540 delim = true;
2542 bdrv_image_info_dump(fprintf, stdout, elem->value);
2546 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2548 return strcmp(a, b) == 0;
2552 * Open an image file chain and return an ImageInfoList
2554 * @filename: topmost image filename
2555 * @fmt: topmost image format (may be NULL to autodetect)
2556 * @chain: true - enumerate entire backing file chain
2557 * false - only topmost image file
2559 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2560 * image file. If there was an error a message will have been printed to
2561 * stderr.
2563 static ImageInfoList *collect_image_info_list(bool image_opts,
2564 const char *filename,
2565 const char *fmt,
2566 bool chain, bool force_share)
2568 ImageInfoList *head = NULL;
2569 ImageInfoList **last = &head;
2570 GHashTable *filenames;
2571 Error *err = NULL;
2573 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2575 while (filename) {
2576 BlockBackend *blk;
2577 BlockDriverState *bs;
2578 ImageInfo *info;
2579 ImageInfoList *elem;
2581 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2582 error_report("Backing file '%s' creates an infinite loop.",
2583 filename);
2584 goto err;
2586 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2588 blk = img_open(image_opts, filename, fmt,
2589 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2590 force_share);
2591 if (!blk) {
2592 goto err;
2594 bs = blk_bs(blk);
2596 bdrv_query_image_info(bs, &info, &err);
2597 if (err) {
2598 error_report_err(err);
2599 blk_unref(blk);
2600 goto err;
2603 elem = g_new0(ImageInfoList, 1);
2604 elem->value = info;
2605 *last = elem;
2606 last = &elem->next;
2608 blk_unref(blk);
2610 filename = fmt = NULL;
2611 if (chain) {
2612 if (info->has_full_backing_filename) {
2613 filename = info->full_backing_filename;
2614 } else if (info->has_backing_filename) {
2615 error_report("Could not determine absolute backing filename,"
2616 " but backing filename '%s' present",
2617 info->backing_filename);
2618 goto err;
2620 if (info->has_backing_filename_format) {
2621 fmt = info->backing_filename_format;
2625 g_hash_table_destroy(filenames);
2626 return head;
2628 err:
2629 qapi_free_ImageInfoList(head);
2630 g_hash_table_destroy(filenames);
2631 return NULL;
2634 static int img_info(int argc, char **argv)
2636 int c;
2637 OutputFormat output_format = OFORMAT_HUMAN;
2638 bool chain = false;
2639 const char *filename, *fmt, *output;
2640 ImageInfoList *list;
2641 bool image_opts = false;
2642 bool force_share = false;
2644 fmt = NULL;
2645 output = NULL;
2646 for(;;) {
2647 int option_index = 0;
2648 static const struct option long_options[] = {
2649 {"help", no_argument, 0, 'h'},
2650 {"format", required_argument, 0, 'f'},
2651 {"output", required_argument, 0, OPTION_OUTPUT},
2652 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2653 {"object", required_argument, 0, OPTION_OBJECT},
2654 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2655 {"force-share", no_argument, 0, 'U'},
2656 {0, 0, 0, 0}
2658 c = getopt_long(argc, argv, ":f:hU",
2659 long_options, &option_index);
2660 if (c == -1) {
2661 break;
2663 switch(c) {
2664 case ':':
2665 missing_argument(argv[optind - 1]);
2666 break;
2667 case '?':
2668 unrecognized_option(argv[optind - 1]);
2669 break;
2670 case 'h':
2671 help();
2672 break;
2673 case 'f':
2674 fmt = optarg;
2675 break;
2676 case 'U':
2677 force_share = true;
2678 break;
2679 case OPTION_OUTPUT:
2680 output = optarg;
2681 break;
2682 case OPTION_BACKING_CHAIN:
2683 chain = true;
2684 break;
2685 case OPTION_OBJECT: {
2686 QemuOpts *opts;
2687 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2688 optarg, true);
2689 if (!opts) {
2690 return 1;
2692 } break;
2693 case OPTION_IMAGE_OPTS:
2694 image_opts = true;
2695 break;
2698 if (optind != argc - 1) {
2699 error_exit("Expecting one image file name");
2701 filename = argv[optind++];
2703 if (output && !strcmp(output, "json")) {
2704 output_format = OFORMAT_JSON;
2705 } else if (output && !strcmp(output, "human")) {
2706 output_format = OFORMAT_HUMAN;
2707 } else if (output) {
2708 error_report("--output must be used with human or json as argument.");
2709 return 1;
2712 if (qemu_opts_foreach(&qemu_object_opts,
2713 user_creatable_add_opts_foreach,
2714 NULL, NULL)) {
2715 return 1;
2718 list = collect_image_info_list(image_opts, filename, fmt, chain,
2719 force_share);
2720 if (!list) {
2721 return 1;
2724 switch (output_format) {
2725 case OFORMAT_HUMAN:
2726 dump_human_image_info_list(list);
2727 break;
2728 case OFORMAT_JSON:
2729 if (chain) {
2730 dump_json_image_info_list(list);
2731 } else {
2732 dump_json_image_info(list->value);
2734 break;
2737 qapi_free_ImageInfoList(list);
2738 return 0;
2741 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2742 MapEntry *next)
2744 switch (output_format) {
2745 case OFORMAT_HUMAN:
2746 if (e->data && !e->has_offset) {
2747 error_report("File contains external, encrypted or compressed clusters.");
2748 exit(1);
2750 if (e->data && !e->zero) {
2751 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2752 e->start, e->length,
2753 e->has_offset ? e->offset : 0,
2754 e->has_filename ? e->filename : "");
2756 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2757 * Modify the flags here to allow more coalescing.
2759 if (next && (!next->data || next->zero)) {
2760 next->data = false;
2761 next->zero = true;
2763 break;
2764 case OFORMAT_JSON:
2765 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2766 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2767 (e->start == 0 ? "[" : ",\n"),
2768 e->start, e->length, e->depth,
2769 e->zero ? "true" : "false",
2770 e->data ? "true" : "false");
2771 if (e->has_offset) {
2772 printf(", \"offset\": %"PRId64"", e->offset);
2774 putchar('}');
2776 if (!next) {
2777 printf("]\n");
2779 break;
2783 static int get_block_status(BlockDriverState *bs, int64_t offset,
2784 int64_t bytes, MapEntry *e)
2786 int ret;
2787 int depth;
2788 BlockDriverState *file;
2789 bool has_offset;
2790 int64_t map;
2792 /* As an optimization, we could cache the current range of unallocated
2793 * clusters in each file of the chain, and avoid querying the same
2794 * range repeatedly.
2797 depth = 0;
2798 for (;;) {
2799 ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file);
2800 if (ret < 0) {
2801 return ret;
2803 assert(bytes);
2804 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2805 break;
2807 bs = backing_bs(bs);
2808 if (bs == NULL) {
2809 ret = 0;
2810 break;
2813 depth++;
2816 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2818 *e = (MapEntry) {
2819 .start = offset,
2820 .length = bytes,
2821 .data = !!(ret & BDRV_BLOCK_DATA),
2822 .zero = !!(ret & BDRV_BLOCK_ZERO),
2823 .offset = map,
2824 .has_offset = has_offset,
2825 .depth = depth,
2826 .has_filename = file && has_offset,
2827 .filename = file && has_offset ? file->filename : NULL,
2830 return 0;
2833 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2835 if (curr->length == 0) {
2836 return false;
2838 if (curr->zero != next->zero ||
2839 curr->data != next->data ||
2840 curr->depth != next->depth ||
2841 curr->has_filename != next->has_filename ||
2842 curr->has_offset != next->has_offset) {
2843 return false;
2845 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2846 return false;
2848 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2849 return false;
2851 return true;
2854 static int img_map(int argc, char **argv)
2856 int c;
2857 OutputFormat output_format = OFORMAT_HUMAN;
2858 BlockBackend *blk;
2859 BlockDriverState *bs;
2860 const char *filename, *fmt, *output;
2861 int64_t length;
2862 MapEntry curr = { .length = 0 }, next;
2863 int ret = 0;
2864 bool image_opts = false;
2865 bool force_share = false;
2867 fmt = NULL;
2868 output = NULL;
2869 for (;;) {
2870 int option_index = 0;
2871 static const struct option long_options[] = {
2872 {"help", no_argument, 0, 'h'},
2873 {"format", required_argument, 0, 'f'},
2874 {"output", required_argument, 0, OPTION_OUTPUT},
2875 {"object", required_argument, 0, OPTION_OBJECT},
2876 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2877 {"force-share", no_argument, 0, 'U'},
2878 {0, 0, 0, 0}
2880 c = getopt_long(argc, argv, ":f:hU",
2881 long_options, &option_index);
2882 if (c == -1) {
2883 break;
2885 switch (c) {
2886 case ':':
2887 missing_argument(argv[optind - 1]);
2888 break;
2889 case '?':
2890 unrecognized_option(argv[optind - 1]);
2891 break;
2892 case 'h':
2893 help();
2894 break;
2895 case 'f':
2896 fmt = optarg;
2897 break;
2898 case 'U':
2899 force_share = true;
2900 break;
2901 case OPTION_OUTPUT:
2902 output = optarg;
2903 break;
2904 case OPTION_OBJECT: {
2905 QemuOpts *opts;
2906 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2907 optarg, true);
2908 if (!opts) {
2909 return 1;
2911 } break;
2912 case OPTION_IMAGE_OPTS:
2913 image_opts = true;
2914 break;
2917 if (optind != argc - 1) {
2918 error_exit("Expecting one image file name");
2920 filename = argv[optind];
2922 if (output && !strcmp(output, "json")) {
2923 output_format = OFORMAT_JSON;
2924 } else if (output && !strcmp(output, "human")) {
2925 output_format = OFORMAT_HUMAN;
2926 } else if (output) {
2927 error_report("--output must be used with human or json as argument.");
2928 return 1;
2931 if (qemu_opts_foreach(&qemu_object_opts,
2932 user_creatable_add_opts_foreach,
2933 NULL, NULL)) {
2934 return 1;
2937 blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
2938 if (!blk) {
2939 return 1;
2941 bs = blk_bs(blk);
2943 if (output_format == OFORMAT_HUMAN) {
2944 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2947 length = blk_getlength(blk);
2948 while (curr.start + curr.length < length) {
2949 int64_t offset = curr.start + curr.length;
2950 int64_t n;
2952 /* Probe up to 1 GiB at a time. */
2953 n = MIN(1 << 30, length - offset);
2954 ret = get_block_status(bs, offset, n, &next);
2956 if (ret < 0) {
2957 error_report("Could not read file metadata: %s", strerror(-ret));
2958 goto out;
2961 if (entry_mergeable(&curr, &next)) {
2962 curr.length += next.length;
2963 continue;
2966 if (curr.length > 0) {
2967 dump_map_entry(output_format, &curr, &next);
2969 curr = next;
2972 dump_map_entry(output_format, &curr, NULL);
2974 out:
2975 blk_unref(blk);
2976 return ret < 0;
2979 #define SNAPSHOT_LIST 1
2980 #define SNAPSHOT_CREATE 2
2981 #define SNAPSHOT_APPLY 3
2982 #define SNAPSHOT_DELETE 4
2984 static int img_snapshot(int argc, char **argv)
2986 BlockBackend *blk;
2987 BlockDriverState *bs;
2988 QEMUSnapshotInfo sn;
2989 char *filename, *snapshot_name = NULL;
2990 int c, ret = 0, bdrv_oflags;
2991 int action = 0;
2992 qemu_timeval tv;
2993 bool quiet = false;
2994 Error *err = NULL;
2995 bool image_opts = false;
2996 bool force_share = false;
2998 bdrv_oflags = BDRV_O_RDWR;
2999 /* Parse commandline parameters */
3000 for(;;) {
3001 static const struct option long_options[] = {
3002 {"help", no_argument, 0, 'h'},
3003 {"object", required_argument, 0, OPTION_OBJECT},
3004 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3005 {"force-share", no_argument, 0, 'U'},
3006 {0, 0, 0, 0}
3008 c = getopt_long(argc, argv, ":la:c:d:hqU",
3009 long_options, NULL);
3010 if (c == -1) {
3011 break;
3013 switch(c) {
3014 case ':':
3015 missing_argument(argv[optind - 1]);
3016 break;
3017 case '?':
3018 unrecognized_option(argv[optind - 1]);
3019 break;
3020 case 'h':
3021 help();
3022 return 0;
3023 case 'l':
3024 if (action) {
3025 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3026 return 0;
3028 action = SNAPSHOT_LIST;
3029 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
3030 break;
3031 case 'a':
3032 if (action) {
3033 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3034 return 0;
3036 action = SNAPSHOT_APPLY;
3037 snapshot_name = optarg;
3038 break;
3039 case 'c':
3040 if (action) {
3041 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3042 return 0;
3044 action = SNAPSHOT_CREATE;
3045 snapshot_name = optarg;
3046 break;
3047 case 'd':
3048 if (action) {
3049 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3050 return 0;
3052 action = SNAPSHOT_DELETE;
3053 snapshot_name = optarg;
3054 break;
3055 case 'q':
3056 quiet = true;
3057 break;
3058 case 'U':
3059 force_share = true;
3060 break;
3061 case OPTION_OBJECT: {
3062 QemuOpts *opts;
3063 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3064 optarg, true);
3065 if (!opts) {
3066 return 1;
3068 } break;
3069 case OPTION_IMAGE_OPTS:
3070 image_opts = true;
3071 break;
3075 if (optind != argc - 1) {
3076 error_exit("Expecting one image file name");
3078 filename = argv[optind++];
3080 if (qemu_opts_foreach(&qemu_object_opts,
3081 user_creatable_add_opts_foreach,
3082 NULL, NULL)) {
3083 return 1;
3086 /* Open the image */
3087 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
3088 force_share);
3089 if (!blk) {
3090 return 1;
3092 bs = blk_bs(blk);
3094 /* Perform the requested action */
3095 switch(action) {
3096 case SNAPSHOT_LIST:
3097 dump_snapshots(bs);
3098 break;
3100 case SNAPSHOT_CREATE:
3101 memset(&sn, 0, sizeof(sn));
3102 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3104 qemu_gettimeofday(&tv);
3105 sn.date_sec = tv.tv_sec;
3106 sn.date_nsec = tv.tv_usec * 1000;
3108 ret = bdrv_snapshot_create(bs, &sn);
3109 if (ret) {
3110 error_report("Could not create snapshot '%s': %d (%s)",
3111 snapshot_name, ret, strerror(-ret));
3113 break;
3115 case SNAPSHOT_APPLY:
3116 ret = bdrv_snapshot_goto(bs, snapshot_name, &err);
3117 if (ret) {
3118 error_reportf_err(err, "Could not apply snapshot '%s': ",
3119 snapshot_name);
3121 break;
3123 case SNAPSHOT_DELETE:
3124 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
3125 if (err) {
3126 error_reportf_err(err, "Could not delete snapshot '%s': ",
3127 snapshot_name);
3128 ret = 1;
3130 break;
3133 /* Cleanup */
3134 blk_unref(blk);
3135 if (ret) {
3136 return 1;
3138 return 0;
3141 static int img_rebase(int argc, char **argv)
3143 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
3144 uint8_t *buf_old = NULL;
3145 uint8_t *buf_new = NULL;
3146 BlockDriverState *bs = NULL;
3147 char *filename;
3148 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
3149 int c, flags, src_flags, ret;
3150 bool writethrough, src_writethrough;
3151 int unsafe = 0;
3152 bool force_share = false;
3153 int progress = 0;
3154 bool quiet = false;
3155 Error *local_err = NULL;
3156 bool image_opts = false;
3158 /* Parse commandline parameters */
3159 fmt = NULL;
3160 cache = BDRV_DEFAULT_CACHE;
3161 src_cache = BDRV_DEFAULT_CACHE;
3162 out_baseimg = NULL;
3163 out_basefmt = NULL;
3164 for(;;) {
3165 static const struct option long_options[] = {
3166 {"help", no_argument, 0, 'h'},
3167 {"object", required_argument, 0, OPTION_OBJECT},
3168 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3169 {"force-share", no_argument, 0, 'U'},
3170 {0, 0, 0, 0}
3172 c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU",
3173 long_options, NULL);
3174 if (c == -1) {
3175 break;
3177 switch(c) {
3178 case ':':
3179 missing_argument(argv[optind - 1]);
3180 break;
3181 case '?':
3182 unrecognized_option(argv[optind - 1]);
3183 break;
3184 case 'h':
3185 help();
3186 return 0;
3187 case 'f':
3188 fmt = optarg;
3189 break;
3190 case 'F':
3191 out_basefmt = optarg;
3192 break;
3193 case 'b':
3194 out_baseimg = optarg;
3195 break;
3196 case 'u':
3197 unsafe = 1;
3198 break;
3199 case 'p':
3200 progress = 1;
3201 break;
3202 case 't':
3203 cache = optarg;
3204 break;
3205 case 'T':
3206 src_cache = optarg;
3207 break;
3208 case 'q':
3209 quiet = true;
3210 break;
3211 case OPTION_OBJECT: {
3212 QemuOpts *opts;
3213 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3214 optarg, true);
3215 if (!opts) {
3216 return 1;
3218 } break;
3219 case OPTION_IMAGE_OPTS:
3220 image_opts = true;
3221 break;
3222 case 'U':
3223 force_share = true;
3224 break;
3228 if (quiet) {
3229 progress = 0;
3232 if (optind != argc - 1) {
3233 error_exit("Expecting one image file name");
3235 if (!unsafe && !out_baseimg) {
3236 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3238 filename = argv[optind++];
3240 if (qemu_opts_foreach(&qemu_object_opts,
3241 user_creatable_add_opts_foreach,
3242 NULL, NULL)) {
3243 return 1;
3246 qemu_progress_init(progress, 2.0);
3247 qemu_progress_print(0, 100);
3249 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
3250 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3251 if (ret < 0) {
3252 error_report("Invalid cache option: %s", cache);
3253 goto out;
3256 src_flags = 0;
3257 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
3258 if (ret < 0) {
3259 error_report("Invalid source cache option: %s", src_cache);
3260 goto out;
3263 /* The source files are opened read-only, don't care about WCE */
3264 assert((src_flags & BDRV_O_RDWR) == 0);
3265 (void) src_writethrough;
3268 * Open the images.
3270 * Ignore the old backing file for unsafe rebase in case we want to correct
3271 * the reference to a renamed or moved backing file.
3273 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3274 false);
3275 if (!blk) {
3276 ret = -1;
3277 goto out;
3279 bs = blk_bs(blk);
3281 if (out_basefmt != NULL) {
3282 if (bdrv_find_format(out_basefmt) == NULL) {
3283 error_report("Invalid format name: '%s'", out_basefmt);
3284 ret = -1;
3285 goto out;
3289 /* For safe rebasing we need to compare old and new backing file */
3290 if (!unsafe) {
3291 char backing_name[PATH_MAX];
3292 QDict *options = NULL;
3294 if (bs->backing_format[0] != '\0') {
3295 options = qdict_new();
3296 qdict_put_str(options, "driver", bs->backing_format);
3299 if (force_share) {
3300 if (!options) {
3301 options = qdict_new();
3303 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3305 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3306 blk_old_backing = blk_new_open(backing_name, NULL,
3307 options, src_flags, &local_err);
3308 if (!blk_old_backing) {
3309 error_reportf_err(local_err,
3310 "Could not open old backing file '%s': ",
3311 backing_name);
3312 ret = -1;
3313 goto out;
3316 if (out_baseimg[0]) {
3317 const char *overlay_filename;
3318 char *out_real_path;
3320 options = qdict_new();
3321 if (out_basefmt) {
3322 qdict_put_str(options, "driver", out_basefmt);
3324 if (force_share) {
3325 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3328 overlay_filename = bs->exact_filename[0] ? bs->exact_filename
3329 : bs->filename;
3330 out_real_path = g_malloc(PATH_MAX);
3332 bdrv_get_full_backing_filename_from_filename(overlay_filename,
3333 out_baseimg,
3334 out_real_path,
3335 PATH_MAX,
3336 &local_err);
3337 if (local_err) {
3338 error_reportf_err(local_err,
3339 "Could not resolve backing filename: ");
3340 ret = -1;
3341 g_free(out_real_path);
3342 goto out;
3345 blk_new_backing = blk_new_open(out_real_path, NULL,
3346 options, src_flags, &local_err);
3347 g_free(out_real_path);
3348 if (!blk_new_backing) {
3349 error_reportf_err(local_err,
3350 "Could not open new backing file '%s': ",
3351 out_baseimg);
3352 ret = -1;
3353 goto out;
3359 * Check each unallocated cluster in the COW file. If it is unallocated,
3360 * accesses go to the backing file. We must therefore compare this cluster
3361 * in the old and new backing file, and if they differ we need to copy it
3362 * from the old backing file into the COW file.
3364 * If qemu-img crashes during this step, no harm is done. The content of
3365 * the image is the same as the original one at any time.
3367 if (!unsafe) {
3368 int64_t size;
3369 int64_t old_backing_size;
3370 int64_t new_backing_size = 0;
3371 uint64_t offset;
3372 int64_t n;
3373 float local_progress = 0;
3375 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
3376 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
3378 size = blk_getlength(blk);
3379 if (size < 0) {
3380 error_report("Could not get size of '%s': %s",
3381 filename, strerror(-size));
3382 ret = -1;
3383 goto out;
3385 old_backing_size = blk_getlength(blk_old_backing);
3386 if (old_backing_size < 0) {
3387 char backing_name[PATH_MAX];
3389 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3390 error_report("Could not get size of '%s': %s",
3391 backing_name, strerror(-old_backing_size));
3392 ret = -1;
3393 goto out;
3395 if (blk_new_backing) {
3396 new_backing_size = blk_getlength(blk_new_backing);
3397 if (new_backing_size < 0) {
3398 error_report("Could not get size of '%s': %s",
3399 out_baseimg, strerror(-new_backing_size));
3400 ret = -1;
3401 goto out;
3405 if (size != 0) {
3406 local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE));
3409 for (offset = 0; offset < size; offset += n) {
3410 /* How many bytes can we handle with the next read? */
3411 n = MIN(IO_BUF_SIZE, size - offset);
3413 /* If the cluster is allocated, we don't need to take action */
3414 ret = bdrv_is_allocated(bs, offset, n, &n);
3415 if (ret < 0) {
3416 error_report("error while reading image metadata: %s",
3417 strerror(-ret));
3418 goto out;
3420 if (ret) {
3421 continue;
3425 * Read old and new backing file and take into consideration that
3426 * backing files may be smaller than the COW image.
3428 if (offset >= old_backing_size) {
3429 memset(buf_old, 0, n);
3430 } else {
3431 if (offset + n > old_backing_size) {
3432 n = old_backing_size - offset;
3435 ret = blk_pread(blk_old_backing, offset, buf_old, n);
3436 if (ret < 0) {
3437 error_report("error while reading from old backing file");
3438 goto out;
3442 if (offset >= new_backing_size || !blk_new_backing) {
3443 memset(buf_new, 0, n);
3444 } else {
3445 if (offset + n > new_backing_size) {
3446 n = new_backing_size - offset;
3449 ret = blk_pread(blk_new_backing, offset, buf_new, n);
3450 if (ret < 0) {
3451 error_report("error while reading from new backing file");
3452 goto out;
3456 /* If they differ, we need to write to the COW file */
3457 uint64_t written = 0;
3459 while (written < n) {
3460 int64_t pnum;
3462 if (compare_buffers(buf_old + written, buf_new + written,
3463 n - written, &pnum))
3465 ret = blk_pwrite(blk, offset + written,
3466 buf_old + written, pnum, 0);
3467 if (ret < 0) {
3468 error_report("Error while writing to COW image: %s",
3469 strerror(-ret));
3470 goto out;
3474 written += pnum;
3476 qemu_progress_print(local_progress, 100);
3481 * Change the backing file. All clusters that are different from the old
3482 * backing file are overwritten in the COW file now, so the visible content
3483 * doesn't change when we switch the backing file.
3485 if (out_baseimg && *out_baseimg) {
3486 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3487 } else {
3488 ret = bdrv_change_backing_file(bs, NULL, NULL);
3491 if (ret == -ENOSPC) {
3492 error_report("Could not change the backing file to '%s': No "
3493 "space left in the file header", out_baseimg);
3494 } else if (ret < 0) {
3495 error_report("Could not change the backing file to '%s': %s",
3496 out_baseimg, strerror(-ret));
3499 qemu_progress_print(100, 0);
3501 * TODO At this point it is possible to check if any clusters that are
3502 * allocated in the COW file are the same in the backing file. If so, they
3503 * could be dropped from the COW file. Don't do this before switching the
3504 * backing file, in case of a crash this would lead to corruption.
3506 out:
3507 qemu_progress_end();
3508 /* Cleanup */
3509 if (!unsafe) {
3510 blk_unref(blk_old_backing);
3511 blk_unref(blk_new_backing);
3513 qemu_vfree(buf_old);
3514 qemu_vfree(buf_new);
3516 blk_unref(blk);
3517 if (ret) {
3518 return 1;
3520 return 0;
3523 static int img_resize(int argc, char **argv)
3525 Error *err = NULL;
3526 int c, ret, relative;
3527 const char *filename, *fmt, *size;
3528 int64_t n, total_size, current_size, new_size;
3529 bool quiet = false;
3530 BlockBackend *blk = NULL;
3531 PreallocMode prealloc = PREALLOC_MODE_OFF;
3532 QemuOpts *param;
3534 static QemuOptsList resize_options = {
3535 .name = "resize_options",
3536 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3537 .desc = {
3539 .name = BLOCK_OPT_SIZE,
3540 .type = QEMU_OPT_SIZE,
3541 .help = "Virtual disk size"
3542 }, {
3543 /* end of list */
3547 bool image_opts = false;
3548 bool shrink = false;
3550 /* Remove size from argv manually so that negative numbers are not treated
3551 * as options by getopt. */
3552 if (argc < 3) {
3553 error_exit("Not enough arguments");
3554 return 1;
3557 size = argv[--argc];
3559 /* Parse getopt arguments */
3560 fmt = NULL;
3561 for(;;) {
3562 static const struct option long_options[] = {
3563 {"help", no_argument, 0, 'h'},
3564 {"object", required_argument, 0, OPTION_OBJECT},
3565 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3566 {"preallocation", required_argument, 0, OPTION_PREALLOCATION},
3567 {"shrink", no_argument, 0, OPTION_SHRINK},
3568 {0, 0, 0, 0}
3570 c = getopt_long(argc, argv, ":f:hq",
3571 long_options, NULL);
3572 if (c == -1) {
3573 break;
3575 switch(c) {
3576 case ':':
3577 missing_argument(argv[optind - 1]);
3578 break;
3579 case '?':
3580 unrecognized_option(argv[optind - 1]);
3581 break;
3582 case 'h':
3583 help();
3584 break;
3585 case 'f':
3586 fmt = optarg;
3587 break;
3588 case 'q':
3589 quiet = true;
3590 break;
3591 case OPTION_OBJECT: {
3592 QemuOpts *opts;
3593 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3594 optarg, true);
3595 if (!opts) {
3596 return 1;
3598 } break;
3599 case OPTION_IMAGE_OPTS:
3600 image_opts = true;
3601 break;
3602 case OPTION_PREALLOCATION:
3603 prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg,
3604 PREALLOC_MODE__MAX, NULL);
3605 if (prealloc == PREALLOC_MODE__MAX) {
3606 error_report("Invalid preallocation mode '%s'", optarg);
3607 return 1;
3609 break;
3610 case OPTION_SHRINK:
3611 shrink = true;
3612 break;
3615 if (optind != argc - 1) {
3616 error_exit("Expecting image file name and size");
3618 filename = argv[optind++];
3620 if (qemu_opts_foreach(&qemu_object_opts,
3621 user_creatable_add_opts_foreach,
3622 NULL, NULL)) {
3623 return 1;
3626 /* Choose grow, shrink, or absolute resize mode */
3627 switch (size[0]) {
3628 case '+':
3629 relative = 1;
3630 size++;
3631 break;
3632 case '-':
3633 relative = -1;
3634 size++;
3635 break;
3636 default:
3637 relative = 0;
3638 break;
3641 /* Parse size */
3642 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3643 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3644 if (err) {
3645 error_report_err(err);
3646 ret = -1;
3647 qemu_opts_del(param);
3648 goto out;
3650 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3651 qemu_opts_del(param);
3653 blk = img_open(image_opts, filename, fmt,
3654 BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet,
3655 false);
3656 if (!blk) {
3657 ret = -1;
3658 goto out;
3661 current_size = blk_getlength(blk);
3662 if (current_size < 0) {
3663 error_report("Failed to inquire current image length: %s",
3664 strerror(-current_size));
3665 ret = -1;
3666 goto out;
3669 if (relative) {
3670 total_size = current_size + n * relative;
3671 } else {
3672 total_size = n;
3674 if (total_size <= 0) {
3675 error_report("New image size must be positive");
3676 ret = -1;
3677 goto out;
3680 if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) {
3681 error_report("Preallocation can only be used for growing images");
3682 ret = -1;
3683 goto out;
3686 if (total_size < current_size && !shrink) {
3687 warn_report("Shrinking an image will delete all data beyond the "
3688 "shrunken image's end. Before performing such an "
3689 "operation, make sure there is no important data there.");
3691 if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) {
3692 error_report(
3693 "Use the --shrink option to perform a shrink operation.");
3694 ret = -1;
3695 goto out;
3696 } else {
3697 warn_report("Using the --shrink option will suppress this message. "
3698 "Note that future versions of qemu-img may refuse to "
3699 "shrink images without this option.");
3703 ret = blk_truncate(blk, total_size, prealloc, &err);
3704 if (ret < 0) {
3705 error_report_err(err);
3706 goto out;
3709 new_size = blk_getlength(blk);
3710 if (new_size < 0) {
3711 error_report("Failed to verify truncated image length: %s",
3712 strerror(-new_size));
3713 ret = -1;
3714 goto out;
3717 /* Some block drivers implement a truncation method, but only so
3718 * the user can cause qemu to refresh the image's size from disk.
3719 * The idea is that the user resizes the image outside of qemu and
3720 * then invokes block_resize to inform qemu about it.
3721 * (This includes iscsi and file-posix for device files.)
3722 * Of course, that is not the behavior someone invoking
3723 * qemu-img resize would find useful, so we catch that behavior
3724 * here and tell the user. */
3725 if (new_size != total_size && new_size == current_size) {
3726 error_report("Image was not resized; resizing may not be supported "
3727 "for this image");
3728 ret = -1;
3729 goto out;
3732 if (new_size != total_size) {
3733 warn_report("Image should have been resized to %" PRIi64
3734 " bytes, but was resized to %" PRIi64 " bytes",
3735 total_size, new_size);
3738 qprintf(quiet, "Image resized.\n");
3740 out:
3741 blk_unref(blk);
3742 if (ret) {
3743 return 1;
3745 return 0;
3748 static void amend_status_cb(BlockDriverState *bs,
3749 int64_t offset, int64_t total_work_size,
3750 void *opaque)
3752 qemu_progress_print(100.f * offset / total_work_size, 0);
3755 static int print_amend_option_help(const char *format)
3757 BlockDriver *drv;
3759 /* Find driver and parse its options */
3760 drv = bdrv_find_format(format);
3761 if (!drv) {
3762 error_report("Unknown file format '%s'", format);
3763 return 1;
3766 if (!drv->bdrv_amend_options) {
3767 error_report("Format driver '%s' does not support option amendment",
3768 format);
3769 return 1;
3772 /* Every driver supporting amendment must have create_opts */
3773 assert(drv->create_opts);
3775 printf("Creation options for '%s':\n", format);
3776 qemu_opts_print_help(drv->create_opts);
3777 printf("\nNote that not all of these options may be amendable.\n");
3778 return 0;
3781 static int img_amend(int argc, char **argv)
3783 Error *err = NULL;
3784 int c, ret = 0;
3785 char *options = NULL;
3786 QemuOptsList *create_opts = NULL;
3787 QemuOpts *opts = NULL;
3788 const char *fmt = NULL, *filename, *cache;
3789 int flags;
3790 bool writethrough;
3791 bool quiet = false, progress = false;
3792 BlockBackend *blk = NULL;
3793 BlockDriverState *bs = NULL;
3794 bool image_opts = false;
3796 cache = BDRV_DEFAULT_CACHE;
3797 for (;;) {
3798 static const struct option long_options[] = {
3799 {"help", no_argument, 0, 'h'},
3800 {"object", required_argument, 0, OPTION_OBJECT},
3801 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3802 {0, 0, 0, 0}
3804 c = getopt_long(argc, argv, ":ho:f:t:pq",
3805 long_options, NULL);
3806 if (c == -1) {
3807 break;
3810 switch (c) {
3811 case ':':
3812 missing_argument(argv[optind - 1]);
3813 break;
3814 case '?':
3815 unrecognized_option(argv[optind - 1]);
3816 break;
3817 case 'h':
3818 help();
3819 break;
3820 case 'o':
3821 if (!is_valid_option_list(optarg)) {
3822 error_report("Invalid option list: %s", optarg);
3823 ret = -1;
3824 goto out_no_progress;
3826 if (!options) {
3827 options = g_strdup(optarg);
3828 } else {
3829 char *old_options = options;
3830 options = g_strdup_printf("%s,%s", options, optarg);
3831 g_free(old_options);
3833 break;
3834 case 'f':
3835 fmt = optarg;
3836 break;
3837 case 't':
3838 cache = optarg;
3839 break;
3840 case 'p':
3841 progress = true;
3842 break;
3843 case 'q':
3844 quiet = true;
3845 break;
3846 case OPTION_OBJECT:
3847 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3848 optarg, true);
3849 if (!opts) {
3850 ret = -1;
3851 goto out_no_progress;
3853 break;
3854 case OPTION_IMAGE_OPTS:
3855 image_opts = true;
3856 break;
3860 if (!options) {
3861 error_exit("Must specify options (-o)");
3864 if (qemu_opts_foreach(&qemu_object_opts,
3865 user_creatable_add_opts_foreach,
3866 NULL, NULL)) {
3867 ret = -1;
3868 goto out_no_progress;
3871 if (quiet) {
3872 progress = false;
3874 qemu_progress_init(progress, 1.0);
3876 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3877 if (fmt && has_help_option(options)) {
3878 /* If a format is explicitly specified (and possibly no filename is
3879 * given), print option help here */
3880 ret = print_amend_option_help(fmt);
3881 goto out;
3884 if (optind != argc - 1) {
3885 error_report("Expecting one image file name");
3886 ret = -1;
3887 goto out;
3890 flags = BDRV_O_RDWR;
3891 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3892 if (ret < 0) {
3893 error_report("Invalid cache option: %s", cache);
3894 goto out;
3897 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3898 false);
3899 if (!blk) {
3900 ret = -1;
3901 goto out;
3903 bs = blk_bs(blk);
3905 fmt = bs->drv->format_name;
3907 if (has_help_option(options)) {
3908 /* If the format was auto-detected, print option help here */
3909 ret = print_amend_option_help(fmt);
3910 goto out;
3913 if (!bs->drv->bdrv_amend_options) {
3914 error_report("Format driver '%s' does not support option amendment",
3915 fmt);
3916 ret = -1;
3917 goto out;
3920 /* Every driver supporting amendment must have create_opts */
3921 assert(bs->drv->create_opts);
3923 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3924 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3925 qemu_opts_do_parse(opts, options, NULL, &err);
3926 if (err) {
3927 error_report_err(err);
3928 ret = -1;
3929 goto out;
3932 /* In case the driver does not call amend_status_cb() */
3933 qemu_progress_print(0.f, 0);
3934 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err);
3935 qemu_progress_print(100.f, 0);
3936 if (ret < 0) {
3937 error_report_err(err);
3938 goto out;
3941 out:
3942 qemu_progress_end();
3944 out_no_progress:
3945 blk_unref(blk);
3946 qemu_opts_del(opts);
3947 qemu_opts_free(create_opts);
3948 g_free(options);
3950 if (ret) {
3951 return 1;
3953 return 0;
3956 typedef struct BenchData {
3957 BlockBackend *blk;
3958 uint64_t image_size;
3959 bool write;
3960 int bufsize;
3961 int step;
3962 int nrreq;
3963 int n;
3964 int flush_interval;
3965 bool drain_on_flush;
3966 uint8_t *buf;
3967 QEMUIOVector *qiov;
3969 int in_flight;
3970 bool in_flush;
3971 uint64_t offset;
3972 } BenchData;
3974 static void bench_undrained_flush_cb(void *opaque, int ret)
3976 if (ret < 0) {
3977 error_report("Failed flush request: %s", strerror(-ret));
3978 exit(EXIT_FAILURE);
3982 static void bench_cb(void *opaque, int ret)
3984 BenchData *b = opaque;
3985 BlockAIOCB *acb;
3987 if (ret < 0) {
3988 error_report("Failed request: %s", strerror(-ret));
3989 exit(EXIT_FAILURE);
3992 if (b->in_flush) {
3993 /* Just finished a flush with drained queue: Start next requests */
3994 assert(b->in_flight == 0);
3995 b->in_flush = false;
3996 } else if (b->in_flight > 0) {
3997 int remaining = b->n - b->in_flight;
3999 b->n--;
4000 b->in_flight--;
4002 /* Time for flush? Drain queue if requested, then flush */
4003 if (b->flush_interval && remaining % b->flush_interval == 0) {
4004 if (!b->in_flight || !b->drain_on_flush) {
4005 BlockCompletionFunc *cb;
4007 if (b->drain_on_flush) {
4008 b->in_flush = true;
4009 cb = bench_cb;
4010 } else {
4011 cb = bench_undrained_flush_cb;
4014 acb = blk_aio_flush(b->blk, cb, b);
4015 if (!acb) {
4016 error_report("Failed to issue flush request");
4017 exit(EXIT_FAILURE);
4020 if (b->drain_on_flush) {
4021 return;
4026 while (b->n > b->in_flight && b->in_flight < b->nrreq) {
4027 int64_t offset = b->offset;
4028 /* blk_aio_* might look for completed I/Os and kick bench_cb
4029 * again, so make sure this operation is counted by in_flight
4030 * and b->offset is ready for the next submission.
4032 b->in_flight++;
4033 b->offset += b->step;
4034 b->offset %= b->image_size;
4035 if (b->write) {
4036 acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b);
4037 } else {
4038 acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b);
4040 if (!acb) {
4041 error_report("Failed to issue request");
4042 exit(EXIT_FAILURE);
4047 static int img_bench(int argc, char **argv)
4049 int c, ret = 0;
4050 const char *fmt = NULL, *filename;
4051 bool quiet = false;
4052 bool image_opts = false;
4053 bool is_write = false;
4054 int count = 75000;
4055 int depth = 64;
4056 int64_t offset = 0;
4057 size_t bufsize = 4096;
4058 int pattern = 0;
4059 size_t step = 0;
4060 int flush_interval = 0;
4061 bool drain_on_flush = true;
4062 int64_t image_size;
4063 BlockBackend *blk = NULL;
4064 BenchData data = {};
4065 int flags = 0;
4066 bool writethrough = false;
4067 struct timeval t1, t2;
4068 int i;
4069 bool force_share = false;
4070 size_t buf_size;
4072 for (;;) {
4073 static const struct option long_options[] = {
4074 {"help", no_argument, 0, 'h'},
4075 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
4076 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4077 {"pattern", required_argument, 0, OPTION_PATTERN},
4078 {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
4079 {"force-share", no_argument, 0, 'U'},
4080 {0, 0, 0, 0}
4082 c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
4083 if (c == -1) {
4084 break;
4087 switch (c) {
4088 case ':':
4089 missing_argument(argv[optind - 1]);
4090 break;
4091 case '?':
4092 unrecognized_option(argv[optind - 1]);
4093 break;
4094 case 'h':
4095 help();
4096 break;
4097 case 'c':
4099 unsigned long res;
4101 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4102 error_report("Invalid request count specified");
4103 return 1;
4105 count = res;
4106 break;
4108 case 'd':
4110 unsigned long res;
4112 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4113 error_report("Invalid queue depth specified");
4114 return 1;
4116 depth = res;
4117 break;
4119 case 'f':
4120 fmt = optarg;
4121 break;
4122 case 'n':
4123 flags |= BDRV_O_NATIVE_AIO;
4124 break;
4125 case 'o':
4127 offset = cvtnum(optarg);
4128 if (offset < 0) {
4129 error_report("Invalid offset specified");
4130 return 1;
4132 break;
4134 break;
4135 case 'q':
4136 quiet = true;
4137 break;
4138 case 's':
4140 int64_t sval;
4142 sval = cvtnum(optarg);
4143 if (sval < 0 || sval > INT_MAX) {
4144 error_report("Invalid buffer size specified");
4145 return 1;
4148 bufsize = sval;
4149 break;
4151 case 'S':
4153 int64_t sval;
4155 sval = cvtnum(optarg);
4156 if (sval < 0 || sval > INT_MAX) {
4157 error_report("Invalid step size specified");
4158 return 1;
4161 step = sval;
4162 break;
4164 case 't':
4165 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
4166 if (ret < 0) {
4167 error_report("Invalid cache mode");
4168 ret = -1;
4169 goto out;
4171 break;
4172 case 'w':
4173 flags |= BDRV_O_RDWR;
4174 is_write = true;
4175 break;
4176 case 'U':
4177 force_share = true;
4178 break;
4179 case OPTION_PATTERN:
4181 unsigned long res;
4183 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
4184 error_report("Invalid pattern byte specified");
4185 return 1;
4187 pattern = res;
4188 break;
4190 case OPTION_FLUSH_INTERVAL:
4192 unsigned long res;
4194 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4195 error_report("Invalid flush interval specified");
4196 return 1;
4198 flush_interval = res;
4199 break;
4201 case OPTION_NO_DRAIN:
4202 drain_on_flush = false;
4203 break;
4204 case OPTION_IMAGE_OPTS:
4205 image_opts = true;
4206 break;
4210 if (optind != argc - 1) {
4211 error_exit("Expecting one image file name");
4213 filename = argv[argc - 1];
4215 if (!is_write && flush_interval) {
4216 error_report("--flush-interval is only available in write tests");
4217 ret = -1;
4218 goto out;
4220 if (flush_interval && flush_interval < depth) {
4221 error_report("Flush interval can't be smaller than depth");
4222 ret = -1;
4223 goto out;
4226 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4227 force_share);
4228 if (!blk) {
4229 ret = -1;
4230 goto out;
4233 image_size = blk_getlength(blk);
4234 if (image_size < 0) {
4235 ret = image_size;
4236 goto out;
4239 data = (BenchData) {
4240 .blk = blk,
4241 .image_size = image_size,
4242 .bufsize = bufsize,
4243 .step = step ?: bufsize,
4244 .nrreq = depth,
4245 .n = count,
4246 .offset = offset,
4247 .write = is_write,
4248 .flush_interval = flush_interval,
4249 .drain_on_flush = drain_on_flush,
4251 printf("Sending %d %s requests, %d bytes each, %d in parallel "
4252 "(starting at offset %" PRId64 ", step size %d)\n",
4253 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
4254 data.offset, data.step);
4255 if (flush_interval) {
4256 printf("Sending flush every %d requests\n", flush_interval);
4259 buf_size = data.nrreq * data.bufsize;
4260 data.buf = blk_blockalign(blk, buf_size);
4261 memset(data.buf, pattern, data.nrreq * data.bufsize);
4263 blk_register_buf(blk, data.buf, buf_size);
4265 data.qiov = g_new(QEMUIOVector, data.nrreq);
4266 for (i = 0; i < data.nrreq; i++) {
4267 qemu_iovec_init(&data.qiov[i], 1);
4268 qemu_iovec_add(&data.qiov[i],
4269 data.buf + i * data.bufsize, data.bufsize);
4272 gettimeofday(&t1, NULL);
4273 bench_cb(&data, 0);
4275 while (data.n > 0) {
4276 main_loop_wait(false);
4278 gettimeofday(&t2, NULL);
4280 printf("Run completed in %3.3f seconds.\n",
4281 (t2.tv_sec - t1.tv_sec)
4282 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
4284 out:
4285 if (data.buf) {
4286 blk_unregister_buf(blk, data.buf);
4288 qemu_vfree(data.buf);
4289 blk_unref(blk);
4291 if (ret) {
4292 return 1;
4294 return 0;
4297 #define C_BS 01
4298 #define C_COUNT 02
4299 #define C_IF 04
4300 #define C_OF 010
4301 #define C_SKIP 020
4303 struct DdInfo {
4304 unsigned int flags;
4305 int64_t count;
4308 struct DdIo {
4309 int bsz; /* Block size */
4310 char *filename;
4311 uint8_t *buf;
4312 int64_t offset;
4315 struct DdOpts {
4316 const char *name;
4317 int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
4318 unsigned int flag;
4321 static int img_dd_bs(const char *arg,
4322 struct DdIo *in, struct DdIo *out,
4323 struct DdInfo *dd)
4325 int64_t res;
4327 res = cvtnum(arg);
4329 if (res <= 0 || res > INT_MAX) {
4330 error_report("invalid number: '%s'", arg);
4331 return 1;
4333 in->bsz = out->bsz = res;
4335 return 0;
4338 static int img_dd_count(const char *arg,
4339 struct DdIo *in, struct DdIo *out,
4340 struct DdInfo *dd)
4342 dd->count = cvtnum(arg);
4344 if (dd->count < 0) {
4345 error_report("invalid number: '%s'", arg);
4346 return 1;
4349 return 0;
4352 static int img_dd_if(const char *arg,
4353 struct DdIo *in, struct DdIo *out,
4354 struct DdInfo *dd)
4356 in->filename = g_strdup(arg);
4358 return 0;
4361 static int img_dd_of(const char *arg,
4362 struct DdIo *in, struct DdIo *out,
4363 struct DdInfo *dd)
4365 out->filename = g_strdup(arg);
4367 return 0;
4370 static int img_dd_skip(const char *arg,
4371 struct DdIo *in, struct DdIo *out,
4372 struct DdInfo *dd)
4374 in->offset = cvtnum(arg);
4376 if (in->offset < 0) {
4377 error_report("invalid number: '%s'", arg);
4378 return 1;
4381 return 0;
4384 static int img_dd(int argc, char **argv)
4386 int ret = 0;
4387 char *arg = NULL;
4388 char *tmp;
4389 BlockDriver *drv = NULL, *proto_drv = NULL;
4390 BlockBackend *blk1 = NULL, *blk2 = NULL;
4391 QemuOpts *opts = NULL;
4392 QemuOptsList *create_opts = NULL;
4393 Error *local_err = NULL;
4394 bool image_opts = false;
4395 int c, i;
4396 const char *out_fmt = "raw";
4397 const char *fmt = NULL;
4398 int64_t size = 0;
4399 int64_t block_count = 0, out_pos, in_pos;
4400 bool force_share = false;
4401 struct DdInfo dd = {
4402 .flags = 0,
4403 .count = 0,
4405 struct DdIo in = {
4406 .bsz = 512, /* Block size is by default 512 bytes */
4407 .filename = NULL,
4408 .buf = NULL,
4409 .offset = 0
4411 struct DdIo out = {
4412 .bsz = 512,
4413 .filename = NULL,
4414 .buf = NULL,
4415 .offset = 0
4418 const struct DdOpts options[] = {
4419 { "bs", img_dd_bs, C_BS },
4420 { "count", img_dd_count, C_COUNT },
4421 { "if", img_dd_if, C_IF },
4422 { "of", img_dd_of, C_OF },
4423 { "skip", img_dd_skip, C_SKIP },
4424 { NULL, NULL, 0 }
4426 const struct option long_options[] = {
4427 { "help", no_argument, 0, 'h'},
4428 { "object", required_argument, 0, OPTION_OBJECT},
4429 { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4430 { "force-share", no_argument, 0, 'U'},
4431 { 0, 0, 0, 0 }
4434 while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) {
4435 if (c == EOF) {
4436 break;
4438 switch (c) {
4439 case 'O':
4440 out_fmt = optarg;
4441 break;
4442 case 'f':
4443 fmt = optarg;
4444 break;
4445 case ':':
4446 missing_argument(argv[optind - 1]);
4447 break;
4448 case '?':
4449 unrecognized_option(argv[optind - 1]);
4450 break;
4451 case 'h':
4452 help();
4453 break;
4454 case 'U':
4455 force_share = true;
4456 break;
4457 case OPTION_OBJECT:
4458 if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) {
4459 ret = -1;
4460 goto out;
4462 break;
4463 case OPTION_IMAGE_OPTS:
4464 image_opts = true;
4465 break;
4469 for (i = optind; i < argc; i++) {
4470 int j;
4471 arg = g_strdup(argv[i]);
4473 tmp = strchr(arg, '=');
4474 if (tmp == NULL) {
4475 error_report("unrecognized operand %s", arg);
4476 ret = -1;
4477 goto out;
4480 *tmp++ = '\0';
4482 for (j = 0; options[j].name != NULL; j++) {
4483 if (!strcmp(arg, options[j].name)) {
4484 break;
4487 if (options[j].name == NULL) {
4488 error_report("unrecognized operand %s", arg);
4489 ret = -1;
4490 goto out;
4493 if (options[j].f(tmp, &in, &out, &dd) != 0) {
4494 ret = -1;
4495 goto out;
4497 dd.flags |= options[j].flag;
4498 g_free(arg);
4499 arg = NULL;
4502 if (!(dd.flags & C_IF && dd.flags & C_OF)) {
4503 error_report("Must specify both input and output files");
4504 ret = -1;
4505 goto out;
4508 if (qemu_opts_foreach(&qemu_object_opts,
4509 user_creatable_add_opts_foreach,
4510 NULL, NULL)) {
4511 ret = -1;
4512 goto out;
4515 blk1 = img_open(image_opts, in.filename, fmt, 0, false, false,
4516 force_share);
4518 if (!blk1) {
4519 ret = -1;
4520 goto out;
4523 drv = bdrv_find_format(out_fmt);
4524 if (!drv) {
4525 error_report("Unknown file format");
4526 ret = -1;
4527 goto out;
4529 proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
4531 if (!proto_drv) {
4532 error_report_err(local_err);
4533 ret = -1;
4534 goto out;
4536 if (!drv->create_opts) {
4537 error_report("Format driver '%s' does not support image creation",
4538 drv->format_name);
4539 ret = -1;
4540 goto out;
4542 if (!proto_drv->create_opts) {
4543 error_report("Protocol driver '%s' does not support image creation",
4544 proto_drv->format_name);
4545 ret = -1;
4546 goto out;
4548 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4549 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4551 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4553 size = blk_getlength(blk1);
4554 if (size < 0) {
4555 error_report("Failed to get size for '%s'", in.filename);
4556 ret = -1;
4557 goto out;
4560 if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz &&
4561 dd.count * in.bsz < size) {
4562 size = dd.count * in.bsz;
4565 /* Overflow means the specified offset is beyond input image's size */
4566 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4567 size < in.bsz * in.offset)) {
4568 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort);
4569 } else {
4570 qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
4571 size - in.bsz * in.offset, &error_abort);
4574 ret = bdrv_create(drv, out.filename, opts, &local_err);
4575 if (ret < 0) {
4576 error_reportf_err(local_err,
4577 "%s: error while creating output image: ",
4578 out.filename);
4579 ret = -1;
4580 goto out;
4583 /* TODO, we can't honour --image-opts for the target,
4584 * since it needs to be given in a format compatible
4585 * with the bdrv_create() call above which does not
4586 * support image-opts style.
4588 blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR,
4589 false, false, false);
4591 if (!blk2) {
4592 ret = -1;
4593 goto out;
4596 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4597 size < in.offset * in.bsz)) {
4598 /* We give a warning if the skip option is bigger than the input
4599 * size and create an empty output disk image (i.e. like dd(1)).
4601 error_report("%s: cannot skip to specified offset", in.filename);
4602 in_pos = size;
4603 } else {
4604 in_pos = in.offset * in.bsz;
4607 in.buf = g_new(uint8_t, in.bsz);
4609 for (out_pos = 0; in_pos < size; block_count++) {
4610 int in_ret, out_ret;
4612 if (in_pos + in.bsz > size) {
4613 in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
4614 } else {
4615 in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
4617 if (in_ret < 0) {
4618 error_report("error while reading from input image file: %s",
4619 strerror(-in_ret));
4620 ret = -1;
4621 goto out;
4623 in_pos += in_ret;
4625 out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
4627 if (out_ret < 0) {
4628 error_report("error while writing to output image file: %s",
4629 strerror(-out_ret));
4630 ret = -1;
4631 goto out;
4633 out_pos += out_ret;
4636 out:
4637 g_free(arg);
4638 qemu_opts_del(opts);
4639 qemu_opts_free(create_opts);
4640 blk_unref(blk1);
4641 blk_unref(blk2);
4642 g_free(in.filename);
4643 g_free(out.filename);
4644 g_free(in.buf);
4645 g_free(out.buf);
4647 if (ret) {
4648 return 1;
4650 return 0;
4653 static void dump_json_block_measure_info(BlockMeasureInfo *info)
4655 QString *str;
4656 QObject *obj;
4657 Visitor *v = qobject_output_visitor_new(&obj);
4659 visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort);
4660 visit_complete(v, &obj);
4661 str = qobject_to_json_pretty(obj);
4662 assert(str != NULL);
4663 printf("%s\n", qstring_get_str(str));
4664 qobject_unref(obj);
4665 visit_free(v);
4666 qobject_unref(str);
4669 static int img_measure(int argc, char **argv)
4671 static const struct option long_options[] = {
4672 {"help", no_argument, 0, 'h'},
4673 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4674 {"object", required_argument, 0, OPTION_OBJECT},
4675 {"output", required_argument, 0, OPTION_OUTPUT},
4676 {"size", required_argument, 0, OPTION_SIZE},
4677 {"force-share", no_argument, 0, 'U'},
4678 {0, 0, 0, 0}
4680 OutputFormat output_format = OFORMAT_HUMAN;
4681 BlockBackend *in_blk = NULL;
4682 BlockDriver *drv;
4683 const char *filename = NULL;
4684 const char *fmt = NULL;
4685 const char *out_fmt = "raw";
4686 char *options = NULL;
4687 char *snapshot_name = NULL;
4688 bool force_share = false;
4689 QemuOpts *opts = NULL;
4690 QemuOpts *object_opts = NULL;
4691 QemuOpts *sn_opts = NULL;
4692 QemuOptsList *create_opts = NULL;
4693 bool image_opts = false;
4694 uint64_t img_size = UINT64_MAX;
4695 BlockMeasureInfo *info = NULL;
4696 Error *local_err = NULL;
4697 int ret = 1;
4698 int c;
4700 while ((c = getopt_long(argc, argv, "hf:O:o:l:U",
4701 long_options, NULL)) != -1) {
4702 switch (c) {
4703 case '?':
4704 case 'h':
4705 help();
4706 break;
4707 case 'f':
4708 fmt = optarg;
4709 break;
4710 case 'O':
4711 out_fmt = optarg;
4712 break;
4713 case 'o':
4714 if (!is_valid_option_list(optarg)) {
4715 error_report("Invalid option list: %s", optarg);
4716 goto out;
4718 if (!options) {
4719 options = g_strdup(optarg);
4720 } else {
4721 char *old_options = options;
4722 options = g_strdup_printf("%s,%s", options, optarg);
4723 g_free(old_options);
4725 break;
4726 case 'l':
4727 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
4728 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
4729 optarg, false);
4730 if (!sn_opts) {
4731 error_report("Failed in parsing snapshot param '%s'",
4732 optarg);
4733 goto out;
4735 } else {
4736 snapshot_name = optarg;
4738 break;
4739 case 'U':
4740 force_share = true;
4741 break;
4742 case OPTION_OBJECT:
4743 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
4744 optarg, true);
4745 if (!object_opts) {
4746 goto out;
4748 break;
4749 case OPTION_IMAGE_OPTS:
4750 image_opts = true;
4751 break;
4752 case OPTION_OUTPUT:
4753 if (!strcmp(optarg, "json")) {
4754 output_format = OFORMAT_JSON;
4755 } else if (!strcmp(optarg, "human")) {
4756 output_format = OFORMAT_HUMAN;
4757 } else {
4758 error_report("--output must be used with human or json "
4759 "as argument.");
4760 goto out;
4762 break;
4763 case OPTION_SIZE:
4765 int64_t sval;
4767 sval = cvtnum(optarg);
4768 if (sval < 0) {
4769 if (sval == -ERANGE) {
4770 error_report("Image size must be less than 8 EiB!");
4771 } else {
4772 error_report("Invalid image size specified! You may use "
4773 "k, M, G, T, P or E suffixes for ");
4774 error_report("kilobytes, megabytes, gigabytes, terabytes, "
4775 "petabytes and exabytes.");
4777 goto out;
4779 img_size = (uint64_t)sval;
4781 break;
4785 if (qemu_opts_foreach(&qemu_object_opts,
4786 user_creatable_add_opts_foreach,
4787 NULL, NULL)) {
4788 goto out;
4791 if (argc - optind > 1) {
4792 error_report("At most one filename argument is allowed.");
4793 goto out;
4794 } else if (argc - optind == 1) {
4795 filename = argv[optind];
4798 if (!filename &&
4799 (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
4800 error_report("--object, --image-opts, -f, and -l "
4801 "require a filename argument.");
4802 goto out;
4804 if (filename && img_size != UINT64_MAX) {
4805 error_report("--size N cannot be used together with a filename.");
4806 goto out;
4808 if (!filename && img_size == UINT64_MAX) {
4809 error_report("Either --size N or one filename must be specified.");
4810 goto out;
4813 if (filename) {
4814 in_blk = img_open(image_opts, filename, fmt, 0,
4815 false, false, force_share);
4816 if (!in_blk) {
4817 goto out;
4820 if (sn_opts) {
4821 bdrv_snapshot_load_tmp(blk_bs(in_blk),
4822 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
4823 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
4824 &local_err);
4825 } else if (snapshot_name != NULL) {
4826 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk),
4827 snapshot_name, &local_err);
4829 if (local_err) {
4830 error_reportf_err(local_err, "Failed to load snapshot: ");
4831 goto out;
4835 drv = bdrv_find_format(out_fmt);
4836 if (!drv) {
4837 error_report("Unknown file format '%s'", out_fmt);
4838 goto out;
4840 if (!drv->create_opts) {
4841 error_report("Format driver '%s' does not support image creation",
4842 drv->format_name);
4843 goto out;
4846 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4847 create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
4848 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4849 if (options) {
4850 qemu_opts_do_parse(opts, options, NULL, &local_err);
4851 if (local_err) {
4852 error_report_err(local_err);
4853 error_report("Invalid options for file format '%s'", out_fmt);
4854 goto out;
4857 if (img_size != UINT64_MAX) {
4858 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4861 info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err);
4862 if (local_err) {
4863 error_report_err(local_err);
4864 goto out;
4867 if (output_format == OFORMAT_HUMAN) {
4868 printf("required size: %" PRIu64 "\n", info->required);
4869 printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated);
4870 } else {
4871 dump_json_block_measure_info(info);
4874 ret = 0;
4876 out:
4877 qapi_free_BlockMeasureInfo(info);
4878 qemu_opts_del(object_opts);
4879 qemu_opts_del(opts);
4880 qemu_opts_del(sn_opts);
4881 qemu_opts_free(create_opts);
4882 g_free(options);
4883 blk_unref(in_blk);
4884 return ret;
4887 static const img_cmd_t img_cmds[] = {
4888 #define DEF(option, callback, arg_string) \
4889 { option, callback },
4890 #include "qemu-img-cmds.h"
4891 #undef DEF
4892 { NULL, NULL, },
4895 int main(int argc, char **argv)
4897 const img_cmd_t *cmd;
4898 const char *cmdname;
4899 Error *local_error = NULL;
4900 char *trace_file = NULL;
4901 int c;
4902 static const struct option long_options[] = {
4903 {"help", no_argument, 0, 'h'},
4904 {"version", no_argument, 0, 'V'},
4905 {"trace", required_argument, NULL, 'T'},
4906 {0, 0, 0, 0}
4909 #ifdef CONFIG_POSIX
4910 signal(SIGPIPE, SIG_IGN);
4911 #endif
4913 module_call_init(MODULE_INIT_TRACE);
4914 error_set_progname(argv[0]);
4915 qemu_init_exec_dir(argv[0]);
4917 if (qemu_init_main_loop(&local_error)) {
4918 error_report_err(local_error);
4919 exit(EXIT_FAILURE);
4922 qcrypto_init(&error_fatal);
4924 module_call_init(MODULE_INIT_QOM);
4925 bdrv_init();
4926 if (argc < 2) {
4927 error_exit("Not enough arguments");
4930 qemu_add_opts(&qemu_object_opts);
4931 qemu_add_opts(&qemu_source_opts);
4932 qemu_add_opts(&qemu_trace_opts);
4934 while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) {
4935 switch (c) {
4936 case ':':
4937 missing_argument(argv[optind - 1]);
4938 return 0;
4939 case '?':
4940 unrecognized_option(argv[optind - 1]);
4941 return 0;
4942 case 'h':
4943 help();
4944 return 0;
4945 case 'V':
4946 printf(QEMU_IMG_VERSION);
4947 return 0;
4948 case 'T':
4949 g_free(trace_file);
4950 trace_file = trace_opt_parse(optarg);
4951 break;
4955 cmdname = argv[optind];
4957 /* reset getopt_long scanning */
4958 argc -= optind;
4959 if (argc < 1) {
4960 return 0;
4962 argv += optind;
4963 optind = 0;
4965 if (!trace_init_backends()) {
4966 exit(1);
4968 trace_init_file(trace_file);
4969 qemu_set_log(LOG_TRACE);
4971 /* find the command */
4972 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
4973 if (!strcmp(cmdname, cmd->name)) {
4974 return cmd->handler(argc, argv);
4978 /* not found */
4979 error_exit("Command not found: %s", cmdname);