Merge remote-tracking branch 'remotes/kraxel/tags/seabios-20200702-pull-request'...
[qemu.git] / qemu-img.c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
24
25 #include "qemu/osdep.h"
26 #include <getopt.h>
27
28 #include "qemu-common.h"
29 #include "qemu-version.h"
30 #include "qapi/error.h"
31 #include "qapi/qapi-commands-block-core.h"
32 #include "qapi/qapi-visit-block-core.h"
33 #include "qapi/qobject-output-visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
37 #include "qemu/cutils.h"
38 #include "qemu/config-file.h"
39 #include "qemu/option.h"
40 #include "qemu/error-report.h"
41 #include "qemu/log.h"
42 #include "qemu/main-loop.h"
43 #include "qemu/module.h"
44 #include "qemu/units.h"
45 #include "qom/object_interfaces.h"
46 #include "sysemu/block-backend.h"
47 #include "block/block_int.h"
48 #include "block/blockjob.h"
49 #include "block/qapi.h"
50 #include "crypto/init.h"
51 #include "trace/control.h"
52
53 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \
54 "\n" QEMU_COPYRIGHT "\n"
55
56 typedef struct img_cmd_t {
57 const char *name;
58 int (*handler)(int argc, char **argv);
59 } img_cmd_t;
60
61 enum {
62 OPTION_OUTPUT = 256,
63 OPTION_BACKING_CHAIN = 257,
64 OPTION_OBJECT = 258,
65 OPTION_IMAGE_OPTS = 259,
66 OPTION_PATTERN = 260,
67 OPTION_FLUSH_INTERVAL = 261,
68 OPTION_NO_DRAIN = 262,
69 OPTION_TARGET_IMAGE_OPTS = 263,
70 OPTION_SIZE = 264,
71 OPTION_PREALLOCATION = 265,
72 OPTION_SHRINK = 266,
73 OPTION_SALVAGE = 267,
74 OPTION_TARGET_IS_ZERO = 268,
75 OPTION_ADD = 269,
76 OPTION_REMOVE = 270,
77 OPTION_CLEAR = 271,
78 OPTION_ENABLE = 272,
79 OPTION_DISABLE = 273,
80 OPTION_MERGE = 274,
81 OPTION_BITMAPS = 275,
82 };
83
84 typedef enum OutputFormat {
85 OFORMAT_JSON,
86 OFORMAT_HUMAN,
87 } OutputFormat;
88
89 /* Default to cache=writeback as data integrity is not important for qemu-img */
90 #define BDRV_DEFAULT_CACHE "writeback"
91
92 static void format_print(void *opaque, const char *name)
93 {
94 printf(" %s", name);
95 }
96
97 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
98 {
99 va_list ap;
100
101 va_start(ap, fmt);
102 error_vreport(fmt, ap);
103 va_end(ap);
104
105 error_printf("Try 'qemu-img --help' for more information\n");
106 exit(EXIT_FAILURE);
107 }
108
109 static void QEMU_NORETURN missing_argument(const char *option)
110 {
111 error_exit("missing argument for option '%s'", option);
112 }
113
114 static void QEMU_NORETURN unrecognized_option(const char *option)
115 {
116 error_exit("unrecognized option '%s'", option);
117 }
118
119 /* Please keep in synch with docs/tools/qemu-img.rst */
120 static void QEMU_NORETURN help(void)
121 {
122 const char *help_msg =
123 QEMU_IMG_VERSION
124 "usage: qemu-img [standard options] command [command options]\n"
125 "QEMU disk image utility\n"
126 "\n"
127 " '-h', '--help' display this help and exit\n"
128 " '-V', '--version' output version information and exit\n"
129 " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
130 " specify tracing options\n"
131 "\n"
132 "Command syntax:\n"
133 #define DEF(option, callback, arg_string) \
134 " " arg_string "\n"
135 #include "qemu-img-cmds.h"
136 #undef DEF
137 "\n"
138 "Command parameters:\n"
139 " 'filename' is a disk image filename\n"
140 " 'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
141 " manual page for a description of the object properties. The most common\n"
142 " object type is a 'secret', which is used to supply passwords and/or\n"
143 " encryption keys.\n"
144 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
145 " 'cache' is the cache mode used to write the output disk image, the valid\n"
146 " options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
147 " 'directsync' and 'unsafe' (default for convert)\n"
148 " 'src_cache' is the cache mode used to read input disk images, the valid\n"
149 " options are the same as for the 'cache' option\n"
150 " 'size' is the disk image size in bytes. Optional suffixes\n"
151 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
152 " 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
153 " supported. 'b' is ignored.\n"
154 " 'output_filename' is the destination disk image filename\n"
155 " 'output_fmt' is the destination format\n"
156 " 'options' is a comma separated list of format specific options in a\n"
157 " name=value format. Use -o ? for an overview of the options supported by the\n"
158 " used format\n"
159 " 'snapshot_param' is param used for internal snapshot, format\n"
160 " is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
161 " '[ID_OR_NAME]'\n"
162 " '-c' indicates that target image must be compressed (qcow format only)\n"
163 " '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
164 " new backing file match exactly. The image doesn't need a working\n"
165 " backing file before rebasing in this case (useful for renaming the\n"
166 " backing file). For image creation, allow creating without attempting\n"
167 " to open the backing file.\n"
168 " '-h' with or without a command shows this help and lists the supported formats\n"
169 " '-p' show progress of command (only certain commands)\n"
170 " '-q' use Quiet mode - do not print any output (except errors)\n"
171 " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
172 " contain only zeros for qemu-img to create a sparse image during\n"
173 " conversion. If the number of bytes is 0, the source will not be scanned for\n"
174 " unallocated or zero sectors, and the destination image will always be\n"
175 " fully allocated\n"
176 " '--output' takes the format in which the output must be done (human or json)\n"
177 " '-n' skips the target volume creation (useful if the volume is created\n"
178 " prior to running qemu-img)\n"
179 "\n"
180 "Parameters to bitmap subcommand:\n"
181 " 'bitmap' is the name of the bitmap to manipulate, through one or more\n"
182 " actions from '--add', '--remove', '--clear', '--enable', '--disable',\n"
183 " or '--merge source'\n"
184 " '-g granularity' sets the granularity for '--add' actions\n"
185 " '-b source' and '-F src_fmt' tell '--merge' actions to find the source\n"
186 " bitmaps from an alternative file\n"
187 "\n"
188 "Parameters to check subcommand:\n"
189 " '-r' tries to repair any inconsistencies that are found during the check.\n"
190 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
191 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
192 " hiding corruption that has already occurred.\n"
193 "\n"
194 "Parameters to convert subcommand:\n"
195 " '--bitmaps' copies all top-level persistent bitmaps to destination\n"
196 " '-m' specifies how many coroutines work in parallel during the convert\n"
197 " process (defaults to 8)\n"
198 " '-W' allow to write to the target out of order rather than sequential\n"
199 "\n"
200 "Parameters to snapshot subcommand:\n"
201 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
202 " '-a' applies a snapshot (revert disk to saved state)\n"
203 " '-c' creates a snapshot\n"
204 " '-d' deletes a snapshot\n"
205 " '-l' lists all snapshots in the given image\n"
206 "\n"
207 "Parameters to compare subcommand:\n"
208 " '-f' first image format\n"
209 " '-F' second image format\n"
210 " '-s' run in Strict mode - fail on different image size or sector allocation\n"
211 "\n"
212 "Parameters to dd subcommand:\n"
213 " 'bs=BYTES' read and write up to BYTES bytes at a time "
214 "(default: 512)\n"
215 " 'count=N' copy only N input blocks\n"
216 " 'if=FILE' read from FILE\n"
217 " 'of=FILE' write to FILE\n"
218 " 'skip=N' skip N bs-sized blocks at the start of input\n";
219
220 printf("%s\nSupported formats:", help_msg);
221 bdrv_iterate_format(format_print, NULL, false);
222 printf("\n\n" QEMU_HELP_BOTTOM "\n");
223 exit(EXIT_SUCCESS);
224 }
225
226 static QemuOptsList qemu_object_opts = {
227 .name = "object",
228 .implied_opt_name = "qom-type",
229 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
230 .desc = {
231 { }
232 },
233 };
234
235 static bool qemu_img_object_print_help(const char *type, QemuOpts *opts)
236 {
237 if (user_creatable_print_help(type, opts)) {
238 exit(0);
239 }
240 return true;
241 }
242
243 /*
244 * Is @optarg safe for accumulate_options()?
245 * It is when multiple of them can be joined together separated by ','.
246 * To make that work, @optarg must not start with ',' (or else a
247 * separating ',' preceding it gets escaped), and it must not end with
248 * an odd number of ',' (or else a separating ',' following it gets
249 * escaped), or be empty (or else a separating ',' preceding it can
250 * escape a separating ',' following it).
251 *
252 */
253 static bool is_valid_option_list(const char *optarg)
254 {
255 size_t len = strlen(optarg);
256 size_t i;
257
258 if (!optarg[0] || optarg[0] == ',') {
259 return false;
260 }
261
262 for (i = len; i > 0 && optarg[i - 1] == ','; i--) {
263 }
264 if ((len - i) % 2) {
265 return false;
266 }
267
268 return true;
269 }
270
271 static int accumulate_options(char **options, char *optarg)
272 {
273 char *new_options;
274
275 if (!is_valid_option_list(optarg)) {
276 error_report("Invalid option list: %s", optarg);
277 return -1;
278 }
279
280 if (!*options) {
281 *options = g_strdup(optarg);
282 } else {
283 new_options = g_strdup_printf("%s,%s", *options, optarg);
284 g_free(*options);
285 *options = new_options;
286 }
287 return 0;
288 }
289
290 static QemuOptsList qemu_source_opts = {
291 .name = "source",
292 .implied_opt_name = "file",
293 .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
294 .desc = {
295 { }
296 },
297 };
298
299 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
300 {
301 int ret = 0;
302 if (!quiet) {
303 va_list args;
304 va_start(args, fmt);
305 ret = vprintf(fmt, args);
306 va_end(args);
307 }
308 return ret;
309 }
310
311
312 static int print_block_option_help(const char *filename, const char *fmt)
313 {
314 BlockDriver *drv, *proto_drv;
315 QemuOptsList *create_opts = NULL;
316 Error *local_err = NULL;
317
318 /* Find driver and parse its options */
319 drv = bdrv_find_format(fmt);
320 if (!drv) {
321 error_report("Unknown file format '%s'", fmt);
322 return 1;
323 }
324
325 if (!drv->create_opts) {
326 error_report("Format driver '%s' does not support image creation", fmt);
327 return 1;
328 }
329
330 create_opts = qemu_opts_append(create_opts, drv->create_opts);
331 if (filename) {
332 proto_drv = bdrv_find_protocol(filename, true, &local_err);
333 if (!proto_drv) {
334 error_report_err(local_err);
335 qemu_opts_free(create_opts);
336 return 1;
337 }
338 if (!proto_drv->create_opts) {
339 error_report("Protocol driver '%s' does not support image creation",
340 proto_drv->format_name);
341 qemu_opts_free(create_opts);
342 return 1;
343 }
344 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
345 }
346
347 if (filename) {
348 printf("Supported options:\n");
349 } else {
350 printf("Supported %s options:\n", fmt);
351 }
352 qemu_opts_print_help(create_opts, false);
353 qemu_opts_free(create_opts);
354
355 if (!filename) {
356 printf("\n"
357 "The protocol level may support further options.\n"
358 "Specify the target filename to include those options.\n");
359 }
360
361 return 0;
362 }
363
364
365 static BlockBackend *img_open_opts(const char *optstr,
366 QemuOpts *opts, int flags, bool writethrough,
367 bool quiet, bool force_share)
368 {
369 QDict *options;
370 Error *local_err = NULL;
371 BlockBackend *blk;
372 options = qemu_opts_to_qdict(opts, NULL);
373 if (force_share) {
374 if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
375 && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) {
376 error_report("--force-share/-U conflicts with image options");
377 qobject_unref(options);
378 return NULL;
379 }
380 qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on");
381 }
382 blk = blk_new_open(NULL, NULL, options, flags, &local_err);
383 if (!blk) {
384 error_reportf_err(local_err, "Could not open '%s': ", optstr);
385 return NULL;
386 }
387 blk_set_enable_write_cache(blk, !writethrough);
388
389 return blk;
390 }
391
392 static BlockBackend *img_open_file(const char *filename,
393 QDict *options,
394 const char *fmt, int flags,
395 bool writethrough, bool quiet,
396 bool force_share)
397 {
398 BlockBackend *blk;
399 Error *local_err = NULL;
400
401 if (!options) {
402 options = qdict_new();
403 }
404 if (fmt) {
405 qdict_put_str(options, "driver", fmt);
406 }
407
408 if (force_share) {
409 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
410 }
411 blk = blk_new_open(filename, NULL, options, flags, &local_err);
412 if (!blk) {
413 error_reportf_err(local_err, "Could not open '%s': ", filename);
414 return NULL;
415 }
416 blk_set_enable_write_cache(blk, !writethrough);
417
418 return blk;
419 }
420
421
422 static int img_add_key_secrets(void *opaque,
423 const char *name, const char *value,
424 Error **errp)
425 {
426 QDict *options = opaque;
427
428 if (g_str_has_suffix(name, "key-secret")) {
429 qdict_put_str(options, name, value);
430 }
431
432 return 0;
433 }
434
435
436 static BlockBackend *img_open(bool image_opts,
437 const char *filename,
438 const char *fmt, int flags, bool writethrough,
439 bool quiet, bool force_share)
440 {
441 BlockBackend *blk;
442 if (image_opts) {
443 QemuOpts *opts;
444 if (fmt) {
445 error_report("--image-opts and --format are mutually exclusive");
446 return NULL;
447 }
448 opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
449 filename, true);
450 if (!opts) {
451 return NULL;
452 }
453 blk = img_open_opts(filename, opts, flags, writethrough, quiet,
454 force_share);
455 } else {
456 blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
457 force_share);
458 }
459 return blk;
460 }
461
462
463 static int add_old_style_options(const char *fmt, QemuOpts *opts,
464 const char *base_filename,
465 const char *base_fmt)
466 {
467 Error *err = NULL;
468
469 if (base_filename) {
470 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
471 if (err) {
472 error_report("Backing file not supported for file format '%s'",
473 fmt);
474 error_free(err);
475 return -1;
476 }
477 }
478 if (base_fmt) {
479 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
480 if (err) {
481 error_report("Backing file format not supported for file "
482 "format '%s'", fmt);
483 error_free(err);
484 return -1;
485 }
486 }
487 return 0;
488 }
489
490 static int64_t cvtnum_full(const char *name, const char *value, int64_t min,
491 int64_t max)
492 {
493 int err;
494 uint64_t res;
495
496 err = qemu_strtosz(value, NULL, &res);
497 if (err < 0 && err != -ERANGE) {
498 error_report("Invalid %s specified. You may use "
499 "k, M, G, T, P or E suffixes for", name);
500 error_report("kilobytes, megabytes, gigabytes, terabytes, "
501 "petabytes and exabytes.");
502 return err;
503 }
504 if (err == -ERANGE || res > max || res < min) {
505 error_report("Invalid %s specified. Must be between %" PRId64
506 " and %" PRId64 ".", name, min, max);
507 return -ERANGE;
508 }
509 return res;
510 }
511
512 static int64_t cvtnum(const char *name, const char *value)
513 {
514 return cvtnum_full(name, value, 0, INT64_MAX);
515 }
516
517 static int img_create(int argc, char **argv)
518 {
519 int c;
520 uint64_t img_size = -1;
521 const char *fmt = "raw";
522 const char *base_fmt = NULL;
523 const char *filename;
524 const char *base_filename = NULL;
525 char *options = NULL;
526 Error *local_err = NULL;
527 bool quiet = false;
528 int flags = 0;
529
530 for(;;) {
531 static const struct option long_options[] = {
532 {"help", no_argument, 0, 'h'},
533 {"object", required_argument, 0, OPTION_OBJECT},
534 {0, 0, 0, 0}
535 };
536 c = getopt_long(argc, argv, ":F:b:f:ho:qu",
537 long_options, NULL);
538 if (c == -1) {
539 break;
540 }
541 switch(c) {
542 case ':':
543 missing_argument(argv[optind - 1]);
544 break;
545 case '?':
546 unrecognized_option(argv[optind - 1]);
547 break;
548 case 'h':
549 help();
550 break;
551 case 'F':
552 base_fmt = optarg;
553 break;
554 case 'b':
555 base_filename = optarg;
556 break;
557 case 'f':
558 fmt = optarg;
559 break;
560 case 'o':
561 if (accumulate_options(&options, optarg) < 0) {
562 goto fail;
563 }
564 break;
565 case 'q':
566 quiet = true;
567 break;
568 case 'u':
569 flags |= BDRV_O_NO_BACKING;
570 break;
571 case OPTION_OBJECT: {
572 QemuOpts *opts;
573 opts = qemu_opts_parse_noisily(&qemu_object_opts,
574 optarg, true);
575 if (!opts) {
576 goto fail;
577 }
578 } break;
579 }
580 }
581
582 /* Get the filename */
583 filename = (optind < argc) ? argv[optind] : NULL;
584 if (options && has_help_option(options)) {
585 g_free(options);
586 return print_block_option_help(filename, fmt);
587 }
588
589 if (optind >= argc) {
590 error_exit("Expecting image file name");
591 }
592 optind++;
593
594 if (qemu_opts_foreach(&qemu_object_opts,
595 user_creatable_add_opts_foreach,
596 qemu_img_object_print_help, &error_fatal)) {
597 goto fail;
598 }
599
600 /* Get image size, if specified */
601 if (optind < argc) {
602 int64_t sval;
603
604 sval = cvtnum("image size", argv[optind++]);
605 if (sval < 0) {
606 goto fail;
607 }
608 img_size = (uint64_t)sval;
609 }
610 if (optind != argc) {
611 error_exit("Unexpected argument: %s", argv[optind]);
612 }
613
614 bdrv_img_create(filename, fmt, base_filename, base_fmt,
615 options, img_size, flags, quiet, &local_err);
616 if (local_err) {
617 error_reportf_err(local_err, "%s: ", filename);
618 goto fail;
619 }
620
621 g_free(options);
622 return 0;
623
624 fail:
625 g_free(options);
626 return 1;
627 }
628
629 static void dump_json_image_check(ImageCheck *check, bool quiet)
630 {
631 QString *str;
632 QObject *obj;
633 Visitor *v = qobject_output_visitor_new(&obj);
634
635 visit_type_ImageCheck(v, NULL, &check, &error_abort);
636 visit_complete(v, &obj);
637 str = qobject_to_json_pretty(obj);
638 assert(str != NULL);
639 qprintf(quiet, "%s\n", qstring_get_str(str));
640 qobject_unref(obj);
641 visit_free(v);
642 qobject_unref(str);
643 }
644
645 static void dump_human_image_check(ImageCheck *check, bool quiet)
646 {
647 if (!(check->corruptions || check->leaks || check->check_errors)) {
648 qprintf(quiet, "No errors were found on the image.\n");
649 } else {
650 if (check->corruptions) {
651 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
652 "Data may be corrupted, or further writes to the image "
653 "may corrupt it.\n",
654 check->corruptions);
655 }
656
657 if (check->leaks) {
658 qprintf(quiet,
659 "\n%" PRId64 " leaked clusters were found on the image.\n"
660 "This means waste of disk space, but no harm to data.\n",
661 check->leaks);
662 }
663
664 if (check->check_errors) {
665 qprintf(quiet,
666 "\n%" PRId64
667 " internal errors have occurred during the check.\n",
668 check->check_errors);
669 }
670 }
671
672 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
673 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
674 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
675 check->allocated_clusters, check->total_clusters,
676 check->allocated_clusters * 100.0 / check->total_clusters,
677 check->fragmented_clusters * 100.0 / check->allocated_clusters,
678 check->compressed_clusters * 100.0 /
679 check->allocated_clusters);
680 }
681
682 if (check->image_end_offset) {
683 qprintf(quiet,
684 "Image end offset: %" PRId64 "\n", check->image_end_offset);
685 }
686 }
687
688 static int collect_image_check(BlockDriverState *bs,
689 ImageCheck *check,
690 const char *filename,
691 const char *fmt,
692 int fix)
693 {
694 int ret;
695 BdrvCheckResult result;
696
697 ret = bdrv_check(bs, &result, fix);
698 if (ret < 0) {
699 return ret;
700 }
701
702 check->filename = g_strdup(filename);
703 check->format = g_strdup(bdrv_get_format_name(bs));
704 check->check_errors = result.check_errors;
705 check->corruptions = result.corruptions;
706 check->has_corruptions = result.corruptions != 0;
707 check->leaks = result.leaks;
708 check->has_leaks = result.leaks != 0;
709 check->corruptions_fixed = result.corruptions_fixed;
710 check->has_corruptions_fixed = result.corruptions_fixed != 0;
711 check->leaks_fixed = result.leaks_fixed;
712 check->has_leaks_fixed = result.leaks_fixed != 0;
713 check->image_end_offset = result.image_end_offset;
714 check->has_image_end_offset = result.image_end_offset != 0;
715 check->total_clusters = result.bfi.total_clusters;
716 check->has_total_clusters = result.bfi.total_clusters != 0;
717 check->allocated_clusters = result.bfi.allocated_clusters;
718 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
719 check->fragmented_clusters = result.bfi.fragmented_clusters;
720 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
721 check->compressed_clusters = result.bfi.compressed_clusters;
722 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
723
724 return 0;
725 }
726
727 /*
728 * Checks an image for consistency. Exit codes:
729 *
730 * 0 - Check completed, image is good
731 * 1 - Check not completed because of internal errors
732 * 2 - Check completed, image is corrupted
733 * 3 - Check completed, image has leaked clusters, but is good otherwise
734 * 63 - Checks are not supported by the image format
735 */
736 static int img_check(int argc, char **argv)
737 {
738 int c, ret;
739 OutputFormat output_format = OFORMAT_HUMAN;
740 const char *filename, *fmt, *output, *cache;
741 BlockBackend *blk;
742 BlockDriverState *bs;
743 int fix = 0;
744 int flags = BDRV_O_CHECK;
745 bool writethrough;
746 ImageCheck *check;
747 bool quiet = false;
748 bool image_opts = false;
749 bool force_share = false;
750
751 fmt = NULL;
752 output = NULL;
753 cache = BDRV_DEFAULT_CACHE;
754
755 for(;;) {
756 int option_index = 0;
757 static const struct option long_options[] = {
758 {"help", no_argument, 0, 'h'},
759 {"format", required_argument, 0, 'f'},
760 {"repair", required_argument, 0, 'r'},
761 {"output", required_argument, 0, OPTION_OUTPUT},
762 {"object", required_argument, 0, OPTION_OBJECT},
763 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
764 {"force-share", no_argument, 0, 'U'},
765 {0, 0, 0, 0}
766 };
767 c = getopt_long(argc, argv, ":hf:r:T:qU",
768 long_options, &option_index);
769 if (c == -1) {
770 break;
771 }
772 switch(c) {
773 case ':':
774 missing_argument(argv[optind - 1]);
775 break;
776 case '?':
777 unrecognized_option(argv[optind - 1]);
778 break;
779 case 'h':
780 help();
781 break;
782 case 'f':
783 fmt = optarg;
784 break;
785 case 'r':
786 flags |= BDRV_O_RDWR;
787
788 if (!strcmp(optarg, "leaks")) {
789 fix = BDRV_FIX_LEAKS;
790 } else if (!strcmp(optarg, "all")) {
791 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
792 } else {
793 error_exit("Unknown option value for -r "
794 "(expecting 'leaks' or 'all'): %s", optarg);
795 }
796 break;
797 case OPTION_OUTPUT:
798 output = optarg;
799 break;
800 case 'T':
801 cache = optarg;
802 break;
803 case 'q':
804 quiet = true;
805 break;
806 case 'U':
807 force_share = true;
808 break;
809 case OPTION_OBJECT: {
810 QemuOpts *opts;
811 opts = qemu_opts_parse_noisily(&qemu_object_opts,
812 optarg, true);
813 if (!opts) {
814 return 1;
815 }
816 } break;
817 case OPTION_IMAGE_OPTS:
818 image_opts = true;
819 break;
820 }
821 }
822 if (optind != argc - 1) {
823 error_exit("Expecting one image file name");
824 }
825 filename = argv[optind++];
826
827 if (output && !strcmp(output, "json")) {
828 output_format = OFORMAT_JSON;
829 } else if (output && !strcmp(output, "human")) {
830 output_format = OFORMAT_HUMAN;
831 } else if (output) {
832 error_report("--output must be used with human or json as argument.");
833 return 1;
834 }
835
836 if (qemu_opts_foreach(&qemu_object_opts,
837 user_creatable_add_opts_foreach,
838 qemu_img_object_print_help, &error_fatal)) {
839 return 1;
840 }
841
842 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
843 if (ret < 0) {
844 error_report("Invalid source cache option: %s", cache);
845 return 1;
846 }
847
848 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
849 force_share);
850 if (!blk) {
851 return 1;
852 }
853 bs = blk_bs(blk);
854
855 check = g_new0(ImageCheck, 1);
856 ret = collect_image_check(bs, check, filename, fmt, fix);
857
858 if (ret == -ENOTSUP) {
859 error_report("This image format does not support checks");
860 ret = 63;
861 goto fail;
862 }
863
864 if (check->corruptions_fixed || check->leaks_fixed) {
865 int corruptions_fixed, leaks_fixed;
866 bool has_leaks_fixed, has_corruptions_fixed;
867
868 leaks_fixed = check->leaks_fixed;
869 has_leaks_fixed = check->has_leaks_fixed;
870 corruptions_fixed = check->corruptions_fixed;
871 has_corruptions_fixed = check->has_corruptions_fixed;
872
873 if (output_format == OFORMAT_HUMAN) {
874 qprintf(quiet,
875 "The following inconsistencies were found and repaired:\n\n"
876 " %" PRId64 " leaked clusters\n"
877 " %" PRId64 " corruptions\n\n"
878 "Double checking the fixed image now...\n",
879 check->leaks_fixed,
880 check->corruptions_fixed);
881 }
882
883 qapi_free_ImageCheck(check);
884 check = g_new0(ImageCheck, 1);
885 ret = collect_image_check(bs, check, filename, fmt, 0);
886
887 check->leaks_fixed = leaks_fixed;
888 check->has_leaks_fixed = has_leaks_fixed;
889 check->corruptions_fixed = corruptions_fixed;
890 check->has_corruptions_fixed = has_corruptions_fixed;
891 }
892
893 if (!ret) {
894 switch (output_format) {
895 case OFORMAT_HUMAN:
896 dump_human_image_check(check, quiet);
897 break;
898 case OFORMAT_JSON:
899 dump_json_image_check(check, quiet);
900 break;
901 }
902 }
903
904 if (ret || check->check_errors) {
905 if (ret) {
906 error_report("Check failed: %s", strerror(-ret));
907 } else {
908 error_report("Check failed");
909 }
910 ret = 1;
911 goto fail;
912 }
913
914 if (check->corruptions) {
915 ret = 2;
916 } else if (check->leaks) {
917 ret = 3;
918 } else {
919 ret = 0;
920 }
921
922 fail:
923 qapi_free_ImageCheck(check);
924 blk_unref(blk);
925 return ret;
926 }
927
928 typedef struct CommonBlockJobCBInfo {
929 BlockDriverState *bs;
930 Error **errp;
931 } CommonBlockJobCBInfo;
932
933 static void common_block_job_cb(void *opaque, int ret)
934 {
935 CommonBlockJobCBInfo *cbi = opaque;
936
937 if (ret < 0) {
938 error_setg_errno(cbi->errp, -ret, "Block job failed");
939 }
940 }
941
942 static void run_block_job(BlockJob *job, Error **errp)
943 {
944 AioContext *aio_context = blk_get_aio_context(job->blk);
945 int ret = 0;
946
947 aio_context_acquire(aio_context);
948 job_ref(&job->job);
949 do {
950 float progress = 0.0f;
951 aio_poll(aio_context, true);
952 if (job->job.progress.total) {
953 progress = (float)job->job.progress.current /
954 job->job.progress.total * 100.f;
955 }
956 qemu_progress_print(progress, 0);
957 } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
958
959 if (!job_is_completed(&job->job)) {
960 ret = job_complete_sync(&job->job, errp);
961 } else {
962 ret = job->job.ret;
963 }
964 job_unref(&job->job);
965 aio_context_release(aio_context);
966
967 /* publish completion progress only when success */
968 if (!ret) {
969 qemu_progress_print(100.f, 0);
970 }
971 }
972
973 static int img_commit(int argc, char **argv)
974 {
975 int c, ret, flags;
976 const char *filename, *fmt, *cache, *base;
977 BlockBackend *blk;
978 BlockDriverState *bs, *base_bs;
979 BlockJob *job;
980 bool progress = false, quiet = false, drop = false;
981 bool writethrough;
982 Error *local_err = NULL;
983 CommonBlockJobCBInfo cbi;
984 bool image_opts = false;
985 AioContext *aio_context;
986
987 fmt = NULL;
988 cache = BDRV_DEFAULT_CACHE;
989 base = NULL;
990 for(;;) {
991 static const struct option long_options[] = {
992 {"help", no_argument, 0, 'h'},
993 {"object", required_argument, 0, OPTION_OBJECT},
994 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
995 {0, 0, 0, 0}
996 };
997 c = getopt_long(argc, argv, ":f:ht:b:dpq",
998 long_options, NULL);
999 if (c == -1) {
1000 break;
1001 }
1002 switch(c) {
1003 case ':':
1004 missing_argument(argv[optind - 1]);
1005 break;
1006 case '?':
1007 unrecognized_option(argv[optind - 1]);
1008 break;
1009 case 'h':
1010 help();
1011 break;
1012 case 'f':
1013 fmt = optarg;
1014 break;
1015 case 't':
1016 cache = optarg;
1017 break;
1018 case 'b':
1019 base = optarg;
1020 /* -b implies -d */
1021 drop = true;
1022 break;
1023 case 'd':
1024 drop = true;
1025 break;
1026 case 'p':
1027 progress = true;
1028 break;
1029 case 'q':
1030 quiet = true;
1031 break;
1032 case OPTION_OBJECT: {
1033 QemuOpts *opts;
1034 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1035 optarg, true);
1036 if (!opts) {
1037 return 1;
1038 }
1039 } break;
1040 case OPTION_IMAGE_OPTS:
1041 image_opts = true;
1042 break;
1043 }
1044 }
1045
1046 /* Progress is not shown in Quiet mode */
1047 if (quiet) {
1048 progress = false;
1049 }
1050
1051 if (optind != argc - 1) {
1052 error_exit("Expecting one image file name");
1053 }
1054 filename = argv[optind++];
1055
1056 if (qemu_opts_foreach(&qemu_object_opts,
1057 user_creatable_add_opts_foreach,
1058 qemu_img_object_print_help, &error_fatal)) {
1059 return 1;
1060 }
1061
1062 flags = BDRV_O_RDWR | BDRV_O_UNMAP;
1063 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1064 if (ret < 0) {
1065 error_report("Invalid cache option: %s", cache);
1066 return 1;
1067 }
1068
1069 blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
1070 false);
1071 if (!blk) {
1072 return 1;
1073 }
1074 bs = blk_bs(blk);
1075
1076 qemu_progress_init(progress, 1.f);
1077 qemu_progress_print(0.f, 100);
1078
1079 if (base) {
1080 base_bs = bdrv_find_backing_image(bs, base);
1081 if (!base_bs) {
1082 error_setg(&local_err,
1083 "Did not find '%s' in the backing chain of '%s'",
1084 base, filename);
1085 goto done;
1086 }
1087 } else {
1088 /* This is different from QMP, which by default uses the deepest file in
1089 * the backing chain (i.e., the very base); however, the traditional
1090 * behavior of qemu-img commit is using the immediate backing file. */
1091 base_bs = backing_bs(bs);
1092 if (!base_bs) {
1093 error_setg(&local_err, "Image does not have a backing file");
1094 goto done;
1095 }
1096 }
1097
1098 cbi = (CommonBlockJobCBInfo){
1099 .errp = &local_err,
1100 .bs = bs,
1101 };
1102
1103 aio_context = bdrv_get_aio_context(bs);
1104 aio_context_acquire(aio_context);
1105 commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,
1106 BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1107 &cbi, false, &local_err);
1108 aio_context_release(aio_context);
1109 if (local_err) {
1110 goto done;
1111 }
1112
1113 /* When the block job completes, the BlockBackend reference will point to
1114 * the old backing file. In order to avoid that the top image is already
1115 * deleted, so we can still empty it afterwards, increment the reference
1116 * counter here preemptively. */
1117 if (!drop) {
1118 bdrv_ref(bs);
1119 }
1120
1121 job = block_job_get("commit");
1122 assert(job);
1123 run_block_job(job, &local_err);
1124 if (local_err) {
1125 goto unref_backing;
1126 }
1127
1128 if (!drop) {
1129 BlockBackend *old_backing_blk;
1130
1131 old_backing_blk = blk_new_with_bs(bs, BLK_PERM_WRITE, BLK_PERM_ALL,
1132 &local_err);
1133 if (!old_backing_blk) {
1134 goto unref_backing;
1135 }
1136 ret = blk_make_empty(old_backing_blk, &local_err);
1137 blk_unref(old_backing_blk);
1138 if (ret == -ENOTSUP) {
1139 error_free(local_err);
1140 local_err = NULL;
1141 } else if (ret < 0) {
1142 goto unref_backing;
1143 }
1144 }
1145
1146 unref_backing:
1147 if (!drop) {
1148 bdrv_unref(bs);
1149 }
1150
1151 done:
1152 qemu_progress_end();
1153
1154 blk_unref(blk);
1155
1156 if (local_err) {
1157 error_report_err(local_err);
1158 return 1;
1159 }
1160
1161 qprintf(quiet, "Image committed.\n");
1162 return 0;
1163 }
1164
1165 /*
1166 * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1167 * of the first sector boundary within buf where the sector contains a
1168 * non-zero byte. This function is robust to a buffer that is not
1169 * sector-aligned.
1170 */
1171 static int64_t find_nonzero(const uint8_t *buf, int64_t n)
1172 {
1173 int64_t i;
1174 int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE);
1175
1176 for (i = 0; i < end; i += BDRV_SECTOR_SIZE) {
1177 if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) {
1178 return i;
1179 }
1180 }
1181 if (i < n && !buffer_is_zero(buf + i, n - end)) {
1182 return i;
1183 }
1184 return -1;
1185 }
1186
1187 /*
1188 * Returns true iff the first sector pointed to by 'buf' contains at least
1189 * a non-NUL byte.
1190 *
1191 * 'pnum' is set to the number of sectors (including and immediately following
1192 * the first one) that are known to be in the same allocated/unallocated state.
1193 * The function will try to align the end offset to alignment boundaries so
1194 * that the request will at least end aligned and consequtive requests will
1195 * also start at an aligned offset.
1196 */
1197 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
1198 int64_t sector_num, int alignment)
1199 {
1200 bool is_zero;
1201 int i, tail;
1202
1203 if (n <= 0) {
1204 *pnum = 0;
1205 return 0;
1206 }
1207 is_zero = buffer_is_zero(buf, 512);
1208 for(i = 1; i < n; i++) {
1209 buf += 512;
1210 if (is_zero != buffer_is_zero(buf, 512)) {
1211 break;
1212 }
1213 }
1214
1215 tail = (sector_num + i) & (alignment - 1);
1216 if (tail) {
1217 if (is_zero && i <= tail) {
1218 /* treat unallocated areas which only consist
1219 * of a small tail as allocated. */
1220 is_zero = false;
1221 }
1222 if (!is_zero) {
1223 /* align up end offset of allocated areas. */
1224 i += alignment - tail;
1225 i = MIN(i, n);
1226 } else {
1227 /* align down end offset of zero areas. */
1228 i -= tail;
1229 }
1230 }
1231 *pnum = i;
1232 return !is_zero;
1233 }
1234
1235 /*
1236 * Like is_allocated_sectors, but if the buffer starts with a used sector,
1237 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1238 * breaking up write requests for only small sparse areas.
1239 */
1240 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1241 int min, int64_t sector_num, int alignment)
1242 {
1243 int ret;
1244 int num_checked, num_used;
1245
1246 if (n < min) {
1247 min = n;
1248 }
1249
1250 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1251 if (!ret) {
1252 return ret;
1253 }
1254
1255 num_used = *pnum;
1256 buf += BDRV_SECTOR_SIZE * *pnum;
1257 n -= *pnum;
1258 sector_num += *pnum;
1259 num_checked = num_used;
1260
1261 while (n > 0) {
1262 ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1263
1264 buf += BDRV_SECTOR_SIZE * *pnum;
1265 n -= *pnum;
1266 sector_num += *pnum;
1267 num_checked += *pnum;
1268 if (ret) {
1269 num_used = num_checked;
1270 } else if (*pnum >= min) {
1271 break;
1272 }
1273 }
1274
1275 *pnum = num_used;
1276 return 1;
1277 }
1278
1279 /*
1280 * Compares two buffers sector by sector. Returns 0 if the first
1281 * sector of each buffer matches, non-zero otherwise.
1282 *
1283 * pnum is set to the sector-aligned size of the buffer prefix that
1284 * has the same matching status as the first sector.
1285 */
1286 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,
1287 int64_t bytes, int64_t *pnum)
1288 {
1289 bool res;
1290 int64_t i = MIN(bytes, BDRV_SECTOR_SIZE);
1291
1292 assert(bytes > 0);
1293
1294 res = !!memcmp(buf1, buf2, i);
1295 while (i < bytes) {
1296 int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE);
1297
1298 if (!!memcmp(buf1 + i, buf2 + i, len) != res) {
1299 break;
1300 }
1301 i += len;
1302 }
1303
1304 *pnum = i;
1305 return res;
1306 }
1307
1308 #define IO_BUF_SIZE (2 * MiB)
1309
1310 /*
1311 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1312 *
1313 * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1314 * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1315 * failure), and 4 on error (the exit status for read errors), after emitting
1316 * an error message.
1317 *
1318 * @param blk: BlockBackend for the image
1319 * @param offset: Starting offset to check
1320 * @param bytes: Number of bytes to check
1321 * @param filename: Name of disk file we are checking (logging purpose)
1322 * @param buffer: Allocated buffer for storing read data
1323 * @param quiet: Flag for quiet mode
1324 */
1325 static int check_empty_sectors(BlockBackend *blk, int64_t offset,
1326 int64_t bytes, const char *filename,
1327 uint8_t *buffer, bool quiet)
1328 {
1329 int ret = 0;
1330 int64_t idx;
1331
1332 ret = blk_pread(blk, offset, buffer, bytes);
1333 if (ret < 0) {
1334 error_report("Error while reading offset %" PRId64 " of %s: %s",
1335 offset, filename, strerror(-ret));
1336 return 4;
1337 }
1338 idx = find_nonzero(buffer, bytes);
1339 if (idx >= 0) {
1340 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1341 offset + idx);
1342 return 1;
1343 }
1344
1345 return 0;
1346 }
1347
1348 /*
1349 * Compares two images. Exit codes:
1350 *
1351 * 0 - Images are identical
1352 * 1 - Images differ
1353 * >1 - Error occurred
1354 */
1355 static int img_compare(int argc, char **argv)
1356 {
1357 const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1358 BlockBackend *blk1, *blk2;
1359 BlockDriverState *bs1, *bs2;
1360 int64_t total_size1, total_size2;
1361 uint8_t *buf1 = NULL, *buf2 = NULL;
1362 int64_t pnum1, pnum2;
1363 int allocated1, allocated2;
1364 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1365 bool progress = false, quiet = false, strict = false;
1366 int flags;
1367 bool writethrough;
1368 int64_t total_size;
1369 int64_t offset = 0;
1370 int64_t chunk;
1371 int c;
1372 uint64_t progress_base;
1373 bool image_opts = false;
1374 bool force_share = false;
1375
1376 cache = BDRV_DEFAULT_CACHE;
1377 for (;;) {
1378 static const struct option long_options[] = {
1379 {"help", no_argument, 0, 'h'},
1380 {"object", required_argument, 0, OPTION_OBJECT},
1381 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1382 {"force-share", no_argument, 0, 'U'},
1383 {0, 0, 0, 0}
1384 };
1385 c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1386 long_options, NULL);
1387 if (c == -1) {
1388 break;
1389 }
1390 switch (c) {
1391 case ':':
1392 missing_argument(argv[optind - 1]);
1393 break;
1394 case '?':
1395 unrecognized_option(argv[optind - 1]);
1396 break;
1397 case 'h':
1398 help();
1399 break;
1400 case 'f':
1401 fmt1 = optarg;
1402 break;
1403 case 'F':
1404 fmt2 = optarg;
1405 break;
1406 case 'T':
1407 cache = optarg;
1408 break;
1409 case 'p':
1410 progress = true;
1411 break;
1412 case 'q':
1413 quiet = true;
1414 break;
1415 case 's':
1416 strict = true;
1417 break;
1418 case 'U':
1419 force_share = true;
1420 break;
1421 case OPTION_OBJECT: {
1422 QemuOpts *opts;
1423 opts = qemu_opts_parse_noisily(&qemu_object_opts,
1424 optarg, true);
1425 if (!opts) {
1426 ret = 2;
1427 goto out4;
1428 }
1429 } break;
1430 case OPTION_IMAGE_OPTS:
1431 image_opts = true;
1432 break;
1433 }
1434 }
1435
1436 /* Progress is not shown in Quiet mode */
1437 if (quiet) {
1438 progress = false;
1439 }
1440
1441
1442 if (optind != argc - 2) {
1443 error_exit("Expecting two image file names");
1444 }
1445 filename1 = argv[optind++];
1446 filename2 = argv[optind++];
1447
1448 if (qemu_opts_foreach(&qemu_object_opts,
1449 user_creatable_add_opts_foreach,
1450 qemu_img_object_print_help, &error_fatal)) {
1451 ret = 2;
1452 goto out4;
1453 }
1454
1455 /* Initialize before goto out */
1456 qemu_progress_init(progress, 2.0);
1457
1458 flags = 0;
1459 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1460 if (ret < 0) {
1461 error_report("Invalid source cache option: %s", cache);
1462 ret = 2;
1463 goto out3;
1464 }
1465
1466 blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1467 force_share);
1468 if (!blk1) {
1469 ret = 2;
1470 goto out3;
1471 }
1472
1473 blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1474 force_share);
1475 if (!blk2) {
1476 ret = 2;
1477 goto out2;
1478 }
1479 bs1 = blk_bs(blk1);
1480 bs2 = blk_bs(blk2);
1481
1482 buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1483 buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1484 total_size1 = blk_getlength(blk1);
1485 if (total_size1 < 0) {
1486 error_report("Can't get size of %s: %s",
1487 filename1, strerror(-total_size1));
1488 ret = 4;
1489 goto out;
1490 }
1491 total_size2 = blk_getlength(blk2);
1492 if (total_size2 < 0) {
1493 error_report("Can't get size of %s: %s",
1494 filename2, strerror(-total_size2));
1495 ret = 4;
1496 goto out;
1497 }
1498 total_size = MIN(total_size1, total_size2);
1499 progress_base = MAX(total_size1, total_size2);
1500
1501 qemu_progress_print(0, 100);
1502
1503 if (strict && total_size1 != total_size2) {
1504 ret = 1;
1505 qprintf(quiet, "Strict mode: Image size mismatch!\n");
1506 goto out;
1507 }
1508
1509 while (offset < total_size) {
1510 int status1, status2;
1511
1512 status1 = bdrv_block_status_above(bs1, NULL, offset,
1513 total_size1 - offset, &pnum1, NULL,
1514 NULL);
1515 if (status1 < 0) {
1516 ret = 3;
1517 error_report("Sector allocation test failed for %s", filename1);
1518 goto out;
1519 }
1520 allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1521
1522 status2 = bdrv_block_status_above(bs2, NULL, offset,
1523 total_size2 - offset, &pnum2, NULL,
1524 NULL);
1525 if (status2 < 0) {
1526 ret = 3;
1527 error_report("Sector allocation test failed for %s", filename2);
1528 goto out;
1529 }
1530 allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1531
1532 assert(pnum1 && pnum2);
1533 chunk = MIN(pnum1, pnum2);
1534
1535 if (strict) {
1536 if (status1 != status2) {
1537 ret = 1;
1538 qprintf(quiet, "Strict mode: Offset %" PRId64
1539 " block status mismatch!\n", offset);
1540 goto out;
1541 }
1542 }
1543 if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1544 /* nothing to do */
1545 } else if (allocated1 == allocated2) {
1546 if (allocated1) {
1547 int64_t pnum;
1548
1549 chunk = MIN(chunk, IO_BUF_SIZE);
1550 ret = blk_pread(blk1, offset, buf1, chunk);
1551 if (ret < 0) {
1552 error_report("Error while reading offset %" PRId64
1553 " of %s: %s",
1554 offset, filename1, strerror(-ret));
1555 ret = 4;
1556 goto out;
1557 }
1558 ret = blk_pread(blk2, offset, buf2, chunk);
1559 if (ret < 0) {
1560 error_report("Error while reading offset %" PRId64
1561 " of %s: %s",
1562 offset, filename2, strerror(-ret));
1563 ret = 4;
1564 goto out;
1565 }
1566 ret = compare_buffers(buf1, buf2, chunk, &pnum);
1567 if (ret || pnum != chunk) {
1568 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1569 offset + (ret ? 0 : pnum));
1570 ret = 1;
1571 goto out;
1572 }
1573 }
1574 } else {
1575 chunk = MIN(chunk, IO_BUF_SIZE);
1576 if (allocated1) {
1577 ret = check_empty_sectors(blk1, offset, chunk,
1578 filename1, buf1, quiet);
1579 } else {
1580 ret = check_empty_sectors(blk2, offset, chunk,
1581 filename2, buf1, quiet);
1582 }
1583 if (ret) {
1584 goto out;
1585 }
1586 }
1587 offset += chunk;
1588 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1589 }
1590
1591 if (total_size1 != total_size2) {
1592 BlockBackend *blk_over;
1593 const char *filename_over;
1594
1595 qprintf(quiet, "Warning: Image size mismatch!\n");
1596 if (total_size1 > total_size2) {
1597 blk_over = blk1;
1598 filename_over = filename1;
1599 } else {
1600 blk_over = blk2;
1601 filename_over = filename2;
1602 }
1603
1604 while (offset < progress_base) {
1605 ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,
1606 progress_base - offset, &chunk,
1607 NULL, NULL);
1608 if (ret < 0) {
1609 ret = 3;
1610 error_report("Sector allocation test failed for %s",
1611 filename_over);
1612 goto out;
1613
1614 }
1615 if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {
1616 chunk = MIN(chunk, IO_BUF_SIZE);
1617 ret = check_empty_sectors(blk_over, offset, chunk,
1618 filename_over, buf1, quiet);
1619 if (ret) {
1620 goto out;
1621 }
1622 }
1623 offset += chunk;
1624 qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1625 }
1626 }
1627
1628 qprintf(quiet, "Images are identical.\n");
1629 ret = 0;
1630
1631 out:
1632 qemu_vfree(buf1);
1633 qemu_vfree(buf2);
1634 blk_unref(blk2);
1635 out2:
1636 blk_unref(blk1);
1637 out3:
1638 qemu_progress_end();
1639 out4:
1640 return ret;
1641 }
1642
1643 /* Convenience wrapper around qmp_block_dirty_bitmap_merge */
1644 static void do_dirty_bitmap_merge(const char *dst_node, const char *dst_name,
1645 const char *src_node, const char *src_name,
1646 Error **errp)
1647 {
1648 BlockDirtyBitmapMergeSource *merge_src;
1649 BlockDirtyBitmapMergeSourceList *list;
1650
1651 merge_src = g_new0(BlockDirtyBitmapMergeSource, 1);
1652 merge_src->type = QTYPE_QDICT;
1653 merge_src->u.external.node = g_strdup(src_node);
1654 merge_src->u.external.name = g_strdup(src_name);
1655 list = g_new0(BlockDirtyBitmapMergeSourceList, 1);
1656 list->value = merge_src;
1657 qmp_block_dirty_bitmap_merge(dst_node, dst_name, list, errp);
1658 qapi_free_BlockDirtyBitmapMergeSourceList(list);
1659 }
1660
1661 enum ImgConvertBlockStatus {
1662 BLK_DATA,
1663 BLK_ZERO,
1664 BLK_BACKING_FILE,
1665 };
1666
1667 #define MAX_COROUTINES 16
1668
1669 typedef struct ImgConvertState {
1670 BlockBackend **src;
1671 int64_t *src_sectors;
1672 int src_num;
1673 int64_t total_sectors;
1674 int64_t allocated_sectors;
1675 int64_t allocated_done;
1676 int64_t sector_num;
1677 int64_t wr_offs;
1678 enum ImgConvertBlockStatus status;
1679 int64_t sector_next_status;
1680 BlockBackend *target;
1681 bool has_zero_init;
1682 bool compressed;
1683 bool unallocated_blocks_are_zero;
1684 bool target_is_new;
1685 bool target_has_backing;
1686 int64_t target_backing_sectors; /* negative if unknown */
1687 bool wr_in_order;
1688 bool copy_range;
1689 bool salvage;
1690 bool quiet;
1691 int min_sparse;
1692 int alignment;
1693 size_t cluster_sectors;
1694 size_t buf_sectors;
1695 long num_coroutines;
1696 int running_coroutines;
1697 Coroutine *co[MAX_COROUTINES];
1698 int64_t wait_sector_num[MAX_COROUTINES];
1699 CoMutex lock;
1700 int ret;
1701 } ImgConvertState;
1702
1703 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1704 int *src_cur, int64_t *src_cur_offset)
1705 {
1706 *src_cur = 0;
1707 *src_cur_offset = 0;
1708 while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1709 *src_cur_offset += s->src_sectors[*src_cur];
1710 (*src_cur)++;
1711 assert(*src_cur < s->src_num);
1712 }
1713 }
1714
1715 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1716 {
1717 int64_t src_cur_offset;
1718 int ret, n, src_cur;
1719 bool post_backing_zero = false;
1720
1721 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1722
1723 assert(s->total_sectors > sector_num);
1724 n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1725
1726 if (s->target_backing_sectors >= 0) {
1727 if (sector_num >= s->target_backing_sectors) {
1728 post_backing_zero = s->unallocated_blocks_are_zero;
1729 } else if (sector_num + n > s->target_backing_sectors) {
1730 /* Split requests around target_backing_sectors (because
1731 * starting from there, zeros are handled differently) */
1732 n = s->target_backing_sectors - sector_num;
1733 }
1734 }
1735
1736 if (s->sector_next_status <= sector_num) {
1737 uint64_t offset = (sector_num - src_cur_offset) * BDRV_SECTOR_SIZE;
1738 int64_t count;
1739
1740 do {
1741 count = n * BDRV_SECTOR_SIZE;
1742
1743 if (s->target_has_backing) {
1744 ret = bdrv_block_status(blk_bs(s->src[src_cur]), offset,
1745 count, &count, NULL, NULL);
1746 } else {
1747 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,
1748 offset, count, &count, NULL,
1749 NULL);
1750 }
1751
1752 if (ret < 0) {
1753 if (s->salvage) {
1754 if (n == 1) {
1755 if (!s->quiet) {
1756 warn_report("error while reading block status at "
1757 "offset %" PRIu64 ": %s", offset,
1758 strerror(-ret));
1759 }
1760 /* Just try to read the data, then */
1761 ret = BDRV_BLOCK_DATA;
1762 count = BDRV_SECTOR_SIZE;
1763 } else {
1764 /* Retry on a shorter range */
1765 n = DIV_ROUND_UP(n, 4);
1766 }
1767 } else {
1768 error_report("error while reading block status at offset "
1769 "%" PRIu64 ": %s", offset, strerror(-ret));
1770 return ret;
1771 }
1772 }
1773 } while (ret < 0);
1774
1775 n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
1776
1777 if (ret & BDRV_BLOCK_ZERO) {
1778 s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;
1779 } else if (ret & BDRV_BLOCK_DATA) {
1780 s->status = BLK_DATA;
1781 } else {
1782 s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1783 }
1784
1785 s->sector_next_status = sector_num + n;
1786 }
1787
1788 n = MIN(n, s->sector_next_status - sector_num);
1789 if (s->status == BLK_DATA) {
1790 n = MIN(n, s->buf_sectors);
1791 }
1792
1793 /* We need to write complete clusters for compressed images, so if an
1794 * unallocated area is shorter than that, we must consider the whole
1795 * cluster allocated. */
1796 if (s->compressed) {
1797 if (n < s->cluster_sectors) {
1798 n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1799 s->status = BLK_DATA;
1800 } else {
1801 n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1802 }
1803 }
1804
1805 return n;
1806 }
1807
1808 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1809 int nb_sectors, uint8_t *buf)
1810 {
1811 uint64_t single_read_until = 0;
1812 int n, ret;
1813
1814 assert(nb_sectors <= s->buf_sectors);
1815 while (nb_sectors > 0) {
1816 BlockBackend *blk;
1817 int src_cur;
1818 int64_t bs_sectors, src_cur_offset;
1819 uint64_t offset;
1820
1821 /* In the case of compression with multiple source files, we can get a
1822 * nb_sectors that spreads into the next part. So we must be able to
1823 * read across multiple BDSes for one convert_read() call. */
1824 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1825 blk = s->src[src_cur];
1826 bs_sectors = s->src_sectors[src_cur];
1827
1828 offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1829
1830 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1831 if (single_read_until > offset) {
1832 n = 1;
1833 }
1834
1835 ret = blk_co_pread(blk, offset, n << BDRV_SECTOR_BITS, buf, 0);
1836 if (ret < 0) {
1837 if (s->salvage) {
1838 if (n > 1) {
1839 single_read_until = offset + (n << BDRV_SECTOR_BITS);
1840 continue;
1841 } else {
1842 if (!s->quiet) {
1843 warn_report("error while reading offset %" PRIu64
1844 ": %s", offset, strerror(-ret));
1845 }
1846 memset(buf, 0, BDRV_SECTOR_SIZE);
1847 }
1848 } else {
1849 return ret;
1850 }
1851 }
1852
1853 sector_num += n;
1854 nb_sectors -= n;
1855 buf += n * BDRV_SECTOR_SIZE;
1856 }
1857
1858 return 0;
1859 }
1860
1861
1862 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1863 int nb_sectors, uint8_t *buf,
1864 enum ImgConvertBlockStatus status)
1865 {
1866 int ret;
1867
1868 while (nb_sectors > 0) {
1869 int n = nb_sectors;
1870 BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1871
1872 switch (status) {
1873 case BLK_BACKING_FILE:
1874 /* If we have a backing file, leave clusters unallocated that are
1875 * unallocated in the source image, so that the backing file is
1876 * visible at the respective offset. */
1877 assert(s->target_has_backing);
1878 break;
1879
1880 case BLK_DATA:
1881 /* If we're told to keep the target fully allocated (-S 0) or there
1882 * is real non-zero data, we must write it. Otherwise we can treat
1883 * it as zero sectors.
1884 * Compressed clusters need to be written as a whole, so in that
1885 * case we can only save the write if the buffer is completely
1886 * zeroed. */
1887 if (!s->min_sparse ||
1888 (!s->compressed &&
1889 is_allocated_sectors_min(buf, n, &n, s->min_sparse,
1890 sector_num, s->alignment)) ||
1891 (s->compressed &&
1892 !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1893 {
1894 ret = blk_co_pwrite(s->target, sector_num << BDRV_SECTOR_BITS,
1895 n << BDRV_SECTOR_BITS, buf, flags);
1896 if (ret < 0) {
1897 return ret;
1898 }
1899 break;
1900 }
1901 /* fall-through */
1902
1903 case BLK_ZERO:
1904 if (s->has_zero_init) {
1905 assert(!s->target_has_backing);
1906 break;
1907 }
1908 ret = blk_co_pwrite_zeroes(s->target,
1909 sector_num << BDRV_SECTOR_BITS,
1910 n << BDRV_SECTOR_BITS,
1911 BDRV_REQ_MAY_UNMAP);
1912 if (ret < 0) {
1913 return ret;
1914 }
1915 break;
1916 }
1917
1918 sector_num += n;
1919 nb_sectors -= n;
1920 buf += n * BDRV_SECTOR_SIZE;
1921 }
1922
1923 return 0;
1924 }
1925
1926 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
1927 int nb_sectors)
1928 {
1929 int n, ret;
1930
1931 while (nb_sectors > 0) {
1932 BlockBackend *blk;
1933 int src_cur;
1934 int64_t bs_sectors, src_cur_offset;
1935 int64_t offset;
1936
1937 convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1938 offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1939 blk = s->src[src_cur];
1940 bs_sectors = s->src_sectors[src_cur];
1941
1942 n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1943
1944 ret = blk_co_copy_range(blk, offset, s->target,
1945 sector_num << BDRV_SECTOR_BITS,
1946 n << BDRV_SECTOR_BITS, 0, 0);
1947 if (ret < 0) {
1948 return ret;
1949 }
1950
1951 sector_num += n;
1952 nb_sectors -= n;
1953 }
1954 return 0;
1955 }
1956
1957 static void coroutine_fn convert_co_do_copy(void *opaque)
1958 {
1959 ImgConvertState *s = opaque;
1960 uint8_t *buf = NULL;
1961 int ret, i;
1962 int index = -1;
1963
1964 for (i = 0; i < s->num_coroutines; i++) {
1965 if (s->co[i] == qemu_coroutine_self()) {
1966 index = i;
1967 break;
1968 }
1969 }
1970 assert(index >= 0);
1971
1972 s->running_coroutines++;
1973 buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1974
1975 while (1) {
1976 int n;
1977 int64_t sector_num;
1978 enum ImgConvertBlockStatus status;
1979 bool copy_range;
1980
1981 qemu_co_mutex_lock(&s->lock);
1982 if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1983 qemu_co_mutex_unlock(&s->lock);
1984 break;
1985 }
1986 n = convert_iteration_sectors(s, s->sector_num);
1987 if (n < 0) {
1988 qemu_co_mutex_unlock(&s->lock);
1989 s->ret = n;
1990 break;
1991 }
1992 /* save current sector and allocation status to local variables */
1993 sector_num = s->sector_num;
1994 status = s->status;
1995 if (!s->min_sparse && s->status == BLK_ZERO) {
1996 n = MIN(n, s->buf_sectors);
1997 }
1998 /* increment global sector counter so that other coroutines can
1999 * already continue reading beyond this request */
2000 s->sector_num += n;
2001 qemu_co_mutex_unlock(&s->lock);
2002
2003 if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
2004 s->allocated_done += n;
2005 qemu_progress_print(100.0 * s->allocated_done /
2006 s->allocated_sectors, 0);
2007 }
2008
2009 retry:
2010 copy_range = s->copy_range && s->status == BLK_DATA;
2011 if (status == BLK_DATA && !copy_range) {
2012 ret = convert_co_read(s, sector_num, n, buf);
2013 if (ret < 0) {
2014 error_report("error while reading at byte %lld: %s",
2015 sector_num * BDRV_SECTOR_SIZE, strerror(-ret));
2016 s->ret = ret;
2017 }
2018 } else if (!s->min_sparse && status == BLK_ZERO) {
2019 status = BLK_DATA;
2020 memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
2021 }
2022
2023 if (s->wr_in_order) {
2024 /* keep writes in order */
2025 while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
2026 s->wait_sector_num[index] = sector_num;
2027 qemu_coroutine_yield();
2028 }
2029 s->wait_sector_num[index] = -1;
2030 }
2031
2032 if (s->ret == -EINPROGRESS) {
2033 if (copy_range) {
2034 ret = convert_co_copy_range(s, sector_num, n);
2035 if (ret) {
2036 s->copy_range = false;
2037 goto retry;
2038 }
2039 } else {
2040 ret = convert_co_write(s, sector_num, n, buf, status);
2041 }
2042 if (ret < 0) {
2043 error_report("error while writing at byte %lld: %s",
2044 sector_num * BDRV_SECTOR_SIZE, strerror(-ret));
2045 s->ret = ret;
2046 }
2047 }
2048
2049 if (s->wr_in_order) {
2050 /* reenter the coroutine that might have waited
2051 * for this write to complete */
2052 s->wr_offs = sector_num + n;
2053 for (i = 0; i < s->num_coroutines; i++) {
2054 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
2055 /*
2056 * A -> B -> A cannot occur because A has
2057 * s->wait_sector_num[i] == -1 during A -> B. Therefore
2058 * B will never enter A during this time window.
2059 */
2060 qemu_coroutine_enter(s->co[i]);
2061 break;
2062 }
2063 }
2064 }
2065 }
2066
2067 qemu_vfree(buf);
2068 s->co[index] = NULL;
2069 s->running_coroutines--;
2070 if (!s->running_coroutines && s->ret == -EINPROGRESS) {
2071 /* the convert job finished successfully */
2072 s->ret = 0;
2073 }
2074 }
2075
2076 static int convert_do_copy(ImgConvertState *s)
2077 {
2078 int ret, i, n;
2079 int64_t sector_num = 0;
2080
2081 /* Check whether we have zero initialisation or can get it efficiently */
2082 if (!s->has_zero_init && s->target_is_new && s->min_sparse &&
2083 !s->target_has_backing) {
2084 s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
2085 }
2086
2087 if (!s->has_zero_init && !s->target_has_backing &&
2088 bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
2089 {
2090 ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK);
2091 if (ret == 0) {
2092 s->has_zero_init = true;
2093 }
2094 }
2095
2096 /* Allocate buffer for copied data. For compressed images, only one cluster
2097 * can be copied at a time. */
2098 if (s->compressed) {
2099 if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
2100 error_report("invalid cluster size");
2101 return -EINVAL;
2102 }
2103 s->buf_sectors = s->cluster_sectors;
2104 }
2105
2106 while (sector_num < s->total_sectors) {
2107 n = convert_iteration_sectors(s, sector_num);
2108 if (n < 0) {
2109 return n;
2110 }
2111 if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
2112 {
2113 s->allocated_sectors += n;
2114 }
2115 sector_num += n;
2116 }
2117
2118 /* Do the copy */
2119 s->sector_next_status = 0;
2120 s->ret = -EINPROGRESS;
2121
2122 qemu_co_mutex_init(&s->lock);
2123 for (i = 0; i < s->num_coroutines; i++) {
2124 s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
2125 s->wait_sector_num[i] = -1;
2126 qemu_coroutine_enter(s->co[i]);
2127 }
2128
2129 while (s->running_coroutines) {
2130 main_loop_wait(false);
2131 }
2132
2133 if (s->compressed && !s->ret) {
2134 /* signal EOF to align */
2135 ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
2136 if (ret < 0) {
2137 return ret;
2138 }
2139 }
2140
2141 return s->ret;
2142 }
2143
2144 static int convert_copy_bitmaps(BlockDriverState *src, BlockDriverState *dst)
2145 {
2146 BdrvDirtyBitmap *bm;
2147 Error *err = NULL;
2148
2149 FOR_EACH_DIRTY_BITMAP(src, bm) {
2150 const char *name;
2151
2152 if (!bdrv_dirty_bitmap_get_persistence(bm)) {
2153 continue;
2154 }
2155 name = bdrv_dirty_bitmap_name(bm);
2156 qmp_block_dirty_bitmap_add(dst->node_name, name,
2157 true, bdrv_dirty_bitmap_granularity(bm),
2158 true, true,
2159 true, !bdrv_dirty_bitmap_enabled(bm),
2160 &err);
2161 if (err) {
2162 error_reportf_err(err, "Failed to create bitmap %s: ", name);
2163 return -1;
2164 }
2165
2166 do_dirty_bitmap_merge(dst->node_name, name, src->node_name, name,
2167 &err);
2168 if (err) {
2169 error_reportf_err(err, "Failed to populate bitmap %s: ", name);
2170 return -1;
2171 }
2172 }
2173
2174 return 0;
2175 }
2176
2177 #define MAX_BUF_SECTORS 32768
2178
2179 static int img_convert(int argc, char **argv)
2180 {
2181 int c, bs_i, flags, src_flags = 0;
2182 const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
2183 *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
2184 *out_filename, *out_baseimg_param, *snapshot_name = NULL;
2185 BlockDriver *drv = NULL, *proto_drv = NULL;
2186 BlockDriverInfo bdi;
2187 BlockDriverState *out_bs;
2188 QemuOpts *opts = NULL, *sn_opts = NULL;
2189 QemuOptsList *create_opts = NULL;
2190 QDict *open_opts = NULL;
2191 char *options = NULL;
2192 Error *local_err = NULL;
2193 bool writethrough, src_writethrough, image_opts = false,
2194 skip_create = false, progress = false, tgt_image_opts = false;
2195 int64_t ret = -EINVAL;
2196 bool force_share = false;
2197 bool explict_min_sparse = false;
2198 bool bitmaps = false;
2199
2200 ImgConvertState s = (ImgConvertState) {
2201 /* Need at least 4k of zeros for sparse detection */
2202 .min_sparse = 8,
2203 .copy_range = false,
2204 .buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
2205 .wr_in_order = true,
2206 .num_coroutines = 8,
2207 };
2208
2209 for(;;) {
2210 static const struct option long_options[] = {
2211 {"help", no_argument, 0, 'h'},
2212 {"object", required_argument, 0, OPTION_OBJECT},
2213 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2214 {"force-share", no_argument, 0, 'U'},
2215 {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
2216 {"salvage", no_argument, 0, OPTION_SALVAGE},
2217 {"target-is-zero", no_argument, 0, OPTION_TARGET_IS_ZERO},
2218 {"bitmaps", no_argument, 0, OPTION_BITMAPS},
2219 {0, 0, 0, 0}
2220 };
2221 c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
2222 long_options, NULL);
2223 if (c == -1) {
2224 break;
2225 }
2226 switch(c) {
2227 case ':':
2228 missing_argument(argv[optind - 1]);
2229 break;
2230 case '?':
2231 unrecognized_option(argv[optind - 1]);
2232 break;
2233 case 'h':
2234 help();
2235 break;
2236 case 'f':
2237 fmt = optarg;
2238 break;
2239 case 'O':
2240 out_fmt = optarg;
2241 break;
2242 case 'B':
2243 out_baseimg = optarg;
2244 break;
2245 case 'C':
2246 s.copy_range = true;
2247 break;
2248 case 'c':
2249 s.compressed = true;
2250 break;
2251 case 'o':
2252 if (accumulate_options(&options, optarg) < 0) {
2253 goto fail_getopt;
2254 }
2255 break;
2256 case 'l':
2257 if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2258 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2259 optarg, false);
2260 if (!sn_opts) {
2261 error_report("Failed in parsing snapshot param '%s'",
2262 optarg);
2263 goto fail_getopt;
2264 }
2265 } else {
2266 snapshot_name = optarg;
2267 }
2268 break;
2269 case 'S':
2270 {
2271 int64_t sval;
2272
2273 sval = cvtnum("buffer size for sparse output", optarg);
2274 if (sval < 0) {
2275 goto fail_getopt;
2276 } else if (!QEMU_IS_ALIGNED(sval, BDRV_SECTOR_SIZE) ||
2277 sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) {
2278 error_report("Invalid buffer size for sparse output specified. "
2279 "Valid sizes are multiples of %llu up to %llu. Select "
2280 "0 to disable sparse detection (fully allocates output).",
2281 BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE);
2282 goto fail_getopt;
2283 }
2284
2285 s.min_sparse = sval / BDRV_SECTOR_SIZE;
2286 explict_min_sparse = true;
2287 break;
2288 }
2289 case 'p':
2290 progress = true;
2291 break;
2292 case 't':
2293 cache = optarg;
2294 break;
2295 case 'T':
2296 src_cache = optarg;
2297 break;
2298 case 'q':
2299 s.quiet = true;
2300 break;
2301 case 'n':
2302 skip_create = true;
2303 break;
2304 case 'm':
2305 if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2306 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2307 error_report("Invalid number of coroutines. Allowed number of"
2308 " coroutines is between 1 and %d", MAX_COROUTINES);
2309 goto fail_getopt;
2310 }
2311 break;
2312 case 'W':
2313 s.wr_in_order = false;
2314 break;
2315 case 'U':
2316 force_share = true;
2317 break;
2318 case OPTION_OBJECT: {
2319 QemuOpts *object_opts;
2320 object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2321 optarg, true);
2322 if (!object_opts) {
2323 goto fail_getopt;
2324 }
2325 break;
2326 }
2327 case OPTION_IMAGE_OPTS:
2328 image_opts = true;
2329 break;
2330 case OPTION_SALVAGE:
2331 s.salvage = true;
2332 break;
2333 case OPTION_TARGET_IMAGE_OPTS:
2334 tgt_image_opts = true;
2335 break;
2336 case OPTION_TARGET_IS_ZERO:
2337 /*
2338 * The user asserting that the target is blank has the
2339 * same effect as the target driver supporting zero
2340 * initialisation.
2341 */
2342 s.has_zero_init = true;
2343 break;
2344 case OPTION_BITMAPS:
2345 bitmaps = true;
2346 break;
2347 }
2348 }
2349
2350 if (!out_fmt && !tgt_image_opts) {
2351 out_fmt = "raw";
2352 }
2353
2354 if (qemu_opts_foreach(&qemu_object_opts,
2355 user_creatable_add_opts_foreach,
2356 qemu_img_object_print_help, &error_fatal)) {
2357 goto fail_getopt;
2358 }
2359
2360 if (s.compressed && s.copy_range) {
2361 error_report("Cannot enable copy offloading when -c is used");
2362 goto fail_getopt;
2363 }
2364
2365 if (explict_min_sparse && s.copy_range) {
2366 error_report("Cannot enable copy offloading when -S is used");
2367 goto fail_getopt;
2368 }
2369
2370 if (s.copy_range && s.salvage) {
2371 error_report("Cannot use copy offloading in salvaging mode");
2372 goto fail_getopt;
2373 }
2374
2375 if (tgt_image_opts && !skip_create) {
2376 error_report("--target-image-opts requires use of -n flag");
2377 goto fail_getopt;
2378 }
2379
2380 if (skip_create && options) {
2381 warn_report("-o has no effect when skipping image creation");
2382 warn_report("This will become an error in future QEMU versions.");
2383 }
2384
2385 if (s.has_zero_init && !skip_create) {
2386 error_report("--target-is-zero requires use of -n flag");
2387 goto fail_getopt;
2388 }
2389
2390 s.src_num = argc - optind - 1;
2391 out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2392
2393 if (options && has_help_option(options)) {
2394 if (out_fmt) {
2395 ret = print_block_option_help(out_filename, out_fmt);
2396 goto fail_getopt;
2397 } else {
2398 error_report("Option help requires a format be specified");
2399 goto fail_getopt;
2400 }
2401 }
2402
2403 if (s.src_num < 1) {
2404 error_report("Must specify image file name");
2405 goto fail_getopt;
2406 }
2407
2408 /* ret is still -EINVAL until here */
2409 ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2410 if (ret < 0) {
2411 error_report("Invalid source cache option: %s", src_cache);
2412 goto fail_getopt;
2413 }
2414
2415 /* Initialize before goto out */
2416 if (s.quiet) {
2417 progress = false;
2418 }
2419 qemu_progress_init(progress, 1.0);
2420 qemu_progress_print(0, 100);
2421
2422 s.src = g_new0(BlockBackend *, s.src_num);
2423 s.src_sectors = g_new(int64_t, s.src_num);
2424
2425 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2426 s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2427 fmt, src_flags, src_writethrough, s.quiet,
2428 force_share);
2429 if (!s.src[bs_i]) {
2430 ret = -1;
2431 goto out;
2432 }
2433 s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2434 if (s.src_sectors[bs_i] < 0) {
2435 error_report("Could not get size of %s: %s",
2436 argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2437 ret = -1;
2438 goto out;
2439 }
2440 s.total_sectors += s.src_sectors[bs_i];
2441 }
2442
2443 if (sn_opts) {
2444 bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2445 qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2446 qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2447 &local_err);
2448 } else if (snapshot_name != NULL) {
2449 if (s.src_num > 1) {
2450 error_report("No support for concatenating multiple snapshot");
2451 ret = -1;
2452 goto out;
2453 }
2454
2455 bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2456 &local_err);
2457 }
2458 if (local_err) {
2459 error_reportf_err(local_err, "Failed to load snapshot: ");
2460 ret = -1;
2461 goto out;
2462 }
2463
2464 if (!skip_create) {
2465 /* Find driver and parse its options */
2466 drv = bdrv_find_format(out_fmt);
2467 if (!drv) {
2468 error_report("Unknown file format '%s'", out_fmt);
2469 ret = -1;
2470 goto out;
2471 }
2472
2473 proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2474 if (!proto_drv) {
2475 error_report_err(local_err);
2476 ret = -1;
2477 goto out;
2478 }
2479
2480 if (!drv->create_opts) {
2481 error_report("Format driver '%s' does not support image creation",
2482 drv->format_name);
2483 ret = -1;
2484 goto out;
2485 }
2486
2487 if (!proto_drv->create_opts) {
2488 error_report("Protocol driver '%s' does not support image creation",
2489 proto_drv->format_name);
2490 ret = -1;
2491 goto out;
2492 }
2493
2494 create_opts = qemu_opts_append(create_opts, drv->create_opts);
2495 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2496
2497 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2498 if (options) {
2499 qemu_opts_do_parse(opts, options, NULL, &local_err);
2500 if (local_err) {
2501 error_report_err(local_err);
2502 ret = -1;
2503 goto out;
2504 }
2505 }
2506
2507 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2508 &error_abort);
2509 ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2510 if (ret < 0) {
2511 goto out;
2512 }
2513 }
2514
2515 /* Get backing file name if -o backing_file was used */
2516 out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2517 if (out_baseimg_param) {
2518 out_baseimg = out_baseimg_param;
2519 }
2520 s.target_has_backing = (bool) out_baseimg;
2521
2522 if (s.has_zero_init && s.target_has_backing) {
2523 error_report("Cannot use --target-is-zero when the destination "
2524 "image has a backing file");
2525 goto out;
2526 }
2527
2528 if (s.src_num > 1 && out_baseimg) {
2529 error_report("Having a backing file for the target makes no sense when "
2530 "concatenating multiple input images");
2531 ret = -1;
2532 goto out;
2533 }
2534
2535 /* Check if compression is supported */
2536 if (s.compressed) {
2537 bool encryption =
2538 qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2539 const char *encryptfmt =
2540 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2541 const char *preallocation =
2542 qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2543
2544 if (drv && !block_driver_can_compress(drv)) {
2545 error_report("Compression not supported for this file format");
2546 ret = -1;
2547 goto out;
2548 }
2549
2550 if (encryption || encryptfmt) {
2551 error_report("Compression and encryption not supported at "
2552 "the same time");
2553 ret = -1;
2554 goto out;
2555 }
2556
2557 if (preallocation
2558 && strcmp(preallocation, "off"))
2559 {
2560 error_report("Compression and preallocation not supported at "
2561 "the same time");
2562 ret = -1;
2563 goto out;
2564 }
2565 }
2566
2567 /* Determine if bitmaps need copying */
2568 if (bitmaps) {
2569 if (s.src_num > 1) {
2570 error_report("Copying bitmaps only possible with single source");
2571 ret = -1;
2572 goto out;
2573 }
2574 if (!bdrv_supports_persistent_dirty_bitmap(blk_bs(s.src[0]))) {
2575 error_report("Source lacks bitmap support");
2576 ret = -1;
2577 goto out;
2578 }
2579 }
2580
2581 /*
2582 * The later open call will need any decryption secrets, and
2583 * bdrv_create() will purge "opts", so extract them now before
2584 * they are lost.
2585 */
2586 if (!skip_create) {
2587 open_opts = qdict_new();
2588 qemu_opt_foreach(opts, img_add_key_secrets, open_opts, &error_abort);
2589
2590 /* Create the new image */
2591 ret = bdrv_create(drv, out_filename, opts, &local_err);
2592 if (ret < 0) {
2593 error_reportf_err(local_err, "%s: error while converting %s: ",
2594 out_filename, out_fmt);
2595 goto out;
2596 }
2597 }
2598
2599 s.target_is_new = !skip_create;
2600
2601 flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2602 ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2603 if (ret < 0) {
2604 error_report("Invalid cache option: %s", cache);
2605 goto out;
2606 }
2607
2608 if (skip_create) {
2609 s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2610 flags, writethrough, s.quiet, false);
2611 } else {
2612 /* TODO ultimately we should allow --target-image-opts
2613 * to be used even when -n is not given.
2614 * That has to wait for bdrv_create to be improved
2615 * to allow filenames in option syntax
2616 */
2617 s.target = img_open_file(out_filename, open_opts, out_fmt,
2618 flags, writethrough, s.quiet, false);
2619 open_opts = NULL; /* blk_new_open will have freed it */
2620 }
2621 if (!s.target) {
2622 ret = -1;
2623 goto out;
2624 }
2625 out_bs = blk_bs(s.target);
2626
2627 if (bitmaps && !bdrv_supports_persistent_dirty_bitmap(out_bs)) {
2628 error_report("Format driver '%s' does not support bitmaps",
2629 out_bs->drv->format_name);
2630 ret = -1;
2631 goto out;
2632 }
2633
2634 if (s.compressed && !block_driver_can_compress(out_bs->drv)) {
2635 error_report("Compression not supported for this file format");
2636 ret = -1;
2637 goto out;
2638 }
2639
2640 /* increase bufsectors from the default 4096 (2M) if opt_transfer
2641 * or discard_alignment of the out_bs is greater. Limit to
2642 * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2643 s.buf_sectors = MIN(MAX_BUF_SECTORS,
2644 MAX(s.buf_sectors,
2645 MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2646 out_bs->bl.pdiscard_alignment >>
2647 BDRV_SECTOR_BITS)));
2648
2649 /* try to align the write requests to the destination to avoid unnecessary
2650 * RMW cycles. */
2651 s.alignment = MAX(pow2floor(s.min_sparse),
2652 DIV_ROUND_UP(out_bs->bl.request_alignment,
2653 BDRV_SECTOR_SIZE));
2654 assert(is_power_of_2(s.alignment));
2655
2656 if (skip_create) {
2657 int64_t output_sectors = blk_nb_sectors(s.target);
2658 if (output_sectors < 0) {
2659 error_report("unable to get output image length: %s",
2660 strerror(-output_sectors));
2661 ret = -1;
2662 goto out;
2663 } else if (output_sectors < s.total_sectors) {
2664 error_report("output file is smaller than input file");
2665 ret = -1;
2666 goto out;
2667 }
2668 }
2669
2670 if (s.target_has_backing && s.target_is_new) {
2671 /* Errors are treated as "backing length unknown" (which means
2672 * s.target_backing_sectors has to be negative, which it will
2673 * be automatically). The backing file length is used only
2674 * for optimizations, so such a case is not fatal. */
2675 s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
2676 } else {
2677 s.target_backing_sectors = -1;
2678 }
2679
2680 ret = bdrv_get_info(out_bs, &bdi);
2681 if (ret < 0) {
2682 if (s.compressed) {
2683 error_report("could not get block driver info");
2684 goto out;
2685 }
2686 } else {
2687 s.compressed = s.compressed || bdi.needs_compressed_writes;
2688 s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2689 s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;
2690 }
2691
2692 ret = convert_do_copy(&s);
2693
2694 /* Now copy the bitmaps */
2695 if (bitmaps && ret == 0) {
2696 ret = convert_copy_bitmaps(blk_bs(s.src[0]), out_bs);
2697 }
2698
2699 out:
2700 if (!ret) {
2701 qemu_progress_print(100, 0);
2702 }
2703 qemu_progress_end();
2704 qemu_opts_del(opts);
2705 qemu_opts_free(create_opts);
2706 qemu_opts_del(sn_opts);
2707 qobject_unref(open_opts);
2708 blk_unref(s.target);
2709 if (s.src) {
2710 for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2711 blk_unref(s.src[bs_i]);
2712 }
2713 g_free(s.src);
2714 }
2715 g_free(s.src_sectors);
2716 fail_getopt:
2717 g_free(options);
2718
2719 return !!ret;
2720 }
2721
2722
2723 static void dump_snapshots(BlockDriverState *bs)
2724 {
2725 QEMUSnapshotInfo *sn_tab, *sn;
2726 int nb_sns, i;
2727
2728 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2729 if (nb_sns <= 0)
2730 return;
2731 printf("Snapshot list:\n");
2732 bdrv_snapshot_dump(NULL);
2733 printf("\n");
2734 for(i = 0; i < nb_sns; i++) {
2735 sn = &sn_tab[i];
2736 bdrv_snapshot_dump(sn);
2737 printf("\n");
2738 }
2739 g_free(sn_tab);
2740 }
2741
2742 static void dump_json_image_info_list(ImageInfoList *list)
2743 {
2744 QString *str;
2745 QObject *obj;
2746 Visitor *v = qobject_output_visitor_new(&obj);
2747
2748 visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2749 visit_complete(v, &obj);
2750 str = qobject_to_json_pretty(obj);
2751 assert(str != NULL);
2752 printf("%s\n", qstring_get_str(str));
2753 qobject_unref(obj);
2754 visit_free(v);
2755 qobject_unref(str);
2756 }
2757
2758 static void dump_json_image_info(ImageInfo *info)
2759 {
2760 QString *str;
2761 QObject *obj;
2762 Visitor *v = qobject_output_visitor_new(&obj);
2763
2764 visit_type_ImageInfo(v, NULL, &info, &error_abort);
2765 visit_complete(v, &obj);
2766 str = qobject_to_json_pretty(obj);
2767 assert(str != NULL);
2768 printf("%s\n", qstring_get_str(str));
2769 qobject_unref(obj);
2770 visit_free(v);
2771 qobject_unref(str);
2772 }
2773
2774 static void dump_human_image_info_list(ImageInfoList *list)
2775 {
2776 ImageInfoList *elem;
2777 bool delim = false;
2778
2779 for (elem = list; elem; elem = elem->next) {
2780 if (delim) {
2781 printf("\n");
2782 }
2783 delim = true;
2784
2785 bdrv_image_info_dump(elem->value);
2786 }
2787 }
2788
2789 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2790 {
2791 return strcmp(a, b) == 0;
2792 }
2793
2794 /**
2795 * Open an image file chain and return an ImageInfoList
2796 *
2797 * @filename: topmost image filename
2798 * @fmt: topmost image format (may be NULL to autodetect)
2799 * @chain: true - enumerate entire backing file chain
2800 * false - only topmost image file
2801 *
2802 * Returns a list of ImageInfo objects or NULL if there was an error opening an
2803 * image file. If there was an error a message will have been printed to
2804 * stderr.
2805 */
2806 static ImageInfoList *collect_image_info_list(bool image_opts,
2807 const char *filename,
2808 const char *fmt,
2809 bool chain, bool force_share)
2810 {
2811 ImageInfoList *head = NULL;
2812 ImageInfoList **last = &head;
2813 GHashTable *filenames;
2814 Error *err = NULL;
2815
2816 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2817
2818 while (filename) {
2819 BlockBackend *blk;
2820 BlockDriverState *bs;
2821 ImageInfo *info;
2822 ImageInfoList *elem;
2823
2824 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2825 error_report("Backing file '%s' creates an infinite loop.",
2826 filename);
2827 goto err;
2828 }
2829 g_hash_table_insert(filenames, (gpointer)filename, NULL);
2830
2831 blk = img_open(image_opts, filename, fmt,
2832 BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2833 force_share);
2834 if (!blk) {
2835 goto err;
2836 }
2837 bs = blk_bs(blk);
2838
2839 bdrv_query_image_info(bs, &info, &err);
2840 if (err) {
2841 error_report_err(err);
2842 blk_unref(blk);
2843 goto err;
2844 }
2845
2846 elem = g_new0(ImageInfoList, 1);
2847 elem->value = info;
2848 *last = elem;
2849 last = &elem->next;
2850
2851 blk_unref(blk);
2852
2853 /* Clear parameters that only apply to the topmost image */
2854 filename = fmt = NULL;
2855 image_opts = false;
2856
2857 if (chain) {
2858 if (info->has_full_backing_filename) {
2859 filename = info->full_backing_filename;
2860 } else if (info->has_backing_filename) {
2861 error_report("Could not determine absolute backing filename,"
2862 " but backing filename '%s' present",
2863 info->backing_filename);
2864 goto err;
2865 }
2866 if (info->has_backing_filename_format) {
2867 fmt = info->backing_filename_format;
2868 }
2869 }
2870 }
2871 g_hash_table_destroy(filenames);
2872 return head;
2873
2874 err:
2875 qapi_free_ImageInfoList(head);
2876 g_hash_table_destroy(filenames);
2877 return NULL;
2878 }
2879
2880 static int img_info(int argc, char **argv)
2881 {
2882 int c;
2883 OutputFormat output_format = OFORMAT_HUMAN;
2884 bool chain = false;
2885 const char *filename, *fmt, *output;
2886 ImageInfoList *list;
2887 bool image_opts = false;
2888 bool force_share = false;
2889
2890 fmt = NULL;
2891 output = NULL;
2892 for(;;) {
2893 int option_index = 0;
2894 static const struct option long_options[] = {
2895 {"help", no_argument, 0, 'h'},
2896 {"format", required_argument, 0, 'f'},
2897 {"output", required_argument, 0, OPTION_OUTPUT},
2898 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2899 {"object", required_argument, 0, OPTION_OBJECT},
2900 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2901 {"force-share", no_argument, 0, 'U'},
2902 {0, 0, 0, 0}
2903 };
2904 c = getopt_long(argc, argv, ":f:hU",
2905 long_options, &option_index);
2906 if (c == -1) {
2907 break;
2908 }
2909 switch(c) {
2910 case ':':
2911 missing_argument(argv[optind - 1]);
2912 break;
2913 case '?':
2914 unrecognized_option(argv[optind - 1]);
2915 break;
2916 case 'h':
2917 help();
2918 break;
2919 case 'f':
2920 fmt = optarg;
2921 break;
2922 case 'U':
2923 force_share = true;
2924 break;
2925 case OPTION_OUTPUT:
2926 output = optarg;
2927 break;
2928 case OPTION_BACKING_CHAIN:
2929 chain = true;
2930 break;
2931 case OPTION_OBJECT: {
2932 QemuOpts *opts;
2933 opts = qemu_opts_parse_noisily(&qemu_object_opts,
2934 optarg, true);
2935 if (!opts) {
2936 return 1;
2937 }
2938 } break;
2939 case OPTION_IMAGE_OPTS:
2940 image_opts = true;
2941 break;
2942 }
2943 }
2944 if (optind != argc - 1) {
2945 error_exit("Expecting one image file name");
2946 }
2947 filename = argv[optind++];
2948
2949 if (output && !strcmp(output, "json")) {
2950 output_format = OFORMAT_JSON;
2951 } else if (output && !strcmp(output, "human")) {
2952 output_format = OFORMAT_HUMAN;
2953 } else if (output) {
2954 error_report("--output must be used with human or json as argument.");
2955 return 1;
2956 }
2957
2958 if (qemu_opts_foreach(&qemu_object_opts,
2959 user_creatable_add_opts_foreach,
2960 qemu_img_object_print_help, &error_fatal)) {
2961 return 1;
2962 }
2963
2964 list = collect_image_info_list(image_opts, filename, fmt, chain,
2965 force_share);
2966 if (!list) {
2967 return 1;
2968 }
2969
2970 switch (output_format) {
2971 case OFORMAT_HUMAN:
2972 dump_human_image_info_list(list);
2973 break;
2974 case OFORMAT_JSON:
2975 if (chain) {
2976 dump_json_image_info_list(list);
2977 } else {
2978 dump_json_image_info(list->value);
2979 }
2980 break;
2981 }
2982
2983 qapi_free_ImageInfoList(list);
2984 return 0;
2985 }
2986
2987 static int dump_map_entry(OutputFormat output_format, MapEntry *e,
2988 MapEntry *next)
2989 {
2990 switch (output_format) {
2991 case OFORMAT_HUMAN:
2992 if (e->data && !e->has_offset) {
2993 error_report("File contains external, encrypted or compressed clusters.");
2994 return -1;
2995 }
2996 if (e->data && !e->zero) {
2997 printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2998 e->start, e->length,
2999 e->has_offset ? e->offset : 0,
3000 e->has_filename ? e->filename : "");
3001 }
3002 /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
3003 * Modify the flags here to allow more coalescing.
3004 */
3005 if (next && (!next->data || next->zero)) {
3006 next->data = false;
3007 next->zero = true;
3008 }
3009 break;
3010 case OFORMAT_JSON:
3011 printf("{ \"start\": %"PRId64", \"length\": %"PRId64","
3012 " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
3013 e->start, e->length, e->depth,
3014 e->zero ? "true" : "false",
3015 e->data ? "true" : "false");
3016 if (e->has_offset) {
3017 printf(", \"offset\": %"PRId64"", e->offset);
3018 }
3019 putchar('}');
3020
3021 if (next) {
3022 puts(",");
3023 }
3024 break;
3025 }
3026 return 0;
3027 }
3028
3029 static int get_block_status(BlockDriverState *bs, int64_t offset,
3030 int64_t bytes, MapEntry *e)
3031 {
3032 int ret;
3033 int depth;
3034 BlockDriverState *file;
3035 bool has_offset;
3036 int64_t map;
3037 char *filename = NULL;
3038
3039 /* As an optimization, we could cache the current range of unallocated
3040 * clusters in each file of the chain, and avoid querying the same
3041 * range repeatedly.
3042 */
3043
3044 depth = 0;
3045 for (;;) {
3046 ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file);
3047 if (ret < 0) {
3048 return ret;
3049 }
3050 assert(bytes);
3051 if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
3052 break;
3053 }
3054 bs = backing_bs(bs);
3055 if (bs == NULL) {
3056 ret = 0;
3057 break;
3058 }
3059
3060 depth++;
3061 }
3062
3063 has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
3064
3065 if (file && has_offset) {
3066 bdrv_refresh_filename(file);
3067 filename = file->filename;
3068 }
3069
3070 *e = (MapEntry) {
3071 .start = offset,
3072 .length = bytes,
3073 .data = !!(ret & BDRV_BLOCK_DATA),
3074 .zero = !!(ret & BDRV_BLOCK_ZERO),
3075 .offset = map,
3076 .has_offset = has_offset,
3077 .depth = depth,
3078 .has_filename = filename,
3079 .filename = filename,
3080 };
3081
3082 return 0;
3083 }
3084
3085 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
3086 {
3087 if (curr->length == 0) {
3088 return false;
3089 }
3090 if (curr->zero != next->zero ||
3091 curr->data != next->data ||
3092 curr->depth != next->depth ||
3093 curr->has_filename != next->has_filename ||
3094 curr->has_offset != next->has_offset) {
3095 return false;
3096 }
3097 if (curr->has_filename && strcmp(curr->filename, next->filename)) {
3098 return false;
3099 }
3100 if (curr->has_offset && curr->offset + curr->length != next->offset) {
3101 return false;
3102 }
3103 return true;
3104 }
3105
3106 static int img_map(int argc, char **argv)
3107 {
3108 int c;
3109 OutputFormat output_format = OFORMAT_HUMAN;
3110 BlockBackend *blk;
3111 BlockDriverState *bs;
3112 const char *filename, *fmt, *output;
3113 int64_t length;
3114 MapEntry curr = { .length = 0 }, next;
3115 int ret = 0;
3116 bool image_opts = false;
3117 bool force_share = false;
3118 int64_t start_offset = 0;
3119 int64_t max_length = -1;
3120
3121 fmt = NULL;
3122 output = NULL;
3123 for (;;) {
3124 int option_index = 0;
3125 static const struct option long_options[] = {
3126 {"help", no_argument, 0, 'h'},
3127 {"format", required_argument, 0, 'f'},
3128 {"output", required_argument, 0, OPTION_OUTPUT},
3129 {"object", required_argument, 0, OPTION_OBJECT},
3130 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3131 {"force-share", no_argument, 0, 'U'},
3132 {"start-offset", required_argument, 0, 's'},
3133 {"max-length", required_argument, 0, 'l'},
3134 {0, 0, 0, 0}
3135 };
3136 c = getopt_long(argc, argv, ":f:s:l:hU",
3137 long_options, &option_index);
3138 if (c == -1) {
3139 break;
3140 }
3141 switch (c) {
3142 case ':':
3143 missing_argument(argv[optind - 1]);
3144 break;
3145 case '?':
3146 unrecognized_option(argv[optind - 1]);
3147 break;
3148 case 'h':
3149 help();
3150 break;
3151 case 'f':
3152 fmt = optarg;
3153 break;
3154 case 'U':
3155 force_share = true;
3156 break;
3157 case OPTION_OUTPUT:
3158 output = optarg;
3159 break;
3160 case 's':
3161 start_offset = cvtnum("start offset", optarg);
3162 if (start_offset < 0) {
3163 return 1;
3164 }
3165 break;
3166 case 'l':
3167 max_length = cvtnum("max length", optarg);
3168 if (max_length < 0) {
3169 return 1;
3170 }
3171 break;
3172 case OPTION_OBJECT: {
3173 QemuOpts *opts;
3174 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3175 optarg, true);
3176 if (!opts) {
3177 return 1;
3178 }
3179 } break;
3180 case OPTION_IMAGE_OPTS:
3181 image_opts = true;
3182 break;
3183 }
3184 }
3185 if (optind != argc - 1) {
3186 error_exit("Expecting one image file name");
3187 }
3188 filename = argv[optind];
3189
3190 if (output && !strcmp(output, "json")) {
3191 output_format = OFORMAT_JSON;
3192 } else if (output && !strcmp(output, "human")) {
3193 output_format = OFORMAT_HUMAN;
3194 } else if (output) {
3195 error_report("--output must be used with human or json as argument.");
3196 return 1;
3197 }
3198
3199 if (qemu_opts_foreach(&qemu_object_opts,
3200 user_creatable_add_opts_foreach,
3201 qemu_img_object_print_help, &error_fatal)) {
3202 return 1;
3203 }
3204
3205 blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
3206 if (!blk) {
3207 return 1;
3208 }
3209 bs = blk_bs(blk);
3210
3211 if (output_format == OFORMAT_HUMAN) {
3212 printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
3213 } else if (output_format == OFORMAT_JSON) {
3214 putchar('[');
3215 }
3216
3217 length = blk_getlength(blk);
3218 if (length < 0) {
3219 error_report("Failed to get size for '%s'", filename);
3220 return 1;
3221 }
3222 if (max_length != -1) {
3223 length = MIN(start_offset + max_length, length);
3224 }
3225
3226 curr.start = start_offset;
3227 while (curr.start + curr.length < length) {
3228 int64_t offset = curr.start + curr.length;
3229 int64_t n;
3230
3231 /* Probe up to 1 GiB at a time. */
3232 n = MIN(1 * GiB, length - offset);
3233 ret = get_block_status(bs, offset, n, &next);
3234
3235 if (ret < 0) {
3236 error_report("Could not read file metadata: %s", strerror(-ret));
3237 goto out;
3238 }
3239
3240 if (entry_mergeable(&curr, &next)) {
3241 curr.length += next.length;
3242 continue;
3243 }
3244
3245 if (curr.length > 0) {
3246 ret = dump_map_entry(output_format, &curr, &next);
3247 if (ret < 0) {
3248 goto out;
3249 }
3250 }
3251 curr = next;
3252 }
3253
3254 ret = dump_map_entry(output_format, &curr, NULL);
3255 if (output_format == OFORMAT_JSON) {
3256 puts("]");
3257 }
3258
3259 out:
3260 blk_unref(blk);
3261 return ret < 0;
3262 }
3263
3264 #define SNAPSHOT_LIST 1
3265 #define SNAPSHOT_CREATE 2
3266 #define SNAPSHOT_APPLY 3
3267 #define SNAPSHOT_DELETE 4
3268
3269 static int img_snapshot(int argc, char **argv)
3270 {
3271 BlockBackend *blk;
3272 BlockDriverState *bs;
3273 QEMUSnapshotInfo sn;
3274 char *filename, *snapshot_name = NULL;
3275 int c, ret = 0, bdrv_oflags;
3276 int action = 0;
3277 qemu_timeval tv;
3278 bool quiet = false;
3279 Error *err = NULL;
3280 bool image_opts = false;
3281 bool force_share = false;
3282
3283 bdrv_oflags = BDRV_O_RDWR;
3284 /* Parse commandline parameters */
3285 for(;;) {
3286 static const struct option long_options[] = {
3287 {"help", no_argument, 0, 'h'},
3288 {"object", required_argument, 0, OPTION_OBJECT},
3289 {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3290 {"force-share", no_argument, 0, 'U'},
3291 {0, 0, 0, 0}
3292 };
3293 c = getopt_long(argc, argv, ":la:c:d:hqU",
3294 long_options, NULL);
3295 if (c == -1) {
3296 break;
3297 }
3298 switch(c) {
3299 case ':':
3300 missing_argument(argv[optind - 1]);
3301 break;
3302 case '?':
3303 unrecognized_option(argv[optind - 1]);
3304 break;
3305 case 'h':
3306 help();
3307 return 0;
3308 case 'l':
3309 if (action) {
3310 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3311 return 0;
3312 }
3313 action = SNAPSHOT_LIST;
3314 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
3315 break;
3316 case 'a':
3317 if (action) {
3318 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3319 return 0;
3320 }
3321 action = SNAPSHOT_APPLY;
3322 snapshot_name = optarg;
3323 break;
3324 case 'c':
3325 if (action) {
3326 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3327 return 0;
3328 }
3329 action = SNAPSHOT_CREATE;
3330 snapshot_name = optarg;
3331 break;
3332 case 'd':
3333 if (action) {
3334 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3335 return 0;
3336 }
3337 action = SNAPSHOT_DELETE;
3338 snapshot_name = optarg;
3339 break;
3340 case 'q':
3341 quiet = true;
3342 break;
3343 case 'U':
3344 force_share = true;
3345 break;
3346 case OPTION_OBJECT: {
3347 QemuOpts *opts;
3348 opts = qemu_opts_parse_noisily(&qemu_object_opts,
3349 optarg, true);
3350 if (!opts) {
3351 return 1;
3352 }
3353 } break;
3354 case OPTION_IMAGE_OPTS:
3355 image_opts = true;
3356 break;
3357 }
3358 }
3359
3360 if (optind != argc - 1) {
3361 error_exit("Expecting one image file name");
3362 }
3363 filename = argv[optind++];
3364
3365 if (qemu_opts_foreach(&qemu_object_opts,
3366 user_creatable_add_opts_foreach,
3367 qemu_img_object_print_help, &error_fatal)) {
3368 return 1;
3369 }
3370
3371 /* Open the image */
3372 blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
3373 force_share);
3374 if (!blk) {
3375 return 1;
3376 }
3377 bs = blk_bs(blk);
3378
3379 /* Perform the requested action */
3380 switch(action) {
3381 case SNAPSHOT_LIST:
3382 dump_snapshots(bs);
3383 break;
3384
3385 case SNAPSHOT_CREATE:
3386 memset(&sn, 0, sizeof(sn));
3387 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3388
3389 qemu_gettimeofday(&tv);
3390 sn.date_sec = tv.tv_sec;
3391 sn.date_nsec = tv.tv_usec * 1000;
3392
3393 ret = bdrv_snapshot_create(bs, &sn);
3394 if (ret) {
3395 error_report("Could not create snapshot '%s': %d (%s)",
3396 snapshot_name, ret, strerror(-ret));
3397 }
3398 break;
3399
3400 case SNAPSHOT_APPLY:
3401 ret = bdrv_snapshot_goto(bs, snapshot_name, &err);
3402 if (ret) {
3403 error_reportf_err(err, "Could not apply snapshot '%s': ",
3404 snapshot_name);
3405 }
3406 break;
3407
3408 case SNAPSHOT_DELETE:
3409 ret = bdrv_snapshot_find(bs, &sn, snapshot_name);
3410 if (ret < 0