Fix %lld or %llx printf format use
[qemu.git] / qemu-img.c
blobcb007b757dc68d1bd4cf03118917a9f743390593
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 "block_int.h"
28 #include <stdio.h>
30 #ifdef _WIN32
31 #include <windows.h>
32 #endif
34 typedef struct img_cmd_t {
35 const char *name;
36 int (*handler)(int argc, char **argv);
37 } img_cmd_t;
39 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
40 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
42 static void QEMU_NORETURN error(const char *fmt, ...)
44 va_list ap;
45 va_start(ap, fmt);
46 fprintf(stderr, "qemu-img: ");
47 vfprintf(stderr, fmt, ap);
48 fprintf(stderr, "\n");
49 exit(1);
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 if (fmt) {
203 drv = bdrv_find_format(fmt);
204 if (!drv)
205 error("Unknown file format '%s'", fmt);
206 } else {
207 drv = NULL;
209 if (bdrv_open(bs, filename, flags, drv) < 0) {
210 error("Could not open '%s'", filename);
212 if (bdrv_is_encrypted(bs)) {
213 printf("Disk image '%s' is encrypted.\n", filename);
214 if (read_password(password, sizeof(password)) < 0)
215 error("No password given");
216 if (bdrv_set_key(bs, password) < 0)
217 error("invalid password");
219 return bs;
222 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
223 int flags, const char *base_filename, const char *base_fmt)
225 if (flags & BLOCK_FLAG_ENCRYPT) {
226 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
227 error("Encryption not supported for file format '%s'", fmt);
230 if (flags & BLOCK_FLAG_COMPAT6) {
231 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
232 error("VMDK version 6 not supported for file format '%s'", fmt);
236 if (base_filename) {
237 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
238 error("Backing file not supported for file format '%s'", fmt);
241 if (base_fmt) {
242 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
243 error("Backing file format not supported for file format '%s'", fmt);
248 static int img_create(int argc, char **argv)
250 int c, ret, flags;
251 const char *fmt = "raw";
252 const char *base_fmt = NULL;
253 const char *filename;
254 const char *base_filename = NULL;
255 BlockDriver *drv;
256 QEMUOptionParameter *param = NULL;
257 char *options = NULL;
259 flags = 0;
260 for(;;) {
261 c = getopt(argc, argv, "F:b:f:he6o:");
262 if (c == -1)
263 break;
264 switch(c) {
265 case 'h':
266 help();
267 break;
268 case 'F':
269 base_fmt = optarg;
270 break;
271 case 'b':
272 base_filename = optarg;
273 break;
274 case 'f':
275 fmt = optarg;
276 break;
277 case 'e':
278 flags |= BLOCK_FLAG_ENCRYPT;
279 break;
280 case '6':
281 flags |= BLOCK_FLAG_COMPAT6;
282 break;
283 case 'o':
284 options = optarg;
285 break;
289 /* Find driver and parse its options */
290 drv = bdrv_find_format(fmt);
291 if (!drv)
292 error("Unknown file format '%s'", fmt);
294 if (options && !strcmp(options, "?")) {
295 print_option_help(drv->create_options);
296 return 0;
299 /* Create parameter list with default values */
300 param = parse_option_parameters("", drv->create_options, param);
301 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
303 /* Parse -o options */
304 if (options) {
305 param = parse_option_parameters(options, drv->create_options, param);
306 if (param == NULL) {
307 error("Invalid options for file format '%s'.", fmt);
311 /* Get the filename */
312 if (optind >= argc)
313 help();
314 filename = argv[optind++];
316 /* Add size to parameters */
317 if (optind < argc) {
318 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
321 /* Add old-style options to parameters */
322 add_old_style_options(fmt, param, flags, base_filename, base_fmt);
324 // The size for the image must always be specified, with one exception:
325 // If we are using a backing file, we can obtain the size from there
326 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
328 QEMUOptionParameter *backing_file =
329 get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
330 QEMUOptionParameter *backing_fmt =
331 get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
333 if (backing_file && backing_file->value.s) {
334 BlockDriverState *bs;
335 uint64_t size;
336 const char *fmt = NULL;
337 char buf[32];
339 if (backing_fmt && backing_fmt->value.s) {
340 if (bdrv_find_format(backing_fmt->value.s)) {
341 fmt = backing_fmt->value.s;
342 } else {
343 error("Unknown backing file format '%s'",
344 backing_fmt->value.s);
348 bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
349 bdrv_get_geometry(bs, &size);
350 size *= 512;
351 bdrv_delete(bs);
353 snprintf(buf, sizeof(buf), "%" PRId64, size);
354 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
355 } else {
356 error("Image creation needs a size parameter");
360 printf("Formatting '%s', fmt=%s ", filename, fmt);
361 print_option_parameters(param);
362 puts("");
364 ret = bdrv_create(drv, filename, param);
365 free_option_parameters(param);
367 if (ret < 0) {
368 if (ret == -ENOTSUP) {
369 error("Formatting or formatting option not supported for file format '%s'", fmt);
370 } else if (ret == -EFBIG) {
371 error("The image size is too large for file format '%s'", fmt);
372 } else {
373 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
376 return 0;
379 static int img_check(int argc, char **argv)
381 int c, ret;
382 const char *filename, *fmt;
383 BlockDriverState *bs;
385 fmt = NULL;
386 for(;;) {
387 c = getopt(argc, argv, "f:h");
388 if (c == -1)
389 break;
390 switch(c) {
391 case 'h':
392 help();
393 break;
394 case 'f':
395 fmt = optarg;
396 break;
399 if (optind >= argc)
400 help();
401 filename = argv[optind++];
403 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
404 ret = bdrv_check(bs);
405 switch(ret) {
406 case 0:
407 printf("No errors were found on the image.\n");
408 break;
409 case -ENOTSUP:
410 error("This image format does not support checks");
411 break;
412 default:
413 if (ret < 0) {
414 error("An error occurred during the check");
415 } else {
416 printf("%d errors were found on the image.\n", ret);
418 break;
421 bdrv_delete(bs);
422 return 0;
425 static int img_commit(int argc, char **argv)
427 int c, ret;
428 const char *filename, *fmt;
429 BlockDriverState *bs;
431 fmt = NULL;
432 for(;;) {
433 c = getopt(argc, argv, "f:h");
434 if (c == -1)
435 break;
436 switch(c) {
437 case 'h':
438 help();
439 break;
440 case 'f':
441 fmt = optarg;
442 break;
445 if (optind >= argc)
446 help();
447 filename = argv[optind++];
449 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
450 ret = bdrv_commit(bs);
451 switch(ret) {
452 case 0:
453 printf("Image committed.\n");
454 break;
455 case -ENOENT:
456 error("No disk inserted");
457 break;
458 case -EACCES:
459 error("Image is read-only");
460 break;
461 case -ENOTSUP:
462 error("Image is already committed");
463 break;
464 default:
465 error("Error while committing image");
466 break;
469 bdrv_delete(bs);
470 return 0;
473 static int is_not_zero(const uint8_t *sector, int len)
475 int i;
476 len >>= 2;
477 for(i = 0;i < len; i++) {
478 if (((uint32_t *)sector)[i] != 0)
479 return 1;
481 return 0;
485 * Returns true iff the first sector pointed to by 'buf' contains at least
486 * a non-NUL byte.
488 * 'pnum' is set to the number of sectors (including and immediately following
489 * the first one) that are known to be in the same allocated/unallocated state.
491 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
493 int v, i;
495 if (n <= 0) {
496 *pnum = 0;
497 return 0;
499 v = is_not_zero(buf, 512);
500 for(i = 1; i < n; i++) {
501 buf += 512;
502 if (v != is_not_zero(buf, 512))
503 break;
505 *pnum = i;
506 return v;
510 * Compares two buffers sector by sector. Returns 0 if the first sector of both
511 * buffers matches, non-zero otherwise.
513 * pnum is set to the number of sectors (including and immediately following
514 * the first one) that are known to have the same comparison result
516 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
517 int *pnum)
519 int res, i;
521 if (n <= 0) {
522 *pnum = 0;
523 return 0;
526 res = !!memcmp(buf1, buf2, 512);
527 for(i = 1; i < n; i++) {
528 buf1 += 512;
529 buf2 += 512;
531 if (!!memcmp(buf1, buf2, 512) != res) {
532 break;
536 *pnum = i;
537 return res;
540 #define IO_BUF_SIZE (2 * 1024 * 1024)
542 static int img_convert(int argc, char **argv)
544 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
545 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
546 BlockDriver *drv;
547 BlockDriverState **bs, *out_bs;
548 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
549 uint64_t bs_sectors;
550 uint8_t * buf;
551 const uint8_t *buf1;
552 BlockDriverInfo bdi;
553 QEMUOptionParameter *param = NULL;
554 char *options = NULL;
556 fmt = NULL;
557 out_fmt = "raw";
558 out_baseimg = NULL;
559 flags = 0;
560 for(;;) {
561 c = getopt(argc, argv, "f:O:B:hce6o:");
562 if (c == -1)
563 break;
564 switch(c) {
565 case 'h':
566 help();
567 break;
568 case 'f':
569 fmt = optarg;
570 break;
571 case 'O':
572 out_fmt = optarg;
573 break;
574 case 'B':
575 out_baseimg = optarg;
576 break;
577 case 'c':
578 flags |= BLOCK_FLAG_COMPRESS;
579 break;
580 case 'e':
581 flags |= BLOCK_FLAG_ENCRYPT;
582 break;
583 case '6':
584 flags |= BLOCK_FLAG_COMPAT6;
585 break;
586 case 'o':
587 options = optarg;
588 break;
592 bs_n = argc - optind - 1;
593 if (bs_n < 1) help();
595 out_filename = argv[argc - 1];
597 if (bs_n > 1 && out_baseimg)
598 error("-B makes no sense when concatenating multiple input images");
600 bs = calloc(bs_n, sizeof(BlockDriverState *));
601 if (!bs)
602 error("Out of memory");
604 total_sectors = 0;
605 for (bs_i = 0; bs_i < bs_n; bs_i++) {
606 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
607 if (!bs[bs_i])
608 error("Could not open '%s'", argv[optind + bs_i]);
609 bdrv_get_geometry(bs[bs_i], &bs_sectors);
610 total_sectors += bs_sectors;
613 /* Find driver and parse its options */
614 drv = bdrv_find_format(out_fmt);
615 if (!drv)
616 error("Unknown file format '%s'", out_fmt);
618 if (options && !strcmp(options, "?")) {
619 print_option_help(drv->create_options);
620 free(bs);
621 return 0;
624 if (options) {
625 param = parse_option_parameters(options, drv->create_options, param);
626 if (param == NULL) {
627 error("Invalid options for file format '%s'.", out_fmt);
629 } else {
630 param = parse_option_parameters("", drv->create_options, param);
633 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
634 add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
636 /* Check if compression is supported */
637 if (flags & BLOCK_FLAG_COMPRESS) {
638 QEMUOptionParameter *encryption =
639 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
641 if (!drv->bdrv_write_compressed) {
642 error("Compression not supported for this file format");
645 if (encryption && encryption->value.n) {
646 error("Compression and encryption not supported at the same time");
650 /* Create the new image */
651 ret = bdrv_create(drv, out_filename, param);
652 free_option_parameters(param);
654 if (ret < 0) {
655 if (ret == -ENOTSUP) {
656 error("Formatting not supported for file format '%s'", out_fmt);
657 } else if (ret == -EFBIG) {
658 error("The image size is too large for file format '%s'", out_fmt);
659 } else {
660 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
664 out_bs = bdrv_new_open(out_filename, out_fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
666 bs_i = 0;
667 bs_offset = 0;
668 bdrv_get_geometry(bs[0], &bs_sectors);
669 buf = qemu_malloc(IO_BUF_SIZE);
671 if (flags & BLOCK_FLAG_COMPRESS) {
672 if (bdrv_get_info(out_bs, &bdi) < 0)
673 error("could not get block driver info");
674 cluster_size = bdi.cluster_size;
675 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
676 error("invalid cluster size");
677 cluster_sectors = cluster_size >> 9;
678 sector_num = 0;
679 for(;;) {
680 int64_t bs_num;
681 int remainder;
682 uint8_t *buf2;
684 nb_sectors = total_sectors - sector_num;
685 if (nb_sectors <= 0)
686 break;
687 if (nb_sectors >= cluster_sectors)
688 n = cluster_sectors;
689 else
690 n = nb_sectors;
692 bs_num = sector_num - bs_offset;
693 assert (bs_num >= 0);
694 remainder = n;
695 buf2 = buf;
696 while (remainder > 0) {
697 int nlow;
698 while (bs_num == bs_sectors) {
699 bs_i++;
700 assert (bs_i < bs_n);
701 bs_offset += bs_sectors;
702 bdrv_get_geometry(bs[bs_i], &bs_sectors);
703 bs_num = 0;
704 /* printf("changing part: sector_num=%" PRId64 ", "
705 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
706 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
708 assert (bs_num < bs_sectors);
710 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
712 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
713 error("error while reading");
715 buf2 += nlow * 512;
716 bs_num += nlow;
718 remainder -= nlow;
720 assert (remainder == 0);
722 if (n < cluster_sectors)
723 memset(buf + n * 512, 0, cluster_size - n * 512);
724 if (is_not_zero(buf, cluster_size)) {
725 if (bdrv_write_compressed(out_bs, sector_num, buf,
726 cluster_sectors) != 0)
727 error("error while compressing sector %" PRId64,
728 sector_num);
730 sector_num += n;
732 /* signal EOF to align */
733 bdrv_write_compressed(out_bs, 0, NULL, 0);
734 } else {
735 int has_zero_init = bdrv_has_zero_init(out_bs);
737 sector_num = 0; // total number of sectors converted so far
738 for(;;) {
739 nb_sectors = total_sectors - sector_num;
740 if (nb_sectors <= 0)
741 break;
742 if (nb_sectors >= (IO_BUF_SIZE / 512))
743 n = (IO_BUF_SIZE / 512);
744 else
745 n = nb_sectors;
747 while (sector_num - bs_offset >= bs_sectors) {
748 bs_i ++;
749 assert (bs_i < bs_n);
750 bs_offset += bs_sectors;
751 bdrv_get_geometry(bs[bs_i], &bs_sectors);
752 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
753 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
754 sector_num, bs_i, bs_offset, bs_sectors); */
757 if (n > bs_offset + bs_sectors - sector_num)
758 n = bs_offset + bs_sectors - sector_num;
760 if (has_zero_init) {
761 /* If the output image is being created as a copy on write image,
762 assume that sectors which are unallocated in the input image
763 are present in both the output's and input's base images (no
764 need to copy them). */
765 if (out_baseimg) {
766 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
767 n, &n1)) {
768 sector_num += n1;
769 continue;
771 /* The next 'n1' sectors are allocated in the input image. Copy
772 only those as they may be followed by unallocated sectors. */
773 n = n1;
775 } else {
776 n1 = n;
779 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
780 error("error while reading");
781 /* NOTE: at the same time we convert, we do not write zero
782 sectors to have a chance to compress the image. Ideally, we
783 should add a specific call to have the info to go faster */
784 buf1 = buf;
785 while (n > 0) {
786 /* If the output image is being created as a copy on write image,
787 copy all sectors even the ones containing only NUL bytes,
788 because they may differ from the sectors in the base image.
790 If the output is to a host device, we also write out
791 sectors that are entirely 0, since whatever data was
792 already there is garbage, not 0s. */
793 if (!has_zero_init || out_baseimg ||
794 is_allocated_sectors(buf1, n, &n1)) {
795 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
796 error("error while writing");
798 sector_num += n1;
799 n -= n1;
800 buf1 += n1 * 512;
804 qemu_free(buf);
805 bdrv_delete(out_bs);
806 for (bs_i = 0; bs_i < bs_n; bs_i++)
807 bdrv_delete(bs[bs_i]);
808 free(bs);
809 return 0;
812 #ifdef _WIN32
813 static int64_t get_allocated_file_size(const char *filename)
815 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
816 get_compressed_t get_compressed;
817 struct _stati64 st;
819 /* WinNT support GetCompressedFileSize to determine allocate size */
820 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
821 if (get_compressed) {
822 DWORD high, low;
823 low = get_compressed(filename, &high);
824 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
825 return (((int64_t) high) << 32) + low;
828 if (_stati64(filename, &st) < 0)
829 return -1;
830 return st.st_size;
832 #else
833 static int64_t get_allocated_file_size(const char *filename)
835 struct stat st;
836 if (stat(filename, &st) < 0)
837 return -1;
838 return (int64_t)st.st_blocks * 512;
840 #endif
842 static void dump_snapshots(BlockDriverState *bs)
844 QEMUSnapshotInfo *sn_tab, *sn;
845 int nb_sns, i;
846 char buf[256];
848 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
849 if (nb_sns <= 0)
850 return;
851 printf("Snapshot list:\n");
852 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
853 for(i = 0; i < nb_sns; i++) {
854 sn = &sn_tab[i];
855 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
857 qemu_free(sn_tab);
860 static int img_info(int argc, char **argv)
862 int c;
863 const char *filename, *fmt;
864 BlockDriverState *bs;
865 char fmt_name[128], size_buf[128], dsize_buf[128];
866 uint64_t total_sectors;
867 int64_t allocated_size;
868 char backing_filename[1024];
869 char backing_filename2[1024];
870 BlockDriverInfo bdi;
872 fmt = NULL;
873 for(;;) {
874 c = getopt(argc, argv, "f:h");
875 if (c == -1)
876 break;
877 switch(c) {
878 case 'h':
879 help();
880 break;
881 case 'f':
882 fmt = optarg;
883 break;
886 if (optind >= argc)
887 help();
888 filename = argv[optind++];
890 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
891 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
892 bdrv_get_geometry(bs, &total_sectors);
893 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
894 allocated_size = get_allocated_file_size(filename);
895 if (allocated_size < 0)
896 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
897 else
898 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
899 allocated_size);
900 printf("image: %s\n"
901 "file format: %s\n"
902 "virtual size: %s (%" PRId64 " bytes)\n"
903 "disk size: %s\n",
904 filename, fmt_name, size_buf,
905 (total_sectors * 512),
906 dsize_buf);
907 if (bdrv_is_encrypted(bs))
908 printf("encrypted: yes\n");
909 if (bdrv_get_info(bs, &bdi) >= 0) {
910 if (bdi.cluster_size != 0)
911 printf("cluster_size: %d\n", bdi.cluster_size);
913 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
914 if (backing_filename[0] != '\0') {
915 path_combine(backing_filename2, sizeof(backing_filename2),
916 filename, backing_filename);
917 printf("backing file: %s (actual path: %s)\n",
918 backing_filename,
919 backing_filename2);
921 dump_snapshots(bs);
922 bdrv_delete(bs);
923 return 0;
926 #define SNAPSHOT_LIST 1
927 #define SNAPSHOT_CREATE 2
928 #define SNAPSHOT_APPLY 3
929 #define SNAPSHOT_DELETE 4
931 static int img_snapshot(int argc, char **argv)
933 BlockDriverState *bs;
934 QEMUSnapshotInfo sn;
935 char *filename, *snapshot_name = NULL;
936 int c, ret, bdrv_oflags;
937 int action = 0;
938 qemu_timeval tv;
940 bdrv_oflags = BDRV_O_RDWR;
941 /* Parse commandline parameters */
942 for(;;) {
943 c = getopt(argc, argv, "la:c:d:h");
944 if (c == -1)
945 break;
946 switch(c) {
947 case 'h':
948 help();
949 return 0;
950 case 'l':
951 if (action) {
952 help();
953 return 0;
955 action = SNAPSHOT_LIST;
956 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
957 break;
958 case 'a':
959 if (action) {
960 help();
961 return 0;
963 action = SNAPSHOT_APPLY;
964 snapshot_name = optarg;
965 break;
966 case 'c':
967 if (action) {
968 help();
969 return 0;
971 action = SNAPSHOT_CREATE;
972 snapshot_name = optarg;
973 break;
974 case 'd':
975 if (action) {
976 help();
977 return 0;
979 action = SNAPSHOT_DELETE;
980 snapshot_name = optarg;
981 break;
985 if (optind >= argc)
986 help();
987 filename = argv[optind++];
989 /* Open the image */
990 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
992 /* Perform the requested action */
993 switch(action) {
994 case SNAPSHOT_LIST:
995 dump_snapshots(bs);
996 break;
998 case SNAPSHOT_CREATE:
999 memset(&sn, 0, sizeof(sn));
1000 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1002 qemu_gettimeofday(&tv);
1003 sn.date_sec = tv.tv_sec;
1004 sn.date_nsec = tv.tv_usec * 1000;
1006 ret = bdrv_snapshot_create(bs, &sn);
1007 if (ret)
1008 error("Could not create snapshot '%s': %d (%s)",
1009 snapshot_name, ret, strerror(-ret));
1010 break;
1012 case SNAPSHOT_APPLY:
1013 ret = bdrv_snapshot_goto(bs, snapshot_name);
1014 if (ret)
1015 error("Could not apply snapshot '%s': %d (%s)",
1016 snapshot_name, ret, strerror(-ret));
1017 break;
1019 case SNAPSHOT_DELETE:
1020 ret = bdrv_snapshot_delete(bs, snapshot_name);
1021 if (ret)
1022 error("Could not delete snapshot '%s': %d (%s)",
1023 snapshot_name, ret, strerror(-ret));
1024 break;
1027 /* Cleanup */
1028 bdrv_delete(bs);
1030 return 0;
1033 static int img_rebase(int argc, char **argv)
1035 BlockDriverState *bs, *bs_old_backing, *bs_new_backing;
1036 BlockDriver *old_backing_drv, *new_backing_drv;
1037 char *filename;
1038 const char *fmt, *out_basefmt, *out_baseimg;
1039 int c, flags, ret;
1040 int unsafe = 0;
1042 /* Parse commandline parameters */
1043 fmt = NULL;
1044 out_baseimg = NULL;
1045 out_basefmt = NULL;
1047 for(;;) {
1048 c = getopt(argc, argv, "uhf:F:b:");
1049 if (c == -1)
1050 break;
1051 switch(c) {
1052 case 'h':
1053 help();
1054 return 0;
1055 case 'f':
1056 fmt = optarg;
1057 break;
1058 case 'F':
1059 out_basefmt = optarg;
1060 break;
1061 case 'b':
1062 out_baseimg = optarg;
1063 break;
1064 case 'u':
1065 unsafe = 1;
1066 break;
1070 if ((optind >= argc) || !out_baseimg)
1071 help();
1072 filename = argv[optind++];
1075 * Open the images.
1077 * Ignore the old backing file for unsafe rebase in case we want to correct
1078 * the reference to a renamed or moved backing file.
1080 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1081 bs = bdrv_new_open(filename, fmt, flags);
1083 /* Find the right drivers for the backing files */
1084 old_backing_drv = NULL;
1085 new_backing_drv = NULL;
1087 if (!unsafe && bs->backing_format[0] != '\0') {
1088 old_backing_drv = bdrv_find_format(bs->backing_format);
1089 if (old_backing_drv == NULL) {
1090 error("Invalid format name: '%s'", bs->backing_format);
1094 if (out_basefmt != NULL) {
1095 new_backing_drv = bdrv_find_format(out_basefmt);
1096 if (new_backing_drv == NULL) {
1097 error("Invalid format name: '%s'", out_basefmt);
1101 /* For safe rebasing we need to compare old and new backing file */
1102 if (unsafe) {
1103 /* Make the compiler happy */
1104 bs_old_backing = NULL;
1105 bs_new_backing = NULL;
1106 } else {
1107 char backing_name[1024];
1109 bs_old_backing = bdrv_new("old_backing");
1110 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1111 if (bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1112 old_backing_drv))
1114 error("Could not open old backing file '%s'", backing_name);
1115 return -1;
1118 bs_new_backing = bdrv_new("new_backing");
1119 if (bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS | BDRV_O_RDWR,
1120 new_backing_drv))
1122 error("Could not open new backing file '%s'", out_baseimg);
1123 return -1;
1128 * Check each unallocated cluster in the COW file. If it is unallocated,
1129 * accesses go to the backing file. We must therefore compare this cluster
1130 * in the old and new backing file, and if they differ we need to copy it
1131 * from the old backing file into the COW file.
1133 * If qemu-img crashes during this step, no harm is done. The content of
1134 * the image is the same as the original one at any time.
1136 if (!unsafe) {
1137 uint64_t num_sectors;
1138 uint64_t sector;
1139 int n;
1140 uint8_t * buf_old;
1141 uint8_t * buf_new;
1143 buf_old = qemu_malloc(IO_BUF_SIZE);
1144 buf_new = qemu_malloc(IO_BUF_SIZE);
1146 bdrv_get_geometry(bs, &num_sectors);
1148 for (sector = 0; sector < num_sectors; sector += n) {
1150 /* How many sectors can we handle with the next read? */
1151 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1152 n = (IO_BUF_SIZE / 512);
1153 } else {
1154 n = num_sectors - sector;
1157 /* If the cluster is allocated, we don't need to take action */
1158 ret = bdrv_is_allocated(bs, sector, n, &n);
1159 if (ret) {
1160 continue;
1163 /* Read old and new backing file */
1164 if (bdrv_read(bs_old_backing, sector, buf_old, n) < 0) {
1165 error("error while reading from old backing file");
1167 if (bdrv_read(bs_new_backing, sector, buf_new, n) < 0) {
1168 error("error while reading from new backing file");
1171 /* If they differ, we need to write to the COW file */
1172 uint64_t written = 0;
1174 while (written < n) {
1175 int pnum;
1177 if (compare_sectors(buf_old + written * 512,
1178 buf_new + written * 512, n - written, &pnum))
1180 ret = bdrv_write(bs, sector + written,
1181 buf_old + written * 512, pnum);
1182 if (ret < 0) {
1183 error("Error while writing to COW image: %s",
1184 strerror(-ret));
1188 written += pnum;
1192 qemu_free(buf_old);
1193 qemu_free(buf_new);
1197 * Change the backing file. All clusters that are different from the old
1198 * backing file are overwritten in the COW file now, so the visible content
1199 * doesn't change when we switch the backing file.
1201 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1202 if (ret == -ENOSPC) {
1203 error("Could not change the backing file to '%s': No space left in "
1204 "the file header", out_baseimg);
1205 } else if (ret < 0) {
1206 error("Could not change the backing file to '%s': %s",
1207 out_baseimg, strerror(-ret));
1211 * TODO At this point it is possible to check if any clusters that are
1212 * allocated in the COW file are the same in the backing file. If so, they
1213 * could be dropped from the COW file. Don't do this before switching the
1214 * backing file, in case of a crash this would lead to corruption.
1217 /* Cleanup */
1218 if (!unsafe) {
1219 bdrv_delete(bs_old_backing);
1220 bdrv_delete(bs_new_backing);
1223 bdrv_delete(bs);
1225 return 0;
1228 static int img_resize(int argc, char **argv)
1230 int c, ret, relative;
1231 const char *filename, *fmt, *size;
1232 int64_t n, total_size;
1233 BlockDriverState *bs;
1234 QEMUOptionParameter *param;
1235 QEMUOptionParameter resize_options[] = {
1237 .name = BLOCK_OPT_SIZE,
1238 .type = OPT_SIZE,
1239 .help = "Virtual disk size"
1241 { NULL }
1244 fmt = NULL;
1245 for(;;) {
1246 c = getopt(argc, argv, "f:h");
1247 if (c == -1) {
1248 break;
1250 switch(c) {
1251 case 'h':
1252 help();
1253 break;
1254 case 'f':
1255 fmt = optarg;
1256 break;
1259 if (optind + 1 >= argc) {
1260 help();
1262 filename = argv[optind++];
1263 size = argv[optind++];
1265 /* Choose grow, shrink, or absolute resize mode */
1266 switch (size[0]) {
1267 case '+':
1268 relative = 1;
1269 size++;
1270 break;
1271 case '-':
1272 relative = -1;
1273 size++;
1274 break;
1275 default:
1276 relative = 0;
1277 break;
1280 /* Parse size */
1281 param = parse_option_parameters("", resize_options, NULL);
1282 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1283 /* Error message already printed when size parsing fails */
1284 exit(1);
1286 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1287 free_option_parameters(param);
1289 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1291 if (relative) {
1292 total_size = bdrv_getlength(bs) + n * relative;
1293 } else {
1294 total_size = n;
1296 if (total_size <= 0) {
1297 error("New image size must be positive");
1300 ret = bdrv_truncate(bs, total_size);
1301 switch (ret) {
1302 case 0:
1303 printf("Image resized.\n");
1304 break;
1305 case -ENOTSUP:
1306 error("This image format does not support resize");
1307 break;
1308 case -EACCES:
1309 error("Image is read-only");
1310 break;
1311 default:
1312 error("Error resizing image (%d)", -ret);
1313 break;
1316 bdrv_delete(bs);
1317 return 0;
1320 static const img_cmd_t img_cmds[] = {
1321 #define DEF(option, callback, arg_string) \
1322 { option, callback },
1323 #include "qemu-img-cmds.h"
1324 #undef DEF
1325 #undef GEN_DOCS
1326 { NULL, NULL, },
1329 int main(int argc, char **argv)
1331 const img_cmd_t *cmd;
1332 const char *cmdname;
1334 bdrv_init();
1335 if (argc < 2)
1336 help();
1337 cmdname = argv[1];
1338 argc--; argv++;
1340 /* find the command */
1341 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1342 if (!strcmp(cmdname, cmd->name)) {
1343 return cmd->handler(argc, argv);
1347 /* not found */
1348 help();
1349 return 0;