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