[virtio-9p] qemu: virtio-9p: Implement LOPEN
[qemu.git] / qemu-img.c
blobe300f911cb5b05b7e68323ad47d80129f4caf8cc
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 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 va_end(ap);
52 static void format_print(void *opaque, const char *name)
54 printf(" %s", name);
57 /* Please keep in synch with qemu-img.texi */
58 static void help(void)
60 const char *help_msg =
61 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
62 "usage: qemu-img command [command options]\n"
63 "QEMU disk image utility\n"
64 "\n"
65 "Command syntax:\n"
66 #define DEF(option, callback, arg_string) \
67 " " arg_string "\n"
68 #include "qemu-img-cmds.h"
69 #undef DEF
70 #undef GEN_DOCS
71 "\n"
72 "Command parameters:\n"
73 " 'filename' is a disk image filename\n"
74 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
75 " 'size' is the disk image size in bytes. Optional suffixes\n"
76 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
77 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
78 " 'output_filename' is the destination disk image filename\n"
79 " 'output_fmt' is the destination format\n"
80 " 'options' is a comma separated list of format specific options in a\n"
81 " name=value format. Use -o ? for an overview of the options supported by the\n"
82 " used format\n"
83 " '-c' indicates that target image must be compressed (qcow format only)\n"
84 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
85 " match exactly. The image doesn't need a working backing file before\n"
86 " rebasing in this case (useful for renaming the backing file)\n"
87 " '-h' with or without a command shows this help and lists the supported formats\n"
88 "\n"
89 "Parameters to snapshot subcommand:\n"
90 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
91 " '-a' applies a snapshot (revert disk to saved state)\n"
92 " '-c' creates a snapshot\n"
93 " '-d' deletes a snapshot\n"
94 " '-l' lists all snapshots in the given image\n";
96 printf("%s\nSupported formats:", help_msg);
97 bdrv_iterate_format(format_print, NULL);
98 printf("\n");
99 exit(1);
102 #if defined(WIN32)
103 /* XXX: put correct support for win32 */
104 static int read_password(char *buf, int buf_size)
106 int c, i;
107 printf("Password: ");
108 fflush(stdout);
109 i = 0;
110 for(;;) {
111 c = getchar();
112 if (c == '\n')
113 break;
114 if (i < (buf_size - 1))
115 buf[i++] = c;
117 buf[i] = '\0';
118 return 0;
121 #else
123 #include <termios.h>
125 static struct termios oldtty;
127 static void term_exit(void)
129 tcsetattr (0, TCSANOW, &oldtty);
132 static void term_init(void)
134 struct termios tty;
136 tcgetattr (0, &tty);
137 oldtty = tty;
139 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
140 |INLCR|IGNCR|ICRNL|IXON);
141 tty.c_oflag |= OPOST;
142 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
143 tty.c_cflag &= ~(CSIZE|PARENB);
144 tty.c_cflag |= CS8;
145 tty.c_cc[VMIN] = 1;
146 tty.c_cc[VTIME] = 0;
148 tcsetattr (0, TCSANOW, &tty);
150 atexit(term_exit);
153 static int read_password(char *buf, int buf_size)
155 uint8_t ch;
156 int i, ret;
158 printf("password: ");
159 fflush(stdout);
160 term_init();
161 i = 0;
162 for(;;) {
163 ret = read(0, &ch, 1);
164 if (ret == -1) {
165 if (errno == EAGAIN || errno == EINTR) {
166 continue;
167 } else {
168 ret = -1;
169 break;
171 } else if (ret == 0) {
172 ret = -1;
173 break;
174 } else {
175 if (ch == '\r') {
176 ret = 0;
177 break;
179 if (i < (buf_size - 1))
180 buf[i++] = ch;
183 term_exit();
184 buf[i] = '\0';
185 printf("\n");
186 return ret;
188 #endif
190 static BlockDriverState *bdrv_new_open(const char *filename,
191 const char *fmt,
192 int flags)
194 BlockDriverState *bs;
195 BlockDriver *drv;
196 char password[256];
198 bs = bdrv_new("");
199 if (!bs) {
200 error("Not enough memory");
201 goto fail;
203 if (fmt) {
204 drv = bdrv_find_format(fmt);
205 if (!drv) {
206 error("Unknown file format '%s'", fmt);
207 goto fail;
209 } else {
210 drv = NULL;
212 if (bdrv_open(bs, filename, flags, drv) < 0) {
213 error("Could not open '%s'", filename);
214 goto fail;
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 goto fail;
222 if (bdrv_set_key(bs, password) < 0) {
223 error("invalid password");
224 goto fail;
227 return bs;
228 fail:
229 if (bs) {
230 bdrv_delete(bs);
232 return NULL;
235 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
236 int flags, const char *base_filename, const char *base_fmt)
238 if (flags & BLOCK_FLAG_ENCRYPT) {
239 if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
240 error("Encryption not supported for file format '%s'", fmt);
241 return -1;
244 if (flags & BLOCK_FLAG_COMPAT6) {
245 if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
246 error("VMDK version 6 not supported for file format '%s'", fmt);
247 return -1;
251 if (base_filename) {
252 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
253 error("Backing file not supported for file format '%s'", fmt);
254 return -1;
257 if (base_fmt) {
258 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
259 error("Backing file format not supported for file format '%s'", fmt);
260 return -1;
263 return 0;
266 static int img_create(int argc, char **argv)
268 int c, ret = 0, flags;
269 const char *fmt = "raw";
270 const char *base_fmt = NULL;
271 const char *filename;
272 const char *base_filename = NULL;
273 BlockDriver *drv, *proto_drv;
274 QEMUOptionParameter *param = NULL, *create_options = NULL;
275 char *options = NULL;
277 flags = 0;
278 for(;;) {
279 c = getopt(argc, argv, "F:b:f:he6o:");
280 if (c == -1)
281 break;
282 switch(c) {
283 case 'h':
284 help();
285 break;
286 case 'F':
287 base_fmt = optarg;
288 break;
289 case 'b':
290 base_filename = optarg;
291 break;
292 case 'f':
293 fmt = optarg;
294 break;
295 case 'e':
296 flags |= BLOCK_FLAG_ENCRYPT;
297 break;
298 case '6':
299 flags |= BLOCK_FLAG_COMPAT6;
300 break;
301 case 'o':
302 options = optarg;
303 break;
307 /* Get the filename */
308 if (optind >= argc)
309 help();
310 filename = argv[optind++];
312 /* Find driver and parse its options */
313 drv = bdrv_find_format(fmt);
314 if (!drv) {
315 error("Unknown file format '%s'", fmt);
316 return 1;
319 proto_drv = bdrv_find_protocol(filename);
320 if (!proto_drv) {
321 error("Unknown protocol '%s'", filename);
322 return 1;
325 create_options = append_option_parameters(create_options,
326 drv->create_options);
327 create_options = append_option_parameters(create_options,
328 proto_drv->create_options);
330 if (options && !strcmp(options, "?")) {
331 print_option_help(create_options);
332 goto out;
335 /* Create parameter list with default values */
336 param = parse_option_parameters("", create_options, param);
337 set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
339 /* Parse -o options */
340 if (options) {
341 param = parse_option_parameters(options, create_options, param);
342 if (param == NULL) {
343 error("Invalid options for file format '%s'.", fmt);
344 ret = -1;
345 goto out;
349 /* Add size to parameters */
350 if (optind < argc) {
351 set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
354 /* Add old-style options to parameters */
355 ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
356 if (ret < 0) {
357 goto out;
360 // The size for the image must always be specified, with one exception:
361 // If we are using a backing file, we can obtain the size from there
362 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
364 QEMUOptionParameter *backing_file =
365 get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
366 QEMUOptionParameter *backing_fmt =
367 get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
369 if (backing_file && backing_file->value.s) {
370 BlockDriverState *bs;
371 uint64_t size;
372 const char *fmt = NULL;
373 char buf[32];
375 if (backing_fmt && backing_fmt->value.s) {
376 if (bdrv_find_format(backing_fmt->value.s)) {
377 fmt = backing_fmt->value.s;
378 } else {
379 error("Unknown backing file format '%s'",
380 backing_fmt->value.s);
381 ret = -1;
382 goto out;
386 bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
387 if (!bs) {
388 ret = -1;
389 goto out;
391 bdrv_get_geometry(bs, &size);
392 size *= 512;
393 bdrv_delete(bs);
395 snprintf(buf, sizeof(buf), "%" PRId64, size);
396 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
397 } else {
398 error("Image creation needs a size parameter");
399 ret = -1;
400 goto out;
404 printf("Formatting '%s', fmt=%s ", filename, fmt);
405 print_option_parameters(param);
406 puts("");
408 ret = bdrv_create(drv, filename, param);
409 free_option_parameters(create_options);
410 free_option_parameters(param);
412 if (ret < 0) {
413 if (ret == -ENOTSUP) {
414 error("Formatting or formatting option not supported for file format '%s'", fmt);
415 } else if (ret == -EFBIG) {
416 error("The image size is too large for file format '%s'", fmt);
417 } else {
418 error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
421 out:
422 if (ret) {
423 return 1;
425 return 0;
429 * Checks an image for consistency. Exit codes:
431 * 0 - Check completed, image is good
432 * 1 - Check not completed because of internal errors
433 * 2 - Check completed, image is corrupted
434 * 3 - Check completed, image has leaked clusters, but is good otherwise
436 static int img_check(int argc, char **argv)
438 int c, ret;
439 const char *filename, *fmt;
440 BlockDriverState *bs;
441 BdrvCheckResult result;
443 fmt = NULL;
444 for(;;) {
445 c = getopt(argc, argv, "f:h");
446 if (c == -1)
447 break;
448 switch(c) {
449 case 'h':
450 help();
451 break;
452 case 'f':
453 fmt = optarg;
454 break;
457 if (optind >= argc)
458 help();
459 filename = argv[optind++];
461 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
462 if (!bs) {
463 return 1;
465 ret = bdrv_check(bs, &result);
467 if (ret == -ENOTSUP) {
468 error("This image format does not support checks");
469 bdrv_delete(bs);
470 return 1;
473 if (!(result.corruptions || result.leaks || result.check_errors)) {
474 printf("No errors were found on the image.\n");
475 } else {
476 if (result.corruptions) {
477 printf("\n%d errors were found on the image.\n"
478 "Data may be corrupted, or further writes to the image "
479 "may corrupt it.\n",
480 result.corruptions);
483 if (result.leaks) {
484 printf("\n%d leaked clusters were found on the image.\n"
485 "This means waste of disk space, but no harm to data.\n",
486 result.leaks);
489 if (result.check_errors) {
490 printf("\n%d internal errors have occurred during the check.\n",
491 result.check_errors);
495 bdrv_delete(bs);
497 if (ret < 0 || result.check_errors) {
498 printf("\nAn error has occurred during the check: %s\n"
499 "The check is not complete and may have missed error.\n",
500 strerror(-ret));
501 return 1;
504 if (result.corruptions) {
505 return 2;
506 } else if (result.leaks) {
507 return 3;
508 } else {
509 return 0;
513 static int img_commit(int argc, char **argv)
515 int c, ret;
516 const char *filename, *fmt;
517 BlockDriverState *bs;
519 fmt = NULL;
520 for(;;) {
521 c = getopt(argc, argv, "f:h");
522 if (c == -1)
523 break;
524 switch(c) {
525 case 'h':
526 help();
527 break;
528 case 'f':
529 fmt = optarg;
530 break;
533 if (optind >= argc)
534 help();
535 filename = argv[optind++];
537 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
538 if (!bs) {
539 return 1;
541 ret = bdrv_commit(bs);
542 switch(ret) {
543 case 0:
544 printf("Image committed.\n");
545 break;
546 case -ENOENT:
547 error("No disk inserted");
548 break;
549 case -EACCES:
550 error("Image is read-only");
551 break;
552 case -ENOTSUP:
553 error("Image is already committed");
554 break;
555 default:
556 error("Error while committing image");
557 break;
560 bdrv_delete(bs);
561 if (ret) {
562 return 1;
564 return 0;
567 static int is_not_zero(const uint8_t *sector, int len)
569 int i;
570 len >>= 2;
571 for(i = 0;i < len; i++) {
572 if (((uint32_t *)sector)[i] != 0)
573 return 1;
575 return 0;
579 * Returns true iff the first sector pointed to by 'buf' contains at least
580 * a non-NUL byte.
582 * 'pnum' is set to the number of sectors (including and immediately following
583 * the first one) that are known to be in the same allocated/unallocated state.
585 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
587 int v, i;
589 if (n <= 0) {
590 *pnum = 0;
591 return 0;
593 v = is_not_zero(buf, 512);
594 for(i = 1; i < n; i++) {
595 buf += 512;
596 if (v != is_not_zero(buf, 512))
597 break;
599 *pnum = i;
600 return v;
604 * Compares two buffers sector by sector. Returns 0 if the first sector of both
605 * buffers matches, non-zero otherwise.
607 * pnum is set to the number of sectors (including and immediately following
608 * the first one) that are known to have the same comparison result
610 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
611 int *pnum)
613 int res, i;
615 if (n <= 0) {
616 *pnum = 0;
617 return 0;
620 res = !!memcmp(buf1, buf2, 512);
621 for(i = 1; i < n; i++) {
622 buf1 += 512;
623 buf2 += 512;
625 if (!!memcmp(buf1, buf2, 512) != res) {
626 break;
630 *pnum = i;
631 return res;
634 #define IO_BUF_SIZE (2 * 1024 * 1024)
636 static int img_convert(int argc, char **argv)
638 int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
639 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
640 BlockDriver *drv, *proto_drv;
641 BlockDriverState **bs = NULL, *out_bs = NULL;
642 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
643 uint64_t bs_sectors;
644 uint8_t * buf = NULL;
645 const uint8_t *buf1;
646 BlockDriverInfo bdi;
647 QEMUOptionParameter *param = NULL, *create_options = NULL;
648 char *options = NULL;
650 fmt = NULL;
651 out_fmt = "raw";
652 out_baseimg = NULL;
653 flags = 0;
654 for(;;) {
655 c = getopt(argc, argv, "f:O:B:hce6o:");
656 if (c == -1)
657 break;
658 switch(c) {
659 case 'h':
660 help();
661 break;
662 case 'f':
663 fmt = optarg;
664 break;
665 case 'O':
666 out_fmt = optarg;
667 break;
668 case 'B':
669 out_baseimg = optarg;
670 break;
671 case 'c':
672 flags |= BLOCK_FLAG_COMPRESS;
673 break;
674 case 'e':
675 flags |= BLOCK_FLAG_ENCRYPT;
676 break;
677 case '6':
678 flags |= BLOCK_FLAG_COMPAT6;
679 break;
680 case 'o':
681 options = optarg;
682 break;
686 bs_n = argc - optind - 1;
687 if (bs_n < 1) help();
689 out_filename = argv[argc - 1];
691 if (bs_n > 1 && out_baseimg) {
692 error("-B makes no sense when concatenating multiple input images");
693 return 1;
696 bs = calloc(bs_n, sizeof(BlockDriverState *));
697 if (!bs) {
698 error("Out of memory");
699 return 1;
702 total_sectors = 0;
703 for (bs_i = 0; bs_i < bs_n; bs_i++) {
704 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
705 if (!bs[bs_i]) {
706 error("Could not open '%s'", argv[optind + bs_i]);
707 ret = -1;
708 goto out;
710 bdrv_get_geometry(bs[bs_i], &bs_sectors);
711 total_sectors += bs_sectors;
714 /* Find driver and parse its options */
715 drv = bdrv_find_format(out_fmt);
716 if (!drv) {
717 error("Unknown file format '%s'", out_fmt);
718 ret = -1;
719 goto out;
722 proto_drv = bdrv_find_protocol(out_filename);
723 if (!proto_drv) {
724 error("Unknown protocol '%s'", out_filename);
725 ret = -1;
726 goto out;
729 create_options = append_option_parameters(create_options,
730 drv->create_options);
731 create_options = append_option_parameters(create_options,
732 proto_drv->create_options);
733 if (options && !strcmp(options, "?")) {
734 print_option_help(create_options);
735 goto out;
738 if (options) {
739 param = parse_option_parameters(options, create_options, param);
740 if (param == NULL) {
741 error("Invalid options for file format '%s'.", out_fmt);
742 ret = -1;
743 goto out;
745 } else {
746 param = parse_option_parameters("", create_options, param);
749 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
750 ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
751 if (ret < 0) {
752 goto out;
755 /* Check if compression is supported */
756 if (flags & BLOCK_FLAG_COMPRESS) {
757 QEMUOptionParameter *encryption =
758 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
760 if (!drv->bdrv_write_compressed) {
761 error("Compression not supported for this file format");
762 ret = -1;
763 goto out;
766 if (encryption && encryption->value.n) {
767 error("Compression and encryption not supported at the same time");
768 ret = -1;
769 goto out;
773 /* Create the new image */
774 ret = bdrv_create(drv, out_filename, param);
775 if (ret < 0) {
776 if (ret == -ENOTSUP) {
777 error("Formatting not supported for file format '%s'", out_fmt);
778 } else if (ret == -EFBIG) {
779 error("The image size is too large for file format '%s'", out_fmt);
780 } else {
781 error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
783 goto out;
786 out_bs = bdrv_new_open(out_filename, out_fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
787 if (!out_bs) {
788 ret = -1;
789 goto out;
792 bs_i = 0;
793 bs_offset = 0;
794 bdrv_get_geometry(bs[0], &bs_sectors);
795 buf = qemu_malloc(IO_BUF_SIZE);
797 if (flags & BLOCK_FLAG_COMPRESS) {
798 ret = bdrv_get_info(out_bs, &bdi);
799 if (ret < 0) {
800 error("could not get block driver info");
801 goto out;
803 cluster_size = bdi.cluster_size;
804 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
805 error("invalid cluster size");
806 ret = -1;
807 goto out;
809 cluster_sectors = cluster_size >> 9;
810 sector_num = 0;
811 for(;;) {
812 int64_t bs_num;
813 int remainder;
814 uint8_t *buf2;
816 nb_sectors = total_sectors - sector_num;
817 if (nb_sectors <= 0)
818 break;
819 if (nb_sectors >= cluster_sectors)
820 n = cluster_sectors;
821 else
822 n = nb_sectors;
824 bs_num = sector_num - bs_offset;
825 assert (bs_num >= 0);
826 remainder = n;
827 buf2 = buf;
828 while (remainder > 0) {
829 int nlow;
830 while (bs_num == bs_sectors) {
831 bs_i++;
832 assert (bs_i < bs_n);
833 bs_offset += bs_sectors;
834 bdrv_get_geometry(bs[bs_i], &bs_sectors);
835 bs_num = 0;
836 /* printf("changing part: sector_num=%" PRId64 ", "
837 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
838 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
840 assert (bs_num < bs_sectors);
842 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
844 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
845 if (ret < 0) {
846 error("error while reading");
847 goto out;
850 buf2 += nlow * 512;
851 bs_num += nlow;
853 remainder -= nlow;
855 assert (remainder == 0);
857 if (n < cluster_sectors)
858 memset(buf + n * 512, 0, cluster_size - n * 512);
859 if (is_not_zero(buf, cluster_size)) {
860 ret = bdrv_write_compressed(out_bs, sector_num, buf,
861 cluster_sectors);
862 if (ret != 0) {
863 error("error while compressing sector %" PRId64,
864 sector_num);
865 goto out;
868 sector_num += n;
870 /* signal EOF to align */
871 bdrv_write_compressed(out_bs, 0, NULL, 0);
872 } else {
873 int has_zero_init = bdrv_has_zero_init(out_bs);
875 sector_num = 0; // total number of sectors converted so far
876 for(;;) {
877 nb_sectors = total_sectors - sector_num;
878 if (nb_sectors <= 0)
879 break;
880 if (nb_sectors >= (IO_BUF_SIZE / 512))
881 n = (IO_BUF_SIZE / 512);
882 else
883 n = nb_sectors;
885 while (sector_num - bs_offset >= bs_sectors) {
886 bs_i ++;
887 assert (bs_i < bs_n);
888 bs_offset += bs_sectors;
889 bdrv_get_geometry(bs[bs_i], &bs_sectors);
890 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
891 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
892 sector_num, bs_i, bs_offset, bs_sectors); */
895 if (n > bs_offset + bs_sectors - sector_num)
896 n = bs_offset + bs_sectors - sector_num;
898 if (has_zero_init) {
899 /* If the output image is being created as a copy on write image,
900 assume that sectors which are unallocated in the input image
901 are present in both the output's and input's base images (no
902 need to copy them). */
903 if (out_baseimg) {
904 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
905 n, &n1)) {
906 sector_num += n1;
907 continue;
909 /* The next 'n1' sectors are allocated in the input image. Copy
910 only those as they may be followed by unallocated sectors. */
911 n = n1;
913 } else {
914 n1 = n;
917 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
918 if (ret < 0) {
919 error("error while reading");
920 goto out;
922 /* NOTE: at the same time we convert, we do not write zero
923 sectors to have a chance to compress the image. Ideally, we
924 should add a specific call to have the info to go faster */
925 buf1 = buf;
926 while (n > 0) {
927 /* If the output image is being created as a copy on write image,
928 copy all sectors even the ones containing only NUL bytes,
929 because they may differ from the sectors in the base image.
931 If the output is to a host device, we also write out
932 sectors that are entirely 0, since whatever data was
933 already there is garbage, not 0s. */
934 if (!has_zero_init || out_baseimg ||
935 is_allocated_sectors(buf1, n, &n1)) {
936 ret = bdrv_write(out_bs, sector_num, buf1, n1);
937 if (ret < 0) {
938 error("error while writing");
939 goto out;
942 sector_num += n1;
943 n -= n1;
944 buf1 += n1 * 512;
948 out:
949 free_option_parameters(create_options);
950 free_option_parameters(param);
951 qemu_free(buf);
952 if (out_bs) {
953 bdrv_delete(out_bs);
955 for (bs_i = 0; bs_i < bs_n; bs_i++) {
956 if (bs[bs_i]) {
957 bdrv_delete(bs[bs_i]);
960 free(bs);
961 if (ret) {
962 return 1;
964 return 0;
967 #ifdef _WIN32
968 static int64_t get_allocated_file_size(const char *filename)
970 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
971 get_compressed_t get_compressed;
972 struct _stati64 st;
974 /* WinNT support GetCompressedFileSize to determine allocate size */
975 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
976 if (get_compressed) {
977 DWORD high, low;
978 low = get_compressed(filename, &high);
979 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
980 return (((int64_t) high) << 32) + low;
983 if (_stati64(filename, &st) < 0)
984 return -1;
985 return st.st_size;
987 #else
988 static int64_t get_allocated_file_size(const char *filename)
990 struct stat st;
991 if (stat(filename, &st) < 0)
992 return -1;
993 return (int64_t)st.st_blocks * 512;
995 #endif
997 static void dump_snapshots(BlockDriverState *bs)
999 QEMUSnapshotInfo *sn_tab, *sn;
1000 int nb_sns, i;
1001 char buf[256];
1003 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1004 if (nb_sns <= 0)
1005 return;
1006 printf("Snapshot list:\n");
1007 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1008 for(i = 0; i < nb_sns; i++) {
1009 sn = &sn_tab[i];
1010 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1012 qemu_free(sn_tab);
1015 static int img_info(int argc, char **argv)
1017 int c;
1018 const char *filename, *fmt;
1019 BlockDriverState *bs;
1020 char fmt_name[128], size_buf[128], dsize_buf[128];
1021 uint64_t total_sectors;
1022 int64_t allocated_size;
1023 char backing_filename[1024];
1024 char backing_filename2[1024];
1025 BlockDriverInfo bdi;
1027 fmt = NULL;
1028 for(;;) {
1029 c = getopt(argc, argv, "f:h");
1030 if (c == -1)
1031 break;
1032 switch(c) {
1033 case 'h':
1034 help();
1035 break;
1036 case 'f':
1037 fmt = optarg;
1038 break;
1041 if (optind >= argc)
1042 help();
1043 filename = argv[optind++];
1045 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1046 if (!bs) {
1047 return 1;
1049 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1050 bdrv_get_geometry(bs, &total_sectors);
1051 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1052 allocated_size = get_allocated_file_size(filename);
1053 if (allocated_size < 0)
1054 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1055 else
1056 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1057 allocated_size);
1058 printf("image: %s\n"
1059 "file format: %s\n"
1060 "virtual size: %s (%" PRId64 " bytes)\n"
1061 "disk size: %s\n",
1062 filename, fmt_name, size_buf,
1063 (total_sectors * 512),
1064 dsize_buf);
1065 if (bdrv_is_encrypted(bs))
1066 printf("encrypted: yes\n");
1067 if (bdrv_get_info(bs, &bdi) >= 0) {
1068 if (bdi.cluster_size != 0)
1069 printf("cluster_size: %d\n", bdi.cluster_size);
1071 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1072 if (backing_filename[0] != '\0') {
1073 path_combine(backing_filename2, sizeof(backing_filename2),
1074 filename, backing_filename);
1075 printf("backing file: %s (actual path: %s)\n",
1076 backing_filename,
1077 backing_filename2);
1079 dump_snapshots(bs);
1080 bdrv_delete(bs);
1081 return 0;
1084 #define SNAPSHOT_LIST 1
1085 #define SNAPSHOT_CREATE 2
1086 #define SNAPSHOT_APPLY 3
1087 #define SNAPSHOT_DELETE 4
1089 static int img_snapshot(int argc, char **argv)
1091 BlockDriverState *bs;
1092 QEMUSnapshotInfo sn;
1093 char *filename, *snapshot_name = NULL;
1094 int c, ret = 0, bdrv_oflags;
1095 int action = 0;
1096 qemu_timeval tv;
1098 bdrv_oflags = BDRV_O_RDWR;
1099 /* Parse commandline parameters */
1100 for(;;) {
1101 c = getopt(argc, argv, "la:c:d:h");
1102 if (c == -1)
1103 break;
1104 switch(c) {
1105 case 'h':
1106 help();
1107 return 0;
1108 case 'l':
1109 if (action) {
1110 help();
1111 return 0;
1113 action = SNAPSHOT_LIST;
1114 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1115 break;
1116 case 'a':
1117 if (action) {
1118 help();
1119 return 0;
1121 action = SNAPSHOT_APPLY;
1122 snapshot_name = optarg;
1123 break;
1124 case 'c':
1125 if (action) {
1126 help();
1127 return 0;
1129 action = SNAPSHOT_CREATE;
1130 snapshot_name = optarg;
1131 break;
1132 case 'd':
1133 if (action) {
1134 help();
1135 return 0;
1137 action = SNAPSHOT_DELETE;
1138 snapshot_name = optarg;
1139 break;
1143 if (optind >= argc)
1144 help();
1145 filename = argv[optind++];
1147 /* Open the image */
1148 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1149 if (!bs) {
1150 return 1;
1153 /* Perform the requested action */
1154 switch(action) {
1155 case SNAPSHOT_LIST:
1156 dump_snapshots(bs);
1157 break;
1159 case SNAPSHOT_CREATE:
1160 memset(&sn, 0, sizeof(sn));
1161 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1163 qemu_gettimeofday(&tv);
1164 sn.date_sec = tv.tv_sec;
1165 sn.date_nsec = tv.tv_usec * 1000;
1167 ret = bdrv_snapshot_create(bs, &sn);
1168 if (ret)
1169 error("Could not create snapshot '%s': %d (%s)",
1170 snapshot_name, ret, strerror(-ret));
1171 break;
1173 case SNAPSHOT_APPLY:
1174 ret = bdrv_snapshot_goto(bs, snapshot_name);
1175 if (ret)
1176 error("Could not apply snapshot '%s': %d (%s)",
1177 snapshot_name, ret, strerror(-ret));
1178 break;
1180 case SNAPSHOT_DELETE:
1181 ret = bdrv_snapshot_delete(bs, snapshot_name);
1182 if (ret)
1183 error("Could not delete snapshot '%s': %d (%s)",
1184 snapshot_name, ret, strerror(-ret));
1185 break;
1188 /* Cleanup */
1189 bdrv_delete(bs);
1190 if (ret) {
1191 return 1;
1193 return 0;
1196 static int img_rebase(int argc, char **argv)
1198 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1199 BlockDriver *old_backing_drv, *new_backing_drv;
1200 char *filename;
1201 const char *fmt, *out_basefmt, *out_baseimg;
1202 int c, flags, ret;
1203 int unsafe = 0;
1205 /* Parse commandline parameters */
1206 fmt = NULL;
1207 out_baseimg = NULL;
1208 out_basefmt = NULL;
1210 for(;;) {
1211 c = getopt(argc, argv, "uhf:F:b:");
1212 if (c == -1)
1213 break;
1214 switch(c) {
1215 case 'h':
1216 help();
1217 return 0;
1218 case 'f':
1219 fmt = optarg;
1220 break;
1221 case 'F':
1222 out_basefmt = optarg;
1223 break;
1224 case 'b':
1225 out_baseimg = optarg;
1226 break;
1227 case 'u':
1228 unsafe = 1;
1229 break;
1233 if ((optind >= argc) || !out_baseimg)
1234 help();
1235 filename = argv[optind++];
1238 * Open the images.
1240 * Ignore the old backing file for unsafe rebase in case we want to correct
1241 * the reference to a renamed or moved backing file.
1243 flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1244 bs = bdrv_new_open(filename, fmt, flags);
1245 if (!bs) {
1246 return 1;
1249 /* Find the right drivers for the backing files */
1250 old_backing_drv = NULL;
1251 new_backing_drv = NULL;
1253 if (!unsafe && bs->backing_format[0] != '\0') {
1254 old_backing_drv = bdrv_find_format(bs->backing_format);
1255 if (old_backing_drv == NULL) {
1256 error("Invalid format name: '%s'", bs->backing_format);
1257 ret = -1;
1258 goto out;
1262 if (out_basefmt != NULL) {
1263 new_backing_drv = bdrv_find_format(out_basefmt);
1264 if (new_backing_drv == NULL) {
1265 error("Invalid format name: '%s'", out_basefmt);
1266 ret = -1;
1267 goto out;
1271 /* For safe rebasing we need to compare old and new backing file */
1272 if (unsafe) {
1273 /* Make the compiler happy */
1274 bs_old_backing = NULL;
1275 bs_new_backing = NULL;
1276 } else {
1277 char backing_name[1024];
1279 bs_old_backing = bdrv_new("old_backing");
1280 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1281 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1282 old_backing_drv);
1283 if (ret) {
1284 error("Could not open old backing file '%s'", backing_name);
1285 goto out;
1288 bs_new_backing = bdrv_new("new_backing");
1289 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS | BDRV_O_RDWR,
1290 new_backing_drv);
1291 if (ret) {
1292 error("Could not open new backing file '%s'", out_baseimg);
1293 goto out;
1298 * Check each unallocated cluster in the COW file. If it is unallocated,
1299 * accesses go to the backing file. We must therefore compare this cluster
1300 * in the old and new backing file, and if they differ we need to copy it
1301 * from the old backing file into the COW file.
1303 * If qemu-img crashes during this step, no harm is done. The content of
1304 * the image is the same as the original one at any time.
1306 if (!unsafe) {
1307 uint64_t num_sectors;
1308 uint64_t sector;
1309 int n;
1310 uint8_t * buf_old;
1311 uint8_t * buf_new;
1313 buf_old = qemu_malloc(IO_BUF_SIZE);
1314 buf_new = qemu_malloc(IO_BUF_SIZE);
1316 bdrv_get_geometry(bs, &num_sectors);
1318 for (sector = 0; sector < num_sectors; sector += n) {
1320 /* How many sectors can we handle with the next read? */
1321 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1322 n = (IO_BUF_SIZE / 512);
1323 } else {
1324 n = num_sectors - sector;
1327 /* If the cluster is allocated, we don't need to take action */
1328 ret = bdrv_is_allocated(bs, sector, n, &n);
1329 if (ret) {
1330 continue;
1333 /* Read old and new backing file */
1334 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1335 if (ret < 0) {
1336 error("error while reading from old backing file");
1337 goto out;
1339 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1340 if (ret < 0) {
1341 error("error while reading from new backing file");
1342 goto out;
1345 /* If they differ, we need to write to the COW file */
1346 uint64_t written = 0;
1348 while (written < n) {
1349 int pnum;
1351 if (compare_sectors(buf_old + written * 512,
1352 buf_new + written * 512, n - written, &pnum))
1354 ret = bdrv_write(bs, sector + written,
1355 buf_old + written * 512, pnum);
1356 if (ret < 0) {
1357 error("Error while writing to COW image: %s",
1358 strerror(-ret));
1359 goto out;
1363 written += pnum;
1367 qemu_free(buf_old);
1368 qemu_free(buf_new);
1372 * Change the backing file. All clusters that are different from the old
1373 * backing file are overwritten in the COW file now, so the visible content
1374 * doesn't change when we switch the backing file.
1376 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1377 if (ret == -ENOSPC) {
1378 error("Could not change the backing file to '%s': No space left in "
1379 "the file header", out_baseimg);
1380 } else if (ret < 0) {
1381 error("Could not change the backing file to '%s': %s",
1382 out_baseimg, strerror(-ret));
1386 * TODO At this point it is possible to check if any clusters that are
1387 * allocated in the COW file are the same in the backing file. If so, they
1388 * could be dropped from the COW file. Don't do this before switching the
1389 * backing file, in case of a crash this would lead to corruption.
1391 out:
1392 /* Cleanup */
1393 if (!unsafe) {
1394 bdrv_delete(bs_old_backing);
1395 bdrv_delete(bs_new_backing);
1398 bdrv_delete(bs);
1399 if (ret) {
1400 return 1;
1402 return 0;
1405 static int img_resize(int argc, char **argv)
1407 int c, ret, relative;
1408 const char *filename, *fmt, *size;
1409 int64_t n, total_size;
1410 BlockDriverState *bs;
1411 QEMUOptionParameter *param;
1412 QEMUOptionParameter resize_options[] = {
1414 .name = BLOCK_OPT_SIZE,
1415 .type = OPT_SIZE,
1416 .help = "Virtual disk size"
1418 { NULL }
1421 fmt = NULL;
1422 for(;;) {
1423 c = getopt(argc, argv, "f:h");
1424 if (c == -1) {
1425 break;
1427 switch(c) {
1428 case 'h':
1429 help();
1430 break;
1431 case 'f':
1432 fmt = optarg;
1433 break;
1436 if (optind + 1 >= argc) {
1437 help();
1439 filename = argv[optind++];
1440 size = argv[optind++];
1442 /* Choose grow, shrink, or absolute resize mode */
1443 switch (size[0]) {
1444 case '+':
1445 relative = 1;
1446 size++;
1447 break;
1448 case '-':
1449 relative = -1;
1450 size++;
1451 break;
1452 default:
1453 relative = 0;
1454 break;
1457 /* Parse size */
1458 param = parse_option_parameters("", resize_options, NULL);
1459 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1460 /* Error message already printed when size parsing fails */
1461 exit(1);
1463 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1464 free_option_parameters(param);
1466 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1467 if (!bs) {
1468 return 1;
1471 if (relative) {
1472 total_size = bdrv_getlength(bs) + n * relative;
1473 } else {
1474 total_size = n;
1476 if (total_size <= 0) {
1477 error("New image size must be positive");
1478 ret = -1;
1479 goto out;
1482 ret = bdrv_truncate(bs, total_size);
1483 switch (ret) {
1484 case 0:
1485 printf("Image resized.\n");
1486 break;
1487 case -ENOTSUP:
1488 error("This image format does not support resize");
1489 break;
1490 case -EACCES:
1491 error("Image is read-only");
1492 break;
1493 default:
1494 error("Error resizing image (%d)", -ret);
1495 break;
1497 out:
1498 bdrv_delete(bs);
1499 if (ret) {
1500 return 1;
1502 return 0;
1505 static const img_cmd_t img_cmds[] = {
1506 #define DEF(option, callback, arg_string) \
1507 { option, callback },
1508 #include "qemu-img-cmds.h"
1509 #undef DEF
1510 #undef GEN_DOCS
1511 { NULL, NULL, },
1514 int main(int argc, char **argv)
1516 const img_cmd_t *cmd;
1517 const char *cmdname;
1519 bdrv_init();
1520 if (argc < 2)
1521 help();
1522 cmdname = argv[1];
1523 argc--; argv++;
1525 /* find the command */
1526 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1527 if (!strcmp(cmdname, cmd->name)) {
1528 return cmd->handler(argc, argv);
1532 /* not found */
1533 help();
1534 return 0;