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