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