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