monitor: New commands netdev_add, netdev_del
[qemu/aliguori-queue.git] / qemu-img.c
blob9b28664a309e6097e54d07c146f332f40b937197
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 BRDV_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 readonly)
195 BlockDriverState *bs;
196 BlockDriver *drv;
197 char password[256];
198 int flags = BRDV_O_FLAGS;
200 bs = bdrv_new("");
201 if (!bs)
202 error("Not enough memory");
203 if (fmt) {
204 drv = bdrv_find_format(fmt);
205 if (!drv)
206 error("Unknown file format '%s'", fmt);
207 } else {
208 drv = NULL;
210 if (!readonly) {
211 flags |= BDRV_O_RDWR;
213 if (bdrv_open2(bs, filename, flags, drv) < 0) {
214 error("Could not open '%s'", filename);
216 if (bdrv_is_encrypted(bs)) {
217 printf("Disk image '%s' is encrypted.\n", filename);
218 if (read_password(password, sizeof(password)) < 0)
219 error("No password given");
220 if (bdrv_set_key(bs, password) < 0)
221 error("invalid password");
223 return bs;
226 static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
227 int flags, const char *base_filename, const char *base_fmt)
229 if (flags & BLOCK_FLAG_ENCRYPT) {
230 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
231 error("Encryption not supported for file format '%s'", fmt);
234 if (flags & BLOCK_FLAG_COMPAT6) {
235 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
236 error("VMDK version 6 not supported for file format '%s'", fmt);
240 if (base_filename) {
241 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
242 error("Backing file not supported for file format '%s'", fmt);
245 if (base_fmt) {
246 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
247 error("Backing file format not supported for file format '%s'", fmt);
252 static int img_create(int argc, char **argv)
254 int c, ret, flags;
255 const char *fmt = "raw";
256 const char *base_fmt = NULL;
257 const char *filename;
258 const char *base_filename = NULL;
259 BlockDriver *drv;
260 QEMUOptionParameter *param = NULL;
261 char *options = NULL;
263 flags = 0;
264 for(;;) {
265 c = getopt(argc, argv, "F:b:f:he6o:");
266 if (c == -1)
267 break;
268 switch(c) {
269 case 'h':
270 help();
271 break;
272 case 'F':
273 base_fmt = optarg;
274 break;
275 case 'b':
276 base_filename = optarg;
277 break;
278 case 'f':
279 fmt = optarg;
280 break;
281 case 'e':
282 flags |= BLOCK_FLAG_ENCRYPT;
283 break;
284 case '6':
285 flags |= BLOCK_FLAG_COMPAT6;
286 break;
287 case 'o':
288 options = optarg;
289 break;
293 /* Find driver and parse its options */
294 drv = bdrv_find_format(fmt);
295 if (!drv)
296 error("Unknown file format '%s'", fmt);
298 if (options && !strcmp(options, "?")) {
299 print_option_help(drv->create_options);
300 return 0;
303 /* Create parameter list with default values */
304 param = parse_option_parameters("", drv->create_options, param);
305 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
307 /* Parse -o options */
308 if (options) {
309 param = parse_option_parameters(options, drv->create_options, param);
310 if (param == NULL) {
311 error("Invalid options for file format '%s'.", fmt);
315 /* Get the filename */
316 if (optind >= argc)
317 help();
318 filename = argv[optind++];
320 /* Add size to parameters */
321 if (optind < argc) {
322 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
325 /* Add old-style options to parameters */
326 add_old_style_options(fmt, param, flags, base_filename, base_fmt);
328 // The size for the image must always be specified, with one exception:
329 // If we are using a backing file, we can obtain the size from there
330 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
332 QEMUOptionParameter *backing_file =
333 get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
334 QEMUOptionParameter *backing_fmt =
335 get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
337 if (backing_file && backing_file->value.s) {
338 BlockDriverState *bs;
339 uint64_t size;
340 const char *fmt = NULL;
341 char buf[32];
343 if (backing_fmt && backing_fmt->value.s) {
344 if (bdrv_find_format(backing_fmt->value.s)) {
345 fmt = backing_fmt->value.s;
346 } else {
347 error("Unknown backing file format '%s'",
348 backing_fmt->value.s);
352 bs = bdrv_new_open(backing_file->value.s, fmt, 1);
353 bdrv_get_geometry(bs, &size);
354 size *= 512;
355 bdrv_delete(bs);
357 snprintf(buf, sizeof(buf), "%" PRId64, size);
358 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
359 } else {
360 error("Image creation needs a size parameter");
364 printf("Formatting '%s', fmt=%s ", filename, fmt);
365 print_option_parameters(param);
366 puts("");
368 ret = bdrv_create(drv, filename, param);
369 free_option_parameters(param);
371 if (ret < 0) {
372 if (ret == -ENOTSUP) {
373 error("Formatting or formatting option not supported for file format '%s'", fmt);
374 } else if (ret == -EFBIG) {
375 error("The image size is too large for file format '%s'", fmt);
376 } else {
377 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
380 return 0;
383 static int img_check(int argc, char **argv)
385 int c, ret;
386 const char *filename, *fmt;
387 BlockDriver *drv;
388 BlockDriverState *bs;
390 fmt = NULL;
391 for(;;) {
392 c = getopt(argc, argv, "f:h");
393 if (c == -1)
394 break;
395 switch(c) {
396 case 'h':
397 help();
398 break;
399 case 'f':
400 fmt = optarg;
401 break;
404 if (optind >= argc)
405 help();
406 filename = argv[optind++];
408 bs = bdrv_new("");
409 if (!bs)
410 error("Not enough memory");
411 if (fmt) {
412 drv = bdrv_find_format(fmt);
413 if (!drv)
414 error("Unknown file format '%s'", fmt);
415 } else {
416 drv = NULL;
418 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
419 error("Could not open '%s'", filename);
421 ret = bdrv_check(bs);
422 switch(ret) {
423 case 0:
424 printf("No errors were found on the image.\n");
425 break;
426 case -ENOTSUP:
427 error("This image format does not support checks");
428 break;
429 default:
430 if (ret < 0) {
431 error("An error occurred during the check");
432 } else {
433 printf("%d errors were found on the image.\n", ret);
435 break;
438 bdrv_delete(bs);
439 return 0;
442 static int img_commit(int argc, char **argv)
444 int c, ret;
445 const char *filename, *fmt;
446 BlockDriver *drv;
447 BlockDriverState *bs;
449 fmt = NULL;
450 for(;;) {
451 c = getopt(argc, argv, "f:h");
452 if (c == -1)
453 break;
454 switch(c) {
455 case 'h':
456 help();
457 break;
458 case 'f':
459 fmt = optarg;
460 break;
463 if (optind >= argc)
464 help();
465 filename = argv[optind++];
467 bs = bdrv_new("");
468 if (!bs)
469 error("Not enough memory");
470 if (fmt) {
471 drv = bdrv_find_format(fmt);
472 if (!drv)
473 error("Unknown file format '%s'", fmt);
474 } else {
475 drv = NULL;
477 if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_RDWR, drv) < 0) {
478 error("Could not open '%s'", filename);
480 ret = bdrv_commit(bs);
481 switch(ret) {
482 case 0:
483 printf("Image committed.\n");
484 break;
485 case -ENOENT:
486 error("No disk inserted");
487 break;
488 case -EACCES:
489 error("Image is read-only");
490 break;
491 case -ENOTSUP:
492 error("Image is already committed");
493 break;
494 default:
495 error("Error while committing image");
496 break;
499 bdrv_delete(bs);
500 return 0;
503 static int is_not_zero(const uint8_t *sector, int len)
505 int i;
506 len >>= 2;
507 for(i = 0;i < len; i++) {
508 if (((uint32_t *)sector)[i] != 0)
509 return 1;
511 return 0;
515 * Returns true iff the first sector pointed to by 'buf' contains at least
516 * a non-NUL byte.
518 * 'pnum' is set to the number of sectors (including and immediately following
519 * the first one) that are known to be in the same allocated/unallocated state.
521 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
523 int v, i;
525 if (n <= 0) {
526 *pnum = 0;
527 return 0;
529 v = is_not_zero(buf, 512);
530 for(i = 1; i < n; i++) {
531 buf += 512;
532 if (v != is_not_zero(buf, 512))
533 break;
535 *pnum = i;
536 return v;
540 * Compares two buffers sector by sector. Returns 0 if the first sector of both
541 * buffers matches, non-zero otherwise.
543 * pnum is set to the number of sectors (including and immediately following
544 * the first one) that are known to have the same comparison result
546 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
547 int *pnum)
549 int res, i;
551 if (n <= 0) {
552 *pnum = 0;
553 return 0;
556 res = !!memcmp(buf1, buf2, 512);
557 for(i = 1; i < n; i++) {
558 buf1 += 512;
559 buf2 += 512;
561 if (!!memcmp(buf1, buf2, 512) != res) {
562 break;
566 *pnum = i;
567 return res;
570 #define IO_BUF_SIZE (2 * 1024 * 1024)
572 static int img_convert(int argc, char **argv)
574 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
575 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
576 BlockDriver *drv;
577 BlockDriverState **bs, *out_bs;
578 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
579 uint64_t bs_sectors;
580 uint8_t * buf;
581 const uint8_t *buf1;
582 BlockDriverInfo bdi;
583 QEMUOptionParameter *param = NULL;
584 char *options = NULL;
586 fmt = NULL;
587 out_fmt = "raw";
588 out_baseimg = NULL;
589 flags = 0;
590 for(;;) {
591 c = getopt(argc, argv, "f:O:B:hce6o:");
592 if (c == -1)
593 break;
594 switch(c) {
595 case 'h':
596 help();
597 break;
598 case 'f':
599 fmt = optarg;
600 break;
601 case 'O':
602 out_fmt = optarg;
603 break;
604 case 'B':
605 out_baseimg = optarg;
606 break;
607 case 'c':
608 flags |= BLOCK_FLAG_COMPRESS;
609 break;
610 case 'e':
611 flags |= BLOCK_FLAG_ENCRYPT;
612 break;
613 case '6':
614 flags |= BLOCK_FLAG_COMPAT6;
615 break;
616 case 'o':
617 options = optarg;
618 break;
622 bs_n = argc - optind - 1;
623 if (bs_n < 1) help();
625 out_filename = argv[argc - 1];
627 if (bs_n > 1 && out_baseimg)
628 error("-B makes no sense when concatenating multiple input images");
630 bs = calloc(bs_n, sizeof(BlockDriverState *));
631 if (!bs)
632 error("Out of memory");
634 total_sectors = 0;
635 for (bs_i = 0; bs_i < bs_n; bs_i++) {
636 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, 1);
637 if (!bs[bs_i])
638 error("Could not open '%s'", argv[optind + bs_i]);
639 bdrv_get_geometry(bs[bs_i], &bs_sectors);
640 total_sectors += bs_sectors;
643 /* Find driver and parse its options */
644 drv = bdrv_find_format(out_fmt);
645 if (!drv)
646 error("Unknown file format '%s'", out_fmt);
648 if (options && !strcmp(options, "?")) {
649 print_option_help(drv->create_options);
650 free(bs);
651 return 0;
654 if (options) {
655 param = parse_option_parameters(options, drv->create_options, param);
656 if (param == NULL) {
657 error("Invalid options for file format '%s'.", out_fmt);
659 } else {
660 param = parse_option_parameters("", drv->create_options, param);
663 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
664 add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
666 /* Check if compression is supported */
667 if (flags & BLOCK_FLAG_COMPRESS) {
668 QEMUOptionParameter *encryption =
669 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
671 if (!drv->bdrv_write_compressed) {
672 error("Compression not supported for this file format");
675 if (encryption && encryption->value.n) {
676 error("Compression and encryption not supported at the same time");
680 /* Create the new image */
681 ret = bdrv_create(drv, out_filename, param);
682 free_option_parameters(param);
684 if (ret < 0) {
685 if (ret == -ENOTSUP) {
686 error("Formatting not supported for file format '%s'", out_fmt);
687 } else if (ret == -EFBIG) {
688 error("The image size is too large for file format '%s'", out_fmt);
689 } else {
690 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
694 out_bs = bdrv_new_open(out_filename, out_fmt, 0);
696 bs_i = 0;
697 bs_offset = 0;
698 bdrv_get_geometry(bs[0], &bs_sectors);
699 buf = qemu_malloc(IO_BUF_SIZE);
701 if (flags & BLOCK_FLAG_COMPRESS) {
702 if (bdrv_get_info(out_bs, &bdi) < 0)
703 error("could not get block driver info");
704 cluster_size = bdi.cluster_size;
705 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
706 error("invalid cluster size");
707 cluster_sectors = cluster_size >> 9;
708 sector_num = 0;
709 for(;;) {
710 int64_t bs_num;
711 int remainder;
712 uint8_t *buf2;
714 nb_sectors = total_sectors - sector_num;
715 if (nb_sectors <= 0)
716 break;
717 if (nb_sectors >= cluster_sectors)
718 n = cluster_sectors;
719 else
720 n = nb_sectors;
722 bs_num = sector_num - bs_offset;
723 assert (bs_num >= 0);
724 remainder = n;
725 buf2 = buf;
726 while (remainder > 0) {
727 int nlow;
728 while (bs_num == bs_sectors) {
729 bs_i++;
730 assert (bs_i < bs_n);
731 bs_offset += bs_sectors;
732 bdrv_get_geometry(bs[bs_i], &bs_sectors);
733 bs_num = 0;
734 /* printf("changing part: sector_num=%lld, "
735 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
736 sector_num, bs_i, bs_offset, bs_sectors); */
738 assert (bs_num < bs_sectors);
740 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
742 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
743 error("error while reading");
745 buf2 += nlow * 512;
746 bs_num += nlow;
748 remainder -= nlow;
750 assert (remainder == 0);
752 if (n < cluster_sectors)
753 memset(buf + n * 512, 0, cluster_size - n * 512);
754 if (is_not_zero(buf, cluster_size)) {
755 if (bdrv_write_compressed(out_bs, sector_num, buf,
756 cluster_sectors) != 0)
757 error("error while compressing sector %" PRId64,
758 sector_num);
760 sector_num += n;
762 /* signal EOF to align */
763 bdrv_write_compressed(out_bs, 0, NULL, 0);
764 } else {
765 sector_num = 0; // total number of sectors converted so far
766 for(;;) {
767 nb_sectors = total_sectors - sector_num;
768 if (nb_sectors <= 0)
769 break;
770 if (nb_sectors >= (IO_BUF_SIZE / 512))
771 n = (IO_BUF_SIZE / 512);
772 else
773 n = nb_sectors;
775 while (sector_num - bs_offset >= bs_sectors) {
776 bs_i ++;
777 assert (bs_i < bs_n);
778 bs_offset += bs_sectors;
779 bdrv_get_geometry(bs[bs_i], &bs_sectors);
780 /* printf("changing part: sector_num=%lld, bs_i=%d, "
781 "bs_offset=%lld, bs_sectors=%lld\n",
782 sector_num, bs_i, bs_offset, bs_sectors); */
785 if (n > bs_offset + bs_sectors - sector_num)
786 n = bs_offset + bs_sectors - sector_num;
788 if (!drv->no_zero_init) {
789 /* If the output image is being created as a copy on write image,
790 assume that sectors which are unallocated in the input image
791 are present in both the output's and input's base images (no
792 need to copy them). */
793 if (out_baseimg) {
794 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
795 n, &n1)) {
796 sector_num += n1;
797 continue;
799 /* The next 'n1' sectors are allocated in the input image. Copy
800 only those as they may be followed by unallocated sectors. */
801 n = n1;
803 } else {
804 n1 = n;
807 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
808 error("error while reading");
809 /* NOTE: at the same time we convert, we do not write zero
810 sectors to have a chance to compress the image. Ideally, we
811 should add a specific call to have the info to go faster */
812 buf1 = buf;
813 while (n > 0) {
814 /* If the output image is being created as a copy on write image,
815 copy all sectors even the ones containing only NUL bytes,
816 because they may differ from the sectors in the base image.
818 If the output is to a host device, we also write out
819 sectors that are entirely 0, since whatever data was
820 already there is garbage, not 0s. */
821 if (drv->no_zero_init || out_baseimg ||
822 is_allocated_sectors(buf1, n, &n1)) {
823 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
824 error("error while writing");
826 sector_num += n1;
827 n -= n1;
828 buf1 += n1 * 512;
832 qemu_free(buf);
833 bdrv_delete(out_bs);
834 for (bs_i = 0; bs_i < bs_n; bs_i++)
835 bdrv_delete(bs[bs_i]);
836 free(bs);
837 return 0;
840 #ifdef _WIN32
841 static int64_t get_allocated_file_size(const char *filename)
843 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
844 get_compressed_t get_compressed;
845 struct _stati64 st;
847 /* WinNT support GetCompressedFileSize to determine allocate size */
848 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
849 if (get_compressed) {
850 DWORD high, low;
851 low = get_compressed(filename, &high);
852 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
853 return (((int64_t) high) << 32) + low;
856 if (_stati64(filename, &st) < 0)
857 return -1;
858 return st.st_size;
860 #else
861 static int64_t get_allocated_file_size(const char *filename)
863 struct stat st;
864 if (stat(filename, &st) < 0)
865 return -1;
866 return (int64_t)st.st_blocks * 512;
868 #endif
870 static void dump_snapshots(BlockDriverState *bs)
872 QEMUSnapshotInfo *sn_tab, *sn;
873 int nb_sns, i;
874 char buf[256];
876 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
877 if (nb_sns <= 0)
878 return;
879 printf("Snapshot list:\n");
880 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
881 for(i = 0; i < nb_sns; i++) {
882 sn = &sn_tab[i];
883 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
885 qemu_free(sn_tab);
888 static int img_info(int argc, char **argv)
890 int c;
891 const char *filename, *fmt;
892 BlockDriver *drv;
893 BlockDriverState *bs;
894 char fmt_name[128], size_buf[128], dsize_buf[128];
895 uint64_t total_sectors;
896 int64_t allocated_size;
897 char backing_filename[1024];
898 char backing_filename2[1024];
899 BlockDriverInfo bdi;
901 fmt = NULL;
902 for(;;) {
903 c = getopt(argc, argv, "f:h");
904 if (c == -1)
905 break;
906 switch(c) {
907 case 'h':
908 help();
909 break;
910 case 'f':
911 fmt = optarg;
912 break;
915 if (optind >= argc)
916 help();
917 filename = argv[optind++];
919 bs = bdrv_new("");
920 if (!bs)
921 error("Not enough memory");
922 if (fmt) {
923 drv = bdrv_find_format(fmt);
924 if (!drv)
925 error("Unknown file format '%s'", fmt);
926 } else {
927 drv = NULL;
929 if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_NO_BACKING, drv) < 0) {
930 error("Could not open '%s'", filename);
932 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
933 bdrv_get_geometry(bs, &total_sectors);
934 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
935 allocated_size = get_allocated_file_size(filename);
936 if (allocated_size < 0)
937 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
938 else
939 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
940 allocated_size);
941 printf("image: %s\n"
942 "file format: %s\n"
943 "virtual size: %s (%" PRId64 " bytes)\n"
944 "disk size: %s\n",
945 filename, fmt_name, size_buf,
946 (total_sectors * 512),
947 dsize_buf);
948 if (bdrv_is_encrypted(bs))
949 printf("encrypted: yes\n");
950 if (bdrv_get_info(bs, &bdi) >= 0) {
951 if (bdi.cluster_size != 0)
952 printf("cluster_size: %d\n", bdi.cluster_size);
954 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
955 if (backing_filename[0] != '\0') {
956 path_combine(backing_filename2, sizeof(backing_filename2),
957 filename, backing_filename);
958 printf("backing file: %s (actual path: %s)\n",
959 backing_filename,
960 backing_filename2);
962 dump_snapshots(bs);
963 bdrv_delete(bs);
964 return 0;
967 #define SNAPSHOT_LIST 1
968 #define SNAPSHOT_CREATE 2
969 #define SNAPSHOT_APPLY 3
970 #define SNAPSHOT_DELETE 4
972 static int img_snapshot(int argc, char **argv)
974 BlockDriverState *bs;
975 QEMUSnapshotInfo sn;
976 char *filename, *snapshot_name = NULL;
977 int c, ret, bdrv_oflags;
978 int action = 0;
979 qemu_timeval tv;
981 bdrv_oflags = BDRV_O_RDWR;
982 /* Parse commandline parameters */
983 for(;;) {
984 c = getopt(argc, argv, "la:c:d:h");
985 if (c == -1)
986 break;
987 switch(c) {
988 case 'h':
989 help();
990 return 0;
991 case 'l':
992 if (action) {
993 help();
994 return 0;
996 action = SNAPSHOT_LIST;
997 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
998 break;
999 case 'a':
1000 if (action) {
1001 help();
1002 return 0;
1004 action = SNAPSHOT_APPLY;
1005 snapshot_name = optarg;
1006 break;
1007 case 'c':
1008 if (action) {
1009 help();
1010 return 0;
1012 action = SNAPSHOT_CREATE;
1013 snapshot_name = optarg;
1014 break;
1015 case 'd':
1016 if (action) {
1017 help();
1018 return 0;
1020 action = SNAPSHOT_DELETE;
1021 snapshot_name = optarg;
1022 break;
1026 if (optind >= argc)
1027 help();
1028 filename = argv[optind++];
1030 /* Open the image */
1031 bs = bdrv_new("");
1032 if (!bs)
1033 error("Not enough memory");
1035 if (bdrv_open2(bs, filename, bdrv_oflags, NULL) < 0) {
1036 error("Could not open '%s'", filename);
1039 /* Perform the requested action */
1040 switch(action) {
1041 case SNAPSHOT_LIST:
1042 dump_snapshots(bs);
1043 break;
1045 case SNAPSHOT_CREATE:
1046 memset(&sn, 0, sizeof(sn));
1047 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1049 qemu_gettimeofday(&tv);
1050 sn.date_sec = tv.tv_sec;
1051 sn.date_nsec = tv.tv_usec * 1000;
1053 ret = bdrv_snapshot_create(bs, &sn);
1054 if (ret)
1055 error("Could not create snapshot '%s': %d (%s)",
1056 snapshot_name, ret, strerror(-ret));
1057 break;
1059 case SNAPSHOT_APPLY:
1060 ret = bdrv_snapshot_goto(bs, snapshot_name);
1061 if (ret)
1062 error("Could not apply snapshot '%s': %d (%s)",
1063 snapshot_name, ret, strerror(-ret));
1064 break;
1066 case SNAPSHOT_DELETE:
1067 ret = bdrv_snapshot_delete(bs, snapshot_name);
1068 if (ret)
1069 error("Could not delete snapshot '%s': %d (%s)",
1070 snapshot_name, ret, strerror(-ret));
1071 break;
1074 /* Cleanup */
1075 bdrv_delete(bs);
1077 return 0;
1080 static int img_rebase(int argc, char **argv)
1082 BlockDriverState *bs, *bs_old_backing, *bs_new_backing;
1083 BlockDriver *drv, *old_backing_drv, *new_backing_drv;
1084 char *filename;
1085 const char *fmt, *out_basefmt, *out_baseimg;
1086 int c, flags, ret;
1087 int unsafe = 0;
1089 /* Parse commandline parameters */
1090 fmt = NULL;
1091 out_baseimg = NULL;
1092 out_basefmt = NULL;
1094 for(;;) {
1095 c = getopt(argc, argv, "uhf:F:b:");
1096 if (c == -1)
1097 break;
1098 switch(c) {
1099 case 'h':
1100 help();
1101 return 0;
1102 case 'f':
1103 fmt = optarg;
1104 break;
1105 case 'F':
1106 out_basefmt = optarg;
1107 break;
1108 case 'b':
1109 out_baseimg = optarg;
1110 break;
1111 case 'u':
1112 unsafe = 1;
1113 break;
1117 if ((optind >= argc) || !out_baseimg)
1118 help();
1119 filename = argv[optind++];
1122 * Open the images.
1124 * Ignore the old backing file for unsafe rebase in case we want to correct
1125 * the reference to a renamed or moved backing file.
1127 bs = bdrv_new("");
1128 if (!bs)
1129 error("Not enough memory");
1131 drv = NULL;
1132 if (fmt) {
1133 drv = bdrv_find_format(fmt);
1134 if (drv == NULL) {
1135 error("Invalid format name: '%s'", fmt);
1139 flags = BRDV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1140 if (bdrv_open2(bs, filename, flags, drv) < 0) {
1141 error("Could not open '%s'", filename);
1144 /* Find the right drivers for the backing files */
1145 old_backing_drv = NULL;
1146 new_backing_drv = NULL;
1148 if (!unsafe && bs->backing_format[0] != '\0') {
1149 old_backing_drv = bdrv_find_format(bs->backing_format);
1150 if (old_backing_drv == NULL) {
1151 error("Invalid format name: '%s'", bs->backing_format);
1155 if (out_basefmt != NULL) {
1156 new_backing_drv = bdrv_find_format(out_basefmt);
1157 if (new_backing_drv == NULL) {
1158 error("Invalid format name: '%s'", out_basefmt);
1162 /* For safe rebasing we need to compare old and new backing file */
1163 if (unsafe) {
1164 /* Make the compiler happy */
1165 bs_old_backing = NULL;
1166 bs_new_backing = NULL;
1167 } else {
1168 char backing_name[1024];
1170 bs_old_backing = bdrv_new("old_backing");
1171 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1172 if (bdrv_open2(bs_old_backing, backing_name, BRDV_O_FLAGS,
1173 old_backing_drv))
1175 error("Could not open old backing file '%s'", backing_name);
1176 return -1;
1179 bs_new_backing = bdrv_new("new_backing");
1180 if (bdrv_open2(bs_new_backing, out_baseimg, BRDV_O_FLAGS | BDRV_O_RDWR,
1181 new_backing_drv))
1183 error("Could not open new backing file '%s'", out_baseimg);
1184 return -1;
1189 * Check each unallocated cluster in the COW file. If it is unallocated,
1190 * accesses go to the backing file. We must therefore compare this cluster
1191 * in the old and new backing file, and if they differ we need to copy it
1192 * from the old backing file into the COW file.
1194 * If qemu-img crashes during this step, no harm is done. The content of
1195 * the image is the same as the original one at any time.
1197 if (!unsafe) {
1198 uint64_t num_sectors;
1199 uint64_t sector;
1200 int n, n1;
1201 uint8_t * buf_old;
1202 uint8_t * buf_new;
1204 buf_old = qemu_malloc(IO_BUF_SIZE);
1205 buf_new = qemu_malloc(IO_BUF_SIZE);
1207 bdrv_get_geometry(bs, &num_sectors);
1209 for (sector = 0; sector < num_sectors; sector += n) {
1211 /* How many sectors can we handle with the next read? */
1212 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1213 n = (IO_BUF_SIZE / 512);
1214 } else {
1215 n = num_sectors - sector;
1218 /* If the cluster is allocated, we don't need to take action */
1219 if (bdrv_is_allocated(bs, sector, n, &n1)) {
1220 n = n1;
1221 continue;
1224 /* Read old and new backing file */
1225 if (bdrv_read(bs_old_backing, sector, buf_old, n) < 0) {
1226 error("error while reading from old backing file");
1228 if (bdrv_read(bs_new_backing, sector, buf_new, n) < 0) {
1229 error("error while reading from new backing file");
1232 /* If they differ, we need to write to the COW file */
1233 uint64_t written = 0;
1235 while (written < n) {
1236 int pnum;
1238 if (compare_sectors(buf_old + written * 512,
1239 buf_new + written * 512, n - written, &pnum))
1241 ret = bdrv_write(bs, sector + written,
1242 buf_old + written * 512, pnum);
1243 if (ret < 0) {
1244 error("Error while writing to COW image: %s",
1245 strerror(-ret));
1249 written += pnum;
1253 qemu_free(buf_old);
1254 qemu_free(buf_new);
1258 * Change the backing file. All clusters that are different from the old
1259 * backing file are overwritten in the COW file now, so the visible content
1260 * doesn't change when we switch the backing file.
1262 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1263 if (ret == -ENOSPC) {
1264 error("Could not change the backing file to '%s': No space left in "
1265 "the file header", out_baseimg);
1266 } else if (ret < 0) {
1267 error("Could not change the backing file to '%s': %s",
1268 out_baseimg, strerror(-ret));
1272 * TODO At this point it is possible to check if any clusters that are
1273 * allocated in the COW file are the same in the backing file. If so, they
1274 * could be dropped from the COW file. Don't do this before switching the
1275 * backing file, in case of a crash this would lead to corruption.
1278 /* Cleanup */
1279 if (!unsafe) {
1280 bdrv_delete(bs_old_backing);
1281 bdrv_delete(bs_new_backing);
1284 bdrv_delete(bs);
1286 return 0;
1289 static const img_cmd_t img_cmds[] = {
1290 #define DEF(option, callback, arg_string) \
1291 { option, callback },
1292 #include "qemu-img-cmds.h"
1293 #undef DEF
1294 #undef GEN_DOCS
1295 { NULL, NULL, },
1298 int main(int argc, char **argv)
1300 const img_cmd_t *cmd;
1301 const char *cmdname;
1303 bdrv_init();
1304 if (argc < 2)
1305 help();
1306 cmdname = argv[1];
1307 argc--; argv++;
1309 /* find the command */
1310 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1311 if (!strcmp(cmdname, cmd->name)) {
1312 return cmd->handler(argc, argv);
1316 /* not found */
1317 help();
1318 return 0;