xref: /openbmc/qemu/qemu-img.c (revision 1f32989d)
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 "qjson.h"
27 #include "qemu-common.h"
28 #include "qemu-option.h"
29 #include "qemu-error.h"
30 #include "osdep.h"
31 #include "sysemu.h"
32 #include "block_int.h"
33 #include <getopt.h>
34 #include <stdio.h>
35 
36 #ifdef _WIN32
37 #include <windows.h>
38 #endif
39 
40 typedef struct img_cmd_t {
41     const char *name;
42     int (*handler)(int argc, char **argv);
43 } img_cmd_t;
44 
45 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
46 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
47 #define BDRV_DEFAULT_CACHE "writeback"
48 
49 static void format_print(void *opaque, const char *name)
50 {
51     printf(" %s", name);
52 }
53 
54 /* Please keep in synch with qemu-img.texi */
55 static void help(void)
56 {
57     const char *help_msg =
58            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
59            "usage: qemu-img command [command options]\n"
60            "QEMU disk image utility\n"
61            "\n"
62            "Command syntax:\n"
63 #define DEF(option, callback, arg_string)        \
64            "  " arg_string "\n"
65 #include "qemu-img-cmds.h"
66 #undef DEF
67 #undef GEN_DOCS
68            "\n"
69            "Command parameters:\n"
70            "  'filename' is a disk image filename\n"
71            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
72            "  'cache' is the cache mode used to write the output disk image, the valid\n"
73            "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
74            "    'directsync' and 'unsafe' (default for convert)\n"
75            "  'size' is the disk image size in bytes. Optional suffixes\n"
76            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
77            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
78            "  'output_filename' is the destination disk image filename\n"
79            "  'output_fmt' is the destination format\n"
80            "  'options' is a comma separated list of format specific options in a\n"
81            "    name=value format. Use -o ? for an overview of the options supported by the\n"
82            "    used format\n"
83            "  '-c' indicates that target image must be compressed (qcow format only)\n"
84            "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
85            "       match exactly. The image doesn't need a working backing file before\n"
86            "       rebasing in this case (useful for renaming the backing file)\n"
87            "  '-h' with or without a command shows this help and lists the supported formats\n"
88            "  '-p' show progress of command (only certain commands)\n"
89            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
90            "       for qemu-img to create a sparse image during conversion\n"
91            "  '--output' takes the format in which the output must be done (human or json)\n"
92            "\n"
93            "Parameters to check subcommand:\n"
94            "  '-r' tries to repair any inconsistencies that are found during the check.\n"
95            "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
96            "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
97            "       hiding corruption that has already occurred.\n"
98            "\n"
99            "Parameters to snapshot subcommand:\n"
100            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
101            "  '-a' applies a snapshot (revert disk to saved state)\n"
102            "  '-c' creates a snapshot\n"
103            "  '-d' deletes a snapshot\n"
104            "  '-l' lists all snapshots in the given image\n";
105 
106     printf("%s\nSupported formats:", help_msg);
107     bdrv_iterate_format(format_print, NULL);
108     printf("\n");
109     exit(1);
110 }
111 
112 #if defined(WIN32)
113 /* XXX: put correct support for win32 */
114 static int read_password(char *buf, int buf_size)
115 {
116     int c, i;
117     printf("Password: ");
118     fflush(stdout);
119     i = 0;
120     for(;;) {
121         c = getchar();
122         if (c == '\n')
123             break;
124         if (i < (buf_size - 1))
125             buf[i++] = c;
126     }
127     buf[i] = '\0';
128     return 0;
129 }
130 
131 #else
132 
133 #include <termios.h>
134 
135 static struct termios oldtty;
136 
137 static void term_exit(void)
138 {
139     tcsetattr (0, TCSANOW, &oldtty);
140 }
141 
142 static void term_init(void)
143 {
144     struct termios tty;
145 
146     tcgetattr (0, &tty);
147     oldtty = tty;
148 
149     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
150                           |INLCR|IGNCR|ICRNL|IXON);
151     tty.c_oflag |= OPOST;
152     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
153     tty.c_cflag &= ~(CSIZE|PARENB);
154     tty.c_cflag |= CS8;
155     tty.c_cc[VMIN] = 1;
156     tty.c_cc[VTIME] = 0;
157 
158     tcsetattr (0, TCSANOW, &tty);
159 
160     atexit(term_exit);
161 }
162 
163 static int read_password(char *buf, int buf_size)
164 {
165     uint8_t ch;
166     int i, ret;
167 
168     printf("password: ");
169     fflush(stdout);
170     term_init();
171     i = 0;
172     for(;;) {
173         ret = read(0, &ch, 1);
174         if (ret == -1) {
175             if (errno == EAGAIN || errno == EINTR) {
176                 continue;
177             } else {
178                 ret = -1;
179                 break;
180             }
181         } else if (ret == 0) {
182             ret = -1;
183             break;
184         } else {
185             if (ch == '\r') {
186                 ret = 0;
187                 break;
188             }
189             if (i < (buf_size - 1))
190                 buf[i++] = ch;
191         }
192     }
193     term_exit();
194     buf[i] = '\0';
195     printf("\n");
196     return ret;
197 }
198 #endif
199 
200 static int print_block_option_help(const char *filename, const char *fmt)
201 {
202     BlockDriver *drv, *proto_drv;
203     QEMUOptionParameter *create_options = NULL;
204 
205     /* Find driver and parse its options */
206     drv = bdrv_find_format(fmt);
207     if (!drv) {
208         error_report("Unknown file format '%s'", fmt);
209         return 1;
210     }
211 
212     proto_drv = bdrv_find_protocol(filename);
213     if (!proto_drv) {
214         error_report("Unknown protocol '%s'", filename);
215         return 1;
216     }
217 
218     create_options = append_option_parameters(create_options,
219                                               drv->create_options);
220     create_options = append_option_parameters(create_options,
221                                               proto_drv->create_options);
222     print_option_help(create_options);
223     free_option_parameters(create_options);
224     return 0;
225 }
226 
227 static BlockDriverState *bdrv_new_open(const char *filename,
228                                        const char *fmt,
229                                        int flags,
230                                        bool require_io)
231 {
232     BlockDriverState *bs;
233     BlockDriver *drv;
234     char password[256];
235     int ret;
236 
237     bs = bdrv_new("image");
238 
239     if (fmt) {
240         drv = bdrv_find_format(fmt);
241         if (!drv) {
242             error_report("Unknown file format '%s'", fmt);
243             goto fail;
244         }
245     } else {
246         drv = NULL;
247     }
248 
249     ret = bdrv_open(bs, filename, flags, drv);
250     if (ret < 0) {
251         error_report("Could not open '%s': %s", filename, strerror(-ret));
252         goto fail;
253     }
254 
255     if (bdrv_is_encrypted(bs) && require_io) {
256         printf("Disk image '%s' is encrypted.\n", filename);
257         if (read_password(password, sizeof(password)) < 0) {
258             error_report("No password given");
259             goto fail;
260         }
261         if (bdrv_set_key(bs, password) < 0) {
262             error_report("invalid password");
263             goto fail;
264         }
265     }
266     return bs;
267 fail:
268     if (bs) {
269         bdrv_delete(bs);
270     }
271     return NULL;
272 }
273 
274 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
275                                  const char *base_filename,
276                                  const char *base_fmt)
277 {
278     if (base_filename) {
279         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
280             error_report("Backing file not supported for file format '%s'",
281                          fmt);
282             return -1;
283         }
284     }
285     if (base_fmt) {
286         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
287             error_report("Backing file format not supported for file "
288                          "format '%s'", fmt);
289             return -1;
290         }
291     }
292     return 0;
293 }
294 
295 static int img_create(int argc, char **argv)
296 {
297     int c, ret = 0;
298     uint64_t img_size = -1;
299     const char *fmt = "raw";
300     const char *base_fmt = NULL;
301     const char *filename;
302     const char *base_filename = NULL;
303     char *options = NULL;
304 
305     for(;;) {
306         c = getopt(argc, argv, "F:b:f:he6o:");
307         if (c == -1) {
308             break;
309         }
310         switch(c) {
311         case '?':
312         case 'h':
313             help();
314             break;
315         case 'F':
316             base_fmt = optarg;
317             break;
318         case 'b':
319             base_filename = optarg;
320             break;
321         case 'f':
322             fmt = optarg;
323             break;
324         case 'e':
325             error_report("option -e is deprecated, please use \'-o "
326                   "encryption\' instead!");
327             return 1;
328         case '6':
329             error_report("option -6 is deprecated, please use \'-o "
330                   "compat6\' instead!");
331             return 1;
332         case 'o':
333             options = optarg;
334             break;
335         }
336     }
337 
338     /* Get the filename */
339     if (optind >= argc) {
340         help();
341     }
342     filename = argv[optind++];
343 
344     /* Get image size, if specified */
345     if (optind < argc) {
346         int64_t sval;
347         char *end;
348         sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
349         if (sval < 0 || *end) {
350             error_report("Invalid image size specified! You may use k, M, G or "
351                   "T suffixes for ");
352             error_report("kilobytes, megabytes, gigabytes and terabytes.");
353             ret = -1;
354             goto out;
355         }
356         img_size = (uint64_t)sval;
357     }
358 
359     if (options && is_help_option(options)) {
360         ret = print_block_option_help(filename, fmt);
361         goto out;
362     }
363 
364     ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
365                           options, img_size, BDRV_O_FLAGS);
366 out:
367     if (ret) {
368         return 1;
369     }
370     return 0;
371 }
372 
373 /*
374  * Checks an image for consistency. Exit codes:
375  *
376  * 0 - Check completed, image is good
377  * 1 - Check not completed because of internal errors
378  * 2 - Check completed, image is corrupted
379  * 3 - Check completed, image has leaked clusters, but is good otherwise
380  */
381 static int img_check(int argc, char **argv)
382 {
383     int c, ret;
384     const char *filename, *fmt;
385     BlockDriverState *bs;
386     BdrvCheckResult result;
387     int fix = 0;
388     int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
389 
390     fmt = NULL;
391     for(;;) {
392         c = getopt(argc, argv, "f:hr:");
393         if (c == -1) {
394             break;
395         }
396         switch(c) {
397         case '?':
398         case 'h':
399             help();
400             break;
401         case 'f':
402             fmt = optarg;
403             break;
404         case 'r':
405             flags |= BDRV_O_RDWR;
406 
407             if (!strcmp(optarg, "leaks")) {
408                 fix = BDRV_FIX_LEAKS;
409             } else if (!strcmp(optarg, "all")) {
410                 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
411             } else {
412                 help();
413             }
414             break;
415         }
416     }
417     if (optind >= argc) {
418         help();
419     }
420     filename = argv[optind++];
421 
422     bs = bdrv_new_open(filename, fmt, flags, true);
423     if (!bs) {
424         return 1;
425     }
426     ret = bdrv_check(bs, &result, fix);
427 
428     if (ret == -ENOTSUP) {
429         error_report("This image format does not support checks");
430         bdrv_delete(bs);
431         return 1;
432     }
433 
434     if (result.corruptions_fixed || result.leaks_fixed) {
435         printf("The following inconsistencies were found and repaired:\n\n"
436                "    %d leaked clusters\n"
437                "    %d corruptions\n\n"
438                "Double checking the fixed image now...\n",
439                result.leaks_fixed,
440                result.corruptions_fixed);
441         ret = bdrv_check(bs, &result, 0);
442     }
443 
444     if (!(result.corruptions || result.leaks || result.check_errors)) {
445         printf("No errors were found on the image.\n");
446     } else {
447         if (result.corruptions) {
448             printf("\n%d errors were found on the image.\n"
449                 "Data may be corrupted, or further writes to the image "
450                 "may corrupt it.\n",
451                 result.corruptions);
452         }
453 
454         if (result.leaks) {
455             printf("\n%d leaked clusters were found on the image.\n"
456                 "This means waste of disk space, but no harm to data.\n",
457                 result.leaks);
458         }
459 
460         if (result.check_errors) {
461             printf("\n%d internal errors have occurred during the check.\n",
462                 result.check_errors);
463         }
464     }
465 
466     if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
467         printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
468         result.bfi.allocated_clusters, result.bfi.total_clusters,
469         result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
470         result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
471     }
472 
473     bdrv_delete(bs);
474 
475     if (ret < 0 || result.check_errors) {
476         printf("\nAn error has occurred during the check: %s\n"
477             "The check is not complete and may have missed error.\n",
478             strerror(-ret));
479         return 1;
480     }
481 
482     if (result.corruptions) {
483         return 2;
484     } else if (result.leaks) {
485         return 3;
486     } else {
487         return 0;
488     }
489 }
490 
491 static int img_commit(int argc, char **argv)
492 {
493     int c, ret, flags;
494     const char *filename, *fmt, *cache;
495     BlockDriverState *bs;
496 
497     fmt = NULL;
498     cache = BDRV_DEFAULT_CACHE;
499     for(;;) {
500         c = getopt(argc, argv, "f:ht:");
501         if (c == -1) {
502             break;
503         }
504         switch(c) {
505         case '?':
506         case 'h':
507             help();
508             break;
509         case 'f':
510             fmt = optarg;
511             break;
512         case 't':
513             cache = optarg;
514             break;
515         }
516     }
517     if (optind >= argc) {
518         help();
519     }
520     filename = argv[optind++];
521 
522     flags = BDRV_O_RDWR;
523     ret = bdrv_parse_cache_flags(cache, &flags);
524     if (ret < 0) {
525         error_report("Invalid cache option: %s", cache);
526         return -1;
527     }
528 
529     bs = bdrv_new_open(filename, fmt, flags, true);
530     if (!bs) {
531         return 1;
532     }
533     ret = bdrv_commit(bs);
534     switch(ret) {
535     case 0:
536         printf("Image committed.\n");
537         break;
538     case -ENOENT:
539         error_report("No disk inserted");
540         break;
541     case -EACCES:
542         error_report("Image is read-only");
543         break;
544     case -ENOTSUP:
545         error_report("Image is already committed");
546         break;
547     default:
548         error_report("Error while committing image");
549         break;
550     }
551 
552     bdrv_delete(bs);
553     if (ret) {
554         return 1;
555     }
556     return 0;
557 }
558 
559 /*
560  * Returns true iff the first sector pointed to by 'buf' contains at least
561  * a non-NUL byte.
562  *
563  * 'pnum' is set to the number of sectors (including and immediately following
564  * the first one) that are known to be in the same allocated/unallocated state.
565  */
566 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
567 {
568     bool is_zero;
569     int i;
570 
571     if (n <= 0) {
572         *pnum = 0;
573         return 0;
574     }
575     is_zero = buffer_is_zero(buf, 512);
576     for(i = 1; i < n; i++) {
577         buf += 512;
578         if (is_zero != buffer_is_zero(buf, 512)) {
579             break;
580         }
581     }
582     *pnum = i;
583     return !is_zero;
584 }
585 
586 /*
587  * Like is_allocated_sectors, but if the buffer starts with a used sector,
588  * up to 'min' consecutive sectors containing zeros are ignored. This avoids
589  * breaking up write requests for only small sparse areas.
590  */
591 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
592     int min)
593 {
594     int ret;
595     int num_checked, num_used;
596 
597     if (n < min) {
598         min = n;
599     }
600 
601     ret = is_allocated_sectors(buf, n, pnum);
602     if (!ret) {
603         return ret;
604     }
605 
606     num_used = *pnum;
607     buf += BDRV_SECTOR_SIZE * *pnum;
608     n -= *pnum;
609     num_checked = num_used;
610 
611     while (n > 0) {
612         ret = is_allocated_sectors(buf, n, pnum);
613 
614         buf += BDRV_SECTOR_SIZE * *pnum;
615         n -= *pnum;
616         num_checked += *pnum;
617         if (ret) {
618             num_used = num_checked;
619         } else if (*pnum >= min) {
620             break;
621         }
622     }
623 
624     *pnum = num_used;
625     return 1;
626 }
627 
628 /*
629  * Compares two buffers sector by sector. Returns 0 if the first sector of both
630  * buffers matches, non-zero otherwise.
631  *
632  * pnum is set to the number of sectors (including and immediately following
633  * the first one) that are known to have the same comparison result
634  */
635 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
636     int *pnum)
637 {
638     int res, i;
639 
640     if (n <= 0) {
641         *pnum = 0;
642         return 0;
643     }
644 
645     res = !!memcmp(buf1, buf2, 512);
646     for(i = 1; i < n; i++) {
647         buf1 += 512;
648         buf2 += 512;
649 
650         if (!!memcmp(buf1, buf2, 512) != res) {
651             break;
652         }
653     }
654 
655     *pnum = i;
656     return res;
657 }
658 
659 #define IO_BUF_SIZE (2 * 1024 * 1024)
660 
661 static int img_convert(int argc, char **argv)
662 {
663     int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
664     int progress = 0, flags;
665     const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
666     BlockDriver *drv, *proto_drv;
667     BlockDriverState **bs = NULL, *out_bs = NULL;
668     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
669     uint64_t bs_sectors;
670     uint8_t * buf = NULL;
671     const uint8_t *buf1;
672     BlockDriverInfo bdi;
673     QEMUOptionParameter *param = NULL, *create_options = NULL;
674     QEMUOptionParameter *out_baseimg_param;
675     char *options = NULL;
676     const char *snapshot_name = NULL;
677     float local_progress = 0;
678     int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
679 
680     fmt = NULL;
681     out_fmt = "raw";
682     cache = "unsafe";
683     out_baseimg = NULL;
684     compress = 0;
685     for(;;) {
686         c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
687         if (c == -1) {
688             break;
689         }
690         switch(c) {
691         case '?':
692         case 'h':
693             help();
694             break;
695         case 'f':
696             fmt = optarg;
697             break;
698         case 'O':
699             out_fmt = optarg;
700             break;
701         case 'B':
702             out_baseimg = optarg;
703             break;
704         case 'c':
705             compress = 1;
706             break;
707         case 'e':
708             error_report("option -e is deprecated, please use \'-o "
709                   "encryption\' instead!");
710             return 1;
711         case '6':
712             error_report("option -6 is deprecated, please use \'-o "
713                   "compat6\' instead!");
714             return 1;
715         case 'o':
716             options = optarg;
717             break;
718         case 's':
719             snapshot_name = optarg;
720             break;
721         case 'S':
722         {
723             int64_t sval;
724             char *end;
725             sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
726             if (sval < 0 || *end) {
727                 error_report("Invalid minimum zero buffer size for sparse output specified");
728                 return 1;
729             }
730 
731             min_sparse = sval / BDRV_SECTOR_SIZE;
732             break;
733         }
734         case 'p':
735             progress = 1;
736             break;
737         case 't':
738             cache = optarg;
739             break;
740         }
741     }
742 
743     bs_n = argc - optind - 1;
744     if (bs_n < 1) {
745         help();
746     }
747 
748     out_filename = argv[argc - 1];
749 
750     /* Initialize before goto out */
751     qemu_progress_init(progress, 2.0);
752 
753     if (options && is_help_option(options)) {
754         ret = print_block_option_help(out_filename, out_fmt);
755         goto out;
756     }
757 
758     if (bs_n > 1 && out_baseimg) {
759         error_report("-B makes no sense when concatenating multiple input "
760                      "images");
761         ret = -1;
762         goto out;
763     }
764 
765     qemu_progress_print(0, 100);
766 
767     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
768 
769     total_sectors = 0;
770     for (bs_i = 0; bs_i < bs_n; bs_i++) {
771         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
772         if (!bs[bs_i]) {
773             error_report("Could not open '%s'", argv[optind + bs_i]);
774             ret = -1;
775             goto out;
776         }
777         bdrv_get_geometry(bs[bs_i], &bs_sectors);
778         total_sectors += bs_sectors;
779     }
780 
781     if (snapshot_name != NULL) {
782         if (bs_n > 1) {
783             error_report("No support for concatenating multiple snapshot");
784             ret = -1;
785             goto out;
786         }
787         if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
788             error_report("Failed to load snapshot");
789             ret = -1;
790             goto out;
791         }
792     }
793 
794     /* Find driver and parse its options */
795     drv = bdrv_find_format(out_fmt);
796     if (!drv) {
797         error_report("Unknown file format '%s'", out_fmt);
798         ret = -1;
799         goto out;
800     }
801 
802     proto_drv = bdrv_find_protocol(out_filename);
803     if (!proto_drv) {
804         error_report("Unknown protocol '%s'", out_filename);
805         ret = -1;
806         goto out;
807     }
808 
809     create_options = append_option_parameters(create_options,
810                                               drv->create_options);
811     create_options = append_option_parameters(create_options,
812                                               proto_drv->create_options);
813 
814     if (options) {
815         param = parse_option_parameters(options, create_options, param);
816         if (param == NULL) {
817             error_report("Invalid options for file format '%s'.", out_fmt);
818             ret = -1;
819             goto out;
820         }
821     } else {
822         param = parse_option_parameters("", create_options, param);
823     }
824 
825     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
826     ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
827     if (ret < 0) {
828         goto out;
829     }
830 
831     /* Get backing file name if -o backing_file was used */
832     out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
833     if (out_baseimg_param) {
834         out_baseimg = out_baseimg_param->value.s;
835     }
836 
837     /* Check if compression is supported */
838     if (compress) {
839         QEMUOptionParameter *encryption =
840             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
841         QEMUOptionParameter *preallocation =
842             get_option_parameter(param, BLOCK_OPT_PREALLOC);
843 
844         if (!drv->bdrv_write_compressed) {
845             error_report("Compression not supported for this file format");
846             ret = -1;
847             goto out;
848         }
849 
850         if (encryption && encryption->value.n) {
851             error_report("Compression and encryption not supported at "
852                          "the same time");
853             ret = -1;
854             goto out;
855         }
856 
857         if (preallocation && preallocation->value.s
858             && strcmp(preallocation->value.s, "off"))
859         {
860             error_report("Compression and preallocation not supported at "
861                          "the same time");
862             ret = -1;
863             goto out;
864         }
865     }
866 
867     /* Create the new image */
868     ret = bdrv_create(drv, out_filename, param);
869     if (ret < 0) {
870         if (ret == -ENOTSUP) {
871             error_report("Formatting not supported for file format '%s'",
872                          out_fmt);
873         } else if (ret == -EFBIG) {
874             error_report("The image size is too large for file format '%s'",
875                          out_fmt);
876         } else {
877             error_report("%s: error while converting %s: %s",
878                          out_filename, out_fmt, strerror(-ret));
879         }
880         goto out;
881     }
882 
883     flags = BDRV_O_RDWR;
884     ret = bdrv_parse_cache_flags(cache, &flags);
885     if (ret < 0) {
886         error_report("Invalid cache option: %s", cache);
887         return -1;
888     }
889 
890     out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
891     if (!out_bs) {
892         ret = -1;
893         goto out;
894     }
895 
896     bs_i = 0;
897     bs_offset = 0;
898     bdrv_get_geometry(bs[0], &bs_sectors);
899     buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
900 
901     if (compress) {
902         ret = bdrv_get_info(out_bs, &bdi);
903         if (ret < 0) {
904             error_report("could not get block driver info");
905             goto out;
906         }
907         cluster_size = bdi.cluster_size;
908         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
909             error_report("invalid cluster size");
910             ret = -1;
911             goto out;
912         }
913         cluster_sectors = cluster_size >> 9;
914         sector_num = 0;
915 
916         nb_sectors = total_sectors;
917         if (nb_sectors != 0) {
918             local_progress = (float)100 /
919                 (nb_sectors / MIN(nb_sectors, cluster_sectors));
920         }
921 
922         for(;;) {
923             int64_t bs_num;
924             int remainder;
925             uint8_t *buf2;
926 
927             nb_sectors = total_sectors - sector_num;
928             if (nb_sectors <= 0)
929                 break;
930             if (nb_sectors >= cluster_sectors)
931                 n = cluster_sectors;
932             else
933                 n = nb_sectors;
934 
935             bs_num = sector_num - bs_offset;
936             assert (bs_num >= 0);
937             remainder = n;
938             buf2 = buf;
939             while (remainder > 0) {
940                 int nlow;
941                 while (bs_num == bs_sectors) {
942                     bs_i++;
943                     assert (bs_i < bs_n);
944                     bs_offset += bs_sectors;
945                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
946                     bs_num = 0;
947                     /* printf("changing part: sector_num=%" PRId64 ", "
948                        "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
949                        "\n", sector_num, bs_i, bs_offset, bs_sectors); */
950                 }
951                 assert (bs_num < bs_sectors);
952 
953                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
954 
955                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
956                 if (ret < 0) {
957                     error_report("error while reading sector %" PRId64 ": %s",
958                                  bs_num, strerror(-ret));
959                     goto out;
960                 }
961 
962                 buf2 += nlow * 512;
963                 bs_num += nlow;
964 
965                 remainder -= nlow;
966             }
967             assert (remainder == 0);
968 
969             if (n < cluster_sectors) {
970                 memset(buf + n * 512, 0, cluster_size - n * 512);
971             }
972             if (!buffer_is_zero(buf, cluster_size)) {
973                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
974                                             cluster_sectors);
975                 if (ret != 0) {
976                     error_report("error while compressing sector %" PRId64
977                                  ": %s", sector_num, strerror(-ret));
978                     goto out;
979                 }
980             }
981             sector_num += n;
982             qemu_progress_print(local_progress, 100);
983         }
984         /* signal EOF to align */
985         bdrv_write_compressed(out_bs, 0, NULL, 0);
986     } else {
987         int has_zero_init = bdrv_has_zero_init(out_bs);
988 
989         sector_num = 0; // total number of sectors converted so far
990         nb_sectors = total_sectors - sector_num;
991         if (nb_sectors != 0) {
992             local_progress = (float)100 /
993                 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
994         }
995 
996         for(;;) {
997             nb_sectors = total_sectors - sector_num;
998             if (nb_sectors <= 0) {
999                 break;
1000             }
1001             if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1002                 n = (IO_BUF_SIZE / 512);
1003             } else {
1004                 n = nb_sectors;
1005             }
1006 
1007             while (sector_num - bs_offset >= bs_sectors) {
1008                 bs_i ++;
1009                 assert (bs_i < bs_n);
1010                 bs_offset += bs_sectors;
1011                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1012                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1013                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1014                    sector_num, bs_i, bs_offset, bs_sectors); */
1015             }
1016 
1017             if (n > bs_offset + bs_sectors - sector_num) {
1018                 n = bs_offset + bs_sectors - sector_num;
1019             }
1020 
1021             if (has_zero_init) {
1022                 /* If the output image is being created as a copy on write image,
1023                    assume that sectors which are unallocated in the input image
1024                    are present in both the output's and input's base images (no
1025                    need to copy them). */
1026                 if (out_baseimg) {
1027                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1028                                            n, &n1)) {
1029                         sector_num += n1;
1030                         continue;
1031                     }
1032                     /* The next 'n1' sectors are allocated in the input image. Copy
1033                        only those as they may be followed by unallocated sectors. */
1034                     n = n1;
1035                 }
1036             } else {
1037                 n1 = n;
1038             }
1039 
1040             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1041             if (ret < 0) {
1042                 error_report("error while reading sector %" PRId64 ": %s",
1043                              sector_num - bs_offset, strerror(-ret));
1044                 goto out;
1045             }
1046             /* NOTE: at the same time we convert, we do not write zero
1047                sectors to have a chance to compress the image. Ideally, we
1048                should add a specific call to have the info to go faster */
1049             buf1 = buf;
1050             while (n > 0) {
1051                 /* If the output image is being created as a copy on write image,
1052                    copy all sectors even the ones containing only NUL bytes,
1053                    because they may differ from the sectors in the base image.
1054 
1055                    If the output is to a host device, we also write out
1056                    sectors that are entirely 0, since whatever data was
1057                    already there is garbage, not 0s. */
1058                 if (!has_zero_init || out_baseimg ||
1059                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1060                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
1061                     if (ret < 0) {
1062                         error_report("error while writing sector %" PRId64
1063                                      ": %s", sector_num, strerror(-ret));
1064                         goto out;
1065                     }
1066                 }
1067                 sector_num += n1;
1068                 n -= n1;
1069                 buf1 += n1 * 512;
1070             }
1071             qemu_progress_print(local_progress, 100);
1072         }
1073     }
1074 out:
1075     qemu_progress_end();
1076     free_option_parameters(create_options);
1077     free_option_parameters(param);
1078     qemu_vfree(buf);
1079     if (out_bs) {
1080         bdrv_delete(out_bs);
1081     }
1082     if (bs) {
1083         for (bs_i = 0; bs_i < bs_n; bs_i++) {
1084             if (bs[bs_i]) {
1085                 bdrv_delete(bs[bs_i]);
1086             }
1087         }
1088         g_free(bs);
1089     }
1090     if (ret) {
1091         return 1;
1092     }
1093     return 0;
1094 }
1095 
1096 
1097 static void dump_snapshots(BlockDriverState *bs)
1098 {
1099     QEMUSnapshotInfo *sn_tab, *sn;
1100     int nb_sns, i;
1101     char buf[256];
1102 
1103     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1104     if (nb_sns <= 0)
1105         return;
1106     printf("Snapshot list:\n");
1107     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1108     for(i = 0; i < nb_sns; i++) {
1109         sn = &sn_tab[i];
1110         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1111     }
1112     g_free(sn_tab);
1113 }
1114 
1115 static void dump_json_image_info_list(ImageInfoList *list)
1116 {
1117     Error *errp = NULL;
1118     QString *str;
1119     QmpOutputVisitor *ov = qmp_output_visitor_new();
1120     QObject *obj;
1121     visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1122                              &list, NULL, &errp);
1123     obj = qmp_output_get_qobject(ov);
1124     str = qobject_to_json_pretty(obj);
1125     assert(str != NULL);
1126     printf("%s\n", qstring_get_str(str));
1127     qobject_decref(obj);
1128     qmp_output_visitor_cleanup(ov);
1129     QDECREF(str);
1130 }
1131 
1132 static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
1133 {
1134     int i, sn_count;
1135     QEMUSnapshotInfo *sn_tab = NULL;
1136     SnapshotInfoList *info_list, *cur_item = NULL;
1137     sn_count = bdrv_snapshot_list(bs, &sn_tab);
1138 
1139     for (i = 0; i < sn_count; i++) {
1140         info->has_snapshots = true;
1141         info_list = g_new0(SnapshotInfoList, 1);
1142 
1143         info_list->value                = g_new0(SnapshotInfo, 1);
1144         info_list->value->id            = g_strdup(sn_tab[i].id_str);
1145         info_list->value->name          = g_strdup(sn_tab[i].name);
1146         info_list->value->vm_state_size = sn_tab[i].vm_state_size;
1147         info_list->value->date_sec      = sn_tab[i].date_sec;
1148         info_list->value->date_nsec     = sn_tab[i].date_nsec;
1149         info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
1150         info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
1151 
1152         /* XXX: waiting for the qapi to support qemu-queue.h types */
1153         if (!cur_item) {
1154             info->snapshots = cur_item = info_list;
1155         } else {
1156             cur_item->next = info_list;
1157             cur_item = info_list;
1158         }
1159 
1160     }
1161 
1162     g_free(sn_tab);
1163 }
1164 
1165 static void dump_json_image_info(ImageInfo *info)
1166 {
1167     Error *errp = NULL;
1168     QString *str;
1169     QmpOutputVisitor *ov = qmp_output_visitor_new();
1170     QObject *obj;
1171     visit_type_ImageInfo(qmp_output_get_visitor(ov),
1172                          &info, NULL, &errp);
1173     obj = qmp_output_get_qobject(ov);
1174     str = qobject_to_json_pretty(obj);
1175     assert(str != NULL);
1176     printf("%s\n", qstring_get_str(str));
1177     qobject_decref(obj);
1178     qmp_output_visitor_cleanup(ov);
1179     QDECREF(str);
1180 }
1181 
1182 static void collect_image_info(BlockDriverState *bs,
1183                    ImageInfo *info,
1184                    const char *filename,
1185                    const char *fmt)
1186 {
1187     uint64_t total_sectors;
1188     char backing_filename[1024];
1189     char backing_filename2[1024];
1190     BlockDriverInfo bdi;
1191 
1192     bdrv_get_geometry(bs, &total_sectors);
1193 
1194     info->filename        = g_strdup(filename);
1195     info->format          = g_strdup(bdrv_get_format_name(bs));
1196     info->virtual_size    = total_sectors * 512;
1197     info->actual_size     = bdrv_get_allocated_file_size(bs);
1198     info->has_actual_size = info->actual_size >= 0;
1199     if (bdrv_is_encrypted(bs)) {
1200         info->encrypted = true;
1201         info->has_encrypted = true;
1202     }
1203     if (bdrv_get_info(bs, &bdi) >= 0) {
1204         if (bdi.cluster_size != 0) {
1205             info->cluster_size = bdi.cluster_size;
1206             info->has_cluster_size = true;
1207         }
1208         info->dirty_flag = bdi.is_dirty;
1209         info->has_dirty_flag = true;
1210     }
1211     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1212     if (backing_filename[0] != '\0') {
1213         info->backing_filename = g_strdup(backing_filename);
1214         info->has_backing_filename = true;
1215         bdrv_get_full_backing_filename(bs, backing_filename2,
1216                                        sizeof(backing_filename2));
1217 
1218         if (strcmp(backing_filename, backing_filename2) != 0) {
1219             info->full_backing_filename =
1220                         g_strdup(backing_filename2);
1221             info->has_full_backing_filename = true;
1222         }
1223 
1224         if (bs->backing_format[0]) {
1225             info->backing_filename_format = g_strdup(bs->backing_format);
1226             info->has_backing_filename_format = true;
1227         }
1228     }
1229 }
1230 
1231 static void dump_human_image_info(ImageInfo *info)
1232 {
1233     char size_buf[128], dsize_buf[128];
1234     if (!info->has_actual_size) {
1235         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1236     } else {
1237         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1238                                 info->actual_size);
1239     }
1240     get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
1241     printf("image: %s\n"
1242            "file format: %s\n"
1243            "virtual size: %s (%" PRId64 " bytes)\n"
1244            "disk size: %s\n",
1245            info->filename, info->format, size_buf,
1246            info->virtual_size,
1247            dsize_buf);
1248 
1249     if (info->has_encrypted && info->encrypted) {
1250         printf("encrypted: yes\n");
1251     }
1252 
1253     if (info->has_cluster_size) {
1254         printf("cluster_size: %" PRId64 "\n", info->cluster_size);
1255     }
1256 
1257     if (info->has_dirty_flag && info->dirty_flag) {
1258         printf("cleanly shut down: no\n");
1259     }
1260 
1261     if (info->has_backing_filename) {
1262         printf("backing file: %s", info->backing_filename);
1263         if (info->has_full_backing_filename) {
1264             printf(" (actual path: %s)", info->full_backing_filename);
1265         }
1266         putchar('\n');
1267         if (info->has_backing_filename_format) {
1268             printf("backing file format: %s\n", info->backing_filename_format);
1269         }
1270     }
1271 
1272     if (info->has_snapshots) {
1273         SnapshotInfoList *elem;
1274         char buf[256];
1275 
1276         printf("Snapshot list:\n");
1277         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1278 
1279         /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
1280          * we convert to the block layer's native QEMUSnapshotInfo for now.
1281          */
1282         for (elem = info->snapshots; elem; elem = elem->next) {
1283             QEMUSnapshotInfo sn = {
1284                 .vm_state_size = elem->value->vm_state_size,
1285                 .date_sec = elem->value->date_sec,
1286                 .date_nsec = elem->value->date_nsec,
1287                 .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
1288                                  elem->value->vm_clock_nsec,
1289             };
1290 
1291             pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1292             pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1293             printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
1294         }
1295     }
1296 }
1297 
1298 static void dump_human_image_info_list(ImageInfoList *list)
1299 {
1300     ImageInfoList *elem;
1301     bool delim = false;
1302 
1303     for (elem = list; elem; elem = elem->next) {
1304         if (delim) {
1305             printf("\n");
1306         }
1307         delim = true;
1308 
1309         dump_human_image_info(elem->value);
1310     }
1311 }
1312 
1313 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1314 {
1315     return strcmp(a, b) == 0;
1316 }
1317 
1318 /**
1319  * Open an image file chain and return an ImageInfoList
1320  *
1321  * @filename: topmost image filename
1322  * @fmt: topmost image format (may be NULL to autodetect)
1323  * @chain: true  - enumerate entire backing file chain
1324  *         false - only topmost image file
1325  *
1326  * Returns a list of ImageInfo objects or NULL if there was an error opening an
1327  * image file.  If there was an error a message will have been printed to
1328  * stderr.
1329  */
1330 static ImageInfoList *collect_image_info_list(const char *filename,
1331                                               const char *fmt,
1332                                               bool chain)
1333 {
1334     ImageInfoList *head = NULL;
1335     ImageInfoList **last = &head;
1336     GHashTable *filenames;
1337 
1338     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1339 
1340     while (filename) {
1341         BlockDriverState *bs;
1342         ImageInfo *info;
1343         ImageInfoList *elem;
1344 
1345         if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1346             error_report("Backing file '%s' creates an infinite loop.",
1347                          filename);
1348             goto err;
1349         }
1350         g_hash_table_insert(filenames, (gpointer)filename, NULL);
1351 
1352         bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1353                            false);
1354         if (!bs) {
1355             goto err;
1356         }
1357 
1358         info = g_new0(ImageInfo, 1);
1359         collect_image_info(bs, info, filename, fmt);
1360         collect_snapshots(bs, info);
1361 
1362         elem = g_new0(ImageInfoList, 1);
1363         elem->value = info;
1364         *last = elem;
1365         last = &elem->next;
1366 
1367         bdrv_delete(bs);
1368 
1369         filename = fmt = NULL;
1370         if (chain) {
1371             if (info->has_full_backing_filename) {
1372                 filename = info->full_backing_filename;
1373             } else if (info->has_backing_filename) {
1374                 filename = info->backing_filename;
1375             }
1376             if (info->has_backing_filename_format) {
1377                 fmt = info->backing_filename_format;
1378             }
1379         }
1380     }
1381     g_hash_table_destroy(filenames);
1382     return head;
1383 
1384 err:
1385     qapi_free_ImageInfoList(head);
1386     g_hash_table_destroy(filenames);
1387     return NULL;
1388 }
1389 
1390 enum {
1391     OPTION_OUTPUT = 256,
1392     OPTION_BACKING_CHAIN = 257,
1393 };
1394 
1395 typedef enum OutputFormat {
1396     OFORMAT_JSON,
1397     OFORMAT_HUMAN,
1398 } OutputFormat;
1399 
1400 static int img_info(int argc, char **argv)
1401 {
1402     int c;
1403     OutputFormat output_format = OFORMAT_HUMAN;
1404     bool chain = false;
1405     const char *filename, *fmt, *output;
1406     ImageInfoList *list;
1407 
1408     fmt = NULL;
1409     output = NULL;
1410     for(;;) {
1411         int option_index = 0;
1412         static const struct option long_options[] = {
1413             {"help", no_argument, 0, 'h'},
1414             {"format", required_argument, 0, 'f'},
1415             {"output", required_argument, 0, OPTION_OUTPUT},
1416             {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1417             {0, 0, 0, 0}
1418         };
1419         c = getopt_long(argc, argv, "f:h",
1420                         long_options, &option_index);
1421         if (c == -1) {
1422             break;
1423         }
1424         switch(c) {
1425         case '?':
1426         case 'h':
1427             help();
1428             break;
1429         case 'f':
1430             fmt = optarg;
1431             break;
1432         case OPTION_OUTPUT:
1433             output = optarg;
1434             break;
1435         case OPTION_BACKING_CHAIN:
1436             chain = true;
1437             break;
1438         }
1439     }
1440     if (optind >= argc) {
1441         help();
1442     }
1443     filename = argv[optind++];
1444 
1445     if (output && !strcmp(output, "json")) {
1446         output_format = OFORMAT_JSON;
1447     } else if (output && !strcmp(output, "human")) {
1448         output_format = OFORMAT_HUMAN;
1449     } else if (output) {
1450         error_report("--output must be used with human or json as argument.");
1451         return 1;
1452     }
1453 
1454     list = collect_image_info_list(filename, fmt, chain);
1455     if (!list) {
1456         return 1;
1457     }
1458 
1459     switch (output_format) {
1460     case OFORMAT_HUMAN:
1461         dump_human_image_info_list(list);
1462         break;
1463     case OFORMAT_JSON:
1464         if (chain) {
1465             dump_json_image_info_list(list);
1466         } else {
1467             dump_json_image_info(list->value);
1468         }
1469         break;
1470     }
1471 
1472     qapi_free_ImageInfoList(list);
1473     return 0;
1474 }
1475 
1476 #define SNAPSHOT_LIST   1
1477 #define SNAPSHOT_CREATE 2
1478 #define SNAPSHOT_APPLY  3
1479 #define SNAPSHOT_DELETE 4
1480 
1481 static int img_snapshot(int argc, char **argv)
1482 {
1483     BlockDriverState *bs;
1484     QEMUSnapshotInfo sn;
1485     char *filename, *snapshot_name = NULL;
1486     int c, ret = 0, bdrv_oflags;
1487     int action = 0;
1488     qemu_timeval tv;
1489 
1490     bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1491     /* Parse commandline parameters */
1492     for(;;) {
1493         c = getopt(argc, argv, "la:c:d:h");
1494         if (c == -1) {
1495             break;
1496         }
1497         switch(c) {
1498         case '?':
1499         case 'h':
1500             help();
1501             return 0;
1502         case 'l':
1503             if (action) {
1504                 help();
1505                 return 0;
1506             }
1507             action = SNAPSHOT_LIST;
1508             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1509             break;
1510         case 'a':
1511             if (action) {
1512                 help();
1513                 return 0;
1514             }
1515             action = SNAPSHOT_APPLY;
1516             snapshot_name = optarg;
1517             break;
1518         case 'c':
1519             if (action) {
1520                 help();
1521                 return 0;
1522             }
1523             action = SNAPSHOT_CREATE;
1524             snapshot_name = optarg;
1525             break;
1526         case 'd':
1527             if (action) {
1528                 help();
1529                 return 0;
1530             }
1531             action = SNAPSHOT_DELETE;
1532             snapshot_name = optarg;
1533             break;
1534         }
1535     }
1536 
1537     if (optind >= argc) {
1538         help();
1539     }
1540     filename = argv[optind++];
1541 
1542     /* Open the image */
1543     bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1544     if (!bs) {
1545         return 1;
1546     }
1547 
1548     /* Perform the requested action */
1549     switch(action) {
1550     case SNAPSHOT_LIST:
1551         dump_snapshots(bs);
1552         break;
1553 
1554     case SNAPSHOT_CREATE:
1555         memset(&sn, 0, sizeof(sn));
1556         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1557 
1558         qemu_gettimeofday(&tv);
1559         sn.date_sec = tv.tv_sec;
1560         sn.date_nsec = tv.tv_usec * 1000;
1561 
1562         ret = bdrv_snapshot_create(bs, &sn);
1563         if (ret) {
1564             error_report("Could not create snapshot '%s': %d (%s)",
1565                 snapshot_name, ret, strerror(-ret));
1566         }
1567         break;
1568 
1569     case SNAPSHOT_APPLY:
1570         ret = bdrv_snapshot_goto(bs, snapshot_name);
1571         if (ret) {
1572             error_report("Could not apply snapshot '%s': %d (%s)",
1573                 snapshot_name, ret, strerror(-ret));
1574         }
1575         break;
1576 
1577     case SNAPSHOT_DELETE:
1578         ret = bdrv_snapshot_delete(bs, snapshot_name);
1579         if (ret) {
1580             error_report("Could not delete snapshot '%s': %d (%s)",
1581                 snapshot_name, ret, strerror(-ret));
1582         }
1583         break;
1584     }
1585 
1586     /* Cleanup */
1587     bdrv_delete(bs);
1588     if (ret) {
1589         return 1;
1590     }
1591     return 0;
1592 }
1593 
1594 static int img_rebase(int argc, char **argv)
1595 {
1596     BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1597     BlockDriver *old_backing_drv, *new_backing_drv;
1598     char *filename;
1599     const char *fmt, *cache, *out_basefmt, *out_baseimg;
1600     int c, flags, ret;
1601     int unsafe = 0;
1602     int progress = 0;
1603 
1604     /* Parse commandline parameters */
1605     fmt = NULL;
1606     cache = BDRV_DEFAULT_CACHE;
1607     out_baseimg = NULL;
1608     out_basefmt = NULL;
1609     for(;;) {
1610         c = getopt(argc, argv, "uhf:F:b:pt:");
1611         if (c == -1) {
1612             break;
1613         }
1614         switch(c) {
1615         case '?':
1616         case 'h':
1617             help();
1618             return 0;
1619         case 'f':
1620             fmt = optarg;
1621             break;
1622         case 'F':
1623             out_basefmt = optarg;
1624             break;
1625         case 'b':
1626             out_baseimg = optarg;
1627             break;
1628         case 'u':
1629             unsafe = 1;
1630             break;
1631         case 'p':
1632             progress = 1;
1633             break;
1634         case 't':
1635             cache = optarg;
1636             break;
1637         }
1638     }
1639 
1640     if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1641         help();
1642     }
1643     filename = argv[optind++];
1644 
1645     qemu_progress_init(progress, 2.0);
1646     qemu_progress_print(0, 100);
1647 
1648     flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1649     ret = bdrv_parse_cache_flags(cache, &flags);
1650     if (ret < 0) {
1651         error_report("Invalid cache option: %s", cache);
1652         return -1;
1653     }
1654 
1655     /*
1656      * Open the images.
1657      *
1658      * Ignore the old backing file for unsafe rebase in case we want to correct
1659      * the reference to a renamed or moved backing file.
1660      */
1661     bs = bdrv_new_open(filename, fmt, flags, true);
1662     if (!bs) {
1663         return 1;
1664     }
1665 
1666     /* Find the right drivers for the backing files */
1667     old_backing_drv = NULL;
1668     new_backing_drv = NULL;
1669 
1670     if (!unsafe && bs->backing_format[0] != '\0') {
1671         old_backing_drv = bdrv_find_format(bs->backing_format);
1672         if (old_backing_drv == NULL) {
1673             error_report("Invalid format name: '%s'", bs->backing_format);
1674             ret = -1;
1675             goto out;
1676         }
1677     }
1678 
1679     if (out_basefmt != NULL) {
1680         new_backing_drv = bdrv_find_format(out_basefmt);
1681         if (new_backing_drv == NULL) {
1682             error_report("Invalid format name: '%s'", out_basefmt);
1683             ret = -1;
1684             goto out;
1685         }
1686     }
1687 
1688     /* For safe rebasing we need to compare old and new backing file */
1689     if (unsafe) {
1690         /* Make the compiler happy */
1691         bs_old_backing = NULL;
1692         bs_new_backing = NULL;
1693     } else {
1694         char backing_name[1024];
1695 
1696         bs_old_backing = bdrv_new("old_backing");
1697         bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1698         ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1699                         old_backing_drv);
1700         if (ret) {
1701             error_report("Could not open old backing file '%s'", backing_name);
1702             goto out;
1703         }
1704         if (out_baseimg[0]) {
1705             bs_new_backing = bdrv_new("new_backing");
1706             ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1707                         new_backing_drv);
1708             if (ret) {
1709                 error_report("Could not open new backing file '%s'",
1710                              out_baseimg);
1711                 goto out;
1712             }
1713         }
1714     }
1715 
1716     /*
1717      * Check each unallocated cluster in the COW file. If it is unallocated,
1718      * accesses go to the backing file. We must therefore compare this cluster
1719      * in the old and new backing file, and if they differ we need to copy it
1720      * from the old backing file into the COW file.
1721      *
1722      * If qemu-img crashes during this step, no harm is done. The content of
1723      * the image is the same as the original one at any time.
1724      */
1725     if (!unsafe) {
1726         uint64_t num_sectors;
1727         uint64_t old_backing_num_sectors;
1728         uint64_t new_backing_num_sectors = 0;
1729         uint64_t sector;
1730         int n;
1731         uint8_t * buf_old;
1732         uint8_t * buf_new;
1733         float local_progress = 0;
1734 
1735         buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1736         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
1737 
1738         bdrv_get_geometry(bs, &num_sectors);
1739         bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1740         if (bs_new_backing) {
1741             bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
1742         }
1743 
1744         if (num_sectors != 0) {
1745             local_progress = (float)100 /
1746                 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1747         }
1748 
1749         for (sector = 0; sector < num_sectors; sector += n) {
1750 
1751             /* How many sectors can we handle with the next read? */
1752             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1753                 n = (IO_BUF_SIZE / 512);
1754             } else {
1755                 n = num_sectors - sector;
1756             }
1757 
1758             /* If the cluster is allocated, we don't need to take action */
1759             ret = bdrv_is_allocated(bs, sector, n, &n);
1760             if (ret) {
1761                 continue;
1762             }
1763 
1764             /*
1765              * Read old and new backing file and take into consideration that
1766              * backing files may be smaller than the COW image.
1767              */
1768             if (sector >= old_backing_num_sectors) {
1769                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
1770             } else {
1771                 if (sector + n > old_backing_num_sectors) {
1772                     n = old_backing_num_sectors - sector;
1773                 }
1774 
1775                 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1776                 if (ret < 0) {
1777                     error_report("error while reading from old backing file");
1778                     goto out;
1779                 }
1780             }
1781 
1782             if (sector >= new_backing_num_sectors || !bs_new_backing) {
1783                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
1784             } else {
1785                 if (sector + n > new_backing_num_sectors) {
1786                     n = new_backing_num_sectors - sector;
1787                 }
1788 
1789                 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1790                 if (ret < 0) {
1791                     error_report("error while reading from new backing file");
1792                     goto out;
1793                 }
1794             }
1795 
1796             /* If they differ, we need to write to the COW file */
1797             uint64_t written = 0;
1798 
1799             while (written < n) {
1800                 int pnum;
1801 
1802                 if (compare_sectors(buf_old + written * 512,
1803                     buf_new + written * 512, n - written, &pnum))
1804                 {
1805                     ret = bdrv_write(bs, sector + written,
1806                         buf_old + written * 512, pnum);
1807                     if (ret < 0) {
1808                         error_report("Error while writing to COW image: %s",
1809                             strerror(-ret));
1810                         goto out;
1811                     }
1812                 }
1813 
1814                 written += pnum;
1815             }
1816             qemu_progress_print(local_progress, 100);
1817         }
1818 
1819         qemu_vfree(buf_old);
1820         qemu_vfree(buf_new);
1821     }
1822 
1823     /*
1824      * Change the backing file. All clusters that are different from the old
1825      * backing file are overwritten in the COW file now, so the visible content
1826      * doesn't change when we switch the backing file.
1827      */
1828     if (out_baseimg && *out_baseimg) {
1829         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1830     } else {
1831         ret = bdrv_change_backing_file(bs, NULL, NULL);
1832     }
1833 
1834     if (ret == -ENOSPC) {
1835         error_report("Could not change the backing file to '%s': No "
1836                      "space left in the file header", out_baseimg);
1837     } else if (ret < 0) {
1838         error_report("Could not change the backing file to '%s': %s",
1839             out_baseimg, strerror(-ret));
1840     }
1841 
1842     qemu_progress_print(100, 0);
1843     /*
1844      * TODO At this point it is possible to check if any clusters that are
1845      * allocated in the COW file are the same in the backing file. If so, they
1846      * could be dropped from the COW file. Don't do this before switching the
1847      * backing file, in case of a crash this would lead to corruption.
1848      */
1849 out:
1850     qemu_progress_end();
1851     /* Cleanup */
1852     if (!unsafe) {
1853         if (bs_old_backing != NULL) {
1854             bdrv_delete(bs_old_backing);
1855         }
1856         if (bs_new_backing != NULL) {
1857             bdrv_delete(bs_new_backing);
1858         }
1859     }
1860 
1861     bdrv_delete(bs);
1862     if (ret) {
1863         return 1;
1864     }
1865     return 0;
1866 }
1867 
1868 static int img_resize(int argc, char **argv)
1869 {
1870     int c, ret, relative;
1871     const char *filename, *fmt, *size;
1872     int64_t n, total_size;
1873     BlockDriverState *bs = NULL;
1874     QemuOpts *param;
1875     static QemuOptsList resize_options = {
1876         .name = "resize_options",
1877         .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
1878         .desc = {
1879             {
1880                 .name = BLOCK_OPT_SIZE,
1881                 .type = QEMU_OPT_SIZE,
1882                 .help = "Virtual disk size"
1883             }, {
1884                 /* end of list */
1885             }
1886         },
1887     };
1888 
1889     /* Remove size from argv manually so that negative numbers are not treated
1890      * as options by getopt. */
1891     if (argc < 3) {
1892         help();
1893         return 1;
1894     }
1895 
1896     size = argv[--argc];
1897 
1898     /* Parse getopt arguments */
1899     fmt = NULL;
1900     for(;;) {
1901         c = getopt(argc, argv, "f:h");
1902         if (c == -1) {
1903             break;
1904         }
1905         switch(c) {
1906         case '?':
1907         case 'h':
1908             help();
1909             break;
1910         case 'f':
1911             fmt = optarg;
1912             break;
1913         }
1914     }
1915     if (optind >= argc) {
1916         help();
1917     }
1918     filename = argv[optind++];
1919 
1920     /* Choose grow, shrink, or absolute resize mode */
1921     switch (size[0]) {
1922     case '+':
1923         relative = 1;
1924         size++;
1925         break;
1926     case '-':
1927         relative = -1;
1928         size++;
1929         break;
1930     default:
1931         relative = 0;
1932         break;
1933     }
1934 
1935     /* Parse size */
1936     param = qemu_opts_create(&resize_options, NULL, 0, NULL);
1937     if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1938         /* Error message already printed when size parsing fails */
1939         ret = -1;
1940         qemu_opts_del(param);
1941         goto out;
1942     }
1943     n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
1944     qemu_opts_del(param);
1945 
1946     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1947     if (!bs) {
1948         ret = -1;
1949         goto out;
1950     }
1951 
1952     if (relative) {
1953         total_size = bdrv_getlength(bs) + n * relative;
1954     } else {
1955         total_size = n;
1956     }
1957     if (total_size <= 0) {
1958         error_report("New image size must be positive");
1959         ret = -1;
1960         goto out;
1961     }
1962 
1963     ret = bdrv_truncate(bs, total_size);
1964     switch (ret) {
1965     case 0:
1966         printf("Image resized.\n");
1967         break;
1968     case -ENOTSUP:
1969         error_report("This image does not support resize");
1970         break;
1971     case -EACCES:
1972         error_report("Image is read-only");
1973         break;
1974     default:
1975         error_report("Error resizing image (%d)", -ret);
1976         break;
1977     }
1978 out:
1979     if (bs) {
1980         bdrv_delete(bs);
1981     }
1982     if (ret) {
1983         return 1;
1984     }
1985     return 0;
1986 }
1987 
1988 static const img_cmd_t img_cmds[] = {
1989 #define DEF(option, callback, arg_string)        \
1990     { option, callback },
1991 #include "qemu-img-cmds.h"
1992 #undef DEF
1993 #undef GEN_DOCS
1994     { NULL, NULL, },
1995 };
1996 
1997 int main(int argc, char **argv)
1998 {
1999     const img_cmd_t *cmd;
2000     const char *cmdname;
2001 
2002     error_set_progname(argv[0]);
2003 
2004     qemu_init_main_loop();
2005     bdrv_init();
2006     if (argc < 2)
2007         help();
2008     cmdname = argv[1];
2009     argc--; argv++;
2010 
2011     /* find the command */
2012     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2013         if (!strcmp(cmdname, cmd->name)) {
2014             return cmd->handler(argc, argv);
2015         }
2016     }
2017 
2018     /* not found */
2019     help();
2020     return 0;
2021 }
2022