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