xref: /openbmc/qemu/qemu-img.c (revision 500eb6db)
1 /*
2  * QEMU disk image utility
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 #include <getopt.h>
27 
28 #include "qemu-common.h"
29 #include "qemu-version.h"
30 #include "qapi/error.h"
31 #include "qapi/qapi-visit-block-core.h"
32 #include "qapi/qobject-output-visitor.h"
33 #include "qapi/qmp/qjson.h"
34 #include "qapi/qmp/qdict.h"
35 #include "qapi/qmp/qstring.h"
36 #include "qemu/cutils.h"
37 #include "qemu/config-file.h"
38 #include "qemu/option.h"
39 #include "qemu/error-report.h"
40 #include "qemu/log.h"
41 #include "qemu/module.h"
42 #include "qemu/units.h"
43 #include "qom/object_interfaces.h"
44 #include "sysemu/sysemu.h"
45 #include "sysemu/block-backend.h"
46 #include "block/block_int.h"
47 #include "block/blockjob.h"
48 #include "block/qapi.h"
49 #include "crypto/init.h"
50 #include "trace/control.h"
51 
52 #define QEMU_IMG_VERSION "qemu-img version " QEMU_FULL_VERSION \
53                           "\n" QEMU_COPYRIGHT "\n"
54 
55 typedef struct img_cmd_t {
56     const char *name;
57     int (*handler)(int argc, char **argv);
58 } img_cmd_t;
59 
60 enum {
61     OPTION_OUTPUT = 256,
62     OPTION_BACKING_CHAIN = 257,
63     OPTION_OBJECT = 258,
64     OPTION_IMAGE_OPTS = 259,
65     OPTION_PATTERN = 260,
66     OPTION_FLUSH_INTERVAL = 261,
67     OPTION_NO_DRAIN = 262,
68     OPTION_TARGET_IMAGE_OPTS = 263,
69     OPTION_SIZE = 264,
70     OPTION_PREALLOCATION = 265,
71     OPTION_SHRINK = 266,
72     OPTION_SALVAGE = 267,
73 };
74 
75 typedef enum OutputFormat {
76     OFORMAT_JSON,
77     OFORMAT_HUMAN,
78 } OutputFormat;
79 
80 /* Default to cache=writeback as data integrity is not important for qemu-img */
81 #define BDRV_DEFAULT_CACHE "writeback"
82 
83 static void format_print(void *opaque, const char *name)
84 {
85     printf(" %s", name);
86 }
87 
88 static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
89 {
90     va_list ap;
91 
92     va_start(ap, fmt);
93     error_vreport(fmt, ap);
94     va_end(ap);
95 
96     error_printf("Try 'qemu-img --help' for more information\n");
97     exit(EXIT_FAILURE);
98 }
99 
100 static void QEMU_NORETURN missing_argument(const char *option)
101 {
102     error_exit("missing argument for option '%s'", option);
103 }
104 
105 static void QEMU_NORETURN unrecognized_option(const char *option)
106 {
107     error_exit("unrecognized option '%s'", option);
108 }
109 
110 /* Please keep in synch with qemu-img.texi */
111 static void QEMU_NORETURN help(void)
112 {
113     const char *help_msg =
114            QEMU_IMG_VERSION
115            "usage: qemu-img [standard options] command [command options]\n"
116            "QEMU disk image utility\n"
117            "\n"
118            "    '-h', '--help'       display this help and exit\n"
119            "    '-V', '--version'    output version information and exit\n"
120            "    '-T', '--trace'      [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
121            "                         specify tracing options\n"
122            "\n"
123            "Command syntax:\n"
124 #define DEF(option, callback, arg_string)        \
125            "  " arg_string "\n"
126 #include "qemu-img-cmds.h"
127 #undef DEF
128            "\n"
129            "Command parameters:\n"
130            "  'filename' is a disk image filename\n"
131            "  'objectdef' is a QEMU user creatable object definition. See the qemu(1)\n"
132            "    manual page for a description of the object properties. The most common\n"
133            "    object type is a 'secret', which is used to supply passwords and/or\n"
134            "    encryption keys.\n"
135            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
136            "  'cache' is the cache mode used to write the output disk image, the valid\n"
137            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
138            "    'directsync' and 'unsafe' (default for convert)\n"
139            "  'src_cache' is the cache mode used to read input disk images, the valid\n"
140            "    options are the same as for the 'cache' option\n"
141            "  'size' is the disk image size in bytes. Optional suffixes\n"
142            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
143            "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
144            "    supported. 'b' is ignored.\n"
145            "  'output_filename' is the destination disk image filename\n"
146            "  'output_fmt' is the destination format\n"
147            "  'options' is a comma separated list of format specific options in a\n"
148            "    name=value format. Use -o ? for an overview of the options supported by the\n"
149            "    used format\n"
150            "  'snapshot_param' is param used for internal snapshot, format\n"
151            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
152            "    '[ID_OR_NAME]'\n"
153            "  '-c' indicates that target image must be compressed (qcow format only)\n"
154            "  '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
155            "       new backing file match exactly. The image doesn't need a working\n"
156            "       backing file before rebasing in this case (useful for renaming the\n"
157            "       backing file). For image creation, allow creating without attempting\n"
158            "       to open the backing file.\n"
159            "  '-h' with or without a command shows this help and lists the supported formats\n"
160            "  '-p' show progress of command (only certain commands)\n"
161            "  '-q' use Quiet mode - do not print any output (except errors)\n"
162            "  '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
163            "       contain only zeros for qemu-img to create a sparse image during\n"
164            "       conversion. If the number of bytes is 0, the source will not be scanned for\n"
165            "       unallocated or zero sectors, and the destination image will always be\n"
166            "       fully allocated\n"
167            "  '--output' takes the format in which the output must be done (human or json)\n"
168            "  '-n' skips the target volume creation (useful if the volume is created\n"
169            "       prior to running qemu-img)\n"
170            "\n"
171            "Parameters to check subcommand:\n"
172            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
173            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
174            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
175            "       hiding corruption that has already occurred.\n"
176            "\n"
177            "Parameters to convert subcommand:\n"
178            "  '-m' specifies how many coroutines work in parallel during the convert\n"
179            "       process (defaults to 8)\n"
180            "  '-W' allow to write to the target out of order rather than sequential\n"
181            "\n"
182            "Parameters to snapshot subcommand:\n"
183            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
184            "  '-a' applies a snapshot (revert disk to saved state)\n"
185            "  '-c' creates a snapshot\n"
186            "  '-d' deletes a snapshot\n"
187            "  '-l' lists all snapshots in the given image\n"
188            "\n"
189            "Parameters to compare subcommand:\n"
190            "  '-f' first image format\n"
191            "  '-F' second image format\n"
192            "  '-s' run in Strict mode - fail on different image size or sector allocation\n"
193            "\n"
194            "Parameters to dd subcommand:\n"
195            "  'bs=BYTES' read and write up to BYTES bytes at a time "
196            "(default: 512)\n"
197            "  'count=N' copy only N input blocks\n"
198            "  'if=FILE' read from FILE\n"
199            "  'of=FILE' write to FILE\n"
200            "  'skip=N' skip N bs-sized blocks at the start of input\n";
201 
202     printf("%s\nSupported formats:", help_msg);
203     bdrv_iterate_format(format_print, NULL, false);
204     printf("\n\n" QEMU_HELP_BOTTOM "\n");
205     exit(EXIT_SUCCESS);
206 }
207 
208 static QemuOptsList qemu_object_opts = {
209     .name = "object",
210     .implied_opt_name = "qom-type",
211     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
212     .desc = {
213         { }
214     },
215 };
216 
217 static QemuOptsList qemu_source_opts = {
218     .name = "source",
219     .implied_opt_name = "file",
220     .head = QTAILQ_HEAD_INITIALIZER(qemu_source_opts.head),
221     .desc = {
222         { }
223     },
224 };
225 
226 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
227 {
228     int ret = 0;
229     if (!quiet) {
230         va_list args;
231         va_start(args, fmt);
232         ret = vprintf(fmt, args);
233         va_end(args);
234     }
235     return ret;
236 }
237 
238 
239 static int print_block_option_help(const char *filename, const char *fmt)
240 {
241     BlockDriver *drv, *proto_drv;
242     QemuOptsList *create_opts = NULL;
243     Error *local_err = NULL;
244 
245     /* Find driver and parse its options */
246     drv = bdrv_find_format(fmt);
247     if (!drv) {
248         error_report("Unknown file format '%s'", fmt);
249         return 1;
250     }
251 
252     if (!drv->create_opts) {
253         error_report("Format driver '%s' does not support image creation", fmt);
254         return 1;
255     }
256 
257     create_opts = qemu_opts_append(create_opts, drv->create_opts);
258     if (filename) {
259         proto_drv = bdrv_find_protocol(filename, true, &local_err);
260         if (!proto_drv) {
261             error_report_err(local_err);
262             qemu_opts_free(create_opts);
263             return 1;
264         }
265         if (!proto_drv->create_opts) {
266             error_report("Protocol driver '%s' does not support image creation",
267                          proto_drv->format_name);
268             qemu_opts_free(create_opts);
269             return 1;
270         }
271         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
272     }
273 
274     if (filename) {
275         printf("Supported options:\n");
276     } else {
277         printf("Supported %s options:\n", fmt);
278     }
279     qemu_opts_print_help(create_opts, false);
280     qemu_opts_free(create_opts);
281 
282     if (!filename) {
283         printf("\n"
284                "The protocol level may support further options.\n"
285                "Specify the target filename to include those options.\n");
286     }
287 
288     return 0;
289 }
290 
291 
292 static BlockBackend *img_open_opts(const char *optstr,
293                                    QemuOpts *opts, int flags, bool writethrough,
294                                    bool quiet, bool force_share)
295 {
296     QDict *options;
297     Error *local_err = NULL;
298     BlockBackend *blk;
299     options = qemu_opts_to_qdict(opts, NULL);
300     if (force_share) {
301         if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
302             && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) {
303             error_report("--force-share/-U conflicts with image options");
304             qobject_unref(options);
305             return NULL;
306         }
307         qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on");
308     }
309     blk = blk_new_open(NULL, NULL, options, flags, &local_err);
310     if (!blk) {
311         error_reportf_err(local_err, "Could not open '%s': ", optstr);
312         return NULL;
313     }
314     blk_set_enable_write_cache(blk, !writethrough);
315 
316     return blk;
317 }
318 
319 static BlockBackend *img_open_file(const char *filename,
320                                    QDict *options,
321                                    const char *fmt, int flags,
322                                    bool writethrough, bool quiet,
323                                    bool force_share)
324 {
325     BlockBackend *blk;
326     Error *local_err = NULL;
327 
328     if (!options) {
329         options = qdict_new();
330     }
331     if (fmt) {
332         qdict_put_str(options, "driver", fmt);
333     }
334 
335     if (force_share) {
336         qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
337     }
338     blk = blk_new_open(filename, NULL, options, flags, &local_err);
339     if (!blk) {
340         error_reportf_err(local_err, "Could not open '%s': ", filename);
341         return NULL;
342     }
343     blk_set_enable_write_cache(blk, !writethrough);
344 
345     return blk;
346 }
347 
348 
349 static int img_add_key_secrets(void *opaque,
350                                const char *name, const char *value,
351                                Error **errp)
352 {
353     QDict *options = opaque;
354 
355     if (g_str_has_suffix(name, "key-secret")) {
356         qdict_put_str(options, name, value);
357     }
358 
359     return 0;
360 }
361 
362 
363 static BlockBackend *img_open(bool image_opts,
364                               const char *filename,
365                               const char *fmt, int flags, bool writethrough,
366                               bool quiet, bool force_share)
367 {
368     BlockBackend *blk;
369     if (image_opts) {
370         QemuOpts *opts;
371         if (fmt) {
372             error_report("--image-opts and --format are mutually exclusive");
373             return NULL;
374         }
375         opts = qemu_opts_parse_noisily(qemu_find_opts("source"),
376                                        filename, true);
377         if (!opts) {
378             return NULL;
379         }
380         blk = img_open_opts(filename, opts, flags, writethrough, quiet,
381                             force_share);
382     } else {
383         blk = img_open_file(filename, NULL, fmt, flags, writethrough, quiet,
384                             force_share);
385     }
386     return blk;
387 }
388 
389 
390 static int add_old_style_options(const char *fmt, QemuOpts *opts,
391                                  const char *base_filename,
392                                  const char *base_fmt)
393 {
394     Error *err = NULL;
395 
396     if (base_filename) {
397         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
398         if (err) {
399             error_report("Backing file not supported for file format '%s'",
400                          fmt);
401             error_free(err);
402             return -1;
403         }
404     }
405     if (base_fmt) {
406         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
407         if (err) {
408             error_report("Backing file format not supported for file "
409                          "format '%s'", fmt);
410             error_free(err);
411             return -1;
412         }
413     }
414     return 0;
415 }
416 
417 static int64_t cvtnum(const char *s)
418 {
419     int err;
420     uint64_t value;
421 
422     err = qemu_strtosz(s, NULL, &value);
423     if (err < 0) {
424         return err;
425     }
426     if (value > INT64_MAX) {
427         return -ERANGE;
428     }
429     return value;
430 }
431 
432 static int img_create(int argc, char **argv)
433 {
434     int c;
435     uint64_t img_size = -1;
436     const char *fmt = "raw";
437     const char *base_fmt = NULL;
438     const char *filename;
439     const char *base_filename = NULL;
440     char *options = NULL;
441     Error *local_err = NULL;
442     bool quiet = false;
443     int flags = 0;
444 
445     for(;;) {
446         static const struct option long_options[] = {
447             {"help", no_argument, 0, 'h'},
448             {"object", required_argument, 0, OPTION_OBJECT},
449             {0, 0, 0, 0}
450         };
451         c = getopt_long(argc, argv, ":F:b:f:ho:qu",
452                         long_options, NULL);
453         if (c == -1) {
454             break;
455         }
456         switch(c) {
457         case ':':
458             missing_argument(argv[optind - 1]);
459             break;
460         case '?':
461             unrecognized_option(argv[optind - 1]);
462             break;
463         case 'h':
464             help();
465             break;
466         case 'F':
467             base_fmt = optarg;
468             break;
469         case 'b':
470             base_filename = optarg;
471             break;
472         case 'f':
473             fmt = optarg;
474             break;
475         case 'o':
476             if (!is_valid_option_list(optarg)) {
477                 error_report("Invalid option list: %s", optarg);
478                 goto fail;
479             }
480             if (!options) {
481                 options = g_strdup(optarg);
482             } else {
483                 char *old_options = options;
484                 options = g_strdup_printf("%s,%s", options, optarg);
485                 g_free(old_options);
486             }
487             break;
488         case 'q':
489             quiet = true;
490             break;
491         case 'u':
492             flags |= BDRV_O_NO_BACKING;
493             break;
494         case OPTION_OBJECT: {
495             QemuOpts *opts;
496             opts = qemu_opts_parse_noisily(&qemu_object_opts,
497                                            optarg, true);
498             if (!opts) {
499                 goto fail;
500             }
501         }   break;
502         }
503     }
504 
505     /* Get the filename */
506     filename = (optind < argc) ? argv[optind] : NULL;
507     if (options && has_help_option(options)) {
508         g_free(options);
509         return print_block_option_help(filename, fmt);
510     }
511 
512     if (optind >= argc) {
513         error_exit("Expecting image file name");
514     }
515     optind++;
516 
517     if (qemu_opts_foreach(&qemu_object_opts,
518                           user_creatable_add_opts_foreach,
519                           NULL, &error_fatal)) {
520         goto fail;
521     }
522 
523     /* Get image size, if specified */
524     if (optind < argc) {
525         int64_t sval;
526 
527         sval = cvtnum(argv[optind++]);
528         if (sval < 0) {
529             if (sval == -ERANGE) {
530                 error_report("Image size must be less than 8 EiB!");
531             } else {
532                 error_report("Invalid image size specified! You may use k, M, "
533                       "G, T, P or E suffixes for ");
534                 error_report("kilobytes, megabytes, gigabytes, terabytes, "
535                              "petabytes and exabytes.");
536             }
537             goto fail;
538         }
539         img_size = (uint64_t)sval;
540     }
541     if (optind != argc) {
542         error_exit("Unexpected argument: %s", argv[optind]);
543     }
544 
545     bdrv_img_create(filename, fmt, base_filename, base_fmt,
546                     options, img_size, flags, quiet, &local_err);
547     if (local_err) {
548         error_reportf_err(local_err, "%s: ", filename);
549         goto fail;
550     }
551 
552     g_free(options);
553     return 0;
554 
555 fail:
556     g_free(options);
557     return 1;
558 }
559 
560 static void dump_json_image_check(ImageCheck *check, bool quiet)
561 {
562     QString *str;
563     QObject *obj;
564     Visitor *v = qobject_output_visitor_new(&obj);
565 
566     visit_type_ImageCheck(v, NULL, &check, &error_abort);
567     visit_complete(v, &obj);
568     str = qobject_to_json_pretty(obj);
569     assert(str != NULL);
570     qprintf(quiet, "%s\n", qstring_get_str(str));
571     qobject_unref(obj);
572     visit_free(v);
573     qobject_unref(str);
574 }
575 
576 static void dump_human_image_check(ImageCheck *check, bool quiet)
577 {
578     if (!(check->corruptions || check->leaks || check->check_errors)) {
579         qprintf(quiet, "No errors were found on the image.\n");
580     } else {
581         if (check->corruptions) {
582             qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
583                     "Data may be corrupted, or further writes to the image "
584                     "may corrupt it.\n",
585                     check->corruptions);
586         }
587 
588         if (check->leaks) {
589             qprintf(quiet,
590                     "\n%" PRId64 " leaked clusters were found on the image.\n"
591                     "This means waste of disk space, but no harm to data.\n",
592                     check->leaks);
593         }
594 
595         if (check->check_errors) {
596             qprintf(quiet,
597                     "\n%" PRId64
598                     " internal errors have occurred during the check.\n",
599                     check->check_errors);
600         }
601     }
602 
603     if (check->total_clusters != 0 && check->allocated_clusters != 0) {
604         qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
605                 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
606                 check->allocated_clusters, check->total_clusters,
607                 check->allocated_clusters * 100.0 / check->total_clusters,
608                 check->fragmented_clusters * 100.0 / check->allocated_clusters,
609                 check->compressed_clusters * 100.0 /
610                 check->allocated_clusters);
611     }
612 
613     if (check->image_end_offset) {
614         qprintf(quiet,
615                 "Image end offset: %" PRId64 "\n", check->image_end_offset);
616     }
617 }
618 
619 static int collect_image_check(BlockDriverState *bs,
620                    ImageCheck *check,
621                    const char *filename,
622                    const char *fmt,
623                    int fix)
624 {
625     int ret;
626     BdrvCheckResult result;
627 
628     ret = bdrv_check(bs, &result, fix);
629     if (ret < 0) {
630         return ret;
631     }
632 
633     check->filename                 = g_strdup(filename);
634     check->format                   = g_strdup(bdrv_get_format_name(bs));
635     check->check_errors             = result.check_errors;
636     check->corruptions              = result.corruptions;
637     check->has_corruptions          = result.corruptions != 0;
638     check->leaks                    = result.leaks;
639     check->has_leaks                = result.leaks != 0;
640     check->corruptions_fixed        = result.corruptions_fixed;
641     check->has_corruptions_fixed    = result.corruptions != 0;
642     check->leaks_fixed              = result.leaks_fixed;
643     check->has_leaks_fixed          = result.leaks != 0;
644     check->image_end_offset         = result.image_end_offset;
645     check->has_image_end_offset     = result.image_end_offset != 0;
646     check->total_clusters           = result.bfi.total_clusters;
647     check->has_total_clusters       = result.bfi.total_clusters != 0;
648     check->allocated_clusters       = result.bfi.allocated_clusters;
649     check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
650     check->fragmented_clusters      = result.bfi.fragmented_clusters;
651     check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
652     check->compressed_clusters      = result.bfi.compressed_clusters;
653     check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
654 
655     return 0;
656 }
657 
658 /*
659  * Checks an image for consistency. Exit codes:
660  *
661  *  0 - Check completed, image is good
662  *  1 - Check not completed because of internal errors
663  *  2 - Check completed, image is corrupted
664  *  3 - Check completed, image has leaked clusters, but is good otherwise
665  * 63 - Checks are not supported by the image format
666  */
667 static int img_check(int argc, char **argv)
668 {
669     int c, ret;
670     OutputFormat output_format = OFORMAT_HUMAN;
671     const char *filename, *fmt, *output, *cache;
672     BlockBackend *blk;
673     BlockDriverState *bs;
674     int fix = 0;
675     int flags = BDRV_O_CHECK;
676     bool writethrough;
677     ImageCheck *check;
678     bool quiet = false;
679     bool image_opts = false;
680     bool force_share = false;
681 
682     fmt = NULL;
683     output = NULL;
684     cache = BDRV_DEFAULT_CACHE;
685 
686     for(;;) {
687         int option_index = 0;
688         static const struct option long_options[] = {
689             {"help", no_argument, 0, 'h'},
690             {"format", required_argument, 0, 'f'},
691             {"repair", required_argument, 0, 'r'},
692             {"output", required_argument, 0, OPTION_OUTPUT},
693             {"object", required_argument, 0, OPTION_OBJECT},
694             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
695             {"force-share", no_argument, 0, 'U'},
696             {0, 0, 0, 0}
697         };
698         c = getopt_long(argc, argv, ":hf:r:T:qU",
699                         long_options, &option_index);
700         if (c == -1) {
701             break;
702         }
703         switch(c) {
704         case ':':
705             missing_argument(argv[optind - 1]);
706             break;
707         case '?':
708             unrecognized_option(argv[optind - 1]);
709             break;
710         case 'h':
711             help();
712             break;
713         case 'f':
714             fmt = optarg;
715             break;
716         case 'r':
717             flags |= BDRV_O_RDWR;
718 
719             if (!strcmp(optarg, "leaks")) {
720                 fix = BDRV_FIX_LEAKS;
721             } else if (!strcmp(optarg, "all")) {
722                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
723             } else {
724                 error_exit("Unknown option value for -r "
725                            "(expecting 'leaks' or 'all'): %s", optarg);
726             }
727             break;
728         case OPTION_OUTPUT:
729             output = optarg;
730             break;
731         case 'T':
732             cache = optarg;
733             break;
734         case 'q':
735             quiet = true;
736             break;
737         case 'U':
738             force_share = true;
739             break;
740         case OPTION_OBJECT: {
741             QemuOpts *opts;
742             opts = qemu_opts_parse_noisily(&qemu_object_opts,
743                                            optarg, true);
744             if (!opts) {
745                 return 1;
746             }
747         }   break;
748         case OPTION_IMAGE_OPTS:
749             image_opts = true;
750             break;
751         }
752     }
753     if (optind != argc - 1) {
754         error_exit("Expecting one image file name");
755     }
756     filename = argv[optind++];
757 
758     if (output && !strcmp(output, "json")) {
759         output_format = OFORMAT_JSON;
760     } else if (output && !strcmp(output, "human")) {
761         output_format = OFORMAT_HUMAN;
762     } else if (output) {
763         error_report("--output must be used with human or json as argument.");
764         return 1;
765     }
766 
767     if (qemu_opts_foreach(&qemu_object_opts,
768                           user_creatable_add_opts_foreach,
769                           NULL, &error_fatal)) {
770         return 1;
771     }
772 
773     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
774     if (ret < 0) {
775         error_report("Invalid source cache option: %s", cache);
776         return 1;
777     }
778 
779     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
780                    force_share);
781     if (!blk) {
782         return 1;
783     }
784     bs = blk_bs(blk);
785 
786     check = g_new0(ImageCheck, 1);
787     ret = collect_image_check(bs, check, filename, fmt, fix);
788 
789     if (ret == -ENOTSUP) {
790         error_report("This image format does not support checks");
791         ret = 63;
792         goto fail;
793     }
794 
795     if (check->corruptions_fixed || check->leaks_fixed) {
796         int corruptions_fixed, leaks_fixed;
797 
798         leaks_fixed         = check->leaks_fixed;
799         corruptions_fixed   = check->corruptions_fixed;
800 
801         if (output_format == OFORMAT_HUMAN) {
802             qprintf(quiet,
803                     "The following inconsistencies were found and repaired:\n\n"
804                     "    %" PRId64 " leaked clusters\n"
805                     "    %" PRId64 " corruptions\n\n"
806                     "Double checking the fixed image now...\n",
807                     check->leaks_fixed,
808                     check->corruptions_fixed);
809         }
810 
811         ret = collect_image_check(bs, check, filename, fmt, 0);
812 
813         check->leaks_fixed          = leaks_fixed;
814         check->corruptions_fixed    = corruptions_fixed;
815     }
816 
817     if (!ret) {
818         switch (output_format) {
819         case OFORMAT_HUMAN:
820             dump_human_image_check(check, quiet);
821             break;
822         case OFORMAT_JSON:
823             dump_json_image_check(check, quiet);
824             break;
825         }
826     }
827 
828     if (ret || check->check_errors) {
829         if (ret) {
830             error_report("Check failed: %s", strerror(-ret));
831         } else {
832             error_report("Check failed");
833         }
834         ret = 1;
835         goto fail;
836     }
837 
838     if (check->corruptions) {
839         ret = 2;
840     } else if (check->leaks) {
841         ret = 3;
842     } else {
843         ret = 0;
844     }
845 
846 fail:
847     qapi_free_ImageCheck(check);
848     blk_unref(blk);
849     return ret;
850 }
851 
852 typedef struct CommonBlockJobCBInfo {
853     BlockDriverState *bs;
854     Error **errp;
855 } CommonBlockJobCBInfo;
856 
857 static void common_block_job_cb(void *opaque, int ret)
858 {
859     CommonBlockJobCBInfo *cbi = opaque;
860 
861     if (ret < 0) {
862         error_setg_errno(cbi->errp, -ret, "Block job failed");
863     }
864 }
865 
866 static void run_block_job(BlockJob *job, Error **errp)
867 {
868     AioContext *aio_context = blk_get_aio_context(job->blk);
869     int ret = 0;
870 
871     aio_context_acquire(aio_context);
872     job_ref(&job->job);
873     do {
874         float progress = 0.0f;
875         aio_poll(aio_context, true);
876         if (job->job.progress_total) {
877             progress = (float)job->job.progress_current /
878                        job->job.progress_total * 100.f;
879         }
880         qemu_progress_print(progress, 0);
881     } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
882 
883     if (!job_is_completed(&job->job)) {
884         ret = job_complete_sync(&job->job, errp);
885     } else {
886         ret = job->job.ret;
887     }
888     job_unref(&job->job);
889     aio_context_release(aio_context);
890 
891     /* publish completion progress only when success */
892     if (!ret) {
893         qemu_progress_print(100.f, 0);
894     }
895 }
896 
897 static int img_commit(int argc, char **argv)
898 {
899     int c, ret, flags;
900     const char *filename, *fmt, *cache, *base;
901     BlockBackend *blk;
902     BlockDriverState *bs, *base_bs;
903     BlockJob *job;
904     bool progress = false, quiet = false, drop = false;
905     bool writethrough;
906     Error *local_err = NULL;
907     CommonBlockJobCBInfo cbi;
908     bool image_opts = false;
909     AioContext *aio_context;
910 
911     fmt = NULL;
912     cache = BDRV_DEFAULT_CACHE;
913     base = NULL;
914     for(;;) {
915         static const struct option long_options[] = {
916             {"help", no_argument, 0, 'h'},
917             {"object", required_argument, 0, OPTION_OBJECT},
918             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
919             {0, 0, 0, 0}
920         };
921         c = getopt_long(argc, argv, ":f:ht:b:dpq",
922                         long_options, NULL);
923         if (c == -1) {
924             break;
925         }
926         switch(c) {
927         case ':':
928             missing_argument(argv[optind - 1]);
929             break;
930         case '?':
931             unrecognized_option(argv[optind - 1]);
932             break;
933         case 'h':
934             help();
935             break;
936         case 'f':
937             fmt = optarg;
938             break;
939         case 't':
940             cache = optarg;
941             break;
942         case 'b':
943             base = optarg;
944             /* -b implies -d */
945             drop = true;
946             break;
947         case 'd':
948             drop = true;
949             break;
950         case 'p':
951             progress = true;
952             break;
953         case 'q':
954             quiet = true;
955             break;
956         case OPTION_OBJECT: {
957             QemuOpts *opts;
958             opts = qemu_opts_parse_noisily(&qemu_object_opts,
959                                            optarg, true);
960             if (!opts) {
961                 return 1;
962             }
963         }   break;
964         case OPTION_IMAGE_OPTS:
965             image_opts = true;
966             break;
967         }
968     }
969 
970     /* Progress is not shown in Quiet mode */
971     if (quiet) {
972         progress = false;
973     }
974 
975     if (optind != argc - 1) {
976         error_exit("Expecting one image file name");
977     }
978     filename = argv[optind++];
979 
980     if (qemu_opts_foreach(&qemu_object_opts,
981                           user_creatable_add_opts_foreach,
982                           NULL, &error_fatal)) {
983         return 1;
984     }
985 
986     flags = BDRV_O_RDWR | BDRV_O_UNMAP;
987     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
988     if (ret < 0) {
989         error_report("Invalid cache option: %s", cache);
990         return 1;
991     }
992 
993     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
994                    false);
995     if (!blk) {
996         return 1;
997     }
998     bs = blk_bs(blk);
999 
1000     qemu_progress_init(progress, 1.f);
1001     qemu_progress_print(0.f, 100);
1002 
1003     if (base) {
1004         base_bs = bdrv_find_backing_image(bs, base);
1005         if (!base_bs) {
1006             error_setg(&local_err,
1007                        "Did not find '%s' in the backing chain of '%s'",
1008                        base, filename);
1009             goto done;
1010         }
1011     } else {
1012         /* This is different from QMP, which by default uses the deepest file in
1013          * the backing chain (i.e., the very base); however, the traditional
1014          * behavior of qemu-img commit is using the immediate backing file. */
1015         base_bs = backing_bs(bs);
1016         if (!base_bs) {
1017             error_setg(&local_err, "Image does not have a backing file");
1018             goto done;
1019         }
1020     }
1021 
1022     cbi = (CommonBlockJobCBInfo){
1023         .errp = &local_err,
1024         .bs   = bs,
1025     };
1026 
1027     aio_context = bdrv_get_aio_context(bs);
1028     aio_context_acquire(aio_context);
1029     commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,
1030                         BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
1031                         &cbi, false, &local_err);
1032     aio_context_release(aio_context);
1033     if (local_err) {
1034         goto done;
1035     }
1036 
1037     /* When the block job completes, the BlockBackend reference will point to
1038      * the old backing file. In order to avoid that the top image is already
1039      * deleted, so we can still empty it afterwards, increment the reference
1040      * counter here preemptively. */
1041     if (!drop) {
1042         bdrv_ref(bs);
1043     }
1044 
1045     job = block_job_get("commit");
1046     assert(job);
1047     run_block_job(job, &local_err);
1048     if (local_err) {
1049         goto unref_backing;
1050     }
1051 
1052     if (!drop && bs->drv->bdrv_make_empty) {
1053         ret = bs->drv->bdrv_make_empty(bs);
1054         if (ret) {
1055             error_setg_errno(&local_err, -ret, "Could not empty %s",
1056                              filename);
1057             goto unref_backing;
1058         }
1059     }
1060 
1061 unref_backing:
1062     if (!drop) {
1063         bdrv_unref(bs);
1064     }
1065 
1066 done:
1067     qemu_progress_end();
1068 
1069     blk_unref(blk);
1070 
1071     if (local_err) {
1072         error_report_err(local_err);
1073         return 1;
1074     }
1075 
1076     qprintf(quiet, "Image committed.\n");
1077     return 0;
1078 }
1079 
1080 /*
1081  * Returns -1 if 'buf' contains only zeroes, otherwise the byte index
1082  * of the first sector boundary within buf where the sector contains a
1083  * non-zero byte.  This function is robust to a buffer that is not
1084  * sector-aligned.
1085  */
1086 static int64_t find_nonzero(const uint8_t *buf, int64_t n)
1087 {
1088     int64_t i;
1089     int64_t end = QEMU_ALIGN_DOWN(n, BDRV_SECTOR_SIZE);
1090 
1091     for (i = 0; i < end; i += BDRV_SECTOR_SIZE) {
1092         if (!buffer_is_zero(buf + i, BDRV_SECTOR_SIZE)) {
1093             return i;
1094         }
1095     }
1096     if (i < n && !buffer_is_zero(buf + i, n - end)) {
1097         return i;
1098     }
1099     return -1;
1100 }
1101 
1102 /*
1103  * Returns true iff the first sector pointed to by 'buf' contains at least
1104  * a non-NUL byte.
1105  *
1106  * 'pnum' is set to the number of sectors (including and immediately following
1107  * the first one) that are known to be in the same allocated/unallocated state.
1108  * The function will try to align the end offset to alignment boundaries so
1109  * that the request will at least end aligned and consequtive requests will
1110  * also start at an aligned offset.
1111  */
1112 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
1113                                 int64_t sector_num, int alignment)
1114 {
1115     bool is_zero;
1116     int i, tail;
1117 
1118     if (n <= 0) {
1119         *pnum = 0;
1120         return 0;
1121     }
1122     is_zero = buffer_is_zero(buf, 512);
1123     for(i = 1; i < n; i++) {
1124         buf += 512;
1125         if (is_zero != buffer_is_zero(buf, 512)) {
1126             break;
1127         }
1128     }
1129 
1130     tail = (sector_num + i) & (alignment - 1);
1131     if (tail) {
1132         if (is_zero && i <= tail) {
1133             /* treat unallocated areas which only consist
1134              * of a small tail as allocated. */
1135             is_zero = false;
1136         }
1137         if (!is_zero) {
1138             /* align up end offset of allocated areas. */
1139             i += alignment - tail;
1140             i = MIN(i, n);
1141         } else {
1142             /* align down end offset of zero areas. */
1143             i -= tail;
1144         }
1145     }
1146     *pnum = i;
1147     return !is_zero;
1148 }
1149 
1150 /*
1151  * Like is_allocated_sectors, but if the buffer starts with a used sector,
1152  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
1153  * breaking up write requests for only small sparse areas.
1154  */
1155 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
1156     int min, int64_t sector_num, int alignment)
1157 {
1158     int ret;
1159     int num_checked, num_used;
1160 
1161     if (n < min) {
1162         min = n;
1163     }
1164 
1165     ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1166     if (!ret) {
1167         return ret;
1168     }
1169 
1170     num_used = *pnum;
1171     buf += BDRV_SECTOR_SIZE * *pnum;
1172     n -= *pnum;
1173     sector_num += *pnum;
1174     num_checked = num_used;
1175 
1176     while (n > 0) {
1177         ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);
1178 
1179         buf += BDRV_SECTOR_SIZE * *pnum;
1180         n -= *pnum;
1181         sector_num += *pnum;
1182         num_checked += *pnum;
1183         if (ret) {
1184             num_used = num_checked;
1185         } else if (*pnum >= min) {
1186             break;
1187         }
1188     }
1189 
1190     *pnum = num_used;
1191     return 1;
1192 }
1193 
1194 /*
1195  * Compares two buffers sector by sector. Returns 0 if the first
1196  * sector of each buffer matches, non-zero otherwise.
1197  *
1198  * pnum is set to the sector-aligned size of the buffer prefix that
1199  * has the same matching status as the first sector.
1200  */
1201 static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,
1202                            int64_t bytes, int64_t *pnum)
1203 {
1204     bool res;
1205     int64_t i = MIN(bytes, BDRV_SECTOR_SIZE);
1206 
1207     assert(bytes > 0);
1208 
1209     res = !!memcmp(buf1, buf2, i);
1210     while (i < bytes) {
1211         int64_t len = MIN(bytes - i, BDRV_SECTOR_SIZE);
1212 
1213         if (!!memcmp(buf1 + i, buf2 + i, len) != res) {
1214             break;
1215         }
1216         i += len;
1217     }
1218 
1219     *pnum = i;
1220     return res;
1221 }
1222 
1223 #define IO_BUF_SIZE (2 * MiB)
1224 
1225 /*
1226  * Check if passed sectors are empty (not allocated or contain only 0 bytes)
1227  *
1228  * Intended for use by 'qemu-img compare': Returns 0 in case sectors are
1229  * filled with 0, 1 if sectors contain non-zero data (this is a comparison
1230  * failure), and 4 on error (the exit status for read errors), after emitting
1231  * an error message.
1232  *
1233  * @param blk:  BlockBackend for the image
1234  * @param offset: Starting offset to check
1235  * @param bytes: Number of bytes to check
1236  * @param filename: Name of disk file we are checking (logging purpose)
1237  * @param buffer: Allocated buffer for storing read data
1238  * @param quiet: Flag for quiet mode
1239  */
1240 static int check_empty_sectors(BlockBackend *blk, int64_t offset,
1241                                int64_t bytes, const char *filename,
1242                                uint8_t *buffer, bool quiet)
1243 {
1244     int ret = 0;
1245     int64_t idx;
1246 
1247     ret = blk_pread(blk, offset, buffer, bytes);
1248     if (ret < 0) {
1249         error_report("Error while reading offset %" PRId64 " of %s: %s",
1250                      offset, filename, strerror(-ret));
1251         return 4;
1252     }
1253     idx = find_nonzero(buffer, bytes);
1254     if (idx >= 0) {
1255         qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1256                 offset + idx);
1257         return 1;
1258     }
1259 
1260     return 0;
1261 }
1262 
1263 /*
1264  * Compares two images. Exit codes:
1265  *
1266  * 0 - Images are identical
1267  * 1 - Images differ
1268  * >1 - Error occurred
1269  */
1270 static int img_compare(int argc, char **argv)
1271 {
1272     const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
1273     BlockBackend *blk1, *blk2;
1274     BlockDriverState *bs1, *bs2;
1275     int64_t total_size1, total_size2;
1276     uint8_t *buf1 = NULL, *buf2 = NULL;
1277     int64_t pnum1, pnum2;
1278     int allocated1, allocated2;
1279     int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
1280     bool progress = false, quiet = false, strict = false;
1281     int flags;
1282     bool writethrough;
1283     int64_t total_size;
1284     int64_t offset = 0;
1285     int64_t chunk;
1286     int c;
1287     uint64_t progress_base;
1288     bool image_opts = false;
1289     bool force_share = false;
1290 
1291     cache = BDRV_DEFAULT_CACHE;
1292     for (;;) {
1293         static const struct option long_options[] = {
1294             {"help", no_argument, 0, 'h'},
1295             {"object", required_argument, 0, OPTION_OBJECT},
1296             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
1297             {"force-share", no_argument, 0, 'U'},
1298             {0, 0, 0, 0}
1299         };
1300         c = getopt_long(argc, argv, ":hf:F:T:pqsU",
1301                         long_options, NULL);
1302         if (c == -1) {
1303             break;
1304         }
1305         switch (c) {
1306         case ':':
1307             missing_argument(argv[optind - 1]);
1308             break;
1309         case '?':
1310             unrecognized_option(argv[optind - 1]);
1311             break;
1312         case 'h':
1313             help();
1314             break;
1315         case 'f':
1316             fmt1 = optarg;
1317             break;
1318         case 'F':
1319             fmt2 = optarg;
1320             break;
1321         case 'T':
1322             cache = optarg;
1323             break;
1324         case 'p':
1325             progress = true;
1326             break;
1327         case 'q':
1328             quiet = true;
1329             break;
1330         case 's':
1331             strict = true;
1332             break;
1333         case 'U':
1334             force_share = true;
1335             break;
1336         case OPTION_OBJECT: {
1337             QemuOpts *opts;
1338             opts = qemu_opts_parse_noisily(&qemu_object_opts,
1339                                            optarg, true);
1340             if (!opts) {
1341                 ret = 2;
1342                 goto out4;
1343             }
1344         }   break;
1345         case OPTION_IMAGE_OPTS:
1346             image_opts = true;
1347             break;
1348         }
1349     }
1350 
1351     /* Progress is not shown in Quiet mode */
1352     if (quiet) {
1353         progress = false;
1354     }
1355 
1356 
1357     if (optind != argc - 2) {
1358         error_exit("Expecting two image file names");
1359     }
1360     filename1 = argv[optind++];
1361     filename2 = argv[optind++];
1362 
1363     if (qemu_opts_foreach(&qemu_object_opts,
1364                           user_creatable_add_opts_foreach,
1365                           NULL, &error_fatal)) {
1366         ret = 2;
1367         goto out4;
1368     }
1369 
1370     /* Initialize before goto out */
1371     qemu_progress_init(progress, 2.0);
1372 
1373     flags = 0;
1374     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
1375     if (ret < 0) {
1376         error_report("Invalid source cache option: %s", cache);
1377         ret = 2;
1378         goto out3;
1379     }
1380 
1381     blk1 = img_open(image_opts, filename1, fmt1, flags, writethrough, quiet,
1382                     force_share);
1383     if (!blk1) {
1384         ret = 2;
1385         goto out3;
1386     }
1387 
1388     blk2 = img_open(image_opts, filename2, fmt2, flags, writethrough, quiet,
1389                     force_share);
1390     if (!blk2) {
1391         ret = 2;
1392         goto out2;
1393     }
1394     bs1 = blk_bs(blk1);
1395     bs2 = blk_bs(blk2);
1396 
1397     buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
1398     buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
1399     total_size1 = blk_getlength(blk1);
1400     if (total_size1 < 0) {
1401         error_report("Can't get size of %s: %s",
1402                      filename1, strerror(-total_size1));
1403         ret = 4;
1404         goto out;
1405     }
1406     total_size2 = blk_getlength(blk2);
1407     if (total_size2 < 0) {
1408         error_report("Can't get size of %s: %s",
1409                      filename2, strerror(-total_size2));
1410         ret = 4;
1411         goto out;
1412     }
1413     total_size = MIN(total_size1, total_size2);
1414     progress_base = MAX(total_size1, total_size2);
1415 
1416     qemu_progress_print(0, 100);
1417 
1418     if (strict && total_size1 != total_size2) {
1419         ret = 1;
1420         qprintf(quiet, "Strict mode: Image size mismatch!\n");
1421         goto out;
1422     }
1423 
1424     while (offset < total_size) {
1425         int status1, status2;
1426 
1427         status1 = bdrv_block_status_above(bs1, NULL, offset,
1428                                           total_size1 - offset, &pnum1, NULL,
1429                                           NULL);
1430         if (status1 < 0) {
1431             ret = 3;
1432             error_report("Sector allocation test failed for %s", filename1);
1433             goto out;
1434         }
1435         allocated1 = status1 & BDRV_BLOCK_ALLOCATED;
1436 
1437         status2 = bdrv_block_status_above(bs2, NULL, offset,
1438                                           total_size2 - offset, &pnum2, NULL,
1439                                           NULL);
1440         if (status2 < 0) {
1441             ret = 3;
1442             error_report("Sector allocation test failed for %s", filename2);
1443             goto out;
1444         }
1445         allocated2 = status2 & BDRV_BLOCK_ALLOCATED;
1446 
1447         assert(pnum1 && pnum2);
1448         chunk = MIN(pnum1, pnum2);
1449 
1450         if (strict) {
1451             if (status1 != status2) {
1452                 ret = 1;
1453                 qprintf(quiet, "Strict mode: Offset %" PRId64
1454                         " block status mismatch!\n", offset);
1455                 goto out;
1456             }
1457         }
1458         if ((status1 & BDRV_BLOCK_ZERO) && (status2 & BDRV_BLOCK_ZERO)) {
1459             /* nothing to do */
1460         } else if (allocated1 == allocated2) {
1461             if (allocated1) {
1462                 int64_t pnum;
1463 
1464                 chunk = MIN(chunk, IO_BUF_SIZE);
1465                 ret = blk_pread(blk1, offset, buf1, chunk);
1466                 if (ret < 0) {
1467                     error_report("Error while reading offset %" PRId64
1468                                  " of %s: %s",
1469                                  offset, filename1, strerror(-ret));
1470                     ret = 4;
1471                     goto out;
1472                 }
1473                 ret = blk_pread(blk2, offset, buf2, chunk);
1474                 if (ret < 0) {
1475                     error_report("Error while reading offset %" PRId64
1476                                  " of %s: %s",
1477                                  offset, filename2, strerror(-ret));
1478                     ret = 4;
1479                     goto out;
1480                 }
1481                 ret = compare_buffers(buf1, buf2, chunk, &pnum);
1482                 if (ret || pnum != chunk) {
1483                     qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1484                             offset + (ret ? 0 : pnum));
1485                     ret = 1;
1486                     goto out;
1487                 }
1488             }
1489         } else {
1490             chunk = MIN(chunk, IO_BUF_SIZE);
1491             if (allocated1) {
1492                 ret = check_empty_sectors(blk1, offset, chunk,
1493                                           filename1, buf1, quiet);
1494             } else {
1495                 ret = check_empty_sectors(blk2, offset, chunk,
1496                                           filename2, buf1, quiet);
1497             }
1498             if (ret) {
1499                 goto out;
1500             }
1501         }
1502         offset += chunk;
1503         qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1504     }
1505 
1506     if (total_size1 != total_size2) {
1507         BlockBackend *blk_over;
1508         const char *filename_over;
1509 
1510         qprintf(quiet, "Warning: Image size mismatch!\n");
1511         if (total_size1 > total_size2) {
1512             blk_over = blk1;
1513             filename_over = filename1;
1514         } else {
1515             blk_over = blk2;
1516             filename_over = filename2;
1517         }
1518 
1519         while (offset < progress_base) {
1520             ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,
1521                                           progress_base - offset, &chunk,
1522                                           NULL, NULL);
1523             if (ret < 0) {
1524                 ret = 3;
1525                 error_report("Sector allocation test failed for %s",
1526                              filename_over);
1527                 goto out;
1528 
1529             }
1530             if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {
1531                 chunk = MIN(chunk, IO_BUF_SIZE);
1532                 ret = check_empty_sectors(blk_over, offset, chunk,
1533                                           filename_over, buf1, quiet);
1534                 if (ret) {
1535                     goto out;
1536                 }
1537             }
1538             offset += chunk;
1539             qemu_progress_print(((float) chunk / progress_base) * 100, 100);
1540         }
1541     }
1542 
1543     qprintf(quiet, "Images are identical.\n");
1544     ret = 0;
1545 
1546 out:
1547     qemu_vfree(buf1);
1548     qemu_vfree(buf2);
1549     blk_unref(blk2);
1550 out2:
1551     blk_unref(blk1);
1552 out3:
1553     qemu_progress_end();
1554 out4:
1555     return ret;
1556 }
1557 
1558 enum ImgConvertBlockStatus {
1559     BLK_DATA,
1560     BLK_ZERO,
1561     BLK_BACKING_FILE,
1562 };
1563 
1564 #define MAX_COROUTINES 16
1565 
1566 typedef struct ImgConvertState {
1567     BlockBackend **src;
1568     int64_t *src_sectors;
1569     int src_num;
1570     int64_t total_sectors;
1571     int64_t allocated_sectors;
1572     int64_t allocated_done;
1573     int64_t sector_num;
1574     int64_t wr_offs;
1575     enum ImgConvertBlockStatus status;
1576     int64_t sector_next_status;
1577     BlockBackend *target;
1578     bool has_zero_init;
1579     bool compressed;
1580     bool unallocated_blocks_are_zero;
1581     bool target_has_backing;
1582     int64_t target_backing_sectors; /* negative if unknown */
1583     bool wr_in_order;
1584     bool copy_range;
1585     bool salvage;
1586     bool quiet;
1587     int min_sparse;
1588     int alignment;
1589     size_t cluster_sectors;
1590     size_t buf_sectors;
1591     long num_coroutines;
1592     int running_coroutines;
1593     Coroutine *co[MAX_COROUTINES];
1594     int64_t wait_sector_num[MAX_COROUTINES];
1595     CoMutex lock;
1596     int ret;
1597 } ImgConvertState;
1598 
1599 static void convert_select_part(ImgConvertState *s, int64_t sector_num,
1600                                 int *src_cur, int64_t *src_cur_offset)
1601 {
1602     *src_cur = 0;
1603     *src_cur_offset = 0;
1604     while (sector_num - *src_cur_offset >= s->src_sectors[*src_cur]) {
1605         *src_cur_offset += s->src_sectors[*src_cur];
1606         (*src_cur)++;
1607         assert(*src_cur < s->src_num);
1608     }
1609 }
1610 
1611 static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
1612 {
1613     int64_t src_cur_offset;
1614     int ret, n, src_cur;
1615     bool post_backing_zero = false;
1616 
1617     convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1618 
1619     assert(s->total_sectors > sector_num);
1620     n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
1621 
1622     if (s->target_backing_sectors >= 0) {
1623         if (sector_num >= s->target_backing_sectors) {
1624             post_backing_zero = s->unallocated_blocks_are_zero;
1625         } else if (sector_num + n > s->target_backing_sectors) {
1626             /* Split requests around target_backing_sectors (because
1627              * starting from there, zeros are handled differently) */
1628             n = s->target_backing_sectors - sector_num;
1629         }
1630     }
1631 
1632     if (s->sector_next_status <= sector_num) {
1633         uint64_t offset = (sector_num - src_cur_offset) * BDRV_SECTOR_SIZE;
1634         int64_t count;
1635 
1636         do {
1637             count = n * BDRV_SECTOR_SIZE;
1638 
1639             if (s->target_has_backing) {
1640                 ret = bdrv_block_status(blk_bs(s->src[src_cur]), offset,
1641                                         count, &count, NULL, NULL);
1642             } else {
1643                 ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,
1644                                               offset, count, &count, NULL,
1645                                               NULL);
1646             }
1647 
1648             if (ret < 0) {
1649                 if (s->salvage) {
1650                     if (n == 1) {
1651                         if (!s->quiet) {
1652                             warn_report("error while reading block status at "
1653                                         "offset %" PRIu64 ": %s", offset,
1654                                         strerror(-ret));
1655                         }
1656                         /* Just try to read the data, then */
1657                         ret = BDRV_BLOCK_DATA;
1658                         count = BDRV_SECTOR_SIZE;
1659                     } else {
1660                         /* Retry on a shorter range */
1661                         n = DIV_ROUND_UP(n, 4);
1662                     }
1663                 } else {
1664                     error_report("error while reading block status at offset "
1665                                  "%" PRIu64 ": %s", offset, strerror(-ret));
1666                     return ret;
1667                 }
1668             }
1669         } while (ret < 0);
1670 
1671         n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
1672 
1673         if (ret & BDRV_BLOCK_ZERO) {
1674             s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;
1675         } else if (ret & BDRV_BLOCK_DATA) {
1676             s->status = BLK_DATA;
1677         } else {
1678             s->status = s->target_has_backing ? BLK_BACKING_FILE : BLK_DATA;
1679         }
1680 
1681         s->sector_next_status = sector_num + n;
1682     }
1683 
1684     n = MIN(n, s->sector_next_status - sector_num);
1685     if (s->status == BLK_DATA) {
1686         n = MIN(n, s->buf_sectors);
1687     }
1688 
1689     /* We need to write complete clusters for compressed images, so if an
1690      * unallocated area is shorter than that, we must consider the whole
1691      * cluster allocated. */
1692     if (s->compressed) {
1693         if (n < s->cluster_sectors) {
1694             n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
1695             s->status = BLK_DATA;
1696         } else {
1697             n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
1698         }
1699     }
1700 
1701     return n;
1702 }
1703 
1704 static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
1705                                         int nb_sectors, uint8_t *buf)
1706 {
1707     uint64_t single_read_until = 0;
1708     int n, ret;
1709 
1710     assert(nb_sectors <= s->buf_sectors);
1711     while (nb_sectors > 0) {
1712         BlockBackend *blk;
1713         int src_cur;
1714         int64_t bs_sectors, src_cur_offset;
1715         uint64_t offset;
1716 
1717         /* In the case of compression with multiple source files, we can get a
1718          * nb_sectors that spreads into the next part. So we must be able to
1719          * read across multiple BDSes for one convert_read() call. */
1720         convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1721         blk = s->src[src_cur];
1722         bs_sectors = s->src_sectors[src_cur];
1723 
1724         offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1725 
1726         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1727         if (single_read_until > offset) {
1728             n = 1;
1729         }
1730 
1731         ret = blk_co_pread(blk, offset, n << BDRV_SECTOR_BITS, buf, 0);
1732         if (ret < 0) {
1733             if (s->salvage) {
1734                 if (n > 1) {
1735                     single_read_until = offset + (n << BDRV_SECTOR_BITS);
1736                     continue;
1737                 } else {
1738                     if (!s->quiet) {
1739                         warn_report("error while reading offset %" PRIu64
1740                                     ": %s", offset, strerror(-ret));
1741                     }
1742                     memset(buf, 0, BDRV_SECTOR_SIZE);
1743                 }
1744             } else {
1745                 return ret;
1746             }
1747         }
1748 
1749         sector_num += n;
1750         nb_sectors -= n;
1751         buf += n * BDRV_SECTOR_SIZE;
1752     }
1753 
1754     return 0;
1755 }
1756 
1757 
1758 static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
1759                                          int nb_sectors, uint8_t *buf,
1760                                          enum ImgConvertBlockStatus status)
1761 {
1762     int ret;
1763 
1764     while (nb_sectors > 0) {
1765         int n = nb_sectors;
1766         BdrvRequestFlags flags = s->compressed ? BDRV_REQ_WRITE_COMPRESSED : 0;
1767 
1768         switch (status) {
1769         case BLK_BACKING_FILE:
1770             /* If we have a backing file, leave clusters unallocated that are
1771              * unallocated in the source image, so that the backing file is
1772              * visible at the respective offset. */
1773             assert(s->target_has_backing);
1774             break;
1775 
1776         case BLK_DATA:
1777             /* If we're told to keep the target fully allocated (-S 0) or there
1778              * is real non-zero data, we must write it. Otherwise we can treat
1779              * it as zero sectors.
1780              * Compressed clusters need to be written as a whole, so in that
1781              * case we can only save the write if the buffer is completely
1782              * zeroed. */
1783             if (!s->min_sparse ||
1784                 (!s->compressed &&
1785                  is_allocated_sectors_min(buf, n, &n, s->min_sparse,
1786                                           sector_num, s->alignment)) ||
1787                 (s->compressed &&
1788                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
1789             {
1790                 ret = blk_co_pwrite(s->target, sector_num << BDRV_SECTOR_BITS,
1791                                     n << BDRV_SECTOR_BITS, buf, flags);
1792                 if (ret < 0) {
1793                     return ret;
1794                 }
1795                 break;
1796             }
1797             /* fall-through */
1798 
1799         case BLK_ZERO:
1800             if (s->has_zero_init) {
1801                 assert(!s->target_has_backing);
1802                 break;
1803             }
1804             ret = blk_co_pwrite_zeroes(s->target,
1805                                        sector_num << BDRV_SECTOR_BITS,
1806                                        n << BDRV_SECTOR_BITS,
1807                                        BDRV_REQ_MAY_UNMAP);
1808             if (ret < 0) {
1809                 return ret;
1810             }
1811             break;
1812         }
1813 
1814         sector_num += n;
1815         nb_sectors -= n;
1816         buf += n * BDRV_SECTOR_SIZE;
1817     }
1818 
1819     return 0;
1820 }
1821 
1822 static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
1823                                               int nb_sectors)
1824 {
1825     int n, ret;
1826 
1827     while (nb_sectors > 0) {
1828         BlockBackend *blk;
1829         int src_cur;
1830         int64_t bs_sectors, src_cur_offset;
1831         int64_t offset;
1832 
1833         convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
1834         offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
1835         blk = s->src[src_cur];
1836         bs_sectors = s->src_sectors[src_cur];
1837 
1838         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
1839 
1840         ret = blk_co_copy_range(blk, offset, s->target,
1841                                 sector_num << BDRV_SECTOR_BITS,
1842                                 n << BDRV_SECTOR_BITS, 0, 0);
1843         if (ret < 0) {
1844             return ret;
1845         }
1846 
1847         sector_num += n;
1848         nb_sectors -= n;
1849     }
1850     return 0;
1851 }
1852 
1853 static void coroutine_fn convert_co_do_copy(void *opaque)
1854 {
1855     ImgConvertState *s = opaque;
1856     uint8_t *buf = NULL;
1857     int ret, i;
1858     int index = -1;
1859 
1860     for (i = 0; i < s->num_coroutines; i++) {
1861         if (s->co[i] == qemu_coroutine_self()) {
1862             index = i;
1863             break;
1864         }
1865     }
1866     assert(index >= 0);
1867 
1868     s->running_coroutines++;
1869     buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
1870 
1871     while (1) {
1872         int n;
1873         int64_t sector_num;
1874         enum ImgConvertBlockStatus status;
1875         bool copy_range;
1876 
1877         qemu_co_mutex_lock(&s->lock);
1878         if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
1879             qemu_co_mutex_unlock(&s->lock);
1880             break;
1881         }
1882         n = convert_iteration_sectors(s, s->sector_num);
1883         if (n < 0) {
1884             qemu_co_mutex_unlock(&s->lock);
1885             s->ret = n;
1886             break;
1887         }
1888         /* save current sector and allocation status to local variables */
1889         sector_num = s->sector_num;
1890         status = s->status;
1891         if (!s->min_sparse && s->status == BLK_ZERO) {
1892             n = MIN(n, s->buf_sectors);
1893         }
1894         /* increment global sector counter so that other coroutines can
1895          * already continue reading beyond this request */
1896         s->sector_num += n;
1897         qemu_co_mutex_unlock(&s->lock);
1898 
1899         if (status == BLK_DATA || (!s->min_sparse && status == BLK_ZERO)) {
1900             s->allocated_done += n;
1901             qemu_progress_print(100.0 * s->allocated_done /
1902                                         s->allocated_sectors, 0);
1903         }
1904 
1905 retry:
1906         copy_range = s->copy_range && s->status == BLK_DATA;
1907         if (status == BLK_DATA && !copy_range) {
1908             ret = convert_co_read(s, sector_num, n, buf);
1909             if (ret < 0) {
1910                 error_report("error while reading sector %" PRId64
1911                              ": %s", sector_num, strerror(-ret));
1912                 s->ret = ret;
1913             }
1914         } else if (!s->min_sparse && status == BLK_ZERO) {
1915             status = BLK_DATA;
1916             memset(buf, 0x00, n * BDRV_SECTOR_SIZE);
1917         }
1918 
1919         if (s->wr_in_order) {
1920             /* keep writes in order */
1921             while (s->wr_offs != sector_num && s->ret == -EINPROGRESS) {
1922                 s->wait_sector_num[index] = sector_num;
1923                 qemu_coroutine_yield();
1924             }
1925             s->wait_sector_num[index] = -1;
1926         }
1927 
1928         if (s->ret == -EINPROGRESS) {
1929             if (copy_range) {
1930                 ret = convert_co_copy_range(s, sector_num, n);
1931                 if (ret) {
1932                     s->copy_range = false;
1933                     goto retry;
1934                 }
1935             } else {
1936                 ret = convert_co_write(s, sector_num, n, buf, status);
1937             }
1938             if (ret < 0) {
1939                 error_report("error while writing sector %" PRId64
1940                              ": %s", sector_num, strerror(-ret));
1941                 s->ret = ret;
1942             }
1943         }
1944 
1945         if (s->wr_in_order) {
1946             /* reenter the coroutine that might have waited
1947              * for this write to complete */
1948             s->wr_offs = sector_num + n;
1949             for (i = 0; i < s->num_coroutines; i++) {
1950                 if (s->co[i] && s->wait_sector_num[i] == s->wr_offs) {
1951                     /*
1952                      * A -> B -> A cannot occur because A has
1953                      * s->wait_sector_num[i] == -1 during A -> B.  Therefore
1954                      * B will never enter A during this time window.
1955                      */
1956                     qemu_coroutine_enter(s->co[i]);
1957                     break;
1958                 }
1959             }
1960         }
1961     }
1962 
1963     qemu_vfree(buf);
1964     s->co[index] = NULL;
1965     s->running_coroutines--;
1966     if (!s->running_coroutines && s->ret == -EINPROGRESS) {
1967         /* the convert job finished successfully */
1968         s->ret = 0;
1969     }
1970 }
1971 
1972 static int convert_do_copy(ImgConvertState *s)
1973 {
1974     int ret, i, n;
1975     int64_t sector_num = 0;
1976 
1977     /* Check whether we have zero initialisation or can get it efficiently */
1978     s->has_zero_init = s->min_sparse && !s->target_has_backing
1979                      ? bdrv_has_zero_init(blk_bs(s->target))
1980                      : false;
1981 
1982     if (!s->has_zero_init && !s->target_has_backing &&
1983         bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
1984     {
1985         ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK);
1986         if (ret == 0) {
1987             s->has_zero_init = true;
1988         }
1989     }
1990 
1991     /* Allocate buffer for copied data. For compressed images, only one cluster
1992      * can be copied at a time. */
1993     if (s->compressed) {
1994         if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
1995             error_report("invalid cluster size");
1996             return -EINVAL;
1997         }
1998         s->buf_sectors = s->cluster_sectors;
1999     }
2000 
2001     while (sector_num < s->total_sectors) {
2002         n = convert_iteration_sectors(s, sector_num);
2003         if (n < 0) {
2004             return n;
2005         }
2006         if (s->status == BLK_DATA || (!s->min_sparse && s->status == BLK_ZERO))
2007         {
2008             s->allocated_sectors += n;
2009         }
2010         sector_num += n;
2011     }
2012 
2013     /* Do the copy */
2014     s->sector_next_status = 0;
2015     s->ret = -EINPROGRESS;
2016 
2017     qemu_co_mutex_init(&s->lock);
2018     for (i = 0; i < s->num_coroutines; i++) {
2019         s->co[i] = qemu_coroutine_create(convert_co_do_copy, s);
2020         s->wait_sector_num[i] = -1;
2021         qemu_coroutine_enter(s->co[i]);
2022     }
2023 
2024     while (s->running_coroutines) {
2025         main_loop_wait(false);
2026     }
2027 
2028     if (s->compressed && !s->ret) {
2029         /* signal EOF to align */
2030         ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
2031         if (ret < 0) {
2032             return ret;
2033         }
2034     }
2035 
2036     return s->ret;
2037 }
2038 
2039 #define MAX_BUF_SECTORS 32768
2040 
2041 static int img_convert(int argc, char **argv)
2042 {
2043     int c, bs_i, flags, src_flags = 0;
2044     const char *fmt = NULL, *out_fmt = NULL, *cache = "unsafe",
2045                *src_cache = BDRV_DEFAULT_CACHE, *out_baseimg = NULL,
2046                *out_filename, *out_baseimg_param, *snapshot_name = NULL;
2047     BlockDriver *drv = NULL, *proto_drv = NULL;
2048     BlockDriverInfo bdi;
2049     BlockDriverState *out_bs;
2050     QemuOpts *opts = NULL, *sn_opts = NULL;
2051     QemuOptsList *create_opts = NULL;
2052     QDict *open_opts = NULL;
2053     char *options = NULL;
2054     Error *local_err = NULL;
2055     bool writethrough, src_writethrough, image_opts = false,
2056          skip_create = false, progress = false, tgt_image_opts = false;
2057     int64_t ret = -EINVAL;
2058     bool force_share = false;
2059     bool explict_min_sparse = false;
2060 
2061     ImgConvertState s = (ImgConvertState) {
2062         /* Need at least 4k of zeros for sparse detection */
2063         .min_sparse         = 8,
2064         .copy_range         = false,
2065         .buf_sectors        = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
2066         .wr_in_order        = true,
2067         .num_coroutines     = 8,
2068     };
2069 
2070     for(;;) {
2071         static const struct option long_options[] = {
2072             {"help", no_argument, 0, 'h'},
2073             {"object", required_argument, 0, OPTION_OBJECT},
2074             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2075             {"force-share", no_argument, 0, 'U'},
2076             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
2077             {"salvage", no_argument, 0, OPTION_SALVAGE},
2078             {0, 0, 0, 0}
2079         };
2080         c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
2081                         long_options, NULL);
2082         if (c == -1) {
2083             break;
2084         }
2085         switch(c) {
2086         case ':':
2087             missing_argument(argv[optind - 1]);
2088             break;
2089         case '?':
2090             unrecognized_option(argv[optind - 1]);
2091             break;
2092         case 'h':
2093             help();
2094             break;
2095         case 'f':
2096             fmt = optarg;
2097             break;
2098         case 'O':
2099             out_fmt = optarg;
2100             break;
2101         case 'B':
2102             out_baseimg = optarg;
2103             break;
2104         case 'C':
2105             s.copy_range = true;
2106             break;
2107         case 'c':
2108             s.compressed = true;
2109             break;
2110         case 'o':
2111             if (!is_valid_option_list(optarg)) {
2112                 error_report("Invalid option list: %s", optarg);
2113                 goto fail_getopt;
2114             }
2115             if (!options) {
2116                 options = g_strdup(optarg);
2117             } else {
2118                 char *old_options = options;
2119                 options = g_strdup_printf("%s,%s", options, optarg);
2120                 g_free(old_options);
2121             }
2122             break;
2123         case 'l':
2124             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
2125                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
2126                                                   optarg, false);
2127                 if (!sn_opts) {
2128                     error_report("Failed in parsing snapshot param '%s'",
2129                                  optarg);
2130                     goto fail_getopt;
2131                 }
2132             } else {
2133                 snapshot_name = optarg;
2134             }
2135             break;
2136         case 'S':
2137         {
2138             int64_t sval;
2139 
2140             sval = cvtnum(optarg);
2141             if (sval < 0 || sval & (BDRV_SECTOR_SIZE - 1) ||
2142                 sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) {
2143                 error_report("Invalid buffer size for sparse output specified. "
2144                     "Valid sizes are multiples of %llu up to %llu. Select "
2145                     "0 to disable sparse detection (fully allocates output).",
2146                     BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE);
2147                 goto fail_getopt;
2148             }
2149 
2150             s.min_sparse = sval / BDRV_SECTOR_SIZE;
2151             explict_min_sparse = true;
2152             break;
2153         }
2154         case 'p':
2155             progress = true;
2156             break;
2157         case 't':
2158             cache = optarg;
2159             break;
2160         case 'T':
2161             src_cache = optarg;
2162             break;
2163         case 'q':
2164             s.quiet = true;
2165             break;
2166         case 'n':
2167             skip_create = true;
2168             break;
2169         case 'm':
2170             if (qemu_strtol(optarg, NULL, 0, &s.num_coroutines) ||
2171                 s.num_coroutines < 1 || s.num_coroutines > MAX_COROUTINES) {
2172                 error_report("Invalid number of coroutines. Allowed number of"
2173                              " coroutines is between 1 and %d", MAX_COROUTINES);
2174                 goto fail_getopt;
2175             }
2176             break;
2177         case 'W':
2178             s.wr_in_order = false;
2179             break;
2180         case 'U':
2181             force_share = true;
2182             break;
2183         case OPTION_OBJECT: {
2184             QemuOpts *object_opts;
2185             object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
2186                                                   optarg, true);
2187             if (!object_opts) {
2188                 goto fail_getopt;
2189             }
2190             break;
2191         }
2192         case OPTION_IMAGE_OPTS:
2193             image_opts = true;
2194             break;
2195         case OPTION_SALVAGE:
2196             s.salvage = true;
2197             break;
2198         case OPTION_TARGET_IMAGE_OPTS:
2199             tgt_image_opts = true;
2200             break;
2201         }
2202     }
2203 
2204     if (!out_fmt && !tgt_image_opts) {
2205         out_fmt = "raw";
2206     }
2207 
2208     if (qemu_opts_foreach(&qemu_object_opts,
2209                           user_creatable_add_opts_foreach,
2210                           NULL, &error_fatal)) {
2211         goto fail_getopt;
2212     }
2213 
2214     if (s.compressed && s.copy_range) {
2215         error_report("Cannot enable copy offloading when -c is used");
2216         goto fail_getopt;
2217     }
2218 
2219     if (explict_min_sparse && s.copy_range) {
2220         error_report("Cannot enable copy offloading when -S is used");
2221         goto fail_getopt;
2222     }
2223 
2224     if (s.copy_range && s.salvage) {
2225         error_report("Cannot use copy offloading in salvaging mode");
2226         goto fail_getopt;
2227     }
2228 
2229     if (tgt_image_opts && !skip_create) {
2230         error_report("--target-image-opts requires use of -n flag");
2231         goto fail_getopt;
2232     }
2233 
2234     s.src_num = argc - optind - 1;
2235     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
2236 
2237     if (options && has_help_option(options)) {
2238         if (out_fmt) {
2239             ret = print_block_option_help(out_filename, out_fmt);
2240             goto fail_getopt;
2241         } else {
2242             error_report("Option help requires a format be specified");
2243             goto fail_getopt;
2244         }
2245     }
2246 
2247     if (s.src_num < 1) {
2248         error_report("Must specify image file name");
2249         goto fail_getopt;
2250     }
2251 
2252 
2253     /* ret is still -EINVAL until here */
2254     ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
2255     if (ret < 0) {
2256         error_report("Invalid source cache option: %s", src_cache);
2257         goto fail_getopt;
2258     }
2259 
2260     /* Initialize before goto out */
2261     if (s.quiet) {
2262         progress = false;
2263     }
2264     qemu_progress_init(progress, 1.0);
2265     qemu_progress_print(0, 100);
2266 
2267     s.src = g_new0(BlockBackend *, s.src_num);
2268     s.src_sectors = g_new(int64_t, s.src_num);
2269 
2270     for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2271         s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],
2272                                fmt, src_flags, src_writethrough, s.quiet,
2273                                force_share);
2274         if (!s.src[bs_i]) {
2275             ret = -1;
2276             goto out;
2277         }
2278         s.src_sectors[bs_i] = blk_nb_sectors(s.src[bs_i]);
2279         if (s.src_sectors[bs_i] < 0) {
2280             error_report("Could not get size of %s: %s",
2281                          argv[optind + bs_i], strerror(-s.src_sectors[bs_i]));
2282             ret = -1;
2283             goto out;
2284         }
2285         s.total_sectors += s.src_sectors[bs_i];
2286     }
2287 
2288     if (sn_opts) {
2289         bdrv_snapshot_load_tmp(blk_bs(s.src[0]),
2290                                qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
2291                                qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
2292                                &local_err);
2293     } else if (snapshot_name != NULL) {
2294         if (s.src_num > 1) {
2295             error_report("No support for concatenating multiple snapshot");
2296             ret = -1;
2297             goto out;
2298         }
2299 
2300         bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(s.src[0]), snapshot_name,
2301                                              &local_err);
2302     }
2303     if (local_err) {
2304         error_reportf_err(local_err, "Failed to load snapshot: ");
2305         ret = -1;
2306         goto out;
2307     }
2308 
2309     if (!skip_create) {
2310         /* Find driver and parse its options */
2311         drv = bdrv_find_format(out_fmt);
2312         if (!drv) {
2313             error_report("Unknown file format '%s'", out_fmt);
2314             ret = -1;
2315             goto out;
2316         }
2317 
2318         proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
2319         if (!proto_drv) {
2320             error_report_err(local_err);
2321             ret = -1;
2322             goto out;
2323         }
2324 
2325         if (!drv->create_opts) {
2326             error_report("Format driver '%s' does not support image creation",
2327                          drv->format_name);
2328             ret = -1;
2329             goto out;
2330         }
2331 
2332         if (!proto_drv->create_opts) {
2333             error_report("Protocol driver '%s' does not support image creation",
2334                          proto_drv->format_name);
2335             ret = -1;
2336             goto out;
2337         }
2338 
2339         create_opts = qemu_opts_append(create_opts, drv->create_opts);
2340         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
2341 
2342         opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
2343         if (options) {
2344             qemu_opts_do_parse(opts, options, NULL, &local_err);
2345             if (local_err) {
2346                 error_report_err(local_err);
2347                 ret = -1;
2348                 goto out;
2349             }
2350         }
2351 
2352         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s.total_sectors * 512,
2353                             &error_abort);
2354         ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
2355         if (ret < 0) {
2356             goto out;
2357         }
2358     }
2359 
2360     /* Get backing file name if -o backing_file was used */
2361     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2362     if (out_baseimg_param) {
2363         out_baseimg = out_baseimg_param;
2364     }
2365     s.target_has_backing = (bool) out_baseimg;
2366 
2367     if (s.src_num > 1 && out_baseimg) {
2368         error_report("Having a backing file for the target makes no sense when "
2369                      "concatenating multiple input images");
2370         ret = -1;
2371         goto out;
2372     }
2373 
2374     /* Check if compression is supported */
2375     if (s.compressed) {
2376         bool encryption =
2377             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
2378         const char *encryptfmt =
2379             qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT);
2380         const char *preallocation =
2381             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
2382 
2383         if (drv && !drv->bdrv_co_pwritev_compressed) {
2384             error_report("Compression not supported for this file format");
2385             ret = -1;
2386             goto out;
2387         }
2388 
2389         if (encryption || encryptfmt) {
2390             error_report("Compression and encryption not supported at "
2391                          "the same time");
2392             ret = -1;
2393             goto out;
2394         }
2395 
2396         if (preallocation
2397             && strcmp(preallocation, "off"))
2398         {
2399             error_report("Compression and preallocation not supported at "
2400                          "the same time");
2401             ret = -1;
2402             goto out;
2403         }
2404     }
2405 
2406     /*
2407      * The later open call will need any decryption secrets, and
2408      * bdrv_create() will purge "opts", so extract them now before
2409      * they are lost.
2410      */
2411     if (!skip_create) {
2412         open_opts = qdict_new();
2413         qemu_opt_foreach(opts, img_add_key_secrets, open_opts, &error_abort);
2414     }
2415 
2416     if (!skip_create) {
2417         /* Create the new image */
2418         ret = bdrv_create(drv, out_filename, opts, &local_err);
2419         if (ret < 0) {
2420             error_reportf_err(local_err, "%s: error while converting %s: ",
2421                               out_filename, out_fmt);
2422             goto out;
2423         }
2424     }
2425 
2426     flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
2427     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
2428     if (ret < 0) {
2429         error_report("Invalid cache option: %s", cache);
2430         goto out;
2431     }
2432 
2433     if (skip_create) {
2434         s.target = img_open(tgt_image_opts, out_filename, out_fmt,
2435                             flags, writethrough, s.quiet, false);
2436     } else {
2437         /* TODO ultimately we should allow --target-image-opts
2438          * to be used even when -n is not given.
2439          * That has to wait for bdrv_create to be improved
2440          * to allow filenames in option syntax
2441          */
2442         s.target = img_open_file(out_filename, open_opts, out_fmt,
2443                                  flags, writethrough, s.quiet, false);
2444         open_opts = NULL; /* blk_new_open will have freed it */
2445     }
2446     if (!s.target) {
2447         ret = -1;
2448         goto out;
2449     }
2450     out_bs = blk_bs(s.target);
2451 
2452     if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
2453         error_report("Compression not supported for this file format");
2454         ret = -1;
2455         goto out;
2456     }
2457 
2458     /* increase bufsectors from the default 4096 (2M) if opt_transfer
2459      * or discard_alignment of the out_bs is greater. Limit to
2460      * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
2461     s.buf_sectors = MIN(MAX_BUF_SECTORS,
2462                         MAX(s.buf_sectors,
2463                             MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
2464                                 out_bs->bl.pdiscard_alignment >>
2465                                 BDRV_SECTOR_BITS)));
2466 
2467     /* try to align the write requests to the destination to avoid unnecessary
2468      * RMW cycles. */
2469     s.alignment = MAX(pow2floor(s.min_sparse),
2470                       DIV_ROUND_UP(out_bs->bl.request_alignment,
2471                                    BDRV_SECTOR_SIZE));
2472     assert(is_power_of_2(s.alignment));
2473 
2474     if (skip_create) {
2475         int64_t output_sectors = blk_nb_sectors(s.target);
2476         if (output_sectors < 0) {
2477             error_report("unable to get output image length: %s",
2478                          strerror(-output_sectors));
2479             ret = -1;
2480             goto out;
2481         } else if (output_sectors < s.total_sectors) {
2482             error_report("output file is smaller than input file");
2483             ret = -1;
2484             goto out;
2485         }
2486     }
2487 
2488     if (s.target_has_backing) {
2489         /* Errors are treated as "backing length unknown" (which means
2490          * s.target_backing_sectors has to be negative, which it will
2491          * be automatically).  The backing file length is used only
2492          * for optimizations, so such a case is not fatal. */
2493         s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
2494     } else {
2495         s.target_backing_sectors = -1;
2496     }
2497 
2498     ret = bdrv_get_info(out_bs, &bdi);
2499     if (ret < 0) {
2500         if (s.compressed) {
2501             error_report("could not get block driver info");
2502             goto out;
2503         }
2504     } else {
2505         s.compressed = s.compressed || bdi.needs_compressed_writes;
2506         s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
2507         s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;
2508     }
2509 
2510     ret = convert_do_copy(&s);
2511 out:
2512     if (!ret) {
2513         qemu_progress_print(100, 0);
2514     }
2515     qemu_progress_end();
2516     qemu_opts_del(opts);
2517     qemu_opts_free(create_opts);
2518     qemu_opts_del(sn_opts);
2519     qobject_unref(open_opts);
2520     blk_unref(s.target);
2521     if (s.src) {
2522         for (bs_i = 0; bs_i < s.src_num; bs_i++) {
2523             blk_unref(s.src[bs_i]);
2524         }
2525         g_free(s.src);
2526     }
2527     g_free(s.src_sectors);
2528 fail_getopt:
2529     g_free(options);
2530 
2531     return !!ret;
2532 }
2533 
2534 
2535 static void dump_snapshots(BlockDriverState *bs)
2536 {
2537     QEMUSnapshotInfo *sn_tab, *sn;
2538     int nb_sns, i;
2539 
2540     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2541     if (nb_sns <= 0)
2542         return;
2543     printf("Snapshot list:\n");
2544     bdrv_snapshot_dump(NULL);
2545     printf("\n");
2546     for(i = 0; i < nb_sns; i++) {
2547         sn = &sn_tab[i];
2548         bdrv_snapshot_dump(sn);
2549         printf("\n");
2550     }
2551     g_free(sn_tab);
2552 }
2553 
2554 static void dump_json_image_info_list(ImageInfoList *list)
2555 {
2556     QString *str;
2557     QObject *obj;
2558     Visitor *v = qobject_output_visitor_new(&obj);
2559 
2560     visit_type_ImageInfoList(v, NULL, &list, &error_abort);
2561     visit_complete(v, &obj);
2562     str = qobject_to_json_pretty(obj);
2563     assert(str != NULL);
2564     printf("%s\n", qstring_get_str(str));
2565     qobject_unref(obj);
2566     visit_free(v);
2567     qobject_unref(str);
2568 }
2569 
2570 static void dump_json_image_info(ImageInfo *info)
2571 {
2572     QString *str;
2573     QObject *obj;
2574     Visitor *v = qobject_output_visitor_new(&obj);
2575 
2576     visit_type_ImageInfo(v, NULL, &info, &error_abort);
2577     visit_complete(v, &obj);
2578     str = qobject_to_json_pretty(obj);
2579     assert(str != NULL);
2580     printf("%s\n", qstring_get_str(str));
2581     qobject_unref(obj);
2582     visit_free(v);
2583     qobject_unref(str);
2584 }
2585 
2586 static void dump_human_image_info_list(ImageInfoList *list)
2587 {
2588     ImageInfoList *elem;
2589     bool delim = false;
2590 
2591     for (elem = list; elem; elem = elem->next) {
2592         if (delim) {
2593             printf("\n");
2594         }
2595         delim = true;
2596 
2597         bdrv_image_info_dump(elem->value);
2598     }
2599 }
2600 
2601 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
2602 {
2603     return strcmp(a, b) == 0;
2604 }
2605 
2606 /**
2607  * Open an image file chain and return an ImageInfoList
2608  *
2609  * @filename: topmost image filename
2610  * @fmt: topmost image format (may be NULL to autodetect)
2611  * @chain: true  - enumerate entire backing file chain
2612  *         false - only topmost image file
2613  *
2614  * Returns a list of ImageInfo objects or NULL if there was an error opening an
2615  * image file.  If there was an error a message will have been printed to
2616  * stderr.
2617  */
2618 static ImageInfoList *collect_image_info_list(bool image_opts,
2619                                               const char *filename,
2620                                               const char *fmt,
2621                                               bool chain, bool force_share)
2622 {
2623     ImageInfoList *head = NULL;
2624     ImageInfoList **last = &head;
2625     GHashTable *filenames;
2626     Error *err = NULL;
2627 
2628     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
2629 
2630     while (filename) {
2631         BlockBackend *blk;
2632         BlockDriverState *bs;
2633         ImageInfo *info;
2634         ImageInfoList *elem;
2635 
2636         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
2637             error_report("Backing file '%s' creates an infinite loop.",
2638                          filename);
2639             goto err;
2640         }
2641         g_hash_table_insert(filenames, (gpointer)filename, NULL);
2642 
2643         blk = img_open(image_opts, filename, fmt,
2644                        BDRV_O_NO_BACKING | BDRV_O_NO_IO, false, false,
2645                        force_share);
2646         if (!blk) {
2647             goto err;
2648         }
2649         bs = blk_bs(blk);
2650 
2651         bdrv_query_image_info(bs, &info, &err);
2652         if (err) {
2653             error_report_err(err);
2654             blk_unref(blk);
2655             goto err;
2656         }
2657 
2658         elem = g_new0(ImageInfoList, 1);
2659         elem->value = info;
2660         *last = elem;
2661         last = &elem->next;
2662 
2663         blk_unref(blk);
2664 
2665         filename = fmt = NULL;
2666         if (chain) {
2667             if (info->has_full_backing_filename) {
2668                 filename = info->full_backing_filename;
2669             } else if (info->has_backing_filename) {
2670                 error_report("Could not determine absolute backing filename,"
2671                              " but backing filename '%s' present",
2672                              info->backing_filename);
2673                 goto err;
2674             }
2675             if (info->has_backing_filename_format) {
2676                 fmt = info->backing_filename_format;
2677             }
2678         }
2679     }
2680     g_hash_table_destroy(filenames);
2681     return head;
2682 
2683 err:
2684     qapi_free_ImageInfoList(head);
2685     g_hash_table_destroy(filenames);
2686     return NULL;
2687 }
2688 
2689 static int img_info(int argc, char **argv)
2690 {
2691     int c;
2692     OutputFormat output_format = OFORMAT_HUMAN;
2693     bool chain = false;
2694     const char *filename, *fmt, *output;
2695     ImageInfoList *list;
2696     bool image_opts = false;
2697     bool force_share = false;
2698 
2699     fmt = NULL;
2700     output = NULL;
2701     for(;;) {
2702         int option_index = 0;
2703         static const struct option long_options[] = {
2704             {"help", no_argument, 0, 'h'},
2705             {"format", required_argument, 0, 'f'},
2706             {"output", required_argument, 0, OPTION_OUTPUT},
2707             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
2708             {"object", required_argument, 0, OPTION_OBJECT},
2709             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2710             {"force-share", no_argument, 0, 'U'},
2711             {0, 0, 0, 0}
2712         };
2713         c = getopt_long(argc, argv, ":f:hU",
2714                         long_options, &option_index);
2715         if (c == -1) {
2716             break;
2717         }
2718         switch(c) {
2719         case ':':
2720             missing_argument(argv[optind - 1]);
2721             break;
2722         case '?':
2723             unrecognized_option(argv[optind - 1]);
2724             break;
2725         case 'h':
2726             help();
2727             break;
2728         case 'f':
2729             fmt = optarg;
2730             break;
2731         case 'U':
2732             force_share = true;
2733             break;
2734         case OPTION_OUTPUT:
2735             output = optarg;
2736             break;
2737         case OPTION_BACKING_CHAIN:
2738             chain = true;
2739             break;
2740         case OPTION_OBJECT: {
2741             QemuOpts *opts;
2742             opts = qemu_opts_parse_noisily(&qemu_object_opts,
2743                                            optarg, true);
2744             if (!opts) {
2745                 return 1;
2746             }
2747         }   break;
2748         case OPTION_IMAGE_OPTS:
2749             image_opts = true;
2750             break;
2751         }
2752     }
2753     if (optind != argc - 1) {
2754         error_exit("Expecting one image file name");
2755     }
2756     filename = argv[optind++];
2757 
2758     if (output && !strcmp(output, "json")) {
2759         output_format = OFORMAT_JSON;
2760     } else if (output && !strcmp(output, "human")) {
2761         output_format = OFORMAT_HUMAN;
2762     } else if (output) {
2763         error_report("--output must be used with human or json as argument.");
2764         return 1;
2765     }
2766 
2767     if (qemu_opts_foreach(&qemu_object_opts,
2768                           user_creatable_add_opts_foreach,
2769                           NULL, &error_fatal)) {
2770         return 1;
2771     }
2772 
2773     list = collect_image_info_list(image_opts, filename, fmt, chain,
2774                                    force_share);
2775     if (!list) {
2776         return 1;
2777     }
2778 
2779     switch (output_format) {
2780     case OFORMAT_HUMAN:
2781         dump_human_image_info_list(list);
2782         break;
2783     case OFORMAT_JSON:
2784         if (chain) {
2785             dump_json_image_info_list(list);
2786         } else {
2787             dump_json_image_info(list->value);
2788         }
2789         break;
2790     }
2791 
2792     qapi_free_ImageInfoList(list);
2793     return 0;
2794 }
2795 
2796 static int dump_map_entry(OutputFormat output_format, MapEntry *e,
2797                           MapEntry *next)
2798 {
2799     switch (output_format) {
2800     case OFORMAT_HUMAN:
2801         if (e->data && !e->has_offset) {
2802             error_report("File contains external, encrypted or compressed clusters.");
2803             return -1;
2804         }
2805         if (e->data && !e->zero) {
2806             printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
2807                    e->start, e->length,
2808                    e->has_offset ? e->offset : 0,
2809                    e->has_filename ? e->filename : "");
2810         }
2811         /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
2812          * Modify the flags here to allow more coalescing.
2813          */
2814         if (next && (!next->data || next->zero)) {
2815             next->data = false;
2816             next->zero = true;
2817         }
2818         break;
2819     case OFORMAT_JSON:
2820         printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64","
2821                " \"depth\": %"PRId64", \"zero\": %s, \"data\": %s",
2822                (e->start == 0 ? "[" : ",\n"),
2823                e->start, e->length, e->depth,
2824                e->zero ? "true" : "false",
2825                e->data ? "true" : "false");
2826         if (e->has_offset) {
2827             printf(", \"offset\": %"PRId64"", e->offset);
2828         }
2829         putchar('}');
2830 
2831         if (!next) {
2832             printf("]\n");
2833         }
2834         break;
2835     }
2836     return 0;
2837 }
2838 
2839 static int get_block_status(BlockDriverState *bs, int64_t offset,
2840                             int64_t bytes, MapEntry *e)
2841 {
2842     int ret;
2843     int depth;
2844     BlockDriverState *file;
2845     bool has_offset;
2846     int64_t map;
2847     char *filename = NULL;
2848 
2849     /* As an optimization, we could cache the current range of unallocated
2850      * clusters in each file of the chain, and avoid querying the same
2851      * range repeatedly.
2852      */
2853 
2854     depth = 0;
2855     for (;;) {
2856         ret = bdrv_block_status(bs, offset, bytes, &bytes, &map, &file);
2857         if (ret < 0) {
2858             return ret;
2859         }
2860         assert(bytes);
2861         if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
2862             break;
2863         }
2864         bs = backing_bs(bs);
2865         if (bs == NULL) {
2866             ret = 0;
2867             break;
2868         }
2869 
2870         depth++;
2871     }
2872 
2873     has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
2874 
2875     if (file && has_offset) {
2876         bdrv_refresh_filename(file);
2877         filename = file->filename;
2878     }
2879 
2880     *e = (MapEntry) {
2881         .start = offset,
2882         .length = bytes,
2883         .data = !!(ret & BDRV_BLOCK_DATA),
2884         .zero = !!(ret & BDRV_BLOCK_ZERO),
2885         .offset = map,
2886         .has_offset = has_offset,
2887         .depth = depth,
2888         .has_filename = filename,
2889         .filename = filename,
2890     };
2891 
2892     return 0;
2893 }
2894 
2895 static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
2896 {
2897     if (curr->length == 0) {
2898         return false;
2899     }
2900     if (curr->zero != next->zero ||
2901         curr->data != next->data ||
2902         curr->depth != next->depth ||
2903         curr->has_filename != next->has_filename ||
2904         curr->has_offset != next->has_offset) {
2905         return false;
2906     }
2907     if (curr->has_filename && strcmp(curr->filename, next->filename)) {
2908         return false;
2909     }
2910     if (curr->has_offset && curr->offset + curr->length != next->offset) {
2911         return false;
2912     }
2913     return true;
2914 }
2915 
2916 static int img_map(int argc, char **argv)
2917 {
2918     int c;
2919     OutputFormat output_format = OFORMAT_HUMAN;
2920     BlockBackend *blk;
2921     BlockDriverState *bs;
2922     const char *filename, *fmt, *output;
2923     int64_t length;
2924     MapEntry curr = { .length = 0 }, next;
2925     int ret = 0;
2926     bool image_opts = false;
2927     bool force_share = false;
2928 
2929     fmt = NULL;
2930     output = NULL;
2931     for (;;) {
2932         int option_index = 0;
2933         static const struct option long_options[] = {
2934             {"help", no_argument, 0, 'h'},
2935             {"format", required_argument, 0, 'f'},
2936             {"output", required_argument, 0, OPTION_OUTPUT},
2937             {"object", required_argument, 0, OPTION_OBJECT},
2938             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
2939             {"force-share", no_argument, 0, 'U'},
2940             {0, 0, 0, 0}
2941         };
2942         c = getopt_long(argc, argv, ":f:hU",
2943                         long_options, &option_index);
2944         if (c == -1) {
2945             break;
2946         }
2947         switch (c) {
2948         case ':':
2949             missing_argument(argv[optind - 1]);
2950             break;
2951         case '?':
2952             unrecognized_option(argv[optind - 1]);
2953             break;
2954         case 'h':
2955             help();
2956             break;
2957         case 'f':
2958             fmt = optarg;
2959             break;
2960         case 'U':
2961             force_share = true;
2962             break;
2963         case OPTION_OUTPUT:
2964             output = optarg;
2965             break;
2966         case OPTION_OBJECT: {
2967             QemuOpts *opts;
2968             opts = qemu_opts_parse_noisily(&qemu_object_opts,
2969                                            optarg, true);
2970             if (!opts) {
2971                 return 1;
2972             }
2973         }   break;
2974         case OPTION_IMAGE_OPTS:
2975             image_opts = true;
2976             break;
2977         }
2978     }
2979     if (optind != argc - 1) {
2980         error_exit("Expecting one image file name");
2981     }
2982     filename = argv[optind];
2983 
2984     if (output && !strcmp(output, "json")) {
2985         output_format = OFORMAT_JSON;
2986     } else if (output && !strcmp(output, "human")) {
2987         output_format = OFORMAT_HUMAN;
2988     } else if (output) {
2989         error_report("--output must be used with human or json as argument.");
2990         return 1;
2991     }
2992 
2993     if (qemu_opts_foreach(&qemu_object_opts,
2994                           user_creatable_add_opts_foreach,
2995                           NULL, &error_fatal)) {
2996         return 1;
2997     }
2998 
2999     blk = img_open(image_opts, filename, fmt, 0, false, false, force_share);
3000     if (!blk) {
3001         return 1;
3002     }
3003     bs = blk_bs(blk);
3004 
3005     if (output_format == OFORMAT_HUMAN) {
3006         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
3007     }
3008 
3009     length = blk_getlength(blk);
3010     while (curr.start + curr.length < length) {
3011         int64_t offset = curr.start + curr.length;
3012         int64_t n;
3013 
3014         /* Probe up to 1 GiB at a time.  */
3015         n = MIN(1 * GiB, length - offset);
3016         ret = get_block_status(bs, offset, n, &next);
3017 
3018         if (ret < 0) {
3019             error_report("Could not read file metadata: %s", strerror(-ret));
3020             goto out;
3021         }
3022 
3023         if (entry_mergeable(&curr, &next)) {
3024             curr.length += next.length;
3025             continue;
3026         }
3027 
3028         if (curr.length > 0) {
3029             ret = dump_map_entry(output_format, &curr, &next);
3030             if (ret < 0) {
3031                 goto out;
3032             }
3033         }
3034         curr = next;
3035     }
3036 
3037     ret = dump_map_entry(output_format, &curr, NULL);
3038 
3039 out:
3040     blk_unref(blk);
3041     return ret < 0;
3042 }
3043 
3044 #define SNAPSHOT_LIST   1
3045 #define SNAPSHOT_CREATE 2
3046 #define SNAPSHOT_APPLY  3
3047 #define SNAPSHOT_DELETE 4
3048 
3049 static int img_snapshot(int argc, char **argv)
3050 {
3051     BlockBackend *blk;
3052     BlockDriverState *bs;
3053     QEMUSnapshotInfo sn;
3054     char *filename, *snapshot_name = NULL;
3055     int c, ret = 0, bdrv_oflags;
3056     int action = 0;
3057     qemu_timeval tv;
3058     bool quiet = false;
3059     Error *err = NULL;
3060     bool image_opts = false;
3061     bool force_share = false;
3062 
3063     bdrv_oflags = BDRV_O_RDWR;
3064     /* Parse commandline parameters */
3065     for(;;) {
3066         static const struct option long_options[] = {
3067             {"help", no_argument, 0, 'h'},
3068             {"object", required_argument, 0, OPTION_OBJECT},
3069             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3070             {"force-share", no_argument, 0, 'U'},
3071             {0, 0, 0, 0}
3072         };
3073         c = getopt_long(argc, argv, ":la:c:d:hqU",
3074                         long_options, NULL);
3075         if (c == -1) {
3076             break;
3077         }
3078         switch(c) {
3079         case ':':
3080             missing_argument(argv[optind - 1]);
3081             break;
3082         case '?':
3083             unrecognized_option(argv[optind - 1]);
3084             break;
3085         case 'h':
3086             help();
3087             return 0;
3088         case 'l':
3089             if (action) {
3090                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3091                 return 0;
3092             }
3093             action = SNAPSHOT_LIST;
3094             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
3095             break;
3096         case 'a':
3097             if (action) {
3098                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3099                 return 0;
3100             }
3101             action = SNAPSHOT_APPLY;
3102             snapshot_name = optarg;
3103             break;
3104         case 'c':
3105             if (action) {
3106                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3107                 return 0;
3108             }
3109             action = SNAPSHOT_CREATE;
3110             snapshot_name = optarg;
3111             break;
3112         case 'd':
3113             if (action) {
3114                 error_exit("Cannot mix '-l', '-a', '-c', '-d'");
3115                 return 0;
3116             }
3117             action = SNAPSHOT_DELETE;
3118             snapshot_name = optarg;
3119             break;
3120         case 'q':
3121             quiet = true;
3122             break;
3123         case 'U':
3124             force_share = true;
3125             break;
3126         case OPTION_OBJECT: {
3127             QemuOpts *opts;
3128             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3129                                            optarg, true);
3130             if (!opts) {
3131                 return 1;
3132             }
3133         }   break;
3134         case OPTION_IMAGE_OPTS:
3135             image_opts = true;
3136             break;
3137         }
3138     }
3139 
3140     if (optind != argc - 1) {
3141         error_exit("Expecting one image file name");
3142     }
3143     filename = argv[optind++];
3144 
3145     if (qemu_opts_foreach(&qemu_object_opts,
3146                           user_creatable_add_opts_foreach,
3147                           NULL, &error_fatal)) {
3148         return 1;
3149     }
3150 
3151     /* Open the image */
3152     blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet,
3153                    force_share);
3154     if (!blk) {
3155         return 1;
3156     }
3157     bs = blk_bs(blk);
3158 
3159     /* Perform the requested action */
3160     switch(action) {
3161     case SNAPSHOT_LIST:
3162         dump_snapshots(bs);
3163         break;
3164 
3165     case SNAPSHOT_CREATE:
3166         memset(&sn, 0, sizeof(sn));
3167         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
3168 
3169         qemu_gettimeofday(&tv);
3170         sn.date_sec = tv.tv_sec;
3171         sn.date_nsec = tv.tv_usec * 1000;
3172 
3173         ret = bdrv_snapshot_create(bs, &sn);
3174         if (ret) {
3175             error_report("Could not create snapshot '%s': %d (%s)",
3176                 snapshot_name, ret, strerror(-ret));
3177         }
3178         break;
3179 
3180     case SNAPSHOT_APPLY:
3181         ret = bdrv_snapshot_goto(bs, snapshot_name, &err);
3182         if (ret) {
3183             error_reportf_err(err, "Could not apply snapshot '%s': ",
3184                               snapshot_name);
3185         }
3186         break;
3187 
3188     case SNAPSHOT_DELETE:
3189         ret = bdrv_snapshot_find(bs, &sn, snapshot_name);
3190         if (ret < 0) {
3191             error_report("Could not delete snapshot '%s': snapshot not "
3192                          "found", snapshot_name);
3193             ret = 1;
3194         } else {
3195             ret = bdrv_snapshot_delete(bs, sn.id_str, sn.name, &err);
3196             if (ret < 0) {
3197                 error_reportf_err(err, "Could not delete snapshot '%s': ",
3198                                   snapshot_name);
3199                 ret = 1;
3200             }
3201         }
3202         break;
3203     }
3204 
3205     /* Cleanup */
3206     blk_unref(blk);
3207     if (ret) {
3208         return 1;
3209     }
3210     return 0;
3211 }
3212 
3213 static int img_rebase(int argc, char **argv)
3214 {
3215     BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
3216     uint8_t *buf_old = NULL;
3217     uint8_t *buf_new = NULL;
3218     BlockDriverState *bs = NULL, *prefix_chain_bs = NULL;
3219     char *filename;
3220     const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
3221     int c, flags, src_flags, ret;
3222     bool writethrough, src_writethrough;
3223     int unsafe = 0;
3224     bool force_share = false;
3225     int progress = 0;
3226     bool quiet = false;
3227     Error *local_err = NULL;
3228     bool image_opts = false;
3229 
3230     /* Parse commandline parameters */
3231     fmt = NULL;
3232     cache = BDRV_DEFAULT_CACHE;
3233     src_cache = BDRV_DEFAULT_CACHE;
3234     out_baseimg = NULL;
3235     out_basefmt = NULL;
3236     for(;;) {
3237         static const struct option long_options[] = {
3238             {"help", no_argument, 0, 'h'},
3239             {"object", required_argument, 0, OPTION_OBJECT},
3240             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3241             {"force-share", no_argument, 0, 'U'},
3242             {0, 0, 0, 0}
3243         };
3244         c = getopt_long(argc, argv, ":hf:F:b:upt:T:qU",
3245                         long_options, NULL);
3246         if (c == -1) {
3247             break;
3248         }
3249         switch(c) {
3250         case ':':
3251             missing_argument(argv[optind - 1]);
3252             break;
3253         case '?':
3254             unrecognized_option(argv[optind - 1]);
3255             break;
3256         case 'h':
3257             help();
3258             return 0;
3259         case 'f':
3260             fmt = optarg;
3261             break;
3262         case 'F':
3263             out_basefmt = optarg;
3264             break;
3265         case 'b':
3266             out_baseimg = optarg;
3267             break;
3268         case 'u':
3269             unsafe = 1;
3270             break;
3271         case 'p':
3272             progress = 1;
3273             break;
3274         case 't':
3275             cache = optarg;
3276             break;
3277         case 'T':
3278             src_cache = optarg;
3279             break;
3280         case 'q':
3281             quiet = true;
3282             break;
3283         case OPTION_OBJECT: {
3284             QemuOpts *opts;
3285             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3286                                            optarg, true);
3287             if (!opts) {
3288                 return 1;
3289             }
3290         }   break;
3291         case OPTION_IMAGE_OPTS:
3292             image_opts = true;
3293             break;
3294         case 'U':
3295             force_share = true;
3296             break;
3297         }
3298     }
3299 
3300     if (quiet) {
3301         progress = 0;
3302     }
3303 
3304     if (optind != argc - 1) {
3305         error_exit("Expecting one image file name");
3306     }
3307     if (!unsafe && !out_baseimg) {
3308         error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
3309     }
3310     filename = argv[optind++];
3311 
3312     if (qemu_opts_foreach(&qemu_object_opts,
3313                           user_creatable_add_opts_foreach,
3314                           NULL, &error_fatal)) {
3315         return 1;
3316     }
3317 
3318     qemu_progress_init(progress, 2.0);
3319     qemu_progress_print(0, 100);
3320 
3321     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
3322     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
3323     if (ret < 0) {
3324         error_report("Invalid cache option: %s", cache);
3325         goto out;
3326     }
3327 
3328     src_flags = 0;
3329     ret = bdrv_parse_cache_mode(src_cache, &src_flags, &src_writethrough);
3330     if (ret < 0) {
3331         error_report("Invalid source cache option: %s", src_cache);
3332         goto out;
3333     }
3334 
3335     /* The source files are opened read-only, don't care about WCE */
3336     assert((src_flags & BDRV_O_RDWR) == 0);
3337     (void) src_writethrough;
3338 
3339     /*
3340      * Open the images.
3341      *
3342      * Ignore the old backing file for unsafe rebase in case we want to correct
3343      * the reference to a renamed or moved backing file.
3344      */
3345     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
3346                    false);
3347     if (!blk) {
3348         ret = -1;
3349         goto out;
3350     }
3351     bs = blk_bs(blk);
3352 
3353     if (out_basefmt != NULL) {
3354         if (bdrv_find_format(out_basefmt) == NULL) {
3355             error_report("Invalid format name: '%s'", out_basefmt);
3356             ret = -1;
3357             goto out;
3358         }
3359     }
3360 
3361     /* For safe rebasing we need to compare old and new backing file */
3362     if (!unsafe) {
3363         QDict *options = NULL;
3364         BlockDriverState *base_bs = backing_bs(bs);
3365 
3366         if (base_bs) {
3367             blk_old_backing = blk_new(qemu_get_aio_context(),
3368                                       BLK_PERM_CONSISTENT_READ,
3369                                       BLK_PERM_ALL);
3370             ret = blk_insert_bs(blk_old_backing, base_bs,
3371                                 &local_err);
3372             if (ret < 0) {
3373                 error_reportf_err(local_err,
3374                                   "Could not reuse old backing file '%s': ",
3375                                   base_bs->filename);
3376                 goto out;
3377             }
3378         } else {
3379             blk_old_backing = NULL;
3380         }
3381 
3382         if (out_baseimg[0]) {
3383             const char *overlay_filename;
3384             char *out_real_path;
3385 
3386             options = qdict_new();
3387             if (out_basefmt) {
3388                 qdict_put_str(options, "driver", out_basefmt);
3389             }
3390             if (force_share) {
3391                 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
3392             }
3393 
3394             bdrv_refresh_filename(bs);
3395             overlay_filename = bs->exact_filename[0] ? bs->exact_filename
3396                                                      : bs->filename;
3397             out_real_path =
3398                 bdrv_get_full_backing_filename_from_filename(overlay_filename,
3399                                                              out_baseimg,
3400                                                              &local_err);
3401             if (local_err) {
3402                 qobject_unref(options);
3403                 error_reportf_err(local_err,
3404                                   "Could not resolve backing filename: ");
3405                 ret = -1;
3406                 goto out;
3407             }
3408 
3409             /*
3410              * Find out whether we rebase an image on top of a previous image
3411              * in its chain.
3412              */
3413             prefix_chain_bs = bdrv_find_backing_image(bs, out_real_path);
3414             if (prefix_chain_bs) {
3415                 qobject_unref(options);
3416                 g_free(out_real_path);
3417 
3418                 blk_new_backing = blk_new(qemu_get_aio_context(),
3419                                           BLK_PERM_CONSISTENT_READ,
3420                                           BLK_PERM_ALL);
3421                 ret = blk_insert_bs(blk_new_backing, prefix_chain_bs,
3422                                     &local_err);
3423                 if (ret < 0) {
3424                     error_reportf_err(local_err,
3425                                       "Could not reuse backing file '%s': ",
3426                                       out_baseimg);
3427                     goto out;
3428                 }
3429             } else {
3430                 blk_new_backing = blk_new_open(out_real_path, NULL,
3431                                                options, src_flags, &local_err);
3432                 g_free(out_real_path);
3433                 if (!blk_new_backing) {
3434                     error_reportf_err(local_err,
3435                                       "Could not open new backing file '%s': ",
3436                                       out_baseimg);
3437                     ret = -1;
3438                     goto out;
3439                 }
3440             }
3441         }
3442     }
3443 
3444     /*
3445      * Check each unallocated cluster in the COW file. If it is unallocated,
3446      * accesses go to the backing file. We must therefore compare this cluster
3447      * in the old and new backing file, and if they differ we need to copy it
3448      * from the old backing file into the COW file.
3449      *
3450      * If qemu-img crashes during this step, no harm is done. The content of
3451      * the image is the same as the original one at any time.
3452      */
3453     if (!unsafe) {
3454         int64_t size;
3455         int64_t old_backing_size = 0;
3456         int64_t new_backing_size = 0;
3457         uint64_t offset;
3458         int64_t n;
3459         float local_progress = 0;
3460 
3461         buf_old = blk_blockalign(blk, IO_BUF_SIZE);
3462         buf_new = blk_blockalign(blk, IO_BUF_SIZE);
3463 
3464         size = blk_getlength(blk);
3465         if (size < 0) {
3466             error_report("Could not get size of '%s': %s",
3467                          filename, strerror(-size));
3468             ret = -1;
3469             goto out;
3470         }
3471         if (blk_old_backing) {
3472             old_backing_size = blk_getlength(blk_old_backing);
3473             if (old_backing_size < 0) {
3474                 char backing_name[PATH_MAX];
3475 
3476                 bdrv_get_backing_filename(bs, backing_name,
3477                                           sizeof(backing_name));
3478                 error_report("Could not get size of '%s': %s",
3479                              backing_name, strerror(-old_backing_size));
3480                 ret = -1;
3481                 goto out;
3482             }
3483         }
3484         if (blk_new_backing) {
3485             new_backing_size = blk_getlength(blk_new_backing);
3486             if (new_backing_size < 0) {
3487                 error_report("Could not get size of '%s': %s",
3488                              out_baseimg, strerror(-new_backing_size));
3489                 ret = -1;
3490                 goto out;
3491             }
3492         }
3493 
3494         if (size != 0) {
3495             local_progress = (float)100 / (size / MIN(size, IO_BUF_SIZE));
3496         }
3497 
3498         for (offset = 0; offset < size; offset += n) {
3499             bool buf_old_is_zero = false;
3500 
3501             /* How many bytes can we handle with the next read? */
3502             n = MIN(IO_BUF_SIZE, size - offset);
3503 
3504             /* If the cluster is allocated, we don't need to take action */
3505             ret = bdrv_is_allocated(bs, offset, n, &n);
3506             if (ret < 0) {
3507                 error_report("error while reading image metadata: %s",
3508                              strerror(-ret));
3509                 goto out;
3510             }
3511             if (ret) {
3512                 continue;
3513             }
3514 
3515             if (prefix_chain_bs) {
3516                 /*
3517                  * If cluster wasn't changed since prefix_chain, we don't need
3518                  * to take action
3519                  */
3520                 ret = bdrv_is_allocated_above(backing_bs(bs), prefix_chain_bs,
3521                                               offset, n, &n);
3522                 if (ret < 0) {
3523                     error_report("error while reading image metadata: %s",
3524                                  strerror(-ret));
3525                     goto out;
3526                 }
3527                 if (!ret) {
3528                     continue;
3529                 }
3530             }
3531 
3532             /*
3533              * Read old and new backing file and take into consideration that
3534              * backing files may be smaller than the COW image.
3535              */
3536             if (offset >= old_backing_size) {
3537                 memset(buf_old, 0, n);
3538                 buf_old_is_zero = true;
3539             } else {
3540                 if (offset + n > old_backing_size) {
3541                     n = old_backing_size - offset;
3542                 }
3543 
3544                 ret = blk_pread(blk_old_backing, offset, buf_old, n);
3545                 if (ret < 0) {
3546                     error_report("error while reading from old backing file");
3547                     goto out;
3548                 }
3549             }
3550 
3551             if (offset >= new_backing_size || !blk_new_backing) {
3552                 memset(buf_new, 0, n);
3553             } else {
3554                 if (offset + n > new_backing_size) {
3555                     n = new_backing_size - offset;
3556                 }
3557 
3558                 ret = blk_pread(blk_new_backing, offset, buf_new, n);
3559                 if (ret < 0) {
3560                     error_report("error while reading from new backing file");
3561                     goto out;
3562                 }
3563             }
3564 
3565             /* If they differ, we need to write to the COW file */
3566             uint64_t written = 0;
3567 
3568             while (written < n) {
3569                 int64_t pnum;
3570 
3571                 if (compare_buffers(buf_old + written, buf_new + written,
3572                                     n - written, &pnum))
3573                 {
3574                     if (buf_old_is_zero) {
3575                         ret = blk_pwrite_zeroes(blk, offset + written, pnum, 0);
3576                     } else {
3577                         ret = blk_pwrite(blk, offset + written,
3578                                          buf_old + written, pnum, 0);
3579                     }
3580                     if (ret < 0) {
3581                         error_report("Error while writing to COW image: %s",
3582                             strerror(-ret));
3583                         goto out;
3584                     }
3585                 }
3586 
3587                 written += pnum;
3588             }
3589             qemu_progress_print(local_progress, 100);
3590         }
3591     }
3592 
3593     /*
3594      * Change the backing file. All clusters that are different from the old
3595      * backing file are overwritten in the COW file now, so the visible content
3596      * doesn't change when we switch the backing file.
3597      */
3598     if (out_baseimg && *out_baseimg) {
3599         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
3600     } else {
3601         ret = bdrv_change_backing_file(bs, NULL, NULL);
3602     }
3603 
3604     if (ret == -ENOSPC) {
3605         error_report("Could not change the backing file to '%s': No "
3606                      "space left in the file header", out_baseimg);
3607     } else if (ret < 0) {
3608         error_report("Could not change the backing file to '%s': %s",
3609             out_baseimg, strerror(-ret));
3610     }
3611 
3612     qemu_progress_print(100, 0);
3613     /*
3614      * TODO At this point it is possible to check if any clusters that are
3615      * allocated in the COW file are the same in the backing file. If so, they
3616      * could be dropped from the COW file. Don't do this before switching the
3617      * backing file, in case of a crash this would lead to corruption.
3618      */
3619 out:
3620     qemu_progress_end();
3621     /* Cleanup */
3622     if (!unsafe) {
3623         blk_unref(blk_old_backing);
3624         blk_unref(blk_new_backing);
3625     }
3626     qemu_vfree(buf_old);
3627     qemu_vfree(buf_new);
3628 
3629     blk_unref(blk);
3630     if (ret) {
3631         return 1;
3632     }
3633     return 0;
3634 }
3635 
3636 static int img_resize(int argc, char **argv)
3637 {
3638     Error *err = NULL;
3639     int c, ret, relative;
3640     const char *filename, *fmt, *size;
3641     int64_t n, total_size, current_size, new_size;
3642     bool quiet = false;
3643     BlockBackend *blk = NULL;
3644     PreallocMode prealloc = PREALLOC_MODE_OFF;
3645     QemuOpts *param;
3646 
3647     static QemuOptsList resize_options = {
3648         .name = "resize_options",
3649         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
3650         .desc = {
3651             {
3652                 .name = BLOCK_OPT_SIZE,
3653                 .type = QEMU_OPT_SIZE,
3654                 .help = "Virtual disk size"
3655             }, {
3656                 /* end of list */
3657             }
3658         },
3659     };
3660     bool image_opts = false;
3661     bool shrink = false;
3662 
3663     /* Remove size from argv manually so that negative numbers are not treated
3664      * as options by getopt. */
3665     if (argc < 3) {
3666         error_exit("Not enough arguments");
3667         return 1;
3668     }
3669 
3670     size = argv[--argc];
3671 
3672     /* Parse getopt arguments */
3673     fmt = NULL;
3674     for(;;) {
3675         static const struct option long_options[] = {
3676             {"help", no_argument, 0, 'h'},
3677             {"object", required_argument, 0, OPTION_OBJECT},
3678             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3679             {"preallocation", required_argument, 0, OPTION_PREALLOCATION},
3680             {"shrink", no_argument, 0, OPTION_SHRINK},
3681             {0, 0, 0, 0}
3682         };
3683         c = getopt_long(argc, argv, ":f:hq",
3684                         long_options, NULL);
3685         if (c == -1) {
3686             break;
3687         }
3688         switch(c) {
3689         case ':':
3690             missing_argument(argv[optind - 1]);
3691             break;
3692         case '?':
3693             unrecognized_option(argv[optind - 1]);
3694             break;
3695         case 'h':
3696             help();
3697             break;
3698         case 'f':
3699             fmt = optarg;
3700             break;
3701         case 'q':
3702             quiet = true;
3703             break;
3704         case OPTION_OBJECT: {
3705             QemuOpts *opts;
3706             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3707                                            optarg, true);
3708             if (!opts) {
3709                 return 1;
3710             }
3711         }   break;
3712         case OPTION_IMAGE_OPTS:
3713             image_opts = true;
3714             break;
3715         case OPTION_PREALLOCATION:
3716             prealloc = qapi_enum_parse(&PreallocMode_lookup, optarg,
3717                                        PREALLOC_MODE__MAX, NULL);
3718             if (prealloc == PREALLOC_MODE__MAX) {
3719                 error_report("Invalid preallocation mode '%s'", optarg);
3720                 return 1;
3721             }
3722             break;
3723         case OPTION_SHRINK:
3724             shrink = true;
3725             break;
3726         }
3727     }
3728     if (optind != argc - 1) {
3729         error_exit("Expecting image file name and size");
3730     }
3731     filename = argv[optind++];
3732 
3733     if (qemu_opts_foreach(&qemu_object_opts,
3734                           user_creatable_add_opts_foreach,
3735                           NULL, &error_fatal)) {
3736         return 1;
3737     }
3738 
3739     /* Choose grow, shrink, or absolute resize mode */
3740     switch (size[0]) {
3741     case '+':
3742         relative = 1;
3743         size++;
3744         break;
3745     case '-':
3746         relative = -1;
3747         size++;
3748         break;
3749     default:
3750         relative = 0;
3751         break;
3752     }
3753 
3754     /* Parse size */
3755     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
3756     qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
3757     if (err) {
3758         error_report_err(err);
3759         ret = -1;
3760         qemu_opts_del(param);
3761         goto out;
3762     }
3763     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
3764     qemu_opts_del(param);
3765 
3766     blk = img_open(image_opts, filename, fmt,
3767                    BDRV_O_RDWR | BDRV_O_RESIZE, false, quiet,
3768                    false);
3769     if (!blk) {
3770         ret = -1;
3771         goto out;
3772     }
3773 
3774     current_size = blk_getlength(blk);
3775     if (current_size < 0) {
3776         error_report("Failed to inquire current image length: %s",
3777                      strerror(-current_size));
3778         ret = -1;
3779         goto out;
3780     }
3781 
3782     if (relative) {
3783         total_size = current_size + n * relative;
3784     } else {
3785         total_size = n;
3786     }
3787     if (total_size <= 0) {
3788         error_report("New image size must be positive");
3789         ret = -1;
3790         goto out;
3791     }
3792 
3793     if (total_size <= current_size && prealloc != PREALLOC_MODE_OFF) {
3794         error_report("Preallocation can only be used for growing images");
3795         ret = -1;
3796         goto out;
3797     }
3798 
3799     if (total_size < current_size && !shrink) {
3800         warn_report("Shrinking an image will delete all data beyond the "
3801                     "shrunken image's end. Before performing such an "
3802                     "operation, make sure there is no important data there.");
3803 
3804         if (g_strcmp0(bdrv_get_format_name(blk_bs(blk)), "raw") != 0) {
3805             error_report(
3806               "Use the --shrink option to perform a shrink operation.");
3807             ret = -1;
3808             goto out;
3809         } else {
3810             warn_report("Using the --shrink option will suppress this message. "
3811                         "Note that future versions of qemu-img may refuse to "
3812                         "shrink images without this option.");
3813         }
3814     }
3815 
3816     ret = blk_truncate(blk, total_size, prealloc, &err);
3817     if (ret < 0) {
3818         error_report_err(err);
3819         goto out;
3820     }
3821 
3822     new_size = blk_getlength(blk);
3823     if (new_size < 0) {
3824         error_report("Failed to verify truncated image length: %s",
3825                      strerror(-new_size));
3826         ret = -1;
3827         goto out;
3828     }
3829 
3830     /* Some block drivers implement a truncation method, but only so
3831      * the user can cause qemu to refresh the image's size from disk.
3832      * The idea is that the user resizes the image outside of qemu and
3833      * then invokes block_resize to inform qemu about it.
3834      * (This includes iscsi and file-posix for device files.)
3835      * Of course, that is not the behavior someone invoking
3836      * qemu-img resize would find useful, so we catch that behavior
3837      * here and tell the user. */
3838     if (new_size != total_size && new_size == current_size) {
3839         error_report("Image was not resized; resizing may not be supported "
3840                      "for this image");
3841         ret = -1;
3842         goto out;
3843     }
3844 
3845     if (new_size != total_size) {
3846         warn_report("Image should have been resized to %" PRIi64
3847                     " bytes, but was resized to %" PRIi64 " bytes",
3848                     total_size, new_size);
3849     }
3850 
3851     qprintf(quiet, "Image resized.\n");
3852 
3853 out:
3854     blk_unref(blk);
3855     if (ret) {
3856         return 1;
3857     }
3858     return 0;
3859 }
3860 
3861 static void amend_status_cb(BlockDriverState *bs,
3862                             int64_t offset, int64_t total_work_size,
3863                             void *opaque)
3864 {
3865     qemu_progress_print(100.f * offset / total_work_size, 0);
3866 }
3867 
3868 static int print_amend_option_help(const char *format)
3869 {
3870     BlockDriver *drv;
3871 
3872     /* Find driver and parse its options */
3873     drv = bdrv_find_format(format);
3874     if (!drv) {
3875         error_report("Unknown file format '%s'", format);
3876         return 1;
3877     }
3878 
3879     if (!drv->bdrv_amend_options) {
3880         error_report("Format driver '%s' does not support option amendment",
3881                      format);
3882         return 1;
3883     }
3884 
3885     /* Every driver supporting amendment must have create_opts */
3886     assert(drv->create_opts);
3887 
3888     printf("Creation options for '%s':\n", format);
3889     qemu_opts_print_help(drv->create_opts, false);
3890     printf("\nNote that not all of these options may be amendable.\n");
3891     return 0;
3892 }
3893 
3894 static int img_amend(int argc, char **argv)
3895 {
3896     Error *err = NULL;
3897     int c, ret = 0;
3898     char *options = NULL;
3899     QemuOptsList *create_opts = NULL;
3900     QemuOpts *opts = NULL;
3901     const char *fmt = NULL, *filename, *cache;
3902     int flags;
3903     bool writethrough;
3904     bool quiet = false, progress = false;
3905     BlockBackend *blk = NULL;
3906     BlockDriverState *bs = NULL;
3907     bool image_opts = false;
3908 
3909     cache = BDRV_DEFAULT_CACHE;
3910     for (;;) {
3911         static const struct option long_options[] = {
3912             {"help", no_argument, 0, 'h'},
3913             {"object", required_argument, 0, OPTION_OBJECT},
3914             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
3915             {0, 0, 0, 0}
3916         };
3917         c = getopt_long(argc, argv, ":ho:f:t:pq",
3918                         long_options, NULL);
3919         if (c == -1) {
3920             break;
3921         }
3922 
3923         switch (c) {
3924         case ':':
3925             missing_argument(argv[optind - 1]);
3926             break;
3927         case '?':
3928             unrecognized_option(argv[optind - 1]);
3929             break;
3930         case 'h':
3931             help();
3932             break;
3933         case 'o':
3934             if (!is_valid_option_list(optarg)) {
3935                 error_report("Invalid option list: %s", optarg);
3936                 ret = -1;
3937                 goto out_no_progress;
3938             }
3939             if (!options) {
3940                 options = g_strdup(optarg);
3941             } else {
3942                 char *old_options = options;
3943                 options = g_strdup_printf("%s,%s", options, optarg);
3944                 g_free(old_options);
3945             }
3946             break;
3947         case 'f':
3948             fmt = optarg;
3949             break;
3950         case 't':
3951             cache = optarg;
3952             break;
3953         case 'p':
3954             progress = true;
3955             break;
3956         case 'q':
3957             quiet = true;
3958             break;
3959         case OPTION_OBJECT:
3960             opts = qemu_opts_parse_noisily(&qemu_object_opts,
3961                                            optarg, true);
3962             if (!opts) {
3963                 ret = -1;
3964                 goto out_no_progress;
3965             }
3966             break;
3967         case OPTION_IMAGE_OPTS:
3968             image_opts = true;
3969             break;
3970         }
3971     }
3972 
3973     if (!options) {
3974         error_exit("Must specify options (-o)");
3975     }
3976 
3977     if (qemu_opts_foreach(&qemu_object_opts,
3978                           user_creatable_add_opts_foreach,
3979                           NULL, &error_fatal)) {
3980         ret = -1;
3981         goto out_no_progress;
3982     }
3983 
3984     if (quiet) {
3985         progress = false;
3986     }
3987     qemu_progress_init(progress, 1.0);
3988 
3989     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
3990     if (fmt && has_help_option(options)) {
3991         /* If a format is explicitly specified (and possibly no filename is
3992          * given), print option help here */
3993         ret = print_amend_option_help(fmt);
3994         goto out;
3995     }
3996 
3997     if (optind != argc - 1) {
3998         error_report("Expecting one image file name");
3999         ret = -1;
4000         goto out;
4001     }
4002 
4003     flags = BDRV_O_RDWR;
4004     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
4005     if (ret < 0) {
4006         error_report("Invalid cache option: %s", cache);
4007         goto out;
4008     }
4009 
4010     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4011                    false);
4012     if (!blk) {
4013         ret = -1;
4014         goto out;
4015     }
4016     bs = blk_bs(blk);
4017 
4018     fmt = bs->drv->format_name;
4019 
4020     if (has_help_option(options)) {
4021         /* If the format was auto-detected, print option help here */
4022         ret = print_amend_option_help(fmt);
4023         goto out;
4024     }
4025 
4026     if (!bs->drv->bdrv_amend_options) {
4027         error_report("Format driver '%s' does not support option amendment",
4028                      fmt);
4029         ret = -1;
4030         goto out;
4031     }
4032 
4033     /* Every driver supporting amendment must have create_opts */
4034     assert(bs->drv->create_opts);
4035 
4036     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
4037     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4038     qemu_opts_do_parse(opts, options, NULL, &err);
4039     if (err) {
4040         error_report_err(err);
4041         ret = -1;
4042         goto out;
4043     }
4044 
4045     /* In case the driver does not call amend_status_cb() */
4046     qemu_progress_print(0.f, 0);
4047     ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err);
4048     qemu_progress_print(100.f, 0);
4049     if (ret < 0) {
4050         error_report_err(err);
4051         goto out;
4052     }
4053 
4054 out:
4055     qemu_progress_end();
4056 
4057 out_no_progress:
4058     blk_unref(blk);
4059     qemu_opts_del(opts);
4060     qemu_opts_free(create_opts);
4061     g_free(options);
4062 
4063     if (ret) {
4064         return 1;
4065     }
4066     return 0;
4067 }
4068 
4069 typedef struct BenchData {
4070     BlockBackend *blk;
4071     uint64_t image_size;
4072     bool write;
4073     int bufsize;
4074     int step;
4075     int nrreq;
4076     int n;
4077     int flush_interval;
4078     bool drain_on_flush;
4079     uint8_t *buf;
4080     QEMUIOVector *qiov;
4081 
4082     int in_flight;
4083     bool in_flush;
4084     uint64_t offset;
4085 } BenchData;
4086 
4087 static void bench_undrained_flush_cb(void *opaque, int ret)
4088 {
4089     if (ret < 0) {
4090         error_report("Failed flush request: %s", strerror(-ret));
4091         exit(EXIT_FAILURE);
4092     }
4093 }
4094 
4095 static void bench_cb(void *opaque, int ret)
4096 {
4097     BenchData *b = opaque;
4098     BlockAIOCB *acb;
4099 
4100     if (ret < 0) {
4101         error_report("Failed request: %s", strerror(-ret));
4102         exit(EXIT_FAILURE);
4103     }
4104 
4105     if (b->in_flush) {
4106         /* Just finished a flush with drained queue: Start next requests */
4107         assert(b->in_flight == 0);
4108         b->in_flush = false;
4109     } else if (b->in_flight > 0) {
4110         int remaining = b->n - b->in_flight;
4111 
4112         b->n--;
4113         b->in_flight--;
4114 
4115         /* Time for flush? Drain queue if requested, then flush */
4116         if (b->flush_interval && remaining % b->flush_interval == 0) {
4117             if (!b->in_flight || !b->drain_on_flush) {
4118                 BlockCompletionFunc *cb;
4119 
4120                 if (b->drain_on_flush) {
4121                     b->in_flush = true;
4122                     cb = bench_cb;
4123                 } else {
4124                     cb = bench_undrained_flush_cb;
4125                 }
4126 
4127                 acb = blk_aio_flush(b->blk, cb, b);
4128                 if (!acb) {
4129                     error_report("Failed to issue flush request");
4130                     exit(EXIT_FAILURE);
4131                 }
4132             }
4133             if (b->drain_on_flush) {
4134                 return;
4135             }
4136         }
4137     }
4138 
4139     while (b->n > b->in_flight && b->in_flight < b->nrreq) {
4140         int64_t offset = b->offset;
4141         /* blk_aio_* might look for completed I/Os and kick bench_cb
4142          * again, so make sure this operation is counted by in_flight
4143          * and b->offset is ready for the next submission.
4144          */
4145         b->in_flight++;
4146         b->offset += b->step;
4147         b->offset %= b->image_size;
4148         if (b->write) {
4149             acb = blk_aio_pwritev(b->blk, offset, b->qiov, 0, bench_cb, b);
4150         } else {
4151             acb = blk_aio_preadv(b->blk, offset, b->qiov, 0, bench_cb, b);
4152         }
4153         if (!acb) {
4154             error_report("Failed to issue request");
4155             exit(EXIT_FAILURE);
4156         }
4157     }
4158 }
4159 
4160 static int img_bench(int argc, char **argv)
4161 {
4162     int c, ret = 0;
4163     const char *fmt = NULL, *filename;
4164     bool quiet = false;
4165     bool image_opts = false;
4166     bool is_write = false;
4167     int count = 75000;
4168     int depth = 64;
4169     int64_t offset = 0;
4170     size_t bufsize = 4096;
4171     int pattern = 0;
4172     size_t step = 0;
4173     int flush_interval = 0;
4174     bool drain_on_flush = true;
4175     int64_t image_size;
4176     BlockBackend *blk = NULL;
4177     BenchData data = {};
4178     int flags = 0;
4179     bool writethrough = false;
4180     struct timeval t1, t2;
4181     int i;
4182     bool force_share = false;
4183     size_t buf_size;
4184 
4185     for (;;) {
4186         static const struct option long_options[] = {
4187             {"help", no_argument, 0, 'h'},
4188             {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
4189             {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4190             {"pattern", required_argument, 0, OPTION_PATTERN},
4191             {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
4192             {"force-share", no_argument, 0, 'U'},
4193             {0, 0, 0, 0}
4194         };
4195         c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
4196         if (c == -1) {
4197             break;
4198         }
4199 
4200         switch (c) {
4201         case ':':
4202             missing_argument(argv[optind - 1]);
4203             break;
4204         case '?':
4205             unrecognized_option(argv[optind - 1]);
4206             break;
4207         case 'h':
4208             help();
4209             break;
4210         case 'c':
4211         {
4212             unsigned long res;
4213 
4214             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4215                 error_report("Invalid request count specified");
4216                 return 1;
4217             }
4218             count = res;
4219             break;
4220         }
4221         case 'd':
4222         {
4223             unsigned long res;
4224 
4225             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4226                 error_report("Invalid queue depth specified");
4227                 return 1;
4228             }
4229             depth = res;
4230             break;
4231         }
4232         case 'f':
4233             fmt = optarg;
4234             break;
4235         case 'n':
4236             flags |= BDRV_O_NATIVE_AIO;
4237             break;
4238         case 'o':
4239         {
4240             offset = cvtnum(optarg);
4241             if (offset < 0) {
4242                 error_report("Invalid offset specified");
4243                 return 1;
4244             }
4245             break;
4246         }
4247             break;
4248         case 'q':
4249             quiet = true;
4250             break;
4251         case 's':
4252         {
4253             int64_t sval;
4254 
4255             sval = cvtnum(optarg);
4256             if (sval < 0 || sval > INT_MAX) {
4257                 error_report("Invalid buffer size specified");
4258                 return 1;
4259             }
4260 
4261             bufsize = sval;
4262             break;
4263         }
4264         case 'S':
4265         {
4266             int64_t sval;
4267 
4268             sval = cvtnum(optarg);
4269             if (sval < 0 || sval > INT_MAX) {
4270                 error_report("Invalid step size specified");
4271                 return 1;
4272             }
4273 
4274             step = sval;
4275             break;
4276         }
4277         case 't':
4278             ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
4279             if (ret < 0) {
4280                 error_report("Invalid cache mode");
4281                 ret = -1;
4282                 goto out;
4283             }
4284             break;
4285         case 'w':
4286             flags |= BDRV_O_RDWR;
4287             is_write = true;
4288             break;
4289         case 'U':
4290             force_share = true;
4291             break;
4292         case OPTION_PATTERN:
4293         {
4294             unsigned long res;
4295 
4296             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
4297                 error_report("Invalid pattern byte specified");
4298                 return 1;
4299             }
4300             pattern = res;
4301             break;
4302         }
4303         case OPTION_FLUSH_INTERVAL:
4304         {
4305             unsigned long res;
4306 
4307             if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
4308                 error_report("Invalid flush interval specified");
4309                 return 1;
4310             }
4311             flush_interval = res;
4312             break;
4313         }
4314         case OPTION_NO_DRAIN:
4315             drain_on_flush = false;
4316             break;
4317         case OPTION_IMAGE_OPTS:
4318             image_opts = true;
4319             break;
4320         }
4321     }
4322 
4323     if (optind != argc - 1) {
4324         error_exit("Expecting one image file name");
4325     }
4326     filename = argv[argc - 1];
4327 
4328     if (!is_write && flush_interval) {
4329         error_report("--flush-interval is only available in write tests");
4330         ret = -1;
4331         goto out;
4332     }
4333     if (flush_interval && flush_interval < depth) {
4334         error_report("Flush interval can't be smaller than depth");
4335         ret = -1;
4336         goto out;
4337     }
4338 
4339     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet,
4340                    force_share);
4341     if (!blk) {
4342         ret = -1;
4343         goto out;
4344     }
4345 
4346     image_size = blk_getlength(blk);
4347     if (image_size < 0) {
4348         ret = image_size;
4349         goto out;
4350     }
4351 
4352     data = (BenchData) {
4353         .blk            = blk,
4354         .image_size     = image_size,
4355         .bufsize        = bufsize,
4356         .step           = step ?: bufsize,
4357         .nrreq          = depth,
4358         .n              = count,
4359         .offset         = offset,
4360         .write          = is_write,
4361         .flush_interval = flush_interval,
4362         .drain_on_flush = drain_on_flush,
4363     };
4364     printf("Sending %d %s requests, %d bytes each, %d in parallel "
4365            "(starting at offset %" PRId64 ", step size %d)\n",
4366            data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
4367            data.offset, data.step);
4368     if (flush_interval) {
4369         printf("Sending flush every %d requests\n", flush_interval);
4370     }
4371 
4372     buf_size = data.nrreq * data.bufsize;
4373     data.buf = blk_blockalign(blk, buf_size);
4374     memset(data.buf, pattern, data.nrreq * data.bufsize);
4375 
4376     blk_register_buf(blk, data.buf, buf_size);
4377 
4378     data.qiov = g_new(QEMUIOVector, data.nrreq);
4379     for (i = 0; i < data.nrreq; i++) {
4380         qemu_iovec_init(&data.qiov[i], 1);
4381         qemu_iovec_add(&data.qiov[i],
4382                        data.buf + i * data.bufsize, data.bufsize);
4383     }
4384 
4385     gettimeofday(&t1, NULL);
4386     bench_cb(&data, 0);
4387 
4388     while (data.n > 0) {
4389         main_loop_wait(false);
4390     }
4391     gettimeofday(&t2, NULL);
4392 
4393     printf("Run completed in %3.3f seconds.\n",
4394            (t2.tv_sec - t1.tv_sec)
4395            + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));
4396 
4397 out:
4398     if (data.buf) {
4399         blk_unregister_buf(blk, data.buf);
4400     }
4401     qemu_vfree(data.buf);
4402     blk_unref(blk);
4403 
4404     if (ret) {
4405         return 1;
4406     }
4407     return 0;
4408 }
4409 
4410 #define C_BS      01
4411 #define C_COUNT   02
4412 #define C_IF      04
4413 #define C_OF      010
4414 #define C_SKIP    020
4415 
4416 struct DdInfo {
4417     unsigned int flags;
4418     int64_t count;
4419 };
4420 
4421 struct DdIo {
4422     int bsz;    /* Block size */
4423     char *filename;
4424     uint8_t *buf;
4425     int64_t offset;
4426 };
4427 
4428 struct DdOpts {
4429     const char *name;
4430     int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
4431     unsigned int flag;
4432 };
4433 
4434 static int img_dd_bs(const char *arg,
4435                      struct DdIo *in, struct DdIo *out,
4436                      struct DdInfo *dd)
4437 {
4438     int64_t res;
4439 
4440     res = cvtnum(arg);
4441 
4442     if (res <= 0 || res > INT_MAX) {
4443         error_report("invalid number: '%s'", arg);
4444         return 1;
4445     }
4446     in->bsz = out->bsz = res;
4447 
4448     return 0;
4449 }
4450 
4451 static int img_dd_count(const char *arg,
4452                         struct DdIo *in, struct DdIo *out,
4453                         struct DdInfo *dd)
4454 {
4455     dd->count = cvtnum(arg);
4456 
4457     if (dd->count < 0) {
4458         error_report("invalid number: '%s'", arg);
4459         return 1;
4460     }
4461 
4462     return 0;
4463 }
4464 
4465 static int img_dd_if(const char *arg,
4466                      struct DdIo *in, struct DdIo *out,
4467                      struct DdInfo *dd)
4468 {
4469     in->filename = g_strdup(arg);
4470 
4471     return 0;
4472 }
4473 
4474 static int img_dd_of(const char *arg,
4475                      struct DdIo *in, struct DdIo *out,
4476                      struct DdInfo *dd)
4477 {
4478     out->filename = g_strdup(arg);
4479 
4480     return 0;
4481 }
4482 
4483 static int img_dd_skip(const char *arg,
4484                        struct DdIo *in, struct DdIo *out,
4485                        struct DdInfo *dd)
4486 {
4487     in->offset = cvtnum(arg);
4488 
4489     if (in->offset < 0) {
4490         error_report("invalid number: '%s'", arg);
4491         return 1;
4492     }
4493 
4494     return 0;
4495 }
4496 
4497 static int img_dd(int argc, char **argv)
4498 {
4499     int ret = 0;
4500     char *arg = NULL;
4501     char *tmp;
4502     BlockDriver *drv = NULL, *proto_drv = NULL;
4503     BlockBackend *blk1 = NULL, *blk2 = NULL;
4504     QemuOpts *opts = NULL;
4505     QemuOptsList *create_opts = NULL;
4506     Error *local_err = NULL;
4507     bool image_opts = false;
4508     int c, i;
4509     const char *out_fmt = "raw";
4510     const char *fmt = NULL;
4511     int64_t size = 0;
4512     int64_t block_count = 0, out_pos, in_pos;
4513     bool force_share = false;
4514     struct DdInfo dd = {
4515         .flags = 0,
4516         .count = 0,
4517     };
4518     struct DdIo in = {
4519         .bsz = 512, /* Block size is by default 512 bytes */
4520         .filename = NULL,
4521         .buf = NULL,
4522         .offset = 0
4523     };
4524     struct DdIo out = {
4525         .bsz = 512,
4526         .filename = NULL,
4527         .buf = NULL,
4528         .offset = 0
4529     };
4530 
4531     const struct DdOpts options[] = {
4532         { "bs", img_dd_bs, C_BS },
4533         { "count", img_dd_count, C_COUNT },
4534         { "if", img_dd_if, C_IF },
4535         { "of", img_dd_of, C_OF },
4536         { "skip", img_dd_skip, C_SKIP },
4537         { NULL, NULL, 0 }
4538     };
4539     const struct option long_options[] = {
4540         { "help", no_argument, 0, 'h'},
4541         { "object", required_argument, 0, OPTION_OBJECT},
4542         { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4543         { "force-share", no_argument, 0, 'U'},
4544         { 0, 0, 0, 0 }
4545     };
4546 
4547     while ((c = getopt_long(argc, argv, ":hf:O:U", long_options, NULL))) {
4548         if (c == EOF) {
4549             break;
4550         }
4551         switch (c) {
4552         case 'O':
4553             out_fmt = optarg;
4554             break;
4555         case 'f':
4556             fmt = optarg;
4557             break;
4558         case ':':
4559             missing_argument(argv[optind - 1]);
4560             break;
4561         case '?':
4562             unrecognized_option(argv[optind - 1]);
4563             break;
4564         case 'h':
4565             help();
4566             break;
4567         case 'U':
4568             force_share = true;
4569             break;
4570         case OPTION_OBJECT:
4571             if (!qemu_opts_parse_noisily(&qemu_object_opts, optarg, true)) {
4572                 ret = -1;
4573                 goto out;
4574             }
4575             break;
4576         case OPTION_IMAGE_OPTS:
4577             image_opts = true;
4578             break;
4579         }
4580     }
4581 
4582     for (i = optind; i < argc; i++) {
4583         int j;
4584         arg = g_strdup(argv[i]);
4585 
4586         tmp = strchr(arg, '=');
4587         if (tmp == NULL) {
4588             error_report("unrecognized operand %s", arg);
4589             ret = -1;
4590             goto out;
4591         }
4592 
4593         *tmp++ = '\0';
4594 
4595         for (j = 0; options[j].name != NULL; j++) {
4596             if (!strcmp(arg, options[j].name)) {
4597                 break;
4598             }
4599         }
4600         if (options[j].name == NULL) {
4601             error_report("unrecognized operand %s", arg);
4602             ret = -1;
4603             goto out;
4604         }
4605 
4606         if (options[j].f(tmp, &in, &out, &dd) != 0) {
4607             ret = -1;
4608             goto out;
4609         }
4610         dd.flags |= options[j].flag;
4611         g_free(arg);
4612         arg = NULL;
4613     }
4614 
4615     if (!(dd.flags & C_IF && dd.flags & C_OF)) {
4616         error_report("Must specify both input and output files");
4617         ret = -1;
4618         goto out;
4619     }
4620 
4621     if (qemu_opts_foreach(&qemu_object_opts,
4622                           user_creatable_add_opts_foreach,
4623                           NULL, &error_fatal)) {
4624         ret = -1;
4625         goto out;
4626     }
4627 
4628     blk1 = img_open(image_opts, in.filename, fmt, 0, false, false,
4629                     force_share);
4630 
4631     if (!blk1) {
4632         ret = -1;
4633         goto out;
4634     }
4635 
4636     drv = bdrv_find_format(out_fmt);
4637     if (!drv) {
4638         error_report("Unknown file format");
4639         ret = -1;
4640         goto out;
4641     }
4642     proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
4643 
4644     if (!proto_drv) {
4645         error_report_err(local_err);
4646         ret = -1;
4647         goto out;
4648     }
4649     if (!drv->create_opts) {
4650         error_report("Format driver '%s' does not support image creation",
4651                      drv->format_name);
4652         ret = -1;
4653         goto out;
4654     }
4655     if (!proto_drv->create_opts) {
4656         error_report("Protocol driver '%s' does not support image creation",
4657                      proto_drv->format_name);
4658         ret = -1;
4659         goto out;
4660     }
4661     create_opts = qemu_opts_append(create_opts, drv->create_opts);
4662     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4663 
4664     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4665 
4666     size = blk_getlength(blk1);
4667     if (size < 0) {
4668         error_report("Failed to get size for '%s'", in.filename);
4669         ret = -1;
4670         goto out;
4671     }
4672 
4673     if (dd.flags & C_COUNT && dd.count <= INT64_MAX / in.bsz &&
4674         dd.count * in.bsz < size) {
4675         size = dd.count * in.bsz;
4676     }
4677 
4678     /* Overflow means the specified offset is beyond input image's size */
4679     if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4680                               size < in.bsz * in.offset)) {
4681         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, 0, &error_abort);
4682     } else {
4683         qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
4684                             size - in.bsz * in.offset, &error_abort);
4685     }
4686 
4687     ret = bdrv_create(drv, out.filename, opts, &local_err);
4688     if (ret < 0) {
4689         error_reportf_err(local_err,
4690                           "%s: error while creating output image: ",
4691                           out.filename);
4692         ret = -1;
4693         goto out;
4694     }
4695 
4696     /* TODO, we can't honour --image-opts for the target,
4697      * since it needs to be given in a format compatible
4698      * with the bdrv_create() call above which does not
4699      * support image-opts style.
4700      */
4701     blk2 = img_open_file(out.filename, NULL, out_fmt, BDRV_O_RDWR,
4702                          false, false, false);
4703 
4704     if (!blk2) {
4705         ret = -1;
4706         goto out;
4707     }
4708 
4709     if (dd.flags & C_SKIP && (in.offset > INT64_MAX / in.bsz ||
4710                               size < in.offset * in.bsz)) {
4711         /* We give a warning if the skip option is bigger than the input
4712          * size and create an empty output disk image (i.e. like dd(1)).
4713          */
4714         error_report("%s: cannot skip to specified offset", in.filename);
4715         in_pos = size;
4716     } else {
4717         in_pos = in.offset * in.bsz;
4718     }
4719 
4720     in.buf = g_new(uint8_t, in.bsz);
4721 
4722     for (out_pos = 0; in_pos < size; block_count++) {
4723         int in_ret, out_ret;
4724 
4725         if (in_pos + in.bsz > size) {
4726             in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
4727         } else {
4728             in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
4729         }
4730         if (in_ret < 0) {
4731             error_report("error while reading from input image file: %s",
4732                          strerror(-in_ret));
4733             ret = -1;
4734             goto out;
4735         }
4736         in_pos += in_ret;
4737 
4738         out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
4739 
4740         if (out_ret < 0) {
4741             error_report("error while writing to output image file: %s",
4742                          strerror(-out_ret));
4743             ret = -1;
4744             goto out;
4745         }
4746         out_pos += out_ret;
4747     }
4748 
4749 out:
4750     g_free(arg);
4751     qemu_opts_del(opts);
4752     qemu_opts_free(create_opts);
4753     blk_unref(blk1);
4754     blk_unref(blk2);
4755     g_free(in.filename);
4756     g_free(out.filename);
4757     g_free(in.buf);
4758     g_free(out.buf);
4759 
4760     if (ret) {
4761         return 1;
4762     }
4763     return 0;
4764 }
4765 
4766 static void dump_json_block_measure_info(BlockMeasureInfo *info)
4767 {
4768     QString *str;
4769     QObject *obj;
4770     Visitor *v = qobject_output_visitor_new(&obj);
4771 
4772     visit_type_BlockMeasureInfo(v, NULL, &info, &error_abort);
4773     visit_complete(v, &obj);
4774     str = qobject_to_json_pretty(obj);
4775     assert(str != NULL);
4776     printf("%s\n", qstring_get_str(str));
4777     qobject_unref(obj);
4778     visit_free(v);
4779     qobject_unref(str);
4780 }
4781 
4782 static int img_measure(int argc, char **argv)
4783 {
4784     static const struct option long_options[] = {
4785         {"help", no_argument, 0, 'h'},
4786         {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
4787         {"object", required_argument, 0, OPTION_OBJECT},
4788         {"output", required_argument, 0, OPTION_OUTPUT},
4789         {"size", required_argument, 0, OPTION_SIZE},
4790         {"force-share", no_argument, 0, 'U'},
4791         {0, 0, 0, 0}
4792     };
4793     OutputFormat output_format = OFORMAT_HUMAN;
4794     BlockBackend *in_blk = NULL;
4795     BlockDriver *drv;
4796     const char *filename = NULL;
4797     const char *fmt = NULL;
4798     const char *out_fmt = "raw";
4799     char *options = NULL;
4800     char *snapshot_name = NULL;
4801     bool force_share = false;
4802     QemuOpts *opts = NULL;
4803     QemuOpts *object_opts = NULL;
4804     QemuOpts *sn_opts = NULL;
4805     QemuOptsList *create_opts = NULL;
4806     bool image_opts = false;
4807     uint64_t img_size = UINT64_MAX;
4808     BlockMeasureInfo *info = NULL;
4809     Error *local_err = NULL;
4810     int ret = 1;
4811     int c;
4812 
4813     while ((c = getopt_long(argc, argv, "hf:O:o:l:U",
4814                             long_options, NULL)) != -1) {
4815         switch (c) {
4816         case '?':
4817         case 'h':
4818             help();
4819             break;
4820         case 'f':
4821             fmt = optarg;
4822             break;
4823         case 'O':
4824             out_fmt = optarg;
4825             break;
4826         case 'o':
4827             if (!is_valid_option_list(optarg)) {
4828                 error_report("Invalid option list: %s", optarg);
4829                 goto out;
4830             }
4831             if (!options) {
4832                 options = g_strdup(optarg);
4833             } else {
4834                 char *old_options = options;
4835                 options = g_strdup_printf("%s,%s", options, optarg);
4836                 g_free(old_options);
4837             }
4838             break;
4839         case 'l':
4840             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
4841                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
4842                                                   optarg, false);
4843                 if (!sn_opts) {
4844                     error_report("Failed in parsing snapshot param '%s'",
4845                                  optarg);
4846                     goto out;
4847                 }
4848             } else {
4849                 snapshot_name = optarg;
4850             }
4851             break;
4852         case 'U':
4853             force_share = true;
4854             break;
4855         case OPTION_OBJECT:
4856             object_opts = qemu_opts_parse_noisily(&qemu_object_opts,
4857                                                   optarg, true);
4858             if (!object_opts) {
4859                 goto out;
4860             }
4861             break;
4862         case OPTION_IMAGE_OPTS:
4863             image_opts = true;
4864             break;
4865         case OPTION_OUTPUT:
4866             if (!strcmp(optarg, "json")) {
4867                 output_format = OFORMAT_JSON;
4868             } else if (!strcmp(optarg, "human")) {
4869                 output_format = OFORMAT_HUMAN;
4870             } else {
4871                 error_report("--output must be used with human or json "
4872                              "as argument.");
4873                 goto out;
4874             }
4875             break;
4876         case OPTION_SIZE:
4877         {
4878             int64_t sval;
4879 
4880             sval = cvtnum(optarg);
4881             if (sval < 0) {
4882                 if (sval == -ERANGE) {
4883                     error_report("Image size must be less than 8 EiB!");
4884                 } else {
4885                     error_report("Invalid image size specified! You may use "
4886                                  "k, M, G, T, P or E suffixes for ");
4887                     error_report("kilobytes, megabytes, gigabytes, terabytes, "
4888                                  "petabytes and exabytes.");
4889                 }
4890                 goto out;
4891             }
4892             img_size = (uint64_t)sval;
4893         }
4894         break;
4895         }
4896     }
4897 
4898     if (qemu_opts_foreach(&qemu_object_opts,
4899                           user_creatable_add_opts_foreach,
4900                           NULL, &error_fatal)) {
4901         goto out;
4902     }
4903 
4904     if (argc - optind > 1) {
4905         error_report("At most one filename argument is allowed.");
4906         goto out;
4907     } else if (argc - optind == 1) {
4908         filename = argv[optind];
4909     }
4910 
4911     if (!filename &&
4912         (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
4913         error_report("--object, --image-opts, -f, and -l "
4914                      "require a filename argument.");
4915         goto out;
4916     }
4917     if (filename && img_size != UINT64_MAX) {
4918         error_report("--size N cannot be used together with a filename.");
4919         goto out;
4920     }
4921     if (!filename && img_size == UINT64_MAX) {
4922         error_report("Either --size N or one filename must be specified.");
4923         goto out;
4924     }
4925 
4926     if (filename) {
4927         in_blk = img_open(image_opts, filename, fmt, 0,
4928                           false, false, force_share);
4929         if (!in_blk) {
4930             goto out;
4931         }
4932 
4933         if (sn_opts) {
4934             bdrv_snapshot_load_tmp(blk_bs(in_blk),
4935                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
4936                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
4937                     &local_err);
4938         } else if (snapshot_name != NULL) {
4939             bdrv_snapshot_load_tmp_by_id_or_name(blk_bs(in_blk),
4940                     snapshot_name, &local_err);
4941         }
4942         if (local_err) {
4943             error_reportf_err(local_err, "Failed to load snapshot: ");
4944             goto out;
4945         }
4946     }
4947 
4948     drv = bdrv_find_format(out_fmt);
4949     if (!drv) {
4950         error_report("Unknown file format '%s'", out_fmt);
4951         goto out;
4952     }
4953     if (!drv->create_opts) {
4954         error_report("Format driver '%s' does not support image creation",
4955                      drv->format_name);
4956         goto out;
4957     }
4958 
4959     create_opts = qemu_opts_append(create_opts, drv->create_opts);
4960     create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
4961     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4962     if (options) {
4963         qemu_opts_do_parse(opts, options, NULL, &local_err);
4964         if (local_err) {
4965             error_report_err(local_err);
4966             error_report("Invalid options for file format '%s'", out_fmt);
4967             goto out;
4968         }
4969     }
4970     if (img_size != UINT64_MAX) {
4971         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4972     }
4973 
4974     info = bdrv_measure(drv, opts, in_blk ? blk_bs(in_blk) : NULL, &local_err);
4975     if (local_err) {
4976         error_report_err(local_err);
4977         goto out;
4978     }
4979 
4980     if (output_format == OFORMAT_HUMAN) {
4981         printf("required size: %" PRIu64 "\n", info->required);
4982         printf("fully allocated size: %" PRIu64 "\n", info->fully_allocated);
4983     } else {
4984         dump_json_block_measure_info(info);
4985     }
4986 
4987     ret = 0;
4988 
4989 out:
4990     qapi_free_BlockMeasureInfo(info);
4991     qemu_opts_del(object_opts);
4992     qemu_opts_del(opts);
4993     qemu_opts_del(sn_opts);
4994     qemu_opts_free(create_opts);
4995     g_free(options);
4996     blk_unref(in_blk);
4997     return ret;
4998 }
4999 
5000 static const img_cmd_t img_cmds[] = {
5001 #define DEF(option, callback, arg_string)        \
5002     { option, callback },
5003 #include "qemu-img-cmds.h"
5004 #undef DEF
5005     { NULL, NULL, },
5006 };
5007 
5008 int main(int argc, char **argv)
5009 {
5010     const img_cmd_t *cmd;
5011     const char *cmdname;
5012     Error *local_error = NULL;
5013     char *trace_file = NULL;
5014     int c;
5015     static const struct option long_options[] = {
5016         {"help", no_argument, 0, 'h'},
5017         {"version", no_argument, 0, 'V'},
5018         {"trace", required_argument, NULL, 'T'},
5019         {0, 0, 0, 0}
5020     };
5021 
5022 #ifdef CONFIG_POSIX
5023     signal(SIGPIPE, SIG_IGN);
5024 #endif
5025 
5026     error_init(argv[0]);
5027     module_call_init(MODULE_INIT_TRACE);
5028     qemu_init_exec_dir(argv[0]);
5029 
5030     if (qemu_init_main_loop(&local_error)) {
5031         error_report_err(local_error);
5032         exit(EXIT_FAILURE);
5033     }
5034 
5035     qcrypto_init(&error_fatal);
5036 
5037     module_call_init(MODULE_INIT_QOM);
5038     bdrv_init();
5039     if (argc < 2) {
5040         error_exit("Not enough arguments");
5041     }
5042 
5043     qemu_add_opts(&qemu_object_opts);
5044     qemu_add_opts(&qemu_source_opts);
5045     qemu_add_opts(&qemu_trace_opts);
5046 
5047     while ((c = getopt_long(argc, argv, "+:hVT:", long_options, NULL)) != -1) {
5048         switch (c) {
5049         case ':':
5050             missing_argument(argv[optind - 1]);
5051             return 0;
5052         case '?':
5053             unrecognized_option(argv[optind - 1]);
5054             return 0;
5055         case 'h':
5056             help();
5057             return 0;
5058         case 'V':
5059             printf(QEMU_IMG_VERSION);
5060             return 0;
5061         case 'T':
5062             g_free(trace_file);
5063             trace_file = trace_opt_parse(optarg);
5064             break;
5065         }
5066     }
5067 
5068     cmdname = argv[optind];
5069 
5070     /* reset getopt_long scanning */
5071     argc -= optind;
5072     if (argc < 1) {
5073         return 0;
5074     }
5075     argv += optind;
5076     qemu_reset_optind();
5077 
5078     if (!trace_init_backends()) {
5079         exit(1);
5080     }
5081     trace_init_file(trace_file);
5082     qemu_set_log(LOG_TRACE);
5083 
5084     /* find the command */
5085     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
5086         if (!strcmp(cmdname, cmd->name)) {
5087             return cmd->handler(argc, argv);
5088         }
5089     }
5090 
5091     /* not found */
5092     error_exit("Command not found: %s", cmdname);
5093 }
5094