hw/arm/bcm2836: Mark the bcm2836 / bcm2837 devices with user_creatable = false
[qemu.git] / qemu-img.c
blob4a7ce43dc9a74babb4ef58c98e91e3914b61554c
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;
348 static BlockBackend *img_open_new_file(const char *filename,
349 QemuOpts *create_opts,
350 const char *fmt, int flags,
351 bool writethrough, bool quiet,
352 bool force_share)
354 QDict *options = NULL;
356 options = qdict_new();
357 qemu_opt_foreach(create_opts, img_add_key_secrets, options, &error_abort);
359 return img_open_file(filename, options, fmt, flags, writethrough, quiet,
360 force_share);
364 static BlockBackend *img_open(bool image_opts,
365 const char *filename,
366 const char *fmt, int flags, bool writethrough,
367 bool quiet, bool force_share)
369 BlockBackend *blk;
370 if (image_opts) {
371 QemuOpts *opts;
372 if (fmt) {
373 error_report("--image-opts and --format are mutually exclusive");
374 return NULL;
376 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
377 filename, true);
378 if (!opts) {
379 return NULL;
381 blk = img_open_opts(filename, opts, flags, writethrough, quiet,
382 force_share);
383 } else {
384 blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
385 force_share);
387 return blk;
391 static int add_old_style_options(const char *fmt, QemuOpts *opts,
392 const char *base_filename,
393 const char *base_fmt)
395 Error *err = NULL;
397 if (base_filename) {
398 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
399 if (err) {
400 error_report("Backing file not supported for file format '%s'",
401 fmt);
402 error_free(err);
403 return -1;
406 if (base_fmt) {
407 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
408 if (err) {
409 error_report("Backing file format not supported for file "
410 "format '%s'", fmt);
411 error_free(err);
412 return -1;
415 return 0;
418 static int64_t cvtnum(const char *s)
420 int err;
421 uint64_t value;
423 err = qemu_strtosz(s, NULL, &value);
424 if (err < 0) {
425 return err;
427 if (value > INT64_MAX) {
428 return -ERANGE;
430 return value;
433 static int img_create(int argc, char **argv)
435 int c;
436 uint64_t img_size = -1;
437 const char *fmt = "raw";
438 const char *base_fmt = NULL;
439 const char *filename;
440 const char *base_filename = NULL;
441 char *options = NULL;
442 Error *local_err = NULL;
443 bool quiet = false;
444 int flags = 0;
446 for(;;) {
447 static const struct option long_options[] = {
448 {"help", no_argument, 0, 'h'},
449 {"object", required_argument, 0, OPTION_OBJECT},
450 {0, 0, 0, 0}
452 c = getopt_long(argc, argv, ":F:b:f:ho:qu",
453 long_options, NULL);
454 if (c == -1) {
455 break;
457 switch(c) {
458 case ':':
459 missing_argument(argv[optind - 1]);
460 break;
461 case '?':
462 unrecognized_option(argv[optind - 1]);
463 break;
464 case 'h':
465 help();
466 break;
467 case 'F':
468 base_fmt = optarg;
469 break;
470 case 'b':
471 base_filename = optarg;
472 break;
473 case 'f':
474 fmt = optarg;
475 break;
476 case 'o':
477 if (!is_valid_option_list(optarg)) {
478 error_report("Invalid option list: %s", optarg);
479 goto fail;
481 if (!options) {
482 options = g_strdup(optarg);
483 } else {
484 char *old_options = options;
485 options = g_strdup_printf("%s,%s", options, optarg);
486 g_free(old_options);
488 break;
489 case 'q':
490 quiet = true;
491 break;
492 case 'u':
493 flags |= BDRV_O_NO_BACKING;
494 break;
495 case OPTION_OBJECT: {
496 QemuOpts *opts;
497 opts = qemu_opts_parse_noisily(&qemu_object_opts,
498 optarg, true);
499 if (!opts) {
500 goto fail;
502 } break;
506 /* Get the filename */
507 filename = (optind < argc) ? argv[optind] : NULL;
508 if (options && has_help_option(options)) {
509 g_free(options);
510 return print_block_option_help(filename, fmt);
513 if (optind >= argc) {
514 error_exit("Expecting image file name");
516 optind++;
518 if (qemu_opts_foreach(&qemu_object_opts,
519 user_creatable_add_opts_foreach,
520 NULL, NULL)) {
521 goto fail;
524 /* Get image size, if specified */
525 if (optind < argc) {
526 int64_t sval;
528 sval = cvtnum(argv[optind++]);
529 if (sval < 0) {
530 if (sval == -ERANGE) {
531 error_report("Image size must be less than 8 EiB!");
532 } else {
533 error_report("Invalid image size specified! You may use k, M, "
534 "G, T, P or E suffixes for ");
535 error_report("kilobytes, megabytes, gigabytes, terabytes, "
536 "petabytes and exabytes.");
538 goto fail;
540 img_size = (uint64_t)sval;
542 if (optind != argc) {
543 error_exit("Unexpected argument: %s", argv[optind]);
546 bdrv_img_create(filename, fmt, base_filename, base_fmt,
547 options, img_size, flags, quiet, &local_err);
548 if (local_err) {
549 error_reportf_err(local_err, "%s: ", filename);
550 goto fail;
553 g_free(options);
554 return 0;
556 fail:
557 g_free(options);
558 return 1;
561 static void dump_json_image_check(ImageCheck *check, bool quiet)
563 QString *str;
564 QObject *obj;
565 Visitor *v = qobject_output_visitor_new(&obj);
567 visit_type_ImageCheck(v, NULL, &check, &error_abort);
568 visit_complete(v, &obj);
569 str = qobject_to_json_pretty(obj);
570 assert(str != NULL);
571 qprintf(quiet, "%s\n", qstring_get_str(str));
572 qobject_unref(obj);
573 visit_free(v);
574 qobject_unref(str);
577 static void dump_human_image_check(ImageCheck *check, bool quiet)
579 if (!(check->corruptions || check->leaks || check->check_errors)) {
580 qprintf(quiet, "No errors were found on the image.\n");
581 } else {
582 if (check->corruptions) {
583 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
584 "Data may be corrupted, or further writes to the image "
585 "may corrupt it.\n",
586 check->corruptions);
589 if (check->leaks) {
590 qprintf(quiet,
591 "\n%" PRId64 " leaked clusters were found on the image.\n"
592 "This means waste of disk space, but no harm to data.\n",
593 check->leaks);
596 if (check->check_errors) {
597 qprintf(quiet,
598 "\n%" PRId64
599 " internal errors have occurred during the check.\n",
600 check->check_errors);
604 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
605 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
606 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
607 check->allocated_clusters, check->total_clusters,
608 check->allocated_clusters * 100.0 / check->total_clusters,
609 check->fragmented_clusters * 100.0 / check->allocated_clusters,
610 check->compressed_clusters * 100.0 /
611 check->allocated_clusters);
614 if (check->image_end_offset) {
615 qprintf(quiet,
616 "Image end offset: %" PRId64 "\n", check->image_end_offset);
620 static int collect_image_check(BlockDriverState *bs,
621 ImageCheck *check,
622 const char *filename,
623 const char *fmt,
624 int fix)
626 int ret;
627 BdrvCheckResult result;
629 ret = bdrv_check(bs, &result, fix);
630 if (ret < 0) {
631 return ret;
634 check->filename = g_strdup(filename);
635 check->format = g_strdup(bdrv_get_format_name(bs));
636 check->check_errors = result.check_errors;
637 check->corruptions = result.corruptions;
638 check->has_corruptions = result.corruptions != 0;
639 check->leaks = result.leaks;
640 check->has_leaks = result.leaks != 0;
641 check->corruptions_fixed = result.corruptions_fixed;
642 check->has_corruptions_fixed = result.corruptions != 0;
643 check->leaks_fixed = result.leaks_fixed;
644 check->has_leaks_fixed = result.leaks != 0;
645 check->image_end_offset = result.image_end_offset;
646 check->has_image_end_offset = result.image_end_offset != 0;
647 check->total_clusters = result.bfi.total_clusters;
648 check->has_total_clusters = result.bfi.total_clusters != 0;
649 check->allocated_clusters = result.bfi.allocated_clusters;
650 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
651 check->fragmented_clusters = result.bfi.fragmented_clusters;
652 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
653 check->compressed_clusters = result.bfi.compressed_clusters;
654 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
656 return 0;
660 * Checks an image for consistency. Exit codes:
662 * 0 - Check completed, image is good
663 * 1 - Check not completed because of internal errors
664 * 2 - Check completed, image is corrupted
665 * 3 - Check completed, image has leaked clusters, but is good otherwise
666 * 63 - Checks are not supported by the image format
668 static int img_check(int argc, char **argv)
670 int c, ret;
671 OutputFormat output_format = OFORMAT_HUMAN;
672 const char *filename, *fmt, *output, *cache;
673 BlockBackend *blk;
674 BlockDriverState *bs;
675 int fix = 0;
676 int flags = BDRV_O_CHECK;
677 bool writethrough;
678 ImageCheck *check;
679 bool quiet = false;
680 bool image_opts = false;
681 bool force_share = false;
683 fmt = NULL;
684 output = NULL;
685 cache = BDRV_DEFAULT_CACHE;
687 for(;;) {
688 int option_index = 0;
689 static const struct option long_options[] = {
690 {"help", no_argument, 0, 'h'},
691 {"format", required_argument, 0, 'f'},
692 {"repair", required_argument, 0, 'r'},
693 {"output", required_argument, 0, OPTION_OUTPUT},
694 {"object", required_argument, 0, OPTION_OBJECT},
695 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
696 {"force-share", no_argument, 0, 'U'},
697 {0, 0, 0, 0}
699 c = getopt_long(argc, argv, ":hf:r:T:qU",
700 long_options, &option_index);
701 if (c == -1) {
702 break;
704 switch(c) {
705 case ':':
706 missing_argument(argv[optind - 1]);
707 break;
708 case '?':
709 unrecognized_option(argv[optind - 1]);
710 break;
711 case 'h':
712 help();
713 break;
714 case 'f':
715 fmt = optarg;
716 break;
717 case 'r':
718 flags |= BDRV_O_RDWR;
720 if (!strcmp(optarg, "leaks")) {
721 fix = BDRV_FIX_LEAKS;
722 } else if (!strcmp(optarg, "all")) {
723 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
724 } else {
725 error_exit("Unknown option value for -r "
726 "(expecting 'leaks' or 'all'): %s", optarg);
728 break;
729 case OPTION_OUTPUT:
730 output = optarg;
731 break;
732 case 'T':
733 cache = optarg;
734 break;
735 case 'q':
736 quiet = true;
737 break;
738 case 'U':
739 force_share = true;
740 break;
741 case OPTION_OBJECT: {
742 QemuOpts *opts;
743 opts = qemu_opts_parse_noisily(&qemu_object_opts,
744 optarg, true);
745 if (!opts) {
746 return 1;
748 } break;
749 case OPTION_IMAGE_OPTS:
750 image_opts = true;
751 break;
754 if (optind != argc - 1) {
755 error_exit("Expecting one image file name");
757 filename = argv[optind++];
759 if (output && !strcmp(output, "json")) {
760 output_format = OFORMAT_JSON;
761 } else if (output && !strcmp(output, "human")) {
762 output_format = OFORMAT_HUMAN;
763 } else if (output) {
764 error_report("--output must be used with human or json as argument.");
765 return 1;
768 if (qemu_opts_foreach(&qemu_object_opts,
769 user_creatable_add_opts_foreach,
770 NULL, NULL)) {
771 return 1;
774 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
775 if (ret < 0) {
776 error_report("Invalid source cache option: %s", cache);
777 return 1;
780 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
781 force_share);
782 if (!blk) {
783 return 1;
785 bs = blk_bs(blk);
787 check = g_new0(ImageCheck, 1);
788 ret = collect_image_check(bs, check, filename, fmt, fix);
790 if (ret == -ENOTSUP) {
791 error_report("This image format does not support checks");
792 ret = 63;
793 goto fail;
796 if (check->corruptions_fixed || check->leaks_fixed) {
797 int corruptions_fixed, leaks_fixed;
799 leaks_fixed = check->leaks_fixed;
800 corruptions_fixed = check->corruptions_fixed;
802 if (output_format == OFORMAT_HUMAN) {
803 qprintf(quiet,
804 "The following inconsistencies were found and repaired:\n\n"
805 " %" PRId64 " leaked clusters\n"
806 " %" PRId64 " corruptions\n\n"
807 "Double checking the fixed image now...\n",
808 check->leaks_fixed,
809 check->corruptions_fixed);
812 ret = collect_image_check(bs, check, filename, fmt, 0);
814 check->leaks_fixed = leaks_fixed;
815 check->corruptions_fixed = corruptions_fixed;
818 if (!ret) {
819 switch (output_format) {
820 case OFORMAT_HUMAN:
821 dump_human_image_check(check, quiet);
822 break;
823 case OFORMAT_JSON:
824 dump_json_image_check(check, quiet);
825 break;
829 if (ret || check->check_errors) {
830 if (ret) {
831 error_report("Check failed: %s", strerror(-ret));
832 } else {
833 error_report("Check failed");
835 ret = 1;
836 goto fail;
839 if (check->corruptions) {
840 ret = 2;
841 } else if (check->leaks) {
842 ret = 3;
843 } else {
844 ret = 0;
847 fail:
848 qapi_free_ImageCheck(check);
849 blk_unref(blk);
850 return ret;
853 typedef struct CommonBlockJobCBInfo {
854 BlockDriverState *bs;
855 Error **errp;
856 } CommonBlockJobCBInfo;
858 static void common_block_job_cb(void *opaque, int ret)
860 CommonBlockJobCBInfo *cbi = opaque;
862 if (ret < 0) {
863 error_setg_errno(cbi->errp, -ret, "Block job failed");
867 static void run_block_job(BlockJob *job, Error **errp)
869 AioContext *aio_context = blk_get_aio_context(job->blk);
870 int ret = 0;
872 aio_context_acquire(aio_context);
873 job_ref(&job->job);
874 do {
875 float progress = 0.0f;
876 aio_poll(aio_context, true);
877 if (job->job.progress_total) {
878 progress = (float)job->job.progress_current /
879 job->job.progress_total * 100.f;
881 qemu_progress_print(progress, 0);
882 } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
884 if (!job_is_completed(&job->job)) {
885 ret = job_complete_sync(&job->job, errp);
886 } else {
887 ret = job->job.ret;
889 job_unref(&job->job);
890 aio_context_release(aio_context);
892 /* publish completion progress only when success */
893 if (!ret) {
894 qemu_progress_print(100.f, 0);
898 static int img_commit(int argc, char **argv)
900 int c, ret, flags;
901 const char *filename, *fmt, *cache, *base;
902 BlockBackend *blk;
903 BlockDriverState *bs, *base_bs;
904 BlockJob *job;
905 bool progress = false, quiet = false, drop = false;
906 bool writethrough;
907 Error *local_err = NULL;
908 CommonBlockJobCBInfo cbi;
909 bool image_opts = false;
910 AioContext *aio_context;
912 fmt = NULL;
913 cache = BDRV_DEFAULT_CACHE;
914 base = NULL;
915 for(;;) {
916 static const struct option long_options[] = {
917 {"help", no_argument, 0, 'h'},
918 {"object", required_argument, 0, OPTION_OBJECT},
919 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
920 {0, 0, 0, 0}
922 c = getopt_long(argc, argv, ":f:ht:b:dpq",
923 long_options, NULL);
924 if (c == -1) {
925 break;
927 switch(c) {
928 case ':':
929 missing_argument(argv[optind - 1]);
930 break;
931 case '?':
932 unrecognized_option(argv[optind - 1]);
933 break;
934 case 'h':
935 help();
936 break;
937 case 'f':
938 fmt = optarg;
939 break;
940 case 't':
941 cache = optarg;
942 break;
943 case 'b':
944 base = optarg;
945 /* -b implies -d */
946 drop = true;
947 break;
948 case 'd':
949 drop = true;
950 break;
951 case 'p':
952 progress = true;
953 break;
954 case 'q':
955 quiet = true;
956 break;
957 case OPTION_OBJECT: {
958 QemuOpts *opts;
959 opts = qemu_opts_parse_noisily(&qemu_object_opts,
960 optarg, true);
961 if (!opts) {
962 return 1;
964 } break;
965 case OPTION_IMAGE_OPTS:
966 image_opts = true;
967 break;
971 /* Progress is not shown in Quiet mode */
972 if (quiet) {
973 progress = false;
976 if (optind != argc - 1) {
977 error_exit("Expecting one image file name");
979 filename = argv[optind++];
981 if (qemu_opts_foreach(&qemu_object_opts,
982 user_creatable_add_opts_foreach,
983 NULL, NULL)) {
984 return 1;
987 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
988 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
989 if (ret < 0) {
990 error_report("Invalid cache option: %s", cache);
991 return 1;
994 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
995 false);
996 if (!blk) {
997 return 1;
999 bs = blk_bs(blk);
1001 qemu_progress_init(progress, 1.f);
1002 qemu_progress_print(0.f, 100);
1004 if (base) {
1005 base_bs = bdrv_find_backing_image(bs, base);
1006 if (!base_bs) {
1007 error_setg(&local_err,
1008 "Did not find '%s' in the backing chain of '%s'",
1009 base, filename);
1010 goto done;
1012 } else {
1013 /* This is different from QMP, which by default uses the deepest file in
1014 * the backing chain (i.e., the very base); however, the traditional
1015 * behavior of qemu-img commit is using the immediate backing file. */
1016 base_bs = backing_bs(bs);
1017 if (!base_bs) {
1018 error_setg(&local_err, "Image does not have a backing file");
1019 goto done;
1023 cbi = (CommonBlockJobCBInfo){
1024 .errp = &local_err,
1025 .bs = bs,
1028 aio_context = bdrv_get_aio_context(bs);
1029 aio_context_acquire(aio_context);
1030 commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,
1031 BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1032 &cbi, false, &local_err);
1033 aio_context_release(aio_context);
1034 if (local_err) {
1035 goto done;
1038 /* When the block job completes, the BlockBackend reference will point to
1039 * the old backing file. In order to avoid that the top image is already
1040 * deleted, so we can still empty it afterwards, increment the reference
1041 * counter here preemptively. */
1042 if (!drop) {
1043 bdrv_ref(bs);
1046 job = block_job_get("commit");
1047 run_block_job(job, &local_err);
1048 if (local_err) {
1049 goto unref_backing;
1052 if (!drop && bs->drv->bdrv_make_empty) {
1053 ret = bs->drv->bdrv_make_empty(bs);
1054 if (ret) {
1055 error_setg_errno(&local_err, -ret, "Could not empty %s",
1056 filename);
1057 goto unref_backing;
1061 unref_backing:
1062 if (!drop) {
1063 bdrv_unref(bs);
1066 done:
1067 qemu_progress_end();
1069 blk_unref(blk);
1071 if (local_err) {
1072 error_report_err(local_err);
1073 return 1;
1076 qprintf(quiet, "Image committed.\n");
1077 return 0;
1081 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1082 * of the first sector boundary within buf where the sector contains a
1083 * non-zero byte. This function is robust to a buffer that is not
1084 * sector-aligned.
1086 static int64_t find_nonzero(const uint8_t *buf, int64_t n)
1088 int64_t i;
1089 int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE);
1091 for (i = 0; i < end; i += BDRV_SECTOR_SIZE) {
1092 if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) {
1093 return i;
1096 if (i < n && !buffer_is_zero(buf + i, n - end)) {
1097 return i;
1099 return -1;
1103 * Returns true iff the first sector pointed to by 'buf' contains at least
1104 * a non-NUL byte.
1106 * 'pnum' is set to the number of sectors (including and immediately following
1107 * the first one) that are known to be in the same allocated/unallocated state.
1108 * The function will try to align the end offset to alignment boundaries so
1109 * that the request will at least end aligned and consequtive requests will
1110 * also start at an aligned offset.
1112 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
1113 int64_t sector_num, int alignment)
1115 bool is_zero;
1116 int i, tail;
1118 if (n <= 0) {
1119 *pnum = 0;
1120 return 0;
1122 is_zero = buffer_is_zero(buf, 512);
1123 for(i = 1; i < n; i++) {
1124 buf += 512;
1125 if (is_zero != buffer_is_zero(buf, 512)) {
1126 break;
1130 tail = (sector_num + i) & (alignment - 1);
1131 if (tail) {
1132 if (is_zero && i <= tail) {
1133 /* treat unallocated areas which only consist
1134 * of a small tail as allocated. */
1135 is_zero = false;
1137 if (!is_zero) {
1138 /* align up end offset of allocated areas. */
1139 i += alignment - tail;
1140 i = MIN(i, n);
1141 } else {
1142 /* align down end offset of zero areas. */
1143 i -= tail;
1146 *pnum = i;
1147 return !is_zero;
1151 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1152 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1153 * breaking up write requests for only small sparse areas.
1155 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1156 int min, int64_t sector_num, int alignment)
1158 int ret;
1159 int num_checked, num_used;
1161 if (n < min) {
1162 min = n;
1165 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1166 if (!ret) {
1167 return ret;
1170 num_used = *pnum;
1171 buf += BDRV_SECTOR_SIZE * *pnum;
1172 n -= *pnum;
1173 sector_num += *pnum;
1174 num_checked = num_used;
1176 while (n > 0) {
1177 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1179 buf += BDRV_SECTOR_SIZE * *pnum;
1180 n -= *pnum;
1181 sector_num += *pnum;
1182 num_checked += *pnum;
1183 if (ret) {
1184 num_used = num_checked;
1185 } else if (*pnum >= min) {
1186 break;
1190 *pnum = num_used;
1191 return 1;
1195 * Compares two buffers sector by sector. Returns 0 if the first
1196 * sector of each buffer matches, non-zero otherwise.
1198 * pnum is set to the sector-aligned size of the buffer prefix that
1199 * has the same matching status as the first sector.
1201 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,
1202 int64_t bytes, int64_t *pnum)
1204 bool res;
1205 int64_t i = MIN(bytes, BDRV_SECTOR_SIZE);
1207 assert(bytes > 0);
1209 res = !!memcmp(buf1, buf2, i);
1210 while (i < bytes) {
1211 int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE);
1213 if (!!memcmp(buf1 + i, buf2 + i, len) != res) {
1214 break;
1216 i += len;
1219 *pnum = i;
1220 return res;
1223 #define IO_BUF_SIZE (2 * 1024 * 1024)
1226 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1228 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1229 * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1230 * failure), and 4 on error (the exit status for read errors), after emitting
1231 * an error message.
1233 * @param blk: BlockBackend for the image
1234 * @param offset: Starting offset to check
1235 * @param bytes: Number of bytes to check
1236 * @param filename: Name of disk file we are checking (logging purpose)
1237 * @param buffer: Allocated buffer for storing read data
1238 * @param quiet: Flag for quiet mode
1240 static int check_empty_sectors(BlockBackend *blk, int64_t offset,
1241 int64_t bytes, const char *filename,
1242 uint8_t *buffer, bool quiet)
1244 int ret = 0;
1245 int64_t idx;
1247 ret = blk_pread(blk, offset, buffer, bytes);
1248 if (ret < 0) {
1249 error_report("Error while reading offset %" PRId64 " of %s: %s",
1250 offset, filename, strerror(-ret));
1251 return 4;
1253 idx = find_nonzero(buffer, bytes);
1254 if (idx >= 0) {
1255 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1256 offset + idx);
1257 return 1;
1260 return 0;
1264 * Compares two images. Exit codes:
1266 * 0 - Images are identical
1267 * 1 - Images differ
1268 * >1 - Error occurred
1270 static int img_compare(int argc, char **argv)
1272 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1273 BlockBackend *blk1, *blk2;
1274 BlockDriverState *bs1, *bs2;
1275 int64_t total_size1, total_size2;
1276 uint8_t *buf1 = NULL, *buf2 = NULL;
1277 int64_t pnum1, pnum2;
1278 int allocated1, allocated2;
1279 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1280 bool progress = false, quiet = false, strict = false;
1281 int flags;
1282 bool writethrough;
1283 int64_t total_size;
1284 int64_t offset = 0;
1285 int64_t chunk;
1286 int c;
1287 uint64_t progress_base;
1288 bool image_opts = false;
1289 bool force_share = false;
1291 cache = BDRV_DEFAULT_CACHE;
1292 for (;;) {
1293 static const struct option long_options[] = {
1294 {"help", no_argument, 0, 'h'},
1295 {"object", required_argument, 0, OPTION_OBJECT},
1296 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1297 {"force-share", no_argument, 0, 'U'},
1298 {0, 0, 0, 0}
1300 c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1301 long_options, NULL);
1302 if (c == -1) {
1303 break;
1305 switch (c) {
1306 case ':':
1307 missing_argument(argv[optind - 1]);
1308 break;
1309 case '?':
1310 unrecognized_option(argv[optind - 1]);
1311 break;
1312 case 'h':
1313 help();
1314 break;
1315 case 'f':
1316 fmt1 = optarg;
1317 break;
1318 case 'F':
1319 fmt2 = optarg;
1320 break;
1321 case 'T':
1322 cache = optarg;
1323 break;
1324 case 'p':
1325 progress = true;
1326 break;
1327 case 'q':
1328 quiet = true;
1329 break;
1330 case 's':
1331 strict = true;
1332 break;
1333 case 'U':
1334 force_share = true;
1335 break;
1336 case OPTION_OBJECT: {
1337 QemuOpts *opts;
1338 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1339 optarg, true);
1340 if (!opts) {
1341 ret = 2;
1342 goto out4;
1344 } break;
1345 case OPTION_IMAGE_OPTS:
1346 image_opts = true;
1347 break;
1351 /* Progress is not shown in Quiet mode */
1352 if (quiet) {
1353 progress = false;
1357 if (optind != argc - 2) {
1358 error_exit("Expecting two image file names");
1360 filename1 = argv[optind++];
1361 filename2 = argv[optind++];
1363 if (qemu_opts_foreach(&qemu_object_opts,
1364 user_creatable_add_opts_foreach,
1365 NULL, NULL)) {
1366 ret = 2;
1367 goto out4;
1370 /* Initialize before goto out */
1371 qemu_progress_init(progress, 2.0);
1373 flags = 0;
1374 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1375 if (ret < 0) {
1376 error_report("Invalid source cache option: %s", cache);
1377 ret = 2;
1378 goto out3;
1381 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1382 force_share);
1383 if (!blk1) {
1384 ret = 2;
1385 goto out3;
1388 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1389 force_share);
1390 if (!blk2) {
1391 ret = 2;
1392 goto out2;
1394 bs1 = blk_bs(blk1);
1395 bs2 = blk_bs(blk2);
1397 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1398 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1399 total_size1 = blk_getlength(blk1);
1400 if (total_size1 < 0) {
1401 error_report("Can't get size of %s: %s",
1402 filename1, strerror(-total_size1));
1403 ret = 4;
1404 goto out;
1406 total_size2 = blk_getlength(blk2);
1407 if (total_size2 < 0) {
1408 error_report("Can't get size of %s: %s",
1409 filename2, strerror(-total_size2));
1410 ret = 4;
1411 goto out;
1413 total_size = MIN(total_size1, total_size2);
1414 progress_base = MAX(total_size1, total_size2);
1416 qemu_progress_print(0, 100);
1418 if (strict && total_size1 != total_size2) {
1419 ret = 1;
1420 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1421 goto out;
1424 while (offset < total_size) {
1425 int status1, status2;
1427 status1 = bdrv_block_status_above(bs1, NULL, offset,
1428 total_size1 - offset, &pnum1, NULL,
1429 NULL);
1430 if (status1 < 0) {
1431 ret = 3;
1432 error_report("Sector allocation test failed for %s", filename1);
1433 goto out;
1435 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1437 status2 = bdrv_block_status_above(bs2, NULL, offset,
1438 total_size2 - offset, &pnum2, NULL,
1439 NULL);
1440 if (status2 < 0) {
1441 ret = 3;
1442 error_report("Sector allocation test failed for %s", filename2);
1443 goto out;
1445 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1447 assert(pnum1 && pnum2);
1448 chunk = MIN(pnum1, pnum2);
1450 if (strict) {
1451 if (status1 != status2) {
1452 ret = 1;
1453 qprintf(quiet, "Strict mode: Offset %" PRId64
1454 " block status mismatch!\n", offset);
1455 goto out;
1458 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1459 /* nothing to do */
1460 } else if (allocated1 == allocated2) {
1461 if (allocated1) {
1462 int64_t pnum;
1464 chunk = MIN(chunk, IO_BUF_SIZE);
1465 ret = blk_pread(blk1, offset, buf1, chunk);
1466 if (ret < 0) {
1467 error_report("Error while reading offset %" PRId64
1468 " of %s: %s",
1469 offset, filename1, strerror(-ret));
1470 ret = 4;
1471 goto out;
1473 ret = blk_pread(blk2, offset, buf2, chunk);
1474 if (ret < 0) {
1475 error_report("Error while reading offset %" PRId64
1476 " of %s: %s",
1477 offset, filename2, strerror(-ret));
1478 ret = 4;
1479 goto out;
1481 ret = compare_buffers(buf1, buf2, chunk, &pnum);
1482 if (ret || pnum != chunk) {
1483 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1484 offset + (ret ? 0 : pnum));
1485 ret = 1;
1486 goto out;
1489 } else {
1490 chunk = MIN(chunk, IO_BUF_SIZE);
1491 if (allocated1) {
1492 ret = check_empty_sectors(blk1, offset, chunk,
1493 filename1, buf1, quiet);
1494 } else {
1495 ret = check_empty_sectors(blk2, offset, chunk,
1496 filename2, buf1, quiet);
1498 if (ret) {
1499 goto out;
1502 offset += chunk;
1503 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1506 if (total_size1 != total_size2) {
1507 BlockBackend *blk_over;
1508 const char *filename_over;
1510 qprintf(quiet, "Warning: Image size mismatch!\n");
1511 if (total_size1 > total_size2) {
1512 blk_over = blk1;
1513 filename_over = filename1;
1514 } else {
1515 blk_over = blk2;
1516 filename_over = filename2;
1519 while (offset < progress_base) {
1520 ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,
1521 progress_base - offset, &chunk,
1522 NULL, NULL);
1523 if (ret < 0) {
1524 ret = 3;
1525 error_report("Sector allocation test failed for %s",
1526 filename_over);
1527 goto out;
1530 if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {
1531 chunk = MIN(chunk, IO_BUF_SIZE);
1532 ret = check_empty_sectors(blk_over, offset, chunk,
1533 filename_over, buf1, quiet);
1534 if (ret) {
1535 goto out;
1538 offset += chunk;
1539 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1543 qprintf(quiet, "Images are identical.\n");
1544 ret = 0;
1546 out:
1547 qemu_vfree(buf1);
1548 qemu_vfree(buf2);
1549 blk_unref(blk2);
1550 out2:
1551 blk_unref(blk1);
1552 out3:
1553 qemu_progress_end();
1554 out4:
1555 return ret;
1558 enum ImgConvertBlockStatus {
1559 BLK_DATA,
1560 BLK_ZERO,
1561 BLK_BACKING_FILE,
1564 #define MAX_COROUTINES 16
1566 typedef struct ImgConvertState {
1567 BlockBackend **src;
1568 int64_t *src_sectors;
1569 int src_num;
1570 int64_t total_sectors;
1571 int64_t allocated_sectors;
1572 int64_t allocated_done;
1573 int64_t sector_num;
1574 int64_t wr_offs;
1575 enum ImgConvertBlockStatus status;
1576 int64_t sector_next_status;
1577 BlockBackend *target;
1578 bool has_zero_init;
1579 bool compressed;
1580 bool unallocated_blocks_are_zero;
1581 bool target_has_backing;
1582 int64_t target_backing_sectors; /* negative if unknown */
1583 bool wr_in_order;
1584 bool copy_range;
1585 int min_sparse;
1586 int alignment;
1587 size_t cluster_sectors;
1588 size_t buf_sectors;
1589 long num_coroutines;
1590 int running_coroutines;
1591 Coroutine *co[MAX_COROUTINES];
1592 int64_t wait_sector_num[MAX_COROUTINES];
1593 CoMutex lock;
1594 int ret;
1595 } ImgConvertState;
1597 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1598 int *src_cur, int64_t *src_cur_offset)
1600 *src_cur = 0;
1601 *src_cur_offset = 0;
1602 while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1603 *src_cur_offset += s->src_sectors[*src_cur];
1604 (*src_cur)++;
1605 assert(*src_cur < s->src_num);
1609 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1611 int64_t src_cur_offset;
1612 int ret, n, src_cur;
1613 bool post_backing_zero = false;
1615 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1617 assert(s->total_sectors > sector_num);
1618 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1620 if (s->target_backing_sectors >= 0) {
1621 if (sector_num >= s->target_backing_sectors) {
1622 post_backing_zero = s->unallocated_blocks_are_zero;
1623 } else if (sector_num + n > s->target_backing_sectors) {
1624 /* Split requests around target_backing_sectors (because
1625 * starting from there, zeros are handled differently) */
1626 n = s->target_backing_sectors - sector_num;
1630 if (s->sector_next_status <= sector_num) {
1631 int64_t count = n * BDRV_SECTOR_SIZE;
1633 if (s->target_has_backing) {
1635 ret = bdrv_block_status(blk_bs(s->src[src_cur]),
1636 (sector_num - src_cur_offset) *
1637 BDRV_SECTOR_SIZE,
1638 count, &count, NULL, NULL);
1639 } else {
1640 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,
1641 (sector_num - src_cur_offset) *
1642 BDRV_SECTOR_SIZE,
1643 count, &count, NULL, NULL);
1645 if (ret < 0) {
1646 return ret;
1648 n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
1650 if (ret & BDRV_BLOCK_ZERO) {
1651 s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;
1652 } else if (ret & BDRV_BLOCK_DATA) {
1653 s->status = BLK_DATA;
1654 } else {
1655 s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1658 s->sector_next_status = sector_num + n;
1661 n = MIN(n, s->sector_next_status - sector_num);
1662 if (s->status == BLK_DATA) {
1663 n = MIN(n, s->buf_sectors);
1666 /* We need to write complete clusters for compressed images, so if an
1667 * unallocated area is shorter than that, we must consider the whole
1668 * cluster allocated. */
1669 if (s->compressed) {
1670 if (n < s->cluster_sectors) {
1671 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1672 s->status = BLK_DATA;
1673 } else {
1674 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1678 return n;
1681 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1682 int nb_sectors, uint8_t *buf)
1684 int n, ret;
1685 QEMUIOVector qiov;
1686 struct iovec iov;
1688 assert(nb_sectors <= s->buf_sectors);
1689 while (nb_sectors > 0) {
1690 BlockBackend *blk;
1691 int src_cur;
1692 int64_t bs_sectors, src_cur_offset;
1694 /* In the case of compression with multiple source files, we can get a
1695 * nb_sectors that spreads into the next part. So we must be able to
1696 * read across multiple BDSes for one convert_read() call. */
1697 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1698 blk = s->src[src_cur];
1699 bs_sectors = s->src_sectors[src_cur];
1701 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1702 iov.iov_base = buf;
1703 iov.iov_len = n << BDRV_SECTOR_BITS;
1704 qemu_iovec_init_external(&qiov, &iov, 1);
1706 ret = blk_co_preadv(
1707 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
1708 n << BDRV_SECTOR_BITS, &qiov, 0);
1709 if (ret < 0) {
1710 return ret;
1713 sector_num += n;
1714 nb_sectors -= n;
1715 buf += n * BDRV_SECTOR_SIZE;
1718 return 0;
1722 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1723 int nb_sectors, uint8_t *buf,
1724 enum ImgConvertBlockStatus status)
1726 int ret;
1727 QEMUIOVector qiov;
1728 struct iovec iov;
1730 while (nb_sectors > 0) {
1731 int n = nb_sectors;
1732 BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1734 switch (status) {
1735 case BLK_BACKING_FILE:
1736 /* If we have a backing file, leave clusters unallocated that are
1737 * unallocated in the source image, so that the backing file is
1738 * visible at the respective offset. */
1739 assert(s->target_has_backing);
1740 break;
1742 case BLK_DATA:
1743 /* If we're told to keep the target fully allocated (-S 0) or there
1744 * is real non-zero data, we must write it. Otherwise we can treat
1745 * it as zero sectors.
1746 * Compressed clusters need to be written as a whole, so in that
1747 * case we can only save the write if the buffer is completely
1748 * zeroed. */
1749 if (!s->min_sparse ||
1750 (!s->compressed &&
1751 is_allocated_sectors_min(buf, n, &n, s->min_sparse,
1752 sector_num, s->alignment)) ||
1753 (s->compressed &&
1754 !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1756 iov.iov_base = buf;
1757 iov.iov_len = n << BDRV_SECTOR_BITS;
1758 qemu_iovec_init_external(&qiov, &iov, 1);
1760 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
1761 n << BDRV_SECTOR_BITS, &qiov, flags);
1762 if (ret < 0) {
1763 return ret;
1765 break;
1767 /* fall-through */
1769 case BLK_ZERO:
1770 if (s->has_zero_init) {
1771 assert(!s->target_has_backing);
1772 break;
1774 ret = blk_co_pwrite_zeroes(s->target,
1775 sector_num << BDRV_SECTOR_BITS,
1776 n << BDRV_SECTOR_BITS, 0);
1777 if (ret < 0) {
1778 return ret;
1780 break;
1783 sector_num += n;
1784 nb_sectors -= n;
1785 buf += n * BDRV_SECTOR_SIZE;
1788 return 0;
1791 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
1792 int nb_sectors)
1794 int n, ret;
1796 while (nb_sectors > 0) {
1797 BlockBackend *blk;
1798 int src_cur;
1799 int64_t bs_sectors, src_cur_offset;
1800 int64_t offset;
1802 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1803 offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1804 blk = s->src[src_cur];
1805 bs_sectors = s->src_sectors[src_cur];
1807 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1809 ret = blk_co_copy_range(blk, offset, s->target,
1810 sector_num << BDRV_SECTOR_BITS,
1811 n << BDRV_SECTOR_BITS, 0, 0);
1812 if (ret < 0) {
1813 return ret;
1816 sector_num += n;
1817 nb_sectors -= n;
1819 return 0;
1822 static void coroutine_fn convert_co_do_copy(void *opaque)
1824 ImgConvertState *s = opaque;
1825 uint8_t *buf = NULL;
1826 int ret, i;
1827 int index = -1;
1829 for (i = 0; i < s->num_coroutines; i++) {
1830 if (s->co[i] == qemu_coroutine_self()) {
1831 index = i;
1832 break;
1835 assert(index >= 0);
1837 s->running_coroutines++;
1838 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1840 while (1) {
1841 int n;
1842 int64_t sector_num;
1843 enum ImgConvertBlockStatus status;
1844 bool copy_range;
1846 qemu_co_mutex_lock(&s->lock);
1847 if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1848 qemu_co_mutex_unlock(&s->lock);
1849 break;
1851 n = convert_iteration_sectors(s, s->sector_num);
1852 if (n < 0) {
1853 qemu_co_mutex_unlock(&s->lock);
1854 s->ret = n;
1855 break;
1857 /* save current sector and allocation status to local variables */
1858 sector_num = s->sector_num;
1859 status = s->status;
1860 if (!s->min_sparse && s->status == BLK_ZERO) {
1861 n = MIN(n, s->buf_sectors);
1863 /* increment global sector counter so that other coroutines can
1864 * already continue reading beyond this request */
1865 s->sector_num += n;
1866 qemu_co_mutex_unlock(&s->lock);
1868 if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
1869 s->allocated_done += n;
1870 qemu_progress_print(100.0 * s->allocated_done /
1871 s->allocated_sectors, 0);
1874 retry:
1875 copy_range = s->copy_range && s->status == BLK_DATA;
1876 if (status == BLK_DATA && !copy_range) {
1877 ret = convert_co_read(s, sector_num, n, buf);
1878 if (ret < 0) {
1879 error_report("error while reading sector %" PRId64
1880 ": %s", sector_num, strerror(-ret));
1881 s->ret = ret;
1883 } else if (!s->min_sparse && status == BLK_ZERO) {
1884 status = BLK_DATA;
1885 memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
1888 if (s->wr_in_order) {
1889 /* keep writes in order */
1890 while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
1891 s->wait_sector_num[index] = sector_num;
1892 qemu_coroutine_yield();
1894 s->wait_sector_num[index] = -1;
1897 if (s->ret == -EINPROGRESS) {
1898 if (copy_range) {
1899 ret = convert_co_copy_range(s, sector_num, n);
1900 if (ret) {
1901 s->copy_range = false;
1902 goto retry;
1904 } else {
1905 ret = convert_co_write(s, sector_num, n, buf, status);
1907 if (ret < 0) {
1908 error_report("error while writing sector %" PRId64
1909 ": %s", sector_num, strerror(-ret));
1910 s->ret = ret;
1914 if (s->wr_in_order) {
1915 /* reenter the coroutine that might have waited
1916 * for this write to complete */
1917 s->wr_offs = sector_num + n;
1918 for (i = 0; i < s->num_coroutines; i++) {
1919 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
1921 * A -> B -> A cannot occur because A has
1922 * s->wait_sector_num[i] == -1 during A -> B. Therefore
1923 * B will never enter A during this time window.
1925 qemu_coroutine_enter(s->co[i]);
1926 break;
1932 qemu_vfree(buf);
1933 s->co[index] = NULL;
1934 s->running_coroutines--;
1935 if (!s->running_coroutines && s->ret == -EINPROGRESS) {
1936 /* the convert job finished successfully */
1937 s->ret = 0;
1941 static int convert_do_copy(ImgConvertState *s)
1943 int ret, i, n;
1944 int64_t sector_num = 0;
1946 /* Check whether we have zero initialisation or can get it efficiently */
1947 s->has_zero_init = s->min_sparse && !s->target_has_backing
1948 ? bdrv_has_zero_init(blk_bs(s->target))
1949 : false;
1951 if (!s->has_zero_init && !s->target_has_backing &&
1952 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1954 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP);
1955 if (ret == 0) {
1956 s->has_zero_init = true;
1960 /* Allocate buffer for copied data. For compressed images, only one cluster
1961 * can be copied at a time. */
1962 if (s->compressed) {
1963 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1964 error_report("invalid cluster size");
1965 return -EINVAL;
1967 s->buf_sectors = s->cluster_sectors;
1970 while (sector_num < s->total_sectors) {
1971 n = convert_iteration_sectors(s, sector_num);
1972 if (n < 0) {
1973 return n;
1975 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
1977 s->allocated_sectors += n;
1979 sector_num += n;
1982 /* Do the copy */
1983 s->sector_next_status = 0;
1984 s->ret = -EINPROGRESS;
1986 qemu_co_mutex_init(&s->lock);
1987 for (i = 0; i < s->num_coroutines; i++) {
1988 s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
1989 s->wait_sector_num[i] = -1;
1990 qemu_coroutine_enter(s->co[i]);
1993 while (s->running_coroutines) {
1994 main_loop_wait(false);
1997 if (s->compressed && !s->ret) {
1998 /* signal EOF to align */
1999 ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
2000 if (ret < 0) {
2001 return ret;
2005 return s->ret;
2008 static int img_convert(int argc, char **argv)
2010 int c, bs_i, flags, src_flags = 0;
2011 const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
2012 *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
2013 *out_filename, *out_baseimg_param, *snapshot_name = NULL;
2014 BlockDriver *drv = NULL, *proto_drv = NULL;
2015 BlockDriverInfo bdi;
2016 BlockDriverState *out_bs;
2017 QemuOpts *opts = NULL, *sn_opts = NULL;
2018 QemuOptsList *create_opts = NULL;
2019 char *options = NULL;
2020 Error *local_err = NULL;
2021 bool writethrough, src_writethrough, quiet = false, image_opts = false,
2022 skip_create = false, progress = false, tgt_image_opts = false;
2023 int64_t ret = -EINVAL;
2024 bool force_share = false;
2026 ImgConvertState s = (ImgConvertState) {
2027 /* Need at least 4k of zeros for sparse detection */
2028 .min_sparse = 8,
2029 .copy_range = true,
2030 .buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
2031 .wr_in_order = true,
2032 .num_coroutines = 8,
2035 for(;;) {
2036 static const struct option long_options[] = {
2037 {"help", no_argument, 0, 'h'},
2038 {"object", required_argument, 0, OPTION_OBJECT},
2039 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2040 {"force-share", no_argument, 0, 'U'},
2041 {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
2042 {0, 0, 0, 0}
2044 c = getopt_long(argc, argv, ":hf:O:B:co:l:S:pt:T:qnm:WU",
2045 long_options, NULL);
2046 if (c == -1) {
2047 break;
2049 switch(c) {
2050 case ':':
2051 missing_argument(argv[optind - 1]);
2052 break;
2053 case '?':
2054 unrecognized_option(argv[optind - 1]);
2055 break;
2056 case 'h':
2057 help();
2058 break;
2059 case 'f':
2060 fmt = optarg;
2061 break;
2062 case 'O':
2063 out_fmt = optarg;
2064 break;
2065 case 'B':
2066 out_baseimg = optarg;
2067 break;
2068 case 'c':
2069 s.compressed = true;
2070 s.copy_range = false;
2071 break;
2072 case 'o':
2073 if (!is_valid_option_list(optarg)) {
2074 error_report("Invalid option list: %s", optarg);
2075 goto fail_getopt;
2077 if (!options) {
2078 options = g_strdup(optarg);
2079 } else {
2080 char *old_options = options;
2081 options = g_strdup_printf("%s,%s", options, optarg);
2082 g_free(old_options);
2084 break;
2085 case 'l':
2086 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2087 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2088 optarg, false);
2089 if (!sn_opts) {
2090 error_report("Failed in parsing snapshot param '%s'",
2091 optarg);
2092 goto fail_getopt;
2094 } else {
2095 snapshot_name = optarg;
2097 break;
2098 case 'S':
2100 int64_t sval;
2102 sval = cvtnum(optarg);
2103 if (sval < 0) {
2104 error_report("Invalid minimum zero buffer size for sparse output specified");
2105 goto fail_getopt;
2108 s.min_sparse = sval / BDRV_SECTOR_SIZE;
2109 s.copy_range = false;
2110 break;
2112 case 'p':
2113 progress = true;
2114 break;
2115 case 't':
2116 cache = optarg;
2117 break;
2118 case 'T':
2119 src_cache = optarg;
2120 break;
2121 case 'q':
2122 quiet = true;
2123 break;
2124 case 'n':
2125 skip_create = true;
2126 break;
2127 case 'm':
2128 if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2129 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2130 error_report("Invalid number of coroutines. Allowed number of"
2131 " coroutines is between 1 and %d", MAX_COROUTINES);
2132 goto fail_getopt;
2134 break;
2135 case 'W':
2136 s.wr_in_order = false;
2137 break;
2138 case 'U':
2139 force_share = true;
2140 break;
2141 case OPTION_OBJECT: {
2142 QemuOpts *object_opts;
2143 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2144 optarg, true);
2145 if (!object_opts) {
2146 goto fail_getopt;
2148 break;
2150 case OPTION_IMAGE_OPTS:
2151 image_opts = true;
2152 break;
2153 case OPTION_TARGET_IMAGE_OPTS:
2154 tgt_image_opts = true;
2155 break;
2159 if (!out_fmt && !tgt_image_opts) {
2160 out_fmt = "raw";
2163 if (qemu_opts_foreach(&qemu_object_opts,
2164 user_creatable_add_opts_foreach,
2165 NULL, NULL)) {
2166 goto fail_getopt;
2169 if (tgt_image_opts && !skip_create) {
2170 error_report("--target-image-opts requires use of -n flag");
2171 goto fail_getopt;
2174 s.src_num = argc - optind - 1;
2175 out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2177 if (options && has_help_option(options)) {
2178 if (out_fmt) {
2179 ret = print_block_option_help(out_filename, out_fmt);
2180 goto fail_getopt;
2181 } else {
2182 error_report("Option help requires a format be specified");
2183 goto fail_getopt;
2187 if (s.src_num < 1) {
2188 error_report("Must specify image file name");
2189 goto fail_getopt;
2193 /* ret is still -EINVAL until here */
2194 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2195 if (ret < 0) {
2196 error_report("Invalid source cache option: %s", src_cache);
2197 goto fail_getopt;
2200 /* Initialize before goto out */
2201 if (quiet) {
2202 progress = false;
2204 qemu_progress_init(progress, 1.0);
2205 qemu_progress_print(0, 100);
2207 s.src = g_new0(BlockBackend *, s.src_num);
2208 s.src_sectors = g_new(int64_t, s.src_num);
2210 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2211 s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2212 fmt, src_flags, src_writethrough, quiet,
2213 force_share);
2214 if (!s.src[bs_i]) {
2215 ret = -1;
2216 goto out;
2218 s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2219 if (s.src_sectors[bs_i] < 0) {
2220 error_report("Could not get size of %s: %s",
2221 argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2222 ret = -1;
2223 goto out;
2225 s.total_sectors += s.src_sectors[bs_i];
2228 if (sn_opts) {
2229 bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2230 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2231 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2232 &local_err);
2233 } else if (snapshot_name != NULL) {
2234 if (s.src_num > 1) {
2235 error_report("No support for concatenating multiple snapshot");
2236 ret = -1;
2237 goto out;
2240 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2241 &local_err);
2243 if (local_err) {
2244 error_reportf_err(local_err, "Failed to load snapshot: ");
2245 ret = -1;
2246 goto out;
2249 if (!skip_create) {
2250 /* Find driver and parse its options */
2251 drv = bdrv_find_format(out_fmt);
2252 if (!drv) {
2253 error_report("Unknown file format '%s'", out_fmt);
2254 ret = -1;
2255 goto out;
2258 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2259 if (!proto_drv) {
2260 error_report_err(local_err);
2261 ret = -1;
2262 goto out;
2265 if (!drv->create_opts) {
2266 error_report("Format driver '%s' does not support image creation",
2267 drv->format_name);
2268 ret = -1;
2269 goto out;
2272 if (!proto_drv->create_opts) {
2273 error_report("Protocol driver '%s' does not support image creation",
2274 proto_drv->format_name);
2275 ret = -1;
2276 goto out;
2279 create_opts = qemu_opts_append(create_opts, drv->create_opts);
2280 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2282 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2283 if (options) {
2284 qemu_opts_do_parse(opts, options, NULL, &local_err);
2285 if (local_err) {
2286 error_report_err(local_err);
2287 ret = -1;
2288 goto out;
2292 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2293 &error_abort);
2294 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2295 if (ret < 0) {
2296 goto out;
2300 /* Get backing file name if -o backing_file was used */
2301 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2302 if (out_baseimg_param) {
2303 out_baseimg = out_baseimg_param;
2305 s.target_has_backing = (bool) out_baseimg;
2307 if (s.src_num > 1 && out_baseimg) {
2308 error_report("Having a backing file for the target makes no sense when "
2309 "concatenating multiple input images");
2310 ret = -1;
2311 goto out;
2314 /* Check if compression is supported */
2315 if (s.compressed) {
2316 bool encryption =
2317 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2318 const char *encryptfmt =
2319 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2320 const char *preallocation =
2321 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2323 if (drv && !drv->bdrv_co_pwritev_compressed) {
2324 error_report("Compression not supported for this file format");
2325 ret = -1;
2326 goto out;
2329 if (encryption || encryptfmt) {
2330 error_report("Compression and encryption not supported at "
2331 "the same time");
2332 ret = -1;
2333 goto out;
2336 if (preallocation
2337 && strcmp(preallocation, "off"))
2339 error_report("Compression and preallocation not supported at "
2340 "the same time");
2341 ret = -1;
2342 goto out;
2346 if (!skip_create) {
2347 /* Create the new image */
2348 ret = bdrv_create(drv, out_filename, opts, &local_err);
2349 if (ret < 0) {
2350 error_reportf_err(local_err, "%s: error while converting %s: ",
2351 out_filename, out_fmt);
2352 goto out;
2356 flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2357 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2358 if (ret < 0) {
2359 error_report("Invalid cache option: %s", cache);
2360 goto out;
2363 if (skip_create) {
2364 s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2365 flags, writethrough, quiet, false);
2366 } else {
2367 /* TODO ultimately we should allow --target-image-opts
2368 * to be used even when -n is not given.
2369 * That has to wait for bdrv_create to be improved
2370 * to allow filenames in option syntax
2372 s.target = img_open_new_file(out_filename, opts, out_fmt,
2373 flags, writethrough, quiet, false);
2375 if (!s.target) {
2376 ret = -1;
2377 goto out;
2379 out_bs = blk_bs(s.target);
2381 if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
2382 error_report("Compression not supported for this file format");
2383 ret = -1;
2384 goto out;
2387 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2388 * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
2389 * as maximum. */
2390 s.buf_sectors = MIN(32768,
2391 MAX(s.buf_sectors,
2392 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2393 out_bs->bl.pdiscard_alignment >>
2394 BDRV_SECTOR_BITS)));
2396 /* try to align the write requests to the destination to avoid unnecessary
2397 * RMW cycles. */
2398 s.alignment = MAX(pow2floor(s.min_sparse),
2399 DIV_ROUND_UP(out_bs->bl.request_alignment,
2400 BDRV_SECTOR_SIZE));
2401 assert(is_power_of_2(s.alignment));
2403 if (skip_create) {
2404 int64_t output_sectors = blk_nb_sectors(s.target);
2405 if (output_sectors < 0) {
2406 error_report("unable to get output image length: %s",
2407 strerror(-output_sectors));
2408 ret = -1;
2409 goto out;
2410 } else if (output_sectors < s.total_sectors) {
2411 error_report("output file is smaller than input file");
2412 ret = -1;
2413 goto out;
2417 if (s.target_has_backing) {
2418 /* Errors are treated as "backing length unknown" (which means
2419 * s.target_backing_sectors has to be negative, which it will
2420 * be automatically). The backing file length is used only
2421 * for optimizations, so such a case is not fatal. */
2422 s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
2423 } else {
2424 s.target_backing_sectors = -1;
2427 ret = bdrv_get_info(out_bs, &bdi);
2428 if (ret < 0) {
2429 if (s.compressed) {
2430 error_report("could not get block driver info");
2431 goto out;
2433 } else {
2434 s.compressed = s.compressed || bdi.needs_compressed_writes;
2435 s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2436 s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;
2439 ret = convert_do_copy(&s);
2440 out:
2441 if (!ret) {
2442 qemu_progress_print(100, 0);
2444 qemu_progress_end();
2445 qemu_opts_del(opts);
2446 qemu_opts_free(create_opts);
2447 qemu_opts_del(sn_opts);
2448 blk_unref(s.target);
2449 if (s.src) {
2450 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2451 blk_unref(s.src[bs_i]);
2453 g_free(s.src);
2455 g_free(s.src_sectors);
2456 fail_getopt:
2457 g_free(options);
2459 return !!ret;
2463 static void dump_snapshots(BlockDriverState *bs)
2465 QEMUSnapshotInfo *sn_tab, *sn;
2466 int nb_sns, i;
2468 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2469 if (nb_sns <= 0)
2470 return;
2471 printf("Snapshot list:\n");
2472 bdrv_snapshot_dump(fprintf, stdout, NULL);
2473 printf("\n");
2474 for(i = 0; i < nb_sns; i++) {
2475 sn = &sn_tab[i];
2476 bdrv_snapshot_dump(fprintf, stdout, sn);
2477 printf("\n");
2479 g_free(sn_tab);
2482 static void dump_json_image_info_list(ImageInfoList *list)
2484 QString *str;
2485 QObject *obj;
2486 Visitor *v = qobject_output_visitor_new(&obj);
2488 visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2489 visit_complete(v, &obj);
2490 str = qobject_to_json_pretty(obj);
2491 assert(str != NULL);
2492 printf("%s\n", qstring_get_str(str));
2493 qobject_unref(obj);
2494 visit_free(v);
2495 qobject_unref(str);
2498 static void dump_json_image_info(ImageInfo *info)
2500 QString *str;
2501 QObject *obj;
2502 Visitor *v = qobject_output_visitor_new(&obj);
2504 visit_type_ImageInfo(v, NULL, &info, &error_abort);
2505 visit_complete(v, &obj);
2506 str = qobject_to_json_pretty(obj);
2507 assert(str != NULL);
2508 printf("%s\n", qstring_get_str(str));
2509 qobject_unref(obj);
2510 visit_free(v);
2511 qobject_unref(str);
2514 static void dump_human_image_info_list(ImageInfoList *list)
2516 ImageInfoList *elem;
2517 bool delim = false;
2519 for (elem = list; elem; elem = elem->next) {
2520 if (delim) {
2521 printf("\n");
2523 delim = true;
2525 bdrv_image_info_dump(fprintf, stdout, elem->value);
2529 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2531 return strcmp(a, b) == 0;
2535 * Open an image file chain and return an ImageInfoList
2537 * @filename: topmost image filename
2538 * @fmt: topmost image format (may be NULL to autodetect)
2539 * @chain: true - enumerate entire backing file chain
2540 * false - only topmost image file
2542 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2543 * image file. If there was an error a message will have been printed to
2544 * stderr.
2546 static ImageInfoList *collect_image_info_list(bool image_opts,
2547 const char *filename,
2548 const char *fmt,
2549 bool chain, bool force_share)
2551 ImageInfoList *head = NULL;
2552 ImageInfoList **last = &head;
2553 GHashTable *filenames;
2554 Error *err = NULL;
2556 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2558 while (filename) {
2559 BlockBackend *blk;
2560 BlockDriverState *bs;
2561 ImageInfo *info;
2562 ImageInfoList *elem;
2564 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2565 error_report("Backing file '%s' creates an infinite loop.",
2566 filename);
2567 goto err;
2569 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2571 blk = img_open(image_opts, filename, fmt,
2572 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2573 force_share);
2574 if (!blk) {
2575 goto err;
2577 bs = blk_bs(blk);
2579 bdrv_query_image_info(bs, &info, &err);
2580 if (err) {
2581 error_report_err(err);
2582 blk_unref(blk);
2583 goto err;
2586 elem = g_new0(ImageInfoList, 1);
2587 elem->value = info;
2588 *last = elem;
2589 last = &elem->next;
2591 blk_unref(blk);
2593 filename = fmt = NULL;
2594 if (chain) {
2595 if (info->has_full_backing_filename) {
2596 filename = info->full_backing_filename;
2597 } else if (info->has_backing_filename) {
2598 error_report("Could not determine absolute backing filename,"
2599 " but backing filename '%s' present",
2600 info->backing_filename);
2601 goto err;
2603 if (info->has_backing_filename_format) {
2604 fmt = info->backing_filename_format;
2608 g_hash_table_destroy(filenames);
2609 return head;
2611 err:
2612 qapi_free_ImageInfoList(head);
2613 g_hash_table_destroy(filenames);
2614 return NULL;
2617 static int img_info(int argc, char **argv)
2619 int c;
2620 OutputFormat output_format = OFORMAT_HUMAN;
2621 bool chain = false;
2622 const char *filename, *fmt, *output;
2623 ImageInfoList *list;
2624 bool image_opts = false;
2625 bool force_share = false;
2627 fmt = NULL;
2628 output = NULL;
2629 for(;;) {
2630 int option_index = 0;
2631 static const struct option long_options[] = {
2632 {"help", no_argument, 0, 'h'},
2633 {"format", required_argument, 0, 'f'},
2634 {"output", required_argument, 0, OPTION_OUTPUT},
2635 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2636 {"object", required_argument, 0, OPTION_OBJECT},
2637 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2638 {"force-share", no_argument, 0, 'U'},
2639 {0, 0, 0, 0}
2641 c = getopt_long(argc, argv, ":f:hU",
2642 long_options, &option_index);
2643 if (c == -1) {
2644 break;
2646 switch(c) {
2647 case ':':
2648 missing_argument(argv[optind - 1]);
2649 break;
2650 case '?':
2651 unrecognized_option(argv[optind - 1]);
2652 break;
2653 case 'h':
2654 help();
2655 break;
2656 case 'f':
2657 fmt = optarg;
2658 break;
2659 case 'U':
2660 force_share = true;
2661 break;
2662 case OPTION_OUTPUT:
2663 output = optarg;
2664 break;
2665 case OPTION_BACKING_CHAIN:
2666 chain = true;
2667 break;
2668 case OPTION_OBJECT: {
2669 QemuOpts *opts;
2670 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2671 optarg, true);
2672 if (!opts) {
2673 return 1;
2675 } break;
2676 case OPTION_IMAGE_OPTS:
2677 image_opts = true;
2678 break;
2681 if (optind != argc - 1) {
2682 error_exit("Expecting one image file name");
2684 filename = argv[optind++];
2686 if (output && !strcmp(output, "json")) {
2687 output_format = OFORMAT_JSON;
2688 } else if (output && !strcmp(output, "human")) {
2689 output_format = OFORMAT_HUMAN;
2690 } else if (output) {
2691 error_report("--output must be used with human or json as argument.");
2692 return 1;
2695 if (qemu_opts_foreach(&qemu_object_opts,
2696 user_creatable_add_opts_foreach,
2697 NULL, NULL)) {
2698 return 1;
2701 list = collect_image_info_list(image_opts, filename, fmt, chain,
2702 force_share);
2703 if (!list) {
2704 return 1;
2707 switch (output_format) {
2708 case OFORMAT_HUMAN:
2709 dump_human_image_info_list(list);
2710 break;
2711 case OFORMAT_JSON:
2712 if (chain) {
2713 dump_json_image_info_list(list);
2714 } else {
2715 dump_json_image_info(list->value);
2717 break;
2720 qapi_free_ImageInfoList(list);
2721 return 0;
2724 static void dump_map_entry(OutputFormat output_format, MapEntry *e,
2725 MapEntry *next)
2727 switch (output_format) {
2728 case OFORMAT_HUMAN:
2729 if (e->data && !e->has_offset) {
2730 error_report("File contains external, encrypted or compressed clusters.");
2731 exit(1);
2733 if (e->data && !e->zero) {
2734 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2735 e->start, e->length,
2736 e->has_offset ? e->offset : 0,
2737 e->has_filename ? e->filename : "");
2739 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2740 * Modify the flags here to allow more coalescing.
2742 if (next && (!next->data || next->zero)) {
2743 next->data = false;
2744 next->zero = true;
2746 break;
2747 case OFORMAT_JSON:
2748 printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2749 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2750 (e->start == 0 ? "[" : ",\n"),
2751 e->start, e->length, e->depth,
2752 e->zero ? "true" : "false",
2753 e->data ? "true" : "false");
2754 if (e->has_offset) {
2755 printf(", \"offset\": %"PRId64"", e->offset);
2757 putchar('}');
2759 if (!next) {
2760 printf("]\n");
2762 break;
2766 static int get_block_status(BlockDriverState *bs, int64_t offset,
2767 int64_t bytes, MapEntry *e)
2769 int ret;
2770 int depth;
2771 BlockDriverState *file;
2772 bool has_offset;
2773 int64_t map;
2775 /* As an optimization, we could cache the current range of unallocated
2776 * clusters in each file of the chain, and avoid querying the same
2777 * range repeatedly.
2780 depth = 0;
2781 for (;;) {
2782 ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file);
2783 if (ret < 0) {
2784 return ret;
2786 assert(bytes);
2787 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2788 break;
2790 bs = backing_bs(bs);
2791 if (bs == NULL) {
2792 ret = 0;
2793 break;
2796 depth++;
2799 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2801 *e = (MapEntry) {
2802 .start = offset,
2803 .length = bytes,
2804 .data = !!(ret & BDRV_BLOCK_DATA),
2805 .zero = !!(ret & BDRV_BLOCK_ZERO),
2806 .offset = map,
2807 .has_offset = has_offset,
2808 .depth = depth,
2809 .has_filename = file && has_offset,
2810 .filename = file && has_offset ? file->filename : NULL,
2813 return 0;
2816 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2818 if (curr->length == 0) {
2819 return false;
2821 if (curr->zero != next->zero ||
2822 curr->data != next->data ||
2823 curr->depth != next->depth ||
2824 curr->has_filename != next->has_filename ||
2825 curr->has_offset != next->has_offset) {
2826 return false;
2828 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2829 return false;
2831 if (curr->has_offset && curr->offset + curr->length != next->offset) {
2832 return false;
2834 return true;
2837 static int img_map(int argc, char **argv)
2839 int c;
2840 OutputFormat output_format = OFORMAT_HUMAN;
2841 BlockBackend *blk;
2842 BlockDriverState *bs;
2843 const char *filename, *fmt, *output;
2844 int64_t length;
2845 MapEntry curr = { .length = 0 }, next;
2846 int ret = 0;
2847 bool image_opts = false;
2848 bool force_share = false;
2850 fmt = NULL;
2851 output = NULL;
2852 for (;;) {
2853 int option_index = 0;
2854 static const struct option long_options[] = {
2855 {"help", no_argument, 0, 'h'},
2856 {"format", required_argument, 0, 'f'},
2857 {"output", required_argument, 0, OPTION_OUTPUT},
2858 {"object", required_argument, 0, OPTION_OBJECT},
2859 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2860 {"force-share", no_argument, 0, 'U'},
2861 {0, 0, 0, 0}
2863 c = getopt_long(argc, argv, ":f:hU",
2864 long_options, &option_index);
2865 if (c == -1) {
2866 break;
2868 switch (c) {
2869 case ':':
2870 missing_argument(argv[optind - 1]);
2871 break;
2872 case '?':
2873 unrecognized_option(argv[optind - 1]);
2874 break;
2875 case 'h':
2876 help();
2877 break;
2878 case 'f':
2879 fmt = optarg;
2880 break;
2881 case 'U':
2882 force_share = true;
2883 break;
2884 case OPTION_OUTPUT:
2885 output = optarg;
2886 break;
2887 case OPTION_OBJECT: {
2888 QemuOpts *opts;
2889 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2890 optarg, true);
2891 if (!opts) {
2892 return 1;
2894 } break;
2895 case OPTION_IMAGE_OPTS:
2896 image_opts = true;
2897 break;
2900 if (optind != argc - 1) {
2901 error_exit("Expecting one image file name");
2903 filename = argv[optind];
2905 if (output && !strcmp(output, "json")) {
2906 output_format = OFORMAT_JSON;
2907 } else if (output && !strcmp(output, "human")) {
2908 output_format = OFORMAT_HUMAN;
2909 } else if (output) {
2910 error_report("--output must be used with human or json as argument.");
2911 return 1;
2914 if (qemu_opts_foreach(&qemu_object_opts,
2915 user_creatable_add_opts_foreach,
2916 NULL, NULL)) {
2917 return 1;
2920 blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
2921 if (!blk) {
2922 return 1;
2924 bs = blk_bs(blk);
2926 if (output_format == OFORMAT_HUMAN) {
2927 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
2930 length = blk_getlength(blk);
2931 while (curr.start + curr.length < length) {
2932 int64_t offset = curr.start + curr.length;
2933 int64_t n;
2935 /* Probe up to 1 GiB at a time. */
2936 n = MIN(1 << 30, length - offset);
2937 ret = get_block_status(bs, offset, n, &next);
2939 if (ret < 0) {
2940 error_report("Could not read file metadata: %s", strerror(-ret));
2941 goto out;
2944 if (entry_mergeable(&curr, &next)) {
2945 curr.length += next.length;
2946 continue;
2949 if (curr.length > 0) {
2950 dump_map_entry(output_format, &curr, &next);
2952 curr = next;
2955 dump_map_entry(output_format, &curr, NULL);
2957 out:
2958 blk_unref(blk);
2959 return ret < 0;
2962 #define SNAPSHOT_LIST 1
2963 #define SNAPSHOT_CREATE 2
2964 #define SNAPSHOT_APPLY 3
2965 #define SNAPSHOT_DELETE 4
2967 static int img_snapshot(int argc, char **argv)
2969 BlockBackend *blk;
2970 BlockDriverState *bs;
2971 QEMUSnapshotInfo sn;
2972 char *filename, *snapshot_name = NULL;
2973 int c, ret = 0, bdrv_oflags;
2974 int action = 0;
2975 qemu_timeval tv;
2976 bool quiet = false;
2977 Error *err = NULL;
2978 bool image_opts = false;
2979 bool force_share = false;
2981 bdrv_oflags = BDRV_O_RDWR;
2982 /* Parse commandline parameters */
2983 for(;;) {
2984 static const struct option long_options[] = {
2985 {"help", no_argument, 0, 'h'},
2986 {"object", required_argument, 0, OPTION_OBJECT},
2987 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2988 {"force-share", no_argument, 0, 'U'},
2989 {0, 0, 0, 0}
2991 c = getopt_long(argc, argv, ":la:c:d:hqU",
2992 long_options, NULL);
2993 if (c == -1) {
2994 break;
2996 switch(c) {
2997 case ':':
2998 missing_argument(argv[optind - 1]);
2999 break;
3000 case '?':
3001 unrecognized_option(argv[optind - 1]);
3002 break;
3003 case 'h':
3004 help();
3005 return 0;
3006 case 'l':
3007 if (action) {
3008 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3009 return 0;
3011 action = SNAPSHOT_LIST;
3012 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
3013 break;
3014 case 'a':
3015 if (action) {
3016 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3017 return 0;
3019 action = SNAPSHOT_APPLY;
3020 snapshot_name = optarg;
3021 break;
3022 case 'c':
3023 if (action) {
3024 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3025 return 0;
3027 action = SNAPSHOT_CREATE;
3028 snapshot_name = optarg;
3029 break;
3030 case 'd':
3031 if (action) {
3032 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3033 return 0;
3035 action = SNAPSHOT_DELETE;
3036 snapshot_name = optarg;
3037 break;
3038 case 'q':
3039 quiet = true;
3040 break;
3041 case 'U':
3042 force_share = true;
3043 break;
3044 case OPTION_OBJECT: {
3045 QemuOpts *opts;
3046 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3047 optarg, true);
3048 if (!opts) {
3049 return 1;
3051 } break;
3052 case OPTION_IMAGE_OPTS:
3053 image_opts = true;
3054 break;
3058 if (optind != argc - 1) {
3059 error_exit("Expecting one image file name");
3061 filename = argv[optind++];
3063 if (qemu_opts_foreach(&qemu_object_opts,
3064 user_creatable_add_opts_foreach,
3065 NULL, NULL)) {
3066 return 1;
3069 /* Open the image */
3070 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
3071 force_share);
3072 if (!blk) {
3073 return 1;
3075 bs = blk_bs(blk);
3077 /* Perform the requested action */
3078 switch(action) {
3079 case SNAPSHOT_LIST:
3080 dump_snapshots(bs);
3081 break;
3083 case SNAPSHOT_CREATE:
3084 memset(&sn, 0, sizeof(sn));
3085 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3087 qemu_gettimeofday(&tv);
3088 sn.date_sec = tv.tv_sec;
3089 sn.date_nsec = tv.tv_usec * 1000;
3091 ret = bdrv_snapshot_create(bs, &sn);
3092 if (ret) {
3093 error_report("Could not create snapshot '%s': %d (%s)",
3094 snapshot_name, ret, strerror(-ret));
3096 break;
3098 case SNAPSHOT_APPLY:
3099 ret = bdrv_snapshot_goto(bs, snapshot_name, &err);
3100 if (ret) {
3101 error_reportf_err(err, "Could not apply snapshot '%s': ",
3102 snapshot_name);
3104 break;
3106 case SNAPSHOT_DELETE:
3107 bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
3108 if (err) {
3109 error_reportf_err(err, "Could not delete snapshot '%s': ",
3110 snapshot_name);
3111 ret = 1;
3113 break;
3116 /* Cleanup */
3117 blk_unref(blk);
3118 if (ret) {
3119 return 1;
3121 return 0;
3124 static int img_rebase(int argc, char **argv)
3126 BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
3127 uint8_t *buf_old = NULL;
3128 uint8_t *buf_new = NULL;
3129 BlockDriverState *bs = NULL;
3130 char *filename;
3131 const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
3132 int c, flags, src_flags, ret;
3133 bool writethrough, src_writethrough;
3134 int unsafe = 0;
3135 bool force_share = false;
3136 int progress = 0;
3137 bool quiet = false;
3138 Error *local_err = NULL;
3139 bool image_opts = false;
3141 /* Parse commandline parameters */
3142 fmt = NULL;
3143 cache = BDRV_DEFAULT_CACHE;
3144 src_cache = BDRV_DEFAULT_CACHE;
3145 out_baseimg = NULL;
3146 out_basefmt = NULL;
3147 for(;;) {
3148 static const struct option long_options[] = {
3149 {"help", no_argument, 0, 'h'},
3150 {"object", required_argument, 0, OPTION_OBJECT},
3151 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3152 {"force-share", no_argument, 0, 'U'},
3153 {0, 0, 0, 0}
3155 c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU",
3156 long_options, NULL);
3157 if (c == -1) {
3158 break;
3160 switch(c) {
3161 case ':':
3162 missing_argument(argv[optind - 1]);
3163 break;
3164 case '?':
3165 unrecognized_option(argv[optind - 1]);
3166 break;
3167 case 'h':
3168 help();
3169 return 0;
3170 case 'f':
3171 fmt = optarg;
3172 break;
3173 case 'F':
3174 out_basefmt = optarg;
3175 break;
3176 case 'b':
3177 out_baseimg = optarg;
3178 break;
3179 case 'u':
3180 unsafe = 1;
3181 break;
3182 case 'p':
3183 progress = 1;
3184 break;
3185 case 't':
3186 cache = optarg;
3187 break;
3188 case 'T':
3189 src_cache = optarg;
3190 break;
3191 case 'q':
3192 quiet = true;
3193 break;
3194 case OPTION_OBJECT: {
3195 QemuOpts *opts;
3196 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3197 optarg, true);
3198 if (!opts) {
3199 return 1;
3201 } break;
3202 case OPTION_IMAGE_OPTS:
3203 image_opts = true;
3204 break;
3205 case 'U':
3206 force_share = true;
3207 break;
3211 if (quiet) {
3212 progress = 0;
3215 if (optind != argc - 1) {
3216 error_exit("Expecting one image file name");
3218 if (!unsafe && !out_baseimg) {
3219 error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3221 filename = argv[optind++];
3223 if (qemu_opts_foreach(&qemu_object_opts,
3224 user_creatable_add_opts_foreach,
3225 NULL, NULL)) {
3226 return 1;
3229 qemu_progress_init(progress, 2.0);
3230 qemu_progress_print(0, 100);
3232 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
3233 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3234 if (ret < 0) {
3235 error_report("Invalid cache option: %s", cache);
3236 goto out;
3239 src_flags = 0;
3240 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
3241 if (ret < 0) {
3242 error_report("Invalid source cache option: %s", src_cache);
3243 goto out;
3246 /* The source files are opened read-only, don't care about WCE */
3247 assert((src_flags & BDRV_O_RDWR) == 0);
3248 (void) src_writethrough;
3251 * Open the images.
3253 * Ignore the old backing file for unsafe rebase in case we want to correct
3254 * the reference to a renamed or moved backing file.
3256 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3257 false);
3258 if (!blk) {
3259 ret = -1;
3260 goto out;
3262 bs = blk_bs(blk);
3264 if (out_basefmt != NULL) {
3265 if (bdrv_find_format(out_basefmt) == NULL) {
3266 error_report("Invalid format name: '%s'", out_basefmt);
3267 ret = -1;
3268 goto out;
3272 /* For safe rebasing we need to compare old and new backing file */
3273 if (!unsafe) {
3274 char backing_name[PATH_MAX];
3275 QDict *options = NULL;
3277 if (bs->backing_format[0] != '\0') {
3278 options = qdict_new();
3279 qdict_put_str(options, "driver", bs->backing_format);
3282 if (force_share) {
3283 if (!options) {
3284 options = qdict_new();
3286 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3288 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3289 blk_old_backing = blk_new_open(backing_name, NULL,
3290 options, src_flags, &local_err);
3291 if (!blk_old_backing) {
3292 error_reportf_err(local_err,
3293 "Could not open old backing file '%s': ",
3294 backing_name);
3295 ret = -1;
3296 goto out;
3299 if (out_baseimg[0]) {
3300 const char *overlay_filename;
3301 char *out_real_path;
3303 options = qdict_new();
3304 if (out_basefmt) {
3305 qdict_put_str(options, "driver", out_basefmt);
3307 if (force_share) {
3308 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3311 overlay_filename = bs->exact_filename[0] ? bs->exact_filename
3312 : bs->filename;
3313 out_real_path = g_malloc(PATH_MAX);
3315 bdrv_get_full_backing_filename_from_filename(overlay_filename,
3316 out_baseimg,
3317 out_real_path,
3318 PATH_MAX,
3319 &local_err);
3320 if (local_err) {
3321 error_reportf_err(local_err,
3322 "Could not resolve backing filename: ");
3323 ret = -1;
3324 g_free(out_real_path);
3325 goto out;
3328 blk_new_backing = blk_new_open(out_real_path, NULL,
3329 options, src_flags, &local_err);
3330 g_free(out_real_path);
3331 if (!blk_new_backing) {
3332 error_reportf_err(local_err,
3333 "Could not open new backing file '%s': ",
3334 out_baseimg);
3335 ret = -1;
3336 goto out;
3342 * Check each unallocated cluster in the COW file. If it is unallocated,
3343 * accesses go to the backing file. We must therefore compare this cluster
3344 * in the old and new backing file, and if they differ we need to copy it
3345 * from the old backing file into the COW file.
3347 * If qemu-img crashes during this step, no harm is done. The content of
3348 * the image is the same as the original one at any time.
3350 if (!unsafe) {
3351 int64_t size;
3352 int64_t old_backing_size;
3353 int64_t new_backing_size = 0;
3354 uint64_t offset;
3355 int64_t n;
3356 float local_progress = 0;
3358 buf_old = blk_blockalign(blk, IO_BUF_SIZE);
3359 buf_new = blk_blockalign(blk, IO_BUF_SIZE);
3361 size = blk_getlength(blk);
3362 if (size < 0) {
3363 error_report("Could not get size of '%s': %s",
3364 filename, strerror(-size));
3365 ret = -1;
3366 goto out;
3368 old_backing_size = blk_getlength(blk_old_backing);
3369 if (old_backing_size < 0) {
3370 char backing_name[PATH_MAX];
3372 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
3373 error_report("Could not get size of '%s': %s",
3374 backing_name, strerror(-old_backing_size));
3375 ret = -1;
3376 goto out;
3378 if (blk_new_backing) {
3379 new_backing_size = blk_getlength(blk_new_backing);
3380 if (new_backing_size < 0) {
3381 error_report("Could not get size of '%s': %s",
3382 out_baseimg, strerror(-new_backing_size));
3383 ret = -1;
3384 goto out;
3388 if (size != 0) {
3389 local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE));
3392 for (offset = 0; offset < size; offset += n) {
3393 /* How many bytes can we handle with the next read? */
3394 n = MIN(IO_BUF_SIZE, size - offset);
3396 /* If the cluster is allocated, we don't need to take action */
3397 ret = bdrv_is_allocated(bs, offset, n, &n);
3398 if (ret < 0) {
3399 error_report("error while reading image metadata: %s",
3400 strerror(-ret));
3401 goto out;
3403 if (ret) {
3404 continue;
3408 * Read old and new backing file and take into consideration that
3409 * backing files may be smaller than the COW image.
3411 if (offset >= old_backing_size) {
3412 memset(buf_old, 0, n);
3413 } else {
3414 if (offset + n > old_backing_size) {
3415 n = old_backing_size - offset;
3418 ret = blk_pread(blk_old_backing, offset, buf_old, n);
3419 if (ret < 0) {
3420 error_report("error while reading from old backing file");
3421 goto out;
3425 if (offset >= new_backing_size || !blk_new_backing) {
3426 memset(buf_new, 0, n);
3427 } else {
3428 if (offset + n > new_backing_size) {
3429 n = new_backing_size - offset;
3432 ret = blk_pread(blk_new_backing, offset, buf_new, n);
3433 if (ret < 0) {
3434 error_report("error while reading from new backing file");
3435 goto out;
3439 /* If they differ, we need to write to the COW file */
3440 uint64_t written = 0;
3442 while (written < n) {
3443 int64_t pnum;
3445 if (compare_buffers(buf_old + written, buf_new + written,
3446 n - written, &pnum))
3448 ret = blk_pwrite(blk, offset + written,
3449 buf_old + written, pnum, 0);
3450 if (ret < 0) {
3451 error_report("Error while writing to COW image: %s",
3452 strerror(-ret));
3453 goto out;
3457 written += pnum;
3459 qemu_progress_print(local_progress, 100);
3464 * Change the backing file. All clusters that are different from the old
3465 * backing file are overwritten in the COW file now, so the visible content
3466 * doesn't change when we switch the backing file.
3468 if (out_baseimg && *out_baseimg) {
3469 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3470 } else {
3471 ret = bdrv_change_backing_file(bs, NULL, NULL);
3474 if (ret == -ENOSPC) {
3475 error_report("Could not change the backing file to '%s': No "
3476 "space left in the file header", out_baseimg);
3477 } else if (ret < 0) {
3478 error_report("Could not change the backing file to '%s': %s",
3479 out_baseimg, strerror(-ret));
3482 qemu_progress_print(100, 0);
3484 * TODO At this point it is possible to check if any clusters that are
3485 * allocated in the COW file are the same in the backing file. If so, they
3486 * could be dropped from the COW file. Don't do this before switching the
3487 * backing file, in case of a crash this would lead to corruption.
3489 out:
3490 qemu_progress_end();
3491 /* Cleanup */
3492 if (!unsafe) {
3493 blk_unref(blk_old_backing);
3494 blk_unref(blk_new_backing);
3496 qemu_vfree(buf_old);
3497 qemu_vfree(buf_new);
3499 blk_unref(blk);
3500 if (ret) {
3501 return 1;
3503 return 0;
3506 static int img_resize(int argc, char **argv)
3508 Error *err = NULL;
3509 int c, ret, relative;
3510 const char *filename, *fmt, *size;
3511 int64_t n, total_size, current_size, new_size;
3512 bool quiet = false;
3513 BlockBackend *blk = NULL;
3514 PreallocMode prealloc = PREALLOC_MODE_OFF;
3515 QemuOpts *param;
3517 static QemuOptsList resize_options = {
3518 .name = "resize_options",
3519 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3520 .desc = {
3522 .name = BLOCK_OPT_SIZE,
3523 .type = QEMU_OPT_SIZE,
3524 .help = "Virtual disk size"
3525 }, {
3526 /* end of list */
3530 bool image_opts = false;
3531 bool shrink = false;
3533 /* Remove size from argv manually so that negative numbers are not treated
3534 * as options by getopt. */
3535 if (argc < 3) {
3536 error_exit("Not enough arguments");
3537 return 1;
3540 size = argv[--argc];
3542 /* Parse getopt arguments */
3543 fmt = NULL;
3544 for(;;) {
3545 static const struct option long_options[] = {
3546 {"help", no_argument, 0, 'h'},
3547 {"object", required_argument, 0, OPTION_OBJECT},
3548 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3549 {"preallocation", required_argument, 0, OPTION_PREALLOCATION},
3550 {"shrink", no_argument, 0, OPTION_SHRINK},
3551 {0, 0, 0, 0}
3553 c = getopt_long(argc, argv, ":f:hq",
3554 long_options, NULL);
3555 if (c == -1) {
3556 break;
3558 switch(c) {
3559 case ':':
3560 missing_argument(argv[optind - 1]);
3561 break;
3562 case '?':
3563 unrecognized_option(argv[optind - 1]);
3564 break;
3565 case 'h':
3566 help();
3567 break;
3568 case 'f':
3569 fmt = optarg;
3570 break;
3571 case 'q':
3572 quiet = true;
3573 break;
3574 case OPTION_OBJECT: {
3575 QemuOpts *opts;
3576 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3577 optarg, true);
3578 if (!opts) {
3579 return 1;
3581 } break;
3582 case OPTION_IMAGE_OPTS:
3583 image_opts = true;
3584 break;
3585 case OPTION_PREALLOCATION:
3586 prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg,
3587 PREALLOC_MODE__MAX, NULL);
3588 if (prealloc == PREALLOC_MODE__MAX) {
3589 error_report("Invalid preallocation mode '%s'", optarg);
3590 return 1;
3592 break;
3593 case OPTION_SHRINK:
3594 shrink = true;
3595 break;
3598 if (optind != argc - 1) {
3599 error_exit("Expecting image file name and size");
3601 filename = argv[optind++];
3603 if (qemu_opts_foreach(&qemu_object_opts,
3604 user_creatable_add_opts_foreach,
3605 NULL, NULL)) {
3606 return 1;
3609 /* Choose grow, shrink, or absolute resize mode */
3610 switch (size[0]) {
3611 case '+':
3612 relative = 1;
3613 size++;
3614 break;
3615 case '-':
3616 relative = -1;
3617 size++;
3618 break;
3619 default:
3620 relative = 0;
3621 break;
3624 /* Parse size */
3625 param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3626 qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3627 if (err) {
3628 error_report_err(err);
3629 ret = -1;
3630 qemu_opts_del(param);
3631 goto out;
3633 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3634 qemu_opts_del(param);
3636 blk = img_open(image_opts, filename, fmt,
3637 BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet,
3638 false);
3639 if (!blk) {
3640 ret = -1;
3641 goto out;
3644 current_size = blk_getlength(blk);
3645 if (current_size < 0) {
3646 error_report("Failed to inquire current image length: %s",
3647 strerror(-current_size));
3648 ret = -1;
3649 goto out;
3652 if (relative) {
3653 total_size = current_size + n * relative;
3654 } else {
3655 total_size = n;
3657 if (total_size <= 0) {
3658 error_report("New image size must be positive");
3659 ret = -1;
3660 goto out;
3663 if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) {
3664 error_report("Preallocation can only be used for growing images");
3665 ret = -1;
3666 goto out;
3669 if (total_size < current_size && !shrink) {
3670 warn_report("Shrinking an image will delete all data beyond the "
3671 "shrunken image's end. Before performing such an "
3672 "operation, make sure there is no important data there.");
3674 if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) {
3675 error_report(
3676 "Use the --shrink option to perform a shrink operation.");
3677 ret = -1;
3678 goto out;
3679 } else {
3680 warn_report("Using the --shrink option will suppress this message. "
3681 "Note that future versions of qemu-img may refuse to "
3682 "shrink images without this option.");
3686 ret = blk_truncate(blk, total_size, prealloc, &err);
3687 if (ret < 0) {
3688 error_report_err(err);
3689 goto out;
3692 new_size = blk_getlength(blk);
3693 if (new_size < 0) {
3694 error_report("Failed to verify truncated image length: %s",
3695 strerror(-new_size));
3696 ret = -1;
3697 goto out;
3700 /* Some block drivers implement a truncation method, but only so
3701 * the user can cause qemu to refresh the image's size from disk.
3702 * The idea is that the user resizes the image outside of qemu and
3703 * then invokes block_resize to inform qemu about it.
3704 * (This includes iscsi and file-posix for device files.)
3705 * Of course, that is not the behavior someone invoking
3706 * qemu-img resize would find useful, so we catch that behavior
3707 * here and tell the user. */
3708 if (new_size != total_size && new_size == current_size) {
3709 error_report("Image was not resized; resizing may not be supported "
3710 "for this image");
3711 ret = -1;
3712 goto out;
3715 if (new_size != total_size) {
3716 warn_report("Image should have been resized to %" PRIi64
3717 " bytes, but was resized to %" PRIi64 " bytes",
3718 total_size, new_size);
3721 qprintf(quiet, "Image resized.\n");
3723 out:
3724 blk_unref(blk);
3725 if (ret) {
3726 return 1;
3728 return 0;
3731 static void amend_status_cb(BlockDriverState *bs,
3732 int64_t offset, int64_t total_work_size,
3733 void *opaque)
3735 qemu_progress_print(100.f * offset / total_work_size, 0);
3738 static int print_amend_option_help(const char *format)
3740 BlockDriver *drv;
3742 /* Find driver and parse its options */
3743 drv = bdrv_find_format(format);
3744 if (!drv) {
3745 error_report("Unknown file format '%s'", format);
3746 return 1;
3749 if (!drv->bdrv_amend_options) {
3750 error_report("Format driver '%s' does not support option amendment",
3751 format);
3752 return 1;
3755 /* Every driver supporting amendment must have create_opts */
3756 assert(drv->create_opts);
3758 printf("Creation options for '%s':\n", format);
3759 qemu_opts_print_help(drv->create_opts);
3760 printf("\nNote that not all of these options may be amendable.\n");
3761 return 0;
3764 static int img_amend(int argc, char **argv)
3766 Error *err = NULL;
3767 int c, ret = 0;
3768 char *options = NULL;
3769 QemuOptsList *create_opts = NULL;
3770 QemuOpts *opts = NULL;
3771 const char *fmt = NULL, *filename, *cache;
3772 int flags;
3773 bool writethrough;
3774 bool quiet = false, progress = false;
3775 BlockBackend *blk = NULL;
3776 BlockDriverState *bs = NULL;
3777 bool image_opts = false;
3779 cache = BDRV_DEFAULT_CACHE;
3780 for (;;) {
3781 static const struct option long_options[] = {
3782 {"help", no_argument, 0, 'h'},
3783 {"object", required_argument, 0, OPTION_OBJECT},
3784 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3785 {0, 0, 0, 0}
3787 c = getopt_long(argc, argv, ":ho:f:t:pq",
3788 long_options, NULL);
3789 if (c == -1) {
3790 break;
3793 switch (c) {
3794 case ':':
3795 missing_argument(argv[optind - 1]);
3796 break;
3797 case '?':
3798 unrecognized_option(argv[optind - 1]);
3799 break;
3800 case 'h':
3801 help();
3802 break;
3803 case 'o':
3804 if (!is_valid_option_list(optarg)) {
3805 error_report("Invalid option list: %s", optarg);
3806 ret = -1;
3807 goto out_no_progress;
3809 if (!options) {
3810 options = g_strdup(optarg);
3811 } else {
3812 char *old_options = options;
3813 options = g_strdup_printf("%s,%s", options, optarg);
3814 g_free(old_options);
3816 break;
3817 case 'f':
3818 fmt = optarg;
3819 break;
3820 case 't':
3821 cache = optarg;
3822 break;
3823 case 'p':
3824 progress = true;
3825 break;
3826 case 'q':
3827 quiet = true;
3828 break;
3829 case OPTION_OBJECT:
3830 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3831 optarg, true);
3832 if (!opts) {
3833 ret = -1;
3834 goto out_no_progress;
3836 break;
3837 case OPTION_IMAGE_OPTS:
3838 image_opts = true;
3839 break;
3843 if (!options) {
3844 error_exit("Must specify options (-o)");
3847 if (qemu_opts_foreach(&qemu_object_opts,
3848 user_creatable_add_opts_foreach,
3849 NULL, NULL)) {
3850 ret = -1;
3851 goto out_no_progress;
3854 if (quiet) {
3855 progress = false;
3857 qemu_progress_init(progress, 1.0);
3859 filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3860 if (fmt && has_help_option(options)) {
3861 /* If a format is explicitly specified (and possibly no filename is
3862 * given), print option help here */
3863 ret = print_amend_option_help(fmt);
3864 goto out;
3867 if (optind != argc - 1) {
3868 error_report("Expecting one image file name");
3869 ret = -1;
3870 goto out;
3873 flags = BDRV_O_RDWR;
3874 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3875 if (ret < 0) {
3876 error_report("Invalid cache option: %s", cache);
3877 goto out;
3880 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3881 false);
3882 if (!blk) {
3883 ret = -1;
3884 goto out;
3886 bs = blk_bs(blk);
3888 fmt = bs->drv->format_name;
3890 if (has_help_option(options)) {
3891 /* If the format was auto-detected, print option help here */
3892 ret = print_amend_option_help(fmt);
3893 goto out;
3896 if (!bs->drv->bdrv_amend_options) {
3897 error_report("Format driver '%s' does not support option amendment",
3898 fmt);
3899 ret = -1;
3900 goto out;
3903 /* Every driver supporting amendment must have create_opts */
3904 assert(bs->drv->create_opts);
3906 create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
3907 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3908 qemu_opts_do_parse(opts, options, NULL, &err);
3909 if (err) {
3910 error_report_err(err);
3911 ret = -1;
3912 goto out;
3915 /* In case the driver does not call amend_status_cb() */
3916 qemu_progress_print(0.f, 0);
3917 ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err);
3918 qemu_progress_print(100.f, 0);
3919 if (ret < 0) {
3920 error_report_err(err);
3921 goto out;
3924 out:
3925 qemu_progress_end();
3927 out_no_progress:
3928 blk_unref(blk);
3929 qemu_opts_del(opts);
3930 qemu_opts_free(create_opts);
3931 g_free(options);
3933 if (ret) {
3934 return 1;
3936 return 0;
3939 typedef struct BenchData {
3940 BlockBackend *blk;
3941 uint64_t image_size;
3942 bool write;
3943 int bufsize;
3944 int step;
3945 int nrreq;
3946 int n;
3947 int flush_interval;
3948 bool drain_on_flush;
3949 uint8_t *buf;
3950 QEMUIOVector *qiov;
3952 int in_flight;
3953 bool in_flush;
3954 uint64_t offset;
3955 } BenchData;
3957 static void bench_undrained_flush_cb(void *opaque, int ret)
3959 if (ret < 0) {
3960 error_report("Failed flush request: %s", strerror(-ret));
3961 exit(EXIT_FAILURE);
3965 static void bench_cb(void *opaque, int ret)
3967 BenchData *b = opaque;
3968 BlockAIOCB *acb;
3970 if (ret < 0) {
3971 error_report("Failed request: %s", strerror(-ret));
3972 exit(EXIT_FAILURE);
3975 if (b->in_flush) {
3976 /* Just finished a flush with drained queue: Start next requests */
3977 assert(b->in_flight == 0);
3978 b->in_flush = false;
3979 } else if (b->in_flight > 0) {
3980 int remaining = b->n - b->in_flight;
3982 b->n--;
3983 b->in_flight--;
3985 /* Time for flush? Drain queue if requested, then flush */
3986 if (b->flush_interval && remaining % b->flush_interval == 0) {
3987 if (!b->in_flight || !b->drain_on_flush) {
3988 BlockCompletionFunc *cb;
3990 if (b->drain_on_flush) {
3991 b->in_flush = true;
3992 cb = bench_cb;
3993 } else {
3994 cb = bench_undrained_flush_cb;
3997 acb = blk_aio_flush(b->blk, cb, b);
3998 if (!acb) {
3999 error_report("Failed to issue flush request");
4000 exit(EXIT_FAILURE);
4003 if (b->drain_on_flush) {
4004 return;
4009 while (b->n > b->in_flight && b->in_flight < b->nrreq) {
4010 int64_t offset = b->offset;
4011 /* blk_aio_* might look for completed I/Os and kick bench_cb
4012 * again, so make sure this operation is counted by in_flight
4013 * and b->offset is ready for the next submission.
4015 b->in_flight++;
4016 b->offset += b->step;
4017 b->offset %= b->image_size;
4018 if (b->write) {
4019 acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b);
4020 } else {
4021 acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b);
4023 if (!acb) {
4024 error_report("Failed to issue request");
4025 exit(EXIT_FAILURE);
4030 static int img_bench(int argc, char **argv)
4032 int c, ret = 0;
4033 const char *fmt = NULL, *filename;
4034 bool quiet = false;
4035 bool image_opts = false;
4036 bool is_write = false;
4037 int count = 75000;
4038 int depth = 64;
4039 int64_t offset = 0;
4040 size_t bufsize = 4096;
4041 int pattern = 0;
4042 size_t step = 0;
4043 int flush_interval = 0;
4044 bool drain_on_flush = true;
4045 int64_t image_size;
4046 BlockBackend *blk = NULL;
4047 BenchData data = {};
4048 int flags = 0;
4049 bool writethrough = false;
4050 struct timeval t1, t2;
4051 int i;
4052 bool force_share = false;
4053 size_t buf_size;
4055 for (;;) {
4056 static const struct option long_options[] = {
4057 {"help", no_argument, 0, 'h'},
4058 {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
4059 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4060 {"pattern", required_argument, 0, OPTION_PATTERN},
4061 {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
4062 {"force-share", no_argument, 0, 'U'},
4063 {0, 0, 0, 0}
4065 c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
4066 if (c == -1) {
4067 break;
4070 switch (c) {
4071 case ':':
4072 missing_argument(argv[optind - 1]);
4073 break;
4074 case '?':
4075 unrecognized_option(argv[optind - 1]);
4076 break;
4077 case 'h':
4078 help();
4079 break;
4080 case 'c':
4082 unsigned long res;
4084 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4085 error_report("Invalid request count specified");
4086 return 1;
4088 count = res;
4089 break;
4091 case 'd':
4093 unsigned long res;
4095 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4096 error_report("Invalid queue depth specified");
4097 return 1;
4099 depth = res;
4100 break;
4102 case 'f':
4103 fmt = optarg;
4104 break;
4105 case 'n':
4106 flags |= BDRV_O_NATIVE_AIO;
4107 break;
4108 case 'o':
4110 offset = cvtnum(optarg);
4111 if (offset < 0) {
4112 error_report("Invalid offset specified");
4113 return 1;
4115 break;
4117 break;
4118 case 'q':
4119 quiet = true;
4120 break;
4121 case 's':
4123 int64_t sval;
4125 sval = cvtnum(optarg);
4126 if (sval < 0 || sval > INT_MAX) {
4127 error_report("Invalid buffer size specified");
4128 return 1;
4131 bufsize = sval;
4132 break;
4134 case 'S':
4136 int64_t sval;
4138 sval = cvtnum(optarg);
4139 if (sval < 0 || sval > INT_MAX) {
4140 error_report("Invalid step size specified");
4141 return 1;
4144 step = sval;
4145 break;
4147 case 't':
4148 ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
4149 if (ret < 0) {
4150 error_report("Invalid cache mode");
4151 ret = -1;
4152 goto out;
4154 break;
4155 case 'w':
4156 flags |= BDRV_O_RDWR;
4157 is_write = true;
4158 break;
4159 case 'U':
4160 force_share = true;
4161 break;
4162 case OPTION_PATTERN:
4164 unsigned long res;
4166 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
4167 error_report("Invalid pattern byte specified");
4168 return 1;
4170 pattern = res;
4171 break;
4173 case OPTION_FLUSH_INTERVAL:
4175 unsigned long res;
4177 if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4178 error_report("Invalid flush interval specified");
4179 return 1;
4181 flush_interval = res;
4182 break;
4184 case OPTION_NO_DRAIN:
4185 drain_on_flush = false;
4186 break;
4187 case OPTION_IMAGE_OPTS:
4188 image_opts = true;
4189 break;
4193 if (optind != argc - 1) {
4194 error_exit("Expecting one image file name");
4196 filename = argv[argc - 1];
4198 if (!is_write && flush_interval) {
4199 error_report("--flush-interval is only available in write tests");
4200 ret = -1;
4201 goto out;
4203 if (flush_interval && flush_interval < depth) {
4204 error_report("Flush interval can't be smaller than depth");
4205 ret = -1;
4206 goto out;
4209 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4210 force_share);
4211 if (!blk) {
4212 ret = -1;
4213 goto out;
4216 image_size = blk_getlength(blk);
4217 if (image_size < 0) {
4218 ret = image_size;
4219 goto out;
4222 data = (BenchData) {
4223 .blk = blk,
4224 .image_size = image_size,
4225 .bufsize = bufsize,
4226 .step = step ?: bufsize,
4227 .nrreq = depth,
4228 .n = count,
4229 .offset = offset,
4230 .write = is_write,
4231 .flush_interval = flush_interval,
4232 .drain_on_flush = drain_on_flush,
4234 printf("Sending %d %s requests, %d bytes each, %d in parallel "
4235 "(starting at offset %" PRId64 ", step size %d)\n",
4236 data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
4237 data.offset, data.step);
4238 if (flush_interval) {
4239 printf("Sending flush every %d requests\n", flush_interval);
4242 buf_size = data.nrreq * data.bufsize;
4243 data.buf = blk_blockalign(blk, buf_size);
4244 memset(data.buf, pattern, data.nrreq * data.bufsize);
4246 blk_register_buf(blk, data.buf, buf_size);
4248 data.qiov = g_new(QEMUIOVector, data.nrreq);
4249 for (i = 0; i < data.nrreq; i++) {
4250 qemu_iovec_init(&data.qiov[i], 1);
4251 qemu_iovec_add(&data.qiov[i],
4252 data.buf + i * data.bufsize, data.bufsize);
4255 gettimeofday(&t1, NULL);
4256 bench_cb(&data, 0);
4258 while (data.n > 0) {
4259 main_loop_wait(false);
4261 gettimeofday(&t2, NULL);
4263 printf("Run completed in %3.3f seconds.\n",
4264 (t2.tv_sec - t1.tv_sec)
4265 + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
4267 out:
4268 if (data.buf) {
4269 blk_unregister_buf(blk, data.buf);
4271 qemu_vfree(data.buf);
4272 blk_unref(blk);
4274 if (ret) {
4275 return 1;
4277 return 0;
4280 #define C_BS 01
4281 #define C_COUNT 02
4282 #define C_IF 04
4283 #define C_OF 010
4284 #define C_SKIP 020
4286 struct DdInfo {
4287 unsigned int flags;
4288 int64_t count;
4291 struct DdIo {
4292 int bsz; /* Block size */
4293 char *filename;
4294 uint8_t *buf;
4295 int64_t offset;
4298 struct DdOpts {
4299 const char *name;
4300 int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
4301 unsigned int flag;
4304 static int img_dd_bs(const char *arg,
4305 struct DdIo *in, struct DdIo *out,
4306 struct DdInfo *dd)
4308 int64_t res;
4310 res = cvtnum(arg);
4312 if (res <= 0 || res > INT_MAX) {
4313 error_report("invalid number: '%s'", arg);
4314 return 1;
4316 in->bsz = out->bsz = res;
4318 return 0;
4321 static int img_dd_count(const char *arg,
4322 struct DdIo *in, struct DdIo *out,
4323 struct DdInfo *dd)
4325 dd->count = cvtnum(arg);
4327 if (dd->count < 0) {
4328 error_report("invalid number: '%s'", arg);
4329 return 1;
4332 return 0;
4335 static int img_dd_if(const char *arg,
4336 struct DdIo *in, struct DdIo *out,
4337 struct DdInfo *dd)
4339 in->filename = g_strdup(arg);
4341 return 0;
4344 static int img_dd_of(const char *arg,
4345 struct DdIo *in, struct DdIo *out,
4346 struct DdInfo *dd)
4348 out->filename = g_strdup(arg);
4350 return 0;
4353 static int img_dd_skip(const char *arg,
4354 struct DdIo *in, struct DdIo *out,
4355 struct DdInfo *dd)
4357 in->offset = cvtnum(arg);
4359 if (in->offset < 0) {
4360 error_report("invalid number: '%s'", arg);
4361 return 1;
4364 return 0;
4367 static int img_dd(int argc, char **argv)
4369 int ret = 0;
4370 char *arg = NULL;
4371 char *tmp;
4372 BlockDriver *drv = NULL, *proto_drv = NULL;
4373 BlockBackend *blk1 = NULL, *blk2 = NULL;
4374 QemuOpts *opts = NULL;
4375 QemuOptsList *create_opts = NULL;
4376 Error *local_err = NULL;
4377 bool image_opts = false;
4378 int c, i;
4379 const char *out_fmt = "raw";
4380 const char *fmt = NULL;
4381 int64_t size = 0;
4382 int64_t block_count = 0, out_pos, in_pos;
4383 bool force_share = false;
4384 struct DdInfo dd = {
4385 .flags = 0,
4386 .count = 0,
4388 struct DdIo in = {
4389 .bsz = 512, /* Block size is by default 512 bytes */
4390 .filename = NULL,
4391 .buf = NULL,
4392 .offset = 0
4394 struct DdIo out = {
4395 .bsz = 512,
4396 .filename = NULL,
4397 .buf = NULL,
4398 .offset = 0
4401 const struct DdOpts options[] = {
4402 { "bs", img_dd_bs, C_BS },
4403 { "count", img_dd_count, C_COUNT },
4404 { "if", img_dd_if, C_IF },
4405 { "of", img_dd_of, C_OF },
4406 { "skip", img_dd_skip, C_SKIP },
4407 { NULL, NULL, 0 }
4409 const struct option long_options[] = {
4410 { "help", no_argument, 0, 'h'},
4411 { "object", required_argument, 0, OPTION_OBJECT},
4412 { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4413 { "force-share", no_argument, 0, 'U'},
4414 { 0, 0, 0, 0 }
4417 while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) {
4418 if (c == EOF) {
4419 break;
4421 switch (c) {
4422 case 'O':
4423 out_fmt = optarg;
4424 break;
4425 case 'f':
4426 fmt = optarg;
4427 break;
4428 case ':':
4429 missing_argument(argv[optind - 1]);
4430 break;
4431 case '?':
4432 unrecognized_option(argv[optind - 1]);
4433 break;
4434 case 'h':
4435 help();
4436 break;
4437 case 'U':
4438 force_share = true;
4439 break;
4440 case OPTION_OBJECT:
4441 if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) {
4442 ret = -1;
4443 goto out;
4445 break;
4446 case OPTION_IMAGE_OPTS:
4447 image_opts = true;
4448 break;
4452 for (i = optind; i < argc; i++) {
4453 int j;
4454 arg = g_strdup(argv[i]);
4456 tmp = strchr(arg, '=');
4457 if (tmp == NULL) {
4458 error_report("unrecognized operand %s", arg);
4459 ret = -1;
4460 goto out;
4463 *tmp++ = '\0';
4465 for (j = 0; options[j].name != NULL; j++) {
4466 if (!strcmp(arg, options[j].name)) {
4467 break;
4470 if (options[j].name == NULL) {
4471 error_report("unrecognized operand %s", arg);
4472 ret = -1;
4473 goto out;
4476 if (options[j].f(tmp, &in, &out, &dd) != 0) {
4477 ret = -1;
4478 goto out;
4480 dd.flags |= options[j].flag;
4481 g_free(arg);
4482 arg = NULL;
4485 if (!(dd.flags & C_IF && dd.flags & C_OF)) {
4486 error_report("Must specify both input and output files");
4487 ret = -1;
4488 goto out;
4491 if (qemu_opts_foreach(&qemu_object_opts,
4492 user_creatable_add_opts_foreach,
4493 NULL, NULL)) {
4494 ret = -1;
4495 goto out;
4498 blk1 = img_open(image_opts, in.filename, fmt, 0, false, false,
4499 force_share);
4501 if (!blk1) {
4502 ret = -1;
4503 goto out;
4506 drv = bdrv_find_format(out_fmt);
4507 if (!drv) {
4508 error_report("Unknown file format");
4509 ret = -1;
4510 goto out;
4512 proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
4514 if (!proto_drv) {
4515 error_report_err(local_err);
4516 ret = -1;
4517 goto out;
4519 if (!drv->create_opts) {
4520 error_report("Format driver '%s' does not support image creation",
4521 drv->format_name);
4522 ret = -1;
4523 goto out;
4525 if (!proto_drv->create_opts) {
4526 error_report("Protocol driver '%s' does not support image creation",
4527 proto_drv->format_name);
4528 ret = -1;
4529 goto out;
4531 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4532 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4534 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4536 size = blk_getlength(blk1);
4537 if (size < 0) {
4538 error_report("Failed to get size for '%s'", in.filename);
4539 ret = -1;
4540 goto out;
4543 if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz &&
4544 dd.count * in.bsz < size) {
4545 size = dd.count * in.bsz;
4548 /* Overflow means the specified offset is beyond input image's size */
4549 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4550 size < in.bsz * in.offset)) {
4551 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort);
4552 } else {
4553 qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
4554 size - in.bsz * in.offset, &error_abort);
4557 ret = bdrv_create(drv, out.filename, opts, &local_err);
4558 if (ret < 0) {
4559 error_reportf_err(local_err,
4560 "%s: error while creating output image: ",
4561 out.filename);
4562 ret = -1;
4563 goto out;
4566 /* TODO, we can't honour --image-opts for the target,
4567 * since it needs to be given in a format compatible
4568 * with the bdrv_create() call above which does not
4569 * support image-opts style.
4571 blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR,
4572 false, false, false);
4574 if (!blk2) {
4575 ret = -1;
4576 goto out;
4579 if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4580 size < in.offset * in.bsz)) {
4581 /* We give a warning if the skip option is bigger than the input
4582 * size and create an empty output disk image (i.e. like dd(1)).
4584 error_report("%s: cannot skip to specified offset", in.filename);
4585 in_pos = size;
4586 } else {
4587 in_pos = in.offset * in.bsz;
4590 in.buf = g_new(uint8_t, in.bsz);
4592 for (out_pos = 0; in_pos < size; block_count++) {
4593 int in_ret, out_ret;
4595 if (in_pos + in.bsz > size) {
4596 in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
4597 } else {
4598 in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
4600 if (in_ret < 0) {
4601 error_report("error while reading from input image file: %s",
4602 strerror(-in_ret));
4603 ret = -1;
4604 goto out;
4606 in_pos += in_ret;
4608 out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
4610 if (out_ret < 0) {
4611 error_report("error while writing to output image file: %s",
4612 strerror(-out_ret));
4613 ret = -1;
4614 goto out;
4616 out_pos += out_ret;
4619 out:
4620 g_free(arg);
4621 qemu_opts_del(opts);
4622 qemu_opts_free(create_opts);
4623 blk_unref(blk1);
4624 blk_unref(blk2);
4625 g_free(in.filename);
4626 g_free(out.filename);
4627 g_free(in.buf);
4628 g_free(out.buf);
4630 if (ret) {
4631 return 1;
4633 return 0;
4636 static void dump_json_block_measure_info(BlockMeasureInfo *info)
4638 QString *str;
4639 QObject *obj;
4640 Visitor *v = qobject_output_visitor_new(&obj);
4642 visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort);
4643 visit_complete(v, &obj);
4644 str = qobject_to_json_pretty(obj);
4645 assert(str != NULL);
4646 printf("%s\n", qstring_get_str(str));
4647 qobject_unref(obj);
4648 visit_free(v);
4649 qobject_unref(str);
4652 static int img_measure(int argc, char **argv)
4654 static const struct option long_options[] = {
4655 {"help", no_argument, 0, 'h'},
4656 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4657 {"object", required_argument, 0, OPTION_OBJECT},
4658 {"output", required_argument, 0, OPTION_OUTPUT},
4659 {"size", required_argument, 0, OPTION_SIZE},
4660 {"force-share", no_argument, 0, 'U'},
4661 {0, 0, 0, 0}
4663 OutputFormat output_format = OFORMAT_HUMAN;
4664 BlockBackend *in_blk = NULL;
4665 BlockDriver *drv;
4666 const char *filename = NULL;
4667 const char *fmt = NULL;
4668 const char *out_fmt = "raw";
4669 char *options = NULL;
4670 char *snapshot_name = NULL;
4671 bool force_share = false;
4672 QemuOpts *opts = NULL;
4673 QemuOpts *object_opts = NULL;
4674 QemuOpts *sn_opts = NULL;
4675 QemuOptsList *create_opts = NULL;
4676 bool image_opts = false;
4677 uint64_t img_size = UINT64_MAX;
4678 BlockMeasureInfo *info = NULL;
4679 Error *local_err = NULL;
4680 int ret = 1;
4681 int c;
4683 while ((c = getopt_long(argc, argv, "hf:O:o:l:U",
4684 long_options, NULL)) != -1) {
4685 switch (c) {
4686 case '?':
4687 case 'h':
4688 help();
4689 break;
4690 case 'f':
4691 fmt = optarg;
4692 break;
4693 case 'O':
4694 out_fmt = optarg;
4695 break;
4696 case 'o':
4697 if (!is_valid_option_list(optarg)) {
4698 error_report("Invalid option list: %s", optarg);
4699 goto out;
4701 if (!options) {
4702 options = g_strdup(optarg);
4703 } else {
4704 char *old_options = options;
4705 options = g_strdup_printf("%s,%s", options, optarg);
4706 g_free(old_options);
4708 break;
4709 case 'l':
4710 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
4711 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
4712 optarg, false);
4713 if (!sn_opts) {
4714 error_report("Failed in parsing snapshot param '%s'",
4715 optarg);
4716 goto out;
4718 } else {
4719 snapshot_name = optarg;
4721 break;
4722 case 'U':
4723 force_share = true;
4724 break;
4725 case OPTION_OBJECT:
4726 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
4727 optarg, true);
4728 if (!object_opts) {
4729 goto out;
4731 break;
4732 case OPTION_IMAGE_OPTS:
4733 image_opts = true;
4734 break;
4735 case OPTION_OUTPUT:
4736 if (!strcmp(optarg, "json")) {
4737 output_format = OFORMAT_JSON;
4738 } else if (!strcmp(optarg, "human")) {
4739 output_format = OFORMAT_HUMAN;
4740 } else {
4741 error_report("--output must be used with human or json "
4742 "as argument.");
4743 goto out;
4745 break;
4746 case OPTION_SIZE:
4748 int64_t sval;
4750 sval = cvtnum(optarg);
4751 if (sval < 0) {
4752 if (sval == -ERANGE) {
4753 error_report("Image size must be less than 8 EiB!");
4754 } else {
4755 error_report("Invalid image size specified! You may use "
4756 "k, M, G, T, P or E suffixes for ");
4757 error_report("kilobytes, megabytes, gigabytes, terabytes, "
4758 "petabytes and exabytes.");
4760 goto out;
4762 img_size = (uint64_t)sval;
4764 break;
4768 if (qemu_opts_foreach(&qemu_object_opts,
4769 user_creatable_add_opts_foreach,
4770 NULL, NULL)) {
4771 goto out;
4774 if (argc - optind > 1) {
4775 error_report("At most one filename argument is allowed.");
4776 goto out;
4777 } else if (argc - optind == 1) {
4778 filename = argv[optind];
4781 if (!filename &&
4782 (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
4783 error_report("--object, --image-opts, -f, and -l "
4784 "require a filename argument.");
4785 goto out;
4787 if (filename && img_size != UINT64_MAX) {
4788 error_report("--size N cannot be used together with a filename.");
4789 goto out;
4791 if (!filename && img_size == UINT64_MAX) {
4792 error_report("Either --size N or one filename must be specified.");
4793 goto out;
4796 if (filename) {
4797 in_blk = img_open(image_opts, filename, fmt, 0,
4798 false, false, force_share);
4799 if (!in_blk) {
4800 goto out;
4803 if (sn_opts) {
4804 bdrv_snapshot_load_tmp(blk_bs(in_blk),
4805 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
4806 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
4807 &local_err);
4808 } else if (snapshot_name != NULL) {
4809 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk),
4810 snapshot_name, &local_err);
4812 if (local_err) {
4813 error_reportf_err(local_err, "Failed to load snapshot: ");
4814 goto out;
4818 drv = bdrv_find_format(out_fmt);
4819 if (!drv) {
4820 error_report("Unknown file format '%s'", out_fmt);
4821 goto out;
4823 if (!drv->create_opts) {
4824 error_report("Format driver '%s' does not support image creation",
4825 drv->format_name);
4826 goto out;
4829 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4830 create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
4831 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4832 if (options) {
4833 qemu_opts_do_parse(opts, options, NULL, &local_err);
4834 if (local_err) {
4835 error_report_err(local_err);
4836 error_report("Invalid options for file format '%s'", out_fmt);
4837 goto out;
4840 if (img_size != UINT64_MAX) {
4841 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4844 info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err);
4845 if (local_err) {
4846 error_report_err(local_err);
4847 goto out;
4850 if (output_format == OFORMAT_HUMAN) {
4851 printf("required size: %" PRIu64 "\n", info->required);
4852 printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated);
4853 } else {
4854 dump_json_block_measure_info(info);
4857 ret = 0;
4859 out:
4860 qapi_free_BlockMeasureInfo(info);
4861 qemu_opts_del(object_opts);
4862 qemu_opts_del(opts);
4863 qemu_opts_del(sn_opts);
4864 qemu_opts_free(create_opts);
4865 g_free(options);
4866 blk_unref(in_blk);
4867 return ret;
4870 static const img_cmd_t img_cmds[] = {
4871 #define DEF(option, callback, arg_string) \
4872 { option, callback },
4873 #include "qemu-img-cmds.h"
4874 #undef DEF
4875 { NULL, NULL, },
4878 int main(int argc, char **argv)
4880 const img_cmd_t *cmd;
4881 const char *cmdname;
4882 Error *local_error = NULL;
4883 char *trace_file = NULL;
4884 int c;
4885 static const struct option long_options[] = {
4886 {"help", no_argument, 0, 'h'},
4887 {"version", no_argument, 0, 'V'},
4888 {"trace", required_argument, NULL, 'T'},
4889 {0, 0, 0, 0}
4892 #ifdef CONFIG_POSIX
4893 signal(SIGPIPE, SIG_IGN);
4894 #endif
4896 module_call_init(MODULE_INIT_TRACE);
4897 error_set_progname(argv[0]);
4898 qemu_init_exec_dir(argv[0]);
4900 if (qemu_init_main_loop(&local_error)) {
4901 error_report_err(local_error);
4902 exit(EXIT_FAILURE);
4905 qcrypto_init(&error_fatal);
4907 module_call_init(MODULE_INIT_QOM);
4908 bdrv_init();
4909 if (argc < 2) {
4910 error_exit("Not enough arguments");
4913 qemu_add_opts(&qemu_object_opts);
4914 qemu_add_opts(&qemu_source_opts);
4915 qemu_add_opts(&qemu_trace_opts);
4917 while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) {
4918 switch (c) {
4919 case ':':
4920 missing_argument(argv[optind - 1]);
4921 return 0;
4922 case '?':
4923 unrecognized_option(argv[optind - 1]);
4924 return 0;
4925 case 'h':
4926 help();
4927 return 0;
4928 case 'V':
4929 printf(QEMU_IMG_VERSION);
4930 return 0;
4931 case 'T':
4932 g_free(trace_file);
4933 trace_file = trace_opt_parse(optarg);
4934 break;
4938 cmdname = argv[optind];
4940 /* reset getopt_long scanning */
4941 argc -= optind;
4942 if (argc < 1) {
4943 return 0;
4945 argv += optind;
4946 optind = 0;
4948 if (!trace_init_backends()) {
4949 exit(1);
4951 trace_init_file(trace_file);
4952 qemu_set_log(LOG_TRACE);
4954 /* find the command */
4955 for (cmd = img_cmds; cmd->name != NULL; cmd++) {
4956 if (!strcmp(cmdname, cmd->name)) {
4957 return cmd->handler(argc, argv);
4961 /* not found */
4962 error_exit("Command not found: %s", cmdname);