Merge remote branch 'mst/for_anthony' into staging
[qemu.git] / qemu-img.c
blobfa77ac0dbe87f6fb36d9e6a0b1abd62b752826a7
1 /*
2 * QEMU disk image utility
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include "qemu-common.h"
25 #include "qemu-option.h"
26 #include "osdep.h"
27 #include "sysemu.h"
28 #include "block_int.h"
29 #include <stdio.h>
31 #ifdef _WIN32
32 #include <windows.h>
33 #endif
35 typedef struct img_cmd_t {
36 const char *name;
37 int (*handler)(int argc, char **argv);
38 } img_cmd_t;
40 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
41 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43 static void GCC_FMT_ATTR(1, 2) error(const char *fmt, ...)
45 va_list ap;
46 va_start(ap, fmt);
47 fprintf(stderr, "qemu-img: ");
48 vfprintf(stderr, fmt, ap);
49 fprintf(stderr, "\n");
50 va_end(ap);
53 static void format_print(void *opaque, const char *name)
55 printf(" %s", name);
58 /* Please keep in synch with qemu-img.texi */
59 static void help(void)
61 const char *help_msg =
62 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
63 "usage: qemu-img command [command options]\n"
64 "QEMU disk image utility\n"
65 "\n"
66 "Command syntax:\n"
67 #define DEF(option, callback, arg_string) \
68 " " arg_string "\n"
69 #include "qemu-img-cmds.h"
70 #undef DEF
71 #undef GEN_DOCS
72 "\n"
73 "Command parameters:\n"
74 " 'filename' is a disk image filename\n"
75 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
76 " 'size' is the disk image size in bytes. Optional suffixes\n"
77 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
78 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
79 " 'output_filename' is the destination disk image filename\n"
80 " 'output_fmt' is the destination format\n"
81 " 'options' is a comma separated list of format specific options in a\n"
82 " name=value format. Use -o ? for an overview of the options supported by the\n"
83 " used format\n"
84 " '-c' indicates that target image must be compressed (qcow format only)\n"
85 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
86 " match exactly. The image doesn't need a working backing file before\n"
87 " rebasing in this case (useful for renaming the backing file)\n"
88 " '-h' with or without a command shows this help and lists the supported formats\n"
89 "\n"
90 "Parameters to snapshot subcommand:\n"
91 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
92 " '-a' applies a snapshot (revert disk to saved state)\n"
93 " '-c' creates a snapshot\n"
94 " '-d' deletes a snapshot\n"
95 " '-l' lists all snapshots in the given image\n";
97 printf("%s\nSupported formats:", help_msg);
98 bdrv_iterate_format(format_print, NULL);
99 printf("\n");
100 exit(1);
103 #if defined(WIN32)
104 /* XXX: put correct support for win32 */
105 static int read_password(char *buf, int buf_size)
107 int c, i;
108 printf("Password: ");
109 fflush(stdout);
110 i = 0;
111 for(;;) {
112 c = getchar();
113 if (c == '\n')
114 break;
115 if (i < (buf_size - 1))
116 buf[i++] = c;
118 buf[i] = '\0';
119 return 0;
122 #else
124 #include <termios.h>
126 static struct termios oldtty;
128 static void term_exit(void)
130 tcsetattr (0, TCSANOW, &oldtty);
133 static void term_init(void)
135 struct termios tty;
137 tcgetattr (0, &tty);
138 oldtty = tty;
140 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
141 |INLCR|IGNCR|ICRNL|IXON);
142 tty.c_oflag |= OPOST;
143 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
144 tty.c_cflag &= ~(CSIZE|PARENB);
145 tty.c_cflag |= CS8;
146 tty.c_cc[VMIN] = 1;
147 tty.c_cc[VTIME] = 0;
149 tcsetattr (0, TCSANOW, &tty);
151 atexit(term_exit);
154 static int read_password(char *buf, int buf_size)
156 uint8_t ch;
157 int i, ret;
159 printf("password: ");
160 fflush(stdout);
161 term_init();
162 i = 0;
163 for(;;) {
164 ret = read(0, &ch, 1);
165 if (ret == -1) {
166 if (errno == EAGAIN || errno == EINTR) {
167 continue;
168 } else {
169 ret = -1;
170 break;
172 } else if (ret == 0) {
173 ret = -1;
174 break;
175 } else {
176 if (ch == '\r') {
177 ret = 0;
178 break;
180 if (i < (buf_size - 1))
181 buf[i++] = ch;
184 term_exit();
185 buf[i] = '\0';
186 printf("\n");
187 return ret;
189 #endif
191 static BlockDriverState *bdrv_new_open(const char *filename,
192 const char *fmt,
193 int flags)
195 BlockDriverState *bs;
196 BlockDriver *drv;
197 char password[256];
199 bs = bdrv_new("");
200 if (!bs) {
201 error("Not enough memory");
202 goto fail;
204 if (fmt) {
205 drv = bdrv_find_format(fmt);
206 if (!drv) {
207 error("Unknown file format '%s'", fmt);
208 goto fail;
210 } else {
211 drv = NULL;
213 if (bdrv_open(bs, filename, flags, drv) < 0) {
214 error("Could not open '%s'", filename);
215 goto fail;
217 if (bdrv_is_encrypted(bs)) {
218 printf("Disk image '%s' is encrypted.\n", filename);
219 if (read_password(password, sizeof(password)) < 0) {
220 error("No password given");
221 goto fail;
223 if (bdrv_set_key(bs, password) < 0) {
224 error("invalid password");
225 goto fail;
228 return bs;
229 fail:
230 if (bs) {
231 bdrv_delete(bs);
233 return NULL;
236 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
237 int flags, const char *base_filename, const char *base_fmt)
239 if (flags & BLOCK_FLAG_ENCRYPT) {
240 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
241 error("Encryption not supported for file format '%s'", fmt);
242 return -1;
245 if (flags & BLOCK_FLAG_COMPAT6) {
246 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
247 error("VMDK version 6 not supported for file format '%s'", fmt);
248 return -1;
252 if (base_filename) {
253 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
254 error("Backing file not supported for file format '%s'", fmt);
255 return -1;
258 if (base_fmt) {
259 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
260 error("Backing file format not supported for file format '%s'", fmt);
261 return -1;
264 return 0;
267 static int img_create(int argc, char **argv)
269 int c, ret = 0, flags;
270 const char *fmt = "raw";
271 const char *base_fmt = NULL;
272 const char *filename;
273 const char *base_filename = NULL;
274 BlockDriver *drv, *proto_drv;
275 QEMUOptionParameter *param = NULL, *create_options = NULL;
276 char *options = NULL;
278 flags = 0;
279 for(;;) {
280 c = getopt(argc, argv, "F:b:f:he6o:");
281 if (c == -1)
282 break;
283 switch(c) {
284 case 'h':
285 help();
286 break;
287 case 'F':
288 base_fmt = optarg;
289 break;
290 case 'b':
291 base_filename = optarg;
292 break;
293 case 'f':
294 fmt = optarg;
295 break;
296 case 'e':
297 flags |= BLOCK_FLAG_ENCRYPT;
298 break;
299 case '6':
300 flags |= BLOCK_FLAG_COMPAT6;
301 break;
302 case 'o':
303 options = optarg;
304 break;
308 /* Get the filename */
309 if (optind >= argc)
310 help();
311 filename = argv[optind++];
313 /* Find driver and parse its options */
314 drv = bdrv_find_format(fmt);
315 if (!drv) {
316 error("Unknown file format '%s'", fmt);
317 return 1;
320 proto_drv = bdrv_find_protocol(filename);
321 if (!proto_drv) {
322 error("Unknown protocol '%s'", filename);
323 return 1;
326 create_options = append_option_parameters(create_options,
327 drv->create_options);
328 create_options = append_option_parameters(create_options,
329 proto_drv->create_options);
331 if (options && !strcmp(options, "?")) {
332 print_option_help(create_options);
333 goto out;
336 /* Create parameter list with default values */
337 param = parse_option_parameters("", create_options, param);
338 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
340 /* Parse -o options */
341 if (options) {
342 param = parse_option_parameters(options, create_options, param);
343 if (param == NULL) {
344 error("Invalid options for file format '%s'.", fmt);
345 ret = -1;
346 goto out;
350 /* Add size to parameters */
351 if (optind < argc) {
352 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
355 /* Add old-style options to parameters */
356 ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
357 if (ret < 0) {
358 goto out;
361 // The size for the image must always be specified, with one exception:
362 // If we are using a backing file, we can obtain the size from there
363 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
365 QEMUOptionParameter *backing_file =
366 get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
367 QEMUOptionParameter *backing_fmt =
368 get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
370 if (backing_file && backing_file->value.s) {
371 BlockDriverState *bs;
372 uint64_t size;
373 const char *fmt = NULL;
374 char buf[32];
376 if (backing_fmt && backing_fmt->value.s) {
377 if (bdrv_find_format(backing_fmt->value.s)) {
378 fmt = backing_fmt->value.s;
379 } else {
380 error("Unknown backing file format '%s'",
381 backing_fmt->value.s);
382 ret = -1;
383 goto out;
387 bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
388 if (!bs) {
389 ret = -1;
390 goto out;
392 bdrv_get_geometry(bs, &size);
393 size *= 512;
394 bdrv_delete(bs);
396 snprintf(buf, sizeof(buf), "%" PRId64, size);
397 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
398 } else {
399 error("Image creation needs a size parameter");
400 ret = -1;
401 goto out;
405 printf("Formatting '%s', fmt=%s ", filename, fmt);
406 print_option_parameters(param);
407 puts("");
409 ret = bdrv_create(drv, filename, param);
410 free_option_parameters(create_options);
411 free_option_parameters(param);
413 if (ret < 0) {
414 if (ret == -ENOTSUP) {
415 error("Formatting or formatting option not supported for file format '%s'", fmt);
416 } else if (ret == -EFBIG) {
417 error("The image size is too large for file format '%s'", fmt);
418 } else {
419 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
422 out:
423 if (ret) {
424 return 1;
426 return 0;
430 * Checks an image for consistency. Exit codes:
432 * 0 - Check completed, image is good
433 * 1 - Check not completed because of internal errors
434 * 2 - Check completed, image is corrupted
435 * 3 - Check completed, image has leaked clusters, but is good otherwise
437 static int img_check(int argc, char **argv)
439 int c, ret;
440 const char *filename, *fmt;
441 BlockDriverState *bs;
442 BdrvCheckResult result;
444 fmt = NULL;
445 for(;;) {
446 c = getopt(argc, argv, "f:h");
447 if (c == -1)
448 break;
449 switch(c) {
450 case 'h':
451 help();
452 break;
453 case 'f':
454 fmt = optarg;
455 break;
458 if (optind >= argc)
459 help();
460 filename = argv[optind++];
462 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
463 if (!bs) {
464 return 1;
466 ret = bdrv_check(bs, &result);
468 if (ret == -ENOTSUP) {
469 error("This image format does not support checks");
470 bdrv_delete(bs);
471 return 1;
474 if (!(result.corruptions || result.leaks || result.check_errors)) {
475 printf("No errors were found on the image.\n");
476 } else {
477 if (result.corruptions) {
478 printf("\n%d errors were found on the image.\n"
479 "Data may be corrupted, or further writes to the image "
480 "may corrupt it.\n",
481 result.corruptions);
484 if (result.leaks) {
485 printf("\n%d leaked clusters were found on the image.\n"
486 "This means waste of disk space, but no harm to data.\n",
487 result.leaks);
490 if (result.check_errors) {
491 printf("\n%d internal errors have occurred during the check.\n",
492 result.check_errors);
496 bdrv_delete(bs);
498 if (ret < 0 || result.check_errors) {
499 printf("\nAn error has occurred during the check: %s\n"
500 "The check is not complete and may have missed error.\n",
501 strerror(-ret));
502 return 1;
505 if (result.corruptions) {
506 return 2;
507 } else if (result.leaks) {
508 return 3;
509 } else {
510 return 0;
514 static int img_commit(int argc, char **argv)
516 int c, ret;
517 const char *filename, *fmt;
518 BlockDriverState *bs;
520 fmt = NULL;
521 for(;;) {
522 c = getopt(argc, argv, "f:h");
523 if (c == -1)
524 break;
525 switch(c) {
526 case 'h':
527 help();
528 break;
529 case 'f':
530 fmt = optarg;
531 break;
534 if (optind >= argc)
535 help();
536 filename = argv[optind++];
538 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
539 if (!bs) {
540 return 1;
542 ret = bdrv_commit(bs);
543 switch(ret) {
544 case 0:
545 printf("Image committed.\n");
546 break;
547 case -ENOENT:
548 error("No disk inserted");
549 break;
550 case -EACCES:
551 error("Image is read-only");
552 break;
553 case -ENOTSUP:
554 error("Image is already committed");
555 break;
556 default:
557 error("Error while committing image");
558 break;
561 bdrv_delete(bs);
562 if (ret) {
563 return 1;
565 return 0;
568 static int is_not_zero(const uint8_t *sector, int len)
570 int i;
571 len >>= 2;
572 for(i = 0;i < len; i++) {
573 if (((uint32_t *)sector)[i] != 0)
574 return 1;
576 return 0;
580 * Returns true iff the first sector pointed to by 'buf' contains at least
581 * a non-NUL byte.
583 * 'pnum' is set to the number of sectors (including and immediately following
584 * the first one) that are known to be in the same allocated/unallocated state.
586 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
588 int v, i;
590 if (n <= 0) {
591 *pnum = 0;
592 return 0;
594 v = is_not_zero(buf, 512);
595 for(i = 1; i < n; i++) {
596 buf += 512;
597 if (v != is_not_zero(buf, 512))
598 break;
600 *pnum = i;
601 return v;
605 * Compares two buffers sector by sector. Returns 0 if the first sector of both
606 * buffers matches, non-zero otherwise.
608 * pnum is set to the number of sectors (including and immediately following
609 * the first one) that are known to have the same comparison result
611 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
612 int *pnum)
614 int res, i;
616 if (n <= 0) {
617 *pnum = 0;
618 return 0;
621 res = !!memcmp(buf1, buf2, 512);
622 for(i = 1; i < n; i++) {
623 buf1 += 512;
624 buf2 += 512;
626 if (!!memcmp(buf1, buf2, 512) != res) {
627 break;
631 *pnum = i;
632 return res;
635 #define IO_BUF_SIZE (2 * 1024 * 1024)
637 static int img_convert(int argc, char **argv)
639 int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
640 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
641 BlockDriver *drv, *proto_drv;
642 BlockDriverState **bs = NULL, *out_bs = NULL;
643 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
644 uint64_t bs_sectors;
645 uint8_t * buf = NULL;
646 const uint8_t *buf1;
647 BlockDriverInfo bdi;
648 QEMUOptionParameter *param = NULL, *create_options = NULL;
649 QEMUOptionParameter *out_baseimg_param;
650 char *options = NULL;
651 const char *snapshot_name = NULL;
653 fmt = NULL;
654 out_fmt = "raw";
655 out_baseimg = NULL;
656 flags = 0;
657 for(;;) {
658 c = getopt(argc, argv, "f:O:B:s:hce6o:");
659 if (c == -1)
660 break;
661 switch(c) {
662 case 'h':
663 help();
664 break;
665 case 'f':
666 fmt = optarg;
667 break;
668 case 'O':
669 out_fmt = optarg;
670 break;
671 case 'B':
672 out_baseimg = optarg;
673 break;
674 case 'c':
675 flags |= BLOCK_FLAG_COMPRESS;
676 break;
677 case 'e':
678 flags |= BLOCK_FLAG_ENCRYPT;
679 break;
680 case '6':
681 flags |= BLOCK_FLAG_COMPAT6;
682 break;
683 case 'o':
684 options = optarg;
685 break;
686 case 's':
687 snapshot_name = optarg;
688 break;
692 bs_n = argc - optind - 1;
693 if (bs_n < 1) help();
695 out_filename = argv[argc - 1];
697 if (bs_n > 1 && out_baseimg) {
698 error("-B makes no sense when concatenating multiple input images");
699 return 1;
702 bs = calloc(bs_n, sizeof(BlockDriverState *));
703 if (!bs) {
704 error("Out of memory");
705 return 1;
708 total_sectors = 0;
709 for (bs_i = 0; bs_i < bs_n; bs_i++) {
710 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
711 if (!bs[bs_i]) {
712 error("Could not open '%s'", argv[optind + bs_i]);
713 ret = -1;
714 goto out;
716 bdrv_get_geometry(bs[bs_i], &bs_sectors);
717 total_sectors += bs_sectors;
720 if (snapshot_name != NULL) {
721 if (bs_n > 1) {
722 error("No support for concatenating multiple snapshot\n");
723 ret = -1;
724 goto out;
726 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
727 error("Failed to load snapshot\n");
728 ret = -1;
729 goto out;
733 /* Find driver and parse its options */
734 drv = bdrv_find_format(out_fmt);
735 if (!drv) {
736 error("Unknown file format '%s'", out_fmt);
737 ret = -1;
738 goto out;
741 proto_drv = bdrv_find_protocol(out_filename);
742 if (!proto_drv) {
743 error("Unknown protocol '%s'", out_filename);
744 ret = -1;
745 goto out;
748 create_options = append_option_parameters(create_options,
749 drv->create_options);
750 create_options = append_option_parameters(create_options,
751 proto_drv->create_options);
752 if (options && !strcmp(options, "?")) {
753 print_option_help(create_options);
754 goto out;
757 if (options) {
758 param = parse_option_parameters(options, create_options, param);
759 if (param == NULL) {
760 error("Invalid options for file format '%s'.", out_fmt);
761 ret = -1;
762 goto out;
764 } else {
765 param = parse_option_parameters("", create_options, param);
768 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
769 ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
770 if (ret < 0) {
771 goto out;
774 /* Get backing file name if -o backing_file was used */
775 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
776 if (out_baseimg_param) {
777 out_baseimg = out_baseimg_param->value.s;
780 /* Check if compression is supported */
781 if (flags & BLOCK_FLAG_COMPRESS) {
782 QEMUOptionParameter *encryption =
783 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
785 if (!drv->bdrv_write_compressed) {
786 error("Compression not supported for this file format");
787 ret = -1;
788 goto out;
791 if (encryption && encryption->value.n) {
792 error("Compression and encryption not supported at the same time");
793 ret = -1;
794 goto out;
798 /* Create the new image */
799 ret = bdrv_create(drv, out_filename, param);
800 if (ret < 0) {
801 if (ret == -ENOTSUP) {
802 error("Formatting not supported for file format '%s'", out_fmt);
803 } else if (ret == -EFBIG) {
804 error("The image size is too large for file format '%s'", out_fmt);
805 } else {
806 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
808 goto out;
811 out_bs = bdrv_new_open(out_filename, out_fmt,
812 BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
813 if (!out_bs) {
814 ret = -1;
815 goto out;
818 bs_i = 0;
819 bs_offset = 0;
820 bdrv_get_geometry(bs[0], &bs_sectors);
821 buf = qemu_malloc(IO_BUF_SIZE);
823 if (flags & BLOCK_FLAG_COMPRESS) {
824 ret = bdrv_get_info(out_bs, &bdi);
825 if (ret < 0) {
826 error("could not get block driver info");
827 goto out;
829 cluster_size = bdi.cluster_size;
830 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
831 error("invalid cluster size");
832 ret = -1;
833 goto out;
835 cluster_sectors = cluster_size >> 9;
836 sector_num = 0;
837 for(;;) {
838 int64_t bs_num;
839 int remainder;
840 uint8_t *buf2;
842 nb_sectors = total_sectors - sector_num;
843 if (nb_sectors <= 0)
844 break;
845 if (nb_sectors >= cluster_sectors)
846 n = cluster_sectors;
847 else
848 n = nb_sectors;
850 bs_num = sector_num - bs_offset;
851 assert (bs_num >= 0);
852 remainder = n;
853 buf2 = buf;
854 while (remainder > 0) {
855 int nlow;
856 while (bs_num == bs_sectors) {
857 bs_i++;
858 assert (bs_i < bs_n);
859 bs_offset += bs_sectors;
860 bdrv_get_geometry(bs[bs_i], &bs_sectors);
861 bs_num = 0;
862 /* printf("changing part: sector_num=%" PRId64 ", "
863 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
864 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
866 assert (bs_num < bs_sectors);
868 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
870 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
871 if (ret < 0) {
872 error("error while reading");
873 goto out;
876 buf2 += nlow * 512;
877 bs_num += nlow;
879 remainder -= nlow;
881 assert (remainder == 0);
883 if (n < cluster_sectors)
884 memset(buf + n * 512, 0, cluster_size - n * 512);
885 if (is_not_zero(buf, cluster_size)) {
886 ret = bdrv_write_compressed(out_bs, sector_num, buf,
887 cluster_sectors);
888 if (ret != 0) {
889 error("error while compressing sector %" PRId64,
890 sector_num);
891 goto out;
894 sector_num += n;
896 /* signal EOF to align */
897 bdrv_write_compressed(out_bs, 0, NULL, 0);
898 } else {
899 int has_zero_init = bdrv_has_zero_init(out_bs);
901 sector_num = 0; // total number of sectors converted so far
902 for(;;) {
903 nb_sectors = total_sectors - sector_num;
904 if (nb_sectors <= 0)
905 break;
906 if (nb_sectors >= (IO_BUF_SIZE / 512))
907 n = (IO_BUF_SIZE / 512);
908 else
909 n = nb_sectors;
911 while (sector_num - bs_offset >= bs_sectors) {
912 bs_i ++;
913 assert (bs_i < bs_n);
914 bs_offset += bs_sectors;
915 bdrv_get_geometry(bs[bs_i], &bs_sectors);
916 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
917 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
918 sector_num, bs_i, bs_offset, bs_sectors); */
921 if (n > bs_offset + bs_sectors - sector_num)
922 n = bs_offset + bs_sectors - sector_num;
924 if (has_zero_init) {
925 /* If the output image is being created as a copy on write image,
926 assume that sectors which are unallocated in the input image
927 are present in both the output's and input's base images (no
928 need to copy them). */
929 if (out_baseimg) {
930 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
931 n, &n1)) {
932 sector_num += n1;
933 continue;
935 /* The next 'n1' sectors are allocated in the input image. Copy
936 only those as they may be followed by unallocated sectors. */
937 n = n1;
939 } else {
940 n1 = n;
943 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
944 if (ret < 0) {
945 error("error while reading");
946 goto out;
948 /* NOTE: at the same time we convert, we do not write zero
949 sectors to have a chance to compress the image. Ideally, we
950 should add a specific call to have the info to go faster */
951 buf1 = buf;
952 while (n > 0) {
953 /* If the output image is being created as a copy on write image,
954 copy all sectors even the ones containing only NUL bytes,
955 because they may differ from the sectors in the base image.
957 If the output is to a host device, we also write out
958 sectors that are entirely 0, since whatever data was
959 already there is garbage, not 0s. */
960 if (!has_zero_init || out_baseimg ||
961 is_allocated_sectors(buf1, n, &n1)) {
962 ret = bdrv_write(out_bs, sector_num, buf1, n1);
963 if (ret < 0) {
964 error("error while writing");
965 goto out;
968 sector_num += n1;
969 n -= n1;
970 buf1 += n1 * 512;
974 out:
975 free_option_parameters(create_options);
976 free_option_parameters(param);
977 qemu_free(buf);
978 if (out_bs) {
979 bdrv_delete(out_bs);
981 for (bs_i = 0; bs_i < bs_n; bs_i++) {
982 if (bs[bs_i]) {
983 bdrv_delete(bs[bs_i]);
986 free(bs);
987 if (ret) {
988 return 1;
990 return 0;
993 #ifdef _WIN32
994 static int64_t get_allocated_file_size(const char *filename)
996 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
997 get_compressed_t get_compressed;
998 struct _stati64 st;
1000 /* WinNT support GetCompressedFileSize to determine allocate size */
1001 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1002 if (get_compressed) {
1003 DWORD high, low;
1004 low = get_compressed(filename, &high);
1005 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
1006 return (((int64_t) high) << 32) + low;
1009 if (_stati64(filename, &st) < 0)
1010 return -1;
1011 return st.st_size;
1013 #else
1014 static int64_t get_allocated_file_size(const char *filename)
1016 struct stat st;
1017 if (stat(filename, &st) < 0)
1018 return -1;
1019 return (int64_t)st.st_blocks * 512;
1021 #endif
1023 static void dump_snapshots(BlockDriverState *bs)
1025 QEMUSnapshotInfo *sn_tab, *sn;
1026 int nb_sns, i;
1027 char buf[256];
1029 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1030 if (nb_sns <= 0)
1031 return;
1032 printf("Snapshot list:\n");
1033 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1034 for(i = 0; i < nb_sns; i++) {
1035 sn = &sn_tab[i];
1036 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1038 qemu_free(sn_tab);
1041 static int img_info(int argc, char **argv)
1043 int c;
1044 const char *filename, *fmt;
1045 BlockDriverState *bs;
1046 char fmt_name[128], size_buf[128], dsize_buf[128];
1047 uint64_t total_sectors;
1048 int64_t allocated_size;
1049 char backing_filename[1024];
1050 char backing_filename2[1024];
1051 BlockDriverInfo bdi;
1053 fmt = NULL;
1054 for(;;) {
1055 c = getopt(argc, argv, "f:h");
1056 if (c == -1)
1057 break;
1058 switch(c) {
1059 case 'h':
1060 help();
1061 break;
1062 case 'f':
1063 fmt = optarg;
1064 break;
1067 if (optind >= argc)
1068 help();
1069 filename = argv[optind++];
1071 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1072 if (!bs) {
1073 return 1;
1075 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1076 bdrv_get_geometry(bs, &total_sectors);
1077 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1078 allocated_size = get_allocated_file_size(filename);
1079 if (allocated_size < 0)
1080 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1081 else
1082 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1083 allocated_size);
1084 printf("image: %s\n"
1085 "file format: %s\n"
1086 "virtual size: %s (%" PRId64 " bytes)\n"
1087 "disk size: %s\n",
1088 filename, fmt_name, size_buf,
1089 (total_sectors * 512),
1090 dsize_buf);
1091 if (bdrv_is_encrypted(bs))
1092 printf("encrypted: yes\n");
1093 if (bdrv_get_info(bs, &bdi) >= 0) {
1094 if (bdi.cluster_size != 0)
1095 printf("cluster_size: %d\n", bdi.cluster_size);
1097 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1098 if (backing_filename[0] != '\0') {
1099 path_combine(backing_filename2, sizeof(backing_filename2),
1100 filename, backing_filename);
1101 printf("backing file: %s (actual path: %s)\n",
1102 backing_filename,
1103 backing_filename2);
1105 dump_snapshots(bs);
1106 bdrv_delete(bs);
1107 return 0;
1110 #define SNAPSHOT_LIST 1
1111 #define SNAPSHOT_CREATE 2
1112 #define SNAPSHOT_APPLY 3
1113 #define SNAPSHOT_DELETE 4
1115 static int img_snapshot(int argc, char **argv)
1117 BlockDriverState *bs;
1118 QEMUSnapshotInfo sn;
1119 char *filename, *snapshot_name = NULL;
1120 int c, ret = 0, bdrv_oflags;
1121 int action = 0;
1122 qemu_timeval tv;
1124 bdrv_oflags = BDRV_O_RDWR;
1125 /* Parse commandline parameters */
1126 for(;;) {
1127 c = getopt(argc, argv, "la:c:d:h");
1128 if (c == -1)
1129 break;
1130 switch(c) {
1131 case 'h':
1132 help();
1133 return 0;
1134 case 'l':
1135 if (action) {
1136 help();
1137 return 0;
1139 action = SNAPSHOT_LIST;
1140 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1141 break;
1142 case 'a':
1143 if (action) {
1144 help();
1145 return 0;
1147 action = SNAPSHOT_APPLY;
1148 snapshot_name = optarg;
1149 break;
1150 case 'c':
1151 if (action) {
1152 help();
1153 return 0;
1155 action = SNAPSHOT_CREATE;
1156 snapshot_name = optarg;
1157 break;
1158 case 'd':
1159 if (action) {
1160 help();
1161 return 0;
1163 action = SNAPSHOT_DELETE;
1164 snapshot_name = optarg;
1165 break;
1169 if (optind >= argc)
1170 help();
1171 filename = argv[optind++];
1173 /* Open the image */
1174 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1175 if (!bs) {
1176 return 1;
1179 /* Perform the requested action */
1180 switch(action) {
1181 case SNAPSHOT_LIST:
1182 dump_snapshots(bs);
1183 break;
1185 case SNAPSHOT_CREATE:
1186 memset(&sn, 0, sizeof(sn));
1187 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1189 qemu_gettimeofday(&tv);
1190 sn.date_sec = tv.tv_sec;
1191 sn.date_nsec = tv.tv_usec * 1000;
1193 ret = bdrv_snapshot_create(bs, &sn);
1194 if (ret)
1195 error("Could not create snapshot '%s': %d (%s)",
1196 snapshot_name, ret, strerror(-ret));
1197 break;
1199 case SNAPSHOT_APPLY:
1200 ret = bdrv_snapshot_goto(bs, snapshot_name);
1201 if (ret)
1202 error("Could not apply snapshot '%s': %d (%s)",
1203 snapshot_name, ret, strerror(-ret));
1204 break;
1206 case SNAPSHOT_DELETE:
1207 ret = bdrv_snapshot_delete(bs, snapshot_name);
1208 if (ret)
1209 error("Could not delete snapshot '%s': %d (%s)",
1210 snapshot_name, ret, strerror(-ret));
1211 break;
1214 /* Cleanup */
1215 bdrv_delete(bs);
1216 if (ret) {
1217 return 1;
1219 return 0;
1222 static int img_rebase(int argc, char **argv)
1224 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1225 BlockDriver *old_backing_drv, *new_backing_drv;
1226 char *filename;
1227 const char *fmt, *out_basefmt, *out_baseimg;
1228 int c, flags, ret;
1229 int unsafe = 0;
1231 /* Parse commandline parameters */
1232 fmt = NULL;
1233 out_baseimg = NULL;
1234 out_basefmt = NULL;
1236 for(;;) {
1237 c = getopt(argc, argv, "uhf:F:b:");
1238 if (c == -1)
1239 break;
1240 switch(c) {
1241 case 'h':
1242 help();
1243 return 0;
1244 case 'f':
1245 fmt = optarg;
1246 break;
1247 case 'F':
1248 out_basefmt = optarg;
1249 break;
1250 case 'b':
1251 out_baseimg = optarg;
1252 break;
1253 case 'u':
1254 unsafe = 1;
1255 break;
1259 if ((optind >= argc) || !out_baseimg)
1260 help();
1261 filename = argv[optind++];
1264 * Open the images.
1266 * Ignore the old backing file for unsafe rebase in case we want to correct
1267 * the reference to a renamed or moved backing file.
1269 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1270 bs = bdrv_new_open(filename, fmt, flags);
1271 if (!bs) {
1272 return 1;
1275 /* Find the right drivers for the backing files */
1276 old_backing_drv = NULL;
1277 new_backing_drv = NULL;
1279 if (!unsafe && bs->backing_format[0] != '\0') {
1280 old_backing_drv = bdrv_find_format(bs->backing_format);
1281 if (old_backing_drv == NULL) {
1282 error("Invalid format name: '%s'", bs->backing_format);
1283 ret = -1;
1284 goto out;
1288 if (out_basefmt != NULL) {
1289 new_backing_drv = bdrv_find_format(out_basefmt);
1290 if (new_backing_drv == NULL) {
1291 error("Invalid format name: '%s'", out_basefmt);
1292 ret = -1;
1293 goto out;
1297 /* For safe rebasing we need to compare old and new backing file */
1298 if (unsafe) {
1299 /* Make the compiler happy */
1300 bs_old_backing = NULL;
1301 bs_new_backing = NULL;
1302 } else {
1303 char backing_name[1024];
1305 bs_old_backing = bdrv_new("old_backing");
1306 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1307 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1308 old_backing_drv);
1309 if (ret) {
1310 error("Could not open old backing file '%s'", backing_name);
1311 goto out;
1314 bs_new_backing = bdrv_new("new_backing");
1315 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1316 new_backing_drv);
1317 if (ret) {
1318 error("Could not open new backing file '%s'", out_baseimg);
1319 goto out;
1324 * Check each unallocated cluster in the COW file. If it is unallocated,
1325 * accesses go to the backing file. We must therefore compare this cluster
1326 * in the old and new backing file, and if they differ we need to copy it
1327 * from the old backing file into the COW file.
1329 * If qemu-img crashes during this step, no harm is done. The content of
1330 * the image is the same as the original one at any time.
1332 if (!unsafe) {
1333 uint64_t num_sectors;
1334 uint64_t sector;
1335 int n;
1336 uint8_t * buf_old;
1337 uint8_t * buf_new;
1339 buf_old = qemu_malloc(IO_BUF_SIZE);
1340 buf_new = qemu_malloc(IO_BUF_SIZE);
1342 bdrv_get_geometry(bs, &num_sectors);
1344 for (sector = 0; sector < num_sectors; sector += n) {
1346 /* How many sectors can we handle with the next read? */
1347 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1348 n = (IO_BUF_SIZE / 512);
1349 } else {
1350 n = num_sectors - sector;
1353 /* If the cluster is allocated, we don't need to take action */
1354 ret = bdrv_is_allocated(bs, sector, n, &n);
1355 if (ret) {
1356 continue;
1359 /* Read old and new backing file */
1360 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1361 if (ret < 0) {
1362 error("error while reading from old backing file");
1363 goto out;
1365 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1366 if (ret < 0) {
1367 error("error while reading from new backing file");
1368 goto out;
1371 /* If they differ, we need to write to the COW file */
1372 uint64_t written = 0;
1374 while (written < n) {
1375 int pnum;
1377 if (compare_sectors(buf_old + written * 512,
1378 buf_new + written * 512, n - written, &pnum))
1380 ret = bdrv_write(bs, sector + written,
1381 buf_old + written * 512, pnum);
1382 if (ret < 0) {
1383 error("Error while writing to COW image: %s",
1384 strerror(-ret));
1385 goto out;
1389 written += pnum;
1393 qemu_free(buf_old);
1394 qemu_free(buf_new);
1398 * Change the backing file. All clusters that are different from the old
1399 * backing file are overwritten in the COW file now, so the visible content
1400 * doesn't change when we switch the backing file.
1402 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1403 if (ret == -ENOSPC) {
1404 error("Could not change the backing file to '%s': No space left in "
1405 "the file header", out_baseimg);
1406 } else if (ret < 0) {
1407 error("Could not change the backing file to '%s': %s",
1408 out_baseimg, strerror(-ret));
1412 * TODO At this point it is possible to check if any clusters that are
1413 * allocated in the COW file are the same in the backing file. If so, they
1414 * could be dropped from the COW file. Don't do this before switching the
1415 * backing file, in case of a crash this would lead to corruption.
1417 out:
1418 /* Cleanup */
1419 if (!unsafe) {
1420 bdrv_delete(bs_old_backing);
1421 bdrv_delete(bs_new_backing);
1424 bdrv_delete(bs);
1425 if (ret) {
1426 return 1;
1428 return 0;
1431 static int img_resize(int argc, char **argv)
1433 int c, ret, relative;
1434 const char *filename, *fmt, *size;
1435 int64_t n, total_size;
1436 BlockDriverState *bs;
1437 QEMUOptionParameter *param;
1438 QEMUOptionParameter resize_options[] = {
1440 .name = BLOCK_OPT_SIZE,
1441 .type = OPT_SIZE,
1442 .help = "Virtual disk size"
1444 { NULL }
1447 fmt = NULL;
1448 for(;;) {
1449 c = getopt(argc, argv, "f:h");
1450 if (c == -1) {
1451 break;
1453 switch(c) {
1454 case 'h':
1455 help();
1456 break;
1457 case 'f':
1458 fmt = optarg;
1459 break;
1462 if (optind + 1 >= argc) {
1463 help();
1465 filename = argv[optind++];
1466 size = argv[optind++];
1468 /* Choose grow, shrink, or absolute resize mode */
1469 switch (size[0]) {
1470 case '+':
1471 relative = 1;
1472 size++;
1473 break;
1474 case '-':
1475 relative = -1;
1476 size++;
1477 break;
1478 default:
1479 relative = 0;
1480 break;
1483 /* Parse size */
1484 param = parse_option_parameters("", resize_options, NULL);
1485 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1486 /* Error message already printed when size parsing fails */
1487 exit(1);
1489 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1490 free_option_parameters(param);
1492 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1493 if (!bs) {
1494 return 1;
1497 if (relative) {
1498 total_size = bdrv_getlength(bs) + n * relative;
1499 } else {
1500 total_size = n;
1502 if (total_size <= 0) {
1503 error("New image size must be positive");
1504 ret = -1;
1505 goto out;
1508 ret = bdrv_truncate(bs, total_size);
1509 switch (ret) {
1510 case 0:
1511 printf("Image resized.\n");
1512 break;
1513 case -ENOTSUP:
1514 error("This image format does not support resize");
1515 break;
1516 case -EACCES:
1517 error("Image is read-only");
1518 break;
1519 default:
1520 error("Error resizing image (%d)", -ret);
1521 break;
1523 out:
1524 bdrv_delete(bs);
1525 if (ret) {
1526 return 1;
1528 return 0;
1531 static const img_cmd_t img_cmds[] = {
1532 #define DEF(option, callback, arg_string) \
1533 { option, callback },
1534 #include "qemu-img-cmds.h"
1535 #undef DEF
1536 #undef GEN_DOCS
1537 { NULL, NULL, },
1540 int main(int argc, char **argv)
1542 const img_cmd_t *cmd;
1543 const char *cmdname;
1545 bdrv_init();
1546 if (argc < 2)
1547 help();
1548 cmdname = argv[1];
1549 argc--; argv++;
1551 /* find the command */
1552 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1553 if (!strcmp(cmdname, cmd->name)) {
1554 return cmd->handler(argc, argv);
1558 /* not found */
1559 help();
1560 return 0;